berryWorkbenchAdvisor.h

Go to the documentation of this file.

/*============================================================================
 
The Medical Imaging Interaction Toolkit (MITK)
 
Copyright (c) German Cancer Research Center (DKFZ)
All rights reserved.
 
Use of this source code is governed by a 3-clause BSD license that can be
found in the LICENSE file.
 
============================================================================*/
 
#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_*/