diff --git a/Modules/DiffusionImaging/DiffusionCore/autoload/IO/mitkDiffusionImageNiftiWriterService.cpp b/Modules/DiffusionImaging/DiffusionCore/autoload/IO/mitkDiffusionImageNiftiWriterService.cpp
index a5c083c356..fdfa5244ac 100644
--- a/Modules/DiffusionImaging/DiffusionCore/autoload/IO/mitkDiffusionImageNiftiWriterService.cpp
+++ b/Modules/DiffusionImaging/DiffusionCore/autoload/IO/mitkDiffusionImageNiftiWriterService.cpp
@@ -1,301 +1,301 @@
 /*===================================================================
 
 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 __mitkDiffusionImageNiftiWriterService__cpp
 #define __mitkDiffusionImageNiftiWriterService__cpp
 
 #include "mitkDiffusionImageNiftiWriterService.h"
 #include "itkMetaDataDictionary.h"
 #include "itkMetaDataObject.h"
 #include "itkNiftiImageIO.h"
 #include "itkImageFileWriter.h"
 #include "itksys/SystemTools.hxx"
 #include "mitkDiffusionCoreIOMimeTypes.h"
 #include "mitkImageCast.h"
 #include <mitkLocaleSwitch.h>
 
 #include <iostream>
 #include <fstream>
 
 
 mitk::DiffusionImageNiftiWriterService::DiffusionImageNiftiWriterService()
   : AbstractFileWriter(mitk::Image::GetStaticNameOfClass(), CustomMimeType( mitk::DiffusionCoreIOMimeTypes::DWI_NIFTI_MIMETYPE() ), mitk::DiffusionCoreIOMimeTypes::DWI_NIFTI_MIMETYPE_DESCRIPTION())
 {
   RegisterService();
 }
 
 mitk::DiffusionImageNiftiWriterService::DiffusionImageNiftiWriterService(const mitk::DiffusionImageNiftiWriterService& other)
   : AbstractFileWriter(other)
 {
 }
 
 mitk::DiffusionImageNiftiWriterService::~DiffusionImageNiftiWriterService()
 {}
 
 void mitk::DiffusionImageNiftiWriterService::Write()
 {
   mitk::Image::ConstPointer input = dynamic_cast<const mitk::Image *>(this->GetInput());
 
   VectorImageType::Pointer itkImg;
   mitk::CastToItkImage(input,itkImg);
 
   if (input.IsNull())
   {
     MITK_ERROR <<"Sorry, input to DiffusionImageNiftiWriterService is nullptr!";
     return;
   }
   if ( this->GetOutputLocation().empty() )
   {
     MITK_ERROR << "Sorry, filename has not been set!";
     return ;
   }
   mitk::LocaleSwitch localeSwitch("C");
 
   char keybuffer[512];
   char valbuffer[512];
 
   //itk::MetaDataDictionary dic = input->GetImage()->GetMetaDataDictionary();
 
   vnl_matrix_fixed<double,3,3> measurementFrame = mitk::DiffusionPropertyHelper::GetMeasurementFrame(input);
   if (measurementFrame(0,0) || measurementFrame(0,1) || measurementFrame(0,2) ||
     measurementFrame(1,0) || measurementFrame(1,1) || measurementFrame(1,2) ||
     measurementFrame(2,0) || measurementFrame(2,1) || measurementFrame(2,2))
   {
     sprintf( valbuffer, " (%lf,%lf,%lf) (%lf,%lf,%lf) (%lf,%lf,%lf)", measurementFrame(0,0), measurementFrame(0,1), measurementFrame(0,2), measurementFrame(1,0), measurementFrame(1,1), measurementFrame(1,2), measurementFrame(2,0), measurementFrame(2,1), measurementFrame(2,2));
     itk::EncapsulateMetaData<std::string>(itkImg->GetMetaDataDictionary(),std::string("measurement frame"),std::string(valbuffer));
   }
 
   sprintf( valbuffer, "DWMRI");
   itk::EncapsulateMetaData<std::string>(itkImg->GetMetaDataDictionary(),std::string("modality"),std::string(valbuffer));
 
   if(mitk::DiffusionPropertyHelper::GetGradientContainer(input)->Size())
   {
     sprintf( valbuffer, "%1f", mitk::DiffusionPropertyHelper::GetReferenceBValue(input) );
     itk::EncapsulateMetaData<std::string>(itkImg->GetMetaDataDictionary(),std::string("DWMRI_b-value"),std::string(valbuffer));
   }
 
   for(unsigned int i=0; i<mitk::DiffusionPropertyHelper::GetGradientContainer(input)->Size(); i++)
   {
     sprintf( keybuffer, "DWMRI_gradient_%04d", i );
 
     /*if(itk::ExposeMetaData<std::string>(input->GetMetaDataDictionary(),
     std::string(keybuffer),tmp))
     continue;*/
 
     sprintf( valbuffer, "%1f %1f %1f", mitk::DiffusionPropertyHelper::GetGradientContainer(input)->ElementAt(i).get(0),
       mitk::DiffusionPropertyHelper::GetGradientContainer(input)->ElementAt(i).get(1), mitk::DiffusionPropertyHelper::GetGradientContainer(input)->ElementAt(i).get(2));
 
     itk::EncapsulateMetaData<std::string>(itkImg->GetMetaDataDictionary(),std::string(keybuffer),std::string(valbuffer));
   }
 
   typedef itk::VectorImage<short,3> ImageType;
 
   std::string ext = this->GetMimeType()->GetExtension(this->GetOutputLocation());
   ext = itksys::SystemTools::LowerCase(ext);
 
   // default extension is .nii.gz
   if( ext == "")
   {
     ext = ".nii.gz";
     this->SetOutputLocation(this->GetOutputLocation() + ext);
   }
   if (ext == ".nii" || ext == ".nii.gz")
   {
     MITK_INFO << "Writing Nifti-Image";
 
     typedef itk::Image<short,4> ImageType4D;
     ImageType4D::Pointer img4 = ImageType4D::New();
 
     ImageType::SpacingType spacing = itkImg->GetSpacing();
     ImageType4D::SpacingType spacing4;
     for(int i=0; i<3; i++)
       spacing4[i] = spacing[i];
     spacing4[3] = 1;
     img4->SetSpacing( spacing4 );   // Set the image spacing
 
     ImageType::PointType origin = itkImg->GetOrigin();
     ImageType4D::PointType origin4;
     for(int i=0; i<3; i++)
       origin4[i] = origin[i];
     origin4[3] = 0;
     img4->SetOrigin( origin4 );     // Set the image origin
 
     ImageType::DirectionType direction = itkImg->GetDirection();
     ImageType4D::DirectionType direction4;
     for(int i=0; i<3; i++)
       for(int j=0; j<3; j++)
         direction4[i][j] = direction[i][j];
     for(int i=0; i<4; i++)
       direction4[i][3] = 0;
     for(int i=0; i<4; i++)
       direction4[3][i] = 0;
     direction4[3][3] = 1;
     img4->SetDirection( direction4 );  // Set the image direction
 
     ImageType::RegionType region = itkImg->GetLargestPossibleRegion();
     ImageType4D::RegionType region4;
 
     ImageType::RegionType::SizeType size = region.GetSize();
     ImageType4D::RegionType::SizeType size4;
 
     for(int i=0; i<3; i++)
       size4[i] = size[i];
     size4[3] = itkImg->GetVectorLength();
 
     ImageType::RegionType::IndexType index = region.GetIndex();
     ImageType4D::RegionType::IndexType index4;
     for(int i=0; i<3; i++)
       index4[i] = index[i];
     index4[3] = 0;
 
     region4.SetSize(size4);
     region4.SetIndex(index4);
     img4->SetRegions( region4 );
 
     img4->Allocate();
 
     itk::ImageRegionIterator<ImageType>   it (itkImg, itkImg->GetLargestPossibleRegion() );
     typedef ImageType::PixelType VecPixType;
 
     for (it.GoToBegin(); !it.IsAtEnd(); ++it)
     {
       VecPixType vec = it.Get();
       ImageType::IndexType currentIndex = it.GetIndex();
       for(unsigned int ind=0; ind<vec.Size(); ind++)
       {
 
         for(int i=0; i<3; i++)
           index4[i] = currentIndex[i];
         index4[3] = ind;
         img4->SetPixel(index4, vec[ind]);
       }
     }
 
     itk::NiftiImageIO::Pointer io4 = itk::NiftiImageIO::New();
 
     typedef itk::ImageFileWriter<ImageType4D> WriterType4;
     WriterType4::Pointer nrrdWriter4 = WriterType4::New();
     nrrdWriter4->UseInputMetaDataDictionaryOn();
     nrrdWriter4->SetInput( img4 );
     nrrdWriter4->SetFileName(this->GetOutputLocation());
     nrrdWriter4->UseCompressionOn();
     nrrdWriter4->SetImageIO(io4);
     try
     {
       nrrdWriter4->Update();
     }
-    catch (itk::ExceptionObject e)
+    catch (const itk::ExceptionObject& e)
     {
       std::cout << e << std::endl;
       throw;
     }
 
     if(mitk::DiffusionPropertyHelper::GetOriginalGradientContainer(input)->Size())
     {
       MITK_INFO << "Saving original gradient directions";
       std::ofstream myfile;
 
       std::string base_path = itksys::SystemTools::GetFilenamePath(this->GetOutputLocation());
       std::string fname = this->GetMimeType()->GetFilenameWithoutExtension(this->GetOutputLocation());
       MITK_INFO << this->GetOutputLocation();
       if (!base_path.empty())
           fname = base_path + "/" + fname;
 
       fname += ".bvals";
       myfile.open (fname.c_str());
       for(unsigned int i=0; i<mitk::DiffusionPropertyHelper::GetOriginalGradientContainer(input)->Size(); i++)
       {
         double twonorm = mitk::DiffusionPropertyHelper::GetOriginalGradientContainer(input)->ElementAt(i).two_norm();
         myfile << mitk::DiffusionPropertyHelper::GetReferenceBValue(input)*twonorm*twonorm << " ";
       }
       myfile.close();
 
       std::ofstream myfile2;
       std::string fname2 = this->GetMimeType()->GetFilenameWithoutExtension(this->GetOutputLocation());
       if (!base_path.empty())
           fname2 = base_path + "/" + fname2;
       fname2 += ".bvecs";
       myfile2.open (fname2.c_str());
       for(int j=0; j<3; j++)
       {
         for(unsigned int i=0; i<mitk::DiffusionPropertyHelper::GetOriginalGradientContainer(input)->Size(); i++)
         {
           //need to modify the length
           GradientDirectionContainerType::Pointer grads = mitk::DiffusionPropertyHelper::GetOriginalGradientContainer(input);
           GradientDirectionType direction = grads->ElementAt(i);
           direction.normalize();
           myfile2 << direction.get(j) << " ";
           //myfile2 << input->GetDirections()->ElementAt(i).get(j) << " ";
         }
         myfile2 << std::endl;
       }
     }
     else if(mitk::DiffusionPropertyHelper::GetGradientContainer(input)->Size())
     {
       MITK_INFO << "Original gradient directions not found. Saving modified gradient directions";
       std::ofstream myfile;
       std::string fname = itksys::SystemTools::GetFilenamePath( this->GetOutputLocation() ) + "/"
         + this->GetMimeType()->GetFilenameWithoutExtension( this->GetOutputLocation() );
       fname += ".bvals";
       myfile.open (fname.c_str());
       for(unsigned int i=0; i<mitk::DiffusionPropertyHelper::GetGradientContainer(input)->Size(); i++)
       {
         double twonorm = mitk::DiffusionPropertyHelper::GetGradientContainer(input)->ElementAt(i).two_norm();
         myfile << mitk::DiffusionPropertyHelper::GetReferenceBValue(input)*twonorm*twonorm << " ";
       }
       myfile.close();
 
       std::ofstream myfile2;
       std::string fname2 = itksys::SystemTools::GetFilenamePath( this->GetOutputLocation() ) + "/"
         + this->GetMimeType()->GetFilenameWithoutExtension( this->GetOutputLocation() );
       fname2 += ".bvecs";
       myfile2.open (fname2.c_str());
       for(int j=0; j<3; j++)
       {
         for(unsigned int i=0; i<mitk::DiffusionPropertyHelper::GetGradientContainer(input)->Size(); i++)
         {
           //need to modify the length
           GradientDirectionContainerType::Pointer grads = mitk::DiffusionPropertyHelper::GetGradientContainer(input);
           GradientDirectionType direction = grads->ElementAt(i);
           direction.normalize();
           myfile2 << direction.get(j) << " ";
           //myfile2 << input->GetDirections()->ElementAt(i).get(j) << " ";
         }
         myfile2 << std::endl;
       }
     }
   }
 }
 
 mitk::DiffusionImageNiftiWriterService* mitk::DiffusionImageNiftiWriterService::Clone() const
 {
   return new DiffusionImageNiftiWriterService(*this);
 }
 
 mitk::IFileWriter::ConfidenceLevel mitk::DiffusionImageNiftiWriterService::GetConfidenceLevel() const
 {
   mitk::Image::ConstPointer input = dynamic_cast<const mitk::Image*>(this->GetInput());
   if (input.IsNull() || !mitk::DiffusionPropertyHelper::IsDiffusionWeightedImage( input ) )
   {
     return Unsupported;
   }
   else
   {
     return Supported;
   }
 }
 
 #endif //__mitkDiffusionImageNiftiWriterService__cpp
