diff --git a/Plugins/org.mitk.gui.qt.basicimageprocessing/src/internal/QmitkBasicImageProcessingView.cpp b/Plugins/org.mitk.gui.qt.basicimageprocessing/src/internal/QmitkBasicImageProcessingView.cpp
index 41c89248e1..0cc8c4331c 100644
--- a/Plugins/org.mitk.gui.qt.basicimageprocessing/src/internal/QmitkBasicImageProcessingView.cpp
+++ b/Plugins/org.mitk.gui.qt.basicimageprocessing/src/internal/QmitkBasicImageProcessingView.cpp
@@ -1,1400 +1,1413 @@
 /*===================================================================
 
 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 "QmitkBasicImageProcessingView.h"
 
 // QT includes (GUI)
 #include <qlabel.h>
 #include <qspinbox.h>
 #include <qpushbutton.h>
 #include <qcheckbox.h>
 #include <qgroupbox.h>
 #include <qradiobutton.h>
 #include <qmessagebox.h>
 
 // Berry includes (selection service)
 #include <berryISelectionService.h>
 #include <berryIWorkbenchWindow.h>
 
 // MITK includes (GUI)
 #include "QmitkStdMultiWidget.h"
 #include "QmitkDataNodeSelectionProvider.h"
 #include "mitkDataNodeObject.h"
 
 // MITK includes (general)
 #include "mitkNodePredicateDataType.h"
 #include "mitkNodePredicateDimension.h"
 #include "mitkNodePredicateAnd.h"
 #include "mitkImageTimeSelector.h"
 #include "mitkVectorImageMapper2D.h"
 #include "mitkProperties.h"
 
 // Includes for image casting between ITK and MITK
 #include "mitkImageCast.h"
 #include "mitkITKImageImport.h"
 
 // ITK includes (general)
 #include <itkVectorImage.h>
 #include <itkImageFileWriter.h>
 
 // Morphological Operations
 #include <itkBinaryBallStructuringElement.h>
 #include <itkGrayscaleDilateImageFilter.h>
 #include <itkGrayscaleErodeImageFilter.h>
 #include <itkGrayscaleMorphologicalOpeningImageFilter.h>
 #include <itkGrayscaleMorphologicalClosingImageFilter.h>
 
 // Smoothing
 #include <itkMedianImageFilter.h>
 #include <itkDiscreteGaussianImageFilter.h>
 #include <itkTotalVariationDenoisingImageFilter.h>
 
 // Threshold
 #include <itkBinaryThresholdImageFilter.h>
 
 // Inversion
 #include <itkInvertIntensityImageFilter.h>
 
 // Derivatives
 #include <itkGradientMagnitudeRecursiveGaussianImageFilter.h>
 #include <itkLaplacianImageFilter.h>
 #include <itkSobelEdgeDetectionImageFilter.h>
 
 // Resampling
 #include <itkResampleImageFilter.h>
 #include <itkNearestNeighborInterpolateImageFunction.h>
 #include <itkCastImageFilter.h>
 #include <itkLinearInterpolateImageFunction.h>
 
 // Image Arithmetics
 #include <itkAddImageFilter.h>
 #include <itkSubtractImageFilter.h>
 #include <itkMultiplyImageFilter.h>
 #include <itkDivideImageFilter.h>
 
 // Boolean operations
 #include <itkOrImageFilter.h>
 #include <itkAndImageFilter.h>
 #include <itkXorImageFilter.h>
 
 // Flip Image
 #include <itkFlipImageFilter.h>
 
 #include <itkRescaleIntensityImageFilter.h>
 #include <itkShiftScaleImageFilter.h>
 
 
 // Convenient Definitions
 typedef itk::Image<short, 3>                                                            ImageType;
 typedef itk::Image<unsigned char, 3>                                                    SegmentationImageType;
 typedef itk::Image<double, 3>                                                           DoubleImageType;
 typedef itk::Image<itk::Vector<float,3>, 3>                                             VectorImageType;
 
 typedef itk::BinaryBallStructuringElement<ImageType::PixelType, 3>                      BallType;
 typedef itk::GrayscaleDilateImageFilter<ImageType, ImageType, BallType>                 DilationFilterType;
 typedef itk::GrayscaleErodeImageFilter<ImageType, ImageType, BallType>                  ErosionFilterType;
 typedef itk::GrayscaleMorphologicalOpeningImageFilter<ImageType, ImageType, BallType>   OpeningFilterType;
 typedef itk::GrayscaleMorphologicalClosingImageFilter<ImageType, ImageType, BallType>   ClosingFilterType;
 
 typedef itk::MedianImageFilter< ImageType, ImageType >                                  MedianFilterType;
 typedef itk::DiscreteGaussianImageFilter< ImageType, ImageType>                         GaussianFilterType;
 typedef itk::TotalVariationDenoisingImageFilter<DoubleImageType, DoubleImageType>         TotalVariationFilterType;
 typedef itk::TotalVariationDenoisingImageFilter<VectorImageType, VectorImageType>       VectorTotalVariationFilterType;
 
 typedef itk::BinaryThresholdImageFilter< ImageType, ImageType >                         ThresholdFilterType;
 typedef itk::InvertIntensityImageFilter< ImageType, ImageType >                         InversionFilterType;
 
 typedef itk::GradientMagnitudeRecursiveGaussianImageFilter< ImageType, ImageType >      GradientFilterType;
 typedef itk::LaplacianImageFilter< DoubleImageType, DoubleImageType >                     LaplacianFilterType;
 typedef itk::SobelEdgeDetectionImageFilter< DoubleImageType, DoubleImageType >            SobelFilterType;
 
 typedef itk::ResampleImageFilter< ImageType, ImageType >                                ResampleImageFilterType;
 typedef itk::ResampleImageFilter< ImageType, ImageType >                                ResampleImageFilterType2;
 typedef itk::CastImageFilter< ImageType, DoubleImageType >                               ImagePTypeToFloatPTypeCasterType;
 
 typedef itk::AddImageFilter< ImageType, ImageType, ImageType >                          AddFilterType;
 typedef itk::SubtractImageFilter< ImageType, ImageType, ImageType >                     SubtractFilterType;
 typedef itk::MultiplyImageFilter< ImageType, ImageType, ImageType >                     MultiplyFilterType;
 typedef itk::DivideImageFilter< ImageType, ImageType, DoubleImageType >                  DivideFilterType;
 
 typedef itk::OrImageFilter< ImageType, ImageType >                                      OrImageFilterType;
 typedef itk::AndImageFilter< ImageType, ImageType >                                     AndImageFilterType;
 typedef itk::XorImageFilter< ImageType, ImageType >                                     XorImageFilterType;
 
 typedef itk::FlipImageFilter< ImageType >                                               FlipImageFilterType;
 
 typedef itk::LinearInterpolateImageFunction< ImageType, double >                        LinearInterpolatorType;
 typedef itk::NearestNeighborInterpolateImageFunction< ImageType, double >               NearestInterpolatorType;
 
 
 QmitkBasicImageProcessing::QmitkBasicImageProcessing()
 : QmitkAbstractView(),
   m_Controls(NULL),
   m_SelectedImageNode(NULL),
   m_TimeStepperAdapter(NULL)
 {
 }
 
 QmitkBasicImageProcessing::~QmitkBasicImageProcessing()
 {
   //berry::ISelectionService* s = GetSite()->GetWorkbenchWindow()->GetSelectionService();
   //if(s)
   //  s->RemoveSelectionListener(m_SelectionListener);
 }
 
 void QmitkBasicImageProcessing::CreateQtPartControl(QWidget *parent)
 {
   if (m_Controls == NULL)
   {
     m_Controls = new Ui::QmitkBasicImageProcessingViewControls;
     m_Controls->setupUi(parent);
     this->CreateConnections();
 
 
     //setup predictaes for combobox
 
     mitk::NodePredicateDimension::Pointer dimensionPredicate = mitk::NodePredicateDimension::New(3);
     mitk::NodePredicateDataType::Pointer imagePredicate = mitk::NodePredicateDataType::New("Image");
     m_Controls->m_ImageSelector2->SetDataStorage(this->GetDataStorage());
     m_Controls->m_ImageSelector2->SetPredicate(mitk::NodePredicateAnd::New(dimensionPredicate, imagePredicate));
   }
   m_Controls->gbTwoImageOps->hide();
 
   m_SelectedImageNode = mitk::DataStorageSelection::New(this->GetDataStorage(), false);
 
   // Setup Controls
 
   this->m_Controls->cbWhat1->clear();
   this->m_Controls->cbWhat1->insertItem(NOACTIONSELECTED, "Please select operation");
   this->m_Controls->cbWhat1->insertItem(CATEGORY_DENOISING, "--- Denoising ---");
   this->m_Controls->cbWhat1->insertItem(GAUSSIAN, "Gaussian");
   this->m_Controls->cbWhat1->insertItem(MEDIAN, "Median");
   this->m_Controls->cbWhat1->insertItem(TOTALVARIATION, "Total Variation");
   this->m_Controls->cbWhat1->insertItem(CATEGORY_MORPHOLOGICAL, "--- Morphological ---");
   this->m_Controls->cbWhat1->insertItem(DILATION, "Dilation");
   this->m_Controls->cbWhat1->insertItem(EROSION, "Erosion");
   this->m_Controls->cbWhat1->insertItem(OPENING, "Opening");
   this->m_Controls->cbWhat1->insertItem(CLOSING, "Closing");
   this->m_Controls->cbWhat1->insertItem(CATEGORY_EDGE_DETECTION, "--- Edge Detection ---");
   this->m_Controls->cbWhat1->insertItem(GRADIENT, "Gradient");
   this->m_Controls->cbWhat1->insertItem(LAPLACIAN, "Laplacian (2nd Derivative)");
   this->m_Controls->cbWhat1->insertItem(SOBEL, "Sobel Operator");
   this->m_Controls->cbWhat1->insertItem(CATEGORY_MISC, "--- Misc ---");
   this->m_Controls->cbWhat1->insertItem(THRESHOLD, "Threshold");
   this->m_Controls->cbWhat1->insertItem(INVERSION, "Image Inversion");
   this->m_Controls->cbWhat1->insertItem(DOWNSAMPLING, "Downsampling");
   this->m_Controls->cbWhat1->insertItem(FLIPPING, "Flipping");
   this->m_Controls->cbWhat1->insertItem(RESAMPLING, "Resample to");
   this->m_Controls->cbWhat1->insertItem(RESCALE, "Rescale values to interval");
   this->m_Controls->cbWhat1->insertItem(RESCALE2, "Rescale values by scalar");
 
   this->m_Controls->cbWhat2->clear();
   this->m_Controls->cbWhat2->insertItem(TWOIMAGESNOACTIONSELECTED, "Please select on operation");
   this->m_Controls->cbWhat2->insertItem(CATEGORY_ARITHMETIC, "--- Arithmetric operations ---");
   this->m_Controls->cbWhat2->insertItem(ADD, "Add to Image 1:");
   this->m_Controls->cbWhat2->insertItem(SUBTRACT, "Subtract from Image 1:");
   this->m_Controls->cbWhat2->insertItem(MULTIPLY, "Multiply with Image 1:");
   this->m_Controls->cbWhat2->insertItem(RESAMPLE_TO, "Resample Image 1 to fit geometry:");
   this->m_Controls->cbWhat2->insertItem(DIVIDE, "Divide Image 1 by:");
   this->m_Controls->cbWhat2->insertItem(CATEGORY_BOOLEAN, "--- Boolean operations ---");
   this->m_Controls->cbWhat2->insertItem(AND, "AND");
   this->m_Controls->cbWhat2->insertItem(OR, "OR");
   this->m_Controls->cbWhat2->insertItem(XOR, "XOR");
 
   this->m_Controls->cbParam4->clear();
   this->m_Controls->cbParam4->insertItem(LINEAR, "Linear");
   this->m_Controls->cbParam4->insertItem(NEAREST, "Nearest neighbor");
 
   m_Controls->dsbParam1->hide();
   m_Controls->dsbParam2->hide();
   m_Controls->dsbParam3->hide();
   m_Controls->tlParam3->hide();
   m_Controls->tlParam4->hide();
   m_Controls->cbParam4->hide();
 }
 
 void QmitkBasicImageProcessing::CreateConnections()
 {
   if ( m_Controls )
   {
     connect( (QObject*)(m_Controls->cbWhat1), SIGNAL( activated(int) ), this, SLOT( SelectAction(int) ) );
     connect( (QObject*)(m_Controls->btnDoIt), SIGNAL(clicked()),(QObject*) this, SLOT(StartButtonClicked()));
     connect( (QObject*)(m_Controls->cbWhat2), SIGNAL( activated(int) ), this, SLOT( SelectAction2(int) ) );
     connect( (QObject*)(m_Controls->btnDoIt2), SIGNAL(clicked()),(QObject*) this, SLOT(StartButton2Clicked()));
     connect( (QObject*)(m_Controls->rBOneImOp), SIGNAL( clicked() ), this, SLOT( ChangeGUI() ) );
     connect( (QObject*)(m_Controls->rBTwoImOp), SIGNAL( clicked() ), this, SLOT( ChangeGUI() ) );
     connect( (QObject*)(m_Controls->cbParam4), SIGNAL( activated(int) ), this, SLOT( SelectInterpolator(int) ) );
   }
+}
 
-  m_TimeStepperAdapter = new QmitkStepperAdapter((QObject*) m_Controls->sliceNavigatorTime,
-    GetRenderWindowPart()->GetTimeNavigationController()->GetTime(), "sliceNavigatorTimeFromBIP");
+void QmitkBasicImageProcessing::InternalGetTimeNavigationController()
+{
+  auto renwin_part = GetRenderWindowPart();
+  if( renwin_part != nullptr )
+  {
+    auto tnc = renwin_part->GetTimeNavigationController();
+    if( tnc != nullptr )
+    {
+      m_TimeStepperAdapter = new QmitkStepperAdapter((QObject*) m_Controls->sliceNavigatorTime, tnc->GetTime(), "sliceNavigatorTimeFromBIP");
+    }
+  }
 }
 
 void QmitkBasicImageProcessing::SetFocus()
 {
   m_Controls->rBOneImOp->setFocus();
 }
 
 //datamanager selection changed
 void QmitkBasicImageProcessing::OnSelectionChanged(berry::IWorkbenchPart::Pointer, const QList<mitk::DataNode::Pointer>& nodes)
 {
   //any nodes there?
   if (!nodes.empty())
   {
   // reset GUI
 //  this->ResetOneImageOpPanel();
   m_Controls->sliceNavigatorTime->setEnabled(false);
   m_Controls->leImage1->setText("Select an Image in Data Manager");
   m_Controls->tlWhat1->setEnabled(false);
   m_Controls->cbWhat1->setEnabled(false);
   m_Controls->tlWhat2->setEnabled(false);
   m_Controls->cbWhat2->setEnabled(false);
 
   m_SelectedImageNode->RemoveAllNodes();
   //get the selected Node
   mitk::DataNode* _DataNode = nodes.front();
   *m_SelectedImageNode = _DataNode;
   //try to cast to image
   mitk::Image::Pointer tempImage = dynamic_cast<mitk::Image*>(m_SelectedImageNode->GetNode()->GetData());
 
     //no image
     if( tempImage.IsNull() || (tempImage->IsInitialized() == false) )
     {
       m_Controls->leImage1->setText("Not an image.");
       return;
     }
 
     //2D image
     if( tempImage->GetDimension() < 3)
     {
       m_Controls->leImage1->setText("2D images are not supported.");
       return;
     }
 
     //image
     m_Controls->leImage1->setText(QString(m_SelectedImageNode->GetNode()->GetName().c_str()));
 
     // button coding
     if ( tempImage->GetDimension() > 3 )
     {
+      // try to retrieve the TNC (for 4-D Processing )
+      this->InternalGetTimeNavigationController();
+
       m_Controls->sliceNavigatorTime->setEnabled(true);
       m_Controls->tlTime->setEnabled(true);
     }
     m_Controls->tlWhat1->setEnabled(true);
     m_Controls->cbWhat1->setEnabled(true);
     m_Controls->tlWhat2->setEnabled(true);
     m_Controls->cbWhat2->setEnabled(true);
   }
 }
 
 void QmitkBasicImageProcessing::ChangeGUI()
 {
   if(m_Controls->rBOneImOp->isChecked())
   {
     m_Controls->gbTwoImageOps->hide();
     m_Controls->gbOneImageOps->show();
   }
   else if(m_Controls->rBTwoImOp->isChecked())
   {
     m_Controls->gbOneImageOps->hide();
     m_Controls->gbTwoImageOps->show();
   }
 }
 
 void QmitkBasicImageProcessing::ResetOneImageOpPanel()
 {
   m_Controls->tlParam1->setText("Param1");
   m_Controls->tlParam2->setText("Param2");
 
   m_Controls->cbWhat1->setCurrentIndex(0);
 
   m_Controls->tlTime->setEnabled(false);
 
   this->ResetParameterPanel();
 
   m_Controls->btnDoIt->setEnabled(false);
   m_Controls->cbHideOrig->setEnabled(false);
 }
 
 void QmitkBasicImageProcessing::ResetParameterPanel()
 {
   m_Controls->tlParam->setEnabled(false);
   m_Controls->tlParam1->setEnabled(false);
   m_Controls->tlParam2->setEnabled(false);
   m_Controls->tlParam3->setEnabled(false);
   m_Controls->tlParam4->setEnabled(false);
 
   m_Controls->sbParam1->setEnabled(false);
   m_Controls->sbParam2->setEnabled(false);
   m_Controls->dsbParam1->setEnabled(false);
   m_Controls->dsbParam2->setEnabled(false);
   m_Controls->dsbParam3->setEnabled(false);
   m_Controls->cbParam4->setEnabled(false);
   m_Controls->sbParam1->setValue(0);
   m_Controls->sbParam2->setValue(0);
   m_Controls->dsbParam1->setValue(0);
   m_Controls->dsbParam2->setValue(0);
   m_Controls->dsbParam3->setValue(0);
 
   m_Controls->sbParam1->show();
   m_Controls->sbParam2->show();
   m_Controls->dsbParam1->hide();
   m_Controls->dsbParam2->hide();
   m_Controls->dsbParam3->hide();
   m_Controls->cbParam4->hide();
   m_Controls->tlParam3->hide();
   m_Controls->tlParam4->hide();
 }
 
 void QmitkBasicImageProcessing::ResetTwoImageOpPanel()
 {
   m_Controls->cbWhat2->setCurrentIndex(0);
 
   m_Controls->tlImage2->setEnabled(false);
   m_Controls->m_ImageSelector2->setEnabled(false);
 
   m_Controls->btnDoIt2->setEnabled(false);
 }
 
 void QmitkBasicImageProcessing::SelectAction(int action)
 {
   if ( ! m_SelectedImageNode->GetNode() ) return;
 
   // Prepare GUI
   this->ResetParameterPanel();
   m_Controls->btnDoIt->setEnabled(false);
   m_Controls->cbHideOrig->setEnabled(false);
 
   QString text1 = "No Parameters";
   QString text2 = "No Parameters";
   QString text3 = "No Parameters";
   QString text4 = "No Parameters";
 
   if (action != 19)
   {
     m_Controls->dsbParam1->hide();
     m_Controls->dsbParam2->hide();
     m_Controls->dsbParam3->hide();
     m_Controls->tlParam1->show();
     m_Controls->tlParam2->show();
     m_Controls->tlParam3->hide();
     m_Controls->tlParam4->hide();
     m_Controls->sbParam1->show();
     m_Controls->sbParam2->show();
     m_Controls->cbParam4->hide();
   }
   // check which operation the user has selected and set parameters and GUI accordingly
   switch (action)
   {
   case 2:
     {
       m_SelectedAction = GAUSSIAN;
       m_Controls->tlParam1->setEnabled(true);
       m_Controls->sbParam1->hide();
       m_Controls->dsbParam1->show();
       m_Controls->dsbParam1->setEnabled(true);
       text1 = "&Variance:";
       m_Controls->tlParam2->hide();
       m_Controls->sbParam2->hide();
 
       m_Controls->dsbParam1->setMinimum( 0 );
       m_Controls->dsbParam1->setMaximum( 200 );
       m_Controls->dsbParam1->setValue( 2 );
       break;
     }
 
   case 3:
     {
       m_SelectedAction = MEDIAN;
       m_Controls->tlParam1->setEnabled(true);
       m_Controls->sbParam1->setEnabled(true);
       text1 = "&Radius:";
       m_Controls->sbParam1->setMinimum( 0 );
       m_Controls->sbParam1->setMaximum( 200 );
       m_Controls->sbParam1->setValue( 3 );
       break;
     }
 
   case 4:
     {
       m_SelectedAction = TOTALVARIATION;
       m_Controls->tlParam1->setEnabled(true);
       m_Controls->sbParam1->setEnabled(true);
       m_Controls->tlParam2->setEnabled(true);
       m_Controls->sbParam2->setEnabled(true);
       text1 = "Number Iterations:";
       text2 = "Regularization\n(Lambda/1000):";
       m_Controls->sbParam1->setMinimum( 1 );
       m_Controls->sbParam1->setMaximum( 1000 );
       m_Controls->sbParam1->setValue( 40 );
       m_Controls->sbParam2->setMinimum( 0 );
       m_Controls->sbParam2->setMaximum( 100000 );
       m_Controls->sbParam2->setValue( 1 );
       break;
     }
 
   case 6:
     {
       m_SelectedAction = DILATION;
       m_Controls->tlParam1->setEnabled(true);
       m_Controls->sbParam1->setEnabled(true);
       text1 = "&Radius:";
       m_Controls->sbParam1->setMinimum( 0 );
       m_Controls->sbParam1->setMaximum( 200 );
       m_Controls->sbParam1->setValue( 3 );
       break;
     }
 
   case 7:
     {
       m_SelectedAction = EROSION;
       m_Controls->tlParam1->setEnabled(true);
       m_Controls->sbParam1->setEnabled(true);
       text1 = "&Radius:";
       m_Controls->sbParam1->setMinimum( 0 );
       m_Controls->sbParam1->setMaximum( 200 );
       m_Controls->sbParam1->setValue( 3 );
       break;
     }
 
   case 8:
     {
       m_SelectedAction = OPENING;
       m_Controls->tlParam1->setEnabled(true);
       m_Controls->sbParam1->setEnabled(true);
       text1 = "&Radius:";
       m_Controls->sbParam1->setMinimum( 0 );
       m_Controls->sbParam1->setMaximum( 200 );
       m_Controls->sbParam1->setValue( 3 );
       break;
     }
 
   case 9:
     {
       m_SelectedAction = CLOSING;
       m_Controls->tlParam1->setEnabled(true);
       m_Controls->sbParam1->setEnabled(true);
       text1 = "&Radius:";
       m_Controls->sbParam1->setMinimum( 0 );
       m_Controls->sbParam1->setMaximum( 200 );
       m_Controls->sbParam1->setValue( 3 );
       break;
     }
 
   case 11:
     {
       m_SelectedAction = GRADIENT;
       m_Controls->tlParam1->setEnabled(true);
       m_Controls->sbParam1->hide();
       m_Controls->dsbParam1->show();
       m_Controls->dsbParam1->setEnabled(true);
       text1 = "Sigma of Gaussian Kernel:\n(in Image Spacing Units)";
       m_Controls->tlParam2->hide();
       m_Controls->sbParam2->hide();
 
       m_Controls->dsbParam1->setMinimum( 0 );
       m_Controls->dsbParam1->setMaximum( 200 );
       m_Controls->dsbParam1->setValue( 2 );
       break;
     }
 
   case 12:
     {
       m_SelectedAction = LAPLACIAN;
       break;
     }
 
   case 13:
     {
       m_SelectedAction = SOBEL;
       break;
     }
 
   case 15:
     {
       m_SelectedAction = THRESHOLD;
       m_Controls->tlParam1->setEnabled(true);
       m_Controls->sbParam1->setEnabled(true);
       m_Controls->tlParam2->setEnabled(true);
       m_Controls->sbParam2->setEnabled(true);
       text1 = "Lower threshold:";
       text2 = "Upper threshold:";
       m_Controls->sbParam1->setMinimum( -100000 );
       m_Controls->sbParam1->setMaximum( 100000 );
       m_Controls->sbParam1->setValue( 0 );
       m_Controls->sbParam2->setMinimum( -100000 );
       m_Controls->sbParam2->setMaximum( 100000 );
       m_Controls->sbParam2->setValue( 300 );
       break;
     }
 
   case 16:
     {
       m_SelectedAction = INVERSION;
       break;
     }
 
   case 17:
     {
       m_SelectedAction = DOWNSAMPLING;
       m_Controls->tlParam1->setEnabled(true);
       m_Controls->sbParam1->setEnabled(true);
       text1 = "Downsampling by Factor:";
       m_Controls->sbParam1->setMinimum( 1 );
       m_Controls->sbParam1->setMaximum( 100 );
       m_Controls->sbParam1->setValue( 2 );
       break;
     }
 
   case 18:
     {
       m_SelectedAction = FLIPPING;
       m_Controls->tlParam1->setEnabled(true);
       m_Controls->sbParam1->setEnabled(true);
       text1 = "Flip across axis:";
       m_Controls->sbParam1->setMinimum( 0 );
       m_Controls->sbParam1->setMaximum( 2 );
       m_Controls->sbParam1->setValue( 1 );
       break;
     }
 
   case 19:
     {
       m_SelectedAction = RESAMPLING;
       m_Controls->tlParam1->setEnabled(true);
       m_Controls->sbParam1->setEnabled(false);
       m_Controls->sbParam1->hide();
       m_Controls->dsbParam1->show();
       m_Controls->dsbParam1->setEnabled(true);
       m_Controls->tlParam2->setEnabled(true);
       m_Controls->sbParam2->setEnabled(false);
       m_Controls->sbParam2->hide();
       m_Controls->dsbParam2->show();
       m_Controls->dsbParam2->setEnabled(true);
       m_Controls->tlParam3->show();
       m_Controls->tlParam3->setEnabled(true);
       m_Controls->dsbParam3->show();
       m_Controls->dsbParam3->setEnabled(true);
       m_Controls->tlParam4->show();
       m_Controls->tlParam4->setEnabled(true);
       m_Controls->cbParam4->show();
       m_Controls->cbParam4->setEnabled(true);
 
       m_Controls->dsbParam1->setMinimum(0.01);
       m_Controls->dsbParam1->setMaximum(10.0);
       m_Controls->dsbParam1->setSingleStep(0.1);
       m_Controls->dsbParam1->setValue(0.3);
       m_Controls->dsbParam2->setMinimum(0.01);
       m_Controls->dsbParam2->setMaximum(10.0);
       m_Controls->dsbParam2->setSingleStep(0.1);
       m_Controls->dsbParam2->setValue(0.3);
       m_Controls->dsbParam3->setMinimum(0.01);
       m_Controls->dsbParam3->setMaximum(10.0);
       m_Controls->dsbParam3->setSingleStep(0.1);
       m_Controls->dsbParam3->setValue(1.5);
 
       text1 = "x-spacing:";
       text2 = "y-spacing:";
       text3 = "z-spacing:";
       text4 = "Interplation:";
       break;
     }
 
   case 20:
     {
       m_SelectedAction = RESCALE;
       m_Controls->dsbParam1->show();
       m_Controls->tlParam1->show();
       m_Controls->dsbParam1->setEnabled(true);
       m_Controls->tlParam1->setEnabled(true);
       m_Controls->dsbParam2->show();
       m_Controls->tlParam2->show();
       m_Controls->dsbParam2->setEnabled(true);
       m_Controls->tlParam2->setEnabled(true);
       text1 = "Output minimum:";
       text2 = "Output maximum:";
       break;
     }
   case 21:
   {
       m_SelectedAction = RESCALE2;
       m_Controls->dsbParam1->show();
       m_Controls->tlParam1->show();
       m_Controls->dsbParam1->setEnabled(true);
       m_Controls->tlParam1->setEnabled(true);
       text1 = "Scaling value:";
       break;
   }
 
   default: return;
   }
 
   m_Controls->tlParam->setEnabled(true);
   m_Controls->tlParam1->setText(text1);
   m_Controls->tlParam2->setText(text2);
   m_Controls->tlParam3->setText(text3);
   m_Controls->tlParam4->setText(text4);
 
   m_Controls->btnDoIt->setEnabled(true);
   m_Controls->cbHideOrig->setEnabled(true);
 }
 
 void QmitkBasicImageProcessing::StartButtonClicked()
 {
   if(!m_SelectedImageNode->GetNode()) return;
 
   this->BusyCursorOn();
 
   mitk::Image::Pointer newImage;
 
   try
   {
     newImage = dynamic_cast<mitk::Image*>(m_SelectedImageNode->GetNode()->GetData());
   }
   catch ( std::exception &e )
   {
   QString exceptionString = "An error occured during image loading:\n";
   exceptionString.append( e.what() );
     QMessageBox::warning( NULL, "Basic Image Processing", exceptionString , QMessageBox::Ok, QMessageBox::NoButton );
     this->BusyCursorOff();
     return;
   }
 
   // check if input image is valid, casting does not throw exception when casting from 'NULL-Object'
   if ( (! newImage) || (newImage->IsInitialized() == false) )
   {
     this->BusyCursorOff();
 
     QMessageBox::warning( NULL, "Basic Image Processing", "Input image is broken or not initialized. Returning.", QMessageBox::Ok, QMessageBox::NoButton );
     return;
   }
 
   // check if operation is done on 4D a image time step
   if(newImage->GetDimension() > 3)
   {
     mitk::ImageTimeSelector::Pointer timeSelector = mitk::ImageTimeSelector::New();
     timeSelector->SetInput(newImage);
     timeSelector->SetTimeNr( ((QmitkSliderNavigatorWidget*)m_Controls->sliceNavigatorTime)->GetPos() );
     timeSelector->Update();
     newImage = timeSelector->GetOutput();
   }
 
 
 
   // check if image or vector image
   ImageType::Pointer itkImage = ImageType::New();
   VectorImageType::Pointer itkVecImage = VectorImageType::New();
 
   int isVectorImage = newImage->GetPixelType().GetNumberOfComponents();
 
   if(isVectorImage > 1)
   {
     CastToItkImage( newImage, itkVecImage );
   }
   else
   {
     CastToItkImage( newImage, itkImage );
   }
 
   std::stringstream nameAddition("");
 
   int param1 = m_Controls->sbParam1->value();
   int param2 = m_Controls->sbParam2->value();
   double dparam1 = m_Controls->dsbParam1->value();
   double dparam2 = m_Controls->dsbParam2->value();
   double dparam3 = m_Controls->dsbParam3->value();
 
   try{
 
   switch (m_SelectedAction)
   {
 
   case GAUSSIAN:
     {
       GaussianFilterType::Pointer gaussianFilter = GaussianFilterType::New();
       gaussianFilter->SetInput( itkImage );
       gaussianFilter->SetVariance( dparam1 );
       gaussianFilter->UpdateLargestPossibleRegion();
       newImage = mitk::ImportItkImage(gaussianFilter->GetOutput())->Clone();
       nameAddition << "_Gaussian_var_" << dparam1;
       std::cout << "Gaussian filtering successful." << std::endl;
       break;
     }
 
   case MEDIAN:
     {
       MedianFilterType::Pointer medianFilter = MedianFilterType::New();
       MedianFilterType::InputSizeType size;
       size.Fill(param1);
       medianFilter->SetRadius( size );
       medianFilter->SetInput(itkImage);
       medianFilter->UpdateLargestPossibleRegion();
       newImage = mitk::ImportItkImage(medianFilter->GetOutput())->Clone();
       nameAddition << "_Median_radius_" << param1;
       std::cout << "Median Filtering successful." << std::endl;
       break;
     }
 
   case TOTALVARIATION:
     {
       if(isVectorImage > 1)
       {
         VectorTotalVariationFilterType::Pointer TVFilter
           = VectorTotalVariationFilterType::New();
         TVFilter->SetInput( itkVecImage.GetPointer() );
         TVFilter->SetNumberIterations(param1);
         TVFilter->SetLambda(double(param2)/1000.);
         TVFilter->UpdateLargestPossibleRegion();
 
         newImage = mitk::ImportItkImage(TVFilter->GetOutput())->Clone();
       }
       else
       {
         ImagePTypeToFloatPTypeCasterType::Pointer floatCaster = ImagePTypeToFloatPTypeCasterType::New();
         floatCaster->SetInput( itkImage );
         floatCaster->Update();
         DoubleImageType::Pointer fImage = floatCaster->GetOutput();
 
         TotalVariationFilterType::Pointer TVFilter
           = TotalVariationFilterType::New();
         TVFilter->SetInput( fImage.GetPointer() );
         TVFilter->SetNumberIterations(param1);
         TVFilter->SetLambda(double(param2)/1000.);
         TVFilter->UpdateLargestPossibleRegion();
 
         newImage = mitk::ImportItkImage(TVFilter->GetOutput())->Clone();
       }
 
       nameAddition << "_TV_Iter_" << param1 << "_L_" << param2;
       std::cout << "Total Variation Filtering successful." << std::endl;
       break;
     }
 
   case DILATION:
     {
       BallType binaryBall;
       binaryBall.SetRadius( param1 );
       binaryBall.CreateStructuringElement();
 
       DilationFilterType::Pointer dilationFilter = DilationFilterType::New();
       dilationFilter->SetInput( itkImage );
       dilationFilter->SetKernel( binaryBall );
       dilationFilter->UpdateLargestPossibleRegion();
       newImage = mitk::ImportItkImage(dilationFilter->GetOutput())->Clone();
       nameAddition << "_Dilated_by_" << param1;
       std::cout << "Dilation successful." << std::endl;
       break;
     }
 
   case EROSION:
     {
       BallType binaryBall;
       binaryBall.SetRadius( param1 );
       binaryBall.CreateStructuringElement();
 
       ErosionFilterType::Pointer erosionFilter = ErosionFilterType::New();
       erosionFilter->SetInput( itkImage );
       erosionFilter->SetKernel( binaryBall );
       erosionFilter->UpdateLargestPossibleRegion();
       newImage = mitk::ImportItkImage(erosionFilter->GetOutput())->Clone();
       nameAddition << "_Eroded_by_" << param1;
       std::cout << "Erosion successful." << std::endl;
       break;
     }
 
   case OPENING:
     {
       BallType binaryBall;
       binaryBall.SetRadius( param1 );
       binaryBall.CreateStructuringElement();
 
       OpeningFilterType::Pointer openFilter = OpeningFilterType::New();
       openFilter->SetInput( itkImage );
       openFilter->SetKernel( binaryBall );
       openFilter->UpdateLargestPossibleRegion();
       newImage = mitk::ImportItkImage(openFilter->GetOutput())->Clone();
       nameAddition << "_Opened_by_" << param1;
       std::cout << "Opening successful." << std::endl;
       break;
     }
 
   case CLOSING:
     {
       BallType binaryBall;
       binaryBall.SetRadius( param1 );
       binaryBall.CreateStructuringElement();
 
       ClosingFilterType::Pointer closeFilter = ClosingFilterType::New();
       closeFilter->SetInput( itkImage );
       closeFilter->SetKernel( binaryBall );
       closeFilter->UpdateLargestPossibleRegion();
       newImage = mitk::ImportItkImage(closeFilter->GetOutput())->Clone();
       nameAddition << "_Closed_by_" << param1;
       std::cout << "Closing successful." << std::endl;
       break;
     }
 
   case GRADIENT:
     {
       GradientFilterType::Pointer gradientFilter = GradientFilterType::New();
       gradientFilter->SetInput( itkImage );
       gradientFilter->SetSigma( dparam1 );
       gradientFilter->UpdateLargestPossibleRegion();
       newImage = mitk::ImportItkImage(gradientFilter->GetOutput())->Clone();
       nameAddition << "_Gradient_sigma_" << dparam1;
       std::cout << "Gradient calculation successful." << std::endl;
       break;
     }
 
   case LAPLACIAN:
     {
       // the laplace filter requires a float type image as input, we need to cast the itkImage
       // to correct type
       ImagePTypeToFloatPTypeCasterType::Pointer caster = ImagePTypeToFloatPTypeCasterType::New();
       caster->SetInput( itkImage );
       caster->Update();
       DoubleImageType::Pointer fImage = caster->GetOutput();
 
       LaplacianFilterType::Pointer laplacianFilter = LaplacianFilterType::New();
       laplacianFilter->SetInput( fImage );
       laplacianFilter->UpdateLargestPossibleRegion();
       newImage = mitk::ImportItkImage(laplacianFilter->GetOutput())->Clone();
       nameAddition << "_Second_Derivative";
       std::cout << "Laplacian filtering successful." << std::endl;
       break;
     }
 
   case SOBEL:
     {
       // the sobel filter requires a float type image as input, we need to cast the itkImage
       // to correct type
       ImagePTypeToFloatPTypeCasterType::Pointer caster = ImagePTypeToFloatPTypeCasterType::New();
       caster->SetInput( itkImage );
       caster->Update();
       DoubleImageType::Pointer fImage = caster->GetOutput();
 
       SobelFilterType::Pointer sobelFilter = SobelFilterType::New();
       sobelFilter->SetInput( fImage );
       sobelFilter->UpdateLargestPossibleRegion();
       newImage = mitk::ImportItkImage(sobelFilter->GetOutput())->Clone();
       nameAddition << "_Sobel";
       std::cout << "Edge Detection successful." << std::endl;
       break;
     }
 
   case THRESHOLD:
     {
       ThresholdFilterType::Pointer thFilter = ThresholdFilterType::New();
       thFilter->SetLowerThreshold(param1 < param2 ? param1 : param2);
       thFilter->SetUpperThreshold(param2 > param1 ? param2 : param1);
       thFilter->SetInsideValue(1);
       thFilter->SetOutsideValue(0);
       thFilter->SetInput(itkImage);
       thFilter->UpdateLargestPossibleRegion();
       newImage = mitk::ImportItkImage(thFilter->GetOutput())->Clone();
       nameAddition << "_Threshold";
       std::cout << "Thresholding successful." << std::endl;
       break;
     }
 
   case INVERSION:
     {
       InversionFilterType::Pointer invFilter = InversionFilterType::New();
       mitk::ScalarType min = newImage->GetScalarValueMin();
       mitk::ScalarType max = newImage->GetScalarValueMax();
       invFilter->SetMaximum( max + min );
       invFilter->SetInput(itkImage);
       invFilter->UpdateLargestPossibleRegion();
       newImage = mitk::ImportItkImage(invFilter->GetOutput())->Clone();
       nameAddition << "_Inverted";
       std::cout << "Image inversion successful." << std::endl;
       break;
     }
 
   case DOWNSAMPLING:
     {
       ResampleImageFilterType::Pointer downsampler = ResampleImageFilterType::New();
       downsampler->SetInput( itkImage );
 
       NearestInterpolatorType::Pointer interpolator = NearestInterpolatorType::New();
       downsampler->SetInterpolator( interpolator );
 
       downsampler->SetDefaultPixelValue( 0 );
 
       ResampleImageFilterType::SpacingType spacing = itkImage->GetSpacing();
       spacing *= (double) param1;
       downsampler->SetOutputSpacing( spacing );
 
       downsampler->SetOutputOrigin( itkImage->GetOrigin() );
       downsampler->SetOutputDirection( itkImage->GetDirection() );
 
       ResampleImageFilterType::SizeType size = itkImage->GetLargestPossibleRegion().GetSize();
       for ( int i = 0; i < 3; ++i )
       {
         size[i] /= param1;
       }
       downsampler->SetSize( size );
       downsampler->UpdateLargestPossibleRegion();
 
       newImage = mitk::ImportItkImage(downsampler->GetOutput())->Clone();
       nameAddition << "_Downsampled_by_" << param1;
       std::cout << "Downsampling successful." << std::endl;
       break;
     }
 
   case FLIPPING:
     {
       FlipImageFilterType::Pointer flipper = FlipImageFilterType::New();
       flipper->SetInput( itkImage );
       itk::FixedArray<bool, 3> flipAxes;
       for(int i=0; i<3; ++i)
       {
         if(i == param1)
         {
           flipAxes[i] = true;
         }
         else
         {
           flipAxes[i] = false;
         }
       }
       flipper->SetFlipAxes(flipAxes);
       flipper->UpdateLargestPossibleRegion();
       newImage = mitk::ImportItkImage(flipper->GetOutput())->Clone();
       std::cout << "Image flipping successful." << std::endl;
       break;
     }
 
   case RESAMPLING:
     {
       std::string selectedInterpolator;
       ResampleImageFilterType::Pointer resampler = ResampleImageFilterType::New();
       switch (m_SelectedInterpolation)
       {
       case LINEAR:
         {
           LinearInterpolatorType::Pointer interpolator = LinearInterpolatorType::New();
           resampler->SetInterpolator(interpolator);
           selectedInterpolator = "Linear";
           break;
         }
       case NEAREST:
         {
           NearestInterpolatorType::Pointer interpolator = NearestInterpolatorType::New();
           resampler->SetInterpolator(interpolator);
           selectedInterpolator = "Nearest";
           break;
         }
       default:
         {
           LinearInterpolatorType::Pointer interpolator = LinearInterpolatorType::New();
           resampler->SetInterpolator(interpolator);
           selectedInterpolator = "Linear";
           break;
         }
       }
       resampler->SetInput( itkImage );
       resampler->SetOutputOrigin( itkImage->GetOrigin() );
 
       ImageType::SizeType input_size = itkImage->GetLargestPossibleRegion().GetSize();
       ImageType::SpacingType input_spacing = itkImage->GetSpacing();
 
       ImageType::SizeType output_size;
       ImageType::SpacingType output_spacing;
 
       output_size[0] = input_size[0] * (input_spacing[0] / dparam1);
       output_size[1] = input_size[1] * (input_spacing[1] / dparam2);
       output_size[2] = input_size[2] * (input_spacing[2] / dparam3);
       output_spacing [0] = dparam1;
       output_spacing [1] = dparam2;
       output_spacing [2] = dparam3;
 
       resampler->SetSize( output_size );
       resampler->SetOutputSpacing( output_spacing );
       resampler->SetOutputDirection( itkImage->GetDirection() );
 
       resampler->UpdateLargestPossibleRegion();
 
       ImageType::Pointer resampledImage = resampler->GetOutput();
 
       newImage = mitk::ImportItkImage( resampledImage )->Clone();
       nameAddition << "_Resampled_" << selectedInterpolator;
       std::cout << "Resampling successful." << std::endl;
       break;
     }
 
 
   case RESCALE:
     {
       DoubleImageType::Pointer floatImage = DoubleImageType::New();
       CastToItkImage( newImage, floatImage );
       itk::RescaleIntensityImageFilter<DoubleImageType,DoubleImageType>::Pointer filter = itk::RescaleIntensityImageFilter<DoubleImageType,DoubleImageType>::New();
       filter->SetInput(0, floatImage);
       filter->SetOutputMinimum(dparam1);
       filter->SetOutputMaximum(dparam2);
       filter->Update();
       floatImage = filter->GetOutput();
 
       newImage = mitk::Image::New();
       newImage->InitializeByItk(floatImage.GetPointer());
       newImage->SetVolume(floatImage->GetBufferPointer());
       nameAddition << "_Rescaled";
       std::cout << "Rescaling successful." << std::endl;
 
       break;
     }
   case RESCALE2:
   {
       DoubleImageType::Pointer floatImage = DoubleImageType::New();
       CastToItkImage( newImage, floatImage );
       itk::ShiftScaleImageFilter<DoubleImageType,DoubleImageType>::Pointer filter = itk::ShiftScaleImageFilter<DoubleImageType,DoubleImageType>::New();
       filter->SetInput(0, floatImage);
       filter->SetScale(dparam1);
 
       filter->Update();
       floatImage = filter->GetOutput();
 
       newImage = mitk::Image::New();
       newImage->InitializeByItk(floatImage.GetPointer());
       newImage->SetVolume(floatImage->GetBufferPointer());
       nameAddition << "_Rescaled";
       std::cout << "Rescaling successful." << std::endl;
       break;
   }
 
   default:
     this->BusyCursorOff();
     return;
   }
   }
   catch (...)
   {
     this->BusyCursorOff();
     QMessageBox::warning(NULL, "Warning", "Problem when applying filter operation. Check your input...");
     return;
   }
 
   newImage->DisconnectPipeline();
 
   // adjust level/window to new image
   mitk::LevelWindow levelwindow;
   levelwindow.SetAuto( newImage );
   mitk::LevelWindowProperty::Pointer levWinProp = mitk::LevelWindowProperty::New();
   levWinProp->SetLevelWindow( levelwindow );
 
   // compose new image name
   std::string name = m_SelectedImageNode->GetNode()->GetName();
   if (name.find(".pic.gz") == name.size() -7 )
   {
     name = name.substr(0,name.size() -7);
   }
   name.append( nameAddition.str() );
 
   // create final result MITK data storage node
   mitk::DataNode::Pointer result = mitk::DataNode::New();
   result->SetProperty( "levelwindow", levWinProp );
   result->SetProperty( "name", mitk::StringProperty::New( name.c_str() ) );
   result->SetData( newImage );
 
   // for vector images, a different mapper is needed
   if(isVectorImage > 1)
   {
     mitk::VectorImageMapper2D::Pointer mapper =
       mitk::VectorImageMapper2D::New();
     result->SetMapper(1,mapper);
   }
 
   // reset GUI to ease further processing
 //  this->ResetOneImageOpPanel();
 
   // add new image to data storage and set as active to ease further processing
   GetDataStorage()->Add( result, m_SelectedImageNode->GetNode() );
   if ( m_Controls->cbHideOrig->isChecked() == true )
     m_SelectedImageNode->GetNode()->SetProperty( "visible", mitk::BoolProperty::New(false) );
   // TODO!! m_Controls->m_ImageSelector1->SetSelectedNode(result);
 
   // show the results
   mitk::RenderingManager::GetInstance()->RequestUpdateAll();
   this->BusyCursorOff();
 }
 
 void QmitkBasicImageProcessing::SelectAction2(int operation)
 {
   // check which operation the user has selected and set parameters and GUI accordingly
   switch (operation)
   {
   case 2:
     m_SelectedOperation = ADD;
     break;
   case 3:
     m_SelectedOperation = SUBTRACT;
     break;
   case 4:
     m_SelectedOperation = MULTIPLY;
     break;
   case 5:
     m_SelectedOperation = DIVIDE;
     break;
   case 6:
     m_SelectedOperation = RESAMPLE_TO;
     break;
   case 8:
     m_SelectedOperation = AND;
     break;
   case 9:
     m_SelectedOperation = OR;
     break;
   case 10:
     m_SelectedOperation = XOR;
     break;
   default:
 //    this->ResetTwoImageOpPanel();
     return;
   }
   m_Controls->tlImage2->setEnabled(true);
   m_Controls->m_ImageSelector2->setEnabled(true);
   m_Controls->btnDoIt2->setEnabled(true);
 }
 
 void QmitkBasicImageProcessing::StartButton2Clicked()
 {
   mitk::Image::Pointer newImage1 = dynamic_cast<mitk::Image*>
     (m_SelectedImageNode->GetNode()->GetData());
   mitk::Image::Pointer newImage2 = dynamic_cast<mitk::Image*>
     (m_Controls->m_ImageSelector2->GetSelectedNode()->GetData());
 
   // check if images are valid
   if( (!newImage1) || (!newImage2) || (newImage1->IsInitialized() == false) || (newImage2->IsInitialized() == false) )
   {
     itkGenericExceptionMacro(<< "At least one of the input images are broken or not initialized. Returning");
     return;
   }
 
   this->BusyCursorOn();
 //  this->ResetTwoImageOpPanel();
 
   // check if 4D image and use filter on correct time step
   int time = ((QmitkSliderNavigatorWidget*)m_Controls->sliceNavigatorTime)->GetPos();
   if(newImage1->GetDimension() > 3)
   {
     mitk::ImageTimeSelector::Pointer timeSelector = mitk::ImageTimeSelector::New();
 
     timeSelector->SetInput(newImage1);
     timeSelector->SetTimeNr( time );
     timeSelector->UpdateLargestPossibleRegion();
     newImage1 = timeSelector->GetOutput();
     newImage1->DisconnectPipeline();
 
     timeSelector->SetInput(newImage2);
     timeSelector->SetTimeNr( time );
     timeSelector->UpdateLargestPossibleRegion();
     newImage2 = timeSelector->GetOutput();
     newImage2->DisconnectPipeline();
   }
 
   // reset GUI for better usability
 //  this->ResetTwoImageOpPanel();
 
   ImageType::Pointer itkImage1 = ImageType::New();
   ImageType::Pointer itkImage2 = ImageType::New();
 
   CastToItkImage( newImage1, itkImage1 );
   CastToItkImage( newImage2, itkImage2 );
 
   // Remove temp image
 //  newImage2 = NULL;
 
   std::string nameAddition = "";
 
   try
   {
   switch (m_SelectedOperation)
   {
   case ADD:
     {
       AddFilterType::Pointer addFilter = AddFilterType::New();
       addFilter->SetInput1( itkImage1 );
       addFilter->SetInput2( itkImage2 );
       addFilter->UpdateLargestPossibleRegion();
       newImage1 = mitk::ImportItkImage(addFilter->GetOutput())->Clone();
       nameAddition = "_Added";
     }
     break;
 
   case SUBTRACT:
     {
       SubtractFilterType::Pointer subFilter = SubtractFilterType::New();
       subFilter->SetInput1( itkImage1 );
       subFilter->SetInput2( itkImage2 );
       subFilter->UpdateLargestPossibleRegion();
       newImage1 = mitk::ImportItkImage(subFilter->GetOutput())->Clone();
       nameAddition = "_Subtracted";
     }
     break;
 
   case MULTIPLY:
     {
       MultiplyFilterType::Pointer multFilter = MultiplyFilterType::New();
       multFilter->SetInput1( itkImage1 );
       multFilter->SetInput2( itkImage2 );
       multFilter->UpdateLargestPossibleRegion();
       newImage1 = mitk::ImportItkImage(multFilter->GetOutput())->Clone();
       nameAddition = "_Multiplied";
     }
     break;
 
   case DIVIDE:
     {
       DivideFilterType::Pointer divFilter = DivideFilterType::New();
       divFilter->SetInput1( itkImage1 );
       divFilter->SetInput2( itkImage2 );
       divFilter->UpdateLargestPossibleRegion();
       newImage1 = mitk::ImportItkImage<DoubleImageType>(divFilter->GetOutput())->Clone();
       nameAddition = "_Divided";
     }
     break;
 
   case AND:
     {
       AndImageFilterType::Pointer andFilter = AndImageFilterType::New();
       andFilter->SetInput1( itkImage1 );
       andFilter->SetInput2( itkImage2 );
       andFilter->UpdateLargestPossibleRegion();
       newImage1 = mitk::ImportItkImage(andFilter->GetOutput())->Clone();
       nameAddition = "_AND";
       break;
     }
 
   case OR:
     {
       OrImageFilterType::Pointer orFilter = OrImageFilterType::New();
       orFilter->SetInput1( itkImage1 );
       orFilter->SetInput2( itkImage2 );
       orFilter->UpdateLargestPossibleRegion();
       newImage1 = mitk::ImportItkImage(orFilter->GetOutput())->Clone();
       nameAddition = "_OR";
       break;
     }
 
   case XOR:
     {
       XorImageFilterType::Pointer xorFilter = XorImageFilterType::New();
       xorFilter->SetInput1( itkImage1 );
       xorFilter->SetInput2( itkImage2 );
       xorFilter->UpdateLargestPossibleRegion();
       newImage1 = mitk::ImportItkImage(xorFilter->GetOutput())->Clone();
       nameAddition = "_XOR";
       break;
     }
 
   case RESAMPLE_TO:
     {
 
       itk::LinearInterpolateImageFunction<DoubleImageType>::Pointer nn_interpolator
         = itk::LinearInterpolateImageFunction<DoubleImageType>::New();
 
       DoubleImageType::Pointer itkImage1 = DoubleImageType::New();
       DoubleImageType::Pointer itkImage2 = DoubleImageType::New();
 
       CastToItkImage( newImage1, itkImage1 );
       CastToItkImage( newImage2, itkImage2 );
 
       itk::ResampleImageFilter< DoubleImageType, DoubleImageType >::Pointer resampleFilter = itk::ResampleImageFilter< DoubleImageType, DoubleImageType >::New();
       resampleFilter->SetInput( itkImage1 );
       resampleFilter->SetReferenceImage( itkImage2 );
       resampleFilter->SetUseReferenceImage( true );
       resampleFilter->SetInterpolator( nn_interpolator );
       resampleFilter->SetDefaultPixelValue( 0 );
 
       try
       {
         resampleFilter->UpdateLargestPossibleRegion();
       }
       catch( const itk::ExceptionObject &e)
       {
         MITK_WARN << "Updating resampling filter failed. ";
         MITK_WARN << "REASON: " << e.what();
       }
 
       DoubleImageType::Pointer resampledImage = resampleFilter->GetOutput();
 
       newImage1 = mitk::ImportItkImage( resampledImage )->Clone();
       nameAddition = "_Resampled";
       break;
     }
 
   default:
     std::cout << "Something went wrong..." << std::endl;
     this->BusyCursorOff();
     return;
   }
   }
   catch (const itk::ExceptionObject& e )
   {
     this->BusyCursorOff();
     QMessageBox::warning(NULL, "ITK Exception", e.what() );
     QMessageBox::warning(NULL, "Warning", "Problem when applying arithmetic operation to two images. Check dimensions of input images.");
     return;
   }
 
   // disconnect pipeline; images will not be reused
   newImage1->DisconnectPipeline();
   itkImage1 = NULL;
   itkImage2 = NULL;
 
   // adjust level/window to new image and compose new image name
   mitk::LevelWindow levelwindow;
   levelwindow.SetAuto( newImage1 );
   mitk::LevelWindowProperty::Pointer levWinProp = mitk::LevelWindowProperty::New();
   levWinProp->SetLevelWindow( levelwindow );
   std::string name = m_SelectedImageNode->GetNode()->GetName();
   if (name.find(".pic.gz") == name.size() -7 )
   {
     name = name.substr(0,name.size() -7);
   }
 
   // create final result MITK data storage node
   mitk::DataNode::Pointer result = mitk::DataNode::New();
   result->SetProperty( "levelwindow", levWinProp );
   result->SetProperty( "name", mitk::StringProperty::New( (name + nameAddition ).c_str() ));
   result->SetData( newImage1 );
   GetDataStorage()->Add( result, m_SelectedImageNode->GetNode() );
 
   // show only the newly created image
   m_SelectedImageNode->GetNode()->SetProperty( "visible", mitk::BoolProperty::New(false) );
   m_Controls->m_ImageSelector2->GetSelectedNode()->SetProperty( "visible", mitk::BoolProperty::New(false) );
 
   // show the newly created image
   mitk::RenderingManager::GetInstance()->RequestUpdateAll();
   this->BusyCursorOff();
 }
 
 void QmitkBasicImageProcessing::SelectInterpolator(int interpolator)
 {
   switch (interpolator)
   {
   case 0:
     {
       m_SelectedInterpolation = LINEAR;
       break;
     }
   case 1:
     {
       m_SelectedInterpolation = NEAREST;
       break;
     }
   }
 }
diff --git a/Plugins/org.mitk.gui.qt.basicimageprocessing/src/internal/QmitkBasicImageProcessingView.h b/Plugins/org.mitk.gui.qt.basicimageprocessing/src/internal/QmitkBasicImageProcessingView.h
index 6c246a58fc..e166a06af8 100644
--- a/Plugins/org.mitk.gui.qt.basicimageprocessing/src/internal/QmitkBasicImageProcessingView.h
+++ b/Plugins/org.mitk.gui.qt.basicimageprocessing/src/internal/QmitkBasicImageProcessingView.h
@@ -1,186 +1,189 @@
 /*===================================================================
 
 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.
 
 ===================================================================*/
 
 #if !defined(QmitkBasicImageProcessingView_H__INCLUDED)
 #define QmitkBasicImageProcessingView_H__INCLUDED
 
 #include <QmitkAbstractView.h>
 #include <org_mitk_gui_qt_basicimageprocessing_Export.h>
 #include "ui_QmitkBasicImageProcessingViewControls.h"
 
 #include "QmitkStepperAdapter.h"
 
 #include <mitkDataStorageSelection.h>
 
 /*!
 \brief This module allows to use some basic image processing filters for preprocessing, image enhancement and testing purposes
 
 Several basic ITK image processing filters, like denoising, morphological and edge detection
 are encapsulated in this module and can be selected via a list and an intuitive parameter input.
 The selected filter will be applied on the image, and a new image showing the output is displayed
 as result.
 Also, some image arithmetic operations are available.
 
 Images can be 3D or 4D.
 In the 4D case, the filters work on the 3D image selected via the
 time slider. The result is also a 3D image.
 
 \sa QmitkFunctionality, QObject
 
 \class QmitkBasicImageProcessing
 \author Tobias Schwarz
 \version 1.0 (3M3)
 \date 2009-05-10
 \ingroup Bundles
 */
 
 class BASICIMAGEPROCESSING_EXPORT QmitkBasicImageProcessing : public QmitkAbstractView
 {
   Q_OBJECT
 
 public:
 
   /*!
   \brief default constructor
   */
   QmitkBasicImageProcessing();
 
   /*!
   \brief default destructor
   */
   virtual ~QmitkBasicImageProcessing();
 
   /*!
   \brief method for creating the widget containing the application controls, like sliders, buttons etc.
   */
   virtual void CreateQtPartControl(QWidget *parent) override;
 
   virtual void SetFocus() override;
 
   /*!
   \brief method for creating the connections of main and control widget
   */
   virtual void CreateConnections();
 
   /*!
   \brief Invoked when the DataManager selection changed
   */
   virtual void OnSelectionChanged(berry::IWorkbenchPart::Pointer, const QList<mitk::DataNode::Pointer>& nodes) override;
 
 
   protected slots:
 
     /*
     * When an action is selected in the "one image ops" list box
     */
     void SelectAction(int action);
 
     /*
     * When an action is selected in the "two image ops" list box
     */
     void SelectAction2(int operation);
 
     /*
     * The "Execute" button in the "one image ops" box was triggered
     */
     void StartButtonClicked();
 
     /*
     * The "Execute" button in the "two image ops" box was triggered
     */
     void StartButton2Clicked();
 
     /*
     *  Switch between the one and the two image operations GUI
     */
     void ChangeGUI();
 
     void SelectInterpolator(int interpolator);
 
 private:
 
   /*
   * After a one image operation, reset the "one image ops" panel
   */
   void ResetOneImageOpPanel();
 
   /*
   * Helper method to reset the parameter set panel
   */
   void ResetParameterPanel();
 
   /*
   * After a two image operation, reset the "two image ops" panel
   */
   void ResetTwoImageOpPanel();
 
+  /** retrieve the tnc from renderwindow part */
+  void InternalGetTimeNavigationController();
+
   /*!
   * controls containing sliders for scrolling through the slices
   */
   Ui::QmitkBasicImageProcessingViewControls *m_Controls;
 
   //mitk::DataNode*       m_SelectedImageNode;
   mitk::DataStorageSelection::Pointer m_SelectedImageNode;
   QmitkStepperAdapter*      m_TimeStepperAdapter;
 
   enum ActionType {
     NOACTIONSELECTED,
     CATEGORY_DENOISING,
     GAUSSIAN,
     MEDIAN,
     TOTALVARIATION,
     CATEGORY_MORPHOLOGICAL,
     DILATION,
     EROSION,
     OPENING,
     CLOSING,
     CATEGORY_EDGE_DETECTION,
     GRADIENT,
     LAPLACIAN,
     SOBEL,
     CATEGORY_MISC,
     THRESHOLD,
     INVERSION,
     DOWNSAMPLING,
     FLIPPING,
     RESAMPLING,
     RESCALE,
     RESCALE2
   } m_SelectedAction;
 
   enum OperationType{
     TWOIMAGESNOACTIONSELECTED,
     CATEGORY_ARITHMETIC,
     ADD,
     SUBTRACT,
     MULTIPLY,
     DIVIDE,
     RESAMPLE_TO,
     CATEGORY_BOOLEAN,
     AND,
     OR,
     XOR
   } m_SelectedOperation;
 
   enum InterpolationType{
     LINEAR,
     NEAREST
   } m_SelectedInterpolation;
 };
 
 #endif // !defined(QmitkBasicImageProcessing_H__INCLUDED)
 
 
