diff --git a/BlueBerry/Bundles/org.blueberry.ui.qt/src/internal/berryQtShell.cpp b/BlueBerry/Bundles/org.blueberry.ui.qt/src/internal/berryQtShell.cpp
index 25c2e2f0ee..74b421c439 100755
--- a/BlueBerry/Bundles/org.blueberry.ui.qt/src/internal/berryQtShell.cpp
+++ b/BlueBerry/Bundles/org.blueberry.ui.qt/src/internal/berryQtShell.cpp
@@ -1,223 +1,224 @@
 /*===================================================================
 
 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.
 
 ===================================================================*/
 
+#include <internal/berryTweaklets.h>
+
 #include "berryQtShell.h"
 
 #include "berryQtWidgetsTweakletImpl.h"
 #include "berryQtMainWindowControl.h"
 #include <internal/berryQtControlWidget.h>
 
 #include <berryConstants.h>
-#include <internal/berryTweaklets.h>
 #include <tweaklets/berryGuiWidgetsTweaklet.h>
 
 #include <QApplication>
 #include <QVariant>
 
 namespace berry
 {
 
 QtShell::QtShell(QWidget* parent, Qt::WindowFlags flags)
  : updatesDisabled(false)
 {
   if (parent == 0 || flags.testFlag(Qt::Window))
   {
     widget = new QtMainWindowControl(this, parent, flags);
     widget->setUpdatesEnabled(false);
     updatesDisabled = true;
 
     widget->setAttribute(Qt::WA_DeleteOnClose);
   }
   else
   {
     widget = new QtControlWidget(parent, this, flags | Qt::Dialog);
     widget->setObjectName("shell widget");
   }
 }
 
 QtShell::~QtShell()
 {
   widget->deleteLater();
 }
 
 void QtShell::SetBounds(const Rectangle& bounds)
 {
   widget->move(bounds.x, bounds.y);
   widget->resize(bounds.width, bounds.height);
 }
 
 Rectangle QtShell::GetBounds() const
 {
   const QRect& qRect = widget->frameGeometry();
   const QSize& size = widget->size();
   Rectangle rect(qRect.x(), qRect.y(), size.width(), size.height());
   return rect;
 }
 
 void QtShell::SetLocation(int x, int y)
 {
   widget->move(x, y);
 }
 
 Point QtShell::ComputeSize(int  /*wHint*/, int  /*hHint*/, bool changed)
 {
   if (changed) widget->updateGeometry();
   QSize size(widget->size());
   Point point(size.width(), size.height());
   return point;
 }
 
 std::string QtShell::GetText() const
 {
   return widget->windowTitle().toStdString();
 }
 
 void QtShell::SetText(const std::string& text)
 {
   QString title(QString::fromStdString(text));
   widget->setWindowTitle(title);
   widget->setObjectName(title);
 }
 
 bool QtShell::IsVisible()
 {
   return widget->isVisible();
 }
 
 void QtShell::SetVisible(bool visible)
 {
   widget->setVisible(visible);
 }
 
 void QtShell::SetActive()
 {
   widget->activateWindow();
   widget->raise();
 }
 
 void* QtShell::GetControl()
 {
   return widget;
 }
 
 void QtShell::SetImages(const std::vector<void*>&  /*images*/)
 {
 }
 
 bool QtShell::GetMaximized()
 {
   return widget->isMaximized();
 }
 
 bool QtShell::GetMinimized()
 {
   return widget->isMinimized();
 }
 
 void QtShell::SetMaximized(bool maximized)
 {
   maximized ? widget->showMaximized() : widget->showNormal();
 }
 
 void QtShell::SetMinimized(bool minimized)
 {
   minimized ? widget->showMinimized() : widget->showNormal();
 }
 
 void QtShell::AddShellListener(IShellListener::Pointer listener)
 {
   QVariant variant = widget->property(QtWidgetController::PROPERTY_ID);
   poco_assert(variant.isValid());
   QtWidgetController::Pointer controller = variant.value<QtWidgetController::Pointer>();
   poco_assert(controller != 0);
   controller->AddShellListener(listener);
 }
 
 void QtShell::RemoveShellListener(IShellListener::Pointer listener)
 {
   QVariant variant = widget->property(QtWidgetController::PROPERTY_ID);
   if (variant.isValid())
   {
     QtWidgetController::Pointer controller = variant.value<QtWidgetController::Pointer>();
     if (controller != 0)
       controller->RemoveShellListener(listener);
   }
 }
 
 void QtShell::Open(bool block)
 {
   if (updatesDisabled)
   {
     widget->setUpdatesEnabled(true);
     updatesDisabled = false;
   }
   widget->setWindowModality(block ? Qt::WindowModal : Qt::NonModal);
   widget->show();
 }
 
 void QtShell::Close()
 {
   widget->close();
 }
 
 std::vector<Shell::Pointer> QtShell::GetShells()
 {
   GuiWidgetsTweaklet* widgetTweaklet = Tweaklets::Get(GuiWidgetsTweaklet::KEY);
   std::vector<Shell::Pointer> allShells(widgetTweaklet->GetShells());
   std::vector<Shell::Pointer> descendants;
 
   for (std::size_t i = 0; i < allShells.size(); ++i)
   {
     Shell::Pointer shell = allShells[i];
     if (widgetTweaklet->GetShell(shell->GetControl()) == this)
     {
       descendants.push_back(shell);
     }
   }
 
   return descendants;
 }
 
 int QtShell::GetStyle()
 {
   Qt::WindowFlags qtFlags = widget->windowFlags();
 
   int berryFlags = 0;
   if (!(qtFlags & Qt::FramelessWindowHint))
     berryFlags |= Constants::BORDER;
   if (qtFlags & Qt::WindowTitleHint)
     berryFlags |= Constants::TITLE;
   if (qtFlags & Qt::WindowSystemMenuHint)
     berryFlags |= Constants::CLOSE;
   if (qtFlags & Qt::WindowMinimizeButtonHint)
     berryFlags |= Constants::MIN;
   if (qtFlags & Qt::WindowMaximizeButtonHint)
     berryFlags |= Constants::MAX;
 
   if (widget->windowModality() == Qt::WindowModal)
     berryFlags |= Constants::PRIMARY_MODAL;
   else if(widget->windowModality() == Qt::ApplicationModal)
     berryFlags |= Constants::APPLICATION_MODAL;
 
   return berryFlags;
 }
 
 QWidget* QtShell::GetWidget()
 {
   return widget;
 }
 
 }
