diff --git a/Modules/DicomUI/Qmitk/QmitkDicomExternalDataWidget.cpp b/Modules/DicomUI/Qmitk/QmitkDicomExternalDataWidget.cpp
index 3d35912558..3fecfe5ff1 100644
--- a/Modules/DicomUI/Qmitk/QmitkDicomExternalDataWidget.cpp
+++ b/Modules/DicomUI/Qmitk/QmitkDicomExternalDataWidget.cpp
@@ -1,223 +1,223 @@
 /*=========================================================================
 
 Program:   Medical Imaging & Interaction Toolkit
 Language:  C++
 Date:      $Date$
 Version:   $Revision$ 
 
 Copyright (c) German Cancer Research Center, Division of Medical and
 Biological Informatics. All rights reserved.
 See MITKCopyright.txt or http://www.mitk.org/copyright.html for details.
 
 This software is distributed WITHOUT ANY WARRANTY; without even
 the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
 PURPOSE.  See the above copyright notices for more information.
 
 =========================================================================*/
 
 #include <mitkStatusBar.h>
 
 // Qmitk
 #include "QmitkDicomExternalDataWidget.h"
 #include <mitkLogMacros.h>
 
 // Qt
 #include <QCheckBox>
 #include <QMessageBox>
 #include <QMap>
 #include <QVariant>
 
 // CTK
 #include <ctkDICOMDataset.h>
 
 
 
 const std::string QmitkDicomExternalDataWidget::Widget_ID = "org.mitk.Widgets.QmitkDicomExternalDataWidget";
 
 QmitkDicomExternalDataWidget::QmitkDicomExternalDataWidget(QWidget *parent)
 :  m_Controls( 0 )
 , m_DirectoryName(new QString())
 {
     Initialize();
     CreateQtPartControl(this);
 }
 
 QmitkDicomExternalDataWidget::~QmitkDicomExternalDataWidget()
 {
     delete m_ImportDialog;
     delete m_ExternalDatabase;
     delete m_ExternalModel;
     delete m_ExternalIndexer;
     delete m_Controls;
     delete m_DirectoryName;
 }
 
 
 void QmitkDicomExternalDataWidget::CreateQtPartControl( QWidget *parent )
 {
 
     // build up qt Widget, unless already done
     if ( !m_Controls )
     {
         // create GUI widgets from the Qt Designer's .ui file
         m_Controls = new Ui::QmitkDicomExternalDataWidgetControls;
         m_Controls->setupUi( parent );
 
         // 
         m_Controls->ExternalDataTreeView->setSortingEnabled(true);
         m_Controls->ExternalDataTreeView->setSelectionBehavior(QAbstractItemView::SelectRows);
         m_Controls->ExternalDataTreeView->setModel(m_ExternalModel);
 
         //Initialize import widget
         m_ImportDialog = new ctkFileDialog();
         QCheckBox* importCheckbox = new QCheckBox("Copy on import", m_ImportDialog);
         m_ImportDialog->setBottomWidget(importCheckbox);
         m_ImportDialog->setFileMode(QFileDialog::Directory);
         m_ImportDialog->setLabelText(QFileDialog::Accept,"Import");
         m_ImportDialog->setWindowTitle("Import DICOM files from directory ...");
         m_ImportDialog->setWindowModality(Qt::ApplicationModal);
         connect(m_ImportDialog, SIGNAL(fileSelected(QString)),this,SLOT(OnFileSelectedAddExternalData(QString)));
 
         //connect Buttons
         connect(m_Controls->downloadButton, SIGNAL(clicked()),this,SLOT(OnDownloadButtonClicked()));
         connect(m_Controls->viewExternalDataButton, SIGNAL(clicked()),this,SLOT(OnViewButtonClicked()));
         connect(m_Controls->cancelButton, SIGNAL(clicked()),this,SLOT(OnDownloadButtonClicked()));
 
         connect(m_Controls->SearchOption_2, SIGNAL(parameterChanged()), this, SLOT(OnSearchParameterChanged()));
     }
 }
 
 void QmitkDicomExternalDataWidget::Initialize()
 {
     m_ExternalDatabase = new ctkDICOMDatabase();
     //m_ExternalDatabase->initializeDatabase();
     try{
         m_ExternalDatabase->openDatabase(QString(":memory:"),QString( "EXTERNAL-DB"));
     }catch(std::exception e){
         MITK_ERROR <<"Database error: "<< m_ExternalDatabase->lastError().toStdString();
         m_ExternalDatabase->closeDatabase();
         return;
     }
 
     m_ExternalModel = new ctkDICOMModel();
     m_ExternalModel->setDatabase(m_ExternalDatabase->database());
     m_ExternalModel->setEndLevel(ctkDICOMModel::SeriesType);
 
     m_ExternalIndexer = new ctkDICOMIndexer();
 }
 
 void QmitkDicomExternalDataWidget::OnFolderCDImport()
 {
     m_ImportDialog->show();
-    m_ImportDialog->raise();  
+    m_ImportDialog->raise();
 }
 
 void QmitkDicomExternalDataWidget::OnFileSelectedAddExternalData(QString directory)
 {
     if (QDir(directory).exists())
     {
         m_DirectoryName = new QString(directory);
         QCheckBox* copyOnImport = qobject_cast<QCheckBox*>(m_ImportDialog->bottomWidget());
 
         if (copyOnImport->isChecked())
         {
             //targetDirectory = d->DICOMDatabase->databaseDirectory();
             MBI_DEBUG<<directory.toStdString();
             emit SignalAddDicomData(directory);
         }else{
             if (m_Watcher.isRunning())
             {
                 m_Watcher.waitForFinished();
             }
             m_Future = QtConcurrent::run(this,(void (QmitkDicomExternalDataWidget::*)(QString)) &QmitkDicomExternalDataWidget::AddDicomTemporary,directory);
             m_Watcher.setFuture(m_Future);
 
             emit SignalChangePage(1);
         }
     }
 }
 
 void QmitkDicomExternalDataWidget::OnDownloadButtonClicked()
 {
     QStringList* filePaths= new QStringList();
     GetFileNamesFromIndex(*filePaths);
     emit SignalAddDicomData(*filePaths);
 }
 
 void QmitkDicomExternalDataWidget::OnViewButtonClicked()
 {
     QModelIndex currentIndex = m_Controls->ExternalDataTreeView->currentIndex();
     if(m_ExternalModel->data(currentIndex,ctkDICOMModel::TypeRole)==static_cast<int>(ctkDICOMModel::SeriesType))
     {
         QString seriesUID = m_ExternalModel->data(currentIndex,ctkDICOMModel::UIDRole).toString();
         QString seriesName = m_ExternalModel->data(currentIndex).toString();        
         
         QModelIndex studyIndex = m_ExternalModel->parent(currentIndex);
         QString studyUID = m_ExternalModel->data(studyIndex,ctkDICOMModel::UIDRole).toString();
         QString studyName = m_ExternalModel->data(studyIndex).toString();
 
         QModelIndex patientIndex = m_ExternalModel->parent(studyIndex);
         QString patientName = m_ExternalModel->data(patientIndex).toString();        
 
         QStringList eventProperties;
         eventProperties << patientName << studyUID << studyName << seriesUID << seriesName << *m_DirectoryName;
         MITK_INFO << m_DirectoryName->toStdString();
 
         emit SignalDicomToDataManager(eventProperties);
     }
 }
 
 void QmitkDicomExternalDataWidget::OnCancelButtonClicked()
 {
     m_Watcher.cancel();
     m_Watcher.waitForFinished();
 }
 
 void QmitkDicomExternalDataWidget::GetFileNamesFromIndex(QStringList& filePaths)
 {
     QModelIndex currentIndex = m_Controls->ExternalDataTreeView->currentIndex();
     QString currentUID = m_ExternalModel->data(currentIndex,ctkDICOMModel::UIDRole).toString();
 
     if(m_ExternalModel->data(currentIndex,ctkDICOMModel::TypeRole)==static_cast<int>(ctkDICOMModel::SeriesType))
     {
         filePaths.append(m_ExternalDatabase->filesForSeries(currentUID));
     }
     else if(m_ExternalModel->data(currentIndex,ctkDICOMModel::TypeRole)==static_cast<int>(ctkDICOMModel::StudyType))
     {
         QStringList seriesList;
         seriesList.append( m_ExternalDatabase->seriesForStudy(currentUID) );
 
         QStringList::Iterator serieIt;
         for(serieIt=seriesList.begin();serieIt!=seriesList.end();++serieIt)
         {
             filePaths.append(m_ExternalDatabase->filesForSeries(*serieIt));
         }
     }
     else if(m_ExternalModel->data(currentIndex,ctkDICOMModel::TypeRole)==static_cast<int>(ctkDICOMModel::PatientType))
     {
         QStringList studiesList,seriesList;
         studiesList.append( m_ExternalDatabase->studiesForPatient(currentUID) );
 
         QStringList::Iterator studyIt,serieIt;
         for(studyIt=studiesList.begin();studyIt!=studiesList.end();++studyIt)
         {
             seriesList.append( m_ExternalDatabase->seriesForStudy(*studyIt) );
 
             for(serieIt=seriesList.begin();serieIt!=seriesList.end();++serieIt)
             {
                 filePaths.append(m_ExternalDatabase->filesForSeries(*serieIt));
             }
         }
     }
 }
 
 void QmitkDicomExternalDataWidget::AddDicomTemporary(QString directory)
 {
     m_ExternalIndexer->addDirectory(*m_ExternalDatabase,directory);
     m_ExternalModel->reset();
 }
 
 void QmitkDicomExternalDataWidget::OnSearchParameterChanged()
 {
     m_ExternalModel->setDatabase(m_ExternalDatabase->database(),m_Controls->SearchOption_2->parameters());
 }