diff --git a/Plugins/org.mitk.gui.qt.xnat/resources/xnat-connect.png b/Plugins/org.mitk.gui.qt.xnat/resources/xnat-connect.png
new file mode 100644
index 0000000000..2e4c85d1ea
Binary files /dev/null and b/Plugins/org.mitk.gui.qt.xnat/resources/xnat-connect.png differ
diff --git a/Plugins/org.mitk.gui.qt.xnat/resources/xnat-disconnect.png b/Plugins/org.mitk.gui.qt.xnat/resources/xnat-disconnect.png
new file mode 100644
index 0000000000..6423104172
Binary files /dev/null and b/Plugins/org.mitk.gui.qt.xnat/resources/xnat-disconnect.png differ
diff --git a/Plugins/org.mitk.gui.qt.xnat/resources/xnat.qrc b/Plugins/org.mitk.gui.qt.xnat/resources/xnat.qrc
index da7032238c..efdd0f6eda 100644
--- a/Plugins/org.mitk.gui.qt.xnat/resources/xnat.qrc
+++ b/Plugins/org.mitk.gui.qt.xnat/resources/xnat.qrc
@@ -1,8 +1,10 @@
 <RCC>
     <qresource prefix="/xnat-plugin">
         <file>xnat-download.png</file>
         <file>xnat-upload.png</file>
         <file>xnat-folder.png</file>
         <file>xnat-icon.png</file>