diff --git a/BlueBerry/Bundles/org.blueberry.ui.qt/src/internal/util/berryPresentablePartFolder.cpp b/BlueBerry/Bundles/org.blueberry.ui.qt/src/internal/util/berryPresentablePartFolder.cpp
index f1488aa669..3358f8fb96 100755
--- a/BlueBerry/Bundles/org.blueberry.ui.qt/src/internal/util/berryPresentablePartFolder.cpp
+++ b/BlueBerry/Bundles/org.blueberry.ui.qt/src/internal/util/berryPresentablePartFolder.cpp
@@ -1,435 +1,436 @@
 /*===================================================================
 
 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.
 
 ===================================================================*/
 
+#include "internal/berryQtWidgetsTweaklet.h"
+
 #include "berryPresentablePartFolder.h"
 #include "berryAbstractTabItem.h"
 
-#include "internal/berryQtWidgetsTweaklet.h"
 #include <internal/berryQtControlWidget.h>
 
 #include <berryConstants.h>
 #include <internal/berryDragUtil.h>
 
 namespace berry
 {
 
 PresentablePartFolder::ContentProxyListener::ContentProxyListener(
     PresentablePartFolder* folder) :
   folder(folder)
 {
 }
 
 GuiTk::IControlListener::Events::Types PresentablePartFolder::ContentProxyListener::GetEventTypes() const
 {
   return Events::MOVED & Events::RESIZED;
 }
 
 void PresentablePartFolder::ContentProxyListener::ControlMoved(
     GuiTk::ControlEvent::Pointer  /*e*/)
 {
   folder->LayoutContent();
 }
 
 void PresentablePartFolder::ContentProxyListener::ControlResized(
     GuiTk::ControlEvent::Pointer  /*e*/)
 {
 }
 
 PresentablePartFolder::ShellListener::ShellListener(AbstractTabFolder* _folder) :
   folder(_folder)
 {
 }
 
 void PresentablePartFolder::ShellListener::ShellActivated(ShellEvent::Pointer  /*e*/)
 {
   folder->ShellActive(true);
 }
 
 void PresentablePartFolder::ShellListener::ShellDeactivated(
     ShellEvent::Pointer  /*e*/)
 {
   folder->ShellActive(false);
 }
 
 PresentablePartFolder::ChildPropertyChangeListener::ChildPropertyChangeListener(
     PresentablePartFolder* folder) :
   presentablePartFolder(folder)
 {
 }
 
 void PresentablePartFolder::ChildPropertyChangeListener::PropertyChange(
     Object::Pointer source, int property)
 {
 
   if (source.Cast<IPresentablePart> () != 0)
   {
     IPresentablePart::Pointer part = source.Cast<IPresentablePart> ();
 
     presentablePartFolder->ChildPropertyChanged(part, property);
   }
 }
 
 PartInfo PresentablePartFolder::tempPartInfo = PartInfo();
 
 void PresentablePartFolder::LayoutContent()
 {
   if (current != 0)
   {
     Rectangle clientArea = DragUtil::GetDisplayBounds(contentProxy);
 
     Rectangle bounds = Tweaklets::Get(GuiWidgetsTweaklet::KEY)->ToControl(
         folder->GetControl()->parentWidget(), clientArea);
     current->SetBounds(bounds);
   }
 }
 
 void PresentablePartFolder::InternalRemove(IPresentablePart::Pointer toRemove)
 {
   AbstractTabItem* item = this->GetTab(toRemove);
   if (item != 0) {
       item->Dispose();
   }
   // do not use item anymore!
 
   if (std::find(partList.begin(), partList.end(), toRemove) != partList.end())
   {
     toRemove->RemovePropertyListener(childPropertyChangeListener);
     partList.remove(toRemove);
   }
 }
 
 void PresentablePartFolder::ChildPropertyChanged(
     IPresentablePart::Pointer part, int property)
 {
   AbstractTabItem* tab = this->GetTab(part);
 
   if (property == IPresentablePart::PROP_HIGHLIGHT_IF_BACK)
   {
     if (tab != 0 && this->GetCurrent() != part)
     {//Set bold if it doesn't currently have focus
       tab->SetBold(true);
       this->InitTab(tab, part);
     }
   }
 
   // else if (property == IPresentablePart::PROP_TOOLBAR)
   //  {
   //    if (tab != 0 && this->GetCurrent() == part)
   //    {
   //      folder->FlushToolbarSize();
   //    }
   //    if (tab != 0)
   //      {
   //        this->InitTab(tab, part);
   //        if (this->GetCurrent() == part)
   //        {
   //          this->Layout(true);
   //        }
   //      }
   else if (property == IPresentablePart::PROP_CONTENT_DESCRIPTION || property
       == IPresentablePart::PROP_PANE_MENU || property
       == IPresentablePart::PROP_TITLE)
   {
     if (tab != 0)
     {
       this->InitTab(tab, part);
       if (this->GetCurrent() == part)
       {
         this->Layout(true);
       }
     }
   }
   else if (property == IPresentablePart::PROP_PREFERRED_SIZE)
   {
     TabFolderEvent::Pointer event(
         new TabFolderEvent(TabFolderEvent::EVENT_PREFERRED_SIZE, tab, 0, 0));
     folder->FireEvent(event);
   }
   else
   {
     if (tab != 0)
       this->InitTab(tab, part);
   }
 }
 
 PresentablePartFolder::~PresentablePartFolder()
 {
   Tweaklets::Get(QtWidgetsTweaklet::KEY)->GetShell(folder->GetControl())->RemoveShellListener(
       shellListener);
   for (std::list<IPresentablePart::Pointer>::iterator iter = partList.begin(); iter
       != partList.end(); ++iter)
   {
     (*iter)->RemovePropertyListener(childPropertyChangeListener);
   }
 
   for (QWidget* currentWidget = contentProxy; currentWidget != 0 && currentWidget
       != folder->GetControl()->parentWidget(); currentWidget = currentWidget->parentWidget())
   {
     Tweaklets::Get(GuiWidgetsTweaklet::KEY)->RemoveControlListener(currentWidget, contentListener);
   }
 
   BERRY_DEBUG << "DELETING PresentablePartFolder and contentProxy\n";
 
   delete folder;
 }
 
 void PresentablePartFolder::InitTab(AbstractTabItem* item,
     IPresentablePart::Pointer part)
 {
   tempPartInfo.Set(part);
   item->SetInfo(tempPartInfo);
 
   item->SetBusy(part->IsBusy());
   if (part == this->GetCurrent())
   {
     folder->SetSelectedInfo(tempPartInfo);
     //TODO Pane menu
     //folder->EnablePaneMenu(part->GetMenu() != 0);
 
     //setToolbar(part.getToolBar());
   }
 }
 
 PresentablePartFolder::PresentablePartFolder(AbstractTabFolder* _folder) :
   folder(_folder), isVisible(true), shellListener(new ShellListener(folder)),
       childPropertyChangeListener(new ChildPropertyChangeListener(this))
 {
   Shell::Pointer controlShell =
       Tweaklets::Get(QtWidgetsTweaklet::KEY)->GetShell(folder->GetControl());
   controlShell->AddShellListener(shellListener);
   folder->ShellActive(Tweaklets::Get(QtWidgetsTweaklet::KEY)->GetActiveShell()
       == controlShell);
 
   //folder.getControl().addDisposeListener(tabDisposeListener);
 
   //toolbarProxy = new ProxyControl(folder.getToolbarParent());
 
   // NOTE: if the shape of contentProxy changes, the fix for bug 85899 in EmptyTabFolder.computeSize may need adjustment.
   contentListener = new ContentProxyListener(this);
   contentProxy = new QtControlWidget(folder->GetContentParent(), 0);
   contentProxy->setSizePolicy(QSizePolicy::Expanding, QSizePolicy::Expanding);
   //contentProxy->setVisible(false);
   for (QWidget* currentWidget = contentProxy; currentWidget != 0 && currentWidget
       != folder->GetControl()->parentWidget(); currentWidget = currentWidget->parentWidget())
   {
     Tweaklets::Get(GuiWidgetsTweaklet::KEY)->AddControlListener(currentWidget, contentListener);
   }
   folder->SetContent(contentProxy);
 
 }
 
 std::vector<IPresentablePart::Pointer> PresentablePartFolder::GetPartList()
 {
   std::vector<AbstractTabItem*> items = folder->GetItems();
   std::vector<IPresentablePart::Pointer> result;
 
   for (unsigned int i = 0; i < items.size(); i++)
   {
     result.push_back(this->GetPartForTab(items[i]));
   }
 
   return result;
 }
 
 void PresentablePartFolder::Insert(IPresentablePart::Pointer part, int idx)
 {
   poco_assert(folder->GetControl() != 0);
 
   if (this->GetTab(part) != 0)
   {
     if (this->IndexOf(part) != idx)
     this->Move(part, idx);
     return;
   }
 
   idx = std::min<int>(idx, static_cast<int>(folder->GetItemCount()));
 
   AbstractTabItem* item = 0;
 
   int style = 0;
 
   if (part->IsCloseable())
   {
     style |= Constants::CLOSE;
   }
 
   item = folder->Add(idx, style);
 
   item->SetData(part);
 
   this->InitTab(item, part);
 
   part->AddPropertyListener(childPropertyChangeListener);
   partList.push_back(part);
 }
 
 void PresentablePartFolder::Remove(IPresentablePart::Pointer toRemove)
 {
   if (toRemove == current)
   {
     this->Select(IPresentablePart::Pointer(0));
   }
 
   this->InternalRemove(toRemove);
 }
 
 void PresentablePartFolder::Move(IPresentablePart::Pointer part, int newIndex)
 {
   int currentIndex = this->IndexOf(part);
 
   if (currentIndex == newIndex)
   {
     return;
   }
 
   folder->Move(currentIndex, newIndex);
 
   //this->InternalRemove(part);
   //this->Insert(part, newIndex);
 
   //if (current == part)
   //{
   //  folder->SetSelection(this->GetTab(part));
   //}
 }
 
 std::size_t PresentablePartFolder::Size()
 {
   return folder->GetItemCount();
 }
 
 void PresentablePartFolder::SetBounds(const QRect& bounds)
 {
   QSize minSize = folder->ComputeSize(bounds.width(), Constants::DEFAULT);
 
   QRect newBounds(bounds);
   if (folder->GetState() == IStackPresentationSite::STATE_MINIMIZED
       && minSize.height() < bounds.height())
   {
     newBounds.setHeight(minSize.height());
   }
 
   // Set the tab folder's bounds
   folder->GetControl()->setGeometry(newBounds);
 
   this->Layout(false);
 }
 
 void PresentablePartFolder::Select(IPresentablePart::Pointer toSelect)
 {
 
   if (toSelect == current)
   {
     return;
   }
 
   if (toSelect != 0)
   {
     toSelect->SetVisible(true);
   }
 
   if (current != 0)
   {
     current->SetVisible(false);
     //setToolbar(null);
   }
 
   current = toSelect;
 
   AbstractTabItem* selectedItem = this->GetTab(toSelect);
 
   folder->SetSelection(selectedItem);
 
   if (selectedItem != 0)
   {
     // Determine if we need to un-bold this tab
     selectedItem->SetBold(false);
     this->InitTab(selectedItem, toSelect);
   }
   //  else
   //  {
   //    setToolbar(null);
   //  }
 
   this->Layout(true);
 }
 
 IPresentablePart::Pointer PresentablePartFolder::GetPartForTab(
     AbstractTabItem* tab)
 {
   if (tab == 0)
   {
     return IPresentablePart::Pointer(0);
   }
 
   IPresentablePart::Pointer part = tab->GetData().Cast<IPresentablePart> ();
 
   return part;
 }
 
 AbstractTabItem* PresentablePartFolder::GetTab(IPresentablePart::Pointer part)
 {
   return folder->FindItem(part);
 }
 
 int PresentablePartFolder::IndexOf(IPresentablePart::Pointer part)
 {
   AbstractTabItem* item = this->GetTab(part);
 
   if (item == 0)
   {
     return -1;
   }
 
   return folder->IndexOf(item);
 }
 
 AbstractTabFolder* PresentablePartFolder::GetTabFolder()
 {
   return folder;
 }
 
 void PresentablePartFolder::SetVisible(bool isVisible)
 {
   this->isVisible = isVisible;
   this->GetTabFolder()->SetVisible(isVisible);
   if (isVisible)
   {
     this->Layout(true);
   }
 }
 
 void PresentablePartFolder::Layout(bool changed)
 {
   if (!isVisible)
   {
     // Don't bother with layout if we're not visible
     return;
   }
   // Lay out the tab folder and compute the client area
   folder->Layout(changed);
 
   //toolbarProxy.layout();
 
   this->LayoutContent();
 }
 
 IPresentablePart::Pointer PresentablePartFolder::GetCurrent()
 {
   return current;
 }
 
 }
