diff --git a/Modules/IGTUI/Qmitk/QmitkNDIToolDelegate.cpp b/Modules/IGTUI/Qmitk/QmitkNDIToolDelegate.cpp
index 68e577301e..f8381fc851 100644
--- a/Modules/IGTUI/Qmitk/QmitkNDIToolDelegate.cpp
+++ b/Modules/IGTUI/Qmitk/QmitkNDIToolDelegate.cpp
@@ -1,210 +1,210 @@
 /*============================================================================
 
 The Medical Imaging Interaction Toolkit (MITK)
 
 Copyright (c) German Cancer Research Center (DKFZ)
 All rights reserved.
 
 Use of this source code is governed by a 3-clause BSD license that can be
 found in the LICENSE file.
 
 ============================================================================*/
 
 
 #include "QmitkNDIToolDelegate.h"
 #include <QStringList>
 #include <QComboBox>
 #include <QLabel>
 #include <QFileDialog>
 
 #include "QmitkEnums.h"
 #include "QmitkDataStorageComboBox.h"
 #include "QmitkCustomVariants.h"
 #include "mitkDataStorage.h"
 #include "mitkNodePredicateBase.h"
 #include "QmitkDataStorageComboBox.h"
 #include "mitkNDIPassiveTool.h"
 
 Q_DECLARE_METATYPE(mitk::NDIPassiveTool*)
 
 
 QmitkNDIToolDelegate::QmitkNDIToolDelegate(QObject * parent) : QStyledItemDelegate(parent),
 m_Types(), m_DataStorage(nullptr), m_Predicate(nullptr), m_TagProperty(nullptr), m_TagPropertyName()
 {
 }
 
 
 QWidget* QmitkNDIToolDelegate::createEditor(QWidget *parent, const QStyleOptionViewItem &option, const QModelIndex &index) const
 {
   if (index.isValid() == false)
     return QStyledItemDelegate::createEditor(parent, option, index);
 
   switch (index.column())
   {
   case SROMCol:
     {
       return new QLabel("", parent);
     }
   case TypeCol:
     {
       auto  c = new QComboBox(parent);
       c->addItems(m_Types);
       return c;
     }
   case NodeCol:
     {
       return new QmitkDataStorageComboBox(m_DataStorage, m_Predicate, parent);
     }
   case IndexCol:
   case NameCol:
   case StatusCol:
   default:
     return QStyledItemDelegate::createEditor(parent, option, index);
   }
 }
 
 
 void QmitkNDIToolDelegate::setEditorData(QWidget *editor, const QModelIndex &index) const
 {
   if (index.isValid() == false)
     return;
 
   switch (index.column())
   {
   case SROMCol:
     {
       QLabel* l = qobject_cast<QLabel*>(editor);
       if (l->text().isEmpty())
       {
         QString fileName = index.data(/*mitk::FileNameRole*/).value<QString>();
         fileName = QFileDialog::getOpenFileName(editor, "Open SROM file", fileName, "SROM files (*.rom)");
         QLabel* l = qobject_cast<QLabel*>(editor);
         l->setText(fileName);
       }
       return;
     }
   case TypeCol:
     {
       QString type = index.data(/*mitk::TypeRole*/).value<QString>();
       QComboBox* c = qobject_cast<QComboBox*>(editor);
       c->setCurrentIndex(c->findText(type));
       connect(c, SIGNAL(currentIndexChanged(int)), this, SLOT(ComboBoxCurrentIndexChanged(int)));
       return;
     }
   case NodeCol:
     {
       mitk::DataNode::Pointer n = index.data(/*mitk::OrganNodeRole*/).value<mitk::DataNode::Pointer>();
       if (n.IsNotNull())
       {
         QmitkDataStorageComboBox* dsc = qobject_cast<QmitkDataStorageComboBox*>(editor);
         dsc->setCurrentIndex(dsc->findText(QString::fromStdString(n->GetName())));
         connect(dsc, SIGNAL(currentIndexChanged(int)), this, SLOT(ComboBoxCurrentIndexChanged(int)));
       }
       return;
     }
   case IndexCol:
   case NameCol:
   case StatusCol:
   default:
     QStyledItemDelegate::setEditorData(editor, index);
   }
 }
 
 
 void QmitkNDIToolDelegate::setModelData(QWidget *editor, QAbstractItemModel* model, const QModelIndex &index) const
 {
   if (index.isValid() == false)
     return;
 
   switch (index.column())
   {
   case SROMCol:
     {
       QLabel* l = qobject_cast<QLabel*>(editor);
       //model->setData(index, l->text(), mitk::FileNameRole);
       //model->setData(index, l->text(), Qt::DisplayRole);  // use for display too
       model->setData(index, l->text());  // use for display too
       return;
     }
   case TypeCol:
     {
       QComboBox* c = qobject_cast<QComboBox*>(editor);
       //model->setData(index, c->currentText(), mitk::TypeRole);
       model->setData(index, c->currentText(), Qt::DisplayRole);
       return;
     }
   case NodeCol:
     {
       QmitkDataStorageComboBox* dsc = qobject_cast<QmitkDataStorageComboBox*>(editor);
       if (dsc->GetSelectedNode().IsNotNull())
       {
-        model->setData(index, qVariantFromValue(dsc->GetSelectedNode()), OrganNodeRole);
+        model->setData(index, QVariant::fromValue(dsc->GetSelectedNode()), OrganNodeRole);
         //model->setData(index, QString::fromStdString(dsc->GetSelectedNode()->GetName()), Qt::DisplayRole);
         model->setData(index, QString::fromStdString(dsc->GetSelectedNode()->GetName()));
         if ((m_TagProperty.IsNotNull()) && (m_TagPropertyName.empty() == false))  // tag this node as selected
           dsc->GetSelectedNode()->SetProperty(m_TagPropertyName.c_str(), m_TagProperty);
       }
     }
     return;
   case IndexCol:
   case NameCol:
   case StatusCol:
   default:
     QStyledItemDelegate::setModelData(editor, model, index);
   }
 }
 
 void QmitkNDIToolDelegate::commitAndCloseEditor()
 {
   //QWidget* editor = 0;
   //if(QPushButton *pushBtn = qobject_cast<QPushButton *>(sender()))
   //{
 
   //}
 
   //if(editor)
   //{
     //emit commitData(editor);
     //emit closeEditor(editor);
   //}
 
 }
 
 
 void QmitkNDIToolDelegate::ComboBoxCurrentIndexChanged( int  /*index*/ )
 {
   if(QComboBox *comboBox = qobject_cast<QComboBox *>(sender()))
   {
     emit commitData(comboBox);
     emit closeEditor(comboBox);
   }
 }
 
 
 void QmitkNDIToolDelegate::SetTypes( const QStringList& types )
 {
   m_Types = types;
 }
 
 
 void QmitkNDIToolDelegate::SetDataStorage(mitk::DataStorage* ds)
 {
   m_DataStorage = ds;
 }
 
 
 void QmitkNDIToolDelegate::SetPredicate(mitk::NodePredicateBase::Pointer p)
 {
   m_Predicate = p;
 }
 
 
 void QmitkNDIToolDelegate::SetTagProperty(mitk::BaseProperty::Pointer prop)
 {
   m_TagProperty = prop;
 }
 
 void QmitkNDIToolDelegate::SetTagPropertyName( const std::string& name )
 {
   m_TagPropertyName = name;
 }
