diff --git a/Plugins/org.mitk.gui.qt.segmentation/src/internal/QmitkAutocropAction.cpp b/Plugins/org.mitk.gui.qt.segmentation/src/internal/QmitkAutocropAction.cpp
index d6612e12f6..5160e39b25 100644
--- a/Plugins/org.mitk.gui.qt.segmentation/src/internal/QmitkAutocropAction.cpp
+++ b/Plugins/org.mitk.gui.qt.segmentation/src/internal/QmitkAutocropAction.cpp
@@ -1,137 +1,137 @@
 #include "QmitkAutocropAction.h"
 
 #include "mitkAutoCropImageFilter.h"
 #include "mitkImageCast.h"
 #include "mitkRenderingManager.h"
 #include "mitkProgressBar.h"
 
 #include <itkConstantPadImageFilter.h>
 
 //needed for qApp 
 #include <qcoreapplication.h>
 
 QmitkAutocropAction::QmitkAutocropAction()
 {
 }
 
 QmitkAutocropAction::~QmitkAutocropAction()
 {
 }
 
 void QmitkAutocropAction::Run( const QList<mitk::DataNode::Pointer> &selectedNodes )
 {
   foreach ( mitk::DataNode::Pointer node, selectedNodes )
   {
     if (node)
     {
       mitk::Image::Pointer image = dynamic_cast<mitk::Image*>( node->GetData() );
       if (image.IsNull()) return;
 
       mitk::ProgressBar::GetInstance()->AddStepsToDo(10);
       mitk::ProgressBar::GetInstance()->Progress(2);
 
       qApp->processEvents();
 
       mitk::AutoCropImageFilter::Pointer cropFilter = mitk::AutoCropImageFilter::New();
       cropFilter->SetInput( image );
       cropFilter->SetBackgroundValue( 0 );
       try
       {
         cropFilter->Update();
 
         image = cropFilter->GetOutput();
 
         if (image.IsNotNull())
         {
           node->SetData( this->IncreaseCroppedImageSize(image) ); // bug fix 3145
           // Reinit node
           mitk::RenderingManager::GetInstance()->InitializeViews(
             node->GetData()->GetTimeSlicedGeometry(), mitk::RenderingManager::REQUEST_UPDATE_ALL, true );
           mitk::RenderingManager::GetInstance()->RequestUpdateAll();
 
         }
       }
       catch(...)
       {
         MITK_ERROR << "Cropping image failed...";
       }
       mitk::ProgressBar::GetInstance()->Progress(8);
     }
     else
     {
       MITK_INFO << "   a NULL node selected";
     }
   }
 }
 
 mitk::Image::Pointer QmitkAutocropAction::IncreaseCroppedImageSize( mitk::Image::Pointer image )
 {
   typedef itk::Image< short, 3 > ImageType;
   typedef itk::Image< unsigned char, 3 > PADOutputImageType;
   ImageType::Pointer itkTransformImage = ImageType::New();
   mitk::CastToItkImage( image, itkTransformImage );
 
   typedef itk::ConstantPadImageFilter< ImageType, PADOutputImageType > PadFilterType;
   PadFilterType::Pointer padFilter = PadFilterType::New();
 
   unsigned long upperPad[3];
   unsigned long lowerPad[3];
   int borderLiner = 3;
 
   mitk::Point3D mitkOriginPoint;
   double origin[3];
   origin[0]=0;
   origin[1]=0;
   origin[2]=0;
   itkTransformImage->SetOrigin(origin);
 
   lowerPad[0]=borderLiner;
   lowerPad[1]=borderLiner;
   lowerPad[2]=borderLiner;
 
   upperPad[0]=borderLiner;
   upperPad[1]=borderLiner;
   upperPad[2]=borderLiner;
 
   padFilter->SetInput(itkTransformImage);
   padFilter->SetConstant(0);
   padFilter->SetPadUpperBound(upperPad);
   padFilter->SetPadLowerBound(lowerPad);
   padFilter->UpdateLargestPossibleRegion();
 
 
   mitk::Image::Pointer paddedImage = mitk::Image::New();
   paddedImage->InitializeByItk(padFilter->GetOutput());
   mitk::CastToMitkImage(padFilter->GetOutput(), paddedImage);
 
   //calculate translation according to padding to get the new origin
   mitk::Point3D paddedOrigin = image->GetGeometry()->GetOrigin();
   mitk::Vector3D spacing = image->GetGeometry()->GetSpacing();
   paddedOrigin[0] -= (borderLiner)*spacing[0];
   paddedOrigin[1] -= (borderLiner)*spacing[1];
   paddedOrigin[2] -= (borderLiner)*spacing[2];
 
   paddedImage->GetGeometry()->SetOrigin( paddedOrigin );
 
   return paddedImage;
 }
 
 void QmitkAutocropAction::SetSmoothed(bool /*smoothed*/)
 {
  //not needed
 }
 
 void QmitkAutocropAction::SetDecimated(bool /*decimated*/)
 {
   //not needed
 }
 
 void QmitkAutocropAction::SetDataStorage(mitk::DataStorage* /*dataStorage*/)
 {
   //not needed
 }
 