diff --git a/BlueBerry/Bundles/org.blueberry.ui/src/internal/berryEditorReference.cpp b/BlueBerry/Bundles/org.blueberry.ui/src/internal/berryEditorReference.cpp
index 908e66f910..a6937bfb49 100644
--- a/BlueBerry/Bundles/org.blueberry.ui/src/internal/berryEditorReference.cpp
+++ b/BlueBerry/Bundles/org.blueberry.ui/src/internal/berryEditorReference.cpp
@@ -1,574 +1,574 @@
 /*===================================================================
 
 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.
 
 ===================================================================*/
 
-#include "berryEditorReference.h"
-
 #include "tweaklets/berryWorkbenchPageTweaklet.h"
 
+#include "berryEditorReference.h"
+
 #include "berryEditorManager.h"
 #include "berryEditorDescriptor.h"
 #include "berryEditorRegistry.h"
 #include "berryEditorSite.h"
 #include "berryEditorAreaHelper.h"
 #include "berryWorkbenchPlugin.h"
 #include "berryWorkbenchPage.h"
 #include "berryNullEditorInput.h"
 #include "berryPartTester.h"
 
 #include "berryImageDescriptor.h"
 #include "berryPlatformUI.h"
 #include "berryIWorkbenchPartConstants.h"
 
 namespace berry
 {
 
 EditorReference::EditorReference(EditorManager* man,
     IEditorInput::Pointer input, EditorDescriptor::Pointer desc,
     IMemento::Pointer editorState) :
   manager(man), expectingInputChange(false),
       reportedMalfunctioningEditor(false)
 {
   this->InitListenersAndHandlers();
   restoredInput = input;
   this->editorState = editorState;
   this->Init(desc->GetId(), "", desc->GetImageDescriptor(),
   desc->GetLabel(), "");
 }
 
 EditorReference::EditorReference(EditorManager* man, IMemento::Pointer memento) :
   manager(man), expectingInputChange(false),
       reportedMalfunctioningEditor(false)
 {
   this->InitListenersAndHandlers();
   this->editorMemento = memento;
   if (manager->UseIPersistableEditor())
   {
     //editorState = editorMemento->GetChild(WorkbenchConstants::TAG_EDITOR_STATE);
   }
   else
   {
     editorState = 0;
   }
   //  String id = memento.getString(IWorkbenchConstants.TAG_ID);
   //  String title = memento.getString(IWorkbenchConstants.TAG_TITLE);
   //  String tooltip = Util.safeString(memento
   //  .getString(IWorkbenchConstants.TAG_TOOLTIP));
   //  String partName = memento
   //  .getString(IWorkbenchConstants.TAG_PART_NAME);
   //
   //  IMemento propBag = memento.getChild(IWorkbenchConstants.TAG_PROPERTIES);
   //  if (propBag != null)
   //  {
   //    IMemento[] props = propBag
   //    .getChildren(IWorkbenchConstants.TAG_PROPERTY);
   //    for (int i = 0; i < props.length; i++)
   //    {
   //      propertyCache.put(props[i].getID(), props[i].getTextData());
   //    }
   //  }
 
   // For compatibility set the part name to the title if not found
 
   //  if (partName.empty())
   //  {
   //    partName = title;
   //  }
 
   // Get the editor descriptor.
   //  EditorDescriptor::Pointer desc;
   //  if (id != null)
   //  {
   //    desc = getDescriptor(id);
   //  }
   //  // desc may be null if id is null or desc is not found, but findImage below handles this
   //  String location = memento.getString(IWorkbenchConstants.TAG_PATH);
   //  IPath path = location == null ? null : new Path(location);
   //  ImageDescriptor iDesc = this.manager.findImage(desc, path);
   //
   //  this.name = memento.getString(IWorkbenchConstants.TAG_NAME);
   //  if (this.name == null)
   //  {
   //    this.name = title;
   //  }
   //  setPinned("true".equals(memento.getString(IWorkbenchConstants.TAG_PINNED))); //$NON-NLS-1$
   //
   //  IMemento inputMem = memento.getChild(IWorkbenchConstants.TAG_INPUT);
   //  if (inputMem != null)
   //  {
   //    this.factoryId = inputMem
   //    .getString(IWorkbenchConstants.TAG_FACTORY_ID);
   //  }
   //
   //  init(id, title, tooltip, iDesc, partName, ""); //$NON-NLS-1$
 }
 
 EditorDescriptor::Pointer EditorReference::GetDescriptor()
 {
   return this->GetDescriptor(this->GetId());
 }
 
 EditorDescriptor::Pointer EditorReference::GetDescriptor(const std::string& id)
 {
   EditorDescriptor::Pointer desc;
   IEditorRegistry* reg = WorkbenchPlugin::GetDefault()->GetEditorRegistry();
   desc = reg->FindEditor(id).Cast<EditorDescriptor> ();
   return desc;
 }
 
 void EditorReference::InitListenersAndHandlers()
 {
   // Create a property change listener to track the "close editors automatically"
   // preference and show/remove the pin icon on editors
   // Only 1 listener will be created in the EditorManager when necessary
   //this->manager->CheckCreateEditorPropListener();
   // Create a keyboard shortcut handler for pinning editors
   // Only 1 handler will be created in the EditorManager when necessary
   //this->manager->CheckCreatePinEditorShortcutKeyHandler();
 }
 
 PartPane::Pointer EditorReference::CreatePane()
 {
   PartPane::Pointer pane(
       new PartPane(IWorkbenchPartReference::Pointer(this), this->manager->page));
   return pane;
   //return Tweaklets::Get(WorkbenchTweaklet::KEY)->CreateEditorPane(this,
   //    this->manager->page);
 }
 
 void EditorReference::PinStatusUpdated()
 {
   //firePropertyChange(IWorkbenchPart.PROP_TITLE);
 }
 
 std::string EditorReference::GetFactoryId()
 {
   //  IEditorPart editor = getEditor(false);
   //  if (editor != null)
   //  {
   //    IPersistableElement persistable = editor.getEditorInput()
   //    .getPersistable();
   //    if (persistable != null)
   //    {
   //      return persistable.getFactoryId();
   //    }
   //    return null;
   //  }
   //  return factoryId;
   return "";
 }
 
 std::string EditorReference::ComputePartName()
 {
   return WorkbenchPartReference::ComputePartName();
 }
 
 std::string EditorReference::GetName()
 {
   if (part.IsNotNull())
   {
     return this->GetEditor(false)->GetEditorInput()->GetName();
   }
   return name;
 }
 
 IEditorPart::Pointer EditorReference::GetEditor(bool restore)
 {
   return this->GetPart(restore).Cast<IEditorPart> ();
 }
 
 void EditorReference::SetName(const std::string& name)
 {
   this->name = name;
 }
 
 IMemento::Pointer EditorReference::GetMemento()
 {
   return editorMemento;
 }
 
 IWorkbenchPage::Pointer EditorReference::GetPage() const
 {
   return IWorkbenchPage::Pointer(this->manager->page);
 }
 
 IEditorInput::Pointer EditorReference::GetEditorInput()
 {
   IEditorPart::Pointer part = this->GetEditor(false);
   if (part.IsNotNull())
   {
     return part->GetEditorInput();
   }
   return this->GetRestoredInput();
 }
 
 IEditorInput::Pointer EditorReference::GetRestoredInput()
 {
   if (restoredInput.IsNotNull())
   {
     return restoredInput;
   }
 
   // Get the input factory.
   //    IMemento::Pointer editorMem = this->GetMemento();
   //    if (editorMem == null)
   //    {
   //      throw new PartInitException(NLS.bind(WorkbenchMessages.EditorManager_no_persisted_state, getId(), getName()));
   //    }
   //    IMemento inputMem = editorMem
   //    .getChild(IWorkbenchConstants.TAG_INPUT);
   //    String factoryID = null;
   //    if (inputMem != null)
   //    {
   //      factoryID = inputMem
   //      .getString(IWorkbenchConstants.TAG_FACTORY_ID);
   //    }
   //    if (factoryID == null)
   //    {
   //      throw new PartInitException(NLS.bind(WorkbenchMessages.EditorManager_no_input_factory_ID, getId(), getName()));
   //    }
   //    IAdaptable input = null;
   //    String label = null; // debugging only
   //    if (UIStats.isDebugging(UIStats.CREATE_PART_INPUT))
   //    {
   //      label = getName() != null ? getName() : factoryID;
   //    }
   //    try
   //    {
   //      UIStats.start(UIStats.CREATE_PART_INPUT, label);
   //      IElementFactory factory = PlatformUI.getWorkbench()
   //      .getElementFactory(factoryID);
   //      if (factory == null)
   //      {
   //        throw new PartInitException(NLS.bind(WorkbenchMessages.EditorManager_bad_element_factory, new Object[]
   //                { factoryID, getId(), getName()}));
   //      }
   //
   //      // Get the input element.
   //      input = factory.createElement(inputMem);
   //      if (input == null)
   //      {
   //        throw new PartInitException(NLS.bind(WorkbenchMessages.EditorManager_create_element_returned_null, new Object[]
   //                { factoryID, getId(), getName()}));
   //      }
   //    }finally
   //    {
   //      UIStats.end(UIStats.CREATE_PART_INPUT, input, label);
   //    }
   //    if (!(input instanceof IEditorInput))
   //    {
   //      throw new PartInitException(NLS.bind(WorkbenchMessages.EditorManager_wrong_createElement_result, new Object[]
   //              { factoryID, getId(), getName()}));
   //    }
   //    restoredInput = (IEditorInput) input;
   return restoredInput;
 }
 
 IWorkbenchPart::Pointer EditorReference::CreatePart()
 {
   if (EditorRegistry::EMPTY_EDITOR_ID == this->GetId())
   {
     return this->GetEmptyEditor(this->GetDescriptor());
   }
 
   IWorkbenchPart::Pointer result;
 
   // Try to restore the editor -- this does the real work of restoring the editor
   //
   try
   {
     result = this->CreatePartHelper().Cast<IWorkbenchPart> ();
   } catch (PartInitException e)
   {
     // If unable to create the part, create an error part instead
     // and pass the error to the status handling facility
     //    IStatus originalStatus = exception.getStatus();
     //    IStatus logStatus = StatusUtil.newStatus(originalStatus,
     //        NLS.bind("Unable to create editor ID {0}: {1}", //$NON-NLS-1$
     //            getId(), originalStatus.getMessage()));
     //    IStatus displayStatus = StatusUtil.newStatus(originalStatus,
     //        NLS.bind(WorkbenchMessages.EditorManager_unableToCreateEditor,
     //            originalStatus.getMessage()));
     WorkbenchPlugin::Log("Unable to create editor ID " + this->GetId() + ": "
         + e.displayText());
 
     // Pass the error to the status handling facility
     //StatusManager.getManager().handle(logStatus);
 
     EditorDescriptor::Pointer descr = this->GetDescriptor();
     std::string label = this->GetId();
     if (descr.IsNotNull())
       label = descr->GetLabel();
 
     IEditorPart::Pointer part =
         Tweaklets::Get(WorkbenchPageTweaklet::KEY)->CreateErrorEditorPart(label,
             e.displayText());
     if (part.IsNotNull())
     {
       IEditorInput::Pointer input;
       try
       {
         input = this->GetEditorInput();
       } catch (PartInitException e1)
       {
         input = new NullEditorInput(EditorReference::Pointer(this));
       }
 
       PartPane::Pointer pane = this->GetPane();
 
       pane->CreateControl(
           manager->page->GetEditorPresentation()->GetLayoutPart()->GetControl());
 
       EditorSite::Pointer site(
           new EditorSite(IEditorReference::Pointer(this), part, manager->page, descr));
 
       //site.setActionBars(new EditorActionBars(manager.page, site.getWorkbenchWindow(), getId()));
 
       part->Init(site, input);
 
       try
       {
         part->CreatePartControl(pane->GetControl());
       } catch (...)
       {
         //content.dispose();
         //StatusUtil.handleStatus(e, StatusManager.SHOW
         //    | StatusManager.LOG);
         WorkbenchPlugin::Log("Error creating editor");
         return IWorkbenchPart::Pointer(0);
       }
 
       result = part.Cast<IWorkbenchPart> ();
     }
   }
 
   return result;
 }
 
 void EditorReference::PropertyChanged(Object::Pointer source, int propId)
 {
   // Detect badly behaved editors that don't fire PROP_INPUT events
   // when they're supposed to. This branch is only needed to handle
   // malfunctioning editors.
   if (propId == IWorkbenchPartConstants::PROP_INPUT)
   {
     expectingInputChange = false;
   }
 
   WorkbenchPartReference::PropertyChanged(source, propId);
 }
 
 bool EditorReference::SetInput(IEditorInput::Pointer input)
 {
 
   if (part.IsNotNull())
   {
     if (part.Cast<IReusableEditor> ().IsNotNull())
     {
       IReusableEditor::Pointer editor = part.Cast<IReusableEditor> ();
 
       expectingInputChange = true;
 
       editor->SetInput(input);
 
       // If the editor never fired a PROP_INPUT event, log the fact that we've discovered
       // a buggy editor and fire the event for free. Firing the event for free isn't required
       // and cannot be relied on (it only works if the input change was triggered by this
       // method, and there are definitely other cases where events will still be lost),
       // but older versions of the workbench did this so we fire it here in the spirit
       // of playing nice.
       if (expectingInputChange)
       {
 
         // Log the fact that this editor is broken
         this->ReportMalfunction(
             "Editor is not firing a PROP_INPUT event in response to IReusableEditor.setInput(...)"); //$NON-NLS-1$
 
         // Fire the property for free (can't be relied on since there are other ways the input
         // can change, but we do it here to be consistent with older versions of the workbench)
         FirePropertyChange(IWorkbenchPartConstants::PROP_INPUT);
       }
 
       return editor->GetEditorInput() == input;
 
     }
     // Can't change the input if the editor already exists and isn't an IReusableEditor
     return false;
   }
 
   // Changing the input is trivial and always succeeds if the editor doesn't exist yet
   if (input != restoredInput)
   {
     restoredInput = input;
 
     //firePropertyChange(IWorkbenchPartConstants.PROP_INPUT);
   }
 
   return true;
 }
 
 void EditorReference::ReportMalfunction(const std::string& string)
 {
   if (!reportedMalfunctioningEditor)
   {
     reportedMalfunctioningEditor = true;
 
     std::string errorMessage = "Problem detected with part " + this->GetId(); //$NON-NLS-1$
     if (part.IsNotNull())
     {
       errorMessage.append("(class = ").append(part->GetClassName()).append(
           ")"); //$NON-NLS-1$ //$NON-NLS-2$
     }
 
     errorMessage += ": " + string; //$NON-NLS-1$
 
     //StatusManager.getManager().handle(StatusUtil.newStatus(getDescriptor().getPluginId(), errorMessage, null));
     BERRY_ERROR << errorMessage << std::endl;
   }
 }
 
 IEditorPart::Pointer EditorReference::CreatePartHelper()
 {
 
   EditorSite::Pointer site;
   IEditorPart::Pointer part;
 
   try
   {
     IEditorInput::Pointer editorInput = this->GetEditorInput();
 
     // Get the editor descriptor.
     std::string editorID = this->GetId();
     EditorDescriptor::Pointer desc = this->GetDescriptor();
 
     if (desc.IsNull())
     {
       throw PartInitException("No editor descriptor for id " + editorID);
     }
 
     if (desc->IsInternal())
     {
       // Create an editor instance.
       part = manager->CreatePart(desc);
 
       this->CreatePartProperties(part);
 
     }
     //    else if (desc->GetId() == IEditorRegistry.SYSTEM_INPLACE_EDITOR_ID)
     //    {
     //
     //      part = ComponentSupport.getSystemInPlaceEditor();
     //
     //      if (part == null)
     //      {
     //        throw new PartInitException(WorkbenchMessages.EditorManager_no_in_place_support);
     //      }
     //    }
     else
     {
       throw PartInitException("Invalid editor descriptor for id " + editorID);
     }
     // Create a pane for this part
     PartPane::Pointer pane = this->GetPane();
 
     pane->CreateControl(manager->page->GetEditorPresentation()->GetLayoutPart()->GetControl());
 
 
     // Link everything up to the part reference (the part reference itself should not have
     // been modified until this point)
     site = manager->CreateSite(IEditorReference::Pointer(this), part, desc, editorInput);
 
     // if there is saved state that's appropriate, pass it on
     if (/*part instanceof IPersistableEditor &&*/editorState.IsNotNull())
     {
       //part->RestoreState(editorState);
     }
 
     // Remember the site and the action bars (now that we've created them, we'll need to dispose
     // them if an exception occurs)
     //actionBars = (EditorActionBars) site.getActionBars();
 
     part->CreatePartControl(pane->GetControl());
 
     // The editor should now be fully created. Exercise its public interface, and sanity-check
     // it wherever possible. If it's going to throw exceptions or behave badly, it's much better
     // that it does so now while we can still cancel creation of the part.
     PartTester::TestEditor(part);
 
     return part;
 
   } catch (std::exception e)
   {
     throw PartInitException(e.what());
   }
 
 }
 
 IEditorPart::Pointer EditorReference::GetEmptyEditor(
     EditorDescriptor::Pointer descr)
 {
   IEditorPart::Pointer part =
       Tweaklets::Get(WorkbenchPageTweaklet::KEY)->CreateErrorEditorPart("(Empty)", "");
 
   IEditorInput::Pointer input;
   try
   {
     input = this->GetEditorInput();
   } catch (PartInitException e1)
   {
     input = new NullEditorInput(EditorReference::Pointer(this));
   }
 
   PartPane::Pointer pane = this->GetPane();
 
   pane->CreateControl(
       manager->page->GetEditorPresentation()->GetLayoutPart()->GetControl());
 
   EditorSite::Pointer site(new EditorSite(IEditorReference::Pointer(this),
                                           part, manager->page, descr));
 
   //site.setActionBars(new EditorActionBars(manager.page, site.getWorkbenchWindow(), getId()));
 
   part->Init(site, input);
 
   try
   {
     part->CreatePartControl(pane->GetControl());
   } catch (std::exception e)
   {
     //StatusManager.getManager().handle(
     //    StatusUtil.newStatus(WorkbenchPlugin.PI_WORKBENCH, e));
     BERRY_ERROR << e.what() << std::endl;
     return IEditorPart::Pointer(0);
   }
 
   this->part = part.Cast<IWorkbenchPart> ();
   // Add a dispose listener to the part. This dispose listener does nothing but log an exception
   // if the part's widgets get disposed unexpectedly. The workbench part reference is the only
   // object that should dispose this control, and it will remove the listener before it does so.
 
   this->RefreshFromPart();
   //this->ReleaseReferences();
 
   if (this->GetPage().Cast<WorkbenchPage> ()->GetActiveEditorReference()
       != this)
   {
     //fireInternalPropertyChange(INTERNAL_PROPERTY_OPENED);
   }
 
   return part;
 }
 
 }