diff --git a/Modules/MatchPointRegistrationUI/Qmitk/QmitkMapPropertyDelegate.cpp b/Modules/MatchPointRegistrationUI/Qmitk/QmitkMapPropertyDelegate.cpp
index 22b1ab732e..9d510b60be 100644
--- a/Modules/MatchPointRegistrationUI/Qmitk/QmitkMapPropertyDelegate.cpp
+++ b/Modules/MatchPointRegistrationUI/Qmitk/QmitkMapPropertyDelegate.cpp
@@ -1,270 +1,268 @@
 /*============================================================================
 
 The Medical Imaging Interaction Toolkit (MITK)
 
 Copyright (c) German Cancer Research Center (DKFZ)
 All rights reserved.
 
 Use of this source code is governed by a 3-clause BSD license that can be
 found in the LICENSE file.
 
 ============================================================================*/
 
 #ifndef NOMINMAX
 #define NOMINMAX
 #endif
 
 #include "QmitkMapPropertyDelegate.h"
 
 #include <QmitkCustomVariants.h>
 
 #include <mitkRenderingManager.h>
 
 #include <QApplication>
 #include <QCheckBox>
 #include <QColorDialog>
 #include <QComboBox>
 #include <QDoubleSpinBox>
 #include <QLabel>
 #include <QMessageBox>
 #include <QPainter>
 #include <QPen>
 #include <QPushButton>
 #include <QStringList>
 #include <bitset>
 
 QmitkMapPropertyDelegate::QmitkMapPropertyDelegate(QObject * /*parent*/)
 {
 }
 
 void QmitkMapPropertyDelegate::paint(QPainter *painter,
                                      const QStyleOptionViewItem &option,
                                      const QModelIndex &index) const
 {
   QVariant data = index.data(Qt::DisplayRole);
 
   QString name = data.value<QString>();
 
   QStyledItemDelegate::paint(painter, option, index);
 }
 
 QWidget *QmitkMapPropertyDelegate::createEditor(QWidget *parent,
                                                 const QStyleOptionViewItem &option,
                                                 const QModelIndex &index) const
 {
   QVariant data = index.data(Qt::EditRole);
   QVariant displayData = index.data(Qt::DisplayRole);
   QString name = index.model()->data(index.model()->index(index.row(), index.column() - 1)).value<QString>();
 
   if (data.isValid())
   {
     QWidget *editorWidget = nullptr;
 
     if (data.type() == QVariant::Int)
     {
       QSpinBox *spinBox = new QSpinBox(parent);
       spinBox->setSingleStep(1);
       spinBox->setMinimum(std::numeric_limits<int>::min());
       spinBox->setMaximum(std::numeric_limits<int>::max());
       editorWidget = spinBox;
     }
     // see qt documentation. cast is correct, it would be obsolete if we
     // store doubles
     else if (static_cast<QMetaType::Type>(data.type()) == QMetaType::Float)
     {
       QDoubleSpinBox *spinBox = new QDoubleSpinBox(parent);
       spinBox->setDecimals(5);
       spinBox->setSingleStep(0.1);
       spinBox->setMinimum(std::numeric_limits<float>::min());
       spinBox->setMaximum(std::numeric_limits<float>::max());
 
       editorWidget = spinBox;
     }
     else if (data.type() == QVariant::StringList)
     {
       QStringList entries = data.value<QStringList>();
       QComboBox *comboBox = new QComboBox(parent);
       comboBox->setEditable(false);
       comboBox->addItems(entries);
 
       editorWidget = comboBox;
     }
     else
     {
       editorWidget = QStyledItemDelegate::createEditor(parent, option, index);
     }
 
     if (editorWidget)
     {
       // install event filter
       editorWidget->installEventFilter(const_cast<QmitkMapPropertyDelegate *>(this));
     }
 
     return editorWidget;
   }
   else
     return new QLabel(displayData.toString(), parent);
 }
 
 void QmitkMapPropertyDelegate::setEditorData(QWidget *editor, const QModelIndex &index) const
 {
   QVariant data = index.data(Qt::EditRole);
   QVariant displayData = index.data(Qt::DisplayRole);
 
   std::cout << "Set EDITOR DATA : " << data.toDouble() << std::endl;
 
   if (data.isValid())
   {
     if (data.type() == QVariant::Int)
     {
       QSpinBox *spinBox = qobject_cast<QSpinBox *>(editor);
       spinBox->setValue(data.toInt());
     }
     // see qt documentation. cast is correct, it would be obsolete if we
     // store doubles
     else if (static_cast<QMetaType::Type>(data.type()) == QMetaType::Float)
     {
       QDoubleSpinBox *spinBox = qobject_cast<QDoubleSpinBox *>(editor);
       spinBox->setValue(data.toDouble());
 
       std::cout << "Set EDITOR DATA : " << spinBox->value() << std::endl;
     }
 
     else if (data.type() == QVariant::StringList)
     {
       QComboBox *comboBox = qobject_cast<QComboBox *>(editor);
       QString displayString = displayData.value<QString>();
       comboBox->setCurrentIndex(comboBox->findData(displayString));
     }
 
     else
       return QStyledItemDelegate::setEditorData(editor, index);
   }
 }
 
 void QmitkMapPropertyDelegate::setModelData(QWidget *editor, QAbstractItemModel *model, const QModelIndex &index) const
 {
   QVariant data = index.data(Qt::EditRole);
   QVariant displayData = index.data(Qt::DisplayRole);
 
   if (data.isValid())
   {
     if (data.type() == QVariant::Color)
     {
       QWidget *colorBtn = qobject_cast<QWidget *>(editor);
-      QVariant colorVariant;
-      colorVariant.setValue<QColor>(colorBtn->palette().color(QPalette::Button));
+      auto colorVariant = QVariant::fromValue(colorBtn->palette().color(QPalette::Button));
       model->setData(index, colorVariant);
     }
 
     else if (data.type() == QVariant::Int)
     {
       QSpinBox *spinBox = qobject_cast<QSpinBox *>(editor);
       int intValue = spinBox->value();
 
       QVariant intValueVariant;
       intValueVariant.setValue<float>(static_cast<float>(intValue));
       model->setData(index, intValueVariant);
     }
 
     else if (static_cast<QMetaType::Type>(data.type()) == QMetaType::Float)
     {
       QDoubleSpinBox *spinBox = qobject_cast<QDoubleSpinBox *>(editor);
       double doubleValue = spinBox->value();
 
       std::cout << "SET MODEL DATA << FLOAT : " << doubleValue << std::endl;
 
       QVariant doubleValueVariant;
       doubleValueVariant.setValue<float>(static_cast<float>(doubleValue));
       std::cout << "SET MODEL DATA << Variant : " << doubleValue << std::endl;
       model->setData(index, doubleValueVariant);
     }
 
     else if (data.type() == QVariant::StringList)
     {
       QString displayData = data.value<QString>();
 
       QComboBox *comboBox = qobject_cast<QComboBox *>(editor);
       QString comboBoxValue = comboBox->currentText();
 
-      QVariant comboBoxValueVariant;
-      comboBoxValueVariant.setValue<QString>(comboBoxValue);
+      auto comboBoxValueVariant = QVariant::fromValue(comboBoxValue);
       model->setData(index, comboBoxValueVariant);
     }
 
     else
       QStyledItemDelegate::setModelData(editor, model, index);
   }
 }
 
 void QmitkMapPropertyDelegate::commitAndCloseEditor()
 {
   QWidget *editor = nullptr;
   if (QPushButton *pushBtn = qobject_cast<QPushButton *>(sender()))
   {
     editor = pushBtn;
   }
 
   if (editor)
   {
     emit commitData(editor);
     emit closeEditor(editor);
   }
 }
 
 void QmitkMapPropertyDelegate::updateEditorGeometry(QWidget *editor,
                                                     const QStyleOptionViewItem &option,
                                                     const QModelIndex & /*index*/) const
 {
   editor->setGeometry(option.rect);
 }
 
 void QmitkMapPropertyDelegate::ComboBoxCurrentIndexChanged(int /*index*/)
 {
   if (QComboBox *comboBox = qobject_cast<QComboBox *>(sender()))
   {
     emit commitData(comboBox);
     emit closeEditor(comboBox);
   }
 }
 
 void QmitkMapPropertyDelegate::SpinBoxValueChanged(const QString & /*value*/)
 {
   QAbstractSpinBox *spinBox = nullptr;
   if ((spinBox = qobject_cast<QSpinBox *>(sender())) || (spinBox = qobject_cast<QDoubleSpinBox *>(sender())))
   {
     emit commitData(spinBox);
     emit closeEditor(spinBox);
   }
 }
 
 void QmitkMapPropertyDelegate::showColorDialog()
 {
 }
 
 bool QmitkMapPropertyDelegate::eventFilter(QObject *o, QEvent *e)
 {
   // filter all kind of events on our editor widgets
   // when certain events occur, repaint all render windows, because rendering relevant properties might have changed
   switch (e->type())
   {
     case QEvent::KeyRelease:
     case QEvent::MouseButtonRelease:
     case QEvent::MouseButtonDblClick:
     case QEvent::Wheel:
     case QEvent::FocusIn:
     {
       if (QWidget *editor = dynamic_cast<QWidget *>(o))
       {
         emit commitData(editor);
       }
       break;
     }
     default:
     {
       break;
     }
   }
 
   return false;
 }