diff --git a/Modules/DicomUI/Qmitk/QmitkDicomLocalStorageWidget.cpp b/Modules/DicomUI/Qmitk/QmitkDicomLocalStorageWidget.cpp
index 7a752709ae..cb6c5fce35 100644
--- a/Modules/DicomUI/Qmitk/QmitkDicomLocalStorageWidget.cpp
+++ b/Modules/DicomUI/Qmitk/QmitkDicomLocalStorageWidget.cpp
@@ -1,191 +1,193 @@
 /*=========================================================================
 
 Program:   Medical Imaging & Interaction Toolkit
 Language:  C++
 Date:      $Date$
 Version:   $Revision$ 
 
 Copyright (c) German Cancer Research Center, Division of Medical and
 Biological Informatics. All rights reserved.
 See MITKCopyright.txt or http://www.mitk.org/copyright.html for details.
 
 This software is distributed WITHOUT ANY WARRANTY; without even
 the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
 PURPOSE.  See the above copyright notices for more information.
 
 =========================================================================*/
 
 // Qmitk
 #include "QmitkDicomLocalStorageWidget.h"
 #include <mitkLogMacros.h>
 #include <mitkProgressBar.h>
 // Qt
 #include <QMessageBox>
 #include <QModelIndex>
 #include <QMap>
 #include <QVariant>
 
 
 
 const std::string QmitkDicomLocalStorageWidget::Widget_ID = "org.mitk.Widgets.QmitkDicomLocalStorageWidget";
 
 QmitkDicomLocalStorageWidget::QmitkDicomLocalStorageWidget(QWidget *parent)
 :  m_Controls( 0 )
 ,m_LocalIndexer(new ctkDICOMIndexer())
 ,m_LocalModel(new ctkDICOMModel())
 {
     CreateQtPartControl(this);
 }
 
 QmitkDicomLocalStorageWidget::~QmitkDicomLocalStorageWidget()
 {
     m_LocalDatabase->closeDatabase();
     delete m_LocalDatabase;
     delete m_LocalIndexer;
     delete m_LocalModel;
     delete m_Controls;
 }
 
 void QmitkDicomLocalStorageWidget::CreateQtPartControl( QWidget *parent )
 {
     if ( !m_Controls )
     {
         m_Controls = new Ui::QmitkDicomLocalStorageWidgetControls;
         m_Controls->setupUi( parent );
         m_Controls->groupBox->setVisible(false);
+        m_Controls->addSortingTagButton_2->setVisible(false);
+        m_Controls->deleteSortingTagButton_2->setVisible(false);
         m_Controls->InternalDataTreeView->setSortingEnabled(true);
         m_Controls->InternalDataTreeView->setSelectionBehavior(QAbstractItemView::SelectRows);
         m_Controls->InternalDataTreeView->setModel(m_LocalModel);
         connect(m_Controls->deleteButton,SIGNAL(clicked()),this,SLOT(OnDeleteButtonClicked()));
         connect(m_Controls->CancelButton, SIGNAL(clicked()), this , SLOT(OnCancelButtonClicked()));
         connect(m_Controls->viewInternalDataButton, SIGNAL(clicked()), this , SLOT(OnViewButtonClicked()));
         connect(m_Controls->SearchOption, SIGNAL(parameterChanged()), this, SLOT(OnSearchParameterChanged()));
     }
 }
 
 void QmitkDicomLocalStorageWidget::StartDicomImport(const QString& dicomData)
 {
     if (m_Watcher.isRunning()){
         m_Watcher.waitForFinished();
     }
     mitk::ProgressBar::GetInstance()->AddStepsToDo(2);
     m_Future = QtConcurrent::run(this,(void (QmitkDicomLocalStorageWidget::*)(const QString&)) &QmitkDicomLocalStorageWidget::AddDICOMData,dicomData);
     m_Watcher.setFuture(m_Future); 
 }
 
 void QmitkDicomLocalStorageWidget::StartDicomImport(const QStringList& dicomData)
 {
     if (m_Watcher.isRunning())
     {
         m_Watcher.waitForFinished();
     }
     mitk::ProgressBar::GetInstance()->AddStepsToDo(dicomData.count());
     m_Future = QtConcurrent::run(this,(void (QmitkDicomLocalStorageWidget::*)(const QStringList&)) &QmitkDicomLocalStorageWidget::AddDICOMData,dicomData);
     m_Watcher.setFuture(m_Future);
 }
 
 void QmitkDicomLocalStorageWidget::AddDICOMData(const QString& directory)
 {
     if(m_LocalDatabase->isOpen())
     {
         mitk::ProgressBar::GetInstance()->Progress();
         m_LocalIndexer->addDirectory(*m_LocalDatabase,directory,m_LocalDatabase->databaseDirectory());
     }
     m_LocalModel->setDatabase(m_LocalDatabase->database());
     mitk::ProgressBar::GetInstance()->Progress();
     emit FinishedImport(directory);
 }
 
 void QmitkDicomLocalStorageWidget::AddDICOMData(const QStringList& patientFiles)
 {
     if(m_LocalDatabase->isOpen())
     {
         QStringListIterator fileIterator(patientFiles);
         while(fileIterator.hasNext())
         {
             m_LocalIndexer->addFile(*m_LocalDatabase,fileIterator.next(),m_LocalDatabase->databaseDirectory());
             mitk::ProgressBar::GetInstance()->Progress();
         }
     }
     m_LocalModel->setDatabase(m_LocalDatabase->database());
     emit FinishedImport(patientFiles);
 }
 
 void QmitkDicomLocalStorageWidget::OnDeleteButtonClicked()
 {
     QModelIndex currentIndex = m_Controls->InternalDataTreeView->currentIndex();
     QString currentUID = m_LocalModel->data(currentIndex,ctkDICOMModel::UIDRole).toString();
     if(m_LocalModel->data(currentIndex,ctkDICOMModel::TypeRole)==static_cast<int>(ctkDICOMModel::SeriesType))
     {
         m_LocalDatabase->removeSeries(currentUID);
     }
     else if(m_LocalModel->data(currentIndex,ctkDICOMModel::TypeRole)==static_cast<int>(ctkDICOMModel::StudyType))
     {
         m_LocalDatabase->removeStudy(currentUID);
     }
     else if(m_LocalModel->data(currentIndex,ctkDICOMModel::TypeRole)==static_cast<int>(ctkDICOMModel::PatientType))
     {
         m_LocalDatabase->removePatient(currentUID);
     }
     m_LocalModel->reset();
 }
 
 void QmitkDicomLocalStorageWidget::OnCancelButtonClicked()
 {
     m_Watcher.cancel();
     m_Watcher.waitForFinished();
     m_LocalDatabase->closeDatabase();
 }
 
 void QmitkDicomLocalStorageWidget::OnViewButtonClicked()
 {
     QModelIndex currentIndex = m_Controls->InternalDataTreeView->currentIndex();
     if(m_LocalModel->data(currentIndex,ctkDICOMModel::TypeRole)==static_cast<int>(ctkDICOMModel::SeriesType))
     {
         QString seriesUID = m_LocalModel->data(currentIndex,ctkDICOMModel::UIDRole).toString();
         QString seriesName = m_LocalModel->data(currentIndex).toString();
         
         QModelIndex studyIndex = m_LocalModel->parent(currentIndex);
         QString studyUID = m_LocalModel->data(studyIndex,ctkDICOMModel::UIDRole).toString();
         QString studyName = m_LocalModel->data(studyIndex).toString();
 
         QModelIndex patientIndex = m_LocalModel->parent(studyIndex);
         QString patientName = m_LocalModel->data(patientIndex).toString();        
 
         QString filePath;
         filePath.append(m_LocalDatabase->databaseDirectory());
         filePath.append("/dicom/");
         filePath.append(studyUID);
         filePath.append("/");
         filePath.append(seriesUID);
         filePath.append("/");
 
         QStringList eventProperties;
         eventProperties << patientName << studyUID <<studyName << seriesUID << seriesName << filePath;
         MITK_INFO << filePath.toStdString();
         emit SignalDicomToDataManager(eventProperties);
     }
 }
 
 void QmitkDicomLocalStorageWidget::OnSearchParameterChanged()
 { 
     m_LocalModel->setDatabase(m_LocalDatabase->database(),m_Controls->SearchOption->parameters());
 }
 
 void QmitkDicomLocalStorageWidget::SetDatabaseDirectory(QString newDatatbaseDirectory)
 {
     QDir databaseDirecory = QDir(newDatatbaseDirectory);
     if(!databaseDirecory.exists())
     {
         databaseDirecory.mkpath(databaseDirecory.absolutePath());
     }
     QString newDatatbaseFile = databaseDirecory.absolutePath() + QString("/ctkDICOM.sql");
     this->SetDatabase(newDatatbaseFile);
 }
 
 void QmitkDicomLocalStorageWidget::SetDatabase(QString databaseFile)
 {
     m_LocalDatabase = new ctkDICOMDatabase(databaseFile);
     m_LocalModel->setEndLevel(ctkDICOMModel::SeriesType);
     m_LocalModel->setDatabase(m_LocalDatabase->database());
 }