+        <file>xnat-connect.png</file>
+        <file>xnat-disconnect.png</file>
     </qresource>
 </RCC>
diff --git a/Plugins/org.mitk.gui.qt.xnat/resources/xnat_treebrowser_icon.png b/Plugins/org.mitk.gui.qt.xnat/resources/xnat_treebrowser_icon.png
index 5d85c84a18..a7d55719f8 100644
Binary files a/Plugins/org.mitk.gui.qt.xnat/resources/xnat_treebrowser_icon.png and b/Plugins/org.mitk.gui.qt.xnat/resources/xnat_treebrowser_icon.png differ
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 6f245ce7ad..e8866dd8ea 100644
--- a/Plugins/org.mitk.gui.qt.xnat/src/internal/QmitkXnatConnectionPreferencePage.cpp
+++ b/Plugins/org.mitk.gui.qt.xnat/src/internal/QmitkXnatConnectionPreferencePage.cpp
@@ -1,316 +1,309 @@
 /*===================================================================
 
 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 "QmitkXnatTreeBrowserView.h"
 
 #include "org_mitk_gui_qt_xnatinterface_Activator.h"
 
 #include "berryIPreferencesService.h"
 #include "berryPlatform.h"
 
 #include <QFileDialog>
 #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(QmitkXnatTreeBrowserView::VIEW_ID);
   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>());
+          mitk::org_mitk_gui_qt_xnatinterface_Activator::GetXnatModuleContext()->GetServiceReference<ctkXnatSession>());
   }
   catch (std::invalid_argument)
   {
     session = nullptr;
   }
 
-  if (session != nullptr)
+  if (session != nullptr && session->isOpen())
   {
-    if (session->isOpen())
-    {
-      m_Controls.xnatTestConnectionButton->setText("Disconnect");
-    }
-    else
-    {
-      m_Controls.xnatTestConnectionButton->setText("Connect");
-    }
+    m_Controls.xnatTestConnectionLabel->setStyleSheet("QLabel { color: green; }");
+    m_Controls.xnatTestConnectionLabel->setText("Already connected.");
+    m_Controls.xnatTestConnectionButton->setEnabled(false);
   }
-
   const QIntValidator *portV = new QIntValidator(0, 65535, parent);
   m_Controls.inXnatPort->setValidator(portV);
 
   const QRegExp hostRx("^(https?)://[^ /](\\S)+$");
   const QRegExpValidator *hostV = new QRegExpValidator(hostRx, parent);
   m_Controls.inXnatHostAddress->setValidator(hostV);
 
-  connect(m_Controls.xnatTestConnectionButton, SIGNAL(clicked()), this, SLOT(ToggleConnection()));
+  connect(m_Controls.xnatTestConnectionButton, SIGNAL(clicked()), this, SLOT(TestConnection()));
 
   connect(m_Controls.inXnatHostAddress, SIGNAL(editingFinished()), this, SLOT(UrlChanged()));
   connect(m_Controls.inXnatDownloadPath, SIGNAL(editingFinished()), this, SLOT(DownloadPathChanged()));
 
   connect(m_Controls.cbUseNetworkProxy, SIGNAL(toggled(bool)), this, SLOT(onUseNetworkProxy(bool)));
 
   connect(m_Controls.btnDownloadPath, SIGNAL(clicked()), this, SLOT(OnDownloadPathButtonClicked()));
 
   m_Controls.groupBoxProxySettings->setVisible(m_Controls.cbUseNetworkProxy->isChecked());
 
   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.xnatHostAddressLabel->text(), m_Controls.inXnatHostAddress->text());
       _XnatConnectionPreferencesNode->Put(m_Controls.xnatPortLabel->text(), m_Controls.inXnatPort->text());
       _XnatConnectionPreferencesNode->Put(m_Controls.xnatUsernameLabel->text(), m_Controls.inXnatUsername->text());
       _XnatConnectionPreferencesNode->Put(m_Controls.xnatPasswortLabel->text(), m_Controls.inXnatPassword->text());
       _XnatConnectionPreferencesNode->Put(m_Controls.xnatDownloadPathLabel->text(), m_Controls.inXnatDownloadPath->text());
 
       // Network proxy settings
       _XnatConnectionPreferencesNode->PutBool(m_Controls.cbUseNetworkProxy->text(), m_Controls.cbUseNetworkProxy->isChecked());
       _XnatConnectionPreferencesNode->Put(m_Controls.proxyAddressLabel->text(), m_Controls.inProxyAddress->text());
       _XnatConnectionPreferencesNode->Put(m_Controls.proxyPortLabel->text(), m_Controls.inProxyPort->text());
       _XnatConnectionPreferencesNode->Put(m_Controls.proxyUsernameLabel->text(), m_Controls.inProxyUsername->text());
       _XnatConnectionPreferencesNode->Put(m_Controls.proxyPasswordLabel->text(), m_Controls.inProxyPassword->text());
+
+      // Silent Mode
+      _XnatConnectionPreferencesNode->PutBool(m_Controls.cbUseSilentMode->text(), m_Controls.cbUseSilentMode->isChecked());
+
+      //Write
       _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.");
+                          "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.inXnatHostAddress->text().isEmpty())
   {
     errString += "Server Address is empty.\n";
   }
 
   if (m_Controls.inXnatUsername->text().isEmpty())
   {
     errString += "Username is empty.\n";
   }
 
   if (m_Controls.inXnatPassword->text().isEmpty())
   {
     errString += "Password is empty.\n";
   }
 
   // if something is empty
   if (!errString.isEmpty())
   {
     m_Controls.xnatTestConnectionLabel->setStyleSheet("QLabel { color: red; }");
     m_Controls.xnatTestConnectionLabel->setText("Connecting failed.\n" + errString);
     return true;
   }
   else
   {
     return false;
   }
 }
 
 void QmitkXnatConnectionPreferencePage::Update()
 {
   IPreferences::Pointer _XnatConnectionPreferencesNode = m_XnatConnectionPreferencesNode.Lock();
   if (_XnatConnectionPreferencesNode.IsNotNull())
   {
     m_Controls.inXnatHostAddress->setText(_XnatConnectionPreferencesNode->Get(
-      m_Controls.xnatHostAddressLabel->text(), m_Controls.inXnatHostAddress->text()));
+                                            m_Controls.xnatHostAddressLabel->text(), m_Controls.inXnatHostAddress->text()));
     m_Controls.inXnatPort->setText(_XnatConnectionPreferencesNode->Get(
-      m_Controls.xnatPortLabel->text(), m_Controls.inXnatPort->text()));
+                                     m_Controls.xnatPortLabel->text(), m_Controls.inXnatPort->text()));
     m_Controls.inXnatUsername->setText(_XnatConnectionPreferencesNode->Get(
-      m_Controls.xnatUsernameLabel->text(), m_Controls.inXnatUsername->text()));
+                                         m_Controls.xnatUsernameLabel->text(), m_Controls.inXnatUsername->text()));
     m_Controls.inXnatPassword->setText(_XnatConnectionPreferencesNode->Get(
-      m_Controls.xnatPasswortLabel->text(), m_Controls.inXnatPassword->text()));
+                                         m_Controls.xnatPasswortLabel->text(), m_Controls.inXnatPassword->text()));
     m_Controls.inXnatDownloadPath->setText(_XnatConnectionPreferencesNode->Get(
-      m_Controls.xnatDownloadPathLabel->text(), m_Controls.inXnatDownloadPath->text()));
+                                             m_Controls.xnatDownloadPathLabel->text(), m_Controls.inXnatDownloadPath->text()));
 
     // Network proxy settings
     m_Controls.cbUseNetworkProxy->setChecked(_XnatConnectionPreferencesNode->GetBool(
-                                             m_Controls.cbUseNetworkProxy->text(), false));
+                                               m_Controls.cbUseNetworkProxy->text(), false));
     m_Controls.inProxyAddress->setText(_XnatConnectionPreferencesNode->Get(
-      m_Controls.proxyAddressLabel->text(), m_Controls.inProxyAddress->text()));
+                                         m_Controls.proxyAddressLabel->text(), m_Controls.inProxyAddress->text()));
     m_Controls.inProxyPort->setText(_XnatConnectionPreferencesNode->Get(
-      m_Controls.proxyPortLabel->text(), m_Controls.inProxyPort->text()));
+                                      m_Controls.proxyPortLabel->text(), m_Controls.inProxyPort->text()));
     m_Controls.inProxyUsername->setText(_XnatConnectionPreferencesNode->Get(
-      m_Controls.proxyUsernameLabel->text(), m_Controls.inProxyUsername->text()));
+                                          m_Controls.proxyUsernameLabel->text(), m_Controls.inProxyUsername->text()));
     m_Controls.inProxyPassword->setText(_XnatConnectionPreferencesNode->Get(
-      m_Controls.proxyPasswordLabel->text(), m_Controls.inProxyPassword->text()));
+                                          m_Controls.proxyPasswordLabel->text(), m_Controls.inProxyPassword->text()));
+
+    // Silent Mode
+    m_Controls.cbUseSilentMode->setChecked(_XnatConnectionPreferencesNode->GetBool(
+                                               m_Controls.cbUseSilentMode->text(), false));
   }
 }
 
 void QmitkXnatConnectionPreferencePage::UrlChanged()
 {
   m_Controls.inXnatHostAddress->setStyleSheet("QLineEdit { background-color: white; }");
   QString str = m_Controls.inXnatHostAddress->text();
 
   while (str.endsWith("/"))
   {
     str = str.left(str.length() - 1);
   }
 
   m_Controls.inXnatHostAddress->setText(str);
 
   QUrl url(m_Controls.inXnatHostAddress->text());
   if (!url.isValid())
   {
     m_Controls.inXnatHostAddress->setStyleSheet("QLineEdit { background-color: red; }");
   }
 }
 
 void QmitkXnatConnectionPreferencePage::DownloadPathChanged()
 {
   m_Controls.inXnatDownloadPath->setStyleSheet("QLineEdit { background-color: white; }");
   QString downloadPath = m_Controls.inXnatDownloadPath->text();
   if (!downloadPath.isEmpty())
   {
     if (downloadPath.lastIndexOf("/") != downloadPath.size() - 1)
     {
       downloadPath.append("/");
       m_Controls.inXnatDownloadPath->setText(downloadPath);
     }
     QFileInfo path(m_Controls.inXnatDownloadPath->text());
     if (!path.isDir())
     {
       m_Controls.inXnatDownloadPath->setStyleSheet("QLineEdit { background-color: red; }");
     }
   }
 }
 
 void QmitkXnatConnectionPreferencePage::onUseNetworkProxy(bool status)
 {
   m_Controls.groupBoxProxySettings->setVisible(status);
 }
 
 void QmitkXnatConnectionPreferencePage::OnDownloadPathButtonClicked()
 {
   QString dir = QFileDialog::getExistingDirectory();
   if (!dir.endsWith("/") || !dir.endsWith("\\"))
     dir.append("/");
   m_Controls.inXnatDownloadPath->setText(dir);
 }
 
-void QmitkXnatConnectionPreferencePage::ToggleConnection()
+void QmitkXnatConnectionPreferencePage::TestConnection()
 {
   ctkXnatSession* session = 0;
 
   try
   {
     session = mitk::org_mitk_gui_qt_xnatinterface_Activator::GetXnatModuleContext()->GetService(
-      mitk::org_mitk_gui_qt_xnatinterface_Activator::GetXnatModuleContext()->GetServiceReference<ctkXnatSession>());
+          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>());
+            mitk::org_mitk_gui_qt_xnatinterface_Activator::GetXnatModuleContext()->GetServiceReference<ctkXnatSession>());
     }
   }
 
-  if (session != 0 && session->isOpen())
+  try
   {
+    mitk::org_mitk_gui_qt_xnatinterface_Activator::GetXnatSessionManager()->OpenXnatSession();
+
+    m_Controls.xnatTestConnectionLabel->setStyleSheet("QLabel { color: green; }");
+    m_Controls.xnatTestConnectionLabel->setText("Connecting successful.");
+
     mitk::org_mitk_gui_qt_xnatinterface_Activator::GetXnatSessionManager()->CloseXnatSession();
-    m_Controls.xnatTestConnectionButton->setText("Connect");
-    m_Controls.xnatTestConnectionLabel->clear();
   }
-  else if (session != 0 && !session->isOpen())
+  catch (const ctkXnatAuthenticationException& auth)
   {
-    m_Controls.xnatTestConnectionButton->setEnabled(false);
-
-    try
-    {
-      mitk::org_mitk_gui_qt_xnatinterface_Activator::GetXnatSessionManager()->OpenXnatSession();
-
-      m_Controls.xnatTestConnectionButton->setText("Disconnect");
-      m_Controls.xnatTestConnectionLabel->setStyleSheet("QLabel { color: green; }");
-      m_Controls.xnatTestConnectionLabel->setText("Connecting successful.");
-    }
-    catch (const ctkXnatAuthenticationException& auth)
-    {
-      m_Controls.xnatTestConnectionLabel->setStyleSheet("QLabel { color: red; }");
-      m_Controls.xnatTestConnectionLabel->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.xnatTestConnectionLabel->setStyleSheet("QLabel { color: red; }");
-      m_Controls.xnatTestConnectionLabel->setText("Connecting failed:\nInvalid Server Adress");
-      MITK_INFO << e.message().toStdString();
-      mitk::org_mitk_gui_qt_xnatinterface_Activator::GetXnatSessionManager()->CloseXnatSession();
-    }
-    m_Controls.xnatTestConnectionButton->setEnabled(true);
+    m_Controls.xnatTestConnectionLabel->setStyleSheet("QLabel { color: red; }");
+    m_Controls.xnatTestConnectionLabel->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.xnatTestConnectionLabel->setStyleSheet("QLabel { color: red; }");
+    m_Controls.xnatTestConnectionLabel->setText("Connecting failed:\nInvalid Server Adress");
+    MITK_INFO << e.message().toStdString();
+    mitk::org_mitk_gui_qt_xnatinterface_Activator::GetXnatSessionManager()->CloseXnatSession();
+  }
+
 }
diff --git a/Plugins/org.mitk.gui.qt.xnat/src/internal/QmitkXnatConnectionPreferencePage.h b/Plugins/org.mitk.gui.qt.xnat/src/internal/QmitkXnatConnectionPreferencePage.h
index 5b2feb14e8..9a1ebf597c 100644
--- a/Plugins/org.mitk.gui.qt.xnat/src/internal/QmitkXnatConnectionPreferencePage.h
+++ b/Plugins/org.mitk.gui.qt.xnat/src/internal/QmitkXnatConnectionPreferencePage.h
@@ -1,87 +1,87 @@
 /*===================================================================
 
 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 QMITKXNATCONNECTIONPREFERENCEPAGE_H_
 #define QMITKXNATCONNECTIONPREFERENCEPAGE_H_
 
 #include "berryIQtPreferencePage.h"
 #include <berryIPreferences.h>
 
 #include "ui_QmitkXnatConnectionPreferencePageControls.h"
 
 class QWidget;
 class QLineEdit;
 
 struct QmitkXnatConnectionPreferencePage : public QObject, public berry::IQtPreferencePage
 {
   Q_OBJECT
   Q_INTERFACES(berry::IPreferencePage)
 
 public:
   QmitkXnatConnectionPreferencePage();
 
   void Init(berry::IWorkbench::Pointer workbench) override;
 
   void CreateQtControl(QWidget* widget) override;
 
   QWidget* GetQtControl() const override;
 
   ///
   /// \see IPreferencePage::PerformOk()
   ///
   virtual bool PerformOk() override;
 
   ///
   /// \see IPreferencePage::PerformCancel()
   ///
   virtual void PerformCancel() override;
 
   ///
   /// \see IPreferencePage::Update()
   ///
   virtual void Update() override;
 
   protected slots:
     virtual void UrlChanged();
     virtual void DownloadPathChanged();
   void OnDownloadPathButtonClicked();
 
     ///
     /// Toggles the Connection in the Service Registry from opened to closed or the other way around.
     ///
-    virtual void ToggleConnection();
+    virtual void TestConnection();
 
   virtual void onUseNetworkProxy(bool);
 
 protected:
 
   Ui::QmitkXnatConnectionPreferencePageControls m_Controls;
 
   QWidget* m_Control;
 
   berry::IPreferences::WeakPtr m_XnatConnectionPreferencesNode;
 
 private:
 
   ///
   /// Checks if the entered user information is empty.
   ///
   virtual bool UserInformationEmpty();
 
 };
 
 #endif /* QMITKXNATCONNECTIONPREFERENCEPAGE_H_ */
