diff --git a/Modules/DicomRT/mitkRTStructureSetReader.cpp b/Modules/DicomRT/mitkRTStructureSetReader.cpp
index 5f7f82a519..dd12a6e834 100644
--- a/Modules/DicomRT/mitkRTStructureSetReader.cpp
+++ b/Modules/DicomRT/mitkRTStructureSetReader.cpp
@@ -1,247 +1,249 @@
 /*===================================================================
 
 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 "mitkRTStructureSetReader.h"
 #include <mitkIOUtil.h>
 
 #include <mitkBaseRenderer.h>
 
 namespace mitk
 {
   RTStructureSetReader::RTStructureSetReader(){}
 
   RTStructureSetReader::~RTStructureSetReader(){}
 
   RTStructureSetReader::RoiEntry::RoiEntry()
   {
     Number = 0;
     DisplayColor[0]=1.0;
     DisplayColor[1]=0.0;
     DisplayColor[2]=0.0;
     ContourModelSet=mitk::ContourModelSet::New();
   }
 
   RTStructureSetReader::RoiEntry::RoiEntry(const RoiEntry &src)
   {
     Number=src.Number;
     Name=src.Name;
     Description=src.Description;
     DisplayColor[0]=src.DisplayColor[0];
     DisplayColor[1]=src.DisplayColor[1];
     DisplayColor[2]=src.DisplayColor[2];
     ContourModelSet=mitk::ContourModelSet::New();
     SetPolyData(src.ContourModelSet);
   }
 
   RTStructureSetReader::RoiEntry::~RoiEntry(){}
 
   RTStructureSetReader::RoiEntry& RTStructureSetReader::
       RoiEntry::operator =(const RoiEntry &src)
   {
     Number=src.Number;
     Name=src.Name;
     Description=src.Description;
     DisplayColor[0]=src.DisplayColor[0];
     DisplayColor[1]=src.DisplayColor[1];
     DisplayColor[2]=src.DisplayColor[2];
     SetPolyData(src.ContourModelSet);
     return (*this);
   }
 
   void RTStructureSetReader::RoiEntry::
       SetPolyData(mitk::ContourModelSet::Pointer roiPolyData)
   {
     if (roiPolyData == this->ContourModelSet)
       return;
     this->ContourModelSet = roiPolyData;
   }
 
   size_t RTStructureSetReader::GetNumberOfROIs()
   {
     return this->ROISequenceVector.size();
   }
 
   RTStructureSetReader::RoiEntry* RTStructureSetReader::
       FindRoiByNumber(unsigned int roiNum)
   {
     for(unsigned int i=0; i<this->ROISequenceVector.size(); ++i)
     {
       if(this->ROISequenceVector[i].Number == roiNum)
         return &this->ROISequenceVector[i];
     }
     return NULL;
   }
 
   RTStructureSetReader::ContourModelSetNodes RTStructureSetReader::ReadStructureSet(const char* filepath)
   {
     DcmFileFormat file;
     OFCondition output = file.loadFile(filepath, EXS_Unknown);
     if(output.bad())
     {
       MITK_ERROR << "Cant read the file" << endl;
     }
     DcmDataset *dataset = file.getDataset();
 
 
 
     ContourModelSetVector contourModelSetVector;
 
     DRTStructureSetIOD structureSetObject;
     OFCondition outp = structureSetObject.read(*dataset);
     if(!outp.good())
     {
       MITK_ERROR << "Error reading the file" << endl;
       RTStructureSetReader::ContourModelSetNodes x;
       return x;
     }
     DRTStructureSetROISequence &roiSequence =
             structureSetObject.getStructureSetROISequence();
     if(!roiSequence.gotoFirstItem().good())
     {
       MITK_ERROR << "Error reading the structure sequence" << endl;
       RTStructureSetReader::ContourModelSetNodes x;
       return x;
     }
     do{
       DRTStructureSetROISequence::Item &currentSequence =
               roiSequence.getCurrentItem();
       if(!currentSequence.isValid())
       {
         continue;
       }
       OFString roiName;
       OFString roiDescription;
       Sint32 roiNumber;
       RoiEntry roi;
 
       currentSequence.getROIName(roiName);
       currentSequence.getROIDescription(roiDescription);
       currentSequence.getROINumber(roiNumber);
 
       roi.Name = roiName.c_str();
       roi.Description = roiDescription.c_str();
       roi.Number = roiNumber;
 
       this->ROISequenceVector.push_back(roi);
     }
     while(roiSequence.gotoNextItem().good());
 
     Sint32 refRoiNumber;
     DRTROIContourSequence &roiContourSeqObject =
             structureSetObject.getROIContourSequence();
     if(!roiContourSeqObject.gotoFirstItem().good())
     {
       MITK_ERROR << "Error reading the contour sequence" << endl;
       RTStructureSetReader::ContourModelSetNodes x;
       return x;
     }
     do
     {
       mitk::ContourModelSet::Pointer contourSet = mitk::ContourModelSet::New();
       DRTROIContourSequence::Item &currentRoiObject =
               roiContourSeqObject.getCurrentItem();
       if(!currentRoiObject.isValid())
       {
         continue;
       }
       currentRoiObject.getReferencedROINumber(refRoiNumber);
       DRTContourSequence &contourSeqObject =
               currentRoiObject.getContourSequence();
 
       if(contourSeqObject.gotoFirstItem().good())
       {
         do
         {
           DRTContourSequence::Item &contourItem =
                   contourSeqObject.getCurrentItem();
           if(!contourItem.isValid())
           {
             continue;
           }
           int number;
           OFString contourNumber;
           OFString numberOfPoints;
           OFVector<Float64> contourData_LPS;
           mitk::ContourModel::Pointer contourSequence =
                   mitk::ContourModel::New();
 
           contourItem.getContourNumber(contourNumber);
           contourItem.getNumberOfContourPoints(numberOfPoints);
           contourItem.getContourData(contourData_LPS);
 
           std::stringstream stream;
           stream << numberOfPoints;
           stream >> number;
 
           for(unsigned int i=0; i<contourData_LPS.size()/3;i++)
           {
             mitk::Point3D point;
             point[0] = contourData_LPS.at(3*i);
             point[1] = contourData_LPS.at(3*i+1);
             point[2] = contourData_LPS.at(3*i+2);
             contourSequence->AddVertex(point);
           }
           contourSequence->Close();
           contourSet->AddContourModel(contourSequence);
         }
         while(contourSeqObject.gotoNextItem().good());
       }
       else
       {
         MITK_ERROR << "Error reading contourSeqObject" << endl;
       }
       RoiEntry* refROI = this->FindRoiByNumber(refRoiNumber);
       if(refROI==NULL)
       {
         MITK_ERROR << "Can not find references ROI" << endl;
         continue;
       }
       Sint32 roiColor;
       for(int j=0;j<3;j++)
       {
         currentRoiObject.getROIDisplayColor(roiColor, j);
         refROI->DisplayColor[j] = roiColor/255.0;
       }
       refROI->ContourModelSet = contourSet;
       contourSet->SetProperty("name", mitk::StringProperty::New(refROI->Name));
       contourSet->SetProperty("contour.color", mitk::ColorProperty::New(
                                 refROI->DisplayColor[0],
                                 refROI->DisplayColor[1],
                                 refROI->DisplayColor[2]));
+
       contourModelSetVector.push_back(contourSet);
 
     }
     while(roiContourSeqObject.gotoNextItem().good());
 
     std::deque<mitk::DataNode::Pointer> nodes;
 
     for(int i=0; i<contourModelSetVector.size();i++)
     {
       mitk::DataNode::Pointer node = mitk::DataNode::New();
       node->SetData(contourModelSetVector.at(i));
       node->SetProperty("name", contourModelSetVector.at(i)->GetProperty("name"));
       node->SetProperty("color",contourModelSetVector.at(i)->GetProperty("contour.color"));
       node->SetProperty("contour.color",contourModelSetVector.at(i)->GetProperty("contour.color"));
+      node->SetProperty("includeInBoundingBox", mitk::BoolProperty::New(false));
       node->SetVisibility(true, mitk::BaseRenderer::GetInstance( mitk::BaseRenderer::GetRenderWindowByName("stdmulti.widget1")));
       node->SetVisibility(false, mitk::BaseRenderer::GetInstance( mitk::BaseRenderer::GetRenderWindowByName("stdmulti.widget2")));
       node->SetVisibility(false, mitk::BaseRenderer::GetInstance( mitk::BaseRenderer::GetRenderWindowByName("stdmulti.widget3")));
       node->SetVisibility(true, mitk::BaseRenderer::GetInstance( mitk::BaseRenderer::GetRenderWindowByName("stdmulti.widget4")));
       nodes.push_back(node);
     }
 
     return nodes;
   }
 }
diff --git a/Modules/DicomUI/Qmitk/QmitkDicomExternalDataWidget.cpp b/Modules/DicomUI/Qmitk/QmitkDicomExternalDataWidget.cpp
index 37f4f06000..ced1ca81cb 100644
--- a/Modules/DicomUI/Qmitk/QmitkDicomExternalDataWidget.cpp
+++ b/Modules/DicomUI/Qmitk/QmitkDicomExternalDataWidget.cpp
@@ -1,216 +1,215 @@
 /*===================================================================
 
 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.
 
 ===================================================================*/
 
 
 // Qmitk
 #include "QmitkDicomExternalDataWidget.h"
 #include <mitkLogMacros.h>
 
 // CTK
 #include <ctkFileDialog.h>
 
 // Qt
 #include <QCheckBox>
 #include <QMessageBox>
 
 const std::string QmitkDicomExternalDataWidget::Widget_ID = "org.mitk.Widgets.QmitkDicomExternalDataWidget";
 
 QmitkDicomExternalDataWidget::QmitkDicomExternalDataWidget(QWidget *parent)
   : QWidget(parent)
   , m_Controls (0)
 {
     Initialize();
     CreateQtPartControl(this);
 }
 
 QmitkDicomExternalDataWidget::~QmitkDicomExternalDataWidget()
 {
 }
 
 
 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->viewExternalDataButton->setVisible(true);
         m_Controls->ctkDICOMBrowser->setDynamicTableLayout(true);
         m_Controls->ctkDICOMBrowser->setDICOMDatabase(m_ExternalDatabase);
 
         this->SetupImportDialog();
         this->SetupProgressDialog(parent);
 
         //connect Buttons
         connect(m_Controls->downloadButton, SIGNAL(clicked()),this,SLOT(OnDownloadButtonClicked()));
         connect(m_Controls->viewExternalDataButton, SIGNAL(clicked()),this,SLOT(OnViewButtonClicked()));
         connect(m_Controls->directoryButton, SIGNAL(clicked()), this, SLOT(OnScanDirectory()));
 
         connect(m_Controls->ctkDICOMBrowser, SIGNAL(seriesSelectionChanged(const QStringList&)),
                 this, SLOT(OnSeriesSelectionChanged(const QStringList&)));
         connect(m_Controls->ctkDICOMBrowser, SIGNAL(seriesDoubleClicked(const QModelIndex&)),
                 this, SLOT(OnViewButtonClicked()));
 
         connect(m_ProgressDialog, SIGNAL(canceled()), m_ExternalIndexer, SLOT(cancel()));
         connect(m_ExternalIndexer, SIGNAL(indexingComplete()),this, SLOT(OnFinishedImport()));
 
         connect(m_ExternalIndexer, SIGNAL(indexingFilePath(const QString&)), m_ProgressDialogLabel, SLOT(setText(const QString&)));
         connect(m_ExternalIndexer, SIGNAL(progress(int)), m_ProgressDialog, SLOT(setValue(int)));
     }
 }
 
 void QmitkDicomExternalDataWidget::Initialize()
 {
     m_ExternalDatabase = new ctkDICOMDatabase(this);
 
     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_ExternalIndexer = new ctkDICOMIndexer(this);
 }
 
 void QmitkDicomExternalDataWidget::OnFinishedImport()
 {
   m_ProgressDialog->setValue(m_ProgressDialog->maximum());
 }
 
 void QmitkDicomExternalDataWidget::OnDownloadButtonClicked()
 {
   QStringList filesToDownload = GetFileNamesFromIndex();
   if (filesToDownload.size() == 0)
   {
     QMessageBox info;
     info.setText("You have to select an entry in the dicom browser for import.");
     info.exec();
     return;
   }
     emit SignalStartDicomImport(GetFileNamesFromIndex());
 }
 
 void QmitkDicomExternalDataWidget::OnViewButtonClicked()
 {
   QStringList uids = m_Controls->ctkDICOMBrowser->currentSeriesSelection();
   QString uid;
   foreach (uid, uids)
   {
     QStringList filesForSeries = m_ExternalDatabase->filesForSeries(uid);
     QHash<QString, QVariant> eventProperty;
     eventProperty.insert("FilesForSeries", filesForSeries);
     if(!filesForSeries.isEmpty())
     {
       QString modality = m_ExternalDatabase->fileValue(filesForSeries.at(0),"0008,0060");
-      MITK_INFO << "Item:" << modality.toStdString() << endl;
       eventProperty.insert("Modality", modality);
     }
     emit SignalDicomToDataManager(eventProperty);
   }
 }
 
 QStringList QmitkDicomExternalDataWidget::GetFileNamesFromIndex()
 {
     QStringList filePaths;
 
     QString uid;
     QStringList seriesUIDs = m_Controls->ctkDICOMBrowser->currentSeriesSelection();
     foreach (uid, seriesUIDs)
     {
       filePaths.append(m_ExternalDatabase->filesForSeries(uid));
 
     }
     if (!filePaths.empty())
       return filePaths;
 
     QStringList studyUIDs = m_Controls->ctkDICOMBrowser->currentStudiesSelection();
 
     foreach (uid, studyUIDs)
       {
         seriesUIDs = m_ExternalDatabase->seriesForStudy(uid);
         foreach (uid, seriesUIDs)
           {
             filePaths.append(m_ExternalDatabase->filesForSeries(uid));
           }
       }
     if (!filePaths.empty())
       return filePaths;
 
     QStringList patientsUIDs = m_Controls->ctkDICOMBrowser->currentPatientsSelection();
 
     foreach (uid, patientsUIDs)
       {
         studyUIDs = m_ExternalDatabase->studiesForPatient(uid);
 
         foreach (uid, studyUIDs)
           {
             seriesUIDs = m_ExternalDatabase->seriesForStudy(uid);
             foreach (uid, seriesUIDs)
               {
                 filePaths.append(m_ExternalDatabase->filesForSeries(uid));
               }
           }
       }
     return filePaths;
 }
 
 void QmitkDicomExternalDataWidget::OnStartDicomImport(const QString& directory)
 {
   m_ImportDialog->close();
   m_ProgressDialog->show();
 
     m_LastImportDirectory = directory;
     m_ExternalIndexer->addDirectory(*m_ExternalDatabase,m_LastImportDirectory);
 }
 
 void QmitkDicomExternalDataWidget::OnSeriesSelectionChanged(const QStringList& s)
 {
   m_Controls->viewExternalDataButton->setEnabled( (s.size() != 0) );
 }
 
 void QmitkDicomExternalDataWidget::SetupImportDialog()
 {
         //Initialize import widget
         m_ImportDialog = new ctkFileDialog(this);
         // Since copy on import is not working at the moment
         // this feature is diabled
 //        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(OnStartDicomImport(QString)));
 }
 
 void QmitkDicomExternalDataWidget::SetupProgressDialog(QWidget* parent)
 {
     m_ProgressDialog = new QProgressDialog("DICOM Import", "Cancel", 0, 100, parent, Qt::WindowTitleHint | Qt::WindowSystemMenuHint);
     m_ProgressDialogLabel = new QLabel("Initialization...", m_ProgressDialog);
     m_ProgressDialog->setLabel(m_ProgressDialogLabel);
     m_ProgressDialog->setWindowModality(Qt::ApplicationModal);
     m_ProgressDialog->setMinimumDuration(0);
 }
 
 void QmitkDicomExternalDataWidget::OnScanDirectory()
 {
   m_ImportDialog->show();
 }