diff --git a/Modules/ModelFitUI/Qmitk/QmitkInitialValuesDelegate.cpp b/Modules/ModelFitUI/Qmitk/QmitkInitialValuesDelegate.cpp
index d70a1cc169..8e0bf7122c 100644
--- a/Modules/ModelFitUI/Qmitk/QmitkInitialValuesDelegate.cpp
+++ b/Modules/ModelFitUI/Qmitk/QmitkInitialValuesDelegate.cpp
@@ -1,113 +1,113 @@
 /*============================================================================
 
 The Medical Imaging Interaction Toolkit (MITK)
 
 Copyright (c) German Cancer Research Center (DKFZ)
 All rights reserved.
 
 Use of this source code is governed by a 3-clause BSD license that can be
 found in the LICENSE file.
 
 ============================================================================*/
 
 #include "QmitkInitialValuesDelegate.h"
 
 #include <mitkModelTraitsInterface.h>
 #include <QmitkDataStorageComboBox.h>
 
 #include <QPainter>
 #include <QApplication>
 #include <QLabel>
 #include <QMouseEvent>
 #include <QListWidget>
 
 QmitkInitialValuesDelegate::QmitkInitialValuesDelegate(QObject* /*parent*/) : m_Storage(nullptr), m_Predicate(nullptr)
 {
 }
 
 QWidget* QmitkInitialValuesDelegate::createEditor(QWidget* parent,
     const QStyleOptionViewItem& option
     , const QModelIndex& index) const
 {
   QVariant data = index.data(Qt::EditRole);
 
   if (data.isValid())
   {
     if (valueType(index)==0)
     {
       return QStyledItemDelegate::createEditor(parent, option, index);
     }
     else
     {
       QmitkDataStorageComboBox* box = new QmitkDataStorageComboBox(m_Storage, m_Predicate, parent);
 
       return box;
     }
 
   }
   else
   {
     return new QLabel(data.toString(), parent);
   }
 }
 
 int
 QmitkInitialValuesDelegate::
 valueType(const QModelIndex& index) const
 {
   QVariant data = index.data(Qt::UserRole);
 
   return data.toInt();
 }
 
 void QmitkInitialValuesDelegate::setEditorData(QWidget* editor,
     const QModelIndex& index) const
 {
   QVariant data = index.data(Qt::EditRole);
 
   if (data.isValid())
   {
     if (valueType(index) == 0)
     {
       return QStyledItemDelegate::setEditorData(editor, index);
     }
     else
     {
       QmitkDataStorageComboBox* box = qobject_cast<QmitkDataStorageComboBox*>(editor);
 
       mitk::DataNode *node = static_cast<mitk::DataNode*>(data.value<void*>());
 
       auto index = box->Find(node);
       box->setCurrentIndex(index);
     }
   }
 }
 
 void QmitkInitialValuesDelegate::setModelData(QWidget* editor, QAbstractItemModel* model
     , const QModelIndex& index) const
 {
   QVariant data = index.data(Qt::EditRole);
 
   if (data.isValid() && valueType(index) == 1)
   {
     QmitkDataStorageComboBox* box = qobject_cast<QmitkDataStorageComboBox*>(editor);
-    QVariant newNode = qVariantFromValue<void*>(static_cast<void*>(box->GetSelectedNode().GetPointer()));
+    QVariant newNode = QVariant::fromValue(static_cast<void*>(box->GetSelectedNode().GetPointer()));
     model->setData(index, newNode);
   }
   else
   {
     QStyledItemDelegate::setModelData(editor, model, index);
   }
 }
 
 void QmitkInitialValuesDelegate::
 setDataStorage(mitk::DataStorage* storage)
 {
   this->m_Storage = storage;
 };
 
 void QmitkInitialValuesDelegate::
 setNodePredicate(mitk::NodePredicateBase* predicate)
 {
   this->m_Predicate = predicate;
 };