diff --git a/Plugins/org.mitk.gui.qt.xnat/src/internal/QmitkXnatConnectionPreferencePageControls.ui b/Plugins/org.mitk.gui.qt.xnat/src/internal/QmitkXnatConnectionPreferencePageControls.ui
index 92edcda670..a5044a5b3c 100644
--- a/Plugins/org.mitk.gui.qt.xnat/src/internal/QmitkXnatConnectionPreferencePageControls.ui
+++ b/Plugins/org.mitk.gui.qt.xnat/src/internal/QmitkXnatConnectionPreferencePageControls.ui
@@ -1,262 +1,320 @@
 <?xml version="1.0" encoding="UTF-8"?>
 <ui version="4.0">
  <class>QmitkXnatConnectionPreferencePageControls</class>
  <widget class="QWidget" name="QmitkXnatConnectionPreferencePageControls">
   <property name="geometry">
    <rect>
     <x>0</x>
     <y>0</y>
     <width>742</width>
-    <height>349</height>
+    <height>419</height>
    </rect>
   </property>
   <property name="sizePolicy">
    <sizepolicy hsizetype="Preferred" vsizetype="Preferred">
     <horstretch>0</horstretch>
     <verstretch>0</verstretch>
    </sizepolicy>
   </property>
   <property name="minimumSize">
    <size>
     <width>653</width>
     <height>116</height>
    </size>
   </property>
   <property name="maximumSize">
    <size>
     <width>16777215</width>
     <height>16777215</height>
    </size>
   </property>
   <property name="windowTitle">
    <string>Form</string>
   </property>
   <layout class="QGridLayout" name="gridLayout">