-void QmitkAutocropAction::SetFunctionality(berry::QtViewPart */*functionality*/)
+void QmitkAutocropAction::SetFunctionality(berry::QtViewPart* /*functionality*/)
 {
   //not needed
 }
diff --git a/Plugins/org.mitk.gui.qt.segmentation/src/internal/QmitkThresholdAction.cpp b/Plugins/org.mitk.gui.qt.segmentation/src/internal/QmitkThresholdAction.cpp
index e48fdcad33..2cb05d7528 100644
--- a/Plugins/org.mitk.gui.qt.segmentation/src/internal/QmitkThresholdAction.cpp
+++ b/Plugins/org.mitk.gui.qt.segmentation/src/internal/QmitkThresholdAction.cpp
@@ -1,99 +1,99 @@
 #include "QmitkThresholdAction.h"
 
 // MITK
 #include <mitkBinaryThresholdTool.h>
 #include <mitkRenderingManager.h>
 #include <QmitkToolGUI.h>
 
 // Qt
 #include <QDialog>
 #include <QVBoxLayout>
 
 using namespace berry;
 using namespace mitk;
 using namespace std;
 
 QmitkThresholdAction::QmitkThresholdAction()
   : m_ThresholdingDialog(NULL)
 { 
 }
 
 QmitkThresholdAction::~QmitkThresholdAction()
 {
 }
 
 void QmitkThresholdAction::Run(const QList<DataNode::Pointer> &selectedNodes)
 {
   m_ThresholdingToolManager = ToolManager::New(m_DataStorage);
 
   m_ThresholdingToolManager->RegisterClient();
   m_ThresholdingToolManager->ActiveToolChanged += mitk::MessageDelegate<QmitkThresholdAction>(this, &QmitkThresholdAction::OnThresholdingToolManagerToolModified);
 
   m_ThresholdingDialog = new QDialog;
   connect(m_ThresholdingDialog, SIGNAL(finished(int)), this, SLOT(ThresholdingDone(int)));
 
   QVBoxLayout *layout = new QVBoxLayout;
   layout->setContentsMargins(0, 0, 0, 0);
 
   Tool *binaryThresholdTool = m_ThresholdingToolManager->GetToolById(m_ThresholdingToolManager->GetToolIdByToolType<mitk::BinaryThresholdTool>());
   
   if (binaryThresholdTool != NULL)
   {
     QmitkToolGUI *gui = dynamic_cast<QmitkToolGUI *>(binaryThresholdTool->GetGUI("Qmitk", "GUI").GetPointer());
     
     if (gui != NULL)
     {
       gui->SetTool(binaryThresholdTool);
       gui->setParent(m_ThresholdingDialog);
 
       layout->addWidget(gui);
 
       m_ThresholdingDialog->setLayout(layout);
       m_ThresholdingDialog->setFixedSize(300, 80);
 
       m_ThresholdingDialog->open();
     }
 
     m_ThresholdingToolManager->SetReferenceData(selectedNodes[0]);
     m_ThresholdingToolManager->ActivateTool(m_ThresholdingToolManager->GetToolIdByToolType<mitk::BinaryThresholdTool>());
   }
 }
 
 void QmitkThresholdAction::ThresholdingDone(int result)
 {
   if (result == QDialog::Rejected)
     m_ThresholdingToolManager->ActivateTool(-1);
 
   m_ThresholdingDialog->deleteLater();
   m_ThresholdingDialog = NULL;
 
   m_ThresholdingToolManager->SetReferenceData(NULL);
   m_ThresholdingToolManager->SetWorkingData(NULL);
 
   RenderingManager::GetInstance()->RequestUpdateAll();
 }
 
 void QmitkThresholdAction::OnThresholdingToolManagerToolModified()
 {
   if (m_ThresholdingToolManager.IsNotNull())
     if (m_ThresholdingToolManager->GetActiveToolID() < 0)
       if (m_ThresholdingDialog != NULL)
         m_ThresholdingDialog->accept();
 }
 
 void QmitkThresholdAction::SetDataStorage(DataStorage *dataStorage)
 {
   m_DataStorage = dataStorage;
 }
 
 void QmitkThresholdAction::SetSmoothed(bool)
 {
 }
 
 void QmitkThresholdAction::SetDecimated(bool)
 {
 }
 
-void QmitkThresholdAction::SetFunctionality(QtViewPart */*functionality*/)
+void QmitkThresholdAction::SetFunctionality(QtViewPart* /*functionality*/)
 {
 }