diff --git a/Plugins/org.mitk.gui.qt.xnat/src/internal/QmitkXnatConnectionPreferencePage.cpp b/Plugins/org.mitk.gui.qt.xnat/src/internal/QmitkXnatConnectionPreferencePage.cpp
index 569f7f8924..e53676181a 100644
--- a/Plugins/org.mitk.gui.qt.xnat/src/internal/QmitkXnatConnectionPreferencePage.cpp
+++ b/Plugins/org.mitk.gui.qt.xnat/src/internal/QmitkXnatConnectionPreferencePage.cpp
@@ -1,274 +1,280 @@
 /*===================================================================
 
 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 "QmitkXnatConnectionPreferencePage.h"
 
 #include "org_mitk_gui_qt_xnatinterface_Activator.h"
 
 #include "berryIPreferencesService.h"
 #include "berryPlatform.h"
 
 #include <QLabel>
 #include <QPushButton>
 #include <QLineEdit>
 #include <QGridLayout>
 #include <QMessageBox>
 #include <QApplication>
 #include <QMap>
 
 #include "ctkXnatSession.h"
 #include "ctkXnatLoginProfile.h"
 #include "ctkXnatException.h"
 
 #include <mitkIOUtil.h>
 
 using namespace berry;
 
 QmitkXnatConnectionPreferencePage::QmitkXnatConnectionPreferencePage()
   : m_Control(0)
 {
 
 }
 
 void QmitkXnatConnectionPreferencePage::Init(berry::IWorkbench::Pointer )
 {
 
 }
 
 void QmitkXnatConnectionPreferencePage::CreateQtControl(QWidget* parent)
 {
   IPreferencesService* prefService = Platform::GetPreferencesService();
   berry::IPreferences::Pointer _XnatConnectionPreferencesNode = prefService->GetSystemPreferences()->Node("/XnatConnection");
   m_XnatConnectionPreferencesNode = _XnatConnectionPreferencesNode;
 
   m_Controls.setupUi(parent);
   m_Control = new QWidget(parent);
   m_Control->setLayout(m_Controls.gridLayout);
 
   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)
   {
     if(session->isOpen())
     {
       m_Controls.testConnectionButton->setText("Disconnect");
     }
     else
     {
       m_Controls.testConnectionButton->setText("Connect");
     }
   }
 
   const QIntValidator *portV = new QIntValidator(0, 65535, parent);
   m_Controls.inPort->setValidator(portV);
 
   const QRegExp hostRx("^(https?)://[^ /](\\S)+$");
   const QRegExpValidator *hostV = new QRegExpValidator(hostRx, parent);
   m_Controls.inHostAddress->setValidator(hostV);
 
   connect( m_Controls.testConnectionButton, SIGNAL(clicked()), this, SLOT(ToggleConnection()) );
 
   connect(m_Controls.inHostAddress, SIGNAL(editingFinished()), this, SLOT(UrlChanged()));
   connect(m_Controls.inDownloadPath, SIGNAL(editingFinished()), this, SLOT(DownloadPathChanged()));
 
   this->Update();
 }
 
 QWidget* QmitkXnatConnectionPreferencePage::GetQtControl() const
 {
   return m_Control;
 }
 
 bool QmitkXnatConnectionPreferencePage::PerformOk()
 {
   if(!UserInformationEmpty())
   {
     IPreferences::Pointer _XnatConnectionPreferencesNode = m_XnatConnectionPreferencesNode.Lock();
     if(_XnatConnectionPreferencesNode.IsNotNull())
     {
       _XnatConnectionPreferencesNode->Put(m_Controls.hostAddressLabel->text(), m_Controls.inHostAddress->text());
       _XnatConnectionPreferencesNode->Put(m_Controls.portLabel->text(), m_Controls.inPort->text());
       _XnatConnectionPreferencesNode->Put(m_Controls.usernameLabel->text(), m_Controls.inUsername->text());
       _XnatConnectionPreferencesNode->Put(m_Controls.passwortLabel->text(), m_Controls.inPassword->text());
       _XnatConnectionPreferencesNode->Put(m_Controls.downloadPathLabel->text(), m_Controls.inDownloadPath->text());
 
       _XnatConnectionPreferencesNode->Flush();
 
       return true;
     }
   }
   else
   {
     QMessageBox::critical(QApplication::activeWindow(), "Saving Preferences failed",
       "The connection parameters in XNAT Preferences were empty.\nPlease use the 'Connect' button to validate the connection parameters.");
   }
   return false;
 }
 
 void QmitkXnatConnectionPreferencePage::PerformCancel()
 {
 
 }
 
 bool QmitkXnatConnectionPreferencePage::UserInformationEmpty()
 {
   // To check empty QLineEdits in the following
   QString errString;
 
   if(m_Controls.inHostAddress->text().isEmpty())
   {
     errString += "Server Address is empty.\n";
   }
 
   if(m_Controls.inUsername->text().isEmpty())
   {
     errString += "Username is empty.\n";
   }
 
   if(m_Controls.inPassword->text().isEmpty())
   {
     errString += "Password is empty.\n";
   }
 
   // if something is empty
   if(!errString.isEmpty())
   {
     m_Controls.testConnectionLabel->setStyleSheet("QLabel { color: red; }");
     m_Controls.testConnectionLabel->setText("Connecting failed.\n" + errString);
     return true;
   }
   else
   {
     return false;
   }
 }
 
 void QmitkXnatConnectionPreferencePage::Update()
 {
   IPreferences::Pointer _XnatConnectionPreferencesNode = m_XnatConnectionPreferencesNode.Lock();
   if(_XnatConnectionPreferencesNode.IsNotNull())
   {
     m_Controls.inHostAddress->setText(_XnatConnectionPreferencesNode->Get(
       m_Controls.hostAddressLabel->text(), m_Controls.inHostAddress->text()));
     m_Controls.inPort->setText(_XnatConnectionPreferencesNode->Get(
       m_Controls.portLabel->text(), m_Controls.inPort->text()));
     m_Controls.inUsername->setText(_XnatConnectionPreferencesNode->Get(
       m_Controls.usernameLabel->text(), m_Controls.inUsername->text()));
     m_Controls.inPassword->setText(_XnatConnectionPreferencesNode->Get(
       m_Controls.passwortLabel->text(), m_Controls.inPassword->text()));
     m_Controls.inDownloadPath->setText(_XnatConnectionPreferencesNode->Get(
       m_Controls.downloadPathLabel->text(), m_Controls.inDownloadPath->text()));
   }
 }
 
 void QmitkXnatConnectionPreferencePage::UrlChanged()
 {
   m_Controls.inHostAddress->setStyleSheet("QLineEdit { background-color: white; }");
   QString str = m_Controls.inHostAddress->text();
 
   while(str.endsWith("/"))
   {
     str = str.left(str.length()-1);
   }
 
   m_Controls.inHostAddress->setText(str);
 
   QUrl url(m_Controls.inHostAddress->text());
   if(!url.isValid())
   {
     m_Controls.inHostAddress->setStyleSheet("QLineEdit { background-color: red; }");
   }
 }
 
 void QmitkXnatConnectionPreferencePage::DownloadPathChanged()
 {
   m_Controls.inDownloadPath->setStyleSheet("QLineEdit { background-color: white; }");
-  if(!m_Controls.inDownloadPath->text().isEmpty())
+  QString downloadPath = m_Controls.inDownloadPath->text();
+  if(!downloadPath.isEmpty())
   {
+    if (downloadPath.lastIndexOf("/") != downloadPath.size()-1)
+    {
+      downloadPath.append("/");
+      m_Controls.inDownloadPath->setText(downloadPath);
+    }
     QFileInfo path(m_Controls.inDownloadPath->text());
     if(!path.isDir())
     {
       m_Controls.inDownloadPath->setStyleSheet("QLineEdit { background-color: red; }");
     }
   }
 }
 
 void QmitkXnatConnectionPreferencePage::ToggleConnection()
 {
   ctkXnatSession* session = 0;
 
   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)
   {
     if(!UserInformationEmpty())
     {
       PerformOk();
 
       mitk::org_mitk_gui_qt_xnatinterface_Activator::GetXnatSessionManager()->CreateXnatSession();
       session = mitk::org_mitk_gui_qt_xnatinterface_Activator::GetXnatModuleContext()->GetService(
         mitk::org_mitk_gui_qt_xnatinterface_Activator::GetXnatModuleContext()->GetServiceReference<ctkXnatSession>());
     }
   }
 
   if(session != 0 && session->isOpen())
   {
     mitk::org_mitk_gui_qt_xnatinterface_Activator::GetXnatSessionManager()->CloseXnatSession();
     m_Controls.testConnectionButton->setText("Connect");
     m_Controls.testConnectionLabel->clear();
   }
   else if(session != 0 && !session->isOpen())
   {
     m_Controls.testConnectionButton->setEnabled(false);
 
     try
     {
       mitk::org_mitk_gui_qt_xnatinterface_Activator::GetXnatSessionManager()->OpenXnatSession();
 
       m_Controls.testConnectionButton->setText("Disconnect");
       m_Controls.testConnectionLabel->setStyleSheet("QLabel { color: green; }");
       m_Controls.testConnectionLabel->setText("Connecting successful.");
     }
     catch(const ctkXnatAuthenticationException& auth)
     {
       m_Controls.testConnectionLabel->setStyleSheet("QLabel { color: red; }");
       m_Controls.testConnectionLabel->setText("Connecting failed:\nAuthentication error.");
       MITK_INFO << auth.message().toStdString();
       mitk::org_mitk_gui_qt_xnatinterface_Activator::GetXnatSessionManager()->CloseXnatSession();
     }
     catch(const ctkException& e)
     {
       m_Controls.testConnectionLabel->setStyleSheet("QLabel { color: red; }");
       m_Controls.testConnectionLabel->setText("Connecting failed:\nInvalid Server Adress");
       MITK_INFO << e.message().toStdString();
       mitk::org_mitk_gui_qt_xnatinterface_Activator::GetXnatSessionManager()->CloseXnatSession();
     }
     m_Controls.testConnectionButton->setEnabled(true);
   }
 }
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 b1f627a41b..854d9b3c8f 100644
--- a/Plugins/org.mitk.gui.qt.xnat/src/internal/QmitkXnatEditor.cpp
+++ b/Plugins/org.mitk.gui.qt.xnat/src/internal/QmitkXnatEditor.cpp
@@ -1,495 +1,502 @@
 /*===================================================================
 
 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 "ctkXnatScanFolder.h"
 #include "ctkXnatFile.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 <QMessageBox>
 
 // MITK
 #include <mitkDataStorage.h>
 #include <mitkIOUtil.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 );
 
   GetSite()->GetWorkbenchWindow()->GetSelectionService()->AddSelectionListener(m_SelectionListener.data());
 
   connect( m_Controls.treeView, SIGNAL(activated(const QModelIndex&)), this, SLOT(OnObjectActivated(const QModelIndex&)) );
 
   connect( m_Controls.buttonDownloadResource, SIGNAL(clicked()), this, SLOT(DownloadResource()) );
   connect( m_Controls.buttonDownloadFile, SIGNAL(clicked()), this, SLOT(DownloadFile()) );
   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()) );
 
   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");
 }
 
 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() )
   {
     ctkXnatScanFolder* resource = dynamic_cast<ctkXnatScanFolder*>(variant.value<ctkXnatObject*>());
     if (resource != NULL)
     {
       MITK_INFO << "Download started ...";
       MITK_INFO << "...";
       QString resourcePath = m_DownloadPath + resource->id() + ".zip";
       resource->download(resourcePath);
 
       // Testing if the path exists
       QDir downDir(m_DownloadPath);
       if( downDir.exists(resource->id() + ".zip") )
       {
         MITK_INFO << "Download of " << resource->id().toStdString() << ".zip was completed!";
       }
       else
       {
         MITK_INFO << "Download of " << resource->id().toStdString() << ".zip failed!";
       }
     }
     else
     {
       MITK_INFO << "Selection was not a resource folder!";
     }
   }
 }
 
 void QmitkXnatEditor::DownloadFile()
 {
   if (!m_Controls.treeView->selectionModel()->hasSelection())
     return;
   const QModelIndex index = m_Controls.treeView->selectionModel()->currentIndex();
   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)
       {
-        mitk::IOUtil::Load((m_DownloadPath + file->id()).toStdString(),
-                           *dsService->GetDataStorage()->GetDataStorage());
-        mitk::RenderingManager::GetInstance()->InitializeViews();
+        QString name = file->property("Name");
+        mitk::DataNode::Pointer node = mitk::IOUtil::LoadDataNode((m_DownloadPath + name).toStdString());
+        if ( ( node.IsNotNull() ) && ( node->GetData() != NULL ) )
+        {
+          dsService->GetDataStorage()->GetDataStorage()->Add(node);
+          mitk::BaseData::Pointer basedata = node->GetData();
+          mitk::RenderingManager::GetInstance()->InitializeViews(
+            basedata->GetTimeGeometry(), mitk::RenderingManager::REQUEST_UPDATE_ALL, true );
+        }
       }
     }
     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)
     {
       MITK_INFO << "Download started ...";
       MITK_INFO << "...";
-      QString filePath = m_DownloadPath + file->id();
+      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(file->id()) )
+      if( downDir.exists(name) )
       {
         MITK_INFO << "Download of " << file->id().toStdString() << " was completed!";
       }
       else
       {
         MITK_INFO << "Download of " << file->id().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; }");
     m_Controls.buttonDownloadFile->setEnabled(true);
     m_Controls.buttonDownloadResource->setEnabled(true);
 
     // 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; }");
     m_Controls.buttonDownloadFile->setEnabled(false);
     m_Controls.buttonDownloadResource->setEnabled(false);
   }
 
   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();
     m_Controls.buttonDownloadFile->setEnabled(false);
     m_Controls.buttonDownloadResource->setEnabled(false);
   }
 }
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 f671f8310b..2038df20f5 100644
--- a/Plugins/org.mitk.gui.qt.xnat/src/internal/QmitkXnatTreeBrowserView.cpp
+++ b/Plugins/org.mitk.gui.qt.xnat/src/internal/QmitkXnatTreeBrowserView.cpp
@@ -1,161 +1,280 @@
 /*===================================================================
 
 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>
+
+// MITK
+#include <mitkDataStorage.h>
+#include <QmitkIOUtil.h>
+
 const std::string QmitkXnatTreeBrowserView::VIEW_ID = "org.mitk.views.xnat.treebrowser";
 
-QmitkXnatTreeBrowserView::QmitkXnatTreeBrowserView():
-  m_TreeModel(new ctkXnatTreeModel()),
-  m_Tracker(0)
+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 )
+void QmitkXnatTreeBrowserView::CreateQtPartControl(QWidget *parent)
 {
   // Create GUI widgets from the Qt Designer's .ui file
-  m_Controls.setupUi( parent );
+  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_Tracker, SIGNAL(AboutToBeClosed(ctkXnatSession*)), this, SLOT(CleanTreeModel(ctkXnatSession*)) );
-  connect( m_Tracker, SIGNAL(Opened(ctkXnatSession*)), this, SLOT(UpdateSession(ctkXnatSession*)) );
+  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)
+  catch (std::invalid_argument)
   {
     session = 0;
   }
 
-  if(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&)) );
+  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::IEditorInput::Pointer editorInput(oPtr);
   berry::IEditorPart::Pointer reuseEditor = page->FindEditor(editorInput);
 
-  if(reuseEditor)
+  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())
     {
-      // No XnatEditor is currently open, create a new one
       ctkXnatFile* file = dynamic_cast<ctkXnatFile*>(oPtr->GetXnatObject());
-      if(file != NULL)
+      if (file != NULL)
       {
-        // If a file is activated take the parent and open a new editor
-        QmitkXnatObjectEditorInput::Pointer oPtr2(new QmitkXnatObjectEditorInput( file->parent() ));
-        berry::IEditorInput::Pointer editorInput2( oPtr2 );
-        page->OpenEditor(editorInput2, QmitkXnatEditor::EDITOR_ID);
+        // 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())
+  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)
+  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()))
+        {
+          MITK_INFO << "Download of " << file->name().toStdString() << " was completed!";
+        }
+        else
+        {
+          MITK_INFO << "Download of " << file->name().toStdString() << " failed!";
+        }
+      }
+      if (downDir.exists(file->name()))
+      {
+        if (loadData)
+        {
+          mitk::IDataStorageService* dsService = m_DataStorageServiceTracker.getService();
+          mitk::DataStorage::Pointer dataStorage = dsService->GetDataStorage()->GetDataStorage();
+          QStringList list;
+          list << (m_DownloadPath + file->name());
+          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());
+    }
+  }
+}
diff --git a/Plugins/org.mitk.gui.qt.xnat/src/internal/QmitkXnatTreeBrowserView.h b/Plugins/org.mitk.gui.qt.xnat/src/internal/QmitkXnatTreeBrowserView.h
index 502d4b2a11..93b72ad1f7 100644
--- a/Plugins/org.mitk.gui.qt.xnat/src/internal/QmitkXnatTreeBrowserView.h
+++ b/Plugins/org.mitk.gui.qt.xnat/src/internal/QmitkXnatTreeBrowserView.h
@@ -1,84 +1,99 @@
 /*===================================================================
 
 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.
 
 ===================================================================*/
 
 #ifndef QMITKXNATTREEBROWSERVIEW_H
 #define QMITKXNATTREEBROWSERVIEW_H
 
 #include <berryQtSelectionProvider.h>
 
 #include <QmitkAbstractView.h>
 
 #include "ui_QmitkXnatTreeBrowserViewControls.h"
 
 // ctkXnatCore
 #include "ctkXnatSession.h"
 
 // ctkXnatWidget
 #include "ctkXnatTreeModel.h"
 
 // MitkXNAT Module
 #include "mitkXnatSessionTracker.h"
 