-   <item row="2" column="1">
-    <widget class="QCheckBox" name="cbUseNetworkProxy">
-     <property name="text">
-      <string>Use Network Proxy</string>
-     </property>
-     <property name="checked">
-      <bool>true</bool>
-     </property>
-    </widget>
-   </item>
-   <item row="0" column="1">
-    <widget class="QGroupBox" name="groupBoxXnatSettings">
+   <item row="4" column="1">
+    <widget class="QGroupBox" name="groupBoxProxySettings">
      <property name="title">
-      <string>XNAT Connection Settings</string>
+      <string>Network Proxy Settings</string>
      </property>
-     <layout class="QGridLayout" name="gridLayout_2">
-      <item row="0" column="0">
-       <widget class="QLabel" name="xnatHostAddressLabel">
-        <property name="text">
-         <string>Server Address</string>
-        </property>
-       </widget>
-      </item>
-      <item row="0" column="1">
-       <widget class="QLineEdit" name="inXnatHostAddress">
-        <property name="toolTip">
-         <string>&lt;html&gt;&lt;head/&gt;&lt;body&gt;&lt;p&gt;Examples:&lt;/p&gt;&lt;p&gt;https://central.xnat.org&lt;br/&gt;http://localhost/xnat&lt;/p&gt;&lt;/body&gt;&lt;/html&gt;</string>
-        </property>
-        <property name="placeholderText">
-         <string>http(s)://</string>
-        </property>
-       </widget>
-      </item>
-      <item row="0" column="2">
-       <widget class="QLabel" name="xnatPortLabel">
-        <property name="text">
-         <string>Port</string>
-        </property>
-       </widget>
-      </item>
-      <item row="0" column="3">
-       <widget class="QLineEdit" name="inXnatPort">
+     <layout class="QGridLayout" name="gridLayout_3">
+      <item row="1" column="3">
+       <widget class="QLineEdit" name="inProxyPort">
         <property name="maximumSize">
          <size>
           <width>50</width>
           <height>16777215</height>
          </size>
         </property>
         <property name="toolTip">
          <string>Standard-Port: 80</string>
         </property>
         <property name="text">
          <string/>
         </property>
        </widget>
       </item>
-      <item row="1" column="0">
-       <widget class="QLabel" name="xnatUsernameLabel">
+      <item row="3" column="0">
+       <widget class="QLabel" name="proxyPasswordLabel">
         <property name="text">
-         <string>Username</string>
+         <string>Proxy Password</string>
+        </property>
+       </widget>
+      </item>
+      <item row="2" column="0">
+       <widget class="QLabel" name="proxyUsernameLabel">
+        <property name="text">
+         <string>Proxy Username</string>
         </property>
        </widget>
       </item>
       <item row="1" column="1">
-       <widget class="QLineEdit" name="inXnatUsername">
+       <widget class="QLineEdit" name="inProxyAddress">
+        <property name="toolTip">
+         <string>&lt;html&gt;&lt;head/&gt;&lt;body&gt;&lt;p&gt;Examples:&lt;/p&gt;&lt;p&gt;https://central.xnat.org&lt;br/&gt;http://localhost/xnat&lt;/p&gt;&lt;/body&gt;&lt;/html&gt;</string>
+        </property>
         <property name="placeholderText">
-         <string>testuser</string>
+         <string>http(s)://</string>
         </property>
        </widget>
       </item>
-      <item row="2" column="0">
-       <widget class="QLabel" name="xnatPasswortLabel">
+      <item row="1" column="2">
+       <widget class="QLabel" name="proxyPortLabel">
         <property name="text">
-         <string>Password</string>
+         <string>Proxy Port</string>
         </property>
        </widget>
       </item>
-      <item row="2" column="1">
-       <widget class="QLineEdit" name="inXnatPassword">
+      <item row="3" column="1">
+       <widget class="QLineEdit" name="inProxyPassword">
         <property name="echoMode">
          <enum>QLineEdit::Password</enum>
         </property>
         <property name="placeholderText">
          <string>testpassword</string>
         </property>
        </widget>
       </item>
-      <item row="3" column="0">
-       <widget class="QLabel" name="xnatDownloadPathLabel">
-        <property name="text">
-         <string>Download Path</string>
+      <item row="2" column="1">
+       <widget class="QLineEdit" name="inProxyUsername">
+        <property name="placeholderText">
+         <string>testuser</string>
         </property>
        </widget>
       </item>
-      <item row="3" column="1">
-       <widget class="QLineEdit" name="inXnatDownloadPath"/>
-      </item>
-      <item row="4" column="0">
-       <widget class="QPushButton" name="xnatTestConnectionButton">
+      <item row="1" column="0">
+       <widget class="QLabel" name="proxyAddressLabel">
         <property name="text">
-         <string>Connect</string>
+         <string>Proxy Server Address</string>
         </property>
        </widget>
       </item>
-      <item row="5" column="0" colspan="2">
-       <widget class="QLabel" name="xnatTestConnectionLabel">
-        <property name="layoutDirection">
-         <enum>Qt::LeftToRight</enum>
-        </property>
-        <property name="lineWidth">
-         <number>1</number>
+     </layout>
+    </widget>
+   </item>
+   <item row="0" column="1">
+    <widget class="QGroupBox" name="groupBoxXnatSettings">
+     <property name="title">
+      <string>XNAT Connection Settings</string>
+     </property>
+     <layout class="QGridLayout" name="gridLayout_2">
+      <item row="0" column="2">
+       <widget class="QLabel" name="xnatPortLabel">
+        <property name="text">
+         <string>Port</string>
         </property>
+       </widget>
+      </item>
+      <item row="1" column="0">
+       <widget class="QLabel" name="xnatUsernameLabel">
         <property name="text">
-         <string/>
+         <string>Username</string>
         </property>
-        <property name="alignment">
-         <set>Qt::AlignLeading|Qt::AlignLeft|Qt::AlignTop</set>
+       </widget>
+      </item>
+      <item row="2" column="0">
+       <widget class="QLabel" name="xnatPasswortLabel">
+        <property name="text">
+         <string>Password</string>
         </property>
        </widget>
       </item>
-      <item row="3" column="2">
-       <widget class="QToolButton" name="btnDownloadPath">
+      <item row="0" column="0">
+       <widget class="QLabel" name="xnatHostAddressLabel">
         <property name="text">
-         <string>...</string>
+         <string>Server Address</string>
         </property>
        </widget>
       </item>
-     </layout>
-    </widget>
-   </item>
-   <item row="3" column="1">
-    <widget class="QGroupBox" name="groupBoxProxySettings">
-     <property name="title">
-      <string>Network Proxy Settings</string>
-     </property>
-     <layout class="QGridLayout" name="gridLayout_3">
-      <item row="1" column="3">
-       <widget class="QLineEdit" name="inProxyPort">
+      <item row="0" column="3">
+       <widget class="QLineEdit" name="inXnatPort">
         <property name="maximumSize">
          <size>
           <width>50</width>
           <height>16777215</height>
          </size>
         </property>
         <property name="toolTip">
          <string>Standard-Port: 80</string>
         </property>
         <property name="text">
          <string/>
         </property>
        </widget>
       </item>
-      <item row="3" column="0">
-       <widget class="QLabel" name="proxyPasswordLabel">
-        <property name="text">
-         <string>Proxy Password</string>
-        </property>
-       </widget>
-      </item>
-      <item row="2" column="0">
-       <widget class="QLabel" name="proxyUsernameLabel">
-        <property name="text">
-         <string>Proxy Username</string>
-        </property>
-       </widget>
-      </item>
       <item row="1" column="1">
-       <widget class="QLineEdit" name="inProxyAddress">
-        <property name="toolTip">
-         <string>&lt;html&gt;&lt;head/&gt;&lt;body&gt;&lt;p&gt;Examples:&lt;/p&gt;&lt;p&gt;https://central.xnat.org&lt;br/&gt;http://localhost/xnat&lt;/p&gt;&lt;/body&gt;&lt;/html&gt;</string>
-        </property>
+       <widget class="QLineEdit" name="inXnatUsername">
         <property name="placeholderText">
-         <string>http(s)://</string>
+         <string>testuser</string>
         </property>
        </widget>
       </item>
-      <item row="1" column="2">
-       <widget class="QLabel" name="proxyPortLabel">
+      <item row="3" column="2">
+       <widget class="QToolButton" name="btnDownloadPath">
         <property name="text">
-         <string>Proxy Port</string>
+         <string>...</string>
         </property>
        </widget>
       </item>
-      <item row="3" column="1">
-       <widget class="QLineEdit" name="inProxyPassword">
+      <item row="2" column="1">
+       <widget class="QLineEdit" name="inXnatPassword">
         <property name="echoMode">
          <enum>QLineEdit::Password</enum>
         </property>
         <property name="placeholderText">
          <string>testpassword</string>
         </property>
        </widget>
       </item>
-      <item row="2" column="1">
-       <widget class="QLineEdit" name="inProxyUsername">
-        <property name="placeholderText">
-         <string>testuser</string>
+      <item row="3" column="1">
+       <widget class="QLineEdit" name="inXnatDownloadPath"/>
+      </item>
+      <item row="3" column="0">
+       <widget class="QLabel" name="xnatDownloadPathLabel">
+        <property name="text">
+         <string>Download Path</string>
         </property>
        </widget>
       </item>
