berryWorkbenchAdvisor.h

Go to the documentation of this file.

/*===================================================================

BlueBerry Platform

Copyright (c) German Cancer Research Center,
Division of Medical and Biological Informatics.
All rights reserved.

This software is distributed WITHOUT ANY WARRANTY; without
even the implied warranty of MERCHANTABILITY or FITNESS FOR
A PARTICULAR PURPOSE.

See LICENSE.txt or http://www.mitk.org for details.

===================================================================*/

#ifndef BERRYWORKBENCHADVISOR_H_
#define BERRYWORKBENCHADVISOR_H_

#include <org_blueberry_ui_qt_Export.h>

#include "berryIMemento.h"
#include <berryIAdaptable.h>

#include "berryWorkbenchWindowAdvisor.h"
#include "berryIWorkbenchConfigurer.h"

namespace berry {

class BERRY_UI_QT WorkbenchAdvisor {

  private: IWorkbenchConfigurer::Pointer workbenchConfigurer;

  /*
   * The workbench error handler.
   */
  //private: AbstractStatusHandler workbenchErrorHandler;

  //private: bool introOpened;

  protected: WorkbenchAdvisor();
             virtual ~WorkbenchAdvisor();

  public: void InternalBasicInitialize(IWorkbenchConfigurer::Pointer configurer);

  public: virtual void Initialize(IWorkbenchConfigurer::Pointer configurer);

  protected: IWorkbenchConfigurer::Pointer GetWorkbenchConfigurer();

  /*
   * Returns the workbench error handler for the advisor.
   *
   * @return the workbench error handler
   * @since 3.3
   */
//  public: AbstractStatusHandler getWorkbenchErrorHandler() {
//    if (workbenchErrorHandler == null) {
//      workbenchErrorHandler = new WorkbenchErrorHandler();
//    }
//    return workbenchErrorHandler;
//  }

  public: virtual void PreStartup();

  public: virtual void PostStartup();

  public: virtual bool PreShutdown();

  public: virtual void PostShutdown();

  /*
   * Performs arbitrary actions when the event loop crashes (the code that
   * handles a UI event throws an exception that is not caught).
   * <p>
   * This method is called when the code handling a UI event throws an
   * exception. In a perfectly functioning application, this method would
   * never be called. In practice, it comes into play when there are bugs in
   * the code that trigger unchecked runtime exceptions. It is also activated
   * when the system runs short of memory, etc. Fatal errors (ThreadDeath) are
   * not passed on to this method, as there is nothing that could be done.
   * </p>
   * <p>
   * Clients must not call this method directly (although super calls are
   * okay). The default implementation logs the problem so that it does not go
   * unnoticed. Subclasses may override or extend this method. It is generally
   * a bad idea to override with an empty method, and you should be especially
   * careful when handling Errors.
   * </p>
   *
   * @param exception
   *            the uncaught exception that was thrown inside the UI event
   *            loop
   */
//  public: void eventLoopException(Throwable exception) {
//    // Protection from client doing super(null) call
//    if (exception == null) {
//      return;
//    }
//
//    try {
//      StatusManager.getManager().handle(
//          new Status(IStatus.ERR, WorkbenchPlugin.PI_WORKBENCH,
//              "Unhandled event loop exception", exception)); //$NON-NLS-1$
//
//      if (WorkbenchPlugin.DEBUG) {
//        exception.printStackTrace();
//      }
//    } catch (Throwable e) {
//      // One of the log listeners probably failed. Core should have logged
//      // the
//      // exception since its the first listener.
//      System.err.println("Error while logging event loop exception:"); //$NON-NLS-1$
//      exception.printStackTrace();
//      System.err.println("Logging exception:"); //$NON-NLS-1$
//      e.printStackTrace();
//    }
//  }

  /*
   * Performs arbitrary work or yields when there are no events to be
   * processed.
   * <p>
   * This method is called when there are currently no more events on the
   * queue to be processed at the moment.
   * </p>
   * <p>
   * Clients must not call this method directly (although super calls are
   * okay). The default implementation yields until new events enter the
   * queue. Subclasses may override or extend this method. It is generally a
   * bad idea to override with an empty method. It is okay to call
   * <code>IWorkbench.close()</code> from this method.
   * </p>
   *
   * @param display
   *            the main display of the workbench UI
   */
//  public: void eventLoopIdle(Display display) {
//    // default: yield cpu until new events enter the queue
//    display.sleep();
//  }

  public: virtual WorkbenchWindowAdvisor* CreateWorkbenchWindowAdvisor(
      IWorkbenchWindowConfigurer::Pointer configurer) = 0;


  public: virtual IAdaptable* GetDefaultPageInput();

  public: virtual QString GetInitialWindowPerspectiveId() = 0;

  public: virtual QString GetMainPreferencePageId();

  public: virtual bool OpenWindows();

  public: virtual bool SaveState(IMemento::Pointer memento);

  public: virtual bool RestoreState(IMemento::Pointer memento);

  /*
   * Return the contribution comparator for the particular type of
   * contribution. The default implementation of this class returns a
   * comparator that sorts the items by label.
   *
   * The contributionType may be one of the constants in
   * {@link IContributionService} or it can be a value defined by the user.
   *
   * @param contributionType
   *            the contribution type
   * @return the comparator, must not return <code>null</code>
   * @see IContributionService#GetComparatorFor(const QString&)
   */
//  public: ContributionComparator getComparatorFor(String contributionType) {
//    return new ContributionComparator();
//  }
};

}

#endif /*BERRYWORKBENCHADVISOR_H_*/