diff --git a/Modules/QtWidgets/src/QmitkPropertiesTableModel.cpp b/Modules/QtWidgets/src/QmitkPropertiesTableModel.cpp
index 5fd79e13bf..65fe3ad56b 100644
--- a/Modules/QtWidgets/src/QmitkPropertiesTableModel.cpp
+++ b/Modules/QtWidgets/src/QmitkPropertiesTableModel.cpp
@@ -1,530 +1,530 @@
 /*============================================================================
 
 The Medical Imaging Interaction Toolkit (MITK)
 
 Copyright (c) German Cancer Research Center (DKFZ)
 All rights reserved.
 
 Use of this source code is governed by a 3-clause BSD license that can be
 found in the LICENSE file.
 
 ============================================================================*/
 
 #include "QmitkPropertiesTableModel.h"
 
 //# Own includes
 #include "QmitkCustomVariants.h"
 #include "mitkColorProperty.h"
 #include "mitkEnumerationProperty.h"
 #include "mitkProperties.h"
 #include "mitkRenderingManager.h"
 #include "mitkStringProperty.h"
 
 //# Toolkit includes
 #include <QBrush>
 #include <QColor>
 #include <QStringList>
 #include <itkCommand.h>
 
 //# PUBLIC CTORS,DTOR
 QmitkPropertiesTableModel::QmitkPropertiesTableModel(QObject *parent, mitk::PropertyList::Pointer _PropertyList)
   : QAbstractTableModel(parent),
     m_PropertyList(nullptr),
     m_BlockEvents(false),
     m_SortDescending(false),
     m_FilterKeyWord("")
 {
   this->SetPropertyList(_PropertyList);
 }
 
 QmitkPropertiesTableModel::~QmitkPropertiesTableModel()
 {
   // remove all event listeners by setting the property list to 0
   this->SetPropertyList(nullptr);
 }
 
 //# PUBLIC GETTER
 mitk::PropertyList::Pointer QmitkPropertiesTableModel::GetPropertyList() const
 {
   return m_PropertyList.Lock();
 }
 
 Qt::ItemFlags QmitkPropertiesTableModel::flags(const QModelIndex &index) const
 {
   // no editing so far, return default (enabled, selectable)
   Qt::ItemFlags flags = QAbstractItemModel::flags(index);
 
   if (index.column() == PROPERTY_VALUE_COLUMN)
   {
     // there are also read only property items -> do not allow editing them
     if (index.data(Qt::EditRole).isValid())
       flags |= Qt::ItemIsEditable;
 
     if (index.data(Qt::CheckStateRole).isValid())
       flags |= Qt::ItemIsUserCheckable;
   }
 
   return flags;
 }
 
 QVariant QmitkPropertiesTableModel::headerData(int section, Qt::Orientation orientation, int role) const
 {
   if (role != Qt::DisplayRole)
     return QVariant();
 
   if (orientation == Qt::Horizontal)
   {
     switch (section)
     {
       case PROPERTY_NAME_COLUMN:
         return tr("Name");
 
       case PROPERTY_VALUE_COLUMN:
         return tr("Value");
 
       default:
         return QVariant();
     }
   }
 
   return QVariant();
 }
 
 QVariant QmitkPropertiesTableModel::data(const QModelIndex &index, int role) const
 {
   // empty data by default
   QVariant data;
 
   if (!index.isValid() || m_SelectedProperties.empty() || index.row() > (int)(m_SelectedProperties.size() - 1))
     return data;
 
   // the properties name
   if (index.column() == PROPERTY_NAME_COLUMN)
   {
     if (role == Qt::DisplayRole)
       data = QString::fromStdString(m_SelectedProperties[index.row()].first);
   }
   // the real properties value
   else if (index.column() == PROPERTY_VALUE_COLUMN)
   {
     mitk::BaseProperty *baseProp = m_SelectedProperties[index.row()].second;
 
     if (const mitk::ColorProperty *colorProp = dynamic_cast<const mitk::ColorProperty *>(baseProp))
     {
       mitk::Color col = colorProp->GetColor();
       QColor qcol((int)(col.GetRed() * 255), (int)(col.GetGreen() * 255), (int)(col.GetBlue() * 255));
       if (role == Qt::DisplayRole)
-        data.setValue<QColor>(qcol);
+        data.setValue(qcol);
       else if (role == Qt::EditRole)
-        data.setValue<QColor>(qcol);
+        data.setValue(qcol);
     }
 
     else if (mitk::BoolProperty *boolProp = dynamic_cast<mitk::BoolProperty *>(baseProp))
     {
       if (role == Qt::CheckStateRole)
         data = boolProp->GetValue() ? Qt::Checked : Qt::Unchecked;
     }
 
     else if (mitk::StringProperty *stringProp = dynamic_cast<mitk::StringProperty *>(baseProp))
     {
       if (role == Qt::DisplayRole)
         data.setValue<QString>(QString::fromStdString(stringProp->GetValue()));
       else if (role == Qt::EditRole)
         data.setValue<QString>(QString::fromStdString(stringProp->GetValue()));
     }
 
     else if (mitk::IntProperty *intProp = dynamic_cast<mitk::IntProperty *>(baseProp))
     {
       if (role == Qt::DisplayRole)
         data.setValue<int>(intProp->GetValue());
       else if (role == Qt::EditRole)
         data.setValue<int>(intProp->GetValue());
     }
 
     else if (mitk::FloatProperty *floatProp = dynamic_cast<mitk::FloatProperty *>(baseProp))
     {
       if (role == Qt::DisplayRole)
         data.setValue<float>(floatProp->GetValue());
       else if (role == Qt::EditRole)
         data.setValue<float>(floatProp->GetValue());
     }
 
     else if (mitk::EnumerationProperty *enumerationProp = dynamic_cast<mitk::EnumerationProperty *>(baseProp))
     {
       if (role == Qt::DisplayRole)
         data.setValue<QString>(QString::fromStdString(baseProp->GetValueAsString()));
       else if (role == Qt::EditRole)
       {
         QStringList values;
         for (auto it = enumerationProp->Begin(); it != enumerationProp->End(); it++)
         {
           values << QString::fromStdString(it->second);
         }
-        data.setValue<QStringList>(values);
+        data.setValue(values);
       }
     }
 
     else
     {
       if (role == Qt::DisplayRole)
-        data.setValue<QString>(QString::fromStdString(m_SelectedProperties[index.row()].second->GetValueAsString()));
+        data.setValue(QString::fromStdString(m_SelectedProperties[index.row()].second->GetValueAsString()));
     }
   }
 
   return data;
 }
 
 int QmitkPropertiesTableModel::rowCount(const QModelIndex & /*parent*/) const
 {
   // return the number of properties in the properties list.
   return m_SelectedProperties.size();
 }
 
 int QmitkPropertiesTableModel::columnCount(const QModelIndex & /*parent*/) const
 {
   return 2;
 }
 
 //# PUBLIC SETTER
 void QmitkPropertiesTableModel::SetPropertyList(mitk::PropertyList *_PropertyList)
 {
   // if propertylist really changed
   if (m_PropertyList != _PropertyList)
   {
     auto propertyList = m_PropertyList.Lock();
     // Remove delete listener if there was a propertylist before
     if (propertyList.IsNotNull())
       propertyList->RemoveObserver(m_PropertyListDeleteObserverTag);
 
     // set new list
     m_PropertyList = _PropertyList;
     propertyList = m_PropertyList.Lock();
 
     if (propertyList.IsNotNull())
     {
       auto command = itk::SimpleMemberCommand<QmitkPropertiesTableModel>::New();
       command->SetCallbackFunction(this, &QmitkPropertiesTableModel::PropertyListDelete);
       m_PropertyListDeleteObserverTag = propertyList->AddObserver(itk::DeleteEvent(), command);
     }
     this->Reset();
   }
 }
 
 void QmitkPropertiesTableModel::PropertyListDelete()
 {
   if (!m_BlockEvents)
   {
     m_BlockEvents = true;
     this->Reset();
     m_BlockEvents = false;
   }
 }
 
 void QmitkPropertiesTableModel::PropertyModified(const itk::Object *caller, const itk::EventObject & /*event*/)
 {
   if (!m_BlockEvents)
   {
     m_BlockEvents = true;
     int row = this->FindProperty(dynamic_cast<const mitk::BaseProperty *>(caller));
 
     QModelIndex indexOfChangedProperty = index(row, 1);
 
     emit dataChanged(indexOfChangedProperty, indexOfChangedProperty);
     m_BlockEvents = false;
   }
 }
 
 void QmitkPropertiesTableModel::PropertyDelete(const itk::Object *caller, const itk::EventObject & /*event*/)
 {
   if (!m_BlockEvents)
   {
     m_BlockEvents = true;
     int row = this->FindProperty(dynamic_cast<const mitk::BaseProperty *>(caller));
     if (row >= 0)
       this->Reset();
     m_BlockEvents = false;
   }
 }
 
 bool QmitkPropertiesTableModel::setData(const QModelIndex &index, const QVariant &value, int role)
 {
   // TODO: check 'role' condition
   if (index.isValid() && !m_SelectedProperties.empty() && index.row() < (int)(m_SelectedProperties.size()) &&
       (role == Qt::EditRole || role == Qt::CheckStateRole))
   {
     // block all events now!
     m_BlockEvents = true;
 
     auto propertyList = m_PropertyList.Lock();
 
     // the properties name
     if (index.column() == PROPERTY_VALUE_COLUMN)
     {
       mitk::BaseProperty *baseProp = m_SelectedProperties[index.row()].second;
 
       if (mitk::ColorProperty *colorProp = dynamic_cast<mitk::ColorProperty *>(baseProp))
       {
         QColor qcolor = value.value<QColor>();
         if (!qcolor.isValid())
           return false;
 
         mitk::Color col = colorProp->GetColor();
         col.SetRed(qcolor.red() / 255.0);
         col.SetGreen(qcolor.green() / 255.0);
         col.SetBlue(qcolor.blue() / 255.0);
         colorProp->SetColor(col);
         propertyList->InvokeEvent(itk::ModifiedEvent());
         propertyList->Modified();
 
         mitk::RenderingManager::GetInstance()->RequestUpdateAll();
       }
 
       else if (mitk::BoolProperty *boolProp = dynamic_cast<mitk::BoolProperty *>(baseProp))
       {
         boolProp->SetValue(value.toInt() == Qt::Checked ? true : false);
         propertyList->InvokeEvent(itk::ModifiedEvent());
         propertyList->Modified();
 
         mitk::RenderingManager::GetInstance()->RequestUpdateAll();
       }
 
       else if (mitk::StringProperty *stringProp = dynamic_cast<mitk::StringProperty *>(baseProp))
       {
         stringProp->SetValue((value.value<QString>()).toStdString());
         propertyList->InvokeEvent(itk::ModifiedEvent());
         propertyList->Modified();
 
         mitk::RenderingManager::GetInstance()->RequestUpdateAll();
       }
 
       else if (mitk::IntProperty *intProp = dynamic_cast<mitk::IntProperty *>(baseProp))
       {
         int intValue = value.value<int>();
         if (intValue != intProp->GetValue())
         {
           intProp->SetValue(intValue);
           propertyList->InvokeEvent(itk::ModifiedEvent());
           propertyList->Modified();
 
           mitk::RenderingManager::GetInstance()->RequestUpdateAll();
         }
       }
 
       else if (mitk::FloatProperty *floatProp = dynamic_cast<mitk::FloatProperty *>(baseProp))
       {
         float floatValue = value.value<float>();
         if (floatValue != floatProp->GetValue())
         {
           floatProp->SetValue(floatValue);
           propertyList->InvokeEvent(itk::ModifiedEvent());
           propertyList->Modified();
 
           mitk::RenderingManager::GetInstance()->RequestUpdateAll();
         }
       }
 
       else if (mitk::EnumerationProperty *enumerationProp = dynamic_cast<mitk::EnumerationProperty *>(baseProp))
       {
         std::string activatedItem = value.value<QString>().toStdString();
         if (activatedItem != enumerationProp->GetValueAsString())
         {
           if (enumerationProp->IsValidEnumerationValue(activatedItem))
           {
             enumerationProp->SetValue(activatedItem);
             propertyList->InvokeEvent(itk::ModifiedEvent());
             propertyList->Modified();
 
             mitk::RenderingManager::GetInstance()->RequestUpdateAll();
           }
         }
       }
     }
 
     // property was changed by us, now we can accept property changes triggered by someone else
     m_BlockEvents = false;
     emit dataChanged(index, index);
     return true;
   }
 
   return false;
 }
 
 void QmitkPropertiesTableModel::sort(int column, Qt::SortOrder order /*= Qt::AscendingOrder */)
 {
   bool sortDescending = (order == Qt::DescendingOrder) ? true : false;
 
   // do not sort twice !!! (dont know why, but qt calls this func twice. STUPID!)
   if (sortDescending != m_SortDescending)
   {
     m_SortDescending = sortDescending;
 
     PropertyDataSetCompareFunction::CompareCriteria _CompareCriteria = PropertyDataSetCompareFunction::CompareByName;
 
     PropertyDataSetCompareFunction::CompareOperator _CompareOperator =
       m_SortDescending ? PropertyDataSetCompareFunction::Greater : PropertyDataSetCompareFunction::Less;
 
     if (column == PROPERTY_VALUE_COLUMN)
       _CompareCriteria = PropertyDataSetCompareFunction::CompareByValue;
 
     PropertyDataSetCompareFunction compareFunc(_CompareCriteria, _CompareOperator);
     std::sort(m_SelectedProperties.begin(), m_SelectedProperties.end(), compareFunc);
 
     QAbstractTableModel::beginResetModel();
     QAbstractTableModel::endResetModel();
   }
 }
 
 //# PROTECTED GETTER
 int QmitkPropertiesTableModel::FindProperty(const mitk::BaseProperty *_Property) const
 {
   int row = -1;
 
   if (_Property)
   {
     // search for property that changed and emit datachanged on the corresponding ModelIndex
     std::vector<PropertyDataSet>::const_iterator propertyIterator;
 
     for (propertyIterator = m_SelectedProperties.begin(); propertyIterator != m_SelectedProperties.end();
          propertyIterator++)
     {
       if (propertyIterator->second == _Property)
         break;
     }
 
     if (propertyIterator != m_SelectedProperties.end())
       row = std::distance(m_SelectedProperties.begin(), propertyIterator);
   }
 
   return row;
 }
 
 //# PROTECTED SETTER
 void QmitkPropertiesTableModel::AddSelectedProperty(PropertyDataSet &_PropertyDataSet)
 {
   // subscribe for modified event
   itk::MemberCommand<QmitkPropertiesTableModel>::Pointer _PropertyDataSetModifiedCommand =
     itk::MemberCommand<QmitkPropertiesTableModel>::New();
   _PropertyDataSetModifiedCommand->SetCallbackFunction(this, &QmitkPropertiesTableModel::PropertyModified);
   m_PropertyModifiedObserverTags.push_back(
     _PropertyDataSet.second->AddObserver(itk::ModifiedEvent(), _PropertyDataSetModifiedCommand));
 
   // subscribe for delete event
   itk::MemberCommand<QmitkPropertiesTableModel>::Pointer _PropertyDataSetDeleteCommand =
     itk::MemberCommand<QmitkPropertiesTableModel>::New();
   _PropertyDataSetDeleteCommand->SetCallbackFunction(this, &QmitkPropertiesTableModel::PropertyDelete);
   m_PropertyDeleteObserverTags.push_back(
     _PropertyDataSet.second->AddObserver(itk::DeleteEvent(), _PropertyDataSetDeleteCommand));
 
   // add to the selection
   m_SelectedProperties.push_back(_PropertyDataSet);
 }
 
 void QmitkPropertiesTableModel::RemoveSelectedProperty(unsigned int _Index)
 {
   PropertyDataSet &_PropertyDataSet = m_SelectedProperties.at(_Index);
 
   // remove modified event listener
   _PropertyDataSet.second->RemoveObserver(m_PropertyModifiedObserverTags[_Index]);
   m_PropertyModifiedObserverTags.erase(m_PropertyModifiedObserverTags.begin() + _Index);
   // remove delete event listener
   _PropertyDataSet.second->RemoveObserver(m_PropertyDeleteObserverTags[_Index]);
   m_PropertyDeleteObserverTags.erase(m_PropertyDeleteObserverTags.begin() + _Index);
   // remove from selection
   m_SelectedProperties.erase(m_SelectedProperties.begin() + _Index);
 }
 
 void QmitkPropertiesTableModel::Reset()
 {
   // remove all selected properties
   while (!m_SelectedProperties.empty())
   {
     this->RemoveSelectedProperty(m_SelectedProperties.size() - 1);
   }
 
   std::vector<PropertyDataSet> allPredicates;
   auto propertyList = m_PropertyList.Lock();
 
   if (propertyList.IsNotNull())
   {
     // first of all: collect all properties from the list
     for (auto it = propertyList->GetMap()->begin(); it != propertyList->GetMap()->end(); it++)
     {
       allPredicates.push_back(*it); //% TODO
     }
   }
   // make a subselection if a keyword is specified
   if (!m_FilterKeyWord.empty())
   {
     std::vector<PropertyDataSet> subSelection;
 
     for (auto it = allPredicates.begin(); it != allPredicates.end(); it++)
     {
       // add this to the selection if it is matched by the keyword
       if ((*it).first.find(m_FilterKeyWord) != std::string::npos)
         subSelection.push_back((*it));
     }
     allPredicates.clear();
     allPredicates = subSelection;
   }
 
   PropertyDataSet tmpPropertyDataSet;
   // add all selected now to the Model
   for (auto it = allPredicates.begin(); it != allPredicates.end(); it++)
   {
     tmpPropertyDataSet = *it;
     this->AddSelectedProperty(tmpPropertyDataSet);
   }
 
   // sort the list as indicated by m_SortDescending
   this->sort(m_SortDescending);
 
   // model was resetted
   QAbstractTableModel::beginResetModel();
   QAbstractTableModel::endResetModel();
 }
 
 void QmitkPropertiesTableModel::SetFilterPropertiesKeyWord(std::string _FilterKeyWord)
 {
   m_FilterKeyWord = _FilterKeyWord;
   this->Reset();
 }
 
 QmitkPropertiesTableModel::PropertyDataSetCompareFunction::PropertyDataSetCompareFunction(
   CompareCriteria _CompareCriteria, CompareOperator _CompareOperator)
   : m_CompareCriteria(_CompareCriteria), m_CompareOperator(_CompareOperator)
 {
 }
 
 bool QmitkPropertiesTableModel::PropertyDataSetCompareFunction::operator()(const PropertyDataSet &_Left,
                                                                            const PropertyDataSet &_Right) const
 {
   switch (m_CompareCriteria)
   {
     case CompareByValue:
       if (m_CompareOperator == Less)
         return (_Left.second->GetValueAsString() < _Right.second->GetValueAsString());
       else
         return (_Left.second->GetValueAsString() > _Right.second->GetValueAsString());
       break;
 
     // CompareByName:
     default:
       if (m_CompareOperator == Less)
         return (_Left.first < _Right.first);
       else
         return (_Left.first > _Right.first);
       break;
   }
 }
 QmitkPropertiesTableModel::PropertyListElementFilterFunction::PropertyListElementFilterFunction(
   const std::string &_FilterKeyWord)
   : m_FilterKeyWord(_FilterKeyWord)
 {
 }
 
 bool QmitkPropertiesTableModel::PropertyListElementFilterFunction::operator()(const PropertyDataSet &_Elem) const
 {
   if (m_FilterKeyWord.empty())
     return true;
   return (_Elem.first.find(m_FilterKeyWord) == 0);
 }