diff --git a/Plugins/org.mitk.gui.qt.dicom/src/internal/QmitkDicomEditor.cpp b/Plugins/org.mitk.gui.qt.dicom/src/internal/QmitkDicomEditor.cpp
index 9783858271..a965c1f8a5 100644
--- a/Plugins/org.mitk.gui.qt.dicom/src/internal/QmitkDicomEditor.cpp
+++ b/Plugins/org.mitk.gui.qt.dicom/src/internal/QmitkDicomEditor.cpp
@@ -1,248 +1,244 @@
 /*=========================================================================
 
 Program:   Medical Imaging & Interaction Toolkit
 Language:  C++
 Date:      $Date$
 Version:   $Revision$
 
 Copyright (c) German Cancer Research Center, Division of Medical and
 Biological Informatics. All rights reserved.
 See MITKCopyright.txt or http://www.mitk.org/copyright.html for details.
 
 This software is distributed WITHOUT ANY WARRANTY; without even
 the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
 PURPOSE.  See the above copyright notices for more information.
 
 =========================================================================*/
 
 
 // Blueberry
 #include <berryISelectionService.h>
 #include <berryIWorkbenchWindow.h>
 #include <berryUIException.h>
 #include <berryIWorkbenchPage.h>
 #include <berryIPreferencesService.h>
 #include <berryIPartListener.h>
 #include <mitkGlobalInteraction.h>
 #include <mitkDataStorageEditorInput.h>
 #include "berryFileEditorInput.h"
 
 // Qmitk
 #include "QmitkDicomEditor.h"
 #include "mitkPluginActivator.h"
 #include <mitkDicomSeriesReader.h>
 
 //#include "mitkProgressBar.h"
 
 // Qt
 #include <QCheckBox>
 #include <QMessageBox>
 #include <QWidget>
 
 #include <QtSql>
 #include <QSqlDatabase>
 #include <QtCore/QVariant>
 #include <QtGui/QAction>
 #include <QtGui/QApplication>
 #include <QtGui/QButtonGroup>
 #include <QtGui/QGridLayout>
 #include <QtGui/QHeaderView>
 #include <QtGui/QPushButton>
 #include <QtGui/QTextEdit>
 #include <QtGui/QWidget>
 
 //CTK
 #include <ctkDICOMModel.h>
 #include <ctkDICOMAppWidget.h>
 #include <ctkDICOMQueryWidget.h>
 #include <ctkFileDialog.h>
 #include <ctkDICOMQueryRetrieveWidget.h>
 
 
 const std::string QmitkDicomEditor::EDITOR_ID = "org.mitk.editors.dicomeditor";
 
 
 QmitkDicomEditor::QmitkDicomEditor()
 : m_Thread(new QThread())
 , m_DicomDirectoryListener(new QmitkDicomDirectoryListener())
 , m_StoreSCPLauncher(new QmitkStoreSCPLauncher(&builder))
 , m_Publisher(new QmitkDicomDataEventPublisher())
 {
 }
 
 QmitkDicomEditor::~QmitkDicomEditor()
 {
     m_Thread->quit();
     m_Thread->wait(1000);
     delete m_Handler;
     delete m_Publisher;
     delete m_StoreSCPLauncher;
     delete m_Thread;
     delete m_DicomDirectoryListener;
 }
 
 void QmitkDicomEditor::CreateQtPartControl(QWidget *parent )
 {   
     m_Controls.setupUi( parent );
     TestHandler();
 
     SetPluginDirectory();
     SetDatabaseDirectory("DatabaseDirectory");
     SetListenerDirectory("ListenerDirectory");
     StartDicomDirectoryListener();
 
     m_Controls.m_ctkDICOMQueryRetrieveWidget->useProgressDialog(false);
+    m_Controls.StoreSCPLabel->setVisible(false);
 
     connect(m_Controls.externalDataWidget,SIGNAL(SignalAddDicomData(const QString&)),m_Controls.internalDataWidget,SLOT(StartDicomImport(const QString&)));
     connect(m_Controls.externalDataWidget,SIGNAL(SignalAddDicomData(const QStringList&)),m_Controls.internalDataWidget,SLOT(StartDicomImport(const QStringList&)));
     connect(m_Controls.externalDataWidget,SIGNAL(SignalDicomToDataManager(const QStringList&)),this,SLOT(OnViewButtonAddToDataManager(const QStringList&)));
     connect(m_Controls.externalDataWidget,SIGNAL(SignalChangePage(int)), this, SLOT(OnChangePage(int)));
 
     connect(m_Controls.internalDataWidget,SIGNAL(FinishedImport(const QString&)),this,SLOT(OnDicomImportFinished(const QString&)));
     connect(m_Controls.internalDataWidget,SIGNAL(FinishedImport(const QStringList&)),this,SLOT(OnDicomImportFinished(const QStringList&)));
     connect(m_Controls.internalDataWidget,SIGNAL(SignalDicomToDataManager(const QStringList&)),this,SLOT(OnViewButtonAddToDataManager(const QStringList&)));
 
     connect(m_Controls.CDButton, SIGNAL(clicked()), m_Controls.externalDataWidget, SLOT(OnFolderCDImport()));
     connect(m_Controls.FolderButton, SIGNAL(clicked()), m_Controls.externalDataWidget, SLOT(OnFolderCDImport()));
+    connect(m_Controls.FolderButton, SIGNAL(clicked()), this, SLOT(OnFolderCDImport()));
     connect(m_Controls.QueryRetrieveButton, SIGNAL(clicked()), this, SLOT(OnQueryRetrieve()));
     connect(m_Controls.LocalStorageButton, SIGNAL(clicked()), this, SLOT(OnLocalStorage()));
 
     //connect(m_Controls.radioButton,SIGNAL(clicked()),this,SLOT(StartStopStoreSCP()));
 }
 
 void QmitkDicomEditor::Init(berry::IEditorSite::Pointer site, berry::IEditorInput::Pointer input)
 {
     this->SetSite(site);
     this->SetInput(input);
 }
 
 void QmitkDicomEditor::SetFocus()
 {
 }
 
 berry::IPartListener::Events::Types QmitkDicomEditor::GetPartEventTypes() const
 {
     return Events::CLOSED | Events::HIDDEN | Events::VISIBLE;
 }
 
 void QmitkDicomEditor::OnQueryRetrieve()
 {
     OnChangePage(2);
-    StartStopStoreSCP();
+    QString storagePort = m_Controls.m_ctkDICOMQueryRetrieveWidget->getServerParameters()["StoragePort"].toString();
+    QString storageAET = m_Controls.m_ctkDICOMQueryRetrieveWidget->getServerParameters()["StorageAETitle"].toString();
+     if(!((builder.GetAETitle()->compare(storageAET,Qt::CaseSensitive)==0)&&
+         (builder.GetPort()->compare(storagePort,Qt::CaseSensitive)==0)))
+     {
+         StopStoreSCP();
+         StartStoreSCP();
+     }
+    m_Controls.StoreSCPLabel->setVisible(true);
+}
+
+void QmitkDicomEditor::OnFolderCDImport()
+{
+    m_Controls.StoreSCPLabel->setVisible(false);
 }
 
 void QmitkDicomEditor::OnLocalStorage()
 {
     OnChangePage(0);
+    m_Controls.StoreSCPLabel->setVisible(false);
 }
 
 void QmitkDicomEditor::OnChangePage(int page)
 {
     try{
         m_Controls.stackedWidget->setCurrentIndex(page);
     }catch(std::exception e){
         MITK_ERROR <<"error: "<< e.what();
         return;
     }
 }
 
 void QmitkDicomEditor::OnDicomImportFinished(const QString& /*path*/)
 {
 }
 
 void QmitkDicomEditor::OnDicomImportFinished(const QStringList& /*path*/)
 {
 }
 
 void QmitkDicomEditor::StartDicomDirectoryListener()
 {   
     if(!m_Thread->isRunning())
     {
         m_DicomDirectoryListener->SetDicomListenerDirectory(m_ListenerDirectory);
         connect(m_DicomDirectoryListener,SIGNAL(SignalAddDicomData(const QStringList&)),m_Controls.internalDataWidget,SLOT(StartDicomImport(const QStringList&)),Qt::DirectConnection);
         connect(m_Controls.internalDataWidget,SIGNAL(FinishedImport(const QStringList&)),m_DicomDirectoryListener,SLOT(OnDicomImportFinished(const QStringList&)),Qt::DirectConnection);
         m_DicomDirectoryListener->moveToThread(m_Thread);
         m_Thread->start();
     }
 }
 
 //TODO Remove
 void QmitkDicomEditor::TestHandler()
 {
     m_Handler = new DicomEventHandler();
     m_Handler->SubscribeSlots();
 }
 
 void QmitkDicomEditor::OnViewButtonAddToDataManager(const QStringList& eventProperties)
 {
     ctkDictionary properties;
     properties["PatientName"] = eventProperties.at(0);
     properties["StudyUID"] = eventProperties.at(1);
     properties["StudyName"] = eventProperties.at(2);
     properties["SeriesUID"] = eventProperties.at(3);
     properties["SeriesName"] = eventProperties.at(4);
     properties["Path"] = eventProperties.at(5);
 
     m_Publisher->PublishSignals(mitk::PluginActivator::getContext());
     m_Publisher->AddSeriesToDataManagerEvent(properties);
 }
 
 
 void QmitkDicomEditor::StartStoreSCP()
 {
     QString storagePort = m_Controls.m_ctkDICOMQueryRetrieveWidget->getServerParameters()["StoragePort"].toString();
     QString storageAET = m_Controls.m_ctkDICOMQueryRetrieveWidget->getServerParameters()["StorageAETitle"].toString();
     builder.AddPort(storagePort)->AddAETitle(storageAET)->AddTransferSyntax()->AddOtherNetworkOptions()->AddMode()->AddOutputDirectory(m_ListenerDirectory);
     m_StoreSCPLauncher = new QmitkStoreSCPLauncher(&builder);
     m_StoreSCPLauncher->StartStoreSCP();
-    m_Controls.radioButton->setChecked(true);
-    m_Controls.radioButton->setText(storageAET+QString(" ")+storagePort);
+    m_Controls.StoreSCPLabel->setText("Storage provider is running on port: "+storagePort);
 
 }
 
 
 void QmitkDicomEditor::StopStoreSCP()
 {
         delete m_StoreSCPLauncher;
-        m_Controls.radioButton->setChecked(false);
-        m_Controls.radioButton->setText(QString("Storage service provider is not running!"));
-}
-
-void QmitkDicomEditor::StartStopStoreSCP()
-{
-    QString storagePort = m_Controls.m_ctkDICOMQueryRetrieveWidget->getServerParameters()["StoragePort"].toString();
-    QString storageAET = m_Controls.m_ctkDICOMQueryRetrieveWidget->getServerParameters()["StorageAETitle"].toString();
-
-    if(!((builder.GetAETitle()->compare(storageAET,Qt::CaseSensitive)==0)&&
-        (builder.GetPort()->compare(storagePort,Qt::CaseSensitive)==0)))
-    {
-        if(m_Controls.radioButton->isChecked())
-        {
-            StopStoreSCP();
-            StartStoreSCP();
-        }else{
-            StartStoreSCP();
-        }
-    }   
+        m_Controls.StoreSCPLabel->setText(QString("Storage service provider is not running!"));
 }
 
 void QmitkDicomEditor::SetPluginDirectory()
 {
   m_PluginDirectory = mitk::PluginActivator::getContext()->getDataFile("").absolutePath();
   m_PluginDirectory.append("/");
 }
 
 void QmitkDicomEditor::SetDatabaseDirectory(const QString& databaseDirectory)
 {
     m_DatabaseDirectory.clear();
     m_DatabaseDirectory.append(m_PluginDirectory);
     m_DatabaseDirectory.append(databaseDirectory);
     m_Controls.internalDataWidget->SetDatabaseDirectory(m_DatabaseDirectory);
 }
 
 void QmitkDicomEditor::SetListenerDirectory(const QString& listenerDirectory)
 {
     m_ListenerDirectory.clear();
     m_ListenerDirectory.append(m_PluginDirectory);
     m_ListenerDirectory.append(listenerDirectory);
 }
