diff --git a/Plugins/org.mitk.gui.qt.xnat/src/internal/QmitkXnatEditor.cpp b/Plugins/org.mitk.gui.qt.xnat/src/internal/QmitkXnatEditor.cpp
index 4ef358f2a1..18277d244d 100644
--- a/Plugins/org.mitk.gui.qt.xnat/src/internal/QmitkXnatEditor.cpp
+++ b/Plugins/org.mitk.gui.qt.xnat/src/internal/QmitkXnatEditor.cpp
@@ -1,558 +1,565 @@
 /*===================================================================
 
 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 "QmitkXnatEditor.h"
 
 // Qmitk
 #include "QmitkXnatObjectEditorInput.h"
 #include "org_mitk_gui_qt_xnatinterface_Activator.h"
 
 // CTK XNAT Core
 #include "ctkXnatObject.h"
 #include "ctkXnatDataModel.h"
 #include "ctkXnatFile.h"
 #include "ctkXnatResource.h"
 #include "ctkXnatScan.h"
 #include "ctkXnatScanFolder.h"
 #include "ctkXnatAssessor.h"
 #include "ctkXnatAssessorFolder.h"
 #include "ctkXnatReconstruction.h"
 #include "ctkXnatReconstructionFolder.h"
 
 // CTK XNAT Widgets
 #include "ctkXnatListModel.h"
 
 // Blueberry
 #include <berryQModelIndexObject.h>
 #include <berryIWorkbenchPage.h>
 #include <berryPlatform.h>
 
 // Qt
 #include <QListView>
 #include <QRegExp>
 #include <QModelIndex>
 #include <QDir>
 #include <QDirIterator>
 #include <QMessageBox>
 
 // MITK
 #include <mitkDataStorage.h>
-#include <mitkIOUtil.h>
+#include <QmitkIOUtil.h>
 
 // Poco
 #include <Poco/Zip/Decompress.h>
 
 const QString QmitkXnatEditor::EDITOR_ID = "org.mitk.editors.xnat.browser";
 
 QmitkXnatEditor::QmitkXnatEditor() :
 m_DownloadPath(berry::Platform::GetPreferencesService()->
 GetSystemPreferences()->Node("/XnatConnection")->Get("Download Path", "")),
 m_ListModel(new ctkXnatListModel()),
 m_Session(0),
 m_DataStorageServiceTracker(mitk::org_mitk_gui_qt_xnatinterface_Activator::GetContext()),
 m_SelectionListener(new berry::SelectionChangedAdapter<QmitkXnatEditor>(this, &QmitkXnatEditor::SelectionChanged))
 {
   m_DataStorageServiceTracker.open();
   if (m_DownloadPath.isEmpty())
   {
     QString xnatFolder = "XNAT_DOWNLOADS";
     QDir dir(mitk::org_mitk_gui_qt_xnatinterface_Activator::GetContext()->getDataFile("").absoluteFilePath());
     dir.mkdir(xnatFolder);
     dir.setPath(dir.path() + "/" + xnatFolder);
     m_DownloadPath = dir.path() + "/";
   }
 }
 
 QmitkXnatEditor::~QmitkXnatEditor()
 {
   delete m_ListModel;
   berry::ISelectionService* s = GetSite()->GetWorkbenchWindow()->GetSelectionService();
   s->RemoveSelectionListener(m_SelectionListener.data());
   m_DataStorageServiceTracker.close();
 }
 
 bool QmitkXnatEditor::IsDirty() const
 {
   return false;
 }
 
 bool QmitkXnatEditor::IsSaveAsAllowed() const
 {
   return false;
 }
 
 void QmitkXnatEditor::Init(berry::IEditorSite::Pointer site, berry::IEditorInput::Pointer input)
 {
   this->SetSite(site);
   berry::QtEditorPart::SetInput(input);
   this->SetInput(input);
 }
 
 void QmitkXnatEditor::DoSave()
 {
 }
 
 void QmitkXnatEditor::DoSaveAs()
 {
 }
 
 void QmitkXnatEditor::SetInput(berry::IEditorInput::Pointer input)
 {
   QmitkXnatObjectEditorInput::Pointer oPtr = input.Cast<QmitkXnatObjectEditorInput>();
   if (oPtr.IsNotNull())
   {
     berry::QtEditorPart::SetInput(oPtr);
     this->GetEditorInput().Cast<QmitkXnatObjectEditorInput>()->GetXnatObject()->fetch();
   }
 }
 
 void QmitkXnatEditor::SetFocus()
 {
 }
 
 void QmitkXnatEditor::CreateQtPartControl(QWidget *parent)
 {
   // create GUI widgets from the Qt Designer's .ui file
   m_Controls.setupUi(parent);
   m_Controls.buttonDownload->setEnabled(false);
   m_Controls.labelDownload->setText("Select a xnat file, resource, scan, or scan folder to download...");
 
   GetSite()->GetWorkbenchWindow()->GetSelectionService()->AddSelectionListener(m_SelectionListener.data());
 
   connect(m_Controls.treeView, SIGNAL(activated(const QModelIndex&)), this, SLOT(OnObjectActivated(const QModelIndex&)));
 
   connect(m_Controls.buttonDownload, SIGNAL(clicked()), this, SLOT(DownloadResource()));
   connect(m_Controls.buttonDataModel, SIGNAL(clicked()), this, SLOT(OnDataModelButtonClicked()));
   connect(m_Controls.buttonProject, SIGNAL(clicked()), this, SLOT(OnProjectButtonClicked()));
   connect(m_Controls.buttonSubject, SIGNAL(clicked()), this, SLOT(OnSubjectButtonClicked()));
   connect(m_Controls.buttonExperiment, SIGNAL(clicked()), this, SLOT(OnExperimentButtonClicked()));
   connect(m_Controls.buttonKindOfData, SIGNAL(clicked()), this, SLOT(OnKindOfDataButtonClicked()));
   connect(m_Controls.buttonSession, SIGNAL(clicked()), this, SLOT(OnSessionButtonClicked()));
   connect(m_Controls.buttonResource, SIGNAL(clicked()), this, SLOT(OnResourceButtonClicked()));
   connect(m_Controls.treeView, SIGNAL(clicked(const QModelIndex&)), SLOT(itemSelected(const QModelIndex&)));
 
   m_Tracker = new mitk::XnatSessionTracker(mitk::org_mitk_gui_qt_xnatinterface_Activator::GetXnatModuleContext());
 
   connect(m_Tracker, SIGNAL(AboutToBeClosed(ctkXnatSession*)), this, SLOT(CleanListModel(ctkXnatSession*)));
   connect(m_Tracker, SIGNAL(Opened(ctkXnatSession*)), this, SLOT(UpdateSession(ctkXnatSession*)));
 
   m_Tracker->Open();
 
   // Makes the breadcrumb feature invisible
   for (int i = 0; i < m_Controls.breadcrumbHorizontalLayout->count() - 1; i++)
   {
     QLayoutItem* child = m_Controls.breadcrumbHorizontalLayout->itemAt(i);
     child->widget()->setVisible(false);
   }
   for (int i = 0; i < m_Controls.breadcrumbDescriptionLayout->count() - 1; i++)
   {
     QLayoutItem* child = m_Controls.breadcrumbDescriptionLayout->itemAt(i);
     child->widget()->setVisible(false);
   }
   QmitkXnatObjectEditorInput::Pointer oPtr = GetEditorInput().Cast<QmitkXnatObjectEditorInput>();
   if (oPtr.IsNotNull())
   {
     UpdateList();
   }
   else
   {
     ctkXnatSession* session;
     try
     {
       session = mitk::org_mitk_gui_qt_xnatinterface_Activator::GetXnatModuleContext()->GetService(
         mitk::org_mitk_gui_qt_xnatinterface_Activator::GetXnatModuleContext()->GetServiceReference<ctkXnatSession>());
     }
     catch (std::invalid_argument)
     {
       session = 0;
     }
     UpdateSession(session);
   }
 }
 
 void QmitkXnatEditor::UpdateList()
 {
   QmitkXnatObjectEditorInput::Pointer xoPtr(GetEditorInput().Cast<QmitkXnatObjectEditorInput>());
   if (xoPtr.IsNull())
     return;
   ctkXnatObject* inputObject = xoPtr->GetXnatObject();
   if (inputObject == NULL)
     return;
 
   m_Controls.treeView->setModel(m_ListModel);
   m_ListModel->setRootObject(inputObject);
   m_Controls.treeView->reset();
 
   // recursive method to check parents of the inputObject
   m_ParentCount = ParentChecker(inputObject);
 
   // breadcrumb labels
   for (int i = 0; i < m_Controls.breadcrumbHorizontalLayout->count() - 1; i++)
   {
     QLayoutItem* child = m_Controls.breadcrumbHorizontalLayout->itemAt(i);
     child->widget()->setVisible(false);
   }
   for (int i = 0; i < m_Controls.breadcrumbDescriptionLayout->count() - 1; i++)
   {
     QLayoutItem* child = m_Controls.breadcrumbDescriptionLayout->itemAt(i);
     child->widget()->setVisible(false);
   }
 
   ctkXnatObject* parent = NULL;
   for (int i = m_ParentCount * 2; i >= 0; i--)
   {
     if (i > 12)
       break;
     m_Controls.breadcrumbDescriptionLayout->itemAt(i)->widget()->setVisible(true);
     QLayoutItem* child = m_Controls.breadcrumbHorizontalLayout->itemAt(i);
     child->widget()->setVisible(true);
     if (i > 0)
     {
       m_Controls.breadcrumbHorizontalLayout->itemAt(i - 1)->widget()->setVisible(true);
       m_Controls.breadcrumbDescriptionLayout->itemAt(i - 1)->widget()->setVisible(true);
     }
     if (parent == NULL)
     {
       parent = inputObject;
     }
     // create breadcrumb button
     QPushButton* breadcrumbButton = dynamic_cast<QPushButton*>(child->widget());
     breadcrumbButton->setText(parent->id());
     parent = parent->parent();
     i--;
   }
   m_Controls.buttonDataModel->setText("root");
   m_Controls.buttonDownload->setEnabled(false);
   m_Controls.labelDownload->setVisible(true);
 }
 
 void QmitkXnatEditor::SelectionChanged(const berry::IWorkbenchPart::Pointer& sourcepart,
   const berry::ISelection::ConstPointer& selection)
 {
   // check for null selection
   if (selection.IsNull())
   {
     return;
   }
   // exclude own selection events and check whether this kind of selection can be handled
   if (sourcepart != this &&
     selection.Cast<const berry::IStructuredSelection>())
   {
     berry::IStructuredSelection::ConstPointer currentSelection = selection.Cast<const berry::IStructuredSelection>();
     // iterates over the selection
     for (berry::IStructuredSelection::iterator itr = currentSelection->Begin();
       itr != currentSelection->End(); ++itr)
     {
       if (berry::SmartPointer<berry::QModelIndexObject> objectPointer = itr->Cast<berry::QModelIndexObject>())
       {
         // get object of selected ListWidgetElement
         ctkXnatObject* object = objectPointer->GetQModelIndex().data(Qt::UserRole).value<ctkXnatObject*>();
 
         // if a file is selected, don't change the input and list view
         if (dynamic_cast<ctkXnatFile*>(object) == NULL)
         {
           QmitkXnatObjectEditorInput::Pointer oPtr(new QmitkXnatObjectEditorInput(object));
           berry::IEditorInput::Pointer editorInput(oPtr);
           if (!(editorInput == this->GetEditorInput()))
             this->SetInput(editorInput);
 
           UpdateList();
         }
       }
     }
   }
 }
 
 void QmitkXnatEditor::DownloadResource()
 {
   if (!m_Controls.treeView->selectionModel()->hasSelection())
     return;
 
   const QModelIndex index = m_Controls.treeView->selectionModel()->currentIndex();
   QVariant variant = m_ListModel->data(index, Qt::UserRole);
   if (variant.isValid())
   {
     ctkXnatObject* resource = variant.value<ctkXnatObject*>();
     if (dynamic_cast<ctkXnatFile*>(resource) == NULL)
     {
       MITK_INFO << "Download started ...";
       MITK_INFO << "...";
       QString resourceName = m_ListModel->data(index, Qt::DisplayRole).toString();
       QString resourcePath = m_DownloadPath + resourceName + ".zip";
       resource->download(resourcePath);
 
       // Testing if the path exists
       QDir downDir(m_DownloadPath);
       if (downDir.exists(resourceName + ".zip"))
       {
         MITK_INFO << "Download of " << resourceName.toStdString() << ".zip was completed!";
       }
       else
       {
         MITK_INFO << "Download of " << resourceName.toStdString() << ".zip failed!";
       }
     }
     else
     {
       InternalFileDownload(index);
     }
   }
 }
 
 void QmitkXnatEditor::ToHigherLevel()
 {
   ctkXnatObject* parent = GetEditorInput().Cast<QmitkXnatObjectEditorInput>()->GetXnatObject()->parent();
   if (parent == NULL)
   {
     return;
   }
   QmitkXnatObjectEditorInput::Pointer oPtr(new QmitkXnatObjectEditorInput(parent));
   berry::IEditorInput::Pointer editorInput(oPtr);
   this->SetInput(editorInput);
   UpdateList();
 }
 
 void QmitkXnatEditor::OnObjectActivated(const QModelIndex &index)
 {
   if (!index.isValid()) return;
 
   ctkXnatObject* child = GetEditorInput().Cast<QmitkXnatObjectEditorInput>()->GetXnatObject()->children().at(index.row());
   if (child != NULL)
   {
     ctkXnatFile* file = dynamic_cast<ctkXnatFile*>(child);
     if (file != NULL)
     {
       // Download file and put into datamanager
       InternalFileDownload(index);
       mitk::IDataStorageService* dsService = m_DataStorageServiceTracker.getService();
       if (dsService != NULL)
       {
         QString name = file->property("Name");
         QString filePath = m_DownloadPath + name;
 
         if (file->property("collection") == "DICOM")
         {
           QDirIterator it(m_DownloadPath, QStringList() << name, QDir::Files, QDirIterator::Subdirectories);
           while (it.hasNext()) {
             it.next();
             filePath = it.filePath();
           }
         }
 
-        mitk::DataNode::Pointer node = mitk::IOUtil::LoadDataNode(filePath.toStdString());
-        if ((node.IsNotNull()) && (node->GetData() != NULL))
+        mitk::IDataStorageService* dsService = m_DataStorageServiceTracker.getService();
+        mitk::DataStorage::Pointer dataStorage = dsService->GetDataStorage()->GetDataStorage();
+        QStringList list;
+        list << filePath;
+        try
         {
-          dsService->GetDataStorage()->GetDataStorage()->Add(node);
-          mitk::BaseData::Pointer basedata = node->GetData();
-          mitk::RenderingManager::GetInstance()->InitializeViews(
-            basedata->GetTimeGeometry(), mitk::RenderingManager::REQUEST_UPDATE_ALL, true);
+          QmitkIOUtil::Load(list, *dataStorage);
         }
+        catch (const mitk::Exception& e)
+        {
+          MITK_INFO << e;
+          return;
+        }
+        mitk::RenderingManager::GetInstance()->InitializeViewsByBoundingObjects(
+          dsService->GetDataStorage()->GetDataStorage());
       }
     }
     else
     {
       // Updates the root item
       QmitkXnatObjectEditorInput::Pointer oPtr(new QmitkXnatObjectEditorInput(child));
       berry::IEditorInput::Pointer editorInput(oPtr);
       this->SetInput(editorInput);
 
       this->GetEditorInput().Cast<QmitkXnatObjectEditorInput>()->GetXnatObject()->fetch();
 
       UpdateList();
     }
   }
 }
 
 void QmitkXnatEditor::InternalFileDownload(const QModelIndex& index)
 {
   QVariant variant = m_ListModel->data(index, Qt::UserRole);
   if (variant.isValid())
   {
     ctkXnatFile* file = dynamic_cast<ctkXnatFile*>(variant.value<ctkXnatObject*>());
     if (file != NULL)
     {
       // Testing if the file exists
       QDir downDir(m_DownloadPath);
       if (downDir.exists(file->property("Name")))
       {
         MITK_INFO << "File exists already!";
         return;
       }
 
       if (file->property("collection") == QString("DICOM"))
       {
         ctkXnatObject* parent = file->parent();
 
         QString filePath = m_DownloadPath + parent->property("label") + ".zip";
         parent->download(filePath);
 
         std::ifstream in(filePath.toStdString().c_str(), std::ios::binary);
         poco_assert(in);
 
         // decompress to XNAT_DOWNLOAD dir
         Poco::Zip::Decompress dec(in, Poco::Path(m_DownloadPath.toStdString()));
         dec.decompressAllFiles();
 
         in.close();
         QFile::remove(filePath);
       }
       else
       {
         MITK_INFO << "Download started ...";
         MITK_INFO << "...";
         QString name = file->property("Name");
         QString filePath = m_DownloadPath + name;
         file->download(filePath);
 
         // Testing if the file exists
         QDir downDir(m_DownloadPath);
         if (downDir.exists(name))
         {
           MITK_INFO << "Download of " << file->name().toStdString() << " was completed!";
         }
         else
         {
           MITK_INFO << "Download of " << file->name().toStdString() << " failed!";
         }
       }
     }
     else
     {
       MITK_INFO << "Selection was not a file!";
     }
   }
 }
 
 int QmitkXnatEditor::ParentChecker(ctkXnatObject* child)
 {
   int sum;
   if (child->parent() == NULL)
   {
     return 0;
   }
   else
   {
     sum = 1 + ParentChecker(child->parent());
   }
   return sum;
 }
 
 void QmitkXnatEditor::OnDataModelButtonClicked()
 {
   for (int i = m_ParentCount; i > 0; i--)
   {
     ToHigherLevel();
   }
 }
 
 void QmitkXnatEditor::OnProjectButtonClicked()
 {
   for (int i = m_ParentCount - 1; i > 0; i--)
   {
     ToHigherLevel();
   }
 }
 
 void QmitkXnatEditor::OnSubjectButtonClicked()
 {
   for (int i = m_ParentCount - 2; i > 0; i--)
   {
     ToHigherLevel();
   }
 }
 
 void QmitkXnatEditor::OnExperimentButtonClicked()
 {
   for (int i = m_ParentCount - 3; i > 0; i--)
   {
     ToHigherLevel();
   }
 }
 
 void QmitkXnatEditor::OnKindOfDataButtonClicked()
 {
   for (int i = m_ParentCount - 4; i > 0; i--)
   {
     ToHigherLevel();
   }
 }
 
 void QmitkXnatEditor::OnSessionButtonClicked()
 {
   for (int i = m_ParentCount - 5; i > 0; i--)
   {
     ToHigherLevel();
   }
 }
 
 void QmitkXnatEditor::OnResourceButtonClicked()
 {
   for (int i = m_ParentCount - 6; i > 0; i--)
   {
     ToHigherLevel();
   }
 }
 
 void QmitkXnatEditor::UpdateSession(ctkXnatSession* session)
 {
   GetSite()->GetWorkbenchWindow()->GetSelectionService()->RemoveSelectionListener(m_SelectionListener.data());
 
   if (session != 0 && session->isOpen())
   {
     m_Controls.labelInfo->setText("Current Position:");
     m_Controls.labelInfo->setStyleSheet("QLabel { color: black; }");
 
     // Fill model and show in the GUI
     QmitkXnatObjectEditorInput::Pointer xoPtr(new QmitkXnatObjectEditorInput(session->dataModel()));
     berry::IEditorInput::Pointer editorInput(xoPtr);
     this->SetInput(editorInput);
     this->GetEditorInput().Cast<QmitkXnatObjectEditorInput>()->GetXnatObject()->fetch();
     UpdateList();
   }
   else
   {
     m_Controls.labelInfo->setText("Please check the Preferences of the XNAT Connection.\nMaybe they are not ok.");
     m_Controls.labelInfo->setStyleSheet("QLabel { color: red; }");
   }
 
   GetSite()->GetWorkbenchWindow()->GetSelectionService()->AddSelectionListener(m_SelectionListener.data());
 }
 
 void QmitkXnatEditor::CleanListModel(ctkXnatSession* session)
 {
   if (session != 0)
   {
     m_Controls.treeView->setModel(0);
     m_ListModel->setRootObject(0);
     m_Controls.treeView->reset();
   }
 }
 
 void QmitkXnatEditor::itemSelected(const QModelIndex &index)
 {
   ctkXnatObject* xnatObject = m_ListModel->data(index, Qt::UserRole).value<ctkXnatObject*>();
   bool downloadable = false;
   downloadable |= dynamic_cast<ctkXnatFile*>(xnatObject) != NULL;
   downloadable |= dynamic_cast<ctkXnatScan*>(xnatObject) != NULL;
   downloadable |= dynamic_cast<ctkXnatScanFolder*>(xnatObject) != NULL;
   downloadable |= dynamic_cast<ctkXnatAssessor*>(xnatObject) != NULL;
   downloadable |= dynamic_cast<ctkXnatAssessorFolder*>(xnatObject) != NULL;
   downloadable |= dynamic_cast<ctkXnatResource*>(xnatObject) != NULL;
   downloadable |= dynamic_cast<ctkXnatReconstruction*>(xnatObject) != NULL;
   downloadable |= dynamic_cast<ctkXnatReconstructionFolder*>(xnatObject) != NULL;
   m_Controls.buttonDownload->setEnabled(downloadable);
   m_Controls.labelDownload->setVisible(!downloadable);
 }
diff --git a/Plugins/org.mitk.gui.qt.xnat/src/internal/QmitkXnatTreeBrowserView.cpp b/Plugins/org.mitk.gui.qt.xnat/src/internal/QmitkXnatTreeBrowserView.cpp
index 2038df20f5..cc9cd9cf51 100644
--- a/Plugins/org.mitk.gui.qt.xnat/src/internal/QmitkXnatTreeBrowserView.cpp
+++ b/Plugins/org.mitk.gui.qt.xnat/src/internal/QmitkXnatTreeBrowserView.cpp
@@ -1,280 +1,313 @@
 /*===================================================================
 
 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 "QmitkXnatTreeBrowserView.h"
 
 // Qmitk
 #include "QmitkXnatObjectEditorInput.h"
 #include "QmitkXnatEditor.h"
 #include "org_mitk_gui_qt_xnatinterface_Activator.h"
 
 // Blueberry
 #include <berryIWorkbenchPage.h>
 #include <berryPlatform.h>
 
 // CTK XNAT Core
 #include "ctkXnatFile.h"
 
 // Qt
 #include <QDir>
 #include <QMenu>
 #include <QAction>
+#include <QDirIterator>
 
 // MITK
 #include <mitkDataStorage.h>
 #include <QmitkIOUtil.h>
 
+// Poco
+#include <Poco/Zip/Decompress.h>
+
 const std::string QmitkXnatTreeBrowserView::VIEW_ID = "org.mitk.views.xnat.treebrowser";
 
 QmitkXnatTreeBrowserView::QmitkXnatTreeBrowserView() :
 m_TreeModel(new ctkXnatTreeModel()),
 m_Tracker(0),
 m_DownloadPath(berry::Platform::GetPreferencesService()->GetSystemPreferences()->Node("/XnatConnection")->Get("Download Path", "")),
 m_DataStorageServiceTracker(mitk::org_mitk_gui_qt_xnatinterface_Activator::GetContext())
 {
   m_DataStorageServiceTracker.open();
 
   // Set DownloadPath
   if (m_DownloadPath.isEmpty())
   {
     QString xnatFolder = "XNAT_DOWNLOADS";
     QDir dir(mitk::org_mitk_gui_qt_xnatinterface_Activator::GetContext()->getDataFile("").absoluteFilePath());
     dir.mkdir(xnatFolder);
     dir.setPath(dir.path() + "/" + xnatFolder);
     m_DownloadPath = dir.path() + "/";
   }
 }
 
 QmitkXnatTreeBrowserView::~QmitkXnatTreeBrowserView()
 {
   delete m_TreeModel;
   delete m_Tracker;
 }
 
 void QmitkXnatTreeBrowserView::SetFocus()
 {
 }
 
 void QmitkXnatTreeBrowserView::CreateQtPartControl(QWidget *parent)
 {
   // Create GUI widgets from the Qt Designer's .ui file
   m_Controls.setupUi(parent);
   m_Controls.treeView->setModel(m_TreeModel);
   m_Controls.treeView->header()->hide();
   m_Controls.labelError->setText("Please use the 'Connect' button in the Preferences.");
   m_Controls.labelError->setStyleSheet("QLabel { color: red; }");
 
   m_SelectionProvider = new berry::QtSelectionProvider();
   this->SetSelectionProvider();
   m_Controls.treeView->setSelectionMode(QAbstractItemView::SingleSelection);
   m_Controls.treeView->setContextMenuPolicy(Qt::CustomContextMenu);
 
   m_Tracker = new mitk::XnatSessionTracker(mitk::org_mitk_gui_qt_xnatinterface_Activator::GetXnatModuleContext());
   m_NodeMenu = new QMenu(m_Controls.treeView);
 
   connect(m_Controls.treeView, SIGNAL(customContextMenuRequested(const QPoint&)),
     this, SLOT(NodeTableViewContextMenuRequested(const QPoint&)));
   connect(m_Tracker, SIGNAL(AboutToBeClosed(ctkXnatSession*)), this, SLOT(CleanTreeModel(ctkXnatSession*)));
   connect(m_Tracker, SIGNAL(Opened(ctkXnatSession*)), this, SLOT(UpdateSession(ctkXnatSession*)));
 
   m_Tracker->Open();
 
   ctkXnatSession* session;
 
   try
   {
     session = mitk::org_mitk_gui_qt_xnatinterface_Activator::GetXnatModuleContext()->GetService(
       mitk::org_mitk_gui_qt_xnatinterface_Activator::GetXnatModuleContext()->GetServiceReference<ctkXnatSession>());
   }
   catch (std::invalid_argument)
   {
     session = 0;
   }
 
   if (session != 0)
   {
     m_Controls.labelError->setVisible(false);
   }
   else
   {
     m_Controls.labelError->setVisible(true);
   }
 
   connect(m_Controls.treeView, SIGNAL(activated(const QModelIndex&)), this, SLOT(OnActivatedNode(const QModelIndex&)));
 }
 
 void QmitkXnatTreeBrowserView::OnActivatedNode(const QModelIndex& index)
 {
   if (!index.isValid()) return;
 
   berry::IWorkbenchPage::Pointer page = GetSite()->GetPage();
   QmitkXnatObjectEditorInput::Pointer oPtr(new QmitkXnatObjectEditorInput(index.data(Qt::UserRole).value<ctkXnatObject*>()));
   berry::IEditorInput::Pointer editorInput(oPtr);
   berry::IEditorPart::Pointer reuseEditor = page->FindEditor(editorInput);
 
   if (reuseEditor)
   {
     // Just set it activ
     page->Activate(reuseEditor);
   }
   else
   {
     QList<berry::IEditorReference::Pointer> editors =
       page->FindEditors(berry::IEditorInput::Pointer(0), QmitkXnatEditor::EDITOR_ID, berry::IWorkbenchPage::MATCH_ID);
 
     if (editors.isEmpty())
     {
       ctkXnatFile* file = dynamic_cast<ctkXnatFile*>(oPtr->GetXnatObject());
       if (file != NULL)
       {
         // If the selected node is a file, so show it in MITK
         InternalFileDownload(index, true);
       }
       else
       {
         // No XnatEditor is currently open, create a new one
         page->OpenEditor(editorInput, QmitkXnatEditor::EDITOR_ID);
       }
     }
     else
     {
       // Reuse an existing editor
       reuseEditor = editors.front()->GetEditor(true);
       page->ReuseEditor(reuseEditor.Cast<berry::IReusableEditor>(), editorInput);
       page->Activate(reuseEditor);
     }
   }
 }
 
 void QmitkXnatTreeBrowserView::SetSelectionProvider()
 {
   GetSite()->SetSelectionProvider(m_SelectionProvider);
 }
 
 void QmitkXnatTreeBrowserView::UpdateSession(ctkXnatSession* session)
 {
   if (session != 0 && session->isOpen())
   {
     m_Controls.labelError->setVisible(false);
     // Fill model and show in the GUI
     m_TreeModel->addDataModel(session->dataModel());
     m_Controls.treeView->reset();
     m_SelectionProvider->SetItemSelectionModel(m_Controls.treeView->selectionModel());
   }
 }
 
 void QmitkXnatTreeBrowserView::CleanTreeModel(ctkXnatSession* session)
 {
   if (session != 0)
   {
     m_TreeModel->removeDataModel(session->dataModel());
     m_Controls.treeView->reset();
   }
 }
 
 void QmitkXnatTreeBrowserView::InternalFileDownload(const QModelIndex& index, bool loadData)
 {
   QVariant variant = m_TreeModel->data(index, Qt::UserRole);
   if (variant.isValid())
   {
     ctkXnatFile* file = dynamic_cast<ctkXnatFile*>(variant.value<ctkXnatObject*>());
     if (file != NULL)
     {
       QDir downDir(m_DownloadPath);
       QString filePath = m_DownloadPath + file->name();
 
       // Testing if the file exists already
       if (downDir.exists(file->name()))
       {
         MITK_INFO << "File '" << file->name().toStdString() << "' already exists!";
       }
       else
       {
-        MITK_INFO << "Download started ...";
-        MITK_INFO << "...";
-        file->download(filePath);
-
-        // Testing if the file exists now
-        if (downDir.exists(file->name()))
+        if (file->property("collection") == QString("DICOM"))
         {
-          MITK_INFO << "Download of " << file->name().toStdString() << " was completed!";
+          ctkXnatObject* parent = file->parent();
+
+          filePath = m_DownloadPath + parent->property("label") + ".zip";
+          parent->download(filePath);
+
+          std::ifstream in(filePath.toStdString().c_str(), std::ios::binary);
+          poco_assert(in);
+
+          // decompress to XNAT_DOWNLOAD dir
+          Poco::Zip::Decompress dec(in, Poco::Path(m_DownloadPath.toStdString()));
+          dec.decompressAllFiles();
+
+          in.close();
+          QFile::remove(filePath);
         }
         else
         {
-          MITK_INFO << "Download of " << file->name().toStdString() << " failed!";
+          MITK_INFO << "Download started ...";
+          MITK_INFO << "...";
+          file->download(filePath);
+
+          // Testing if the file exists now
+          if (downDir.exists(file->name()))
+          {
+            MITK_INFO << "Download of " << file->name().toStdString() << " was completed!";
+          }
+          else
+          {
+            MITK_INFO << "Download of " << file->name().toStdString() << " failed!";
+          }
         }
       }
-      if (downDir.exists(file->name()))
+      if (downDir.exists(file->name()) || file->property("collection") == "DICOM")
       {
         if (loadData)
         {
+          if (file->property("collection") == "DICOM")
+          {
+            // Search for the downloaded file an its file path
+            QDirIterator it(m_DownloadPath, QStringList() << file->name(), QDir::Files, QDirIterator::Subdirectories);
+            while (it.hasNext()) {
+              it.next();
+              filePath = it.filePath();
+            }
+          }
           mitk::IDataStorageService* dsService = m_DataStorageServiceTracker.getService();
           mitk::DataStorage::Pointer dataStorage = dsService->GetDataStorage()->GetDataStorage();
           QStringList list;
-          list << (m_DownloadPath + file->name());
+          list << filePath;
           try
           {
             QmitkIOUtil::Load(list, *dataStorage);
           }
           catch (const mitk::Exception& e)
           {
             MITK_INFO << e;
             return;
           }
           mitk::RenderingManager::GetInstance()->InitializeViewsByBoundingObjects(
             dsService->GetDataStorage()->GetDataStorage());
         }
       }
     }
     else
     {
       MITK_INFO << "Selection was not a file!";
     }
   }
 }
 
 void QmitkXnatTreeBrowserView::OnContextMenuDownloadFile()
 {
   QModelIndex index = m_Controls.treeView->currentIndex();
   InternalFileDownload(index, false);
 }
 
 void QmitkXnatTreeBrowserView::OnContextMenuDownloadAndOpenFile()
 {
   QModelIndex index = m_Controls.treeView->currentIndex();
   InternalFileDownload(index, true);
 }
 
 void QmitkXnatTreeBrowserView::NodeTableViewContextMenuRequested(const QPoint & pos)
 {
   m_NodeMenu->clear();
   QModelIndex index = m_Controls.treeView->indexAt(pos);
   QVariant variant = m_TreeModel->data(index, Qt::UserRole);
   if (variant.isValid())
   {
     ctkXnatFile* file = dynamic_cast<ctkXnatFile*>(variant.value<ctkXnatObject*>());
     if (file != NULL)
     {
       QAction* actShow = new QAction("Download and Open", m_NodeMenu);
       QAction* actDownload = new QAction("Download", m_NodeMenu);
       m_NodeMenu->addAction(actShow);
       m_NodeMenu->addAction(actDownload);
       connect(actShow, SIGNAL(triggered()), this, SLOT(OnContextMenuDownloadAndOpenFile()));
       connect(actDownload, SIGNAL(triggered()), this, SLOT(OnContextMenuDownloadFile()));
       m_NodeMenu->popup(QCursor::pos());
     }
   }
 }