diff --git a/Modules/QtWidgets/src/QmitkPropertyDelegate.cpp b/Modules/QtWidgets/src/QmitkPropertyDelegate.cpp
index 991f374238..ca972a3729 100644
--- a/Modules/QtWidgets/src/QmitkPropertyDelegate.cpp
+++ b/Modules/QtWidgets/src/QmitkPropertyDelegate.cpp
@@ -1,320 +1,320 @@
 /*============================================================================
 
 The Medical Imaging Interaction Toolkit (MITK)
 
 Copyright (c) German Cancer Research Center (DKFZ)
 All rights reserved.
 
 Use of this source code is governed by a 3-clause BSD license that can be
 found in the LICENSE file.
 
 ============================================================================*/
 
 #ifndef NOMINMAX
 #define NOMINMAX
 #endif
 
 #include "QmitkPropertyDelegate.h"
 
 #include "QmitkCustomVariants.h"
 
 #include "mitkRenderingManager.h"
 
 #include <QApplication>
 #include <QCheckBox>
 #include <QColorDialog>
 #include <QComboBox>
 #include <QDoubleSpinBox>
 #include <QLabel>
 #include <QMessageBox>
 #include <QPainter>
 #include <QPen>
 #include <QPushButton>
 #include <QStringList>
 #include <bitset>
 
 QmitkPropertyDelegate::QmitkPropertyDelegate(QObject * /*parent*/)
 {
 }
 
 void QmitkPropertyDelegate::paint(QPainter *painter, const QStyleOptionViewItem &option, const QModelIndex &index) const
 {
   QVariant data = index.data(Qt::DisplayRole);
 
   QString name = data.value<QString>();
 
   if (index.column() == 1 && data.type() == QVariant::Color)
   {
     QColor qcol = data.value<QColor>();
 
     painter->save();
     painter->fillRect(option.rect, qcol);
     QRect rect = option.rect;
     rect.setWidth(rect.width() - 1);
     rect.setHeight(rect.height() - 1);
     QPen pen;
     pen.setWidth(1);
     painter->setPen(pen);
     painter->drawRect(rect);
     painter->restore();
   }
   else
   {
     QStyledItemDelegate::paint(painter, option, index);
   }
 }
 
 QWidget *QmitkPropertyDelegate::createEditor(QWidget *parent,
                                              const QStyleOptionViewItem &option,
                                              const QModelIndex &index) const
 {
   QVariant data = index.data(Qt::EditRole);
   QVariant displayData = index.data(Qt::DisplayRole);
   QString name = index.model()->data(index.model()->index(index.row(), index.column() - 1)).value<QString>();
 
   if (data.isValid())
   {
     QWidget *editorWidget = nullptr;
 
     if (data.type() == QVariant::Color)
     {
       auto colorBtn = new QPushButton(parent);
       QColor color = data.value<QColor>();
 
       QColor result = QColorDialog::getColor(color);
       if (result.isValid())
       {
         QPalette palette = colorBtn->palette();
         palette.setColor(QPalette::Button, result);
         colorBtn->setPalette(palette);
         colorBtn->setStyleSheet(
           QString("background-color: %1;foreground-color: %1; border-style: none;").arg(result.name()));
       }
       // QColorDialog closed by 'Cancel' button, use the old property color
       else
       {
         QPalette palette = colorBtn->palette();
         palette.setColor(QPalette::Button, color);
         colorBtn->setPalette(palette);
         colorBtn->setStyleSheet(
           QString("background-color: %1;foreground-color: %1; border-style: none;").arg(color.name()));
       }
 
       connect(colorBtn, SIGNAL(pressed()), this, SLOT(commitAndCloseEditor()));
 
       editorWidget = colorBtn;
     }
 
     else if (data.type() == QVariant::Int)
     {
       auto spinBox = new QSpinBox(parent);
       spinBox->setSingleStep(1);
       spinBox->setMinimum(std::numeric_limits<int>::min());
       spinBox->setMaximum(std::numeric_limits<int>::max());
       editorWidget = spinBox;
     }
     // see qt documentation. cast is correct, it would be obsolete if we
     // store doubles
     else if (static_cast<QMetaType::Type>(data.type()) == QMetaType::Float)
     {
       auto spinBox = new QDoubleSpinBox(parent);
       spinBox->setDecimals(2);
       spinBox->setSingleStep(0.1);
       if (name == "opacity")
       {
         spinBox->setMinimum(0.0);
         spinBox->setMaximum(1.0);
       }
       else
       {
         spinBox->setMinimum(std::numeric_limits<float>::min());
         spinBox->setMaximum(std::numeric_limits<float>::max());
       }
 
       editorWidget = spinBox;
     }
 
     else if (data.type() == QVariant::StringList)
     {
       QStringList entries = data.value<QStringList>();
       auto comboBox = new QComboBox(parent);
       comboBox->setEditable(false);
       comboBox->addItems(entries);
 
       editorWidget = comboBox;
     }
 
     else
     {
       editorWidget = QStyledItemDelegate::createEditor(parent, option, index);
     }
 
     if (editorWidget)
     {
       // install event filter
       editorWidget->installEventFilter(const_cast<QmitkPropertyDelegate *>(this));
     }
 
     return editorWidget;
   }
   else
     return new QLabel(displayData.toString(), parent);
 }
 
 void QmitkPropertyDelegate::setEditorData(QWidget *editor, const QModelIndex &index) const
 {
   QVariant data = index.data(Qt::EditRole);
   QVariant displayData = index.data(Qt::DisplayRole);
 
   if (data.isValid())
   {
     if (data.type() == QVariant::Int)
     {
       QSpinBox *spinBox = qobject_cast<QSpinBox *>(editor);
       spinBox->setValue(data.toInt());
     }
     // see qt documentation. cast is correct, it would be obsolete if we
     // store doubles
     else if (static_cast<QMetaType::Type>(data.type()) == QMetaType::Float)
     {
       QDoubleSpinBox *spinBox = qobject_cast<QDoubleSpinBox *>(editor);
       spinBox->setValue(data.toDouble());
     }
 
     else if (data.type() == QVariant::StringList)
     {
       QComboBox *comboBox = qobject_cast<QComboBox *>(editor);
       QString displayString = displayData.value<QString>();
       comboBox->setCurrentIndex(comboBox->findData(displayString));
     }
 
     else
       return QStyledItemDelegate::setEditorData(editor, index);
   }
 }
 
 void QmitkPropertyDelegate::setModelData(QWidget *editor, QAbstractItemModel *model, const QModelIndex &index) const
 {
   QVariant data = index.data(Qt::EditRole);
   QVariant displayData = index.data(Qt::DisplayRole);
 
   if (data.isValid())
   {
     if (data.type() == QVariant::Color)
     {
       QWidget *colorBtn = qobject_cast<QWidget *>(editor);
       QVariant colorVariant;
-      colorVariant.setValue<QColor>(colorBtn->palette().color(QPalette::Button));
+      colorVariant.setValue(colorBtn->palette().color(QPalette::Button));
       model->setData(index, colorVariant);
     }
 
     else if (data.type() == QVariant::Int)
     {
       QSpinBox *spinBox = qobject_cast<QSpinBox *>(editor);
       int intValue = spinBox->value();
 
       QVariant intValueVariant;
       intValueVariant.setValue<float>(static_cast<float>(intValue));
       model->setData(index, intValueVariant);
     }
 
     else if (static_cast<QMetaType::Type>(data.type()) == QMetaType::Float)
     {
       QDoubleSpinBox *spinBox = qobject_cast<QDoubleSpinBox *>(editor);
       double doubleValue = spinBox->value();
 
       QVariant doubleValueVariant;
       doubleValueVariant.setValue<float>(static_cast<float>(doubleValue));
       model->setData(index, doubleValueVariant);
     }
 
     else if (data.type() == QVariant::StringList)
     {
       QString displayData = data.value<QString>();
 
       QComboBox *comboBox = qobject_cast<QComboBox *>(editor);
       QString comboBoxValue = comboBox->currentText();
 
       QVariant comboBoxValueVariant;
-      comboBoxValueVariant.setValue<QString>(comboBoxValue);
+      comboBoxValueVariant.setValue(comboBoxValue);
       model->setData(index, comboBoxValueVariant);
     }
 
     else
       QStyledItemDelegate::setModelData(editor, model, index);
   }
 }
 
 void QmitkPropertyDelegate::commitAndCloseEditor()
 {
   QWidget *editor = nullptr;
   if (QPushButton *pushBtn = qobject_cast<QPushButton *>(sender()))
   {
     editor = pushBtn;
   }
 
   if (editor)
   {
     emit commitData(editor);
     emit closeEditor(editor);
   }
 }
 
 void QmitkPropertyDelegate::updateEditorGeometry(QWidget *editor,
                                                  const QStyleOptionViewItem &option,
                                                  const QModelIndex & /*index*/) const
 {
   editor->setGeometry(option.rect);
 }
 
 void QmitkPropertyDelegate::ComboBoxCurrentIndexChanged(int /*index*/)
 {
   if (QComboBox *comboBox = qobject_cast<QComboBox *>(sender()))
   {
     emit commitData(comboBox);
     emit closeEditor(comboBox);
   }
 }
 
 void QmitkPropertyDelegate::SpinBoxValueChanged(const QString & /*value*/)
 {
   QAbstractSpinBox *spinBox = nullptr;
   if ((spinBox = qobject_cast<QSpinBox *>(sender())) || (spinBox = qobject_cast<QDoubleSpinBox *>(sender())))
   {
     emit commitData(spinBox);
     emit closeEditor(spinBox);
   }
 }
 
 void QmitkPropertyDelegate::showColorDialog()
 {
 }
 
 bool QmitkPropertyDelegate::eventFilter(QObject *o, QEvent *e)
 {
   // filter all kind of events on our editor widgets
   // when certain events occur, repaint all render windows, because rendering relevant properties might have changed
   switch (e->type())
   {
     case QEvent::KeyRelease:
     case QEvent::MouseButtonRelease:
     case QEvent::MouseButtonDblClick:
     case QEvent::Wheel:
     case QEvent::FocusIn:
     {
       if (QWidget *editor = dynamic_cast<QWidget *>(o))
       {
         emit commitData(editor);
       }
 
       mitk::RenderingManager::GetInstance()->RequestUpdateAll();
       break;
     }
     default:
     {
       break;
     }
   }
 
   return false;
 }