diff --git a/Plugins/org.mitk.gui.qt.dicom/src/internal/QmitkDicomEditor.h b/Plugins/org.mitk.gui.qt.dicom/src/internal/QmitkDicomEditor.h
index b3113fdb46..6b87a94cb7 100644
--- a/Plugins/org.mitk.gui.qt.dicom/src/internal/QmitkDicomEditor.h
+++ b/Plugins/org.mitk.gui.qt.dicom/src/internal/QmitkDicomEditor.h
@@ -1,136 +1,135 @@
 /*=========================================================================
 
 Program:   Medical Imaging & Interaction Toolkit
 Language:  C++
 Date:      $Date$
 Version:   $Revision$
 
 Copyright (c) German Cancer Research Center, Division of Medical and
 Biological Informatics. All rights reserved.
 See MITKCopyright.txt or http://www.mitk.org/copyright.html for details.
 
 This software is distributed WITHOUT ANY WARRANTY; without even
 the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
 PURPOSE.  See the above copyright notices for more information.
 
 =========================================================================*/
 
 
 #ifndef QmitkDicomEditor_h
 #define QmitkDicomEditor_h
 
 #include <berryISelectionListener.h>
 #include <berryQtEditorPart.h>
 #include <berryIPartListener.h>
 
 #include "ui_QmitkDicomEditorControls.h"
 #include "QmitkDicomDirectoryListener.h"
 #include "QmitkStoreSCPLauncher.h"
 #include "QmitkStoreSCPLauncherBuilder.h"
 #include "DicomEventHandler.h"
 #include "QmitkDicomDataEventPublisher.h"
 
 #include <QTextEdit>
 #include <QModelIndex>
 #include <QString>
 #include <QMap>
 #include <QVariant>
 #include <QStringList>
 #include <QThread>
 #include <QProcess>
 #include <QStringList>
 #include <org_mitk_gui_qt_dicom_Export.h>
 /*!
 \brief QmitkDicomEditor
 
 \warning  This class is not yet documented. Use "git blame" and ask the author to provide basic documentation.
 
 \sa QmitkFunctionality
 \ingroup ${plugin_target}_internal
 */
 class DICOM_EXPORT QmitkDicomEditor : public berry::QtEditorPart, virtual public berry::IPartListener
 {
     // this is needed for all Qt objects that should have a Qt meta-object
     // (everything that derives from QObject and wants to have signal/slots)
     Q_OBJECT
 
 public:
 
     berryObjectMacro(QmitkDicomEditor)
     static const std::string EDITOR_ID;
 
     QmitkDicomEditor();
 
     virtual ~QmitkDicomEditor();
 
     void Init(berry::IEditorSite::Pointer site, berry::IEditorInput::Pointer input);
 
     void SetFocus();
     void DoSave() {}
     void DoSaveAs() {}
     bool IsDirty() const { return false; }
     bool IsSaveAsAllowed() const { return false; }
     
 signals:
 
 
     protected slots:
 
-        /// \brief Called when StoreSCP shold be started or updated
-        void StartStopStoreSCP();
+        /// \brief Called when StoreSCP shold start
+        void StartStoreSCP();
+
+        /// \brief Called when StoreSCP should stop
+        void StopStoreSCP();
 
         /// \brief Called when import is finished
         void OnDicomImportFinished(const QString& path);
 
         /// \brief Called when import is finished
         void OnDicomImportFinished(const QStringList& path);
 
         /// \brief Called when Query Retrieve or Import Folder was clicked.
         void OnQueryRetrieve();
 
         /// \brief Called when LocalStorageButton was clicked.
         void OnLocalStorage();
 
+        /// \brief Called when FolderCDButton was clicked.
+        void OnFolderCDImport();
+
         /// \brief Called when view button is clicked. Sends out an event for adding the current selected file to the mitkDataStorage.
         void OnViewButtonAddToDataManager(const QStringList& eventProperties);
 
         void StartDicomDirectoryListener();
 
         void OnChangePage(int);
 
         void TestHandler();
 
         void SetDatabaseDirectory(const QString& databaseDirectory);
     
         void SetListenerDirectory(const QString& listenerDirectory);
 
 protected:
 
-    /// \brief Called when StoreSCP shold start
-    void StartStoreSCP();
-
-    /// \brief Called when StoreSCP should stop
-    void StopStoreSCP();
-
     void CreateQtPartControl(QWidget *parent);
 
     void SetPluginDirectory();
 
     Events::Types GetPartEventTypes() const;
 
     Ui::QmitkDicomEditorControls m_Controls;
 
     QThread* m_Thread;
     QmitkDicomDirectoryListener* m_DicomDirectoryListener;
     QmitkStoreSCPLauncherBuilder builder;
     QmitkStoreSCPLauncher* m_StoreSCPLauncher;
     DicomEventHandler* m_Handler;
     QmitkDicomDataEventPublisher* m_Publisher;
     QString m_PluginDirectory;
     QString m_ListenerDirectory;
     QString m_DatabaseDirectory;
 
 };
 
 #endif // QmitkDicomEditor_h
-
diff --git a/Plugins/org.mitk.gui.qt.dicom/src/internal/QmitkDicomEditorControls.ui b/Plugins/org.mitk.gui.qt.dicom/src/internal/QmitkDicomEditorControls.ui
index 38fe91a59b..c4d1a85be9 100644
--- a/Plugins/org.mitk.gui.qt.dicom/src/internal/QmitkDicomEditorControls.ui
+++ b/Plugins/org.mitk.gui.qt.dicom/src/internal/QmitkDicomEditorControls.ui
@@ -1,163 +1,157 @@
 <?xml version="1.0" encoding="UTF-8"?>
 <ui version="4.0">
  <class>QmitkDicomEditorControls</class>
  <widget class="QWidget" name="QmitkDicomEditorControls">
   <property name="geometry">
    <rect>
     <x>0</x>
     <y>0</y>
     <width>752</width>
     <height>696</height>
    </rect>
   </property>
   <property name="minimumSize">
    <size>
     <width>0</width>
     <height>0</height>
    </size>
   </property>
   <property name="windowTitle">
    <string>QmitkTemplate</string>
   </property>
   <layout class="QVBoxLayout" name="verticalLayout_8">
    <item>
     <widget class="QFrame" name="frame">
      <property name="frameShape">
       <enum>QFrame::StyledPanel</enum>
      </property>
      <property name="frameShadow">
       <enum>QFrame::Raised</enum>
      </property>
      <layout class="QVBoxLayout" name="verticalLayout_2">
       <item>
        <widget class="QFrame" name="frame_3">
         <property name="frameShape">
          <enum>QFrame::StyledPanel</enum>
         </property>
         <property name="frameShadow">
          <enum>QFrame::Plain</enum>
         </property>
         <layout class="QHBoxLayout" name="horizontalLayout_6">
          <item>
           <widget class="QPushButton" name="LocalStorageButton">
            <property name="text">
             <string>Local Storage</string>
            </property>
           </widget>
          </item>
          <item>
           <widget class="QPushButton" name="CDButton">
            <property name="text">
             <string>Import CD</string>
            </property>
           </widget>
          </item>
          <item>
           <widget class="QPushButton" name="FolderButton">
            <property name="text">
             <string>Import Folder</string>
            </property>
           </widget>
          </item>
          <item>
           <widget class="QPushButton" name="QueryRetrieveButton">
            <property name="text">
             <string>Query Retrieve</string>
            </property>
           </widget>
          </item>
          <item>
           <spacer name="horizontalSpacer_5">
            <property name="orientation">
             <enum>Qt::Horizontal</enum>
            </property>
            <property name="sizeHint" stdset="0">
             <size>
              <width>40</width>
              <height>20</height>
             </size>
            </property>
           </spacer>
          </item>
         </layout>
        </widget>
       </item>
       <item>
        <widget class="QStackedWidget" name="stackedWidget">
         <property name="enabled">
          <bool>true</bool>
         </property>
         <property name="currentIndex">
          <number>0</number>
         </property>
         <widget class="QWidget" name="page">
          <layout class="QVBoxLayout" name="verticalLayout_3">
           <item>
            <widget class="QmitkDicomLocalStorageWidget" name="internalDataWidget" native="true"/>
           </item>
          </layout>
         </widget>
         <widget class="QWidget" name="importWidgetPage">
          <layout class="QVBoxLayout" name="verticalLayout_9">
           <item>
            <widget class="QmitkDicomExternalDataWidget" name="externalDataWidget" native="true"/>
           </item>
          </layout>
         </widget>
         <widget class="QWidget" name="queryRetrieveWidgetPage">
          <layout class="QVBoxLayout" name="verticalLayout_12">
           <item>
            <widget class="ctkDICOMQueryRetrieveWidget" name="m_ctkDICOMQueryRetrieveWidget" native="true"/>
           </item>
          </layout>
         </widget>
        </widget>
       </item>
       <item>
-       <widget class="QRadioButton" name="radioButton">
-        <property name="toolTip">
-         <string>Switch the storage service provider (STORESCP) on or of.</string>
-        </property>
+       <widget class="QLabel" name="StoreSCPLabel">
         <property name="text">
-         <string>Storage provider is not running! </string>
-        </property>
-        <property name="checkable">
-         <bool>true</bool>
+         <string>Storage provider is not running!</string>
         </property>
-        <property name="checked">
-         <bool>false</bool>
+        <property name="textInteractionFlags">
+         <set>Qt::NoTextInteraction</set>
         </property>
        </widget>
       </item>
      </layout>
     </widget>
    </item>
   </layout>
  </widget>
  <layoutdefault spacing="6" margin="11"/>
  <customwidgets>
   <customwidget>
    <class>ctkDICOMQueryRetrieveWidget</class>
    <extends>QWidget</extends>
    <header>ctkDICOMQueryRetrieveWidget.h</header>
    <container>1</container>
   </customwidget>
   <customwidget>
    <class>QmitkDicomLocalStorageWidget</class>
    <extends>QWidget</extends>
    <header>Qmitk/QmitkDicomLocalStorageWidget.h</header>
    <container>1</container>
   </customwidget>
   <customwidget>
    <class>QmitkDicomExternalDataWidget</class>
    <extends>QWidget</extends>
    <header>Qmitk/QmitkDicomExternalDataWidget.h</header>
    <container>1</container>
   </customwidget>
  </customwidgets>
  <resources/>
  <connections/>
  <slots>
   <slot>OnChangePage(int)</slot>
  </slots>
 </ui>
