diff --git a/Modules/QtWidgets/QmitkCustomVariants.h b/Modules/QtWidgets/QmitkCustomVariants.h
index b5d44e4c0d..9aec7980e1 100755
--- a/Modules/QtWidgets/QmitkCustomVariants.h
+++ b/Modules/QtWidgets/QmitkCustomVariants.h
@@ -1,26 +1,28 @@
 /*===================================================================
 
 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 QMITKCUSTOMVARIANTS_H_
 #define QMITKCUSTOMVARIANTS_H_
 
 #include <mitkDataNode.h>
 
-Q_DECLARE_METATYPE(mitk::DataNode::Pointer)
+typedef mitk::DataNode::Pointer mitkDataNodePtr;
+
+Q_DECLARE_METATYPE(mitkDataNodePtr)
 Q_DECLARE_METATYPE(mitk::DataNode*)
 
 #endif /* QMITKCUSTOMVARIANTS_H_ */
diff --git a/Plugins/org.mitk.gui.qt.cmdlinemodules/src/internal/QmitkCmdLineModuleGui.cpp b/Plugins/org.mitk.gui.qt.cmdlinemodules/src/internal/QmitkCmdLineModuleGui.cpp
index 367d83497f..e50116b94c 100644
--- a/Plugins/org.mitk.gui.qt.cmdlinemodules/src/internal/QmitkCmdLineModuleGui.cpp
+++ b/Plugins/org.mitk.gui.qt.cmdlinemodules/src/internal/QmitkCmdLineModuleGui.cpp
@@ -1,274 +1,275 @@
 /*===================================================================
 
 The Medical Imaging Interaction Toolkit (MITK)
 
 Copyright (c) University College London (UCL).
 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 "QmitkCmdLineModuleGui.h"
 #include "QmitkUiLoader.h"
 #include <QVariant>
 #include <QIODevice>
 #include <QFile>
 #include <QScopedPointer>
 #include <QWidget>
 #include <QTextBrowser>
 #include <QVBoxLayout>
 #include <QmitkCustomVariants.h>
 #include <ctkCmdLineModuleXslTransform.h>
 #include <ctkCmdLineModuleParameter.h>
 #include <ctkCmdLineModuleDescription.h>
 #include <ctkCollapsibleGroupBox.h>
 #include "mitkDataStorage.h"
 
 //-----------------------------------------------------------------------------
 struct QmitkCmdLineModuleGuiPrivate
 {
   QmitkCmdLineModuleGuiPrivate(const mitk::DataStorage* dataStorage)
     : m_DataStorage(dataStorage), m_Loader(NULL), m_Transform(NULL), m_TopLevelWidget(NULL)
   {
   }
   const mitk::DataStorage* m_DataStorage;
   mutable QScopedPointer<QUiLoader> m_Loader;
   mutable QScopedPointer<ctkCmdLineModuleXslTransform> m_Transform;
   mutable QScopedPointer<QWidget> m_TopLevelWidget;
 };
 
 
 //-----------------------------------------------------------------------------
 QmitkCmdLineModuleGui::QmitkCmdLineModuleGui(const mitk::DataStorage* dataStorage, const ctkCmdLineModuleReference& moduleRef)
   : ctkCmdLineModuleFrontendQtGui(moduleRef)
 , d(new QmitkCmdLineModuleGuiPrivate(dataStorage))
 {
   qRegisterMetaType<mitk::DataNode::Pointer>();
+  qRegisterMetaType<mitkDataNodePtr>();
 }
 
 
 //-----------------------------------------------------------------------------
 QmitkCmdLineModuleGui::~QmitkCmdLineModuleGui()
 {
 }
 
 
 //-----------------------------------------------------------------------------
 QUiLoader* QmitkCmdLineModuleGui::uiLoader() const
 {
   // Here we are creating a QUiLoader locally, so when this method
   // is called, it overrides the one in the base class, so the base
   // class one is never constructed, and this one is constructed as
   // a replacement.
   if (d->m_Loader == NULL)
   {
     d->m_Loader.reset(new QmitkUiLoader(d->m_DataStorage));
   }
   return d->m_Loader.data();
 }
 
 
 //-----------------------------------------------------------------------------
 ctkCmdLineModuleXslTransform* QmitkCmdLineModuleGui::xslTransform() const
 {
   // This is a virtual getter, overriding the one in the base class.
   // However, we want to use the transform in the base class, and just append to it.
   // So we call the base class one, modify it by adding some stuff, and then return
   // the pointer to the one in the base class.
   ctkCmdLineModuleXslTransform *transform = ctkCmdLineModuleFrontendQtGui::xslTransform();
   if (transform != NULL)
   {
     transform->bindVariable("imageInputWidget", QVariant(QString("QmitkDataStorageComboBoxWithSelectNone")));
     transform->bindVariable("imageInputValueProperty", "currentValue");
     transform->bindVariable("imageInputSetProperty", ""); // Don't need this, as we are connected to DataStorage.
   }
   return transform;
 }
 
 
 //-----------------------------------------------------------------------------
 QVariant QmitkCmdLineModuleGui::value(const QString &parameter, int role) const
 {
   if (role == UserRole)
   {
     ctkCmdLineModuleParameter param = this->moduleReference().description().parameter(parameter);
     if (param.channel() == "input" && param.tag() == "image")
     {
       return this->customValue(parameter, "SelectedNode");
     }
     return QVariant();
   }
   return ctkCmdLineModuleFrontendQtGui::value(parameter, role);
 }
 
 
 //-----------------------------------------------------------------------------
 void QmitkCmdLineModuleGui::setValue(const QString& parameter, const QVariant& value, int role)
 {
   if (role == UserRole)
   {
     ctkCmdLineModuleParameter param = this->moduleReference().description().parameter(parameter);
     if (param.channel() == "input" && param.tag() == "image")
     {
       this->setCustomValue(parameter, value, "SelectedNode");
     }
     else
     {
       ctkCmdLineModuleFrontendQtGui::setValue(parameter, value, role);
     }
   }
   else
   {
     ctkCmdLineModuleFrontendQtGui::setValue(parameter, value, role);
   }
 }
 
 //-----------------------------------------------------------------------------
 QWidget* QmitkCmdLineModuleGui::getGui()
 {
   if (!d->m_TopLevelWidget)
   {
     // Construct additional widgets to contain full GUI.
     QWidget *aboutBoxContainerWidget = new QWidget();
 
     ctkCollapsibleGroupBox *aboutBox = new ctkCollapsibleGroupBox(aboutBoxContainerWidget);
     aboutBox->setTitle("About");
 
     QTextBrowser *aboutBrowser = new QTextBrowser(aboutBox);
     aboutBrowser->setReadOnly(true);
     aboutBrowser->setSizePolicy(QSizePolicy::Preferred, QSizePolicy::Preferred);
     aboutBrowser->setOpenExternalLinks(true);
     aboutBrowser->setOpenLinks(true);
 
     QVBoxLayout *aboutLayout = new QVBoxLayout(aboutBox);
     aboutLayout->addWidget(aboutBrowser);
 
     QVBoxLayout *aboutBoxContainerWidgetLayout = new QVBoxLayout(aboutBoxContainerWidget);
     aboutBoxContainerWidgetLayout->addWidget(aboutBox);
 
     QWidget *helpBoxContainerWidget = new QWidget();
 
     ctkCollapsibleGroupBox *helpBox = new ctkCollapsibleGroupBox();
     helpBox->setTitle("Help");
 
     QTextBrowser *helpBrowser = new QTextBrowser(helpBox);
     helpBrowser->setReadOnly(true);
     helpBrowser->setSizePolicy(QSizePolicy::Preferred, QSizePolicy::Preferred);
     helpBrowser->setOpenExternalLinks(true);
     helpBrowser->setOpenLinks(true);
 
     QVBoxLayout *helpLayout = new QVBoxLayout(helpBox);
     helpLayout->addWidget(helpBrowser);
 
     QVBoxLayout *helpBoxContainerWidgetLayout = new QVBoxLayout(helpBoxContainerWidget);
     helpBoxContainerWidgetLayout->addWidget(helpBox);
 
     QObject* guiHandle = this->guiHandle();
     QWidget* generatedGuiWidgets = qobject_cast<QWidget*>(guiHandle);
 
     QWidget *topLevelWidget = new QWidget();
 
     QGridLayout *topLevelLayout = new QGridLayout(topLevelWidget);
     topLevelLayout->setContentsMargins(0,0,0,0);
     topLevelLayout->setSpacing(0);
     topLevelLayout->addWidget(aboutBoxContainerWidget, 0, 0);
     topLevelLayout->addWidget(helpBoxContainerWidget, 1, 0);
     topLevelLayout->addWidget(generatedGuiWidgets, 2, 0);
 
     ctkCmdLineModuleDescription description = this->moduleReference().description();
 
     QString helpString = "";
 
     if (!description.title().isEmpty())
     {
       QString titleHtml = "<h1>" + description.title() + "</h1>";
       helpString += titleHtml;
     }
 
     if (!description.description().isEmpty())
     {
       QString descriptionHtml = "<p>" + description.description() + "</p>";
       helpString += descriptionHtml;
     }
 
     if (!description.documentationURL().isEmpty())
     {
       QString docUrlHtml = "<p>For more information please see <a href=\"" + description.documentationURL()
           + "\">" + description.documentationURL() + "</a></p>";
       helpString += docUrlHtml;
     }
 
     QString aboutString = "";
 
     if (!description.title().isEmpty())
     {
       QString titleHtml = "<h1>" + description.title() + "</h1>";
       aboutString += titleHtml;
     }
 
     if (!description.contributor().isEmpty())
     {
       QString contributorHtml = "<h2>Contributed By</h2><p>" + description.contributor() + "</p>";
       aboutString += contributorHtml;
     }
 
     if (!description.license().isEmpty())
     {
       QString licenseHtml = "<h2>License</h2><p>" + description.license() + "</p>";
       aboutString += licenseHtml;
     }
 
     if (!description.acknowledgements().isEmpty())
     {
       QString acknowledgementsHtml = "<h2>Acknowledgements</h2><p>" + description.acknowledgements() + "</p>";
       aboutString += acknowledgementsHtml;
     }
 
     helpBrowser->clear();
     helpBrowser->setHtml(helpString);
     helpBox->setCollapsed(true);
 
     aboutBrowser->clear();
     aboutBrowser->setHtml(aboutString);
     aboutBox->setCollapsed(true);
 
     d->m_TopLevelWidget.reset(topLevelWidget);
   }
 
   return d->m_TopLevelWidget.data();
 }
 
 
 //-----------------------------------------------------------------------------
 void QmitkCmdLineModuleGui::copyParameters(QmitkCmdLineModuleGui& another)
 {
 
   // This copies "display" parameter types.
   // See ctkCmdLineModuleFrontend::DisplayRole
   this->setValues(another.values());
 
   // For custom types, we must manually copy the values.
   // In our case, we copy image types manually, to pass across the mitk::DataNode pointer.
   QList<ctkCmdLineModuleParameter> parameters = another.parameters("image", ctkCmdLineModuleFrontend::Input);
   foreach (ctkCmdLineModuleParameter parameter, parameters)
   {
     QString parameterName = parameter.name();
 
     QVariant tmp = another.value(parameterName, ctkCmdLineModuleFrontend::UserRole);
     mitk::DataNode::Pointer node = tmp.value<mitk::DataNode::Pointer>();
 
     if (node.IsNotNull())
     {
       mitk::Image* image = dynamic_cast<mitk::Image*>(node->GetData());
       if (image != NULL)
       {
         this->setValue(parameterName, tmp, ctkCmdLineModuleFrontend::UserRole);
       }
     }
   }
 }
diff --git a/Plugins/org.mitk.gui.qt.cmdlinemodules/src/internal/QmitkCmdLineModuleProgressWidget.cpp b/Plugins/org.mitk.gui.qt.cmdlinemodules/src/internal/QmitkCmdLineModuleProgressWidget.cpp
index 7c5036d0fd..62c32857ed 100644
--- a/Plugins/org.mitk.gui.qt.cmdlinemodules/src/internal/QmitkCmdLineModuleProgressWidget.cpp
+++ b/Plugins/org.mitk.gui.qt.cmdlinemodules/src/internal/QmitkCmdLineModuleProgressWidget.cpp
@@ -1,637 +1,637 @@
 /*===================================================================
 
 The Medical Imaging Interaction Toolkit (MITK)
 
 Copyright (c) University College London (UCL).
 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 "QmitkCmdLineModuleProgressWidget.h"
 #include "ui_QmitkCmdLineModuleProgressWidget.h"
 
 // Qt
 #include <QFile>
 #include <QFileInfo>
 #include <QDir>
 #include <QMessageBox>
 #include <QVBoxLayout>
 #include <QLayoutItem>
 #include <QTextBrowser>
 #include <QByteArray>
 #include <QApplication>
 #include <QRegExp>
 
 // CTK
 #include <ctkCmdLineModuleFuture.h>
 #include <ctkCmdLineModuleFutureWatcher.h>
 #include <ctkCmdLineModuleManager.h>
 #include <ctkCmdLineModuleFrontend.h>
 #include <ctkCmdLineModuleDescription.h>
 #include <ctkCmdLineModuleParameter.h>
 #include <ctkCollapsibleGroupBox.h>
 
 // MITK
 #include <mitkIOUtil.h>
 #include <mitkDataStorage.h>
 #include <mitkDataNode.h>
 #include <QmitkCustomVariants.h>
 #include "QmitkCmdLineModuleGui.h"
 
+
 //-----------------------------------------------------------------------------
 QmitkCmdLineModuleProgressWidget::QmitkCmdLineModuleProgressWidget(QWidget *parent)
   : QWidget(parent)
 , m_ModuleManager(NULL)
 , m_DataStorage(NULL)
 , m_TemporaryDirectoryName("")
 , m_UI(new Ui::QmitkCmdLineModuleProgressWidget)
 , m_Layout(NULL)
 , m_ModuleFrontEnd(NULL)
 , m_FutureWatcher(NULL)
 {
   m_UI->setupUi(this);
   m_UI->m_RemoveButton->setIcon(QApplication::style()->standardIcon(QStyle::SP_TitleBarCloseButton));
 
   m_Layout = new QVBoxLayout();
   m_Layout->setContentsMargins(0,0,0,0);
   m_Layout->setSpacing(0);
   m_UI->m_ParametersGroupBox->setLayout(m_Layout);
 
-  qRegisterMetaType<mitk::DataNode::Pointer>();
   qRegisterMetaType<ctkCmdLineModuleReference>();
 
   connect(m_UI->m_RemoveButton, SIGNAL(clicked()), this, SLOT(OnRemoveButtonClicked()));
 
   // Due to Qt bug 12152, we cannot listen to the "paused" signal because it is
   // not emitted directly when the QFuture is paused. Instead, it is emitted after
   // resuming the future, after the "resume" signal has been emitted... we use
   // a polling approach instead.
   connect(&m_PollPauseTimer, SIGNAL(timeout()), SLOT(OnCheckModulePaused()));
   m_PollPauseTimer.setInterval(300);
   m_PollPauseTimer.start();
 }
 
 
 //-----------------------------------------------------------------------------
 QmitkCmdLineModuleProgressWidget::~QmitkCmdLineModuleProgressWidget()
 {
   if (m_ModuleFrontEnd != NULL)
   {
     delete m_ModuleFrontEnd;
   }
 
   this->ClearUpTemporaryFiles();
 
   delete m_UI;
 }
 
 
 //-----------------------------------------------------------------------------
 void QmitkCmdLineModuleProgressWidget::SetManager(ctkCmdLineModuleManager* manager)
 {
   this->m_ModuleManager = manager;
 }
 
 
 //-----------------------------------------------------------------------------
 void QmitkCmdLineModuleProgressWidget::SetDataStorage(mitk::DataStorage* dataStorage)
 {
   this->m_DataStorage = dataStorage;
 }
 
 
 //-----------------------------------------------------------------------------
 void QmitkCmdLineModuleProgressWidget::SetTemporaryDirectory(const QString& directoryName)
 {
   this->m_TemporaryDirectoryName = directoryName;
 }
 
 
 //-----------------------------------------------------------------------------
 void QmitkCmdLineModuleProgressWidget::SetOutputDirectory(const QString& directoryName)
 {
   this->m_OutputDirectoryName = directoryName;
 }
 
 
 //-----------------------------------------------------------------------------
 QString QmitkCmdLineModuleProgressWidget::GetTitle()
 {
   assert(m_ModuleFrontEnd);
 
   ctkCmdLineModuleReference reference = m_ModuleFrontEnd->moduleReference();
   ctkCmdLineModuleDescription description = reference.description();
 
   return description.title();
 }
 
 
 //-----------------------------------------------------------------------------
 QString QmitkCmdLineModuleProgressWidget::GetFullName() const
 {
   assert(m_ModuleFrontEnd);
 
   ctkCmdLineModuleReference reference = m_ModuleFrontEnd->moduleReference();
   ctkCmdLineModuleDescription description = reference.description();
 
   return description.categoryDotTitle();
 }
 
 
 //-----------------------------------------------------------------------------
 QString QmitkCmdLineModuleProgressWidget::GetValidNodeName(const QString& nodeName)
 {
   QString outputName = nodeName;
 
   // We will allow A-Z, a-z, 0-9, period, hyphen and underscore in the output file name.
   // This method is parsing a node name, and other bits of code add on a file extension .nii.
   // So, in the output string from this function, we should not allow period, so that
   // the second recommendation on this page:
   // http://www.boost.org/doc/libs/1_43_0/libs/filesystem/doc/portability_guide.htm
   // is still true.
 
   QRegExp rx("[A-Z|a-z|0-9|-|_]{1,1}");
 
   QString singleLetter;
 
   for (int i = 0; i < outputName.size(); i++)
   {
     if (i == 0 && outputName[i] == '-')
     {
       outputName[i] = '_';
     }
 
     singleLetter = outputName[i];
 
     if (!rx.exactMatch(singleLetter))
     {
       outputName[i] = '-';
     }
   }
   return outputName;
 }
 
 
 //-----------------------------------------------------------------------------
 bool QmitkCmdLineModuleProgressWidget::IsStarted() const
 {
   bool isStarted = false;
   if (m_FutureWatcher != NULL && m_FutureWatcher->isStarted())
   {
     isStarted = true;
   }
   return isStarted;
 }
 
 //-----------------------------------------------------------------------------
 void QmitkCmdLineModuleProgressWidget::OnCheckModulePaused()
 {
   if (!this->IsStarted())
   {
     return;
   }
 
   if (this->m_FutureWatcher->future().isPaused())
   {
     if (!m_UI->m_PauseButton->isChecked())
     {
       m_UI->m_PauseButton->setChecked(true);
     }
   }
   else
   {
     if (m_UI->m_PauseButton->isChecked())
     {
       m_UI->m_PauseButton->setChecked(false);
     }
   }
 }
 
 
 //-----------------------------------------------------------------------------
 void QmitkCmdLineModuleProgressWidget::OnPauseButtonToggled(bool toggled)
 {
   this->m_FutureWatcher->setPaused(toggled);
 
   if (toggled)
   {
     this->m_UI->m_ProgressTitle->setText(this->GetTitle() + ": paused");
   }
   else
   {
     this->m_UI->m_ProgressTitle->setText(this->GetTitle() + ": resumed");
   }
 }
 
 
 //-----------------------------------------------------------------------------
 void QmitkCmdLineModuleProgressWidget::OnRemoveButtonClicked()
 {
   this->deleteLater();
 }
 
 
 //-----------------------------------------------------------------------------
 void QmitkCmdLineModuleProgressWidget::OnModuleStarted()
 {
   this->m_UI->m_ProgressBar->setMaximum(0);
 
   QString message = "started.";
   this->PublishMessage(message);
 
   emit started();
 }
 
 
 //-----------------------------------------------------------------------------
 void QmitkCmdLineModuleProgressWidget::OnModuleCanceled()
 {
   QString message = "cancelling.";
   this->PublishMessage(message);
 
   this->m_UI->m_PauseButton->setEnabled(false);
   this->m_UI->m_PauseButton->setChecked(false);
   this->m_UI->m_CancelButton->setEnabled(false);
   this->m_UI->m_RemoveButton->setEnabled(true);
 
   this->m_UI->m_ParametersGroupBox->setCollapsed(true);
   this->m_UI->m_ConsoleGroupBox->setCollapsed(true);
   this->m_UI->m_ProgressTitle->setText(this->GetTitle() + ": cancelled");
 
   message = "cancelled.";
   this->PublishMessage(message);
 }
 
 
 //-----------------------------------------------------------------------------
 void QmitkCmdLineModuleProgressWidget::OnModuleFinished()
 {
   this->m_UI->m_PauseButton->setEnabled(false);
   this->m_UI->m_PauseButton->setChecked(false);
   this->m_UI->m_CancelButton->setEnabled(false);
   this->m_UI->m_RemoveButton->setEnabled(true);
 
   if (!this->m_FutureWatcher->isCanceled())
   {
     QString message = "finishing.";
     this->PublishMessage(message);
 
     // If no incremental results from stdout, try getting hold of the whole buffer and printing it.
     if (m_OutputCount == 0)
     {
       message = "Output channel is:";
       this->PublishMessage(message);
       this->PublishByteArray(this->m_FutureWatcher->readAllOutputData());
     }
 
     // If no incremental results from stderr, try getting hold of the whole buffer and printing it.
     if (m_ErrorCount == 0)
     {
       message = "Error channel is:";
       this->PublishMessage(message);
       this->PublishByteArray(this->m_FutureWatcher->readAllErrorData());
     }
 
     this->m_UI->m_ProgressTitle->setText(this->GetTitle() + ": finished");
 
     this->LoadOutputData();
     this->ClearUpTemporaryFiles();
 
     message = "finished.";
     this->PublishMessage(message);
 
   }
 
   emit finished();
 }
 
 
 //-----------------------------------------------------------------------------
 void QmitkCmdLineModuleProgressWidget::OnModuleResumed()
 {
   this->m_UI->m_PauseButton->setChecked(false);
 }
 
 
 //-----------------------------------------------------------------------------
 void QmitkCmdLineModuleProgressWidget::OnModuleProgressRangeChanged(int progressMin, int progressMax)
 {
   this->m_UI->m_ProgressBar->setMinimum(progressMin);
   this->m_UI->m_ProgressBar->setMaximum(progressMax);
 }
 
 
 //-----------------------------------------------------------------------------
 void QmitkCmdLineModuleProgressWidget::OnModuleProgressTextChanged(const QString& progressText)
 {
   this->m_UI->m_Console->appendPlainText(progressText);
 }
 
 
 //-----------------------------------------------------------------------------
 void QmitkCmdLineModuleProgressWidget::OnModuleProgressValueChanged(int progressValue)
 {
   this->m_UI->m_ProgressBar->setValue(progressValue);
 }
 
 
 //-----------------------------------------------------------------------------
 void QmitkCmdLineModuleProgressWidget::OnOutputDataReady()
 {
   m_OutputCount++;
   this->PublishByteArray(this->m_FutureWatcher->readPendingOutputData());
 }
 
 
 //-----------------------------------------------------------------------------
 void QmitkCmdLineModuleProgressWidget::OnErrorDataReady()
 {
   m_ErrorCount++;
   this->PublishByteArray(this->m_FutureWatcher->readPendingErrorData());
 }
 
 
 //-----------------------------------------------------------------------------
 void QmitkCmdLineModuleProgressWidget::PublishMessage(const QString& message)
 {
   QString prefix = ""; // Can put additional prefix here if needed.
   QString outputMessage = prefix + message;
 
   qDebug() << outputMessage;
   this->m_UI->m_Console->appendPlainText(outputMessage);
 }
 
 
 //-----------------------------------------------------------------------------
 void QmitkCmdLineModuleProgressWidget::PublishByteArray(const QByteArray& array)
 {
   QString message = array.data();
   this->PublishMessage(message);
 }
 
 
 //-----------------------------------------------------------------------------
 void QmitkCmdLineModuleProgressWidget::ClearUpTemporaryFiles()
 {
   QString message;
   QString fileName;
 
   foreach (fileName, m_TemporaryFileNames)
   {
     QFile file(fileName);
     if (file.exists())
     {
       message = QObject::tr("removing %1").arg(fileName);
       this->PublishMessage(message);
 
       bool success = file.remove();
 
       message = QObject::tr("removed %1, successfully=%2").arg(fileName).arg(success);
       this->PublishMessage(message);
     }
   }
 }
 
 
 //-----------------------------------------------------------------------------
 void QmitkCmdLineModuleProgressWidget::LoadOutputData()
 {
   assert(m_DataStorage);
 
   std::vector<std::string> fileNames;
 
   QString fileName;
   foreach (fileName, m_OutputDataToLoad)
   {
     QString message = QObject::tr("loading %1").arg(fileName);
     this->PublishMessage(message);
 
     fileNames.push_back(fileName.toStdString());
   }
 
   if (fileNames.size() > 0)
   {
     int numberLoaded = mitk::IOUtil::LoadFiles(fileNames, *(m_DataStorage));
 
     QString message = QObject::tr("loaded %1 files").arg(numberLoaded);
     this->PublishMessage(message);
   }
 }
 
 
 //-----------------------------------------------------------------------------
 void QmitkCmdLineModuleProgressWidget::SetFrontend(QmitkCmdLineModuleGui* frontEnd)
 {
   assert(frontEnd);
   assert(m_ModuleManager);
   assert(m_DataStorage);
 
   // We are assuming that this method is ONLY EVER CALLED ONCE.
   assert(!m_ModuleFrontEnd);
 
   // Assign the frontEnd to the member variable.
   m_ModuleFrontEnd = frontEnd;
 
   // We put the new GUI into the layout.
   m_Layout->insertWidget(0, m_ModuleFrontEnd->getGui());
 
   // And configure a few other niceties.
   m_UI->m_ProgressTitle->setText(this->GetTitle());
   m_UI->m_ConsoleGroupBox->setCollapsed(true);     // We basically call SetFrontend then Run
   m_UI->m_ParametersGroupBox->setCollapsed(true);  // so in practice the user will only want the progress bar.
 }
 
 
 //-----------------------------------------------------------------------------
 void QmitkCmdLineModuleProgressWidget::Run()
 {
   assert(m_ModuleManager);
   assert(m_DataStorage);
   assert(m_ModuleFrontEnd);
 
   m_OutputDataToLoad.clear();
 
   QString parameterName;
   QString message;
   QList<ctkCmdLineModuleParameter> parameters;
 
   ctkCmdLineModuleReference reference = m_ModuleFrontEnd->moduleReference();
   ctkCmdLineModuleDescription description = reference.description();
 
   // Check we have valid output. If at all possible, they should be somewhere writable.
 
   parameters = m_ModuleFrontEnd->parameters("image", ctkCmdLineModuleFrontend::Output);
   parameters << m_ModuleFrontEnd->parameters("file", ctkCmdLineModuleFrontend::Output);
   parameters << m_ModuleFrontEnd->parameters("geometry", ctkCmdLineModuleFrontend::Output);
 
   foreach (ctkCmdLineModuleParameter parameter, parameters)
   {
     parameterName = parameter.name();
     QString outputFileName = m_ModuleFrontEnd->value(parameterName, ctkCmdLineModuleFrontend::DisplayRole).toString();
 
     // Try to make sure we are not running in the application installation folder,
     // as more likely than not, it should not have write access, and you certainly
     // don't want users output files dumped there.
     //
     // eg. C:/Program Files (Windows), /Applications (Mac), /usr/local (Linux) etc.
 
     QFileInfo outputFileInfo(outputFileName);
 
     QString applicationDir = QApplication::applicationDirPath();
     QString outputDir = outputFileInfo.dir().absolutePath();
 
     if (applicationDir == outputDir)
     {
       qDebug() << "QmitkCmdLineModuleProgressWidget::Run(), output folder = application folder, so will swap to defaultOutputDir, specified in CLI module preferences";
 
       QFileInfo newOutputFileInfo(m_OutputDirectoryName, outputFileInfo.fileName());
       QString newOutputFileAbsolutePath = newOutputFileInfo.absoluteFilePath();
 
       qDebug() << "QmitkCmdLineModuleProgressWidget::Run(), swapping " << outputFileName << " to " << newOutputFileAbsolutePath;
 
       QMessageBox msgBox;
         msgBox.setText("The output directory is the same as the application installation directory");
         msgBox.setInformativeText(tr("Output file:\n%1\n\nwill be swapped to\n%2").arg(outputFileName).arg(newOutputFileAbsolutePath));
         msgBox.setStandardButtons(QMessageBox::Ok);
         msgBox.setIcon(QMessageBox::Warning);
         msgBox.exec();
 
       m_ModuleFrontEnd->setValue(parameterName, newOutputFileAbsolutePath, ctkCmdLineModuleFrontend::DisplayRole);
     }
   }
 
   // For each output image or file, store the filename, so we can auto-load it once the process finishes.
   foreach (ctkCmdLineModuleParameter parameter, parameters)
   {
     parameterName = parameter.name();
     QString outputFileName = m_ModuleFrontEnd->value(parameterName, ctkCmdLineModuleFrontend::DisplayRole).toString();
 
     if (!outputFileName.isEmpty())
     {
       m_OutputDataToLoad.push_back(outputFileName);
 
       message = "Registered " + outputFileName + " to auto load upon completion.";
       this->PublishMessage(message);
     }
   }
 
   // For each input image, write a temporary file as a Nifti image (TODO - iterate through list of file formats).
   // and then save the full path name back on the parameter.
 
   message = "Saving image data to temporary storage...";
   this->PublishMessage(message);
 
   parameters = m_ModuleFrontEnd->parameters("image", ctkCmdLineModuleFrontend::Input);
   foreach (ctkCmdLineModuleParameter parameter, parameters)
   {
     parameterName = parameter.name();
 
     QVariant tmp = m_ModuleFrontEnd->value(parameterName, ctkCmdLineModuleFrontend::UserRole);
-    mitk::DataNode::Pointer node = tmp.value<mitk::DataNode::Pointer>();
+    mitk::DataNode::Pointer node = tmp.value<mitkDataNodePtr>();
 
     if (node.IsNotNull())
     {
       mitk::Image* image = dynamic_cast<mitk::Image*>(node->GetData());
       if (image != NULL)
       {
         QString name = this->GetValidNodeName(QString::fromStdString(node->GetName()));
         int pid = QCoreApplication::applicationPid();
         int randomInt = qrand() % 1000000;
 
         QString fileNameBase = m_TemporaryDirectoryName + "/" + name + QString::number(pid) + "_" + QString::number(randomInt);
         QString fileName = "";
         bool writeSucess = false;
 
         // Try to save the image using one of the specified "fileExtensions" or
         // .nii if none have been specified.
         if (parameter.fileExtensions().isEmpty())
         {
           fileName = fileNameBase + ".nii";
           try
           {
             if (mitk::IOUtil::SaveBaseData( image, fileName.toStdString() ))
             {
               writeSucess = true;
             }
           }
           catch(const std::exception&){}
         }
         else
         {
           foreach (QString extension, parameter.fileExtensions())
           {
             fileName = fileNameBase + "." + extension;
             try
             {
               if (mitk::IOUtil::SaveBaseData( image, fileName.toStdString() ))
               {
                 writeSucess = true;
                 break;
               }
             }
             catch(const std::exception&)
             {}
           }
         }
 
         if(!writeSucess)
         {
           QStringList extensions = parameter.fileExtensions();
           if (extensions.isEmpty())
           {
             extensions.push_back("nii");
           }
           QMessageBox::warning(this, "Saving temporary input file failed",
                                QString("Unsupported file formats: ") + extensions.join(", "));
           return;
         }
         m_TemporaryFileNames.push_back(fileName);
         m_ModuleFrontEnd->setValue(parameterName, fileName);
 
         message = "Saved " + fileName;
         this->PublishMessage(message);
       } // end if image
     } // end if node
   } // end foreach input image
 
   m_OutputCount = 0;
   m_ErrorCount = 0;
 
   // Now we run stuff.
   message = "starting.";
   this->PublishMessage(message);
 
   if (m_FutureWatcher == NULL)
   {
     m_FutureWatcher = new ctkCmdLineModuleFutureWatcher();
 
     connect(m_FutureWatcher, SIGNAL(started()), SLOT(OnModuleStarted()));
     connect(m_FutureWatcher, SIGNAL(canceled()), SLOT(OnModuleCanceled()));
     connect(m_FutureWatcher, SIGNAL(finished()), SLOT(OnModuleFinished()));
     connect(m_FutureWatcher, SIGNAL(resumed()), SLOT(OnModuleResumed()));
     connect(m_FutureWatcher, SIGNAL(progressRangeChanged(int,int)), SLOT(OnModuleProgressRangeChanged(int,int)));
     connect(m_FutureWatcher, SIGNAL(progressTextChanged(QString)), SLOT(OnModuleProgressTextChanged(QString)));
     connect(m_FutureWatcher, SIGNAL(progressValueChanged(int)), SLOT(OnModuleProgressValueChanged(int)));
     connect(m_FutureWatcher, SIGNAL(outputDataReady()), SLOT(OnOutputDataReady()));
     connect(m_FutureWatcher, SIGNAL(errorDataReady()), SLOT(OnErrorDataReady()));
 
     connect(m_UI->m_CancelButton, SIGNAL(clicked()), m_FutureWatcher, SLOT(cancel()));
     connect(m_UI->m_PauseButton, SIGNAL(toggled(bool)), this, SLOT(OnPauseButtonToggled(bool)));
 
   }
   ctkCmdLineModuleFuture future = m_ModuleManager->run(m_ModuleFrontEnd);
   m_FutureWatcher->setFuture(future);
 
   m_UI->m_PauseButton->setEnabled(future.canPause());
   m_UI->m_CancelButton->setEnabled(future.canCancel());
   m_UI->m_RemoveButton->setEnabled(!future.isRunning());
 
   // Give some immediate indication that we are running.
   m_UI->m_ProgressTitle->setText(description.title() + ": running");
 }
diff --git a/Plugins/org.mitk.gui.qt.cmdlinemodules/src/internal/QmitkDataStorageComboBoxWithSelectNone.h b/Plugins/org.mitk.gui.qt.cmdlinemodules/src/internal/QmitkDataStorageComboBoxWithSelectNone.h
index 72713a740d..605ffdbf0b 100644
--- a/Plugins/org.mitk.gui.qt.cmdlinemodules/src/internal/QmitkDataStorageComboBoxWithSelectNone.h
+++ b/Plugins/org.mitk.gui.qt.cmdlinemodules/src/internal/QmitkDataStorageComboBoxWithSelectNone.h
@@ -1,142 +1,142 @@
 /*===================================================================
 
 The Medical Imaging Interaction Toolkit (MITK)
 
 Copyright (c) University College London (UCL).
 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 QmitkDataStorageComboBoxWithSelectNone_h
 #define QmitkDataStorageComboBoxWithSelectNone_h
 
 #include "QmitkDataStorageComboBox.h"
 #include "QmitkCustomVariants.h"
 #include "mitkDataNode.h"
 
+
 /**
  * \class QmitkDataStorageComboBoxWithSelectNone
  * \brief Displays all or a subset (defined by a predicate) of nodes of the Data Storage,
  * and additionally, index 0 is always "please select", indicating no selection, and will
  * hence always return a NULL mitk::DataNode* if asked for the node at index 0.
  *
  * \author Matt Clarkson (m.clarkson@ucl.ac.uk)
  * \ingroup org_mitk_gui_qt_cmdlinemodules_internal
  * \sa QmitkDataStorageComboBox
  */
 class QmitkDataStorageComboBoxWithSelectNone : public QmitkDataStorageComboBox
 {
-  typedef mitk::DataNode::Pointer DataNodePtr;
 
   Q_OBJECT
-  Q_PROPERTY(DataNodePtr SelectedNode READ GetSelectedNode WRITE SetSelectedNode)
+  Q_PROPERTY(mitkDataNodePtr SelectedNode READ GetSelectedNode WRITE SetSelectedNode)
   Q_PROPERTY(QString currentValue READ currentValue WRITE setCurrentValue)
 
   public:
     /**
      * \brief Calls base class constructor.
      * \see QmitkDataStorageComboBox
      */
     QmitkDataStorageComboBoxWithSelectNone(QWidget* parent = 0, bool autoSelectNewNodes=false);
 
     /**
      * \brief Calls base class constructor.
      * \see QmitkDataStorageComboBox
      */
     QmitkDataStorageComboBoxWithSelectNone( mitk::DataStorage* _DataStorage,
                                             const mitk::NodePredicateBase* predicate,
                                             QWidget* parent = 0,
                                             bool autoSelectNewNodes=false);
 
     /**
      * \brief Nothing to do.
      * \see QmitkDataStorageComboBox
      */
     ~QmitkDataStorageComboBoxWithSelectNone();
 
     /**
      * \brief Stores the string that will be present on index 0, currently equal to "please select".
      */
     static const QString ZERO_ENTRY_STRING;
 
     /**
      * \brief Searches for a given node, returning the index if found.
      * \param dataNode an mitk::DataNode, can be NULL.
      * \return int -1 if not found, and compared to base class, will add 1 onto the retrieved index.
      */
     virtual int Find( const mitk::DataNode* dataNode ) const;
 
     /**
      * \brief Retrieves the node at a given index, where if index is zero, will always return NULL.
      * \param index An integer between 0 and n = number of nodes.
      * \return mitk::DataNode::Pointer NULL or a data node pointer.
      */
     virtual mitk::DataNode::Pointer GetNode(int index) const;
 
     /**
      * \brief Returns the selected DataNode or NULL if there is none, or the current index is zero.
      */
     virtual mitk::DataNode::Pointer GetSelectedNode() const;
 
     /**
      * \brief Sets the combo box to the index that contains the specified node, or 0 if the node cannot be found.
      */
     virtual void SetSelectedNode(const mitk::DataNode::Pointer& node);
 
     /**
      * \brief Removes a node from the ComboBox at a specified index (if the index exists).
      * Gets called when a DataStorage Remove Event was thrown.
      */
     virtual void RemoveNode(int index);
 
     /**
      * \brief Set a DataNode in the ComboBox at the specified index (if the index exists).
      * Internally the method just calls InsertNode(unsigned int)
      */
     virtual void SetNode(int index, const mitk::DataNode* dataNode);
 
     /**
      * \brief Get the current file path.
      */
     virtual QString currentValue() const;
 
     /**
      * \brief Set the current file path.
      */
     virtual void setCurrentValue(const QString& path);
 
   protected:
 
     /**
      * \brief Checks if the given index is within range.
      */
     bool HasIndex(unsigned int index) const;
 
     /**
      * \brief Inserts a new node at the given index, unless index is 0, which is silently ignored.
      */
     virtual void InsertNode(int index, const mitk::DataNode* dataNode);
 
     /**
      * \brief Reset function whenever datastorage or predicate changes.
      */
     virtual void Reset();
 
   private:
 
     /**
      * \brief This should store the current file path of the current image.
      *
      *
      * The reason is so that we can store and retrieve a temporary file name.
      */
     QString m_CurrentPath;
 };
 
 #endif // QmitkDataStorageComboBoxWithSelectNone_h