diff --git a/Plugins/org.blueberry.ui.qt/src/internal/berryQtControlWidget.cpp b/Plugins/org.blueberry.ui.qt/src/internal/berryQtControlWidget.cpp
index aaa76a78b4..15456536a5 100755
--- a/Plugins/org.blueberry.ui.qt/src/internal/berryQtControlWidget.cpp
+++ b/Plugins/org.blueberry.ui.qt/src/internal/berryQtControlWidget.cpp
@@ -1,157 +1,156 @@
 /*============================================================================
 
 The Medical Imaging Interaction Toolkit (MITK)
 
 Copyright (c) German Cancer Research Center (DKFZ)
 All rights reserved.
 
 Use of this source code is governed by a 3-clause BSD license that can be
 found in the LICENSE file.
 
 ============================================================================*/
 
 #include "berryLog.h"
 
 #include "berryQtControlWidget.h"
 
 #include <berryShell.h>
 
 #include <QMoveEvent>
 #include <QResizeEvent>
 
 #include <algorithm>
 
 namespace berry {
 
 QtControlWidget::QtControlWidget(QWidget* parent, Shell* shell, Qt::WindowFlags f)
  : QFrame(parent, f)
 {
   controller = new QtWidgetController(shell);
 
   this->setFrameStyle(QFrame::NoFrame);
 
   // TODO WeakPointer: QVariant should hold a weak pointer
-  QVariant variant(QVariant::UserType);
-  variant.setValue(controller);
+  auto variant = QVariant::fromValue(controller);
   this->setProperty(QtWidgetController::PROPERTY_ID, variant);
 }
 
 QtControlWidget::~QtControlWidget()
 {
   GuiTk::ControlEvent::Pointer controlEvent(new GuiTk::ControlEvent(static_cast<QWidget*>(this)));
   controller->controlEvents.destroyedEvent(controlEvent);
 }
 
 void QtControlWidget::changeEvent(QEvent* event)
 {
   typedef IShellListener::Events::ShellEventType::ListenerList ListenerList;
 
   switch (event->type())
   {
   case QEvent::WindowActivate:
   {
       ShellEvent::Pointer shellEvent(new ShellEvent(Shell::Pointer(controller->shell)));
     ListenerList activatedListeners(controller->shellEvents.shellActivated.GetListeners());
     for (auto listener = activatedListeners.begin();
          listener != activatedListeners.end(); ++listener)
     {
       (*listener)->Execute(shellEvent);
       if (!shellEvent->doit) {
         event->accept();
         return;
       }
     }
   }
     break;
   case QEvent::WindowDeactivate:
   {
       ShellEvent::Pointer shellEvent(new ShellEvent(Shell::Pointer(controller->shell)));
     ListenerList deactivatedListeners(controller->shellEvents.shellDeactivated.GetListeners());
     for (auto listener = deactivatedListeners.begin();
          listener != deactivatedListeners.end(); ++listener)
     {
       (*listener)->Execute(shellEvent);
       if (!shellEvent->doit) {
         event->accept();
         return;
       }
     }
   }
     break;
   case QEvent::WindowStateChange:
   {
       ShellEvent::Pointer shellEvent(new ShellEvent(Shell::Pointer(controller->shell)));
     QWindowStateChangeEvent* stateEvent = dynamic_cast<QWindowStateChangeEvent*>(event);
     Qt::WindowStates oldState = stateEvent->oldState();
     if (this->isMinimized() && !(oldState & Qt::WindowMinimized))
     {
       ListenerList iconifiedListeners(controller->shellEvents.shellIconified.GetListeners());
       for (auto listener = iconifiedListeners.begin();
          listener != iconifiedListeners.end(); ++listener)
       {
         (*listener)->Execute(shellEvent);
         if (!shellEvent->doit) {
           event->accept();
           return;
         }
       }
     }
     else if (oldState & Qt::WindowMinimized && !this->isMinimized())
     {
       ListenerList deiconifiedListeners(controller->shellEvents.shellDeiconified.GetListeners());
       for (auto listener = deiconifiedListeners.begin();
          listener != deiconifiedListeners.end(); ++listener)
       {
         (*listener)->Execute(shellEvent);
         if (!shellEvent->doit) return;
       }
     }
   }
     break;
   default:
     break;
   }
 
   QFrame::changeEvent(event);
 }
 
 void QtControlWidget::closeEvent(QCloseEvent* event)
 {
   typedef IShellListener::Events::ShellEventType::ListenerList ListenerList;
 
   ShellEvent::Pointer shellEvent(new ShellEvent(Shell::Pointer(controller->shell)));
 
   ListenerList closedListeners(controller->shellEvents.shellClosed.GetListeners());
   for (auto listener = closedListeners.begin();
        listener != closedListeners.end(); ++listener)
   {
     (*listener)->Execute(shellEvent);
     if (!shellEvent->doit) {
       //event->accept();
       return;
     }
   }
 
   event->accept();
 }
 
 void QtControlWidget::moveEvent(QMoveEvent* event)
 {
   GuiTk::ControlEvent::Pointer controlEvent(new GuiTk::ControlEvent(static_cast<QWidget*>(this), event->pos().x(), event->pos().y()));
   controller->controlEvents.movedEvent(controlEvent);
 }
 
 void QtControlWidget::resizeEvent(QResizeEvent* event)
 {
   GuiTk::ControlEvent::Pointer controlEvent(new GuiTk::ControlEvent(static_cast<QWidget*>(this), 0, 0, event->size().width(), event->size().height()));
   controller->controlEvents.resizedEvent(controlEvent);
 }
 
 void QtControlWidget::FireActivateEvent()
 {
   GuiTk::ControlEvent::Pointer controlEvent(new GuiTk::ControlEvent(static_cast<QWidget*>(this)));
   controller->controlEvents.activatedEvent(controlEvent);
 }
 
 
 }