diff --git a/Plugins/org.mitk.gui.qt.ext/src/QmitkExtWorkbenchWindowAdvisor.cpp b/Plugins/org.mitk.gui.qt.ext/src/QmitkExtWorkbenchWindowAdvisor.cpp
index 98cfce802d..882ed37891 100644
--- a/Plugins/org.mitk.gui.qt.ext/src/QmitkExtWorkbenchWindowAdvisor.cpp
+++ b/Plugins/org.mitk.gui.qt.ext/src/QmitkExtWorkbenchWindowAdvisor.cpp
@@ -1,1153 +1,1153 @@
 /*===================================================================
 
 The Medical Imaging Interaction Toolkit (MITK)
 
 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 "QmitkExtWorkbenchWindowAdvisor.h"
 #include "QmitkExtActionBarAdvisor.h"
 
 #include <QMenu>
 #include <QMenuBar>
 #include <QMainWindow>
 #include <QStatusBar>
 #include <QString>
 #include <QFile>
 #include <QRegExp>
 #include <QTextStream>
 #include <QSettings>
 
 #include <ctkPluginException.h>
 #include <service/event/ctkEventAdmin.h>
 
 #include <berryPlatform.h>
 #include <berryPlatformUI.h>
 #include <berryIWorkbenchWindow.h>
 #include <berryIWorkbenchPage.h>
 #include <berryIPreferencesService.h>
 #include <berryIPerspectiveRegistry.h>
 #include <berryIPerspectiveDescriptor.h>
 #include <berryIWorkbenchPartConstants.h>
 
 #include <internal/berryQtShowViewAction.h>
 #include <internal/berryQtOpenPerspectiveAction.h>
 
 #include <QmitkFileOpenAction.h>
 #include <QmitkExtFileSaveProjectAction.h>
 #include <QmitkFileExitAction.h>
 #include <QmitkCloseProjectAction.h>
 #include <QmitkDefaultDropTargetListener.h>
 #include <QmitkStatusBar.h>
 #include <QmitkProgressBar.h>
 #include <QmitkMemoryUsageIndicatorView.h>
 #include <QmitkPreferencesDialog.h>
 #include <QmitkOpenDicomEditorAction.h>
 
 #include <itkConfigure.h>
 #include <vtkConfigure.h>
 #include <mitkVersion.h>
 
 // UGLYYY
 #include "internal/QmitkExtWorkbenchWindowAdvisorHack.h"
 #include "internal/QmitkCommonExtPlugin.h"
 #include "mitkUndoController.h"
 #include "mitkVerboseLimitedLinearUndo.h"
 #include <QToolBar>
 #include <QMessageBox>
 #include <QLabel>
 #include <QmitkAboutDialog/QmitkAboutDialog.h>
 
 QmitkExtWorkbenchWindowAdvisorHack
 * QmitkExtWorkbenchWindowAdvisorHack::undohack =
 new QmitkExtWorkbenchWindowAdvisorHack();
 
 QString QmitkExtWorkbenchWindowAdvisor::QT_SETTINGS_FILENAME = "QtSettings.ini";
 
 class PartListenerForTitle: public berry::IPartListener
 {
 public:
 
  PartListenerForTitle(QmitkExtWorkbenchWindowAdvisor* wa) :
    windowAdvisor(wa)
    {
    }
 
    Events::Types GetPartEventTypes() const
    {
     return Events::ACTIVATED | Events::BROUGHT_TO_TOP | Events::CLOSED
      | Events::HIDDEN | Events::VISIBLE;
    }
 
    void PartActivated(berry::IWorkbenchPartReference::Pointer ref)
    {
     if (ref.Cast<berry::IEditorReference> ())
     {
      windowAdvisor->UpdateTitle(false);
     }
    }
 
    void PartBroughtToTop(berry::IWorkbenchPartReference::Pointer ref)
    {
     if (ref.Cast<berry::IEditorReference> ())
     {
      windowAdvisor->UpdateTitle(false);
     }
    }
 
    void PartClosed(berry::IWorkbenchPartReference::Pointer /*ref*/)
    {
     windowAdvisor->UpdateTitle(false);
    }
 
    void PartHidden(berry::IWorkbenchPartReference::Pointer ref)
    {
     if (!windowAdvisor->lastActiveEditor.Expired() &&
      ref->GetPart(false) == windowAdvisor->lastActiveEditor.Lock())
     {
      windowAdvisor->UpdateTitle(true);
     }
    }
 
    void PartVisible(berry::IWorkbenchPartReference::Pointer ref)
    {
     if (!windowAdvisor->lastActiveEditor.Expired() &&
      ref->GetPart(false) == windowAdvisor->lastActiveEditor.Lock())
     {
      windowAdvisor->UpdateTitle(false);
     }
    }
 
 private:
  QmitkExtWorkbenchWindowAdvisor* windowAdvisor;
 
 };
 
 class PartListenerForImageNavigator: public berry::IPartListener
 {
 public:
 
  PartListenerForImageNavigator(QAction* act) :
    imageNavigatorAction(act)
    {
    }
 
    Events::Types GetPartEventTypes() const
    {
     return Events::OPENED | Events::CLOSED | Events::HIDDEN |
      Events::VISIBLE;
    }
 
    void PartOpened(berry::IWorkbenchPartReference::Pointer ref)
    {
     if (ref->GetId()=="org.mitk.views.imagenavigator")
     {
      imageNavigatorAction->setChecked(true);
     }
    }
 
    void PartClosed(berry::IWorkbenchPartReference::Pointer ref)
    {
     if (ref->GetId()=="org.mitk.views.imagenavigator")
     {
      imageNavigatorAction->setChecked(false);
     }
    }
 
    void PartVisible(berry::IWorkbenchPartReference::Pointer ref)
    {
     if (ref->GetId()=="org.mitk.views.imagenavigator")
     {
      imageNavigatorAction->setChecked(true);
     }
    }
 
    void PartHidden(berry::IWorkbenchPartReference::Pointer ref)
    {
     if (ref->GetId()=="org.mitk.views.imagenavigator")
     {
      imageNavigatorAction->setChecked(false);
     }
    }
 
 private:
  QAction* imageNavigatorAction;
 
 };
 
 class PerspectiveListenerForTitle: public berry::IPerspectiveListener
 {
 public:
 
  PerspectiveListenerForTitle(QmitkExtWorkbenchWindowAdvisor* wa) :
    windowAdvisor(wa), perspectivesClosed(false)
    {
    }
 
    Events::Types GetPerspectiveEventTypes() const
    {
     return Events::ACTIVATED | Events::SAVED_AS | Events::DEACTIVATED
      // remove the following line when command framework is finished
      | Events::CLOSED | Events::OPENED;
    }
 
    void PerspectiveActivated(berry::IWorkbenchPage::Pointer /*page*/,
     berry::IPerspectiveDescriptor::Pointer /*perspective*/)
    {
     windowAdvisor->UpdateTitle(false);
    }
 
    void PerspectiveSavedAs(berry::IWorkbenchPage::Pointer /*page*/,
     berry::IPerspectiveDescriptor::Pointer /*oldPerspective*/,
     berry::IPerspectiveDescriptor::Pointer /*newPerspective*/)
    {
     windowAdvisor->UpdateTitle(false);
    }
 
    void PerspectiveDeactivated(berry::IWorkbenchPage::Pointer /*page*/,
     berry::IPerspectiveDescriptor::Pointer /*perspective*/)
    {
     windowAdvisor->UpdateTitle(false);
    }
 
    void PerspectiveOpened(berry::IWorkbenchPage::Pointer /*page*/,
     berry::IPerspectiveDescriptor::Pointer /*perspective*/)
    {
     if (perspectivesClosed)
     {
      QListIterator<QAction*> i(windowAdvisor->viewActions);
      while (i.hasNext())
      {
       i.next()->setEnabled(true);
      }
      windowAdvisor->openDicomEditorAction->setEnabled(true);
      windowAdvisor->fileSaveProjectAction->setEnabled(true);
      windowAdvisor->closeProjectAction->setEnabled(true);
      windowAdvisor->undoAction->setEnabled(true);
      windowAdvisor->redoAction->setEnabled(true);
      windowAdvisor->imageNavigatorAction->setEnabled(true);
      windowAdvisor->resetPerspAction->setEnabled(true);
      if( windowAdvisor->GetShowClosePerspectiveMenuItem() )
      {
        windowAdvisor->closePerspAction->setEnabled(true);
      }   
     }
 
     perspectivesClosed = false;
    }
 
    void PerspectiveClosed(berry::IWorkbenchPage::Pointer /*page*/,
     berry::IPerspectiveDescriptor::Pointer /*perspective*/)
    {
     berry::IWorkbenchWindow::Pointer wnd = windowAdvisor->GetWindowConfigurer()->GetWindow();
     bool allClosed = true;
     if (wnd->GetActivePage())
     {
      std::vector<berry::IPerspectiveDescriptor::Pointer> perspectives(wnd->GetActivePage()->GetOpenPerspectives());
      allClosed = perspectives.empty();
     }
 
     if (allClosed)
     {
      perspectivesClosed = true;
 
      QListIterator<QAction*> i(windowAdvisor->viewActions);
      while (i.hasNext())
      {
       i.next()->setEnabled(false);
      }
 
      windowAdvisor->openDicomEditorAction->setEnabled(false);
      windowAdvisor->fileSaveProjectAction->setEnabled(false);
      windowAdvisor->closeProjectAction->setEnabled(false);
      windowAdvisor->undoAction->setEnabled(false);
      windowAdvisor->redoAction->setEnabled(false);
      windowAdvisor->imageNavigatorAction->setEnabled(false);
      windowAdvisor->resetPerspAction->setEnabled(false);
      if( windowAdvisor->GetShowClosePerspectiveMenuItem() )
      {
        windowAdvisor->closePerspAction->setEnabled(false);
      }     
     }
    }
 
 private:
  QmitkExtWorkbenchWindowAdvisor* windowAdvisor;
  bool perspectivesClosed;
 };
 
 class PerspectiveListenerForMenu: public berry::IPerspectiveListener
 {
 public:
 
  PerspectiveListenerForMenu(QmitkExtWorkbenchWindowAdvisor* wa) :
    windowAdvisor(wa)
    {
    }
 
    Events::Types GetPerspectiveEventTypes() const
    {
     return Events::ACTIVATED | Events::DEACTIVATED;
    }
 
    void PerspectiveActivated(berry::IWorkbenchPage::Pointer /*page*/,
     berry::IPerspectiveDescriptor::Pointer perspective)
    {
      QAction* action = windowAdvisor->mapPerspIdToAction[perspective->GetId()];
      if (action)
      {
        action->setChecked(true);
      }
    }
 
    void PerspectiveDeactivated(berry::IWorkbenchPage::Pointer /*page*/,
     berry::IPerspectiveDescriptor::Pointer perspective)
    {
      QAction* action = windowAdvisor->mapPerspIdToAction[perspective->GetId()];
      if (action)
      {
        action->setChecked(false);
      }
    }
 
 private:
  QmitkExtWorkbenchWindowAdvisor* windowAdvisor;
 };
 
 
 
 QmitkExtWorkbenchWindowAdvisor::QmitkExtWorkbenchWindowAdvisor(berry::WorkbenchAdvisor* wbAdvisor,
                   berry::IWorkbenchWindowConfigurer::Pointer configurer) :
 berry::WorkbenchWindowAdvisor(configurer),
 lastInput(0),
 wbAdvisor(wbAdvisor),
 showViewToolbar(true),
 showPerspectiveToolbar(false),
 showVersionInfo(true),
 showMitkVersionInfo(true),
 showViewMenuItem(true),
 showNewWindowMenuItem(false),
 showClosePerspectiveMenuItem(true),
 dropTargetListener(new QmitkDefaultDropTargetListener)
 {
  productName = berry::Platform::GetConfiguration().getString("application.baseName");
 }
 
 berry::ActionBarAdvisor::Pointer QmitkExtWorkbenchWindowAdvisor::CreateActionBarAdvisor(
  berry::IActionBarConfigurer::Pointer configurer)
 {
  berry::ActionBarAdvisor::Pointer actionBarAdvisor(
   new QmitkExtActionBarAdvisor(configurer));
  return actionBarAdvisor;
 }
 
 void* QmitkExtWorkbenchWindowAdvisor::CreateEmptyWindowContents(void* parent)
 {
  QWidget* parentWidget = static_cast<QWidget*>(parent);
  QLabel* label = new QLabel(parentWidget);
  label->setText("<b>No perspectives are open. Open a perspective in the <i>Window->Open Perspective</i> menu.</b>");
  label->setContentsMargins(10,10,10,10);
  label->setAlignment(Qt::AlignTop);
  label->setEnabled(false);
  parentWidget->layout()->addWidget(label);
  return label;
 }
 
 void QmitkExtWorkbenchWindowAdvisor::ShowClosePerspectiveMenuItem(bool show)
 {
  showClosePerspectiveMenuItem = show;
 }
 
 bool QmitkExtWorkbenchWindowAdvisor::GetShowClosePerspectiveMenuItem()
 {
   return showClosePerspectiveMenuItem;
 }
 
 void QmitkExtWorkbenchWindowAdvisor::ShowNewWindowMenuItem(bool show)
 {
  showNewWindowMenuItem = show;
 }
 
 void QmitkExtWorkbenchWindowAdvisor::ShowViewToolbar(bool show)
 {
  showViewToolbar = show;
 }
 
 void QmitkExtWorkbenchWindowAdvisor::ShowViewMenuItem(bool show)
 {
  showViewMenuItem = show;
 }
 
 void QmitkExtWorkbenchWindowAdvisor::ShowPerspectiveToolbar(bool show)
 {
  showPerspectiveToolbar = show;
 }
 
 void QmitkExtWorkbenchWindowAdvisor::ShowVersionInfo(bool show)
 {
  showVersionInfo = show;
 }
 
 void QmitkExtWorkbenchWindowAdvisor::ShowMitkVersionInfo(bool show)
 {
  showMitkVersionInfo = show;
 }
 
 void QmitkExtWorkbenchWindowAdvisor::SetProductName(const std::string& product)
 {
  productName = product;
 }
 
 void QmitkExtWorkbenchWindowAdvisor::SetWindowIcon(const std::string& wndIcon)
 {
  windowIcon = wndIcon;
 }
 
 void QmitkExtWorkbenchWindowAdvisor::PostWindowCreate()
 {
  // very bad hack...
  berry::IWorkbenchWindow::Pointer window =
   this->GetWindowConfigurer()->GetWindow();
  QMainWindow* mainWindow =
   static_cast<QMainWindow*> (window->GetShell()->GetControl());
 
  if (!windowIcon.empty())
  {
   mainWindow->setWindowIcon(QIcon(QString::fromStdString(windowIcon)));
  }
  mainWindow->setContextMenuPolicy(Qt::PreventContextMenu);
 
  /*mainWindow->setStyleSheet("color: white;"
  "background-color: #808080;"
  "selection-color: #659EC7;"
  "selection-background-color: #808080;"
  " QMenuBar {"
  "background-color: #808080; }");*/
 
  // ==== Application menu ============================
  QMenuBar* menuBar = mainWindow->menuBar();
  menuBar->setContextMenuPolicy(Qt::PreventContextMenu);
 
  QMenu* fileMenu = menuBar->addMenu("&File");
  fileMenu->setObjectName("FileMenu");
 
  QAction* fileOpenAction = new QmitkFileOpenAction(QIcon(":/org.mitk.gui.qt.ext/Load_48.png"), window);
  fileMenu->addAction(fileOpenAction);
  fileSaveProjectAction = new QmitkExtFileSaveProjectAction(window);
  fileSaveProjectAction->setIcon(QIcon(":/org.mitk.gui.qt.ext/Save_48.png"));
  fileMenu->addAction(fileSaveProjectAction);
  closeProjectAction = new QmitkCloseProjectAction(window);
  closeProjectAction->setIcon(QIcon(":/org.mitk.gui.qt.ext/Remove_48.png"));
  fileMenu->addAction(closeProjectAction);
  fileMenu->addSeparator();
  QAction* fileExitAction = new QmitkFileExitAction(window);
  fileExitAction->setObjectName("QmitkFileExitAction");
  fileMenu->addAction(fileExitAction);
 
  openDicomEditorAction = new QmitkOpenDicomEditorAction(window);
- fileMenu->addAction(openDicomEditorAction);
+ //fileMenu->addAction(openDicomEditorAction);
 
  berry::IViewRegistry* viewRegistry =
   berry::PlatformUI::GetWorkbench()->GetViewRegistry();
  const std::vector<berry::IViewDescriptor::Pointer>& viewDescriptors =
   viewRegistry->GetViews();
 
  // another bad hack to get an edit/undo menu...
  QMenu* editMenu = menuBar->addMenu("&Edit");
  undoAction = editMenu->addAction(QIcon(":/org.mitk.gui.qt.ext/Undo_48.png"),
   "&Undo",
   QmitkExtWorkbenchWindowAdvisorHack::undohack, SLOT(onUndo()),
   QKeySequence("CTRL+Z"));
  undoAction->setToolTip("Undo the last action (not supported by all modules)");
  redoAction = editMenu->addAction(QIcon(":/org.mitk.gui.qt.ext/Redo_48.png")
   , "&Redo",
   QmitkExtWorkbenchWindowAdvisorHack::undohack, SLOT(onRedo()),
   QKeySequence("CTRL+Y"));
  redoAction->setToolTip("execute the last action that was undone again (not supported by all modules)");
 
  imageNavigatorAction = new QAction(QIcon(":/org.mitk.gui.qt.ext/Slider.png"), "&Image Navigator", NULL);
  bool imageNavigatorViewFound = window->GetWorkbench()->GetViewRegistry()->Find("org.mitk.views.imagenavigator");
  if (imageNavigatorViewFound)
  {
    QObject::connect(imageNavigatorAction, SIGNAL(triggered(bool)), QmitkExtWorkbenchWindowAdvisorHack::undohack, SLOT(onImageNavigator()));
    imageNavigatorAction->setCheckable(true);
 
    // add part listener for image navigator
    imageNavigatorPartListener = new PartListenerForImageNavigator(imageNavigatorAction);
    window->GetPartService()->AddPartListener(imageNavigatorPartListener);
    berry::IViewPart::Pointer imageNavigatorView =
        window->GetActivePage()->FindView("org.mitk.views.imagenavigator");
    imageNavigatorAction->setChecked(false);
    if (imageNavigatorView)
    {
      bool isImageNavigatorVisible = window->GetActivePage()->IsPartVisible(imageNavigatorView);
      if (isImageNavigatorVisible)
        imageNavigatorAction->setChecked(true);
    }
    imageNavigatorAction->setToolTip("Open image navigator for navigating through image");
  }
 
  // toolbar for showing file open, undo, redo and other main actions
  QToolBar* mainActionsToolBar = new QToolBar;
  mainActionsToolBar->setContextMenuPolicy(Qt::PreventContextMenu);
 #ifdef __APPLE__
  mainActionsToolBar->setToolButtonStyle ( Qt::ToolButtonTextUnderIcon );
 #else
  mainActionsToolBar->setToolButtonStyle ( Qt::ToolButtonTextBesideIcon );
 #endif
 
  mainActionsToolBar->addAction(fileOpenAction);
  mainActionsToolBar->addAction(fileSaveProjectAction);
  mainActionsToolBar->addAction(closeProjectAction);
  mainActionsToolBar->addAction(undoAction);
  mainActionsToolBar->addAction(redoAction);
   mainActionsToolBar->addAction(openDicomEditorAction);
  if (imageNavigatorViewFound)
  {
    mainActionsToolBar->addAction(imageNavigatorAction);
  }
  mainWindow->addToolBar(mainActionsToolBar);
 
 #ifdef __APPLE__
  mainWindow->setUnifiedTitleAndToolBarOnMac(true);
 #endif
 
  // ==== Window Menu ==========================
  QMenu* windowMenu = menuBar->addMenu("Window");
  if (showNewWindowMenuItem)
  {
    windowMenu->addAction("&New Window", QmitkExtWorkbenchWindowAdvisorHack::undohack, SLOT(onNewWindow()));
    windowMenu->addSeparator();
  }
 
  QMenu* perspMenu = windowMenu->addMenu("&Open Perspective");
 
  QMenu* viewMenu;
  if (showViewMenuItem)
  {
    viewMenu = windowMenu->addMenu("Show &View");
    viewMenu->setObjectName("Show View");
  }
  windowMenu->addSeparator();
  resetPerspAction = windowMenu->addAction("&Reset Perspective",
   QmitkExtWorkbenchWindowAdvisorHack::undohack, SLOT(onResetPerspective()));
 
  if(showClosePerspectiveMenuItem)
   closePerspAction = windowMenu->addAction("&Close Perspective", QmitkExtWorkbenchWindowAdvisorHack::undohack, SLOT(onClosePerspective()));
 
  windowMenu->addSeparator();
  windowMenu->addAction("&Preferences...",
   QmitkExtWorkbenchWindowAdvisorHack::undohack, SLOT(onEditPreferences()),
   QKeySequence("CTRL+P"));
 
  // fill perspective menu
  berry::IPerspectiveRegistry* perspRegistry =
   window->GetWorkbench()->GetPerspectiveRegistry();
  QActionGroup* perspGroup = new QActionGroup(menuBar);
 
  std::vector<berry::IPerspectiveDescriptor::Pointer> perspectives(
   perspRegistry->GetPerspectives());
 
     bool skip = false;
     for (std::vector<berry::IPerspectiveDescriptor::Pointer>::iterator perspIt =
       perspectives.begin(); perspIt != perspectives.end(); ++perspIt)
     {
 
       // if perspectiveExcludeList is set, it contains the id-strings of perspectives, which
       // should not appear as an menu-entry in the perspective menu
       if (perspectiveExcludeList.size() > 0)
       {
         for (unsigned int i=0; i<perspectiveExcludeList.size(); i++)
         {
           if (perspectiveExcludeList.at(i) == (*perspIt)->GetId())
           {
             skip = true;
             break;
           }
         }
         if (skip)
         {
           skip = false;
           continue;
         }
       }
 
       QAction* perspAction = new berry::QtOpenPerspectiveAction(window,
         *perspIt, perspGroup);
       mapPerspIdToAction.insert(std::make_pair((*perspIt)->GetId(), perspAction));
     }
  perspMenu->addActions(perspGroup->actions());
 
  // sort elements (converting vector to map...)
  std::vector<berry::IViewDescriptor::Pointer>::const_iterator iter;
  std::map<std::string, berry::IViewDescriptor::Pointer> VDMap;
 
  skip = false;
  for (iter = viewDescriptors.begin(); iter != viewDescriptors.end(); ++iter)
  {
 
    // if viewExcludeList is set, it contains the id-strings of view, which
    // should not appear as an menu-entry in the menu
    if (viewExcludeList.size() > 0)
    {
      for (unsigned int i=0; i<viewExcludeList.size(); i++)
      {
        if (viewExcludeList.at(i) == (*iter)->GetId())
        {
          skip = true;
          break;
        }
      }
      if (skip)
      {
        skip = false;
        continue;
      }
    }
 
   if ((*iter)->GetId() == "org.blueberry.ui.internal.introview")
    continue;
   if ((*iter)->GetId() == "org.mitk.views.imagenavigator")
    continue;
 
   std::pair<std::string, berry::IViewDescriptor::Pointer> p(
    (*iter)->GetLabel(), (*iter));
   VDMap.insert(p);
  }
  // ==================================================
 
   // ==== Perspective Toolbar ==================================
  QToolBar* qPerspectiveToolbar = new QToolBar;
 
  if (showPerspectiveToolbar)
  {
   qPerspectiveToolbar->addActions(perspGroup->actions());
   mainWindow->addToolBar(qPerspectiveToolbar);
  }
  else
   delete qPerspectiveToolbar;
 
  // ==== View Toolbar ==================================
  QToolBar* qToolbar = new QToolBar;
 
  std::map<std::string, berry::IViewDescriptor::Pointer>::const_iterator
   MapIter;
  for (MapIter = VDMap.begin(); MapIter != VDMap.end(); ++MapIter)
  {
   berry::QtShowViewAction* viewAction = new berry::QtShowViewAction(window,
    (*MapIter).second);
   viewActions.push_back(viewAction);
   if(showViewMenuItem)
     viewMenu->addAction(viewAction);
   if (showViewToolbar)
   {
    qToolbar->addAction(viewAction);
   }
  }
 
  if (showViewToolbar)
  {
   mainWindow->addToolBar(qToolbar);
  }
  else
   delete qToolbar;
 
  QSettings settings(GetQSettingsFile(), QSettings::IniFormat);
  mainWindow->restoreState(settings.value("ToolbarPosition").toByteArray());
 
 
  // ====================================================
 
  // ===== Help menu ====================================
  QMenu* helpMenu = menuBar->addMenu("Help");
  helpMenu->addAction("&Welcome",this, SLOT(onIntro()));
  helpMenu->addAction("&Contents", this, SLOT(onHelpContents()));
   helpMenu->addAction("Context &Help",this, SLOT(onHelp()),  QKeySequence("F1"));
  helpMenu->addAction("&About",this, SLOT(onAbout()));
  // =====================================================
 
 
  QStatusBar* qStatusBar = new QStatusBar();
 
  //creating a QmitkStatusBar for Output on the QStatusBar and connecting it with the MainStatusBar
  QmitkStatusBar *statusBar = new QmitkStatusBar(qStatusBar);
  //disabling the SizeGrip in the lower right corner
  statusBar->SetSizeGripEnabled(false);
 
 
 
  QmitkProgressBar *progBar = new QmitkProgressBar();
 
  qStatusBar->addPermanentWidget(progBar, 0);
  progBar->hide();
 // progBar->AddStepsToDo(2);
 // progBar->Progress(1);
 
  mainWindow->setStatusBar(qStatusBar);
 
  QmitkMemoryUsageIndicatorView* memoryIndicator =
   new QmitkMemoryUsageIndicatorView();
  qStatusBar->addPermanentWidget(memoryIndicator, 0);
 }
 
 void QmitkExtWorkbenchWindowAdvisor::PreWindowOpen()
 {
  berry::IWorkbenchWindowConfigurer::Pointer configurer = GetWindowConfigurer();
 
  // show the shortcut bar and progress indicator, which are hidden by
  // default
  //configurer->SetShowPerspectiveBar(true);
  //configurer->SetShowFastViewBars(true);
  //configurer->SetShowProgressIndicator(true);
 
  //  // add the drag and drop support for the editor area
  //  configurer.addEditorAreaTransfer(EditorInputTransfer.getInstance());
  //  configurer.addEditorAreaTransfer(ResourceTransfer.getInstance());
  //  configurer.addEditorAreaTransfer(FileTransfer.getInstance());
  //  configurer.addEditorAreaTransfer(MarkerTransfer.getInstance());
  //  configurer.configureEditorAreaDropListener(new EditorAreaDropAdapter(
  //      configurer.getWindow()));
 
  this->HookTitleUpdateListeners(configurer);
 
  menuPerspectiveListener = new PerspectiveListenerForMenu(this);
  configurer->GetWindow()->AddPerspectiveListener(menuPerspectiveListener);
 
  configurer->AddEditorAreaTransfer(QStringList("text/uri-list"));
  configurer->ConfigureEditorAreaDropListener(dropTargetListener);
 }
 
 void QmitkExtWorkbenchWindowAdvisor::onIntro()
 {
   QmitkExtWorkbenchWindowAdvisorHack::undohack->onIntro();
 }
 
 void QmitkExtWorkbenchWindowAdvisor::onHelp()
 {
   QmitkExtWorkbenchWindowAdvisorHack::undohack->onHelp();
 }
 
 void QmitkExtWorkbenchWindowAdvisor::onHelpContents()
 {
   QmitkExtWorkbenchWindowAdvisorHack::undohack->onHelpContents();
 }
 
 void QmitkExtWorkbenchWindowAdvisor::onAbout()
 {
   QmitkExtWorkbenchWindowAdvisorHack::undohack->onAbout();
 }
 
 //--------------------------------------------------------------------------------
 // Ugly hack from here on. Feel free to delete when command framework
 // and undo buttons are done.
 //--------------------------------------------------------------------------------
 
 QmitkExtWorkbenchWindowAdvisorHack::QmitkExtWorkbenchWindowAdvisorHack() : QObject()
 {
 
 }
 
 QmitkExtWorkbenchWindowAdvisorHack::~QmitkExtWorkbenchWindowAdvisorHack()
 {
 
 }
 
 void QmitkExtWorkbenchWindowAdvisorHack::onUndo()
 {
  mitk::UndoModel* model = mitk::UndoController::GetCurrentUndoModel();
  if (model)
  {
   if (mitk::VerboseLimitedLinearUndo* verboseundo = dynamic_cast<mitk::VerboseLimitedLinearUndo*>( model ))
   {
    mitk::VerboseLimitedLinearUndo::StackDescription descriptions =
     verboseundo->GetUndoDescriptions();
    if (descriptions.size() >= 1)
    {
     MITK_INFO << "Undo " << descriptions.front().second;
    }
   }
   model->Undo();
  }
  else
  {
   MITK_ERROR << "No undo model instantiated";
  }
 }
 
 void QmitkExtWorkbenchWindowAdvisorHack::onRedo()
 {
  mitk::UndoModel* model = mitk::UndoController::GetCurrentUndoModel();
  if (model)
  {
   if (mitk::VerboseLimitedLinearUndo* verboseundo = dynamic_cast<mitk::VerboseLimitedLinearUndo*>( model ))
   {
    mitk::VerboseLimitedLinearUndo::StackDescription descriptions =
     verboseundo->GetRedoDescriptions();
    if (descriptions.size() >= 1)
    {
     MITK_INFO << "Redo " << descriptions.front().second;
    }
   }
   model->Redo();
  }
  else
  {
   MITK_ERROR << "No undo model instantiated";
  }
 }
 
 void QmitkExtWorkbenchWindowAdvisorHack::onImageNavigator()
 {
  // get ImageNavigatorView
  berry::IViewPart::Pointer imageNavigatorView =
   berry::PlatformUI::GetWorkbench()->GetActiveWorkbenchWindow()->GetActivePage()->FindView("org.mitk.views.imagenavigator");
  if (imageNavigatorView)
  {
   bool isImageNavigatorVisible = berry::PlatformUI::GetWorkbench()->GetActiveWorkbenchWindow()->GetActivePage()->IsPartVisible(imageNavigatorView);
   if (isImageNavigatorVisible)
   {
    berry::PlatformUI::GetWorkbench()->GetActiveWorkbenchWindow()->GetActivePage()->HideView(imageNavigatorView);
    return;
   }
  }
  berry::PlatformUI::GetWorkbench()->GetActiveWorkbenchWindow()->GetActivePage()->ShowView("org.mitk.views.imagenavigator");
  //berry::PlatformUI::GetWorkbench()->GetActiveWorkbenchWindow()->GetActivePage()->ResetPerspective();
 }
 
 void QmitkExtWorkbenchWindowAdvisorHack::onEditPreferences()
 {
  QmitkPreferencesDialog _PreferencesDialog(QApplication::activeWindow());
  _PreferencesDialog.exec();
 }
 
 void QmitkExtWorkbenchWindowAdvisorHack::onQuit()
 {
  berry::PlatformUI::GetWorkbench()->Close();
 }
 
 void QmitkExtWorkbenchWindowAdvisorHack::onResetPerspective()
 {
  berry::PlatformUI::GetWorkbench()->GetActiveWorkbenchWindow()->GetActivePage()->ResetPerspective();
 }
 
 void QmitkExtWorkbenchWindowAdvisorHack::onClosePerspective()
 {
  berry::IWorkbenchPage::Pointer
   page =
   berry::PlatformUI::GetWorkbench()->GetActiveWorkbenchWindow()->GetActivePage();
  page->ClosePerspective(page->GetPerspective(), true, true);
 }
 
 void QmitkExtWorkbenchWindowAdvisorHack::onNewWindow()
 {
  berry::PlatformUI::GetWorkbench()->OpenWorkbenchWindow(0);
 }
 
 void QmitkExtWorkbenchWindowAdvisorHack::onIntro()
 {
  bool hasIntro =
   berry::PlatformUI::GetWorkbench()->GetIntroManager()->HasIntro();
  if (!hasIntro)
  {
 
   QRegExp reg("(.*)<title>(\\n)*");
   QRegExp reg2("(\\n)*</title>(.*)");
   QFile file(":/org.mitk.gui.qt.ext/index.html");
   file.open(QIODevice::ReadOnly | QIODevice::Text); // Als Text-Datei nur zum Lesen öffnen
 
   QString text = QString(file.readAll());
 
   file.close();
 
   QString title = text;
   title.replace(reg, "");
   title.replace(reg2, "");
 
   std::cout << title.toStdString() << std::endl;
 
   QMessageBox::information(NULL, title,
    text, "Close");
 
  }
  else
  {
   berry::PlatformUI::GetWorkbench()->GetIntroManager()->ShowIntro(
    berry::PlatformUI::GetWorkbench()->GetActiveWorkbenchWindow(), false);
  }
 }
 
 void QmitkExtWorkbenchWindowAdvisorHack::onHelp()
 {
   ctkPluginContext* context = QmitkCommonExtPlugin::getContext();
   if (context == 0)
   {
     MITK_WARN << "Plugin context not set, unable to open context help";
     return;
   }
 
   // Check if the org.blueberry.ui.qt.help plug-in is installed and started
   QList<QSharedPointer<ctkPlugin> > plugins = context->getPlugins();
   foreach(QSharedPointer<ctkPlugin> p, plugins)
   {
     if (p->getSymbolicName() == "org.blueberry.ui.qt.help")
     {
       if (p->getState() != ctkPlugin::ACTIVE)
       {
         // try to activate the plug-in explicitly
         try
         {
           p->start(ctkPlugin::START_TRANSIENT);
         }
         catch (const ctkPluginException& pe)
         {
           MITK_ERROR << "Activating org.blueberry.ui.qt.help failed: " << pe.what();
           return;
         }
       }
     }
   }
 
   ctkServiceReference eventAdminRef = context->getServiceReference<ctkEventAdmin>();
   ctkEventAdmin* eventAdmin = 0;
   if (eventAdminRef)
   {
     eventAdmin = context->getService<ctkEventAdmin>(eventAdminRef);
   }
   if (eventAdmin == 0)
   {
     MITK_WARN << "ctkEventAdmin service not found. Unable to open context help";
   }
   else
   {
     ctkEvent ev("org/blueberry/ui/help/CONTEXTHELP_REQUESTED");
     eventAdmin->postEvent(ev);
   }
 }
 
 void QmitkExtWorkbenchWindowAdvisorHack::onHelpContents()
 {
   berry::PlatformUI::GetWorkbench()->ShowPerspective("org.blueberry.perspectives.help",
                                                      berry::PlatformUI::GetWorkbench()->GetActiveWorkbenchWindow());
 }
 
 void QmitkExtWorkbenchWindowAdvisorHack::onAbout()
 {
  QmitkAboutDialog* aboutDialog = new QmitkAboutDialog(QApplication::activeWindow(),NULL);
  aboutDialog->open();
 }
 
 void QmitkExtWorkbenchWindowAdvisor::HookTitleUpdateListeners(
  berry::IWorkbenchWindowConfigurer::Pointer configurer)
 {
  // hook up the listeners to update the window title
  titlePartListener = new PartListenerForTitle(this);
  titlePerspectiveListener = new PerspectiveListenerForTitle(this);
  editorPropertyListener = new berry::PropertyChangeIntAdapter<
   QmitkExtWorkbenchWindowAdvisor>(this,
   &QmitkExtWorkbenchWindowAdvisor::PropertyChange);
 
  //    configurer.getWindow().addPageListener(new IPageListener() {
  //      public void pageActivated(IWorkbenchPage page) {
  //        updateTitle(false);
  //      }
  //
  //      public void pageClosed(IWorkbenchPage page) {
  //        updateTitle(false);
  //      }
  //
  //      public void pageOpened(IWorkbenchPage page) {
  //        // do nothing
  //      }
  //    });
 
  configurer->GetWindow()->AddPerspectiveListener(titlePerspectiveListener);
  configurer->GetWindow()->GetPartService()->AddPartListener(titlePartListener);
 }
 
 std::string QmitkExtWorkbenchWindowAdvisor::ComputeTitle()
 {
  berry::IWorkbenchWindowConfigurer::Pointer configurer =
   GetWindowConfigurer();
  berry::IWorkbenchPage::Pointer currentPage =
   configurer->GetWindow()->GetActivePage();
  berry::IEditorPart::Pointer activeEditor;
  if (currentPage)
  {
   activeEditor = lastActiveEditor.Lock();
  }
 
  std::string title;
  //TODO Product
  //    IProduct product = Platform.getProduct();
  //    if (product != null) {
  //      title = product.getName();
  //    }
  // instead of the product name, we use a custom variable for now
  title = productName;
 
  if(showMitkVersionInfo)
  {
    title += std::string(" ") + MITK_VERSION_STRING;
  }
 
  if (showVersionInfo)
  {
   // add version informatioin
   QString versions = QString(" (ITK %1.%2.%3  VTK %4.%5.%6 Qt %7 MITK %8)")
    .arg(ITK_VERSION_MAJOR).arg(ITK_VERSION_MINOR).arg(ITK_VERSION_PATCH)
    .arg(VTK_MAJOR_VERSION).arg(VTK_MINOR_VERSION).arg(VTK_BUILD_VERSION)
    .arg(QT_VERSION_STR)
    .arg(MITK_VERSION_STRING);
 
   title += versions.toStdString();
  }
 
  if (currentPage)
  {
   if (activeEditor)
   {
    lastEditorTitle = activeEditor->GetTitleToolTip();
    if (!lastEditorTitle.empty())
     title = lastEditorTitle + " - " + title;
   }
   berry::IPerspectiveDescriptor::Pointer persp =
    currentPage->GetPerspective();
   std::string label = "";
   if (persp)
   {
    label = persp->GetLabel();
   }
   berry::IAdaptable* input = currentPage->GetInput();
   if (input && input != wbAdvisor->GetDefaultPageInput())
   {
    label = currentPage->GetLabel();
   }
   if (!label.empty())
   {
    title = label + " - " + title;
   }
  }
 
  title += " (Not for use in diagnosis or treatment of patients)";
 
  return title;
 }
 
 void QmitkExtWorkbenchWindowAdvisor::RecomputeTitle()
 {
  berry::IWorkbenchWindowConfigurer::Pointer configurer =
   GetWindowConfigurer();
  std::string oldTitle = configurer->GetTitle();
  std::string newTitle = ComputeTitle();
  if (newTitle != oldTitle)
  {
   configurer->SetTitle(newTitle);
  }
 }
 
 void QmitkExtWorkbenchWindowAdvisor::UpdateTitle(bool editorHidden)
 {
  berry::IWorkbenchWindowConfigurer::Pointer configurer =
   GetWindowConfigurer();
  berry::IWorkbenchWindow::Pointer window = configurer->GetWindow();
  berry::IEditorPart::Pointer activeEditor;
  berry::IWorkbenchPage::Pointer currentPage = window->GetActivePage();
  berry::IPerspectiveDescriptor::Pointer persp;
  berry::IAdaptable* input = 0;
 
  if (currentPage)
  {
   activeEditor = currentPage->GetActiveEditor();
   persp = currentPage->GetPerspective();
   input = currentPage->GetInput();
  }
 
  if (editorHidden)
  {
   activeEditor = 0;
  }
 
  // Nothing to do if the editor hasn't changed
  if (activeEditor == lastActiveEditor.Lock() && currentPage == lastActivePage.Lock()
   && persp == lastPerspective.Lock() && input == lastInput)
  {
   return;
  }
 
  if (!lastActiveEditor.Expired())
  {
   lastActiveEditor.Lock()->RemovePropertyListener(editorPropertyListener);
  }
 
  lastActiveEditor = activeEditor;
  lastActivePage = currentPage;
  lastPerspective = persp;
  lastInput = input;
 
  if (activeEditor)
  {
   activeEditor->AddPropertyListener(editorPropertyListener);
  }
 
  RecomputeTitle();
 }
 
 void QmitkExtWorkbenchWindowAdvisor::PropertyChange(berry::Object::Pointer /*source*/, int propId)
 {
  if (propId == berry::IWorkbenchPartConstants::PROP_TITLE)
  {
   if (!lastActiveEditor.Expired())
   {
    std::string newTitle = lastActiveEditor.Lock()->GetPartName();
    if (lastEditorTitle != newTitle)
    {
     RecomputeTitle();
    }
   }
  }
 }
 
 
 void QmitkExtWorkbenchWindowAdvisor::SetPerspectiveExcludeList(std::vector<std::string> v)
 {
   this->perspectiveExcludeList = v;
 }
 
 std::vector<std::string> QmitkExtWorkbenchWindowAdvisor::GetPerspectiveExcludeList()
 {
   return this->perspectiveExcludeList;
 }
 
 void QmitkExtWorkbenchWindowAdvisor::SetViewExcludeList(std::vector<std::string> v)
 {
   this->viewExcludeList = v;
 }
 
 std::vector<std::string> QmitkExtWorkbenchWindowAdvisor::GetViewExcludeList()
 {
   return this->viewExcludeList;
 }
 
 void QmitkExtWorkbenchWindowAdvisor::PostWindowClose()
 {
   berry::IWorkbenchWindow::Pointer window = this->GetWindowConfigurer()->GetWindow();
   QMainWindow* mainWindow = static_cast<QMainWindow*> (window->GetShell()->GetControl());
 
   QSettings settings(GetQSettingsFile(), QSettings::IniFormat);
   settings.setValue("ToolbarPosition", mainWindow->saveState());
 }
 
 QString QmitkExtWorkbenchWindowAdvisor::GetQSettingsFile() const
 {
   QFileInfo settingsInfo = QmitkCommonExtPlugin::getContext()->getDataFile(QT_SETTINGS_FILENAME);
   return settingsInfo.canonicalFilePath();
 }