diff --git a/Modules/DiffusionImaging/DiffusionCore/autoload/IO/mitkDiffusionImageNrrdWriterService.cpp b/Modules/DiffusionImaging/DiffusionCore/autoload/IO/mitkDiffusionImageNrrdWriterService.cpp
index ce72e798f1..bd315d7063 100644
--- a/Modules/DiffusionImaging/DiffusionCore/autoload/IO/mitkDiffusionImageNrrdWriterService.cpp
+++ b/Modules/DiffusionImaging/DiffusionCore/autoload/IO/mitkDiffusionImageNrrdWriterService.cpp
@@ -1,173 +1,173 @@
 /*===================================================================
 
 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 __mitkDiffusionImageNrrdWriterService__cpp
 #define __mitkDiffusionImageNrrdWriterService__cpp
 
 #include "mitkDiffusionImageNrrdWriterService.h"
 #include "itkMetaDataDictionary.h"
 #include "itkMetaDataObject.h"
 #include "itkNrrdImageIO.h"
 #include "itkImageFileWriter.h"
 #include "itksys/SystemTools.hxx"
 #include "mitkDiffusionCoreIOMimeTypes.h"
 #include "mitkImageCast.h"
 #include <mitkLocaleSwitch.h>
 
 #include <iostream>
 #include <fstream>
 
 
 mitk::DiffusionImageNrrdWriterService::DiffusionImageNrrdWriterService()
   : AbstractFileWriter(mitk::Image::GetStaticNameOfClass(), CustomMimeType( mitk::DiffusionCoreIOMimeTypes::DWI_NRRD_MIMETYPE() ), mitk::DiffusionCoreIOMimeTypes::DWI_NRRD_MIMETYPE_DESCRIPTION())
 {
   RegisterService();
 }
 
 mitk::DiffusionImageNrrdWriterService::DiffusionImageNrrdWriterService(const mitk::DiffusionImageNrrdWriterService& other)
   : AbstractFileWriter(other)
 {
 }
 
 mitk::DiffusionImageNrrdWriterService::~DiffusionImageNrrdWriterService()
 {}
 
 void mitk::DiffusionImageNrrdWriterService::Write()
 {
   mitk::Image::ConstPointer input = dynamic_cast<const mitk::Image *>(this->GetInput());
 
   VectorImageType::Pointer itkImg;
   mitk::CastToItkImage(input,itkImg);
 
   if (input.IsNull())
   {
     MITK_ERROR <<"Sorry, input to DiffusionImageNrrdWriterService is nullptr!";
     return;
   }
   if ( this->GetOutputLocation().empty() )
   {
     MITK_ERROR << "Sorry, filename has not been set!";
     return ;
   }
   mitk::LocaleSwitch localeSwitch("C");
 
   char keybuffer[512];
   char valbuffer[512];
 
   //itk::MetaDataDictionary dic = input->GetImage()->GetMetaDataDictionary();
 
   vnl_matrix_fixed<double,3,3> measurementFrame = mitk::DiffusionPropertyHelper::GetMeasurementFrame(input);
   if (measurementFrame(0,0) || measurementFrame(0,1) || measurementFrame(0,2) ||
     measurementFrame(1,0) || measurementFrame(1,1) || measurementFrame(1,2) ||
     measurementFrame(2,0) || measurementFrame(2,1) || measurementFrame(2,2))
   {
     sprintf( valbuffer, " (%lf,%lf,%lf) (%lf,%lf,%lf) (%lf,%lf,%lf)", measurementFrame(0,0), measurementFrame(0,1), measurementFrame(0,2), measurementFrame(1,0), measurementFrame(1,1), measurementFrame(1,2), measurementFrame(2,0), measurementFrame(2,1), measurementFrame(2,2));
     itk::EncapsulateMetaData<std::string>(itkImg->GetMetaDataDictionary(),std::string("measurement frame"),std::string(valbuffer));
   }
 
   sprintf( valbuffer, "DWMRI");
   itk::EncapsulateMetaData<std::string>(itkImg->GetMetaDataDictionary(),std::string("modality"),std::string(valbuffer));
 
   if (mitk::DiffusionPropertyHelper::GetOriginalGradientContainer(input)->Size())
   {
       MITK_INFO << "Saving original gradient directions";
       sprintf( valbuffer, "%1f", mitk::DiffusionPropertyHelper::GetReferenceBValue(input) );
       itk::EncapsulateMetaData<std::string>(itkImg->GetMetaDataDictionary(),std::string("DWMRI_b-value"),std::string(valbuffer));
 
       for(unsigned int i=0; i<mitk::DiffusionPropertyHelper::GetGradientContainer(input)->Size(); i++)
       {
         sprintf( keybuffer, "DWMRI_gradient_%04d", i );
 
         sprintf( valbuffer, "%1f %1f %1f", mitk::DiffusionPropertyHelper::GetOriginalGradientContainer(input)->ElementAt(i).get(0),
           mitk::DiffusionPropertyHelper::GetOriginalGradientContainer(input)->ElementAt(i).get(1), mitk::DiffusionPropertyHelper::GetOriginalGradientContainer(input)->ElementAt(i).get(2));
 
         itk::EncapsulateMetaData<std::string>(itkImg->GetMetaDataDictionary(),std::string(keybuffer),std::string(valbuffer));
       }
   }
   else if(mitk::DiffusionPropertyHelper::GetGradientContainer(input)->Size())
   {
       MITK_INFO << "Original gradient directions not found. Saving modified gradient directions";
       sprintf( valbuffer, "%1f", mitk::DiffusionPropertyHelper::GetReferenceBValue(input) );
       itk::EncapsulateMetaData<std::string>(itkImg->GetMetaDataDictionary(),std::string("DWMRI_b-value"),std::string(valbuffer));
 
       for(unsigned int i=0; i<mitk::DiffusionPropertyHelper::GetGradientContainer(input)->Size(); i++)
       {
         sprintf( keybuffer, "DWMRI_gradient_%04d", i );
 
         sprintf( valbuffer, "%1f %1f %1f", mitk::DiffusionPropertyHelper::GetGradientContainer(input)->ElementAt(i).get(0),
           mitk::DiffusionPropertyHelper::GetGradientContainer(input)->ElementAt(i).get(1), mitk::DiffusionPropertyHelper::GetGradientContainer(input)->ElementAt(i).get(2));
 
         itk::EncapsulateMetaData<std::string>(itkImg->GetMetaDataDictionary(),std::string(keybuffer),std::string(valbuffer));
       }
   }
 
   typedef itk::VectorImage<short,3> ImageType;
 
   std::string ext = this->GetMimeType()->GetExtension(this->GetOutputLocation());
   ext = itksys::SystemTools::LowerCase(ext);
 
   // default extension is .nrrd
   if( ext == "")
   {
     ext = ".nrrd";
     this->SetOutputLocation(this->GetOutputLocation() + ext);
   }
 
   if (ext == ".hdwi" || ext == ".nrrd" || ext == ".dwi")
   {
     itk::NrrdImageIO::Pointer io = itk::NrrdImageIO::New();
     io->SetFileType( itk::ImageIOBase::Binary );
     io->UseCompressionOn();
 
     typedef itk::ImageFileWriter<ImageType> WriterType;
     WriterType::Pointer nrrdWriter = WriterType::New();
     nrrdWriter->UseInputMetaDataDictionaryOn();
     nrrdWriter->SetInput( itkImg );
     nrrdWriter->SetImageIO(io);
     nrrdWriter->SetFileName(this->GetOutputLocation());
     nrrdWriter->UseCompressionOn();
     nrrdWriter->SetImageIO(io);
     try
     {
       nrrdWriter->Update();
     }
-    catch (itk::ExceptionObject e)
+    catch (const itk::ExceptionObject& e)
     {
       std::cout << e << std::endl;
       throw;
     }
   }
 }
 
 mitk::DiffusionImageNrrdWriterService* mitk::DiffusionImageNrrdWriterService::Clone() const
 {
   return new DiffusionImageNrrdWriterService(*this);
 }
 
 mitk::IFileWriter::ConfidenceLevel mitk::DiffusionImageNrrdWriterService::GetConfidenceLevel() const
 {
   mitk::Image::ConstPointer input = dynamic_cast<const mitk::Image*>(this->GetInput());
   if (input.IsNull() || !mitk::DiffusionPropertyHelper::IsDiffusionWeightedImage( input ) )
   {
     return Unsupported;
   }
   else
   {
     return Supported;
   }
 }
 
 #endif //__mitkDiffusionImageNrrdWriterService__cpp
diff --git a/Modules/DiffusionImaging/DiffusionCore/autoload/IO/mitkNrrdOdfImageWriter.cpp b/Modules/DiffusionImaging/DiffusionCore/autoload/IO/mitkNrrdOdfImageWriter.cpp
index 68c3d46ed7..2d106240ba 100644
--- a/Modules/DiffusionImaging/DiffusionCore/autoload/IO/mitkNrrdOdfImageWriter.cpp
+++ b/Modules/DiffusionImaging/DiffusionCore/autoload/IO/mitkNrrdOdfImageWriter.cpp
@@ -1,129 +1,129 @@
 /*===================================================================
 
 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 "mitkNrrdOdfImageWriter.h"
 #include "itkMetaDataDictionary.h"
 #include "itkMetaDataObject.h"
 #include "itkNrrdImageIO.h"
 #include "itkImageFileWriter.h"
 #include "mitkImageCast.h"
 #include "mitkIOMimeTypes.h"
 #include "mitkDiffusionCoreIOMimeTypes.h"
 #include <mitkLocaleSwitch.h>
 
 
 mitk::NrrdOdfImageWriter::NrrdOdfImageWriter()
   : AbstractFileWriter(mitk::OdfImage::GetStaticNameOfClass(), CustomMimeType( mitk::DiffusionCoreIOMimeTypes::ODF_MIMETYPE() ), mitk::DiffusionCoreIOMimeTypes::ODF_MIMETYPE_DESCRIPTION())
 {
   RegisterService();
 }
 
 mitk::NrrdOdfImageWriter::NrrdOdfImageWriter(const mitk::NrrdOdfImageWriter& other)
   : AbstractFileWriter(other)
 {
 }
 
 mitk::NrrdOdfImageWriter::~NrrdOdfImageWriter()
 {}
 
 
 void mitk::NrrdOdfImageWriter::Write()
 {
   InputType::ConstPointer input = dynamic_cast<const InputType*>(this->GetInput());
     if (input.IsNull())
     {
         MITK_ERROR <<"Sorry, input to NrrdOdfImageWriter is nullptr!";
         return;
     }
     if ( this->GetOutputLocation().empty() )
     {
         MITK_ERROR << "Sorry, filename has not been set!";
         return ;
     }
 
     mitk::LocaleSwitch localeSwitch("C");
 
     itk::NrrdImageIO::Pointer io = itk::NrrdImageIO::New();
     io->SetFileType( itk::ImageIOBase::Binary );
     io->UseCompressionOn();
 
     typedef itk::VectorImage<float, 3> VecImgType;
 
     typedef itk::Image<itk::Vector<float,ODF_SAMPLING_SIZE>,3> ImageType;
     typedef itk::ImageFileWriter<VecImgType> WriterType;
     WriterType::Pointer nrrdWriter = WriterType::New();
 
     ImageType::Pointer outimage = ImageType::New();
     CastToItkImage(input, outimage);
 
     VecImgType::Pointer vecImg = VecImgType::New();
     vecImg->SetSpacing( outimage->GetSpacing() );   // Set the image spacing
     vecImg->SetOrigin( outimage->GetOrigin() );     // Set the image origin
     vecImg->SetDirection( outimage->GetDirection() );  // Set the image direction
     vecImg->SetLargestPossibleRegion( outimage->GetLargestPossibleRegion());
     vecImg->SetBufferedRegion( outimage->GetLargestPossibleRegion() );
     vecImg->SetVectorLength(ODF_SAMPLING_SIZE);
     vecImg->Allocate();
 
     itk::ImageRegionIterator<VecImgType> ot (vecImg, vecImg->GetLargestPossibleRegion() );
     ot.GoToBegin();
 
     itk::ImageRegionIterator<ImageType> it (outimage, outimage->GetLargestPossibleRegion() );
 
     typedef ImageType::PixelType VecPixType;
     typedef VecImgType::PixelType VarVecType;
 
     for (it.GoToBegin(); !it.IsAtEnd(); ++it)
     {
       VecPixType vec = it.Get();
       VarVecType varVec(vec.GetVnlVector().data_block(), ODF_SAMPLING_SIZE);
       ot.Set(varVec);
       ++ot;
     }
 
     nrrdWriter->SetInput( vecImg );
     nrrdWriter->SetImageIO(io);
     nrrdWriter->SetFileName(this->GetOutputLocation().c_str());
     nrrdWriter->UseCompressionOn();
 
 
     try
     {
       nrrdWriter->Update();
     }
-    catch (itk::ExceptionObject e)
+    catch (const itk::ExceptionObject& e)
     {
       std::cout << e << std::endl;
     }
 }
 
 mitk::NrrdOdfImageWriter* mitk::NrrdOdfImageWriter::Clone() const
 {
   return new NrrdOdfImageWriter(*this);
 }
 
 mitk::IFileWriter::ConfidenceLevel mitk::NrrdOdfImageWriter::GetConfidenceLevel() const
 {
   InputType::ConstPointer input = dynamic_cast<const InputType*>(this->GetInput());
   if (input.IsNull() )
   {
     return Unsupported;
   }
   else
   {
     return Supported;
   }
 }
diff --git a/Modules/DiffusionImaging/DiffusionCore/autoload/IO/mitkNrrdTensorImageWriter.cpp b/Modules/DiffusionImaging/DiffusionCore/autoload/IO/mitkNrrdTensorImageWriter.cpp
index 44dfa8e9d1..9b2ee7ea83 100644
--- a/Modules/DiffusionImaging/DiffusionCore/autoload/IO/mitkNrrdTensorImageWriter.cpp
+++ b/Modules/DiffusionImaging/DiffusionCore/autoload/IO/mitkNrrdTensorImageWriter.cpp
@@ -1,99 +1,99 @@
 /*===================================================================
 
 The Medical Imaging Interaction Toolkit (MITK)
 
 Copyright (c) German Cancer Research Center,
 Division of Medical and Biological Informatics.
 All rights reserved.
 
 This software is distributed WITHOUT ANY WARRANTY; without
 even the implied warranty of MERCHANTABILITY or FITNESS FOR
 A PARTICULAR PURPOSE.
 
 See LICENSE.txt or http://www.mitk.org for details.
 
 ===================================================================*/
 
 #include "mitkNrrdTensorImageWriter.h"
 #include "itkMetaDataDictionary.h"
 #include "itkMetaDataObject.h"
 #include "itkNrrdImageIO.h"
 #include "itkImageFileWriter.h"
 #include "itkDiffusionTensor3D.h"
 #include "mitkImageCast.h"
 #include "mitkDiffusionCoreIOMimeTypes.h"
 #include <mitkLocaleSwitch.h>
 
 
 mitk::NrrdTensorImageWriter::NrrdTensorImageWriter()
   : AbstractFileWriter(mitk::TensorImage::GetStaticNameOfClass(), CustomMimeType( mitk::DiffusionCoreIOMimeTypes::DTI_MIMETYPE() ), mitk::DiffusionCoreIOMimeTypes::DTI_MIMETYPE_DESCRIPTION() )
 {
   RegisterService();
 }
 
 mitk::NrrdTensorImageWriter::NrrdTensorImageWriter(const mitk::NrrdTensorImageWriter& other)
   : AbstractFileWriter(other)
 {
 }
 
 
 mitk::NrrdTensorImageWriter::~NrrdTensorImageWriter()
 {}
 
 
 void mitk::NrrdTensorImageWriter::Write()
 {
   InputType::ConstPointer input = dynamic_cast<const InputType*>(this->GetInput());
   if (input.IsNull() )
   {
     MITK_ERROR <<"Sorry, input to NrrdTensorImageWriter is nullptr!";
     return;
   }
   if ( this->GetOutputLocation().empty() )
   {
     MITK_ERROR << "Sorry, filename has not been set!" ;
     return ;
   }
 
   itk::NrrdImageIO::Pointer io = itk::NrrdImageIO::New();
   io->SetFileType( itk::ImageIOBase::Binary );
   io->UseCompressionOn();
 
   typedef itk::ImageFileWriter<TensorImage::ItkTensorImageType> WriterType;
   WriterType::Pointer nrrdWriter = WriterType::New();
 
   TensorImage::ItkTensorImageType::Pointer outimage = TensorImage::ItkTensorImageType::New();
   CastToItkImage(input, outimage);
 
   nrrdWriter->SetInput( outimage );
   nrrdWriter->SetImageIO(io);
   nrrdWriter->SetFileName(this->GetOutputLocation().c_str());
   nrrdWriter->UseCompressionOn();
 
   try
   {
     nrrdWriter->Update();
   }
-  catch (itk::ExceptionObject e)
+  catch (const itk::ExceptionObject& e)
   {
     std::cout << e << std::endl;
   }
 }
 
 mitk::NrrdTensorImageWriter* mitk::NrrdTensorImageWriter::Clone() const
 {
   return new NrrdTensorImageWriter(*this);
 }
 
 mitk::IFileWriter::ConfidenceLevel mitk::NrrdTensorImageWriter::GetConfidenceLevel() const
 {
   InputType::ConstPointer input = dynamic_cast<const InputType*>(this->GetInput());
   if (input.IsNull() )
   {
     return Unsupported;
   }
   else
   {
     return Supported;
   }
 }