-      <item row="1" column="0">
-       <widget class="QLabel" name="proxyAddressLabel">
-        <property name="text">
-         <string>Proxy Server Address</string>
+      <item row="0" column="1">
+       <widget class="QLineEdit" name="inXnatHostAddress">
+        <property name="toolTip">
+         <string>&lt;html&gt;&lt;head/&gt;&lt;body&gt;&lt;p&gt;Examples:&lt;/p&gt;&lt;p&gt;https://central.xnat.org&lt;br/&gt;http://localhost/xnat&lt;/p&gt;&lt;/body&gt;&lt;/html&gt;</string>
+        </property>
+        <property name="placeholderText">
+         <string>http(s)://</string>
         </property>
        </widget>
       </item>
      </layout>
     </widget>
    </item>
-   <item row="4" column="1">
+   <item row="8" column="1">
     <spacer name="verticalSpacer">
      <property name="orientation">
       <enum>Qt::Vertical</enum>
      </property>
      <property name="sizeHint" stdset="0">
       <size>
        <width>20</width>
        <height>40</height>
       </size>
      </property>
     </spacer>
    </item>
+   <item row="2" column="1">
+    <widget class="QCheckBox" name="cbUseNetworkProxy">
+     <property name="text">
+      <string>Use Network Proxy</string>
+     </property>
+     <property name="checked">
+      <bool>true</bool>
+     </property>
+    </widget>
+   </item>
+   <item row="5" column="1">
+    <layout class="QGridLayout" name="groupConnectionTest">
+     <property name="spacing">
+      <number>6</number>
+     </property>
+     <item row="1" column="0">
+      <layout class="QHBoxLayout" name="buttonSpacerLayout">
+       <item>
+        <widget class="QPushButton" name="xnatTestConnectionButton">
+         <property name="text">
+          <string>Test Connection</string>
+         </property>
+        </widget>
+       </item>
+       <item>
+        <spacer name="horizontalSpacer">
+         <property name="orientation">
+          <enum>Qt::Horizontal</enum>
+         </property>
+         <property name="sizeHint" stdset="0">
+          <size>
+           <width>40</width>
+           <height>20</height>
+          </size>
+         </property>
+        </spacer>
+       </item>
+      </layout>
+     </item>
+     <item row="3" column="0">
+      <widget class="QLabel" name="xnatTestConnectionLabel">
+       <property name="layoutDirection">
+        <enum>Qt::LeftToRight</enum>
+       </property>
+       <property name="lineWidth">
+        <number>1</number>
+       </property>
+       <property name="text">
+        <string/>
+       </property>
+       <property name="alignment">
+        <set>Qt::AlignLeading|Qt::AlignLeft|Qt::AlignTop</set>
+       </property>
+      </widget>
+     </item>
+    </layout>
+   </item>
+   <item row="6" column="1">
+    <layout class="QHBoxLayout" name="horizontalLayout">
+     <item>
+      <widget class="QCheckBox" name="cbUseSilentMode">
+       <property name="text">
+        <string>Silent Mode</string>
+       </property>
+       <property name="checked">
+        <bool>true</bool>
+       </property>
+      </widget>
+     </item>
+     <item>
+      <widget class="QLabel" name="label">
+       <property name="text">
+        <string>(Suppresses most message popups)</string>
+       </property>
+      </widget>
+     </item>
+     <item>
+      <spacer name="horizontalSpacer_2">
+       <property name="orientation">
+        <enum>Qt::Horizontal</enum>
+       </property>
+       <property name="sizeHint" stdset="0">
+        <size>
+         <width>40</width>
+         <height>20</height>
+        </size>
+       </property>
+      </spacer>
+     </item>
+    </layout>
+   </item>
   </layout>
  </widget>
  <resources/>
  <connections/>
 </ui>
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 4bc02a9c1a..157a3d942d 100644
--- a/Plugins/org.mitk.gui.qt.xnat/src/internal/QmitkXnatTreeBrowserView.cpp
+++ b/Plugins/org.mitk.gui.qt.xnat/src/internal/QmitkXnatTreeBrowserView.cpp
@@ -1,1007 +1,1100 @@
 /*===================================================================
 
 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 "org_mitk_gui_qt_xnatinterface_Activator.h"
 
 // Blueberry
 #include <berryPlatform.h>
 
 // CTK XNAT Core
 #include <ctkXnatAssessor.h>
 #include <ctkXnatAssessorFolder.h>
 #include <ctkXnatDataModel.h>
 #include <ctkXnatException.h>
 #include <ctkXnatExperiment.h>
 #include "ctkXnatFile.h"
 #include <ctkXnatProject.h>
 #include <ctkXnatReconstruction.h>
 #include <ctkXnatReconstructionFolder.h>
 #include <ctkXnatResource.h>
 #include <ctkXnatResourceFolder.h>
 #include <ctkXnatScan.h>
 #include <ctkXnatScanFolder.h>
 #include <ctkXnatSubject.h>
 
 
 // MITK XNAT
 #include <mitkDataStorage.h>
 #include <QmitkIOUtil.h>
 #include <QmitkXnatProjectWidget.h>
 #include <QmitkXnatSubjectWidget.h>
 #include <QmitkXnatExperimentWidget.h>
 #include <QmitkXnatCreateObjectDialog.h>
 #include <QmitkXnatUploadFromDataStorageDialog.h>
 
 // Qt
 #include <QAction>
 #include <QClipboard>
 #include <QDateTime>
 #include <QDialog>
 #include <QDialogButtonBox>
 #include <QDir>
 #include <QDirIterator>
 #include <QFileDialog>
 #include <QInputDialog>
 #include <QLayoutItem>
 #include <QMenu>
 #include <QMessageBox>
 #include <QTimer>
+#include <QmitkPreferencesDialog.h>
 
 // Poco
 #include <Poco/Zip/Decompress.h>
 
 const QString QmitkXnatTreeBrowserView::VIEW_ID = "org.mitk.views.xnat.treebrowser";
 
 QmitkXnatTreeBrowserView::QmitkXnatTreeBrowserView() :
-m_DataStorageServiceTracker(mitk::org_mitk_gui_qt_xnatinterface_Activator::GetContext()),
-m_TreeModel(new QmitkXnatTreeModel()),
-m_Tracker(0),
-m_DownloadPath(berry::Platform::GetPreferencesService()->GetSystemPreferences()->Node(VIEW_ID)->Get("Download Path", ""))
+  m_DataStorageServiceTracker(mitk::org_mitk_gui_qt_xnatinterface_Activator::GetContext()),
+  m_TreeModel(new QmitkXnatTreeModel()),
+  m_Tracker(0),
+  m_DownloadPath(berry::Platform::GetPreferencesService()->GetSystemPreferences()->Node(VIEW_ID)->Get("Download Path", "")),
+  m_SilentMode(false)
 {
   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()
 {
   m_DataStorageServiceTracker.close();
   delete m_TreeModel;
   delete m_Tracker;
 }
 
 void QmitkXnatTreeBrowserView::SetFocus()
 {
 }
 
+void QmitkXnatTreeBrowserView::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 (true)
+    {
+      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.btnXnatConnect->setToolTip("Connect");
+    m_Controls.btnXnatConnect->setIcon(QIcon(":/xnat-plugin/xnat-connect.png"));
+    CleanUp();
+  }
+  else if (session != 0 && !session->isOpen())
+  {
+    try
+    {
+      mitk::org_mitk_gui_qt_xnatinterface_Activator::GetXnatSessionManager()->OpenXnatSession();
+      m_Controls.btnXnatConnect->setToolTip("Disconnect");
+      m_Controls.btnXnatConnect->setIcon(QIcon(":/xnat-plugin/xnat-disconnect.png"));
+    }
+    catch (const ctkXnatAuthenticationException& auth)
+    {
+      MITK_INFO << auth.message().toStdString();
+      mitk::org_mitk_gui_qt_xnatinterface_Activator::GetXnatSessionManager()->CloseXnatSession();
+      QmitkPreferencesDialog _PreferencesDialog(QApplication::activeWindow());
+      _PreferencesDialog.SetSelectedPage("org.mitk.gui.qt.application.XnatConnectionPreferencePage");
+      _PreferencesDialog.exec();
+    }
+    catch (const ctkException& e)
+    {
+      MITK_INFO << e.message().toStdString();
+      mitk::org_mitk_gui_qt_xnatinterface_Activator::GetXnatSessionManager()->CloseXnatSession();
+      QmitkPreferencesDialog _PreferencesDialog(QApplication::activeWindow());
+      _PreferencesDialog.SetSelectedPage("org.mitk.gui.qt.application.XnatConnectionPreferencePage");
+      _PreferencesDialog.exec();
+    }
+    catch (...)
+    {
+      QmitkPreferencesDialog _PreferencesDialog(QApplication::activeWindow());
+      _PreferencesDialog.SetSelectedPage("org.mitk.gui.qt.application.XnatConnectionPreferencePage");
+      _PreferencesDialog.exec();
+    }
+  }
+}
+
 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.treeView->setSelectionMode(QAbstractItemView::ExtendedSelection);
   m_Controls.treeView->setAcceptDrops(true);
   m_Controls.treeView->setDropIndicatorShown(true);
-  m_Controls.labelError->setText("Please use the 'Connect' button in the Preferences.");
-  m_Controls.labelError->setStyleSheet("QLabel { color: red; }");
 
   m_Controls.treeView->setSelectionMode(QAbstractItemView::SingleSelection);
   m_Controls.treeView->setContextMenuPolicy(Qt::CustomContextMenu);
 
   m_Controls.groupBox->hide();
   m_Controls.wgtExperimentInfo->hide();
   m_Controls.wgtSubjectInfo->hide();
   m_Controls.wgtProjectInfo->hide();
 
   m_Tracker = new mitk::XnatSessionTracker(mitk::org_mitk_gui_qt_xnatinterface_Activator::GetXnatModuleContext());
 
   m_ContextMenu = new QMenu(m_Controls.treeView);
 
   connect(m_Controls.treeView, SIGNAL(clicked(const QModelIndex&)), SLOT(itemSelected(const QModelIndex&)));
   connect(m_Controls.treeView, SIGNAL(customContextMenuRequested(const QPoint&)),
-    this, SLOT(OnContextMenuRequested(const QPoint&)));
+          this, SLOT(OnContextMenuRequested(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>());
+          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(doubleClicked(const QModelIndex&)), this, SLOT(OnActivatedNode(const QModelIndex&)));
   connect(m_Controls.treeView, SIGNAL(clicked(const QModelIndex&)), this, SLOT(OnXnatNodeSelected(const QModelIndex&)));
   connect(m_TreeModel, SIGNAL(ResourceDropped(const QList<mitk::DataNode*>&, ctkXnatObject*, const QModelIndex&)), this, SLOT(OnUploadResource(const QList<mitk::DataNode*>&, ctkXnatObject*, const QModelIndex&)));
 
+  connect(m_Controls.btnXnatConnect, SIGNAL(clicked()), SLOT(ToggleConnection()));
   connect(m_Controls.btnXnatUpload, SIGNAL(clicked()), this, SLOT(OnUploadFromDataStorage()));
   connect(m_Controls.btnXnatDownload, SIGNAL(clicked()), this, SLOT(OnDownloadSelectedXnatFile()));
   connect(m_Controls.btnCreateXnatFolder, SIGNAL(clicked()), this, SLOT(OnCreateResourceFolder()));
 }
 
 void QmitkXnatTreeBrowserView::OnCreateResourceFolder()
 {
   QModelIndex index = m_Controls.treeView->selectionModel()->currentIndex();
 
   if(!index.isValid()) return;
 
   ctkXnatObject* parent = index.data(Qt::UserRole).value<ctkXnatObject*>();
 
   this->InternalAddResourceFolder(parent);
   m_TreeModel->refresh(index);
 }
 
 void QmitkXnatTreeBrowserView::OnDownloadSelectedXnatFile()
 {
   QModelIndex index = m_Controls.treeView->selectionModel()->currentIndex();
 
   if(!index.isValid()) return;
 
   ctkXnatObject* selectedXnatObject = index.data(Qt::UserRole).value<ctkXnatObject*>();
   bool enableDownload = dynamic_cast<ctkXnatFile*>(selectedXnatObject) != nullptr;
   enableDownload |= dynamic_cast<ctkXnatScan*>(selectedXnatObject) != nullptr;
 
   if (enableDownload)
   {
     this->InternalFileDownload(index, true);
   }
 }
 
 void QmitkXnatTreeBrowserView::OnUploadFromDataStorage()
 {
   QmitkXnatUploadFromDataStorageDialog dialog;
   dialog.SetDataStorage(this->GetDataStorage());
   int result = dialog.exec();
   if (result == QDialog::Accepted)
   {
     QList<mitk::DataNode*> nodes;
     nodes << dialog.GetSelectedNode().GetPointer();
     QModelIndex index = m_Controls.treeView->selectionModel()->currentIndex();
 
     if (!index.isValid()) return;
     ctkXnatObject* parent = m_TreeModel->xnatObject(index);
     this->OnUploadResource(nodes, parent, index);
   }
 }
 
 void QmitkXnatTreeBrowserView::OnXnatNodeSelected(const QModelIndex& index)
 {
   // Enable download button
   if (!index.isValid()) return;
 
   ctkXnatObject* selectedXnatObject = index.data(Qt::UserRole).value<ctkXnatObject*>();
 
   bool enableDownload = dynamic_cast<ctkXnatFile*>(selectedXnatObject) != nullptr;
   enableDownload |= dynamic_cast<ctkXnatScan*>(selectedXnatObject) != nullptr;
   m_Controls.btnXnatDownload->setEnabled(enableDownload);
 
   bool enableCreateFolder = dynamic_cast<ctkXnatProject*>(selectedXnatObject) != nullptr;
   enableCreateFolder |= dynamic_cast<ctkXnatSubject*>(selectedXnatObject) != nullptr;
   enableCreateFolder |= dynamic_cast<ctkXnatExperiment*>(selectedXnatObject) != nullptr;
   m_Controls.btnCreateXnatFolder->setEnabled(enableCreateFolder);
 
   bool enableUpload = dynamic_cast<ctkXnatResource*>(selectedXnatObject) != nullptr;
   m_Controls.btnXnatUpload->setEnabled(enableUpload);
 }
 
 void QmitkXnatTreeBrowserView::OnActivatedNode(const QModelIndex& index)
 {
   if (!index.isValid()) return;
 
   ctkXnatObject* selectedXnatObject = index.data(Qt::UserRole).value<ctkXnatObject*>();
   bool enableDownload = dynamic_cast<ctkXnatFile*>(selectedXnatObject) != nullptr;
   enableDownload |= dynamic_cast<ctkXnatScan*>(selectedXnatObject) != nullptr;
   if (enableDownload)
   {
-    QMessageBox msgBox;
-    QString msg ("Do you want to download "+selectedXnatObject->name()+"?");
-    msgBox.setWindowTitle("MITK XNAT upload");
-    msgBox.setText(msg);
-    msgBox.setIcon(QMessageBox::Question);
-    msgBox.setStandardButtons(QMessageBox::Ok | QMessageBox::Cancel);
-    int result = msgBox.exec();
-    if (result == QMessageBox::Ok)
+    if(!m_SilentMode)
+    {
+      QMessageBox msgBox;
+      QString msg ("Do you want to download "+selectedXnatObject->name()+"?");
+      msgBox.setWindowTitle("MITK XNAT download");
+      msgBox.setText(msg);
+      msgBox.setIcon(QMessageBox::Question);
+      msgBox.setStandardButtons(QMessageBox::Ok | QMessageBox::Cancel);
+      int result = msgBox.exec();
+      if (result == QMessageBox::Ok)
+      {
+        InternalFileDownload(index, true);
+      }
+    }
+    else
+    {
       InternalFileDownload(index, true);
+    }
   }
 }
 
 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();
 
     connect(session, SIGNAL(progress(QUuid,double)), this, SLOT(OnProgress(QUuid,double)));
     connect(session, SIGNAL(timedOut()), this, SLOT(sessionTimedOutMsg()));
     connect(session, SIGNAL(aboutToTimeOut()), this, SLOT(sessionTimesOutSoonMsg()));
   }
 }
 
 void QmitkXnatTreeBrowserView::CleanTreeModel(ctkXnatSession* session)
 {
   if (session != 0)
   {
     m_TreeModel->removeDataModel(session->dataModel());
     m_Controls.treeView->reset();
   }
 }
 
 void QmitkXnatTreeBrowserView::OnProgress(QUuid /*queryID*/, double progress)
 {
   if (progress > 0)
   {
     unsigned int currentProgress = progress*100;
     if (m_Controls.groupBox->isHidden())
     {
       m_Controls.groupBox->show();
       m_Controls.progressBar->setValue(0);
     }
     m_Controls.progressBar->setValue(currentProgress);
   }
 }
 
 void QmitkXnatTreeBrowserView::OnPreferencesChanged(const berry::IBerryPreferences* prefs)
 {
   QString downloadPath = prefs->Get("Download Path", "");
   QDir downloadDir (downloadPath);
   if (downloadPath.length() != 0 && downloadDir.exists())
     m_DownloadPath = downloadPath;
+
+  m_SilentMode = prefs->GetBool("Silent Mode", false);
 }
 
 void QmitkXnatTreeBrowserView::InternalFileDownload(const QModelIndex& index, bool loadData)
 {
   if (!index.isValid())
     return;
 
   ctkXnatObject* xnatObject = m_TreeModel->xnatObject(index);
   if (xnatObject != nullptr)
   {
     m_Controls.progressBar->setMinimum(0);
     m_Controls.progressBar->setMaximum(100);
     // The path to the downloaded file
     QString filePath;
     QDir downloadPath (m_DownloadPath);
     QString serverURL = berry::Platform::GetPreferencesService()->GetSystemPreferences()->Node(VIEW_ID)->Get("Server Address", "");
     bool isDICOM (false);
 
     // If a scan was selected, downloading the contained DICOM folder as ZIP
     ctkXnatScan* scan = dynamic_cast<ctkXnatScan*>(xnatObject);
 
     if (scan != nullptr)
     {
       isDICOM = true;
 
       if (!scan->isFetched())
         scan->fetch();
 
       QList<ctkXnatObject*> children = scan->children();
 
       foreach (ctkXnatObject* obj, children)
       {
         if (obj->name() == "DICOM")
         {
           QString folderName = obj->resourceUri();
           folderName.replace("/","_");
           downloadPath = m_DownloadPath + folderName;
           this->InternalDICOMDownload(obj, downloadPath);
           serverURL = obj->resourceUri();
         }
       }
     }
     else
     {
       ctkXnatFile* file = dynamic_cast<ctkXnatFile*>(xnatObject);
 
       if (file == nullptr)
       {
         MITK_ERROR << "Selected XNAT object not downloadable!";
         return;
       }
 
       QString uriId = file->parent()->resourceUri();
       uriId.replace("/data/archive/projects/", "");
 
       QString folderName = m_DownloadPath + uriId + "/";
       downloadPath = folderName;
 
       QDir dir(downloadPath);
       if (!dir.exists())
       {
         dir.mkpath(".");
       }
 
       filePath = folderName + file->name();
 
       // Checking if the file exists already
       if (downloadPath.exists(file->name()))
       {
         MITK_INFO << "File '" << file->name().toStdString() << "' already exists!";
         serverURL = file->parent()->resourceUri();
       }
       else
       {
         if (file->property("collection") == QString("DICOM"))
         {
           isDICOM = true;
           ctkXnatObject* parent = file->parent();
           QString folderName = parent->resourceUri();
           folderName.replace("/","_");
           downloadPath = m_DownloadPath + folderName;
           this->InternalDICOMDownload(parent, downloadPath);
           serverURL = parent->resourceUri();
         }
         else
         {
           this->SetStatusInformation("Downloading file " + file->name());
 
           file->download(filePath);
           serverURL = file->parent()->resourceUri();
 
           // Checking if the file exists now
           if (downloadPath.exists(file->name()))
           {
             MITK_INFO << "Download of " << file->name().toStdString() << " completed!";
-            QMessageBox msgBox;
-            msgBox.setText("Download of " + file->name() + " completed!");
-            msgBox.setIcon(QMessageBox::Information);
-            msgBox.exec();
+            if(!m_SilentMode)
+            {
+              QMessageBox msgBox;
+              msgBox.setText("Download of " + file->name() + " completed!");
+              msgBox.setIcon(QMessageBox::Information);
+              msgBox.exec();
+            }
             m_Controls.groupBox->hide();
           }
           else
           {
             MITK_INFO << "Download of " << file->name().toStdString() << " failed!";
             QMessageBox msgBox;
             msgBox.setText("Download of " + file->name() + " failed!");
             msgBox.setIcon(QMessageBox::Critical);
             msgBox.exec();
             m_Controls.groupBox->hide();
             return;
           }
         }
       }
     }
     if (loadData)
     {
       QFileInfoList fileList;
       if (isDICOM)
       {
         fileList = downloadPath.entryInfoList(QDir::Files);
       }
       else
       {
         QFileInfo fileInfo(filePath);
         fileList << fileInfo;
       }
 
       mitk::StringProperty::Pointer xnatURL = mitk::StringProperty::New(serverURL.toStdString());
       this->InternalOpenFiles(fileList, xnatURL);
     }
   }
 }
 
 void QmitkXnatTreeBrowserView::InternalDICOMDownload(ctkXnatObject *obj, QDir &DICOMDirPath)
 {
 
   QString filePath = m_DownloadPath + obj->property("label") + ".zip";
 
   this->SetStatusInformation("Downloading DICOM series " + obj->parent()->name());
   // In case of DICOM zip download we do not know the total file size
   // Because of that the dowload progres cannot be calculated
   // Because of that we use the busy indicator of the progress bar by setting min and max to 0
   m_Controls.progressBar->setMinimum(0);
   m_Controls.progressBar->setMaximum(0);
   m_Controls.progressBar->show();
   obj->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(DICOMDirPath.path().toStdString()), true);
   dec.decompressAllFiles();
 
   in.close();
   QFile::remove(filePath);
 
   // Checking if the file exists now
   if (DICOMDirPath.exists())
   {
     MITK_INFO << "Download of DICOM series " << obj->parent()->name().toStdString() << " completed!";
     QMessageBox msgBox;
     msgBox.setText("Download of DICOM series " + obj->parent()->name() + " completed!");
     msgBox.setIcon(QMessageBox::Information);
     msgBox.exec();
     m_Controls.groupBox->hide();
   }
   else
   {
     MITK_INFO << "Download of DICOM series " << obj->parent()->name().toStdString() << " failed!";
     QMessageBox msgBox;
     msgBox.setText("Download of DICOM series " + obj->parent()->name() + " failed!");
     msgBox.setIcon(QMessageBox::Critical);
     msgBox.exec();
     m_Controls.groupBox->hide();
   }
 }
 
 void QmitkXnatTreeBrowserView::InternalOpenFiles(const QFileInfoList & fileList, mitk::StringProperty::Pointer xnatURL)
 {
 
   if (fileList.isEmpty())
   {
     MITK_WARN << "No files available for laoding!";
     return;
   }
 
   mitk::IDataStorageService* dsService = m_DataStorageServiceTracker.getService();
   mitk::DataStorage::Pointer dataStorage = dsService->GetDataStorage()->GetDataStorage();
   QStringList list;
   list << fileList.at(0).absoluteFilePath();
   try
   {
     mitk::DataStorage::SetOfObjects::Pointer nodes = QmitkIOUtil::Load(list, *dataStorage);
     if (nodes->size() == 1)
     {
       mitk::DataNode* node = nodes->at(0);
       node->SetProperty("xnat.url", xnatURL);
     }
   }
   catch (const mitk::Exception& e)
   {
     MITK_INFO << e;
     return;
   }
   mitk::RenderingManager::GetInstance()->InitializeViewsByBoundingObjects(
         dsService->GetDataStorage()->GetDataStorage());
 }
 
 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::OnContextMenuCreateResourceFolder()
 {
   const QModelIndex index = m_Controls.treeView->selectionModel()->currentIndex();
   ctkXnatObject* parentObject = m_TreeModel->xnatObject(index);
 
   if (parentObject != nullptr)
   {
     this->InternalAddResourceFolder(parentObject);
   }
 }
 
 ctkXnatResource* QmitkXnatTreeBrowserView::InternalAddResourceFolder(ctkXnatObject *parent)
 {
   bool ok;
   QString folderName = QInputDialog::getText(m_Controls.treeView, tr("Create XNAT resource folder"),
-                                       tr("Folder name:"), QLineEdit::Normal, tr("data"), &ok);
+                                             tr("Folder name:"), QLineEdit::Normal, tr("data"), &ok);
   if (ok)
   {
     if (folderName.isEmpty())
       folderName = "NO LABEL";
 
     return parent->addResourceFolder(folderName);
   }
   else
   {
     return nullptr;
   }
 }
 
 void QmitkXnatTreeBrowserView::InternalFileUpload(ctkXnatFile* file)
 {
   m_Controls.groupBox->setTitle("Uploading file...");
   m_Controls.groupBox->show();
 
   try
   {
     file->save();
     MITK_INFO << "Upload of " << file->name().toStdString() << " completed!";
-    QMessageBox msgBox;
-    msgBox.setText("Upload of " + file->name() + " completed!");
-    msgBox.setIcon(QMessageBox::Information);
-    msgBox.show();
-    msgBox.exec();
+    if(!m_SilentMode)
+    {
+      QMessageBox msgBox;
+      msgBox.setText("Upload of " + file->name() + " completed!");
+      msgBox.setIcon(QMessageBox::Information);
+      msgBox.show();
+      msgBox.exec();
+    }
   }
   catch (ctkXnatException &e)
   {
     QMessageBox msgbox;
     msgbox.setText(e.what());
     msgbox.setIcon(QMessageBox::Critical);
     msgbox.exec();
     m_Controls.progressBar->setValue(0);
   }
   m_Controls.groupBox->hide();
 }
 
 void QmitkXnatTreeBrowserView::OnContextMenuUploadFile()
 {
   QString filename = QFileDialog::getOpenFileName(m_Controls.treeView, tr("Open File"), QDir::homePath());
   const QModelIndex index = m_Controls.treeView->selectionModel()->currentIndex();
   ctkXnatResource* resource = dynamic_cast<ctkXnatResource*>(m_TreeModel->xnatObject(index));
   if (resource != nullptr && filename.length() != 0)
   {
     ctkXnatFile* file = new ctkXnatFile(resource);
     file->setLocalFilePath(filename);
     QFileInfo fileInfo (filename);
     file->setName(fileInfo.fileName());
     this->InternalFileUpload(file);
     m_TreeModel->addChildNode(index, file);
   }
 }
 
 void QmitkXnatTreeBrowserView::OnContextMenuCopyXNATUrlToClipboard()
 {
   const QModelIndex index = m_Controls.treeView->selectionModel()->currentIndex();
   ctkXnatObject* currentXnatObject = m_TreeModel->xnatObject(index);
   if (currentXnatObject != nullptr)
   {
     QString serverURL = berry::Platform::GetPreferencesService()->GetSystemPreferences()->Node(VIEW_ID)->Get("Server Address", "");
     serverURL.append(currentXnatObject->resourceUri());
     QClipboard *clipboard = QApplication::clipboard();
     clipboard->setText(serverURL);
   }
 }
 
 void QmitkXnatTreeBrowserView::OnContextMenuRefreshItem()
 {
   const QModelIndex index = m_Controls.treeView->selectionModel()->currentIndex();
   if (index.isValid())
   {
     this->m_TreeModel->refresh(index);
   }
 }
 
 void QmitkXnatTreeBrowserView::OnUploadResource(const QList<mitk::DataNode*>& droppedNodes, ctkXnatObject* parentObject, const QModelIndex& parentIndex)
 {
   if (parentObject == nullptr)
     return;
 
   //1. If not dropped on a resource, create a new folder
+  //temporarily remove the annoying message box that upload was successfull..
   ctkXnatResource* resource = dynamic_cast<ctkXnatResource*>(parentObject);
   if (resource == nullptr)
   {
     resource = this->InternalAddResourceFolder(parentObject);
   }
 
   if (resource == nullptr)
   {
     MITK_WARN << "Could not upload file! No resource available!";
     QMessageBox msgbox;
     msgbox.setText("Could not upload file! No resource available!");
     msgbox.setIcon(QMessageBox::Critical);
     msgbox.exec();
     return;
   }
 
   //2. Save files locally
   //3. Upload file
   mitk::DataNode* node = NULL;
   foreach (node, droppedNodes)
   {
     mitk::BaseData* data = node->GetData();
     if (!data)
       return;
 
 
     QString fileName (QString::fromStdString(node->GetName()));
 
     ctkXnatFile* xnatFile = new ctkXnatFile(resource);
 
     if (dynamic_cast<mitk::Image*>(data))
     {
       fileName.append(".nrrd");
     }
     else if (dynamic_cast<mitk::Surface*>(data))
     {
       fileName.append(".vtk");
     }
     else if (dynamic_cast<mitk::PointSet*>(data))
     {
       fileName.append(".mps");
     }
     else
     {
       MITK_WARN << "Could not upload file! File-type not supported";
       QMessageBox msgbox;
       msgbox.setText("Could not upload file! File-type not supported");
       msgbox.setIcon(QMessageBox::Critical);
       msgbox.exec();
       return;
     }
 
     xnatFile->setName(fileName);
 
     QString xnatFolder = "XNAT_UPLOADS";
     QDir dir(mitk::org_mitk_gui_qt_xnatinterface_Activator::GetContext()->getDataFile("").absoluteFilePath());
     dir.mkdir(xnatFolder);
 
     fileName = dir.path().append("/" + fileName);
     mitk::IOUtil::Save (data, fileName.toStdString());
 
     // TODO Check if file exists
     // AbstractFileReader::SetDefaultDataNodeProperties
     // und in die andere SetDefaultDataNodeProperties
     // PropertyName klein: mtime.initial + Kommentar
     mitk::StringProperty::Pointer orignalFilePath = mitk::StringProperty::New();
     node->GetProperty(orignalFilePath, "path");
 
     xnatFile->setLocalFilePath(fileName);
 
     this->InternalFileUpload(xnatFile);
     QFile::remove(fileName);
 
     m_TreeModel->refresh(parentIndex);
 
     // The filename for uploading
-//    QFileInfo fileInfo;
+    //    QFileInfo fileInfo;
     //      if (surface)
     //      {
     //        // Save surface
     //        fileName.append(".stl");
     //        xnatFile->setName(fileName);
     //        dir.setPath(dir.path().append("/" + fileName));
 
-//    QString origFile = QString::fromStdString(orignalFilePath->GetValueAsString());
-//    origFile.append("/" + fileName);
+    //    QString origFile = QString::fromStdString(orignalFilePath->GetValueAsString());
+    //    origFile.append("/" + fileName);
     //        origFile.append(".stl");
 
     //        fileInfo.setFile(origFile);
     //        if (!fileInfo.exists())
     //          mitk::IOUtil::SaveSurface(surface, dir.path().toStdString());
     //      }
-//    this->uploadFileToXnat(xnatFile, dir.path());
+    //    this->uploadFileToXnat(xnatFile, dir.path());
   }
 }
 
 void QmitkXnatTreeBrowserView::OnContextMenuRequested(const QPoint & pos)
 {
+  if(m_TreeModel==nullptr)
+  {
+    return;
+  }
+
+  QModelIndex index = m_Controls.treeView->indexAt(pos);
+
+  if(index.isValid() == false)
+  {
+    return;
+  }
+
   m_ContextMenu->clear();
 
   QAction* actRefreshItem = new QAction("Refresh", m_ContextMenu);
   m_ContextMenu->addAction(actRefreshItem);
   connect(actRefreshItem, SIGNAL(triggered()), this, SLOT(OnContextMenuRefreshItem()));
-  m_ContextMenu->popup(QCursor::pos());
 
   QAction* actGetXNATURL = new QAction("Copy XNAT URL to clipboard", m_ContextMenu);
   m_ContextMenu->addAction(actGetXNATURL);
   connect(actGetXNATURL, SIGNAL(triggered()), this, SLOT(OnContextMenuCopyXNATUrlToClipboard()));
   m_ContextMenu->addSeparator();
 
-  QModelIndex index = m_Controls.treeView->indexAt(pos);
-
   ctkXnatObject* xnatObject = m_TreeModel->xnatObject(index);
 
   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;
 
   bool canHaveResourceFolder = false;
   canHaveResourceFolder |= dynamic_cast<ctkXnatProject*>(xnatObject) != NULL;
   canHaveResourceFolder |=  dynamic_cast<ctkXnatSubject*>(xnatObject) != NULL;
   canHaveResourceFolder |=  dynamic_cast<ctkXnatExperiment*>(xnatObject) != NULL;
 
   bool uploadFilePossible = false;
   uploadFilePossible |= dynamic_cast<ctkXnatResource*>(xnatObject) != NULL;
   uploadFilePossible |=  dynamic_cast<ctkXnatScan*>(xnatObject) != NULL;
   uploadFilePossible |=  dynamic_cast<ctkXnatAssessor*>(xnatObject) != NULL;
 
   if (downloadable)
   {
     QAction* actDownload = new QAction("Download", m_ContextMenu);
     connect(actDownload, SIGNAL(triggered()), this, SLOT(OnContextMenuDownloadFile()));
     m_ContextMenu->addAction(actDownload);
     ctkXnatFile* file = dynamic_cast<ctkXnatFile*>(xnatObject);
     if (file)
     {
       QAction* actView = new QAction("Download and Open", m_ContextMenu);
       connect(actView, SIGNAL(triggered()), this, SLOT(OnContextMenuDownloadAndOpenFile()));
       m_ContextMenu->addAction(actView);
     }
   }
 
   if (canHaveResourceFolder)
   {
     QAction* actCreateResource = new QAction("Add resource folder", m_ContextMenu);
     connect(actCreateResource, SIGNAL(triggered()), this, SLOT(OnContextMenuCreateResourceFolder()));
     m_ContextMenu->addAction(actCreateResource);
   }
 
   if (uploadFilePossible)
   {
     QAction* actUploadFile = new QAction("Upload File", m_ContextMenu);
     connect(actUploadFile, SIGNAL(triggered()), this, SLOT(OnContextMenuUploadFile()));
     m_ContextMenu->addAction(actUploadFile);
   }
 
   ctkXnatProject* project = dynamic_cast<ctkXnatProject*>(xnatObject);
   if (project != nullptr)
   {
     QAction* actCreateSubject = new QAction("Create new subject", m_ContextMenu);
     m_ContextMenu->addAction(actCreateSubject);
     connect(actCreateSubject, SIGNAL(triggered()), this, SLOT(OnContextMenuCreateNewSubject()));
-    m_ContextMenu->popup(QCursor::pos());
   }
   ctkXnatSubject* subject = dynamic_cast<ctkXnatSubject*>(xnatObject);
   if (subject != nullptr)
   {
     QAction* actCreateExperiment = new QAction("Create new experiment", m_ContextMenu);
     m_ContextMenu->addAction(actCreateExperiment);
     connect(actCreateExperiment, SIGNAL(triggered()), this, SLOT(OnContextMenuCreateNewExperiment()));
-    m_ContextMenu->popup(QCursor::pos());
   }
 
+
   m_ContextMenu->popup(QCursor::pos());
+
+}
+
+void QmitkXnatTreeBrowserView::CleanUp()
+{
+  m_Controls.wgtExperimentInfo->hide();
+  m_Controls.wgtSubjectInfo->hide();
+  m_Controls.wgtProjectInfo->hide();
+  m_Controls.btnCreateXnatFolder->setEnabled(false);
+  m_Controls.btnXnatDownload->setEnabled(false);
+  m_Controls.btnXnatUpload->setEnabled(false);
 }
 
 void QmitkXnatTreeBrowserView::itemSelected(const QModelIndex& index)
 {
 
   QVariant variant = m_TreeModel->data(index, Qt::UserRole);
   if (variant.isValid())
   {
     ctkXnatSession *session = mitk::org_mitk_gui_qt_xnatinterface_Activator::GetXnatModuleContext()->GetService(
-      mitk::org_mitk_gui_qt_xnatinterface_Activator::GetXnatModuleContext()->GetServiceReference<ctkXnatSession>());
+          mitk::org_mitk_gui_qt_xnatinterface_Activator::GetXnatModuleContext()->GetServiceReference<ctkXnatSession>());
 
     ctkXnatObject* object = variant.value<ctkXnatObject*>();
     ctkXnatProject* project = dynamic_cast<ctkXnatProject*>(object);
     ctkXnatSubject* subject = dynamic_cast<ctkXnatSubject*>(object);
     ctkXnatExperiment* experiment = dynamic_cast<ctkXnatExperiment*>(object);
 
     if (project != nullptr)
     {
       m_Controls.wgtExperimentInfo->hide();
       m_Controls.wgtSubjectInfo->hide();
 
       m_Controls.wgtProjectInfo->SetProject(project);
       m_Controls.wgtProjectInfo->show();
     }
     else if (subject != nullptr)
     {
       QMap<QString, QString> paramMap;
       paramMap.insert("columns", "dob,gender,handedness,weight,height");
       QUuid requestID = session->httpGet(QString("%1/subjects").arg(subject->parent()->resourceUri()), paramMap);
       QList<QVariantMap> results = session->httpSync(requestID);
 
       foreach(const QVariantMap& propertyMap, results)
       {
         QMapIterator<QString, QVariant> it(propertyMap);
         bool isConcretSubject = false;
 
         if (it.hasNext())
         {
           it.next();
 
           QVariant var = it.value();
 
           // After CTK Change (subjectID = name) to (subjectID = ID)
           // CHANGE TO: if (var == subject->property("ID"))
           if (var == subject->property("URI").right(11))
           {
             isConcretSubject = true;
           }
           else
           {
             isConcretSubject = false;
           }
           it.toFront();
         }
 
         while (it.hasNext() && isConcretSubject)
         {
           it.next();
 
           QString  str = it.key().toLatin1().data();
           QVariant var = it.value();
 
           subject->setProperty(str, var);
         }
       }
       m_Controls.wgtExperimentInfo->hide();
       m_Controls.wgtProjectInfo->hide();
 
       m_Controls.wgtSubjectInfo->SetSubject(subject);
       m_Controls.wgtSubjectInfo->show();
     }
     else if (experiment != nullptr)
     {
       QMap<QString, QString> paramMap;
       paramMap.insert("columns", "date,time,scanner,modality");
       QUuid requestID = session->httpGet(QString("%1/experiments").arg(experiment->parent()->resourceUri()), paramMap);
       QList<QVariantMap> results = session->httpSync(requestID);
 
       foreach(const QVariantMap& propertyMap, results)
       {
         QMapIterator<QString, QVariant> it(propertyMap);
         bool isConcretExperiment = false;
 
         if (it.hasNext())
         {
           it.next();
 
           QVariant var = it.value();
 
           if (var == experiment->property("URI"))
           {
             isConcretExperiment = true;
           }
           else
           {
             isConcretExperiment = false;
           }
           it.toFront();
         }
 
         while (it.hasNext() && isConcretExperiment)
         {
           it.next();
 
           QString  str = it.key().toLatin1().data();
           QVariant var = it.value();
 
           experiment->setProperty(str, var);
         }
       }
 
       m_Controls.wgtSubjectInfo->hide();
       m_Controls.wgtProjectInfo->hide();
 
       m_Controls.wgtExperimentInfo->SetExperiment(experiment);
       m_Controls.wgtExperimentInfo->show();
     }
   }
 }
 
 void QmitkXnatTreeBrowserView::OnContextMenuCreateNewSubject()
 {
   QModelIndex index = m_Controls.treeView->currentIndex();
   QVariant variant = m_TreeModel->data(index, Qt::UserRole);
   if (variant.isValid())
   {
     QmitkXnatCreateObjectDialog* dialog = new QmitkXnatCreateObjectDialog(QmitkXnatCreateObjectDialog::SpecificType::SUBJECT);
     if (dialog->exec() == QDialog::Accepted)
     {
       ctkXnatProject* project = dynamic_cast<ctkXnatProject*>(variant.value<ctkXnatObject*>());
       ctkXnatSubject* subject = dynamic_cast<ctkXnatSubject*>(dialog->GetXnatObject());
       subject->setParent(project);
       subject->save();
 
       // Get xnat session from micro service
       ctkXnatSession* session = mitk::org_mitk_gui_qt_xnatinterface_Activator::GetXnatModuleContext()->GetService(
-        mitk::org_mitk_gui_qt_xnatinterface_Activator::GetXnatModuleContext()->GetServiceReference<ctkXnatSession>());
+            mitk::org_mitk_gui_qt_xnatinterface_Activator::GetXnatModuleContext()->GetServiceReference<ctkXnatSession>());
 
       // Update View
       m_TreeModel->removeDataModel(session->dataModel());
+
       UpdateSession(session);
+
     }
   }
 }
 
 void QmitkXnatTreeBrowserView::OnContextMenuCreateNewExperiment()
 {
   QModelIndex index = m_Controls.treeView->currentIndex();
   QVariant variant = m_TreeModel->data(index, Qt::UserRole);
   if (variant.isValid())
   {
     QmitkXnatCreateObjectDialog* dialog = new QmitkXnatCreateObjectDialog(QmitkXnatCreateObjectDialog::SpecificType::EXPERIMENT);
     if (dialog->exec() == QDialog::Accepted)
     {
       ctkXnatSubject* subject = dynamic_cast<ctkXnatSubject*>(variant.value<ctkXnatObject*>());
       ctkXnatExperiment* experiment = dynamic_cast<ctkXnatExperiment*>(dialog->GetXnatObject());
       experiment->setParent(subject);
       experiment->setProperty("xsiType", experiment->imageModality());
       experiment->save();
 
       // Get xnat session from micro service
       ctkXnatSession* session = mitk::org_mitk_gui_qt_xnatinterface_Activator::GetXnatModuleContext()->GetService(
-        mitk::org_mitk_gui_qt_xnatinterface_Activator::GetXnatModuleContext()->GetServiceReference<ctkXnatSession>());
+            mitk::org_mitk_gui_qt_xnatinterface_Activator::GetXnatModuleContext()->GetServiceReference<ctkXnatSession>());
 
       // Update View
       m_TreeModel->removeDataModel(session->dataModel());
       UpdateSession(session);
     }
   }
 }
 
 void QmitkXnatTreeBrowserView::SetStatusInformation(const QString& text)
 {
   m_Controls.groupBox->setTitle(text);
   m_Controls.progressBar->setValue(0);
   m_Controls.groupBox->show();
 }
 
 void QmitkXnatTreeBrowserView::sessionTimedOutMsg()
 {
   ctkXnatSession* session = qobject_cast<ctkXnatSession*>(QObject::sender());
 
   if (session == nullptr)
     return;
 
   ctkXnatDataModel* dataModel = session->dataModel();
   m_TreeModel->removeDataModel(dataModel);
   m_Controls.treeView->reset();
   session->close();
-  m_Controls.labelError->show();
   QMessageBox::warning(m_Controls.treeView, "Session Timeout", "The session timed out.");
+
+  m_Controls.btnXnatConnect->setToolTip("Connect");
+  m_Controls.btnXnatConnect->setIcon(QIcon(":/xnat-plugin/xnat-connect.png"));
+
+  CleanUp();
 }
 
 void QmitkXnatTreeBrowserView::sessionTimesOutSoonMsg()
 {
   ctkXnatSession* session = qobject_cast<ctkXnatSession*>(QObject::sender());
 
   if (session == nullptr)
     return;
 
   QMessageBox msgBox;
   msgBox.setIcon(QMessageBox::Warning);
   msgBox.setWindowTitle("Session Timeout Soon");
   msgBox.setText("The session will time out in 1 minute.\nDo you want to renew the session?");
   msgBox.setStandardButtons(QMessageBox::Yes | QMessageBox::No);
   msgBox.setDefaultButton(QMessageBox::No);
   msgBox.show();
   QTimer* timer = new QTimer(this);
   timer->start(60000);
   this->connect(timer, SIGNAL(timeout()), &msgBox, SLOT(reject()));
   if (msgBox.exec() == QMessageBox::Yes){
     session->renew();
   }
   timer->stop();
 }
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 88eae213bb..4b7a6978f3 100644
--- a/Plugins/org.mitk.gui.qt.xnat/src/internal/QmitkXnatTreeBrowserView.h
+++ b/Plugins/org.mitk.gui.qt.xnat/src/internal/QmitkXnatTreeBrowserView.h
@@ -1,129 +1,135 @@
 /*===================================================================
 
 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 <QmitkAbstractView.h>
 
 #include "ui_QmitkXnatTreeBrowserViewControls.h"
 
 // ctkXnatCore
 #include "ctkXnatSession.h"
 
 // ctkXnatWidget
 #include "QmitkXnatTreeModel.h"
 
 // MitkXNAT Module
 #include "mitkXnatSessionTracker.h"
 
 #include <mitkIDataStorageService.h>
 #include <ctkServiceTracker.h>
 
 #include <berryIBerryPreferences.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 QString VIEW_ID;
 
   virtual void CreateQtPartControl(QWidget *parent) override;
 
 protected slots:
 
   /// \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 Cleans the tree model
   void CleanTreeModel(ctkXnatSession* session);
 
   void OnContextMenuRequested(const QPoint & pos);
   void OnContextMenuDownloadAndOpenFile();
   void OnContextMenuDownloadFile();
   void OnContextMenuCreateResourceFolder();
   void OnContextMenuUploadFile();
   void OnContextMenuCreateNewSubject();
   void OnContextMenuCreateNewExperiment();
   void OnContextMenuCopyXNATUrlToClipboard();
   void OnContextMenuRefreshItem();
 
   void OnUploadResource(const QList<mitk::DataNode*>& , ctkXnatObject *, const QModelIndex &parentIndex);
 
   void OnProgress(QUuid, double);
 
   void itemSelected(const QModelIndex& index);
 
   void OnUploadFromDataStorage();
 
   void sessionTimedOutMsg();
   void sessionTimesOutSoonMsg();
 
+  void ToggleConnection();
+
 protected:
 
   virtual void SetFocus() override;
 
   Ui::QmitkXnatTreeBrowserViewControls m_Controls;
 
 private slots:
   void OnXnatNodeSelected(const QModelIndex &index);
   void OnDownloadSelectedXnatFile();
   void OnCreateResourceFolder();
 
 private:
 
   void OnPreferencesChanged(const berry::IBerryPreferences*) override;
 
   void InternalFileDownload(const QModelIndex& index, bool loadData);
   void InternalDICOMDownload(ctkXnatObject* obj, QDir &DICOMDirPath);
   void InternalFileUpload(ctkXnatFile *file);
   ctkXnatResource* InternalAddResourceFolder(ctkXnatObject* parent);
 
   void InternalOpenFiles(const QFileInfoList&, mitk::StringProperty::Pointer xnatURL);
 
   void SetStatusInformation(const QString&);
 
+  void CleanUp();
+
   ctkServiceTracker<mitk::IDataStorageService*> m_DataStorageServiceTracker;
   QmitkXnatTreeModel* m_TreeModel;
 
   mitk::XnatSessionTracker* m_Tracker;
   QString m_DownloadPath;
 
   QMenu* m_ContextMenu;
+
+  bool m_SilentMode;
 };
 
 #endif // QMITKXNATTREEBROWSERVIEW_H
diff --git a/Plugins/org.mitk.gui.qt.xnat/src/internal/QmitkXnatTreeBrowserViewControls.ui b/Plugins/org.mitk.gui.qt.xnat/src/internal/QmitkXnatTreeBrowserViewControls.ui
index d14a755b51..1a11790912 100644
--- a/Plugins/org.mitk.gui.qt.xnat/src/internal/QmitkXnatTreeBrowserViewControls.ui
+++ b/Plugins/org.mitk.gui.qt.xnat/src/internal/QmitkXnatTreeBrowserViewControls.ui
@@ -1,191 +1,201 @@
 <?xml version="1.0" encoding="UTF-8"?>
 <ui version="4.0">
  <class>QmitkXnatTreeBrowserViewControls</class>
  <widget class="QWidget" name="QmitkXnatTreeBrowserViewControls">
   <property name="geometry">
    <rect>
     <x>0</x>
     <y>0</y>
     <width>455</width>
     <height>332</height>
    </rect>
   </property>
   <property name="minimumSize">
    <size>
     <width>0</width>
     <height>0</height>
    </size>
   </property>
   <property name="windowTitle">
    <string>QmitkTemplate</string>
   </property>
   <layout class="QVBoxLayout" name="verticalLayout">
-   <item>
-    <widget class="QLabel" name="labelError">
-     <property name="text">
-      <string/>
-     </property>
-     <property name="alignment">
-      <set>Qt::AlignCenter</set>
-     </property>
-     <property name="margin">
-      <number>5</number>
-     </property>
-     <property name="indent">
-      <number>0</number>
-     </property>
-    </widget>
-   </item>
    <item>
     <layout class="QHBoxLayout" name="horizontalLayout">
      <item>
       <widget class="QPushButton" name="btnXnatUpload">
        <property name="enabled">
         <bool>false</bool>
        </property>
        <property name="toolTip">
         <string>Upload to XNAT</string>
        </property>
        <property name="styleSheet">
         <string notr="true"/>
        </property>
        <property name="text">
         <string/>
        </property>
        <property name="icon">
         <iconset resource="../../resources/xnat.qrc">
          <normaloff>:/xnat-plugin/xnat-upload.png</normaloff>:/xnat-plugin/xnat-upload.png</iconset>
        </property>
        <property name="iconSize">
         <size>
          <width>32</width>
          <height>32</height>
         </size>
        </property>
       </widget>
      </item>
      <item>
       <widget class="QPushButton" name="btnXnatDownload">
        <property name="enabled">
         <bool>false</bool>
        </property>
        <property name="toolTip">
         <string>Download File</string>
        </property>
        <property name="text">
         <string/>
        </property>
        <property name="icon">
         <iconset resource="../../resources/xnat.qrc">
          <normaloff>:/xnat-plugin/xnat-download.png</normaloff>:/xnat-plugin/xnat-download.png</iconset>
        </property>
        <property name="iconSize">
         <size>
          <width>32</width>
          <height>32</height>
         </size>
        </property>
       </widget>
      </item>
      <item>
       <widget class="QPushButton" name="btnCreateXnatFolder">
        <property name="enabled">
         <bool>false</bool>
        </property>
        <property name="toolTip">
         <string>Create Folder</string>
        </property>
        <property name="text">
         <string/>
        </property>
        <property name="icon">
         <iconset resource="../../resources/xnat.qrc">
          <normaloff>:/xnat-plugin/xnat-folder.png</normaloff>:/xnat-plugin/xnat-folder.png</iconset>
        </property>
        <property name="iconSize">
         <size>
          <width>32</width>
          <height>32</height>
         </size>
        </property>
       </widget>
      </item>
+     <item>
+      <widget class="QPushButton" name="btnXnatConnect">
+       <property name="enabled">
+        <bool>true</bool>
+       </property>
+       <property name="toolTip">
+        <string>Connect</string>
+       </property>
+       <property name="text">
+        <string/>
+       </property>
+       <property name="icon">
+        <iconset resource="../../resources/xnat.qrc">
+         <normaloff>:/xnat-plugin/xnat-connect.png</normaloff>:/xnat-plugin/xnat-connect.png</iconset>
+       </property>
+       <property name="iconSize">
+        <size>
+         <width>32</width>
+         <height>32</height>
+        </size>
+       </property>
+       <property name="checkable">
+        <bool>false</bool>
+       </property>
+      </widget>
+     </item>
      <item>
       <spacer name="horizontalSpacer">
        <property name="orientation">
         <enum>Qt::Horizontal</enum>
        </property>
        <property name="sizeHint" stdset="0">
         <size>
          <width>40</width>
          <height>20</height>
         </size>
        </property>
       </spacer>
      </item>
     </layout>
    </item>
+   <item>
+    <layout class="QVBoxLayout" name="verticalLayout_2">
+     <item>
+      <widget class="QTreeView" name="treeView"/>
+     </item>
+    </layout>
+   </item>
    <item>
     <widget class="QGroupBox" name="groupBox">
      <property name="title">
       <string>Dowloading file ...</string>
      </property>
      <layout class="QVBoxLayout" name="verticalLayout_3">
       <item>
        <widget class="QProgressBar" name="progressBar">
         <property name="value">
          <number>0</number>
         </property>
        </widget>
       </item>
      </layout>
     </widget>
    </item>
-   <item>
-    <layout class="QVBoxLayout" name="verticalLayout_2">
-     <item>
-      <widget class="QTreeView" name="treeView"/>
-     </item>
-    </layout>
-   </item>
    <item>
     <layout class="QVBoxLayout" name="infoVerticalLayout">
      <item>
       <widget class="QmitkXnatProjectWidget" name="wgtProjectInfo" native="true"/>
      </item>
      <item>
       <widget class="QmitkXnatExperimentWidget" name="wgtExperimentInfo" native="true"/>
      </item>
      <item>
       <widget class="QmitkXnatSubjectWidget" name="wgtSubjectInfo" native="true"/>
      </item>
     </layout>
    </item>
   </layout>
  </widget>
  <layoutdefault spacing="6" margin="11"/>
  <customwidgets>
   <customwidget>
    <class>QmitkXnatProjectWidget</class>
    <extends>QWidget</extends>
    <header>QmitkXnatProjectWidget.h</header>
    <container>1</container>
   </customwidget>
   <customwidget>
    <class>QmitkXnatSubjectWidget</class>
    <extends>QWidget</extends>
    <header>QmitkXnatSubjectWidget.h</header>
    <container>1</container>
   </customwidget>
   <customwidget>
    <class>QmitkXnatExperimentWidget</class>
    <extends>QWidget</extends>
    <header>QmitkXnatExperimentWidget.h</header>
    <container>1</container>
   </customwidget>
  </customwidgets>
  <resources>
   <include location="../../resources/xnat.qrc"/>
  </resources>
  <connections/>
 </ui>