+#include <mitkIDataStorageService.h>
+#include <ctkServiceTracker.h>
+
+class QMenu;
+
 /*!
 \brief QmitkXnatTreeBrowserView
 
 \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 QmitkXnatTreeBrowserView : public QmitkAbstractView
 {
   // 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:
 
   QmitkXnatTreeBrowserView();
   ~QmitkXnatTreeBrowserView();
 
   static const std::string VIEW_ID;
 
   virtual void CreateQtPartControl(QWidget *parent);
 
   protected slots:
 
-    /// \brief Opens or reuses the xnat editor with the activated node as root item.
-    void OnActivatedNode(const QModelIndex& index);
+  /// \brief Opens or reuses the xnat editor with the activated node as root item.
+  void OnActivatedNode(const QModelIndex& index);
+
+  /// \brief Updates the ctkXnatSession and the user interface
+  void UpdateSession(ctkXnatSession* session);
 
-    /// \brief Updates the ctkXnatSession and the user interface
-    void UpdateSession(ctkXnatSession* session);
+  /// \brief Cleans the tree model
+  void CleanTreeModel(ctkXnatSession* session);
 
-    /// \brief Cleans the tree model
-    void CleanTreeModel(ctkXnatSession* session);
+  void NodeTableViewContextMenuRequested(const QPoint & pos);
+
+  void OnContextMenuDownloadAndOpenFile();
+  void OnContextMenuDownloadFile();
 
 protected:
 
   virtual void SetFocus();
 
   Ui::QmitkXnatTreeBrowserViewControls m_Controls;
 
 private:
 
+  void InternalFileDownload(const QModelIndex& index, bool loadData);
   berry::QtSelectionProvider::Pointer m_SelectionProvider;
   void SetSelectionProvider();
 
+  ctkServiceTracker<mitk::IDataStorageService*> m_DataStorageServiceTracker;
   ctkXnatTreeModel* m_TreeModel;
   mitk::XnatSessionTracker* m_Tracker;
+  QString m_DownloadPath;
+
+  QMenu* m_NodeMenu;
 };
 
 #endif // QMITKXNATTREEBROWSERVIEW_H