diff --git a/Modules/DiffusionImaging/DiffusionCore/autoload/IO/mitkShImageWriter.cpp b/Modules/DiffusionImaging/DiffusionCore/autoload/IO/mitkShImageWriter.cpp
index 6552b4514a..d5bf94df6d 100644
--- a/Modules/DiffusionImaging/DiffusionCore/autoload/IO/mitkShImageWriter.cpp
+++ b/Modules/DiffusionImaging/DiffusionCore/autoload/IO/mitkShImageWriter.cpp
@@ -1,136 +1,136 @@
 /*===================================================================
 
 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 "mitkShImageWriter.h"
 #include "itkMetaDataDictionary.h"
 #include "itkMetaDataObject.h"
 #include "itkImageFileWriter.h"
 #include "mitkImageCast.h"
 #include "mitkIOMimeTypes.h"
 #include "mitkDiffusionCoreIOMimeTypes.h"
 #include <mitkLocaleSwitch.h>
 #include <itkShCoefficientImageExporter.h>
 #include <itksys/SystemTools.hxx>
 #include <itkNrrdImageIO.h>
 
 mitk::ShImageWriter::ShImageWriter()
   : AbstractFileWriter(mitk::ShImage::GetStaticNameOfClass(), CustomMimeType( mitk::DiffusionCoreIOMimeTypes::SH_MIMETYPE() ), mitk::DiffusionCoreIOMimeTypes::SH_MIMETYPE_DESCRIPTION())
 {
   RegisterService();
 }
 
 mitk::ShImageWriter::ShImageWriter(const mitk::ShImageWriter& other)
   : AbstractFileWriter(other)
 {
 }
 
 mitk::ShImageWriter::~ShImageWriter()
 {}
 
 template <int shOrder>
 void mitk::ShImageWriter::WriteShImage(InputType::ConstPointer input)
 {
   typename itk::ShCoefficientImageExporter< float, shOrder >::InputImageType::Pointer itk_image = itk::ShCoefficientImageExporter< float, shOrder >::InputImageType::New();
   CastToItkImage(input, itk_image);
 
   typedef itk::ShCoefficientImageExporter< float, shOrder > ExporterType;
   typename ExporterType::Pointer exporter = ExporterType::New();
   exporter->SetInputImage(itk_image);
   exporter->GenerateData();
 
   std::string ext = itksys::SystemTools::GetFilenameExtension(this->GetOutputLocation());
 
   typedef itk::ImageFileWriter<ShImage::ShOnDiskType> WriterType;
   WriterType::Pointer writer = WriterType::New();
   writer->SetInput( exporter->GetOutputImage() );
 
   if (ext==".shi")
   {
     itk::NrrdImageIO::Pointer io = itk::NrrdImageIO::New();
     io->SetFileType( itk::ImageIOBase::Binary );
     io->UseCompressionOn();
     writer->SetImageIO(io);
   }
 
   writer->SetFileName(this->GetOutputLocation().c_str());
   writer->SetUseCompression(true);
 
   try
   {
     writer->Update();
   }
-  catch (itk::ExceptionObject e)
+  catch (const itk::ExceptionObject& e)
   {
     std::cout << e << std::endl;
   }
 }
 
 void mitk::ShImageWriter::Write()
 {
   InputType::ConstPointer input = dynamic_cast<const InputType*>(this->GetInput());
   if (input.IsNull())
   {
     MITK_ERROR <<"Sorry, input to ShImageWriter is nullptr!";
     return;
   }
   if ( this->GetOutputLocation().empty() )
   {
     MITK_ERROR << "Sorry, filename has not been set!";
     return ;
   }
 
   switch (input->GetImageDescriptor()->GetChannelTypeById(0).GetNumberOfComponents())
   {
   case 6:
     WriteShImage<2>(input);
     break;
   case 15:
     WriteShImage<4>(input);
     break;
   case 28:
     WriteShImage<6>(input);
     break;
   case 45:
     WriteShImage<8>(input);
     break;
   case 66:
     WriteShImage<10>(input);
     break;
   case 91:
     WriteShImage<12>(input);
     break;
   default :
     mitkThrow() << "SH order larger 12 not supported";
   }
 }
 
 mitk::ShImageWriter* mitk::ShImageWriter::Clone() const
 {
   return new ShImageWriter(*this);
 }
 
 mitk::IFileWriter::ConfidenceLevel mitk::ShImageWriter::GetConfidenceLevel() const
 {
   InputType::ConstPointer input = dynamic_cast<const InputType*>(this->GetInput());
   if (input.IsNull() )
   {
     return Unsupported;
   }
   else
   {
     return Supported;
   }
 }
diff --git a/Modules/MatchPointRegistration/autoload/IO/mitkMAPRegistrationWrapperIO.cpp b/Modules/MatchPointRegistration/autoload/IO/mitkMAPRegistrationWrapperIO.cpp
index 1266eaf6b6..28833a1370 100644
--- a/Modules/MatchPointRegistration/autoload/IO/mitkMAPRegistrationWrapperIO.cpp
+++ b/Modules/MatchPointRegistration/autoload/IO/mitkMAPRegistrationWrapperIO.cpp
@@ -1,319 +1,319 @@
 /*===================================================================
 
 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 <iostream>
 #include <fstream>
 
 #include <clocale>
 
 #include "mapRegistration.h"
 #include "mapRegistrationFileWriter.h"
 #include "mapRegistrationFileReader.h"
 #include "mapLazyFileFieldKernelLoader.h"
 
 #include <mitkCustomMimeType.h>
 #include <mitkIOMimeTypes.h>
 
 #include "mitkMAPRegistrationWrapperIO.h"
 #include "mitkMAPRegistrationWrapper.h"
 
 namespace mitk
 {
 
   /** Helper structure to change (and reset) the
   * local settings in a function scope*/
   struct LocaleSwitch
   {
     LocaleSwitch(const std::string& newLocale)
       : m_OldLocale(std::setlocale(LC_ALL, nullptr))
       , m_NewLocale(newLocale)
     {
       if (m_OldLocale == nullptr)
       {
         m_OldLocale = "";
       }
       else if (m_NewLocale != m_OldLocale)
       {
         // set the locale
         if (std::setlocale(LC_ALL, m_NewLocale.c_str()) == nullptr)
         {
           MITK_INFO << "Could not set locale " << m_NewLocale;
           m_OldLocale = nullptr;
         }
       }
     }
 
     ~LocaleSwitch()
     {
       if (m_OldLocale != nullptr && std::setlocale(LC_ALL, m_OldLocale) == nullptr)
       {
         MITK_INFO << "Could not reset locale " << m_OldLocale;
       }
     }
 
   private:
     const char* m_OldLocale;
     const std::string m_NewLocale;
   };
 
   /** Helper class that allows to use an functor in multiple combinations of
   * moving and target dimensions on a passed MAPRegistrationWrapper instance.\n
   * DimHelperSub is used DimHelper to iterate in a row of the dimension
   * combination matrix.
   */
   template< unsigned int i, unsigned int j, template < unsigned int,  unsigned int> class TFunctor>
   class DimHelperSub
   {
   public:
     static bool Execute(const mitk::MAPRegistrationWrapper* obj, const map::core::String& data)
     {
       if (TFunctor<i,j>::Execute(obj, data))
       {
         return true;
       }
       return DimHelperSub<i,j-1,TFunctor>::Execute(obj, data);
     }
   };
 
   /** Specialized template version of DimSubHelper that indicates the end
   * of the row in the dimension combination matrix, thus does nothing.
   */
   template< unsigned int i, template < unsigned int,  unsigned int> class TFunctor>
   class DimHelperSub<i,1,TFunctor >
   {
   public:
     static bool Execute(const mitk::MAPRegistrationWrapper*, const map::core::String&)
     {
       //just unwind. Go to the next "row" with DimHelper
       return false;
     }
   };
 
   /** Helper class that allows to use an functor in multiple combinations of
   * moving and target dimensions on a passed MAPRegistrationWrapper instance.\n
   * It is helpful if you want to ensure that all combinations are checked/touched
   * (e.g. 3D 3D, 3D 2D, 2D 3D, 2D 2D) without generating a large switch yard.
   * Think of n*m matrix (indicating the posible combinations). DimHelper walks from
   * one row to the next and uses DimHelperSub to iterate in a row.\n
   * For every element of the matrix the functor is executed on the passed object.
   */
   template< unsigned int i,  unsigned int j, template < unsigned int,  unsigned int> class TFunctor>
   class DimHelper{
   public:
     static bool Execute(const mitk::MAPRegistrationWrapper* obj, const map::core::String& data = "")
     {
       if (DimHelperSub<i,j,TFunctor>::Execute(obj, data))
       {
         return true;
       }
       return DimHelper<i-1,j,TFunctor>::Execute(obj, data);
     }
   };
 
   /** Specialized template version of DimHelper that indicates the end
   * of the dimension combination matrix, thus does nothing.
   */
   template< unsigned int j, template < unsigned int,  unsigned int> class TFunctor>
   class DimHelper<1,j, TFunctor >
   {
   public:
     static bool Execute(const mitk::MAPRegistrationWrapper*, const map::core::String&)
     {
       //just unwind. We are done.
       return false;
     }
   };
 
   /** Functor that checks of the dimension of the registration is supported and can
   * be written.
   */
   template<unsigned int i, unsigned int j>
   class CanWrite
   {
   public:
     static bool Execute(const mitk::MAPRegistrationWrapper* obj, const map::core::String& = "")
     {
       bool result = false;
 
       result = dynamic_cast<const map::core::Registration<i,j> *>(obj->GetRegistration()) != nullptr;
 
       return result;
     }
   };
 
   /** Functor that writes the registration to a file if it has the right dimensionality.
   */
   template<unsigned int i, unsigned int j>
   class WriteReg
   {
   public:
     static bool Execute(const mitk::MAPRegistrationWrapper* obj, const map::core::String& data)
     {
       const map::core::Registration<i,j>* pReg = dynamic_cast<const map::core::Registration<i,j>*>(obj->GetRegistration());
       if (pReg == nullptr)
       {
         return false;
       }
 
       typedef map::io::RegistrationFileWriter<i,j> WriterType;
       typename WriterType::Pointer writer = WriterType::New();
 
       writer->setExpandLazyKernels(false);
 
       try
       {
         writer->write(pReg,data);
       }
-      catch (itk::ExceptionObject e)
+      catch (const itk::ExceptionObject& e)
       {
         std::cout << e << std::endl;
         throw;
       }
 
       return true;
     }
   };
 
   MAPRegistrationWrapperIO::MAPRegistrationWrapperIO(const MAPRegistrationWrapperIO& other)
     : AbstractFileIO(other)
   {
   }
 
   MAPRegistrationWrapperIO::MAPRegistrationWrapperIO() : AbstractFileIO(mitk::MAPRegistrationWrapper::GetStaticNameOfClass())
   {
     std::string category = "MatchPoint Registration File";
     CustomMimeType customMimeType;
     customMimeType.SetCategory(category);
     customMimeType.AddExtension("mapr");
     this->AbstractFileIOWriter::SetMimeType(customMimeType);
     this->AbstractFileIOWriter::SetDescription(category);
 
     customMimeType.AddExtension("mapr.xml");
     customMimeType.AddExtension("MAPR");
     customMimeType.AddExtension("MAPR.XML");
     this->AbstractFileIOReader::SetMimeType(customMimeType);
     this->AbstractFileIOReader::SetDescription(category);
 
     this->RegisterService();
   }
 
 
   void MAPRegistrationWrapperIO::Write()
   {
     bool success = false;
     const BaseData* input = this->GetInput();
     if (input == nullptr)
     {
       mitkThrow() << "Cannot write data. Data pointer is nullptr.";
     }
 
     const mitk::MAPRegistrationWrapper* wrapper = dynamic_cast<const mitk::MAPRegistrationWrapper*>(input);
     if (wrapper == nullptr)
     {
       mitkThrow() << "Cannot write data. Data pointer is not a Registration wrapper.";
     }
 
     std::ostream* writeStream = this->GetOutputStream();
     std::string fileName = this->GetOutputLocation();
     if (writeStream)
     {
       fileName = this->GetLocalFileName();
     }
 
     // Switch the current locale to "C"
     LocaleSwitch localeSwitch("C");
 
     try
     {
       success = DimHelper<3,3,WriteReg>::Execute(wrapper, fileName);
     }
     catch (const std::exception& e)
     {
       mitkThrow() << e.what();
     }
 
     if (!success)
     {
       mitkThrow() << "Cannot write registration. Currently only registrations up to 4D are supported.";
     }
   }
 
   AbstractFileIO::ConfidenceLevel MAPRegistrationWrapperIO::GetWriterConfidenceLevel() const
   {
     const mitk::MAPRegistrationWrapper* regWrapper =  dynamic_cast<const mitk::MAPRegistrationWrapper*>(this->GetInput());
 
     if (regWrapper == nullptr)
     {
       return IFileWriter::Unsupported;
     }
 
     // Check if the registration dimension is supported
     if (! DimHelper<3,3,CanWrite>::Execute(regWrapper))
     {
       return IFileWriter::Unsupported;
     };
 
     return IFileWriter::Supported;
   }
 
   std::vector<BaseData::Pointer >  MAPRegistrationWrapperIO::Read()
   {
     std::vector<BaseData::Pointer > result;
 
     LocaleSwitch("C");
 
     std::string fileName = this->GetLocalFileName();
     if ( fileName.empty() )
     {
       mitkThrow() << "Cannot read file. Filename has not been set!";
     }
 
     /* Remove the following kernel loader provider because in MITK no lazy file loading should be used
     due to conflicts with session loading (end there usage of temporary directories)*/
     map::io::RegistrationFileReader::LoaderStackType::unregisterProvider(map::io::LazyFileFieldKernelLoader<2,2>::getStaticProviderName());
     map::io::RegistrationFileReader::LoaderStackType::unregisterProvider(map::io::LazyFileFieldKernelLoader<3,3>::getStaticProviderName());
 
     map::io::RegistrationFileReader::Pointer spReader = map::io::RegistrationFileReader::New();
     spReader->setPreferLazyLoading(true);
     map::core::RegistrationBase::Pointer spReg = spReader->read(fileName);
     mitk::MAPRegistrationWrapper::Pointer spRegWrapper = mitk::MAPRegistrationWrapper::New();
     spRegWrapper->SetRegistration(spReg);
 
     result.push_back(spRegWrapper.GetPointer());
     return result;
   }
 
   AbstractFileIO::ConfidenceLevel MAPRegistrationWrapperIO::GetReaderConfidenceLevel() const
   {
     AbstractFileIO::ConfidenceLevel result = IFileReader::Unsupported;
 
     std::string fileName = this->GetLocalFileName();
     std::ifstream in( fileName.c_str() );
     if ( in.good() )
     {
       result = IFileReader::Supported;
     }
 
     in.close();
     return result;
   }
 
   MAPRegistrationWrapperIO* MAPRegistrationWrapperIO::IOClone() const
   {
     return new MAPRegistrationWrapperIO(*this);
   }
 
 }