diff --git a/Plugins/org.mitk.gui.qt.dicom/CMakeLists.txt b/Plugins/org.mitk.gui.qt.dicom/CMakeLists.txt
index e292640cea..e148df4e8e 100644
--- a/Plugins/org.mitk.gui.qt.dicom/CMakeLists.txt
+++ b/Plugins/org.mitk.gui.qt.dicom/CMakeLists.txt
@@ -1,20 +1,20 @@
 project(org_mitk_gui_qt_dicom)
 
 find_program(DCMTK_STORESCP storescp PATHS "${DCMTK_DIR}/bin" PATH_SUFFIXES Release Debug DOC "Dcmtk storage provider which is used to store dicom files which are transfered over network." NO_DEFAULT_PATH)
 mark_as_advanced(DCMTK_STORESCP)
 
 if(NOT EXISTS ${DCMTK_STORESCP})
   message(WARNING "Couldn't find program storescp without the program query retrieve of the dicom plugin won't work!")
 else(NOT EXISTS ${DCMTK_STORESCP})
 
   configure_file( org_mitk_gui_qt_dicom_config.h.in org_mitk_gui_qt_dicom_config.h @ONLY)
 
   MITK_INSTALL_HELPER_APP(${DCMTK_STORESCP})
 
   MACRO_CREATE_MITK_CTK_PLUGIN(
     EXPORT_DIRECTIVE DICOM_EXPORT
     EXPORTED_INCLUDE_SUFFIXES src
-    MODULE_DEPENDS MitkQtWidgetsExt MitkDicomUI MitkDicomRT
+    MODULE_DEPENDS MitkQtWidgetsExt MitkDicomUI MitkDicomRT MitkRTUI
   )
 
 endif()