diff --git a/Plugins/org.blueberry.ui.qt/src/internal/berryQtMainWindowControl.cpp b/Plugins/org.blueberry.ui.qt/src/internal/berryQtMainWindowControl.cpp
index 9b752e30bb..6f3545ecac 100755
--- a/Plugins/org.blueberry.ui.qt/src/internal/berryQtMainWindowControl.cpp
+++ b/Plugins/org.blueberry.ui.qt/src/internal/berryQtMainWindowControl.cpp
@@ -1,151 +1,150 @@
 /*============================================================================
 
 The Medical Imaging Interaction Toolkit (MITK)
 
 Copyright (c) German Cancer Research Center (DKFZ)
 All rights reserved.
 
 Use of this source code is governed by a 3-clause BSD license that can be
 found in the LICENSE file.
 
 ============================================================================*/
 
 #include "berryQtMainWindowControl.h"
 
 #include <berryShell.h>
 
 #include <QEvent>
 #include <QMoveEvent>
 #include <QResizeEvent>
 #include <QWindowStateChangeEvent>
 
 namespace berry {
 
 QtMainWindowControl::QtMainWindowControl(Shell* shell, QWidget* parent, Qt::WindowFlags flags)
  : QMainWindow(parent, flags)
 {
   controller = new QtWidgetController(shell);
 
   // TODO WeakPointer: QVariant should hold a weak pointer
-  QVariant variant(QVariant::UserType);
-  variant.setValue(controller);
+  auto variant = QVariant::fromValue(controller);
   this->setProperty(QtWidgetController::PROPERTY_ID, variant);
 }
 
 void QtMainWindowControl::changeEvent(QEvent* event)
 {
   if (!controller->shell)
     return QMainWindow::changeEvent(event);
 
   typedef IShellListener::Events::ShellEventType::ListenerList ListenerList;
   ShellEvent::Pointer shellEvent(new ShellEvent(Shell::Pointer(controller->shell)));
   switch (event->type())
   {
   case QEvent::ActivationChange:
   {
     if (isActiveWindow())
     {
       ListenerList activatedListeners(controller->shellEvents.shellActivated.GetListeners());
       for (auto listener = activatedListeners.begin();
            listener != activatedListeners.end(); ++listener)
       {
         (*listener)->Execute(shellEvent);
         if (!shellEvent->doit) {
           event->accept();
           return;
         }
       }
     }
     else
     {
       ListenerList deactivatedListeners(controller->shellEvents.shellDeactivated.GetListeners());
       for (auto listener = deactivatedListeners.begin();
            listener != deactivatedListeners.end(); ++listener)
       {
         (*listener)->Execute(shellEvent);
         if (!shellEvent->doit) {
           event->accept();
           return;
         }
       }
     }
   }
     break;
   case QEvent::WindowStateChange:
   {
     QWindowStateChangeEvent* stateEvent = dynamic_cast<QWindowStateChangeEvent*>(event);
     Qt::WindowStates oldState = stateEvent->oldState();
     if (this->isMinimized() && !(oldState & Qt::WindowMinimized))
     {
       ListenerList iconifiedListeners(controller->shellEvents.shellIconified.GetListeners());
       for (auto listener = iconifiedListeners.begin();
          listener != iconifiedListeners.end(); ++listener)
       {
         (*listener)->Execute(shellEvent);
         if (!shellEvent->doit) {
           event->accept();
           return;
         }
       }
     }
     else if (oldState & Qt::WindowMinimized && !this->isMinimized())
     {
       ListenerList deiconifiedListeners(controller->shellEvents.shellDeiconified.GetListeners());
       for (auto listener = deiconifiedListeners.begin();
          listener != deiconifiedListeners.end(); ++listener)
       {
         (*listener)->Execute(shellEvent);
         if (!shellEvent->doit) return;
       }
     }
   }
     break;
   default:
     break;
   }
 
   QMainWindow::changeEvent(event);
 }
 
 void QtMainWindowControl::closeEvent(QCloseEvent* event)
 {
   if (!controller->shell)
     return QMainWindow::changeEvent(event);
 
   typedef IShellListener::Events::ShellEventType::ListenerList ListenerList;
 
   ShellEvent::Pointer shellEvent(new ShellEvent(Shell::Pointer(controller->shell)));
 
   ListenerList closedListeners(controller->shellEvents.shellClosed.GetListeners());
   for (auto listener = closedListeners.begin();
        listener != closedListeners.end(); ++listener)
   {
     (*listener)->Execute(shellEvent);
     if (!shellEvent->doit) {
       event->ignore();
       return;
     }
   }
 
   QMainWindow::closeEvent(event);
 }
 
 void QtMainWindowControl::moveEvent(QMoveEvent* event)
 {
   GuiTk::ControlEvent::Pointer controlEvent(new GuiTk::ControlEvent(this, event->pos().x(), event->pos().y()));
   controller->controlEvents.movedEvent(controlEvent);
 }
 
 void QtMainWindowControl::resizeEvent(QResizeEvent* event)
 {
   GuiTk::ControlEvent::Pointer controlEvent(new GuiTk::ControlEvent(this, 0, 0, event->size().width(), event->size().height()));
   controller->controlEvents.resizedEvent(controlEvent);
 }
 
 void QtMainWindowControl::inFocusEvent(QFocusEvent* /*event*/)
 {
   GuiTk::ControlEvent::Pointer controlEvent(new GuiTk::ControlEvent(this));
   controller->controlEvents.activatedEvent(controlEvent);
 }
 
 }