diff --git a/Plugins/org.mitk.gui.qt.viewnavigator/src/QmitkViewNavigatorWidget.cpp b/Plugins/org.mitk.gui.qt.viewnavigator/src/QmitkViewNavigatorWidget.cpp
index 4df8ae6609..8df6937384 100644
--- a/Plugins/org.mitk.gui.qt.viewnavigator/src/QmitkViewNavigatorWidget.cpp
+++ b/Plugins/org.mitk.gui.qt.viewnavigator/src/QmitkViewNavigatorWidget.cpp
@@ -1,701 +1,701 @@
 /*===================================================================
 
 The Medical Imaging Interaction Toolkit (MITK)
 
 Copyright (c) German Cancer Research Center,
 Division of Medical and Biological Informatics.
 All rights reserved.
 
 This software is distributed WITHOUT ANY WARRANTY; without
 even the implied warranty of MERCHANTABILITY or FITNESS FOR
 A PARTICULAR PURPOSE.
 
 See LICENSE.txt or http://www.mitk.org for details.
 
 ===================================================================*/
 
 //Qmitk headers
 #include "QmitkViewNavigatorWidget.h"
 
 // Blueberry
 #include <berryISelectionService.h>
 #include <berryIWorkbenchWindow.h>
 #include <berryIPerspectiveRegistry.h>
 #include <berryPlatformUI.h>
 #include <berryPlatform.h>
 #include <berryIWorkbenchPage.h>
 #include <berryIExtensionRegistry.h>
 #include <berryIHandlerService.h>
 #include <berryIWorkbenchCommandConstants.h>
 #include <berryUIElement.h>
 
 // MITK
 #include <mitkLogMacros.h>
 
 // Qt
 #include <QHash>
 #include <QMessageBox>
 #include <QTreeView>
 #include <QStandardItem>
 #include <QSortFilterProxyModel>
 
 class KeywordRegistry
 {
 public:
     KeywordRegistry()
     {
         berry::IExtensionRegistry* extensionPointService = berry::Platform::GetExtensionRegistry();
         auto keywordExts = extensionPointService->GetConfigurationElementsFor("org.blueberry.ui.keywords");
         for (auto keywordExtsIt = keywordExts.begin(); keywordExtsIt != keywordExts.end(); ++keywordExtsIt)
         {
             QString keywordId = (*keywordExtsIt)->GetAttribute("id");
             QString keywordLabels = (*keywordExtsIt)->GetAttribute("label");
             m_Keywords[keywordId].push_back(keywordLabels);
         }
     }
 
     QStringList GetKeywords(const QString& id)
     {
         return m_Keywords[id];
     }
 
     QStringList GetKeywords(const QStringList& ids)
     {
         QStringList result;
         for (int i = 0; i < ids.size(); ++i)
         {
             result.append(this->GetKeywords(ids[i]));
         }
         return result;
     }
 
 private:
     QHash<QString, QStringList> m_Keywords;
 };
 
 
 class ClassFilterProxyModel : public QSortFilterProxyModel
 {
 private :
     bool hasToBeDisplayed(const QModelIndex index) const;
     bool displayElement(const QModelIndex index) const;
 public:
     ClassFilterProxyModel(QObject *parent = nullptr);
     bool filterAcceptsRow(int sourceRow, const QModelIndex &sourceParent) const override;
 };
 ClassFilterProxyModel::ClassFilterProxyModel(QObject *parent):
     QSortFilterProxyModel(parent)
 {
 }
 
 bool ClassFilterProxyModel::filterAcceptsRow(int sourceRow,
                                              const QModelIndex &sourceParent) const
 {
     QModelIndex index = sourceModel()->index(sourceRow, 0, sourceParent);
 
     return hasToBeDisplayed(index);
 }
 
 bool ClassFilterProxyModel::displayElement(const QModelIndex index) const
 {
     bool result = false;
     QString type = sourceModel()->data(index, Qt::DisplayRole).toString();
     QStandardItem * item = dynamic_cast<QStandardItemModel*>(sourceModel())->itemFromIndex(index);
 
     if (type.contains(filterRegExp()))
     {
         return true;
     }
     {
         mitk::QtViewItem* viewItem = dynamic_cast<mitk::QtViewItem*>(item);
         if (viewItem)
         {
             for (int i = 0; i < viewItem->m_Tags.size(); ++i)
             {
                 if (viewItem->m_Tags[i].contains(filterRegExp()))
                 {
                     return true;
                 }
             }
             if (viewItem->m_Description.contains(filterRegExp()))
             {
                 return true;
             }
         }
     }
     {
         mitk::QtPerspectiveItem* viewItem = dynamic_cast<mitk::QtPerspectiveItem*>(item);
         if (viewItem)
         {
             for (int i = 0; i < viewItem->m_Tags.size(); ++i)
             {
                 if (viewItem->m_Tags[i].contains(filterRegExp()))
                 {
                     return true;
                 }
             }
             if (viewItem->m_Description.contains(filterRegExp()))
             {
                 return true;
             }
         }
     }
 
     return result;
 }
 
 bool ClassFilterProxyModel::hasToBeDisplayed(const QModelIndex index) const
 {
     bool result = false;
     if ( sourceModel()->rowCount(index) > 0 )
     {
         for( int ii = 0; ii < sourceModel()->rowCount(index); ii++)
         {
             QModelIndex childIndex = sourceModel()->index(ii,0,index);
             if ( ! childIndex.isValid() )
                 break;
             result = hasToBeDisplayed(childIndex);
             result |= displayElement(index);
             if (result)
             {
                 break;
             }
         }
     }
     else
     {
         result = displayElement(index);
     }
     return result;
 }
 
 class ViewNavigatorPerspectiveListener: public berry::IPerspectiveListener
 {
 public:
 
     ViewNavigatorPerspectiveListener(QmitkViewNavigatorWidget* p) :
         parentWidget(p)
     {
     }
 
     Events::Types GetPerspectiveEventTypes() const override
     {
         return Events::ACTIVATED | Events::SAVED_AS | Events::DEACTIVATED
                 // remove the following line when command framework is finished
                 | Events::CLOSED | Events::OPENED | Events::PART_CHANGED;
     }
 
     void PerspectiveActivated(const berry::IWorkbenchPage::Pointer& /*page*/,
                               const berry::IPerspectiveDescriptor::Pointer& perspective) override
     {
         parentWidget->m_ActivePerspective = perspective;
         parentWidget->UpdateTreeList();
     }
 
     void PerspectiveSavedAs(const berry::IWorkbenchPage::Pointer& /*page*/,
                             const berry::IPerspectiveDescriptor::Pointer& /*oldPerspective*/,
                             const berry::IPerspectiveDescriptor::Pointer& newPerspective) override
     {
       parentWidget->m_ActivePerspective = newPerspective;
       parentWidget->UpdateTreeList();
     }
 
     void PerspectiveDeactivated(const berry::IWorkbenchPage::Pointer& /*page*/,
                                 const berry::IPerspectiveDescriptor::Pointer& /*perspective*/) override
     {
       parentWidget->m_ActivePerspective = nullptr;
       parentWidget->UpdateTreeList();
     }
 
     void PerspectiveOpened(const berry::IWorkbenchPage::Pointer& /*page*/,
                            const berry::IPerspectiveDescriptor::Pointer& /*perspective*/) override
     {
         parentWidget->UpdateTreeList();
     }
 
     void PerspectiveClosed(const berry::IWorkbenchPage::Pointer& /*page*/,
                            const berry::IPerspectiveDescriptor::Pointer& /*perspective*/) override
     {
       parentWidget->m_ActivePerspective = nullptr;
       parentWidget->UpdateTreeList();
     }
 
     using IPerspectiveListener::PerspectiveChanged;
 
     void PerspectiveChanged(const berry::IWorkbenchPage::Pointer&,
                             const berry::IPerspectiveDescriptor::Pointer&,
                             const berry::IWorkbenchPartReference::Pointer& partRef, const std::string& changeId)
     {
         if (changeId=="viewHide" && partRef->GetId()=="org.mitk.views.viewnavigatorview")
             berry::PlatformUI::GetWorkbench()->GetActiveWorkbenchWindow()->RemovePerspectiveListener(parentWidget->m_PerspectiveListener.data());
         else
             parentWidget->UpdateTreeList(nullptr, partRef.GetPointer(), changeId);
     }
 
 private:
     QmitkViewNavigatorWidget* parentWidget;
 };
 
 bool compareViews(const berry::IViewDescriptor::Pointer& a, const berry::IViewDescriptor::Pointer& b)
 {
     if (a.IsNull() || b.IsNull())
         return false;
     return a->GetLabel().compare(b->GetLabel()) < 0;
 }
 
 bool comparePerspectives(const berry::IPerspectiveDescriptor::Pointer& a, const berry::IPerspectiveDescriptor::Pointer& b)
 {
     if (a.IsNull() || b.IsNull())
         return false;
     return a->GetLabel().compare(b->GetLabel()) < 0;
 }
 
 bool compareQStandardItems(const QStandardItem* a, const QStandardItem* b)
 {
     if (a==nullptr || b==nullptr)
         return false;
     return a->text().compare(b->text()) < 0;
 }
 
 QmitkViewNavigatorWidget::QmitkViewNavigatorWidget(berry::IWorkbenchWindow::Pointer window,
                                                    QWidget * parent, Qt::WindowFlags )
     : QWidget(parent)
     , m_Window(window)
 {
     m_Generated = false;
     this->CreateQtPartControl(this);
 }
 
 QmitkViewNavigatorWidget::~QmitkViewNavigatorWidget()
 {
   m_Window->RemovePerspectiveListener(m_PerspectiveListener.data());
 }
 
 void QmitkViewNavigatorWidget::setFocus()
 {
   m_Controls.lineEdit->setFocus();
 }
 
 void QmitkViewNavigatorWidget::CreateQtPartControl( QWidget *parent )
 {
     // create GUI widgets from the Qt Designer's .ui file
     m_PerspectiveListener.reset(new ViewNavigatorPerspectiveListener(this));
     m_Window->AddPerspectiveListener(m_PerspectiveListener.data());
 
     m_Parent = parent;
     m_Controls.setupUi( parent );
     connect( m_Controls.m_PluginTreeView, SIGNAL(customContextMenuRequested(QPoint)), SLOT(CustomMenuRequested(QPoint)));
     connect( m_Controls.m_PluginTreeView, SIGNAL(doubleClicked(const QModelIndex&)), SLOT(ItemClicked(const QModelIndex&)));
     connect( m_Controls.lineEdit, SIGNAL(textChanged(QString)), SLOT(FilterChanged()));
 
     m_ContextMenu = new QMenu(m_Controls.m_PluginTreeView);
     m_Controls.m_PluginTreeView->setContextMenuPolicy(Qt::CustomContextMenu);
 
     // Create a new TreeModel for the data
     m_TreeModel = new QStandardItemModel();
     m_FilterProxyModel = new ClassFilterProxyModel(this);
     m_FilterProxyModel->setSourceModel(m_TreeModel);
     //proxyModel->setFilterFixedString("Diff");
     m_Controls.m_PluginTreeView->setModel(m_FilterProxyModel);
 
     this->UpdateTreeList();
 }
 
 void QmitkViewNavigatorWidget::UpdateTreeList(QStandardItem* root, berry::IWorkbenchPartReference *partRef, const std::string &changeId)
 {
     berry::IWorkbenchPage::Pointer page = m_Window->GetActivePage();
     if (page.IsNull())
         return;
 
     if( !m_Generated )
     {
       m_Generated = FillTreeList();
     }
 
     if (root==nullptr)
         root = m_TreeModel->invisibleRootItem();
     for (int i=0; i<root->rowCount(); i++)
     {
         QStandardItem* item = root->child(i);
         QFont font;
         if (dynamic_cast<mitk::QtPerspectiveItem*>(item))
         {
             mitk::QtPerspectiveItem* pItem = dynamic_cast<mitk::QtPerspectiveItem*>(item);
             berry::IPerspectiveDescriptor::Pointer currentPersp = page->GetPerspective();
 
             if (currentPersp.IsNotNull() && currentPersp->GetId()==pItem->m_Perspective->GetId())
                 font.setBold(true);
             pItem->setFont(font);
         }
         mitk::QtViewItem* vItem = dynamic_cast<mitk::QtViewItem*>(item);
         if (vItem)
         {
             QList<berry::IViewPart::Pointer> viewParts(page->GetViews());
             for (int i=0; i<viewParts.size(); i++)
                 if(viewParts[i]->GetPartName()==vItem->m_View->GetLabel())
                 {
                     font.setBold(true);
                     break;
                 }
 
             if( partRef!=nullptr && partRef->GetId()==vItem->m_View->GetId() && changeId=="viewHide")
                 font.setBold(false);
 
             vItem->setFont(font);
         }
         UpdateTreeList(item, partRef, changeId);
     }
 }
 
 bool QmitkViewNavigatorWidget::FillTreeList()
 {
     // active workbench window available?
     if (m_Window.IsNull())
         return false;
 
     // active page available?
     berry::IWorkbenchPage::Pointer page = m_Window->GetActivePage();
     if (page.IsNull())
         return false;
 
     // everything is fine and we can remove the window listener
     if (m_WindowListener != nullptr)
         berry::PlatformUI::GetWorkbench()->RemoveWindowListener(m_WindowListener.data());
 
     // initialize tree model
     m_TreeModel->clear();
     QStandardItem *treeRootItem = m_TreeModel->invisibleRootItem();
 
     // get all available perspectives
     berry::IPerspectiveRegistry* perspRegistry = berry::PlatformUI::GetWorkbench()->GetPerspectiveRegistry();
     QList<berry::IPerspectiveDescriptor::Pointer> perspectiveDescriptors(perspRegistry->GetPerspectives());
     qSort(perspectiveDescriptors.begin(), perspectiveDescriptors.end(), comparePerspectives);
 
     // get all Keywords
     KeywordRegistry keywordRegistry;
 
     berry::IPerspectiveDescriptor::Pointer currentPersp = page->GetPerspective();
     //QStringList perspectiveExcludeList = berry::PlatformUI::GetWorkbench()->GetActiveWorkbenchWindow()->GetPerspectiveExcludeList();
 
     std::vector< QStandardItem* > categoryItems;
     QStandardItem *perspectiveRootItem = new QStandardItem("Perspectives");
     perspectiveRootItem->setEditable(false);
     perspectiveRootItem->setFont(QFont("", 12, QFont::Normal));
     treeRootItem->appendRow(perspectiveRootItem);
 
     for (int i=0; i<perspectiveDescriptors.size(); i++)
     {
         berry::IPerspectiveDescriptor::Pointer p = perspectiveDescriptors.at(i);
 /*
         bool skipPerspective = false;
         for(int e=0; e<perspectiveExcludeList.size(); e++)
             if(perspectiveExcludeList.at(e)==p->GetId())
             {
                 skipPerspective = true;
                 break;
             }
         if (skipPerspective)
             continue;
 */
         //QIcon* pIcon = static_cast<QIcon*>(p->GetImageDescriptor()->CreateImage());
         mitk::QtPerspectiveItem* pItem = new mitk::QtPerspectiveItem(p->GetLabel());
         pItem->m_Perspective = p;
         pItem->m_Description = p->GetDescription();
         QStringList keylist = p->GetKeywordReferences();
         pItem->m_Tags = keywordRegistry.GetKeywords(keylist);
         pItem->setEditable(false);
 
         QFont font; font.setBold(true);
         if (currentPersp.IsNotNull() && currentPersp->GetId()==p->GetId())
             pItem->setFont(font);
 
         QStringList catPath = p->GetCategoryPath();
         if (catPath.isEmpty())
         {
             perspectiveRootItem->appendRow(pItem);
         }
         else
         {
             QStandardItem* categoryItem = nullptr;
 
             for (unsigned int c=0; c<categoryItems.size(); c++)
             {
                 if (categoryItems.at(c)->text() == catPath.front())
                 {
                     categoryItem = categoryItems.at(c);
                     break;
                 }
             }
 
             if (categoryItem==nullptr)
             {
                 categoryItem  = new QStandardItem(QIcon(),catPath.front());
                 categoryItems.push_back(categoryItem);
             }
             categoryItem->setEditable(false);
             categoryItem->appendRow(pItem);
             categoryItem->setFont(QFont("", 12, QFont::Normal));
         }
     }
     std::sort(categoryItems.begin(), categoryItems.end(), compareQStandardItems);
     for (unsigned int i=0; i<categoryItems.size(); i++)
         perspectiveRootItem->appendRow(categoryItems.at(i));
 
     // get all available views
     berry::IViewRegistry* viewRegistry = berry::PlatformUI::GetWorkbench()->GetViewRegistry();
     QList<berry::IViewDescriptor::Pointer> viewDescriptors(viewRegistry->GetViews());
     QList<berry::IViewPart::Pointer> viewParts(page->GetViews());
     qSort(viewDescriptors.begin(), viewDescriptors.end(), compareViews);
     auto   emptyItem = new QStandardItem();
     emptyItem->setFlags(Qt::ItemIsEnabled);
     treeRootItem->appendRow(emptyItem);
     //QStringList viewExcludeList = berry::PlatformUI::GetWorkbench()->GetActiveWorkbenchWindow()->GetViewExcludeList();
 
     //There currently is no way to get the list of excluded views at application start
     QStringList viewExcludeList;
     // internal view used for the intro screen, will crash when opened directly, see T22352
     viewExcludeList.append(QString("org.blueberry.ui.internal.introview"));
     viewExcludeList.append(QString("org.mitk.views.controlvisualizationpropertiesview"));
     viewExcludeList.append(QString("org.mitk.views.modules"));
     viewExcludeList.append(QString("org.mitk.views.viewnavigatorview"));
 
     QStandardItem* viewRootItem = new QStandardItem(QIcon(),"Views");
     viewRootItem->setFont(QFont("", 12, QFont::Normal));
     viewRootItem->setEditable(false);
     treeRootItem->appendRow(viewRootItem);
 
     categoryItems.clear();
     QStandardItem* noCategoryItem = new QStandardItem(QIcon(),"Miscellaneous");
     noCategoryItem->setEditable(false);
     noCategoryItem->setFont(QFont("", 12, QFont::Normal));
 
     for (int i = 0; i < viewDescriptors.size(); ++i)
     {
         berry::IViewDescriptor::Pointer v = viewDescriptors[i];
         bool skipView = false;
         for(int e=0; e<viewExcludeList.size(); e++)
             if(viewExcludeList.at(e)==v->GetId())
             {
                 skipView = true;
                 break;
             }
         if (skipView)
             continue;
 
         QStringList catPath = v->GetCategoryPath();
 
         QIcon icon = v->GetImageDescriptor();
         mitk::QtViewItem* vItem = new mitk::QtViewItem(icon, v->GetLabel());
         vItem->m_View = v;
         vItem->setToolTip(v->GetDescription());
         vItem->m_Description = v->GetDescription();
 
         QStringList keylist = v->GetKeywordReferences();
         vItem->m_Tags = keywordRegistry.GetKeywords(keylist);
         vItem->setEditable(false);
 
         for (int i=0; i<viewParts.size(); i++)
             if(viewParts[i]->GetPartName()==v->GetLabel())
             {
                 QFont font; font.setBold(true);
                 vItem->setFont(font);
                 break;
             }
 
         if (catPath.empty())
             noCategoryItem->appendRow(vItem);
         else
         {
             QStandardItem* categoryItem = nullptr;
 
             for (unsigned int c=0; c<categoryItems.size(); c++)
                 if (categoryItems.at(c)->text() == catPath.front())
                 {
                     categoryItem = categoryItems.at(c);
                     break;
                 }
 
             if (categoryItem==nullptr)
             {
                 categoryItem  = new QStandardItem(QIcon(),catPath.front());
                 categoryItems.push_back(categoryItem);
             }
             categoryItem->setEditable(false);
             categoryItem->appendRow(vItem);
             categoryItem->setFont(QFont("", 12, QFont::Normal));
         }
     }
     std::sort(categoryItems.begin(), categoryItems.end(), compareQStandardItems);
 
     for (unsigned int i=0; i<categoryItems.size(); i++)
         viewRootItem->appendRow(categoryItems.at(i));
     if (noCategoryItem->hasChildren())
         viewRootItem->appendRow(noCategoryItem);
 
     m_Controls.m_PluginTreeView->expandAll();
 
     return true;
 }
 
 void QmitkViewNavigatorWidget::FilterChanged()
 {
     QString filterString = m_Controls.lineEdit->text();
 //    if (filterString.size() > 0 )
     m_Controls.m_PluginTreeView->expandAll();
 //    else
 //        m_Controls.m_PluginTreeView->collapseAll();
     //    QRegExp::PatternSyntax syntax = QRegExp::RegExp;
 
     Qt::CaseSensitivity caseSensitivity = Qt::CaseInsensitive;
     QString strPattern = "^*" + filterString;
     QRegExp regExp(strPattern, caseSensitivity);
 
     m_FilterProxyModel->setFilterRegExp(regExp);
 }
 
 void QmitkViewNavigatorWidget::ItemClicked(const QModelIndex &index)
 {
     QStandardItem* item = m_TreeModel->itemFromIndex(m_FilterProxyModel->mapToSource(index));
 
     if ( dynamic_cast< mitk::QtPerspectiveItem* >(item) )
     {
         try
         {
             mitk::QtPerspectiveItem* pItem = dynamic_cast< mitk::QtPerspectiveItem* >(item);
             berry::PlatformUI::GetWorkbench()->ShowPerspective( pItem->m_Perspective->GetId(), berry::PlatformUI::GetWorkbench()->GetActiveWorkbenchWindow() );
         }
         catch (...)
         {
             QMessageBox::critical(nullptr, "Opening Perspective Failed", QString("The requested perspective could not be opened.\nSee the log for details."));
         }
     }
     else if ( dynamic_cast< mitk::QtViewItem* >(item) )
     {
         berry::IWorkbenchPage::Pointer page = berry::PlatformUI::GetWorkbench()->GetActiveWorkbenchWindow()->GetActivePage();
 
         if (page.IsNotNull())
         {
             try
             {
                 mitk::QtViewItem* vItem = dynamic_cast< mitk::QtViewItem* >(item);
                 page->ShowView(vItem->m_View->GetId());
             }
-            catch (berry::PartInitException e)
+            catch (const berry::PartInitException& e)
             {
                 BERRY_ERROR << "Error: " << e.what() << std::endl;
             }
         }
     }
 }
 
 void QmitkViewNavigatorWidget::SaveCurrentPerspectiveAs()
 {
   berry::IHandlerService* handlerService = m_Window->GetService<berry::IHandlerService>();
   try
   {
     handlerService->ExecuteCommand(berry::IWorkbenchCommandConstants::WINDOW_SAVE_PERSPECTIVE_AS,
                                    berry::UIElement::Pointer());
     FillTreeList();
   }
-  catch(const berry::NotHandledException)
+  catch(const berry::NotHandledException&)
   {}
   catch(const berry::CommandException& e)
   {
     MITK_ERROR << e.what();
   }
 }
 
 void QmitkViewNavigatorWidget::ResetCurrentPerspective()
 {
     if (QMessageBox::Yes == QMessageBox(QMessageBox::Question, "Please confirm", "Do you really want to reset the current perspective?", QMessageBox::Yes|QMessageBox::No).exec())
         berry::PlatformUI::GetWorkbench()->GetActiveWorkbenchWindow()->GetActivePage()->ResetPerspective();
 }
 
 void QmitkViewNavigatorWidget::ClosePerspective()
 {
     if (QMessageBox::Yes == QMessageBox(QMessageBox::Question, "Please confirm", "Do you really want to close the current perspective?", QMessageBox::Yes|QMessageBox::No).exec())
     {
         berry::IWorkbenchPage::Pointer page = m_Window->GetActivePage();
         page->ClosePerspective(page->GetPerspective(), true, true);
 
         //        if ( page->GetPerspective().IsNull() )
         //        {
         //            berry::IPerspectiveRegistry* perspRegistry = berry::PlatformUI::GetWorkbench()->GetPerspectiveRegistry();
         //            berry::PlatformUI::GetWorkbench()->ShowPerspective( perspRegistry->GetDefaultPerspective(), berry::PlatformUI::GetWorkbench()->GetActiveWorkbenchWindow() );
         //        }
     }
 }
 
 void QmitkViewNavigatorWidget::CloseAllPerspectives()
 {
     if (QMessageBox::Yes == QMessageBox(QMessageBox::Question, "Please confirm", "Do you really want to close all perspectives?", QMessageBox::Yes|QMessageBox::No).exec())
     {
         berry::IWorkbenchPage::Pointer page = berry::PlatformUI::GetWorkbench()->GetActiveWorkbenchWindow()->GetActivePage();
         page->CloseAllPerspectives(true, true);
 
         //        berry::IPerspectiveRegistry* perspRegistry = berry::PlatformUI::GetWorkbench()->GetPerspectiveRegistry();
         //        berry::PlatformUI::GetWorkbench()->ShowPerspective( perspRegistry->GetDefaultPerspective(), berry::PlatformUI::GetWorkbench()->GetActiveWorkbenchWindow() );
     }
 }
 
 void QmitkViewNavigatorWidget::ExpandAll()
 {
     m_Controls.m_PluginTreeView->expandAll();
 }
 
 void QmitkViewNavigatorWidget::CollapseAll()
 {
     m_Controls.m_PluginTreeView->collapseAll();
 }
 
 void QmitkViewNavigatorWidget::CustomMenuRequested(QPoint pos)
 {
     QModelIndex index = m_Controls.m_PluginTreeView->indexAt(pos);
     QStandardItem* item = m_TreeModel->itemFromIndex(m_FilterProxyModel->mapToSource(index));
 
     if (m_ContextMenu==nullptr)
         return;
 
     m_ContextMenu->clear();
 
     QAction* expandAction = new QAction("Expand tree", this);
     m_ContextMenu->addAction(expandAction);
     connect(expandAction, SIGNAL(triggered()), SLOT(ExpandAll()));
 
     QAction* collapseAction = new QAction("Collapse tree", this);
     m_ContextMenu->addAction(collapseAction);
     connect(collapseAction, SIGNAL(triggered()), SLOT(CollapseAll()));
 
     m_ContextMenu->addSeparator();
 
 
     if ( item!=nullptr && dynamic_cast< mitk::QtPerspectiveItem* >(item) )
     {
         berry::IPerspectiveDescriptor::Pointer persp = dynamic_cast< mitk::QtPerspectiveItem* >(item)->m_Perspective;
         if (this->m_ActivePerspective.IsNotNull() && this->m_ActivePerspective == persp)
         {
           //m_ContextMenu->addSeparator();
 
           QAction* saveAsAction = new QAction("Save As...", this);
           m_ContextMenu->addAction(saveAsAction);
           connect(saveAsAction, SIGNAL(triggered()), SLOT(SaveCurrentPerspectiveAs()));
           m_ContextMenu->addSeparator();
         }
     }
 
     QAction* resetAction = new QAction("Reset current perspective", this);
     m_ContextMenu->addAction(resetAction);
     connect(resetAction, SIGNAL(triggered()), SLOT(ResetCurrentPerspective()));
 
     QAction* closeAction = new QAction("Close perspective", this);
     m_ContextMenu->addAction(closeAction);
     connect(closeAction, SIGNAL(triggered()), SLOT(ClosePerspective()));
 
     m_ContextMenu->addSeparator();
 
     QAction* closeAllAction = new QAction("Close all perspectives", this);
     m_ContextMenu->addAction(closeAllAction);
     connect(closeAllAction, SIGNAL(triggered()), SLOT(CloseAllPerspectives()));
 
     m_ContextMenu->popup(m_Controls.m_PluginTreeView->viewport()->mapToGlobal(pos));
 }