diff --git a/Plugins/org.mitk.gui.qt.dicom/src/internal/DicomEventHandler.cpp b/Plugins/org.mitk.gui.qt.dicom/src/internal/DicomEventHandler.cpp
index 127a5713b5..16a2ff0fb0 100644
--- a/Plugins/org.mitk.gui.qt.dicom/src/internal/DicomEventHandler.cpp
+++ b/Plugins/org.mitk.gui.qt.dicom/src/internal/DicomEventHandler.cpp
@@ -1,216 +1,276 @@
 /*===================================================================
 
 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 "mitkPluginActivator.h"
 #include "DicomEventHandler.h"
 #include <service/event/ctkEventConstants.h>
 #include <ctkDictionary.h>
 #include <mitkLogMacros.h>
 #include <mitkDicomSeriesReader.h>
 #include <mitkDataNode.h>
 #include <mitkIDataStorageService.h>
 #include <service/event/ctkEventAdmin.h>
 #include <ctkServiceReference.h>
 #include <mitkRenderingManager.h>
 #include <QVector>
 #include "mitkImage.h"
 #include <mitkContourModelSet.h>
 
 #include <mitkRTDoseReader.h>
 #include <mitkRTStructureSetReader.h>
 #include <mitkRTConstants.h>
+#include <mitkIsoDoseLevelCollections.h>
+#include <mitkIsoDoseLevelSetProperty.h>
+#include <mitkIsoDoseLevelVectorProperty.h>
+#include <mitkDoseImageVtkMapper2D.h>
+#include <mitkRTUIConstants.h>
+#include <mitkIsoLevelsGenerator.h>
+
+#include <vtkSmartPointer.h>
+#include <vtkMath.h>
+#include <mitkTransferFunction.h>
+#include <mitkTransferFunctionProperty.h>
+#include <mitkRenderingModeProperty.h>
+
+#include <berryIPreferencesService.h>
+#include <berryPlatform.h>
 
 DicomEventHandler::DicomEventHandler()
 {
 }
 
 DicomEventHandler::~DicomEventHandler()
 {
 }
 
 void DicomEventHandler::OnSignalAddSeriesToDataManager(const ctkEvent& ctkEvent)
 {
   QStringList listOfFilesForSeries;
   mitk::DicomSeriesReader::StringContainer seriesToLoad;
 
   listOfFilesForSeries = ctkEvent.getProperty("FilesForSeries").toStringList();
 
   if (!listOfFilesForSeries.isEmpty()){
 
     //for rt data, if the modality tag isnt defined or is "CT" the image is handled like before
     if(ctkEvent.containsProperty("Modality") &&
        (ctkEvent.getProperty("Modality").toString().compare("RTDOSE",Qt::CaseInsensitive) == 0 ||
         ctkEvent.getProperty("Modality").toString().compare("RTSTRUCT",Qt::CaseInsensitive) == 0))
     {
       QString modality = ctkEvent.getProperty("Modality").toString();
-      MITK_INFO << endl << "----> MODALITY: " << ctkEvent.getProperty("Modality").toString().toStdString() << endl;
 
       if(modality.compare("RTDOSE",Qt::CaseInsensitive) == 0)
       {
-        //        MITK_INFO << "------->FILEname: " << listOfFilesForSeries.at(0).toStdString() << endl;
-//        mitk::RTDoseReader::Pointer doseReader = mitk::RTDoseReader::New();
-
-//        mitk::DataNode::Pointer doseImageNode = mitk::DataNode::New();
-//        mitk::DataNode::Pointer doseOutlineNode = mitk::DataNode::New();
-
-//        doseImageNode = doseReader->LoadRTDose(listOfFilesForSeries.at(0).toStdString().c_str());
-//        doseOutlineNode->SetData(doseImageNode->GetData());
-//        if(doseImageNode.IsNotNull() && doseOutlineNode->GetData() != NULL)
-//        {
-//          double referenceDose = 40.0;
-//          mitk::GetReferenceDoseValue(referenceDose);
-//          //set some specific colorwash and isoline properties
-//          doseImageNode->SetBoolProperty(mitk::Constants::DOSE_SHOW_COLORWASH_PROPERTY_NAME.c_str(), true);
-//          doseOutlineNode->SetBoolProperty(mitk::Constants::DOSE_SHOW_ISOLINES_PROPERTY_NAME.c_str(), true);
-//          //Set reference dose property
-//          doseImageNode->SetFloatProperty(mitk::Constants::REFERENCE_DOSE_PROPERTY_NAME.c_str(), referenceDose);
-//          doseOutlineNode->SetFloatProperty(mitk::Constants::REFERENCE_DOSE_PROPERTY_NAME.c_str(), referenceDose);
-
-//          //Get the presets and put it into properties for the datanodes
-//          mitk::PresetMapType presetsMap = mitk::rt::LoadPresetsMap();
-//          std::string selectedPresetName = mitk::rt::GetSelectedPresetName();
-
-//          mitk::IsoDoseLevelSet::Pointer isoDoseLevelPreset = presetsMap[mitk::rt::GetSelectedPresetName()];
-//          mitk::IsoDoseLevelSetProperty::Pointer levelSetProp = mitk::IsoDoseLevelSetProperty::New(isoDoseLevelPreset);
-//          doseImageNode->SetProperty(mitk::Constants::DOSE_ISO_LEVELS_PROPERTY_NAME.c_str(),levelSetProp);
-//          doseOutlineNode->SetProperty(mitk::Constants::DOSE_ISO_LEVELS_PROPERTY_NAME.c_str(),levelSetProp);
-
-//          mitk::IsoDoseLevelVector::Pointer levelVector = mitk::IsoDoseLevelVector::New();
-//          mitk::IsoDoseLevelVectorProperty::Pointer levelVecProp = mitk::IsoDoseLevelVectorProperty::New(levelVector);
-//          doseImageNode->SetProperty(mitk::Constants::DOSE_FREE_ISO_VALUES_PROPERTY_NAME.c_str(),levelVecProp);
-//          doseOutlineNode->SetProperty(mitk::Constants::DOSE_FREE_ISO_VALUES_PROPERTY_NAME.c_str(),levelVecProp);
-
-//          //Generating the Colorwash
-//          vtkSmartPointer<vtkColorTransferFunction> transferFunction = vtkSmartPointer<vtkColorTransferFunction>::New();
-
-//          for(mitk::IsoDoseLevelSet::ConstIterator itIsoDoseLevel = isoDoseLevelPreset->Begin(); itIsoDoseLevel != isoDoseLevelPreset->End(); ++itIsoDoseLevel)
-//          {
-//            float *hsv = new float[3];
-//            //used for transfer rgb to hsv
-//            vtkSmartPointer<vtkMath> cCalc = vtkSmartPointer<vtkMath>::New();
-//            if(itIsoDoseLevel->GetVisibleColorWash()){
-//              cCalc->RGBToHSV(itIsoDoseLevel->GetColor()[0],itIsoDoseLevel->GetColor()[1],itIsoDoseLevel->GetColor()[2],&hsv[0],&hsv[1],&hsv[2]);
-//              transferFunction->AddHSVPoint(itIsoDoseLevel->GetDoseValue()*referenceDose,hsv[0],hsv[1],hsv[2],1.0,1.0);
-//            }
-//          }
-
-//          mitk::TransferFunction::Pointer mitkTransFunc = mitk::TransferFunction::New();
-//          mitk::TransferFunctionProperty::Pointer mitkTransFuncProp = mitk::TransferFunctionProperty::New();
-//          mitkTransFunc->SetColorTransferFunction(transferFunction);
-//          mitkTransFuncProp->SetValue(mitkTransFunc);
-
-//          mitk::RenderingModeProperty::Pointer renderingModeProp = mitk::RenderingModeProperty::New();
-//          renderingModeProp->SetValue(mitk::RenderingModeProperty::COLORTRANSFERFUNCTION_COLOR);
-
-//          doseImageNode->SetProperty("Image Rendering.Transfer Function", mitkTransFuncProp);
-//          doseImageNode->SetProperty("Image Rendering.Mode", renderingModeProp);
-//          doseImageNode->SetProperty("opacity", mitk::FloatProperty::New(0.5));
-
-//          //set the outline properties
-//          doseOutlineNode->SetBoolProperty("outline binary", true);
-//          doseOutlineNode->SetProperty( "helper object", mitk::BoolProperty::New(true) );
-//          doseOutlineNode->SetProperty( "includeInBoundingBox", mitk::BoolProperty::New(false) );
-
-//          GetDataStorage()->Add(doseImageNode);
-//          GetDataStorage()->Add(doseOutlineNode);
-
-//          //set the dose mapper for outline drawing; the colorwash is realized by the imagevtkmapper2D
-//          mitk::DoseImageVtkMapper2D::Pointer contourMapper = mitk::DoseImageVtkMapper2D::New();
-//          doseOutlineNode->SetMapper(1,contourMapper);
-
-//          mitk::TimeGeometry::Pointer geo = this->GetDataStorage()->ComputeBoundingGeometry3D(this->GetDataStorage()->GetAll());
-//          mitk::RenderingManager::GetInstance()->InitializeViews( geo );
-//        }
+        mitk::RTDoseReader::Pointer doseReader = mitk::RTDoseReader::New();
+
+        mitk::DataNode::Pointer doseImageNode = mitk::DataNode::New();
+        mitk::DataNode::Pointer doseOutlineNode = mitk::DataNode::New();
+
+        doseImageNode = doseReader->LoadRTDose(listOfFilesForSeries.at(0).toStdString().c_str());
+        doseOutlineNode->SetData(doseImageNode->GetData());
+        if(doseImageNode.IsNotNull() && doseOutlineNode->GetData() != NULL)
+        {
+          berry::IPreferencesService::Pointer prefService =
+              berry::Platform::GetServiceRegistry().GetServiceById<berry::IPreferencesService>(berry::IPreferencesService::ID);
+          berry::IPreferences::Pointer prefNode = prefService->GetSystemPreferences()->Node(mitk::RTUIConstants::ROOT_ISO_PRESETS_PREFERENCE_NODE_ID);
+
+          typedef std::vector<std::string> NamesType;
+          NamesType names = prefNode->ChildrenNames();
+
+          std::map<std::string, mitk::IsoDoseLevelSet::Pointer> presetMap;
+
+          for (NamesType::const_iterator pos = names.begin(); pos != names.end(); ++pos)
+          {
+            berry::IPreferences::Pointer aPresetNode = prefNode->Node(*pos);
+
+            if (aPresetNode.IsNull())
+            {
+              mitkThrow()<< "Error in preference interface. Cannot find preset node under given name. Name: "<<*pos;
+            }
+
+            mitk::IsoDoseLevelSet::Pointer levelSet = mitk::IsoDoseLevelSet::New();
+
+            NamesType levelNames =  aPresetNode->ChildrenNames();
+            for (NamesType::const_iterator levelName = levelNames.begin(); levelName != levelNames.end(); ++levelName)
+            {
+              berry::IPreferences::Pointer levelNode = aPresetNode->Node(*levelName);
+              if (aPresetNode.IsNull())
+              {
+                mitkThrow()<< "Error in preference interface. Cannot find level node under given preset name. Name: "<<*pos<<"; Level id: "<<*levelName;
+              }
+
+              mitk::IsoDoseLevel::Pointer isoLevel = mitk::IsoDoseLevel::New();
+
+              isoLevel->SetDoseValue(levelNode->GetDouble(mitk::RTUIConstants::ISO_LEVEL_DOSE_VALUE_ID,0.0));
+              mitk::IsoDoseLevel::ColorType color;
+              color.SetRed(levelNode->GetFloat(mitk::RTUIConstants::ISO_LEVEL_COLOR_RED_ID,1.0));
+              color.SetGreen(levelNode->GetFloat(mitk::RTUIConstants::ISO_LEVEL_COLOR_GREEN_ID,1.0));
+              color.SetBlue(levelNode->GetFloat(mitk::RTUIConstants::ISO_LEVEL_COLOR_BLUE_ID,1.0));
+              isoLevel->SetColor(color);
+              isoLevel->SetVisibleIsoLine(levelNode->GetBool(mitk::RTUIConstants::ISO_LEVEL_VISIBILITY_ISOLINES_ID,true));
+              isoLevel->SetVisibleColorWash(levelNode->GetBool(mitk::RTUIConstants::ISO_LEVEL_VISIBILITY_COLORWASH_ID,true));
+
+              levelSet->SetIsoDoseLevel(isoLevel);
+            }
+
+            presetMap.insert(std::make_pair(*pos,levelSet));
+          }
+
+          if (presetMap.size() == 0)
+          {
+            presetMap.insert(std::make_pair(std::string("Virtuos"), mitk::GeneratIsoLevels_Virtuos()));
+          }
+
+          double referenceDose = 40.0;
+          //set some specific colorwash and isoline properties
+          doseImageNode->SetBoolProperty(mitk::Constants::DOSE_SHOW_COLORWASH_PROPERTY_NAME.c_str(), true);
+          doseOutlineNode->SetBoolProperty(mitk::Constants::DOSE_SHOW_ISOLINES_PROPERTY_NAME.c_str(), true);
+          //Set reference dose property
+          doseImageNode->SetFloatProperty(mitk::Constants::REFERENCE_DOSE_PROPERTY_NAME.c_str(), referenceDose);
+          doseOutlineNode->SetFloatProperty(mitk::Constants::REFERENCE_DOSE_PROPERTY_NAME.c_str(), referenceDose);
+
+          berry::IPreferences::Pointer nameNode = prefService->GetSystemPreferences()->Node(mitk::RTUIConstants::ROOT_DOSE_VIS_PREFERENCE_NODE_ID);
+          std::string presetName = nameNode->Get(mitk::RTUIConstants::SELECTED_ISO_PRESET_ID,"");
+
+          mitk::IsoDoseLevelSet::Pointer isoDoseLevelPreset = presetMap[presetName];
+          mitk::IsoDoseLevelSetProperty::Pointer levelSetProp = mitk::IsoDoseLevelSetProperty::New(isoDoseLevelPreset);
+          doseImageNode->SetProperty(mitk::Constants::DOSE_ISO_LEVELS_PROPERTY_NAME.c_str(),levelSetProp);
+          doseOutlineNode->SetProperty(mitk::Constants::DOSE_ISO_LEVELS_PROPERTY_NAME.c_str(),levelSetProp);
+
+          mitk::IsoDoseLevelVector::Pointer levelVector = mitk::IsoDoseLevelVector::New();
+          mitk::IsoDoseLevelVectorProperty::Pointer levelVecProp = mitk::IsoDoseLevelVectorProperty::New(levelVector);
+          doseImageNode->SetProperty(mitk::Constants::DOSE_FREE_ISO_VALUES_PROPERTY_NAME.c_str(),levelVecProp);
+          doseOutlineNode->SetProperty(mitk::Constants::DOSE_FREE_ISO_VALUES_PROPERTY_NAME.c_str(),levelVecProp);
+
+          //Generating the Colorwash
+          vtkSmartPointer<vtkColorTransferFunction> transferFunction = vtkSmartPointer<vtkColorTransferFunction>::New();
+
+          for(mitk::IsoDoseLevelSet::ConstIterator itIsoDoseLevel = isoDoseLevelPreset->Begin(); itIsoDoseLevel != isoDoseLevelPreset->End(); ++itIsoDoseLevel)
+          {
+            float *hsv = new float[3];
+            //used for transfer rgb to hsv
+            vtkSmartPointer<vtkMath> cCalc = vtkSmartPointer<vtkMath>::New();
+            if(itIsoDoseLevel->GetVisibleColorWash()){
+              cCalc->RGBToHSV(itIsoDoseLevel->GetColor()[0],itIsoDoseLevel->GetColor()[1],itIsoDoseLevel->GetColor()[2],&hsv[0],&hsv[1],&hsv[2]);
+              transferFunction->AddHSVPoint(itIsoDoseLevel->GetDoseValue()*referenceDose,hsv[0],hsv[1],hsv[2],1.0,1.0);
+            }
+          }
+
+          mitk::TransferFunction::Pointer mitkTransFunc = mitk::TransferFunction::New();
+          mitk::TransferFunctionProperty::Pointer mitkTransFuncProp = mitk::TransferFunctionProperty::New();
+          mitkTransFunc->SetColorTransferFunction(transferFunction);
+          mitkTransFuncProp->SetValue(mitkTransFunc);
+
+          mitk::RenderingModeProperty::Pointer renderingModeProp = mitk::RenderingModeProperty::New();
+          renderingModeProp->SetValue(mitk::RenderingModeProperty::COLORTRANSFERFUNCTION_COLOR);
+
+          doseImageNode->SetProperty("Image Rendering.Transfer Function", mitkTransFuncProp);
+          doseImageNode->SetProperty("Image Rendering.Mode", renderingModeProp);
+          doseImageNode->SetProperty("opacity", mitk::FloatProperty::New(0.5));
+
+          //set the outline properties
+          doseOutlineNode->SetBoolProperty("outline binary", true);
+          doseOutlineNode->SetProperty( "helper object", mitk::BoolProperty::New(true) );
+          doseOutlineNode->SetProperty( "includeInBoundingBox", mitk::BoolProperty::New(false) );
+
+          ctkServiceReference serviceReference =mitk::PluginActivator::getContext()->getServiceReference<mitk::IDataStorageService>();
+          mitk::IDataStorageService* storageService = mitk::PluginActivator::getContext()->getService<mitk::IDataStorageService>(serviceReference);
+          mitk::DataStorage* dataStorage = storageService->GetDefaultDataStorage().GetPointer()->GetDataStorage();
+
+          dataStorage->Add(doseImageNode);
+          dataStorage->Add(doseOutlineNode);
+
+          //set the dose mapper for outline drawing; the colorwash is realized by the imagevtkmapper2D
+          mitk::DoseImageVtkMapper2D::Pointer contourMapper = mitk::DoseImageVtkMapper2D::New();
+          doseOutlineNode->SetMapper(1,contourMapper);
+
+          mitk::RenderingManager::GetInstance()->InitializeViewsByBoundingObjects(dataStorage);
+        }//END DOSE
       }
       else if(modality.compare("RTSTRUCT",Qt::CaseInsensitive) == 0)
       {
         mitk::RTStructureSetReader::Pointer structreader = mitk::RTStructureSetReader::New();
         std::deque<mitk::DataNode::Pointer> modelVector = structreader->ReadStructureSet(listOfFilesForSeries.at(0).toStdString().c_str());
 
         if(modelVector.empty())
         {
           MITK_ERROR << "No structuresets were created" << endl;
         }
         else
         {
           ctkServiceReference serviceReference =mitk::PluginActivator::getContext()->getServiceReference<mitk::IDataStorageService>();
           mitk::IDataStorageService* storageService = mitk::PluginActivator::getContext()->getService<mitk::IDataStorageService>(serviceReference);
           mitk::DataStorage* dataStorage = storageService->GetDefaultDataStorage().GetPointer()->GetDataStorage();
 
           for(int i=0; i<modelVector.size();i++)
           {
             dataStorage->Add(modelVector.at(i));
           }
-          mitk::TimeGeometry::Pointer geometry = dataStorage->ComputeBoundingGeometry3D(dataStorage->GetAll());
-          mitk::RenderingManager::GetInstance()->InitializeViews(geometry);
+          mitk::RenderingManager::GetInstance()->InitializeViewsByBoundingObjects(dataStorage);
         }
       }
     }
     else
     {
 
       QStringListIterator it(listOfFilesForSeries);
 
       while (it.hasNext())
       {
         seriesToLoad.push_back(it.next().toStdString());
       }
 
 
       mitk::DataNode::Pointer node = mitk::DicomSeriesReader::LoadDicomSeries(seriesToLoad);
       if (node.IsNull())
       {
         MITK_ERROR << "Error loading series: " << ctkEvent.getProperty("SeriesName").toString().toStdString()
                    << " id: " <<ctkEvent.getProperty("SeriesUID").toString().toStdString();
       }
       else
       {
         //Get Reference for default data storage.
         ctkServiceReference serviceReference =mitk::PluginActivator::getContext()->getServiceReference<mitk::IDataStorageService>();
         mitk::IDataStorageService* storageService = mitk::PluginActivator::getContext()->getService<mitk::IDataStorageService>(serviceReference);
         mitk::DataStorage* dataStorage = storageService->GetDefaultDataStorage().GetPointer()->GetDataStorage();
 
         dataStorage->Add(node);
-
-        // Initialize the RenderWindow
-        mitk::TimeGeometry::Pointer geometry = dataStorage->ComputeBoundingGeometry3D(dataStorage->GetAll());
-        mitk::RenderingManager::GetInstance()->InitializeViews(geometry);
       }
     }
   }
   else
   {
     MITK_INFO << "There are no files for the current series";
   }
 }
 
 void DicomEventHandler::OnSignalRemoveSeriesFromStorage(const ctkEvent& ctkEvent)
 {
 }
 
 void DicomEventHandler::SubscribeSlots()
 {
   ctkServiceReference ref = mitk::PluginActivator::getContext()->getServiceReference<ctkEventAdmin>();
   if (ref)
   {
     ctkEventAdmin* eventAdmin = mitk::PluginActivator::getContext()->getService<ctkEventAdmin>(ref);
     ctkDictionary properties;
     properties[ctkEventConstants::EVENT_TOPIC] = "org/mitk/gui/qt/dicom/ADD";
     eventAdmin->subscribeSlot(this, SLOT(OnSignalAddSeriesToDataManager(ctkEvent)), properties);
     properties[ctkEventConstants::EVENT_TOPIC] = "org/mitk/gui/qt/dicom/DELETED";
     eventAdmin->subscribeSlot(this, SLOT(OnSignalRemoveSeriesFromStorage(ctkEvent)), properties);
   }
 }
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 8a3af7129d..e381a988ab 100644
--- a/Plugins/org.mitk.gui.qt.dicom/src/internal/QmitkDicomEditor.cpp
+++ b/Plugins/org.mitk.gui.qt.dicom/src/internal/QmitkDicomEditor.cpp
@@ -1,205 +1,204 @@
 /*===================================================================
 
 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.
 
 ===================================================================*/
 
 // Qmitk
 #include "QmitkDicomEditor.h"
 #include "mitkPluginActivator.h"
 
 
 const std::string QmitkDicomEditor::EDITOR_ID = "org.mitk.editors.dicomeditor";
 const QString QmitkDicomEditor::TEMP_DICOM_FOLDER_SUFFIX="TmpDicomFolder";
 
 
 QmitkDicomEditor::QmitkDicomEditor()
 : m_Thread(new QThread())
 , m_DicomDirectoryListener(new QmitkDicomDirectoryListener())
 , m_StoreSCPLauncher(new QmitkStoreSCPLauncher(&m_Builder))
 , m_Publisher(new QmitkDicomDataEventPublisher())
 {
 }
 
 QmitkDicomEditor::~QmitkDicomEditor()
 {
     m_Thread.quit();
     m_Thread.wait(1000);
     delete m_DicomDirectoryListener;
     delete m_StoreSCPLauncher;
     delete m_Handler;
     delete m_Publisher;
 }
 
 void QmitkDicomEditor::CreateQtPartControl(QWidget *parent )
 {
     m_Controls.setupUi( parent );
     m_Controls.StoreSCPStatusLabel->setTextFormat(Qt::RichText);
     m_Controls.StoreSCPStatusLabel->setText("<img src=':/org.mitk.gui.qt.dicom/network-offline_16.png'>");
 
 
     TestHandler();
 
     SetPluginDirectory();
     SetDatabaseDirectory("DatabaseDirectory");
     CreateTemporaryDirectory();
     StartDicomDirectoryListener();
 
     m_Controls.m_ctkDICOMQueryRetrieveWidget->useProgressDialog(false);
 
     connect(m_Controls.tabWidget, SIGNAL(currentChanged(int)), this, SLOT(OnTabChanged(int)));
 
     connect(m_Controls.externalDataWidget,SIGNAL(SignalStartDicomImport(const QStringList&)),
             m_Controls.internalDataWidget,SLOT(OnStartDicomImport(const QStringList&)));
 
     connect(m_Controls.externalDataWidget,SIGNAL(SignalDicomToDataManager(const QHash<QString,QVariant>&)),
             this,SLOT(OnViewButtonAddToDataManager(const QHash<QString,QVariant>&)));
 
     connect(m_Controls.internalDataWidget,SIGNAL(SignalFinishedImport()),this, SLOT(OnDicomImportFinished()));
     connect(m_Controls.internalDataWidget,SIGNAL(SignalDicomToDataManager(const QHash<QString,QVariant>&)),
             this,SLOT(OnViewButtonAddToDataManager(const QHash<QString,QVariant>&)));
 }
 
 
 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::OnTabChanged(int page)
 {
   if (page == 2)//Query/Retrieve is selected
   {
     QString storagePort = m_Controls.m_ctkDICOMQueryRetrieveWidget->getServerParameters()["StoragePort"].toString();
     QString storageAET = m_Controls.m_ctkDICOMQueryRetrieveWidget->getServerParameters()["StorageAETitle"].toString();
      if(!((m_Builder.GetAETitle()->compare(storageAET,Qt::CaseSensitive)==0)&&
          (m_Builder.GetPort()->compare(storagePort,Qt::CaseSensitive)==0)))
      {
          StopStoreSCP();
          StartStoreSCP();
      }
   }
 }
 
 void QmitkDicomEditor::OnDicomImportFinished()
 {
   m_Controls.tabWidget->setCurrentIndex(0);
 }
 
 void QmitkDicomEditor::StartDicomDirectoryListener()
 {
     if(!m_Thread.isRunning())
     {
         m_DicomDirectoryListener->SetDicomListenerDirectory(m_TempDirectory);
         m_DicomDirectoryListener->SetDicomFolderSuffix(TEMP_DICOM_FOLDER_SUFFIX);
         connect(m_DicomDirectoryListener,SIGNAL(SignalStartDicomImport(const QStringList&)),m_Controls.internalDataWidget,SLOT(OnStartDicomImport(const QStringList&)),Qt::DirectConnection);
         //connect(m_Controls.internalDataWidget,SIGNAL(SignalFinishedImport()),m_DicomDirectoryListener,SLOT(OnImportFinished()),Qt::DirectConnection);
         m_DicomDirectoryListener->moveToThread(&m_Thread);
         m_Thread.start();
     }
 }
 
 
 void QmitkDicomEditor::TestHandler()
 {
     m_Handler = new DicomEventHandler();
     m_Handler->SubscribeSlots();
 }
 
 void QmitkDicomEditor::OnViewButtonAddToDataManager(QHash<QString, QVariant> eventProperties)
 {
     ctkDictionary properties;
 //    properties["PatientName"] = eventProperties["PatientName"];
 //    properties["StudyUID"] = eventProperties["StudyUID"];
 //    properties["StudyName"] = eventProperties["StudyName"];
 //    properties["SeriesUID"] = eventProperties["SeriesUID"];
 //    properties["SeriesName"] = eventProperties["SeriesName"];
     properties["FilesForSeries"] = eventProperties["FilesForSeries"];
     if(eventProperties.contains("Modality"))
     {
       properties["Modality"] = eventProperties["Modality"];
     }
-//    properties["Modality"] = eventProperties["Modality"];
 
     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();
     m_Builder.AddPort(storagePort)->AddAETitle(storageAET)->AddTransferSyntax()->AddOtherNetworkOptions()->AddMode()->AddOutputDirectory(m_TempDirectory);
     m_StoreSCPLauncher = new QmitkStoreSCPLauncher(&m_Builder);
     connect(m_StoreSCPLauncher, SIGNAL(SignalStatusOfStoreSCP(const QString&)), this, SLOT(OnStoreSCPStatusChanged(const QString&)));
     connect(m_StoreSCPLauncher ,SIGNAL(SignalStartImport(const QStringList&)),m_Controls.internalDataWidget,SLOT(OnStartDicomImport(const QStringList&)));
     connect(m_StoreSCPLauncher ,SIGNAL(SignalStoreSCPError(const QString&)),m_DicomDirectoryListener,SLOT(OnDicomNetworkError(const QString&)),Qt::DirectConnection);
     connect(m_StoreSCPLauncher ,SIGNAL(SignalStoreSCPError(const QString&)),this,SLOT(OnDicomNetworkError(const QString&)),Qt::DirectConnection);
     m_StoreSCPLauncher->StartStoreSCP();
 
 }
 
 void QmitkDicomEditor::OnStoreSCPStatusChanged(const QString& status)
 {
     m_Controls.StoreSCPStatusLabel->setText("<img src=':/org.mitk.gui.qt.dicom/network-idle_16.png'> "+status);
 }
 
 void QmitkDicomEditor::OnDicomNetworkError(const QString& status)
 {
     m_Controls.StoreSCPStatusLabel->setText("<img src=':/org.mitk.gui.qt.dicom/network-error_16.png'> "+status);
 }
 
 void QmitkDicomEditor::StopStoreSCP()
 {
     delete m_StoreSCPLauncher;
 }
 
 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::CreateTemporaryDirectory()
 {
     QDir tmp;
     QString tmpPath = QDir::tempPath();
     m_TempDirectory.clear();
     m_TempDirectory.append(tmpPath);
     m_TempDirectory.append(QString("/"));
     m_TempDirectory.append(TEMP_DICOM_FOLDER_SUFFIX);
     m_TempDirectory.append(QString("."));
     m_TempDirectory.append(QTime::currentTime().toString("hhmmsszzz"));
     m_TempDirectory.append(QString::number(QCoreApplication::applicationPid()));
     tmp.mkdir(QDir::toNativeSeparators( m_TempDirectory ));
 
 }