diff --git a/Modules/Core/include/mitkCoreServices.h b/Modules/Core/include/mitkCoreServices.h
index f32ec04b61..1e3f179acd 100644
--- a/Modules/Core/include/mitkCoreServices.h
+++ b/Modules/Core/include/mitkCoreServices.h
@@ -1,170 +1,177 @@
 /*============================================================================
 
 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 MITKCORESERVICES_H
 #define MITKCORESERVICES_H
 
 #include "MitkCoreExports.h"
 
 #include <mitkCommon.h>
 #include <mitkLogMacros.h>
 
 #include <mitkServiceInterface.h>
 #include <usGetModuleContext.h>
 #include <usModuleContext.h>
 #include <usServiceReference.h>
 
 #include <cassert>
 
 namespace mitk
 {
   struct IMimeTypeProvider;
   class IPropertyAliases;
   class IPropertyDescriptions;
   class IPropertyExtensions;
   class IPropertyFilters;
   class IPropertyPersistence;
   class IPropertyRelations;
 
   /**
    * @brief Access MITK core services.
    *
    * This class can be used to conveniently access common
    * MITK Core service objects. Some getter methods where implementations
    * exist in the core library are guaranteed to return a non-nullptr service object.
    *
    * To ensure that CoreServices::Unget() is called after the caller
    * has finished using a service object, you should use the CoreServicePointer
    * helper class which calls Unget() when it goes out of scope:
    *
    * \code
    * CoreServicePointer<IShaderRepository> shaderRepo(CoreServices::GetShaderRepository());
    * // Do something with shaderRepo
    * \endcode
    *
    * @see CoreServicePointer
    */
   class MITKCORE_EXPORT CoreServices
   {
   public:
 
     /**
      * @brief Get an IPropertyAliases instance.
      * @param context The module context of the module getting the service.
      * @return A non-nullptr IPropertyAliases instance.
      */
     static IPropertyAliases *GetPropertyAliases(us::ModuleContext *context = us::GetModuleContext());
 
     /**
      * @brief Get an IPropertyDescriptions instance.
      * @param context The module context of the module getting the service.
      * @return A non-nullptr IPropertyDescriptions instance.
      */
     static IPropertyDescriptions *GetPropertyDescriptions(us::ModuleContext *context = us::GetModuleContext());
 
     /**
      * @brief Get an IPropertyExtensions instance.
      * @param context The module context of the module getting the service.
      * @return A non-nullptr IPropertyExtensions instance.
      */
     static IPropertyExtensions *GetPropertyExtensions(us::ModuleContext *context = us::GetModuleContext());
 
     /**
      * @brief Get an IPropertyFilters instance.
      * @param context The module context of the module getting the service.
      * @return A non-nullptr IPropertyFilters instance.
      */
     static IPropertyFilters *GetPropertyFilters(us::ModuleContext *context = us::GetModuleContext());
 
     /**
     * @brief Get an IPropertyPersistence instance.
     * @param context The module context of the module getting the service.
     * @return A non-nullptr IPropertyPersistence instance.
     */
     static IPropertyPersistence *GetPropertyPersistence(us::ModuleContext *context = us::GetModuleContext());
 
     /**
     * @brief Get an IPropertyRelations instance.
     * @param context The module context of the module getting the service.
     * @return A non-nullptr IPropertyRelations instance.
     */
     static IPropertyRelations *GetPropertyRelations(us::ModuleContext *context = us::GetModuleContext());
 
     /**
      * @brief Get an IMimeTypeProvider instance.
      * @param context The module context of the module getting the service.
      * @return A non-nullptr IMimeTypeProvider instance.
      */
     static IMimeTypeProvider *GetMimeTypeProvider(us::ModuleContext *context = us::GetModuleContext());
 
     /**
      * @brief Unget a previously acquired service instance.
      * @param service The service instance to be released.
      * @return \c true if ungetting the service was successful, \c false otherwise.
      */
     template <class S>
     static bool Unget(S *service, us::ModuleContext *context = us::GetModuleContext())
     {
       return Unget(context, us_service_interface_iid<S>(), service);
     }
 
   private:
     static bool Unget(us::ModuleContext *context, const std::string &interfaceId, void *service);
 
     // purposely not implemented
     CoreServices();
     CoreServices(const CoreServices &);
     CoreServices &operator=(const CoreServices &);
   };
 
   /**
    * @brief A RAII helper class for core service objects.
    *
    * This is class is intended for usage in local scopes; it calls
    * CoreServices::Unget(S*) in its destructor. You should not construct
    * multiple CoreServicePointer instances using the same service pointer,
    * unless it is retrieved by a new call to a CoreServices getter method.
    *
    * @see CoreServices
    */
   template <class S>
   class MITK_LOCAL CoreServicePointer
   {
   public:
-    explicit CoreServicePointer(S *service) : m_service(service) { assert(m_service); }
+    explicit CoreServicePointer(S *service, us::ModuleContext* context = us::GetModuleContext())
+      : m_Service(service),
+        m_Context(context)
+    {
+      assert(service);
+    }
+
     ~CoreServicePointer()
     {
       try
       {
-        CoreServices::Unget(m_service);
+        CoreServices::Unget(m_Service, m_Context);
       }
       catch (const std::exception &e)
       {
         MITK_ERROR << e.what();
       }
       catch (...)
       {
         MITK_ERROR << "Ungetting core service failed.";
       }
     }
 
-    S *operator->() const { return m_service; }
-  private:
-    // purposely not implemented
-    CoreServicePointer(const CoreServicePointer &);
-    CoreServicePointer &operator=(const CoreServicePointer &);
+    S *operator->() const
+    {
+      return m_Service;
+    }
 
-    S *const m_service;
+  private:
+    S *const m_Service;
+    us::ModuleContext* m_Context;
   };
 }
 
 #endif // MITKCORESERVICES_H
diff --git a/Modules/QtWidgets/include/QmitkPropertyItemModel.h b/Modules/QtWidgets/include/QmitkPropertyItemModel.h
index ebc4088044..1b501710a8 100644
--- a/Modules/QtWidgets/include/QmitkPropertyItemModel.h
+++ b/Modules/QtWidgets/include/QmitkPropertyItemModel.h
@@ -1,85 +1,76 @@
 /*============================================================================
 
 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 QmitkPropertyItemModel_h
 #define QmitkPropertyItemModel_h
 
 #include <MitkQtWidgetsExports.h>
 #include <QAbstractItemModel>
 #include <mitkPropertyList.h>
 #include <mitkWeakPointer.h>
+#include <mitkCoreServices.h>
 
 class QmitkPropertyItem;
 
 namespace berry
 {
   struct IBerryPreferences;
 }
 
 namespace mitk
 {
-  class IPropertyAliases;
-  class IPropertyFilters;
-
   enum
   {
     PropertyRole = Qt::UserRole + 1
   };
 }
 
 class MITKQTWIDGETS_EXPORT QmitkPropertyItemModel : public QAbstractItemModel
 {
   Q_OBJECT
 
 public:
   explicit QmitkPropertyItemModel(QObject *parent = nullptr);
   ~QmitkPropertyItemModel() override;
 
   int columnCount(const QModelIndex &parent = QModelIndex()) const override;
   QVariant data(const QModelIndex &index, int role = Qt::DisplayRole) const override;
   Qt::ItemFlags flags(const QModelIndex &index) const override;
   mitk::PropertyList *GetPropertyList() const;
   QVariant headerData(int section, Qt::Orientation orientation, int role) const override;
   QModelIndex index(int row, int column, const QModelIndex &parent = QModelIndex()) const override;
-  void OnPreferencesChanged();
   QModelIndex parent(const QModelIndex &child) const override;
   int rowCount(const QModelIndex &parent = QModelIndex()) const override;
   bool setData(const QModelIndex &index, const QVariant &value, int role = Qt::EditRole) override;
   void SetPropertyList(mitk::PropertyList *propertyList, const QString &className = "");
   void Update();
 
-  void SetShowAliases(const bool showAliases) { this->m_ShowAliases = showAliases; }
-  bool GetShowAliases() const { return this->m_ShowAliases; }
-  void SetFilterProperties(const bool filterProperties) { this->m_FilterProperties = filterProperties; }
-  bool GetFilterProperties() const { return this->m_FilterProperties; }
 private:
   void CreateRootItem();
   QModelIndex FindProperty(const mitk::BaseProperty *property);
   void OnPropertyListModified();
   void OnPropertyListDeleted();
   void OnPropertyModified(const itk::Object *property, const itk::EventObject &event);
   void SetNewPropertyList(mitk::PropertyList *newPropertyList);
 
-  bool m_ShowAliases;
-  bool m_FilterProperties;
-  mitk::IPropertyAliases *m_PropertyAliases;
-  mitk::IPropertyFilters *m_PropertyFilters;
+  mitk::CoreServicePointer<mitk::IPropertyAliases> m_PropertyAliases;
+  mitk::CoreServicePointer<mitk::IPropertyFilters> m_PropertyFilters;
   mitk::WeakPointer<mitk::PropertyList> m_PropertyList;
   QString m_ClassName;
   std::unique_ptr<QmitkPropertyItem> m_RootItem;
   std::map<std::string, unsigned long> m_PropertyDeletedTags;
   std::map<std::string, unsigned long> m_PropertyModifiedTags;
   unsigned long m_PropertyListDeletedTag;
   unsigned long m_PropertyListModifiedTag;
 };
 
 #endif
diff --git a/Modules/QtWidgets/src/QmitkPropertyItemDelegate.cpp b/Modules/QtWidgets/src/QmitkPropertyItemDelegate.cpp
index dc74128ae6..ed90dc0aa3 100644
--- a/Modules/QtWidgets/src/QmitkPropertyItemDelegate.cpp
+++ b/Modules/QtWidgets/src/QmitkPropertyItemDelegate.cpp
@@ -1,391 +1,380 @@
 /*============================================================================
 
 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 "QmitkPropertyItemDelegate.h"
 #include "QmitkPropertyItemModel.h"
 #include <QApplication>
 #include <QColorDialog>
 #include <QComboBox>
 #include <QHBoxLayout>
 #include <QLineEdit>
 #include <QPaintEvent>
 #include <QPainter>
 #include <QSpinBox>
 #include <QToolButton>
 #include <algorithm>
 #include <mitkBaseProperty.h>
+#include <mitkCoreServices.h>
 #include <mitkFloatPropertyExtension.h>
 #include <mitkIPropertyExtensions.h>
 #include <mitkIntPropertyExtension.h>
-#include <usGetModuleContext.h>
-#include <usModuleContext.h>
-#include <usServiceReference.h>
-
-mitk::IPropertyExtensions *GetPropertyService()
-{
-  us::ModuleContext *context = us::GetModuleContext();
-  us::ServiceReference<mitk::IPropertyExtensions> serviceRef =
-    context->GetServiceReference<mitk::IPropertyExtensions>();
-
-  return serviceRef ? context->GetService<mitk::IPropertyExtensions>(serviceRef) : nullptr;
-}
 
 QmitkColorWidget::QmitkColorWidget(QWidget *parent)
   : QWidget(parent), m_LineEdit(new QLineEdit), m_Button(new QToolButton)
 {
   m_LineEdit->setText(m_Color.name());
   m_Button->setText("...");
 
   QHBoxLayout *layout = new QHBoxLayout;
   layout->setContentsMargins(0, 0, 0, 0);
   layout->setSpacing(0);
 
   layout->addWidget(m_LineEdit);
   layout->addWidget(m_Button);
 
   this->setFocusProxy(m_LineEdit);
   this->setLayout(layout);
 
   connect(m_LineEdit, SIGNAL(editingFinished()), this, SLOT(OnLineEditEditingFinished()));
   connect(m_Button, SIGNAL(clicked()), this, SLOT(OnButtonClicked()));
 }
 
 QmitkColorWidget::~QmitkColorWidget()
 {
 }
 
 QColor QmitkColorWidget::GetColor() const
 {
   return m_Color;
 }
 
 void QmitkColorWidget::SetColor(QColor color)
 {
   m_Color = color;
   m_LineEdit->setText(color.name());
 }
 
 void QmitkColorWidget::OnLineEditEditingFinished()
 {
   if (!QColor::isValidColor(m_LineEdit->text()))
     m_LineEdit->setText("#000000");
 
   m_Color.setNamedColor(m_LineEdit->text());
 }
 
 void QmitkColorWidget::OnButtonClicked()
 {
   QColor color = QColorDialog::getColor(m_Color, QApplication::activeWindow());
 
   if (color.isValid())
   {
     this->SetColor(color);
     emit ColorPicked();
   }
 }
 
 QmitkComboBoxListView::QmitkComboBoxListView(QComboBox *comboBox) : m_ComboBox(comboBox)
 {
 }
 
 QmitkComboBoxListView::~QmitkComboBoxListView()
 {
 }
 
 void QmitkComboBoxListView::paintEvent(QPaintEvent *event)
 {
   if (m_ComboBox != nullptr)
   {
     QStyleOptionComboBox option;
 
     option.initFrom(m_ComboBox);
     option.editable = m_ComboBox->isEditable();
 
     if (m_ComboBox->style()->styleHint(QStyle::SH_ComboBox_Popup, &option, m_ComboBox))
     {
       QStyleOptionMenuItem menuOption;
       menuOption.initFrom(this);
       menuOption.palette = this->palette();
       menuOption.state = QStyle::State_None;
       menuOption.checkType = QStyleOptionMenuItem::NotCheckable;
       menuOption.menuRect = event->rect();
       menuOption.maxIconWidth = 0;
       menuOption.tabWidth = 0;
 
       QPainter painter(this->viewport());
       m_ComboBox->style()->drawControl(QStyle::CE_MenuEmptyArea, &menuOption, &painter, this);
     }
   }
 
   QListView::paintEvent(event);
 }
 
 void QmitkComboBoxListView::resizeEvent(QResizeEvent *event)
 {
   int width = this->viewport()->width();
   int height = this->contentsSize().height();
 
   this->resizeContents(width, height);
 
   QListView::resizeEvent(event);
 }
 
 QStyleOptionViewItem QmitkComboBoxListView::viewOptions() const
 {
   QStyleOptionViewItem option = QListView::viewOptions();
   option.showDecorationSelected = true;
 
   if (m_ComboBox != nullptr)
     option.font = m_ComboBox->font();
 
   return option;
 }
 
 class PropertyEqualTo
 {
 public:
   PropertyEqualTo(const mitk::BaseProperty *property) : m_Property(property) {}
   bool operator()(const mitk::PropertyList::PropertyMapElementType &pair) const
   {
     return pair.second.GetPointer() == m_Property;
   }
 
 private:
   const mitk::BaseProperty *m_Property;
 };
 
 QmitkPropertyItemDelegate::QmitkPropertyItemDelegate(QObject *parent) : QStyledItemDelegate(parent)
 {
 }
 
 QmitkPropertyItemDelegate::~QmitkPropertyItemDelegate()
 {
 }
 
 QWidget *QmitkPropertyItemDelegate::createEditor(QWidget *parent,
                                                  const QStyleOptionViewItem &option,
                                                  const QModelIndex &index) const
 {
   QVariant data = index.data(Qt::EditRole);
 
   if (data.isValid())
   {
     if (data.type() == QVariant::Int)
     {
       QSpinBox *spinBox = new QSpinBox(parent);
 
-      mitk::IPropertyExtensions *extensions = GetPropertyService();
+      mitk::CoreServicePointer<mitk::IPropertyExtensions> extensions(mitk::CoreServices::GetPropertyExtensions());
       std::string name = this->GetPropertyName(index);
 
-      if (extensions != nullptr && !name.empty() && extensions->HasExtension(name))
+      if (!name.empty() && extensions->HasExtension(name))
       {
         mitk::IntPropertyExtension::Pointer extension =
           dynamic_cast<mitk::IntPropertyExtension *>(extensions->GetExtension(name).GetPointer());
 
         if (extension.IsNotNull())
         {
           spinBox->setMinimum(extension->GetMinimum());
           spinBox->setMaximum(extension->GetMaximum());
           spinBox->setSingleStep(extension->GetSingleStep());
         }
       }
 
       connect(spinBox, SIGNAL(editingFinished()), this, SLOT(OnSpinBoxEditingFinished()));
 
       return spinBox;
     }
 
     if (data.type() == QVariant::Double || static_cast<QMetaType::Type>(data.type()) == QMetaType::Float)
     {
       QDoubleSpinBox *spinBox = new QDoubleSpinBox(parent);
 
-      mitk::IPropertyExtensions *extensions = GetPropertyService();
+      mitk::CoreServicePointer<mitk::IPropertyExtensions> extensions(mitk::CoreServices::GetPropertyExtensions());
       std::string name = this->GetPropertyName(index);
 
-      if (extensions != nullptr && !name.empty() && extensions->HasExtension(name))
+      if (!name.empty() && extensions->HasExtension(name))
       {
         mitk::FloatPropertyExtension::Pointer extension =
           dynamic_cast<mitk::FloatPropertyExtension *>(extensions->GetExtension(name).GetPointer());
 
         if (extension.IsNotNull())
         {
           spinBox->setMinimum(extension->GetMinimum());
           spinBox->setMaximum(extension->GetMaximum());
           spinBox->setSingleStep(extension->GetSingleStep());
           spinBox->setDecimals(extension->GetDecimals());
         }
       }
       else
       {
         spinBox->setSingleStep(0.1);
         spinBox->setDecimals(4);
       }
 
       if (name == "opacity") // TODO
       {
         spinBox->setMinimum(0.0);
         spinBox->setMaximum(1.0);
       }
 
       connect(spinBox, SIGNAL(editingFinished()), this, SLOT(OnSpinBoxEditingFinished()));
 
       return spinBox;
     }
 
     if (data.type() == QVariant::StringList)
     {
       QComboBox *comboBox = new QComboBox(parent);
       comboBox->setView(new QmitkComboBoxListView(comboBox));
 
       comboBox->addItems(data.toStringList());
 
       connect(comboBox, SIGNAL(currentIndexChanged(int)), this, SLOT(OnComboBoxCurrentIndexChanged(int)));
 
       return comboBox;
     }
 
     if (data.type() == QVariant::Color)
     {
       QmitkColorWidget *colorWidget = new QmitkColorWidget(parent);
 
       connect(colorWidget, SIGNAL(ColorPicked()), this, SLOT(OnColorPicked()));
 
       return colorWidget;
     }
   }
 
   return QStyledItemDelegate::createEditor(parent, option, index);
 }
 
 std::string QmitkPropertyItemDelegate::GetPropertyName(const QModelIndex &index) const
 {
   if (!m_PropertyList.IsExpired())
   {
     mitk::BaseProperty *property =
       reinterpret_cast<mitk::BaseProperty *>(index.data(mitk::PropertyRole).value<void *>());
     const mitk::PropertyList::PropertyMap *propertyMap = m_PropertyList.Lock()->GetMap();
 
     mitk::PropertyList::PropertyMap::const_iterator it =
       std::find_if(propertyMap->begin(), propertyMap->end(), PropertyEqualTo(property));
 
     if (it != propertyMap->end())
       return it->first;
   }
 
   return "";
 }
 
 void QmitkPropertyItemDelegate::OnComboBoxCurrentIndexChanged(int)
 {
   QComboBox *comboBox = qobject_cast<QComboBox *>(sender());
 
   emit commitData(comboBox);
   emit closeEditor(comboBox);
 }
 
 void QmitkPropertyItemDelegate::OnSpinBoxEditingFinished()
 {
   QAbstractSpinBox *spinBox = qobject_cast<QAbstractSpinBox *>(sender());
 
   emit commitData(spinBox);
   emit closeEditor(spinBox);
 }
 
 void QmitkPropertyItemDelegate::OnColorPicked()
 {
   QmitkColorWidget *colorWidget = qobject_cast<QmitkColorWidget *>(sender());
 
   emit commitData(colorWidget);
   emit closeEditor(colorWidget);
 }
 
 void QmitkPropertyItemDelegate::paint(QPainter *painter,
                                       const QStyleOptionViewItem &option,
                                       const QModelIndex &index) const
 {
   QVariant data = index.data();
 
   if (index.column() == 1 && data.type() == QVariant::Color)
   {
     painter->fillRect(option.rect, data.value<QColor>());
     return;
   }
 
   QStyledItemDelegate::paint(painter, option, index);
 }
 
 void QmitkPropertyItemDelegate::setEditorData(QWidget *editor, const QModelIndex &index) const
 {
   QVariant data = index.data(Qt::EditRole);
 
   if (!data.isValid())
     return;
 
   if (data.type() == QVariant::StringList)
   {
     QComboBox *comboBox = qobject_cast<QComboBox *>(editor);
     comboBox->setCurrentIndex(comboBox->findText(index.data().toString()));
   }
   if (data.type() == QVariant::Color)
   {
     QmitkColorWidget *colorWidget = qobject_cast<QmitkColorWidget *>(editor);
     colorWidget->SetColor(data.value<QColor>());
   }
   else
   {
     QStyledItemDelegate::setEditorData(editor, index);
   }
 }
 
 void QmitkPropertyItemDelegate::setModelData(QWidget *editor, QAbstractItemModel *model, const QModelIndex &index) const
 {
   QVariant data = index.data(Qt::EditRole);
 
   if (!data.isValid())
     return;
 
   if (data.type() == QVariant::Int)
   {
     QSpinBox *spinBox = qobject_cast<QSpinBox *>(editor);
     model->setData(index, spinBox->value());
   }
   else if (data.type() == QVariant::Double)
   {
     QDoubleSpinBox *spinBox = qobject_cast<QDoubleSpinBox *>(editor);
     model->setData(index, spinBox->value());
   }
   else if (static_cast<QMetaType::Type>(data.type()) == QMetaType::Float)
   {
     QDoubleSpinBox *spinBox = qobject_cast<QDoubleSpinBox *>(editor);
     model->setData(index, static_cast<float>(spinBox->value()));
   }
   else if (data.type() == QVariant::StringList)
   {
     QComboBox *comboBox = qobject_cast<QComboBox *>(editor);
     model->setData(index, comboBox->currentText());
   }
   else if (data.type() == QVariant::Color)
   {
     QmitkColorWidget *colorWidget = qobject_cast<QmitkColorWidget *>(editor);
     model->setData(index, colorWidget->GetColor());
   }
   else
   {
     QStyledItemDelegate::setModelData(editor, model, index);
   }
 }
 
 void QmitkPropertyItemDelegate::SetPropertyList(mitk::PropertyList *propertyList)
 {
   if (m_PropertyList != propertyList)
     m_PropertyList = propertyList;
 }
diff --git a/Modules/QtWidgets/src/QmitkPropertyItemModel.cpp b/Modules/QtWidgets/src/QmitkPropertyItemModel.cpp
index 351b71fd9c..f65d8888e1 100644
--- a/Modules/QtWidgets/src/QmitkPropertyItemModel.cpp
+++ b/Modules/QtWidgets/src/QmitkPropertyItemModel.cpp
@@ -1,516 +1,474 @@
 /*============================================================================
 
 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 "QmitkPropertyItemModel.h"
 #include "QmitkPropertyItem.h"
 #include <QColor>
 #include <mitkColorProperty.h>
 #include <mitkEnumerationProperty.h>
 #include <mitkIPropertyAliases.h>
 #include <mitkIPropertyFilters.h>
 #include <mitkProperties.h>
 #include <mitkRenderingManager.h>
 #include <mitkStringProperty.h>
 
-#include <usGetModuleContext.h>
-#include <usModuleContext.h>
-#include <usServiceReference.h>
-
-template <class T>
-T *GetPropertyService()
-{
-  us::ModuleContext *context = us::GetModuleContext();
-  us::ServiceReference<T> serviceRef = context->GetServiceReference<T>();
-
-  return serviceRef ? context->GetService<T>(serviceRef) : nullptr;
-}
-
-static QColor MitkToQt(const mitk::Color &color)
+namespace
 {
-  return QColor(color.GetRed() * 255, color.GetGreen() * 255, color.GetBlue() * 255);
-}
+  QColor MitkToQt(const mitk::Color& color)
+  {
+    return QColor(color.GetRed() * 255, color.GetGreen() * 255, color.GetBlue() * 255);
+  }
 
-static mitk::BaseProperty *GetBaseProperty(const QVariant &data)
-{
-  return data.isValid() ? reinterpret_cast<mitk::BaseProperty *>(data.value<void *>()) : nullptr;
-}
+  mitk::BaseProperty* GetBaseProperty(const QVariant& data)
+  {
+    return data.isValid() ? reinterpret_cast<mitk::BaseProperty*>(data.value<void*>()) : nullptr;
+  }
 
-static mitk::Color QtToMitk(const QColor &color)
-{
-  mitk::Color mitkColor;
+  mitk::Color QtToMitk(const QColor& color)
+  {
+    mitk::Color mitkColor;
 
-  mitkColor.SetRed(color.red() / 255.0f);
-  mitkColor.SetGreen(color.green() / 255.0f);
-  mitkColor.SetBlue(color.blue() / 255.0f);
+    mitkColor.SetRed(color.red() / 255.0f);
+    mitkColor.SetGreen(color.green() / 255.0f);
+    mitkColor.SetBlue(color.blue() / 255.0f);
 
-  return mitkColor;
+    return mitkColor;
+  }
 }
 
 class PropertyEqualTo
 {
 public:
   PropertyEqualTo(const mitk::BaseProperty *property) : m_Property(property) {}
   bool operator()(const mitk::PropertyList::PropertyMapElementType &pair) const
   {
     return pair.second.GetPointer() == m_Property;
   }
 
 private:
   const mitk::BaseProperty *m_Property;
 };
 
 QmitkPropertyItemModel::QmitkPropertyItemModel(QObject *parent)
   : QAbstractItemModel(parent),
-    m_ShowAliases(false),
-    m_FilterProperties(false),
-    m_PropertyAliases(nullptr),
-    m_PropertyFilters(nullptr)
+    m_PropertyAliases(mitk::CoreServices::GetPropertyAliases()),
+    m_PropertyFilters(mitk::CoreServices::GetPropertyFilters())
 {
   this->CreateRootItem();
 }
 
 QmitkPropertyItemModel::~QmitkPropertyItemModel()
 {
   this->SetNewPropertyList(nullptr);
 }
 
 int QmitkPropertyItemModel::columnCount(const QModelIndex &parent) const
 {
   if (parent.isValid())
     return static_cast<QmitkPropertyItem *>(parent.internalPointer())->GetColumnCount();
   else
     return m_RootItem->GetColumnCount();
 }
 
 void QmitkPropertyItemModel::CreateRootItem()
 {
   QList<QVariant> rootData;
   rootData << "Property"
            << "Value";
 
   m_RootItem.reset(new QmitkPropertyItem(rootData));
 
   this->beginResetModel();
   this->endResetModel();
 }
 
 QVariant QmitkPropertyItemModel::data(const QModelIndex &index, int role) const
 {
   if (!index.isValid())
     return QVariant();
 
   mitk::BaseProperty *property =
     index.column() == 1 ? GetBaseProperty(static_cast<QmitkPropertyItem *>(index.internalPointer())->GetData(1)) : nullptr;
 
   if (role == Qt::DisplayRole)
   {
     if (index.column() == 0)
     {
       return static_cast<QmitkPropertyItem *>(index.internalPointer())->GetData(0);
     }
     else if (index.column() == 1 && property != nullptr)
     {
       if (auto colorProperty = dynamic_cast<mitk::ColorProperty *>(property))
         return MitkToQt(colorProperty->GetValue());
       else if (dynamic_cast<mitk::BoolProperty *>(property) == nullptr)
         return QString::fromStdString(property->GetValueAsString());
     }
   }
   else if (index.column() == 1 && property != nullptr)
   {
     if (role == Qt::CheckStateRole)
     {
       if (auto boolProperty = dynamic_cast<mitk::BoolProperty *>(property))
         return boolProperty->GetValue() ? Qt::Checked : Qt::Unchecked;
     }
     else if (role == Qt::EditRole)
     {
       if (dynamic_cast<mitk::StringProperty *>(property) != nullptr)
       {
         return QString::fromStdString(property->GetValueAsString());
       }
       else if (auto intProperty = dynamic_cast<mitk::IntProperty *>(property))
       {
         return intProperty->GetValue();
       }
       else if (auto floatProperty = dynamic_cast<mitk::FloatProperty *>(property))
       {
         return floatProperty->GetValue();
       }
       else if (auto doubleProperty = dynamic_cast<mitk::DoubleProperty *>(property))
       {
         return doubleProperty->GetValue();
       }
       else if (auto enumProperty = dynamic_cast<mitk::EnumerationProperty *>(property))
       {
         QStringList values;
 
         for (mitk::EnumerationProperty::EnumConstIterator it = enumProperty->Begin(); it != enumProperty->End(); it++)
           values << QString::fromStdString(it->second);
 
         return values;
       }
       else if (auto colorProperty = dynamic_cast<mitk::ColorProperty *>(property))
       {
         return MitkToQt(colorProperty->GetValue());
       }
     }
     else if (role == mitk::PropertyRole)
     {
       return QVariant::fromValue<void *>(property);
     }
   }
 
   return QVariant();
 }
 
 QModelIndex QmitkPropertyItemModel::FindProperty(const mitk::BaseProperty *property)
 {
   if (property == nullptr)
     return QModelIndex();
 
   if (m_PropertyList.IsExpired())
     return QModelIndex();
 
   auto propertyMap = m_PropertyList.Lock()->GetMap();
   auto it = std::find_if(propertyMap->begin(), propertyMap->end(), PropertyEqualTo(property));
 
   if (it == propertyMap->end())
     return QModelIndex();
 
   QString name = QString::fromStdString(it->first);
 
   if (!name.contains('.'))
   {
     QModelIndexList item = this->match(index(0, 0), Qt::DisplayRole, name, 1, Qt::MatchExactly);
 
     if (!item.empty())
       return item[0];
   }
   else
   {
     QStringList names = name.split('.');
     QModelIndexList items =
       this->match(index(0, 0), Qt::DisplayRole, names.last(), -1, Qt::MatchRecursive | Qt::MatchExactly);
 
     for (auto item : items)
     {
       QModelIndex candidate = item;
 
       for (int i = names.length() - 1; i != 0; --i)
       {
         QModelIndex parent = item.parent();
 
         if (parent.parent() == QModelIndex())
         {
           if (parent.data() != names.first())
             break;
 
           return candidate;
         }
 
         if (parent.data() != names[i - 1])
           break;
 
         item = parent;
       }
     }
   }
 
   return QModelIndex();
 }
 
 Qt::ItemFlags QmitkPropertyItemModel::flags(const QModelIndex &index) const
 {
   Qt::ItemFlags flags = QAbstractItemModel::flags(index);
 
   if (index.column() == 1)
   {
     if (index.data(Qt::EditRole).isValid())
       flags |= Qt::ItemIsEditable;
 
     if (index.data(Qt::CheckStateRole).isValid())
       flags |= Qt::ItemIsUserCheckable;
   }
 
   return flags;
 }
 
 mitk::PropertyList *QmitkPropertyItemModel::GetPropertyList() const
 {
   return m_PropertyList.Lock().GetPointer();
 }
 
 QVariant QmitkPropertyItemModel::headerData(int section, Qt::Orientation orientation, int role) const
 {
   if (orientation == Qt::Horizontal && role == Qt::DisplayRole)
     return m_RootItem->GetData(section);
 
   return QVariant();
 }
 
 QModelIndex QmitkPropertyItemModel::index(int row, int column, const QModelIndex &parent) const
 {
   if (!this->hasIndex(row, column, parent))
     return QModelIndex();
 
   QmitkPropertyItem *parentItem =
     parent.isValid() ? static_cast<QmitkPropertyItem *>(parent.internalPointer()) : m_RootItem.get();
 
   QmitkPropertyItem *childItem = parentItem->GetChild(row);
 
   return childItem != nullptr ? this->createIndex(row, column, childItem) : QModelIndex();
 }
 
-void QmitkPropertyItemModel::OnPreferencesChanged()
-{
-  bool updateAliases = m_ShowAliases != (m_PropertyAliases != nullptr);
-  bool updateFilters = m_FilterProperties != (m_PropertyFilters != nullptr);
-
-  bool resetPropertyList = false;
-
-  if (updateAliases)
-  {
-    m_PropertyAliases = m_ShowAliases ? GetPropertyService<mitk::IPropertyAliases>() : nullptr;
-
-    resetPropertyList = !m_PropertyList.IsExpired();
-  }
-
-  if (updateFilters)
-  {
-    m_PropertyFilters = m_FilterProperties ? GetPropertyService<mitk::IPropertyFilters>() : nullptr;
-
-    if (!resetPropertyList)
-      resetPropertyList = !m_PropertyList.IsExpired();
-  }
-
-  if (resetPropertyList)
-    this->SetNewPropertyList(m_PropertyList.Lock());
-}
-
 void QmitkPropertyItemModel::OnPropertyListModified()
 {
   this->SetNewPropertyList(m_PropertyList.Lock());
 }
 
 void QmitkPropertyItemModel::OnPropertyListDeleted()
 {
   this->CreateRootItem();
 }
 
 void QmitkPropertyItemModel::OnPropertyModified(const itk::Object *property, const itk::EventObject &)
 {
   QModelIndex index = this->FindProperty(static_cast<const mitk::BaseProperty *>(property));
 
   if (index != QModelIndex())
     emit dataChanged(index, index);
 }
 
 QModelIndex QmitkPropertyItemModel::parent(const QModelIndex &child) const
 {
   if (!child.isValid())
     return QModelIndex();
 
   QmitkPropertyItem *parentItem = static_cast<QmitkPropertyItem *>(child.internalPointer())->GetParent();
 
   if (parentItem == m_RootItem.get())
     return QModelIndex();
 
   return this->createIndex(parentItem->GetRow(), 0, parentItem);
 }
 
 int QmitkPropertyItemModel::rowCount(const QModelIndex &parent) const
 {
   if (parent.column() > 0)
     return 0;
 
   QmitkPropertyItem *parentItem =
     parent.isValid() ? static_cast<QmitkPropertyItem *>(parent.internalPointer()) : m_RootItem.get();
 
   return parentItem->GetChildCount();
 }
 
 bool QmitkPropertyItemModel::setData(const QModelIndex &index, const QVariant &value, int role)
 {
   if (!index.isValid() || index.column() != 1 || (role != Qt::EditRole && role != Qt::CheckStateRole))
     return false;
 
   mitk::BaseProperty *property = GetBaseProperty(static_cast<QmitkPropertyItem *>(index.internalPointer())->GetData(1));
 
   if (property == nullptr)
     return false;
 
   if (mitk::BoolProperty *boolProperty = dynamic_cast<mitk::BoolProperty *>(property))
   {
     boolProperty->SetValue(value.toInt() == Qt::Checked ? true : false);
   }
   else if (mitk::StringProperty *stringProperty = dynamic_cast<mitk::StringProperty *>(property))
   {
     stringProperty->SetValue(value.toString().toStdString());
   }
   else if (mitk::IntProperty *intProperty = dynamic_cast<mitk::IntProperty *>(property))
   {
     intProperty->SetValue(value.toInt());
   }
   else if (mitk::FloatProperty *floatProperty = dynamic_cast<mitk::FloatProperty *>(property))
   {
     floatProperty->SetValue(value.toFloat());
   }
   else if (mitk::DoubleProperty *doubleProperty = dynamic_cast<mitk::DoubleProperty *>(property))
   {
     doubleProperty->SetValue(value.toDouble());
   }
   else if (mitk::EnumerationProperty *enumProperty = dynamic_cast<mitk::EnumerationProperty *>(property))
   {
     std::string selection = value.toString().toStdString();
 
     if (selection != enumProperty->GetValueAsString() && enumProperty->IsValidEnumerationValue(selection))
       enumProperty->SetValue(selection);
   }
   else if (mitk::ColorProperty *colorProperty = dynamic_cast<mitk::ColorProperty *>(property))
   {
     colorProperty->SetValue(QtToMitk(value.value<QColor>()));
   }
 
   auto propertyList = m_PropertyList.Lock();
 
   propertyList->Modified();
 
   mitk::RenderingManager::GetInstance()->RequestUpdateAll();
 
   return true;
 }
 
 void QmitkPropertyItemModel::SetNewPropertyList(mitk::PropertyList *newPropertyList)
 {
   typedef mitk::PropertyList::PropertyMap PropertyMap;
 
   this->beginResetModel();
 
   if (!m_PropertyList.IsExpired())
   {
     auto propertyList = m_PropertyList.Lock();
 
     propertyList->RemoveObserver(m_PropertyListDeletedTag);
     propertyList->RemoveObserver(m_PropertyListModifiedTag);
 
     const PropertyMap *propertyMap = m_PropertyList.Lock()->GetMap();
 
     for (PropertyMap::const_iterator propertyIt = propertyMap->begin(); propertyIt != propertyMap->end(); ++propertyIt)
     {
       std::map<std::string, unsigned long>::const_iterator tagIt = m_PropertyModifiedTags.find(propertyIt->first);
 
       if (tagIt != m_PropertyModifiedTags.end())
         propertyIt->second->RemoveObserver(tagIt->second);
 
       tagIt = m_PropertyDeletedTags.find(propertyIt->first);
 
       if (tagIt != m_PropertyDeletedTags.end())
         propertyIt->second->RemoveObserver(tagIt->second);
     }
 
     m_PropertyModifiedTags.clear();
     m_PropertyDeletedTags.clear();
   }
 
   m_PropertyList = newPropertyList;
 
   if (!m_PropertyList.IsExpired())
   {
     auto onPropertyListModified = itk::SimpleMemberCommand<QmitkPropertyItemModel>::New();
     onPropertyListModified->SetCallbackFunction(this, &QmitkPropertyItemModel::OnPropertyListModified);
     m_PropertyListModifiedTag = m_PropertyList.Lock()->AddObserver(itk::ModifiedEvent(), onPropertyListModified);
 
     auto onPropertyListDeleted = itk::SimpleMemberCommand<QmitkPropertyItemModel>::New();
     onPropertyListDeleted->SetCallbackFunction(this, &QmitkPropertyItemModel::OnPropertyListDeleted);
     m_PropertyListDeletedTag = m_PropertyList.Lock()->AddObserver(itk::DeleteEvent(), onPropertyListDeleted);
 
     auto modifiedCommand = itk::MemberCommand<QmitkPropertyItemModel>::New();
     modifiedCommand->SetCallbackFunction(this, &QmitkPropertyItemModel::OnPropertyModified);
 
     const PropertyMap *propertyMap = m_PropertyList.Lock()->GetMap();
 
     for (PropertyMap::const_iterator it = propertyMap->begin(); it != propertyMap->end(); ++it)
       m_PropertyModifiedTags.insert(
         std::make_pair(it->first, it->second->AddObserver(itk::ModifiedEvent(), modifiedCommand)));
   }
 
   this->CreateRootItem();
 
   if (m_PropertyList != nullptr && !m_PropertyList.Lock()->IsEmpty())
   {
     mitk::PropertyList::PropertyMap filteredProperties;
     bool filterProperties = false;
 
-    if (m_PropertyFilters != nullptr &&
-        (m_PropertyFilters->HasFilter() || m_PropertyFilters->HasFilter(m_ClassName.toStdString())))
+    if (m_PropertyFilters->HasFilter() || m_PropertyFilters->HasFilter(m_ClassName.toStdString()))
     {
       filteredProperties = m_PropertyFilters->ApplyFilter(*m_PropertyList.Lock()->GetMap(), m_ClassName.toStdString());
       filterProperties = true;
     }
 
     const mitk::PropertyList::PropertyMap *propertyMap =
       !filterProperties ? m_PropertyList.Lock()->GetMap() : &filteredProperties;
 
     mitk::PropertyList::PropertyMap::const_iterator end = propertyMap->end();
 
     for (mitk::PropertyList::PropertyMap::const_iterator iter = propertyMap->begin(); iter != end; ++iter)
     {
       std::vector<std::string> aliases;
 
-      if (m_PropertyAliases != nullptr)
-      {
-        aliases = m_PropertyAliases->GetAliases(iter->first, m_ClassName.toStdString());
+      aliases = m_PropertyAliases->GetAliases(iter->first, m_ClassName.toStdString());
 
-        if (aliases.empty() && !m_ClassName.isEmpty())
-          aliases = m_PropertyAliases->GetAliases(iter->first);
-      }
+      if (aliases.empty() && !m_ClassName.isEmpty())
+        aliases = m_PropertyAliases->GetAliases(iter->first);
 
       if (aliases.empty())
       {
         QList<QVariant> data;
         data << QString::fromStdString(iter->first)
              << QVariant::fromValue((reinterpret_cast<void *>(iter->second.GetPointer())));
 
         m_RootItem->AppendChild(new QmitkPropertyItem(data));
       }
       else
       {
         std::vector<std::string>::const_iterator end = aliases.end();
         for (std::vector<std::string>::const_iterator aliasIter = aliases.begin(); aliasIter != end; ++aliasIter)
         {
           QList<QVariant> data;
           data << QString::fromStdString(*aliasIter)
                << QVariant::fromValue((reinterpret_cast<void *>(iter->second.GetPointer())));
 
           m_RootItem->AppendChild(new QmitkPropertyItem(data));
         }
       }
     }
   }
 
   this->endResetModel();
 }
 
 void QmitkPropertyItemModel::SetPropertyList(mitk::PropertyList *propertyList, const QString &className)
 {
   if (m_PropertyList != propertyList)
   {
     m_ClassName = className;
     this->SetNewPropertyList(propertyList);
   }
 }
 
 void QmitkPropertyItemModel::Update()
 {
   this->SetNewPropertyList(m_PropertyList.Lock());
 }
diff --git a/Plugins/org.mitk.gui.qt.properties/files.cmake b/Plugins/org.mitk.gui.qt.properties/files.cmake
index 432abbe830..f62d511fb2 100644
--- a/Plugins/org.mitk.gui.qt.properties/files.cmake
+++ b/Plugins/org.mitk.gui.qt.properties/files.cmake
@@ -1,44 +1,41 @@
 set(SRC_CPP_FILES
 )
 
 set(INTERNAL_CPP_FILES
   org_mitk_gui_qt_properties_Activator.cpp
-  QmitkPropertiesPreferencePage.cpp
   QmitkPropertyItemSortFilterProxyModel.cpp
   QmitkPropertyTreeView.cpp
   QmitkAddNewPropertyDialog.cpp
 )
 
 set(UI_FILES
-  src/internal/QmitkPropertiesPreferencePage.ui
   src/internal/QmitkPropertyTreeView.ui
   src/internal/QmitkAddNewPropertyDialog.ui
 )
 
 set(MOC_H_FILES
-  src/internal/QmitkPropertiesPreferencePage.h
   src/internal/org_mitk_gui_qt_properties_Activator.h
   src/internal/QmitkPropertyItemSortFilterProxyModel.h
   src/internal/QmitkPropertyTreeView.h
   src/internal/QmitkAddNewPropertyDialog.h
 )
 
 set(CACHED_RESOURCE_FILES
   resources/property_list.svg
   plugin.xml
 )
 
 set(QRC_FILES
   resources/Properties.qrc
 )
 
 set(CPP_FILES
 )
 
 foreach(file ${SRC_CPP_FILES})
   set(CPP_FILES ${CPP_FILES} src/${file})
 endforeach()
 
 foreach(file ${INTERNAL_CPP_FILES})
   set(CPP_FILES ${CPP_FILES} src/internal/${file})
 endforeach()
diff --git a/Plugins/org.mitk.gui.qt.properties/plugin.xml b/Plugins/org.mitk.gui.qt.properties/plugin.xml
index 91f2c13b6e..a7cc038ef4 100644
--- a/Plugins/org.mitk.gui.qt.properties/plugin.xml
+++ b/Plugins/org.mitk.gui.qt.properties/plugin.xml
@@ -1,22 +1,17 @@
 <?xml version="1.0"?>
 <plugin>
   <extension point="org.blueberry.ui.views">
     <view id="org.mitk.views.properties"
           name="Properties"
           category="Data"
           class="QmitkPropertyTreeView"
           icon="resources/property_list.svg" >
           <description>View, Set, and Change properties of DataNodes</description>
     </view>
   </extension>
-  <extension point="org.blueberry.ui.preferencePages">
-    <page id="org.mitk.gui.qt.application.PropertiesPreferencePage" name="Properties" class="QmitkPropertiesPreferencePage">
-      <keywordreference id="org.mitk.views.properties.Keyword"/>
-    </page>
-  </extension>
   <extension point="org.blueberry.ui.keywords">
     <keyword id="org.mitk.views.properties.Keyword" label="DataNode Data Show aliases properties replace genuine property name by" />
     <keyword id="org.mitk.views.properties.Keyword" label="show description persistence info filters filtered developer mode enabled" />
   </extension>
 
 </plugin>
diff --git a/Plugins/org.mitk.gui.qt.properties/src/internal/QmitkAddNewPropertyDialog.cpp b/Plugins/org.mitk.gui.qt.properties/src/internal/QmitkAddNewPropertyDialog.cpp
index c91a5e7524..9f389cc95b 100644
--- a/Plugins/org.mitk.gui.qt.properties/src/internal/QmitkAddNewPropertyDialog.cpp
+++ b/Plugins/org.mitk.gui.qt.properties/src/internal/QmitkAddNewPropertyDialog.cpp
@@ -1,204 +1,201 @@
 /*============================================================================
 
 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 "org_mitk_gui_qt_properties_Activator.h"
 #include "QmitkAddNewPropertyDialog.h"
-#include "mitkGetPropertyService.h"
-#include <mitkIPropertyPersistence.h>
 #include <mitkProperties.h>
+#include <mitkIPropertyPersistence.h>
+#include <mitkCoreServices.h>
 #include <QMessageBox>
 #include <cassert>
 
 QmitkAddNewPropertyDialog::QmitkAddNewPropertyDialog(mitk::BaseData::Pointer baseData, QWidget* parent)
   : QDialog(parent),
     m_BaseData(baseData)
 {
   this->Initialize();
 }
 
 QmitkAddNewPropertyDialog::QmitkAddNewPropertyDialog(mitk::DataNode::Pointer dataNode, mitk::BaseRenderer::Pointer renderer, QWidget* parent)
   : QDialog(parent),
     m_DataNode(dataNode),
     m_Renderer(renderer)
 {
   this->Initialize();
 }
 
 QmitkAddNewPropertyDialog::~QmitkAddNewPropertyDialog()
 {
 }
 
 void QmitkAddNewPropertyDialog::Initialize()
 {
   m_Controls.setupUi(this);
 
   QStringList types;
   types << "bool" << "double" << "float" << "int" << "string";
 
   m_Controls.typeComboBox->addItems(types);
 
   m_Controls.persistentLabel->setVisible(m_BaseData.IsNotNull());
   m_Controls.persistentCheckBox->setVisible(m_BaseData.IsNotNull());
 
   connect(m_Controls.typeComboBox, SIGNAL(currentIndexChanged(const QString&)), this, SLOT(ShowAdequateValueWidget(const QString&)));
   connect(m_Controls.addButton, SIGNAL(clicked()), this, SLOT(AddNewProperty()));
   connect(m_Controls.cancelButton, SIGNAL(clicked()), this, SLOT(reject()));
 
   this->ShowAdequateValueWidget(types[0]);
 }
 
 void QmitkAddNewPropertyDialog::AddNewProperty()
 {
   if (m_Controls.nameLineEdit->text().isEmpty())
   {
     QMessageBox::critical(this, "No name specified", "Enter a property name.");
     return;
   }
 
   if (!this->ValidateValue())
   {
     QMessageBox::critical(this, "Invalid value", "Enter a valid " + m_Controls.typeComboBox->currentText() + " value.");
     return;
   }
 
   if (m_BaseData.IsNotNull())
   {
     mitk::BaseProperty::Pointer property = this->CreateProperty();
     m_BaseData->SetProperty(m_Controls.nameLineEdit->text().toLatin1(), property);
 
     if (m_Controls.persistentCheckBox->isChecked())
     {
-      mitk::IPropertyPersistence* propertyPersistence = mitk::GetPropertyService<mitk::IPropertyPersistence>();
-
-      if (propertyPersistence != nullptr)
-      {
-        mitk::PropertyPersistenceInfo::Pointer info = mitk::PropertyPersistenceInfo::New(m_Controls.nameLineEdit->text().toStdString());
-        propertyPersistence->AddInfo(info);
-      }
+      mitk::CoreServicePointer<mitk::IPropertyPersistence> propertyPersistence(mitk::CoreServices::GetPropertyPersistence());
+      auto info = mitk::PropertyPersistenceInfo::New(m_Controls.nameLineEdit->text().toStdString());
+      propertyPersistence->AddInfo(info);
     }
   }
   else
   {
     m_DataNode->SetProperty(m_Controls.nameLineEdit->text().toLatin1(), this->CreateProperty(), m_Renderer);
   }
 
   this->accept();
 }
 
 mitk::BaseProperty::Pointer QmitkAddNewPropertyDialog::CreateProperty() const
 {
   QString type = m_Controls.typeComboBox->currentText();
 
   if (type == "bool")
   {
     return mitk::BoolProperty::New(m_Controls.valueCheckBox->isChecked()).GetPointer();
   }
   else if (type == "double")
   {
     return mitk::DoubleProperty::New(m_Controls.valueLineEdit->text().toDouble()).GetPointer();
   }
   else if (type == "float")
   {
     return mitk::FloatProperty::New(m_Controls.valueLineEdit->text().toFloat()).GetPointer();
   }
   else if (type == "int")
   {
     return mitk::IntProperty::New(m_Controls.valueLineEdit->text().toInt()).GetPointer();
   }
   else if (type == "string")
   {
     return mitk::StringProperty::New(m_Controls.valueLineEdit->text().toStdString()).GetPointer();
   }
   else
   {
     assert(false && "Property creation for selected type not implemented!");
   }
 
   return nullptr;
 }
 
 bool QmitkAddNewPropertyDialog::ValidateValue()
 {
   QString type = m_Controls.typeComboBox->currentText();
 
   if (type == "bool")
   {
     return true;
   }
   else if (type == "double")
   {
     bool ok = false;
     m_Controls.valueLineEdit->text().toDouble(&ok);
 
     return ok;
   }
   else if (type == "float")
   {
     bool ok = false;
     m_Controls.valueLineEdit->text().toFloat(&ok);
 
     return ok;
   }
   else if (type == "int")
   {
     bool ok = false;
     m_Controls.valueLineEdit->text().toInt(&ok);
 
     return ok;
   }
   else if (type == "string")
   {
     return true;
   }
   else
   {
     assert(false && "Value validation for selected type not implemented!");
   }
 
   return false;
 }
 
 void QmitkAddNewPropertyDialog::ShowAdequateValueWidget(const QString& type)
 {
   m_Controls.valueLineEdit->clear();
   m_Controls.valueLineEdit->hide();
 
   m_Controls.valueCheckBox->setChecked(false);
   m_Controls.valueCheckBox->hide();
 
   if (type == "bool")
   {
     m_Controls.valueCheckBox->show();
   }
   else if (type == "double")
   {
     m_Controls.valueLineEdit->setText("0");
     m_Controls.valueLineEdit->show();
   }
   else if (type == "float")
   {
     m_Controls.valueLineEdit->setText("0");
     m_Controls.valueLineEdit->show();
   }
   else if (type == "int")
   {
     m_Controls.valueLineEdit->setText("0");
     m_Controls.valueLineEdit->show();
   }
   else if (type == "string")
   {
     m_Controls.valueLineEdit->show();
   }
   else
   {
     assert(false && "No adequate value widget specified for selected type!");
   }
 }
diff --git a/Plugins/org.mitk.gui.qt.properties/src/internal/QmitkPropertiesPreferencePage.cpp b/Plugins/org.mitk.gui.qt.properties/src/internal/QmitkPropertiesPreferencePage.cpp
deleted file mode 100644
index 702fab3cb9..0000000000
--- a/Plugins/org.mitk.gui.qt.properties/src/internal/QmitkPropertiesPreferencePage.cpp
+++ /dev/null
@@ -1,83 +0,0 @@
-/*============================================================================
-
-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 "QmitkPropertiesPreferencePage.h"
-#include <berryIPreferencesService.h>
-#include <berryPlatform.h>
-
-const QString QmitkPropertiesPreferencePage::FILTER_PROPERTIES = "filter properties";
-const QString QmitkPropertiesPreferencePage::SHOW_ALIASES = "show aliases";
-const QString QmitkPropertiesPreferencePage::SHOW_DESCRIPTIONS = "show descriptions";
-const QString QmitkPropertiesPreferencePage::SHOW_ALIASES_IN_DESCRIPTION = "show aliases in description";
-const QString QmitkPropertiesPreferencePage::SHOW_PERSISTENCE_IN_DESCRIPTION = "show persistence in description";
-const QString QmitkPropertiesPreferencePage::DEVELOPER_MODE = "enable developer mode";
-
-QmitkPropertiesPreferencePage::QmitkPropertiesPreferencePage()
-  : m_Control(nullptr),
-    m_Preferences(berry::Platform::GetPreferencesService()->GetSystemPreferences()->Node("/org.mitk.views.properties"))
-{
-}
-
-QmitkPropertiesPreferencePage::~QmitkPropertiesPreferencePage()
-{
-}
-
-void QmitkPropertiesPreferencePage::CreateQtControl(QWidget* parent)
-{
-  m_Control = new QWidget(parent);
-  m_Controls.setupUi(m_Control);
-
-  connect(m_Controls.showDescriptionsCheckBox, SIGNAL(stateChanged(int)), this, SLOT(OnShowDescriptionsStateChanged(int)));
-
-  this->Update();
-}
-
-QWidget* QmitkPropertiesPreferencePage::GetQtControl() const
-{
-  return m_Control;
-}
-
-void QmitkPropertiesPreferencePage::Init(berry::IWorkbench::Pointer)
-{
-}
-
-void QmitkPropertiesPreferencePage::OnShowDescriptionsStateChanged(int state)
-{
-  m_Controls.showAliasesInDescriptionCheckBox->setEnabled(state != Qt::Unchecked);
-  m_Controls.showPersistenceInDescriptionCheckBox->setEnabled(state != Qt::Unchecked);
-}
-
-bool QmitkPropertiesPreferencePage::PerformOk()
-{
-  m_Preferences->PutBool(FILTER_PROPERTIES, m_Controls.filterPropertiesCheckBox->isChecked());
-  m_Preferences->PutBool(SHOW_ALIASES, m_Controls.showAliasesCheckBox->isChecked());
-  m_Preferences->PutBool(SHOW_DESCRIPTIONS, m_Controls.showDescriptionsCheckBox->isChecked());
-  m_Preferences->PutBool(SHOW_ALIASES_IN_DESCRIPTION, m_Controls.showAliasesInDescriptionCheckBox->isChecked());
-  m_Preferences->PutBool(SHOW_PERSISTENCE_IN_DESCRIPTION, m_Controls.showPersistenceInDescriptionCheckBox->isChecked());
-  m_Preferences->PutBool(DEVELOPER_MODE, m_Controls.enableDeveloperModeCheckBox->isChecked());
-
-  return true;
-}
-
-void QmitkPropertiesPreferencePage::PerformCancel()
-{
-}
-
-void QmitkPropertiesPreferencePage::Update()
-{
-  m_Controls.filterPropertiesCheckBox->setChecked(m_Preferences->GetBool(FILTER_PROPERTIES, true));
-  m_Controls.showAliasesCheckBox->setChecked(m_Preferences->GetBool(SHOW_ALIASES, true));
-  m_Controls.showDescriptionsCheckBox->setChecked(m_Preferences->GetBool(SHOW_DESCRIPTIONS, true));
-  m_Controls.showAliasesInDescriptionCheckBox->setChecked(m_Preferences->GetBool(SHOW_ALIASES_IN_DESCRIPTION, true));
-  m_Controls.showPersistenceInDescriptionCheckBox->setChecked(m_Preferences->GetBool(SHOW_PERSISTENCE_IN_DESCRIPTION, true));
-  m_Controls.enableDeveloperModeCheckBox->setChecked(m_Preferences->GetBool(DEVELOPER_MODE, false));
-}
diff --git a/Plugins/org.mitk.gui.qt.properties/src/internal/QmitkPropertiesPreferencePage.h b/Plugins/org.mitk.gui.qt.properties/src/internal/QmitkPropertiesPreferencePage.h
deleted file mode 100644
index a204e50038..0000000000
--- a/Plugins/org.mitk.gui.qt.properties/src/internal/QmitkPropertiesPreferencePage.h
+++ /dev/null
@@ -1,51 +0,0 @@
-/*============================================================================
-
-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 QmitkPropertiesPreferencePage_h
-#define QmitkPropertiesPreferencePage_h
-
-#include <berryIQtPreferencePage.h>
-#include <ui_QmitkPropertiesPreferencePage.h>
-
-class QmitkPropertiesPreferencePage : public QObject, public berry::IQtPreferencePage
-{
-  Q_OBJECT
-  Q_INTERFACES(berry::IPreferencePage)
-
-public:
-  static const QString FILTER_PROPERTIES;
-  static const QString SHOW_ALIASES;
-  static const QString SHOW_DESCRIPTIONS;
-  static const QString SHOW_ALIASES_IN_DESCRIPTION;
-  static const QString SHOW_PERSISTENCE_IN_DESCRIPTION;
-  static const QString DEVELOPER_MODE;
-
-  QmitkPropertiesPreferencePage();
-  ~QmitkPropertiesPreferencePage() override;
-
-  void CreateQtControl(QWidget* parent) override;
-  QWidget* GetQtControl() const override;
-  void Init(berry::IWorkbench::Pointer workbench) override;
-  bool PerformOk() override;
-  void PerformCancel() override;
-  void Update() override;
-
-private slots:
-  void OnShowDescriptionsStateChanged(int state);
-
-private:
-  QWidget* m_Control;
-  Ui::QmitkPropertiesPreferencePage m_Controls;
-  berry::IPreferences::Pointer m_Preferences;
-};
-
-#endif
diff --git a/Plugins/org.mitk.gui.qt.properties/src/internal/QmitkPropertiesPreferencePage.ui b/Plugins/org.mitk.gui.qt.properties/src/internal/QmitkPropertiesPreferencePage.ui
deleted file mode 100644
index 2732cacb72..0000000000
--- a/Plugins/org.mitk.gui.qt.properties/src/internal/QmitkPropertiesPreferencePage.ui
+++ /dev/null
@@ -1,143 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<ui version="4.0">
- <class>QmitkPropertiesPreferencePage</class>
- <widget class="QWidget" name="QmitkPropertiesPreferencePage">
-  <property name="geometry">
-   <rect>
-    <x>0</x>
-    <y>0</y>
-    <width>400</width>
-    <height>577</height>
-   </rect>
-  </property>
-  <property name="windowTitle">
-   <string/>
-  </property>
-  <layout class="QVBoxLayout" name="verticalLayout_5">
-   <item>
-    <widget class="QGroupBox" name="aliasesGroupBox">
-     <property name="title">
-      <string>Aliases</string>
-     </property>
-     <layout class="QVBoxLayout" name="verticalLayout_2">
-      <item>
-       <widget class="QCheckBox" name="showAliasesCheckBox">
-        <property name="text">
-         <string>Replace genuine property names by aliases</string>
-        </property>
-        <property name="checked">
-         <bool>true</bool>
-        </property>
-       </widget>
-      </item>
-     </layout>
-    </widget>
-   </item>
-   <item>
-    <widget class="QGroupBox" name="descriptionsGroupBox">
-     <property name="title">
-      <string>Descriptions</string>
-     </property>
-     <layout class="QVBoxLayout" name="verticalLayout">
-      <item>
-       <widget class="QCheckBox" name="showDescriptionsCheckBox">
-        <property name="text">
-         <string>Show descriptions</string>
-        </property>
-        <property name="checked">
-         <bool>true</bool>
-        </property>
-       </widget>
-      </item>
-      <item>
-       <widget class="QCheckBox" name="showAliasesInDescriptionCheckBox">
-        <property name="styleSheet">
-         <string notr="true">margin-left: 18px;</string>
-        </property>
-        <property name="text">
-         <string>Show aliases of genuine property names</string>
-        </property>
-        <property name="checked">
-         <bool>true</bool>
-        </property>
-       </widget>
-      </item>
-      <item>
-       <widget class="QCheckBox" name="showPersistenceInDescriptionCheckBox">
-        <property name="styleSheet">
-         <string notr="true">margin-left: 18px;</string>
-        </property>
-        <property name="text">
-         <string>Show persistence info</string>
-        </property>
-        <property name="checked">
-         <bool>true</bool>
-        </property>
-       </widget>
-      </item>
-     </layout>
-    </widget>
-   </item>
-   <item>
-    <widget class="QGroupBox" name="filtersGroupBox">
-     <property name="title">
-      <string>Filters</string>
-     </property>
-     <layout class="QVBoxLayout" name="verticalLayout_3">
-      <item>
-       <widget class="QCheckBox" name="filterPropertiesCheckBox">
-        <property name="text">
-         <string>Only show filtered properties</string>
-        </property>
-        <property name="checked">
-         <bool>true</bool>
-        </property>
-       </widget>
-      </item>
-     </layout>
-    </widget>
-   </item>
-   <item>
-    <widget class="QGroupBox" name="developerModeGroupBox">
-     <property name="title">
-      <string>Developer Mode</string>
-     </property>
-     <layout class="QVBoxLayout" name="verticalLayout_4">
-      <item>
-       <widget class="QCheckBox" name="enableDeveloperModeCheckBox">
-        <property name="enabled">
-         <bool>true</bool>
-        </property>
-        <property name="text">
-         <string>Enabled</string>
-        </property>
-        <property name="checked">
-         <bool>false</bool>
-        </property>
-       </widget>
-      </item>
-     </layout>
-    </widget>
-   </item>
-   <item>
-    <spacer name="verticalSpacer">
-     <property name="orientation">
-      <enum>Qt::Vertical</enum>
-     </property>
-     <property name="sizeHint" stdset="0">
-      <size>
-       <width>20</width>
-       <height>204</height>
-      </size>
-     </property>
-    </spacer>
-   </item>
-  </layout>
- </widget>
- <tabstops>
-  <tabstop>showAliasesCheckBox</tabstop>
-  <tabstop>showDescriptionsCheckBox</tabstop>
- </tabstops>
- <resources/>
- <connections/>
-</ui>
diff --git a/Plugins/org.mitk.gui.qt.properties/src/internal/QmitkPropertyTreeView.cpp b/Plugins/org.mitk.gui.qt.properties/src/internal/QmitkPropertyTreeView.cpp
index e70d8edae3..7d2d2f0ce5 100644
--- a/Plugins/org.mitk.gui.qt.properties/src/internal/QmitkPropertyTreeView.cpp
+++ b/Plugins/org.mitk.gui.qt.properties/src/internal/QmitkPropertyTreeView.cpp
@@ -1,439 +1,364 @@
 /*============================================================================
 
 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 "mitkGetPropertyService.h"
 #include "QmitkAddNewPropertyDialog.h"
-#include "QmitkPropertiesPreferencePage.h"
 #include "QmitkPropertyItemDelegate.h"
 #include "QmitkPropertyItemModel.h"
 #include "QmitkPropertyItemSortFilterProxyModel.h"
 #include "QmitkPropertyTreeView.h"
 #include <berryIBerryPreferences.h>
 #include <berryQtStyleManager.h>
 #include <mitkIPropertyAliases.h>
 #include <mitkIPropertyDescriptions.h>
 #include <mitkIPropertyPersistence.h>
 #include <QmitkRenderWindow.h>
 #include <QPainter>
 #include <memory>
 
 const std::string QmitkPropertyTreeView::VIEW_ID = "org.mitk.views.properties";
 
 QmitkPropertyTreeView::QmitkPropertyTreeView()
-  : m_PropertyAliases(nullptr),
-    m_PropertyDescriptions(nullptr),
-    m_PropertyPersistence(nullptr),
-    m_ShowAliasesInDescription(true),
-    m_ShowPersistenceInDescription(true),
-    m_DeveloperMode(false),
+  : m_PropertyAliases(mitk::CoreServices::GetPropertyAliases(nullptr), nullptr),
+    m_PropertyDescriptions(mitk::CoreServices::GetPropertyDescriptions(nullptr), nullptr),
+    m_PropertyPersistence(mitk::CoreServices::GetPropertyPersistence(nullptr), nullptr),
     m_ProxyModel(nullptr),
     m_Model(nullptr),
     m_Delegate(nullptr),
     m_Renderer(nullptr)
 {
 }
 
 QmitkPropertyTreeView::~QmitkPropertyTreeView()
 {
 }
 
 void QmitkPropertyTreeView::SetFocus()
 {
   m_Controls.filterLineEdit->setFocus();
 }
 
 void QmitkPropertyTreeView::RenderWindowPartActivated(mitk::IRenderWindowPart* /*renderWindowPart*/)
 {
   if (m_Controls.propertyListComboBox->count() == 2)
   {
     QHash<QString, QmitkRenderWindow*> renderWindows = this->GetRenderWindowPart()->GetQmitkRenderWindows();
 
     Q_FOREACH(QString renderWindow, renderWindows.keys())
     {
       m_Controls.propertyListComboBox->insertItem(m_Controls.propertyListComboBox->count() - 1, QString("Data node: ") + renderWindow);
     }
   }
 }
 
 void QmitkPropertyTreeView::RenderWindowPartDeactivated(mitk::IRenderWindowPart*)
 {
   if (m_Controls.propertyListComboBox->count() > 2)
   {
     m_Controls.propertyListComboBox->clear();
     m_Controls.propertyListComboBox->addItem("Data node: common");
     m_Controls.propertyListComboBox->addItem("Base data");
   }
 }
 
 void QmitkPropertyTreeView::CreateQtPartControl(QWidget* parent)
 {
   m_Controls.setupUi(parent);
 
   m_Controls.propertyListComboBox->addItem("Data node: common");
 
   mitk::IRenderWindowPart* renderWindowPart = this->GetRenderWindowPart();
   if (renderWindowPart != nullptr)
   {
     QHash<QString, QmitkRenderWindow*> renderWindows = renderWindowPart->GetQmitkRenderWindows();
 
     for(const auto& renderWindow : renderWindows.keys())
     {
       m_Controls.propertyListComboBox->addItem(QString("Data node: ") + renderWindow);
     }
   }
 
   m_Controls.propertyListComboBox->addItem("Base data");
 
   m_Controls.newButton->setEnabled(false);
 
   this->HideAllIcons();
-  m_Controls.descriptionLabel->hide();
-  m_Controls.propertyListLabel->hide();
-  m_Controls.propertyListComboBox->hide();
-  m_Controls.newButton->hide();
 
   m_ProxyModel = new QmitkPropertyItemSortFilterProxyModel(m_Controls.treeView);
   m_Model = new QmitkPropertyItemModel(m_ProxyModel);
 
   m_ProxyModel->setSourceModel(m_Model);
   m_ProxyModel->setFilterCaseSensitivity(Qt::CaseInsensitive);
   m_ProxyModel->setSortCaseSensitivity(Qt::CaseInsensitive);
   m_ProxyModel->setDynamicSortFilter(true);
 
   m_Delegate = new QmitkPropertyItemDelegate(m_Controls.treeView);
 
   m_Controls.singleSlot->SetDataStorage(GetDataStorage());
   m_Controls.singleSlot->SetSelectionIsOptional(true);
   m_Controls.singleSlot->SetEmptyInfo(QString("Please select a data node"));
   m_Controls.singleSlot->SetPopUpTitel(QString("Select data node"));
 
   m_SelectionServiceConnector = std::make_unique<QmitkSelectionServiceConnector>();
   SetAsSelectionListener(true);
 
   m_Controls.filterLineEdit->setClearButtonEnabled(true);
 
   m_Controls.treeView->setItemDelegateForColumn(1, m_Delegate);
   m_Controls.treeView->setModel(m_ProxyModel);
   m_Controls.treeView->setColumnWidth(0, 160);
   m_Controls.treeView->sortByColumn(0, Qt::AscendingOrder);
   m_Controls.treeView->setSelectionBehavior(QAbstractItemView::SelectRows);
   m_Controls.treeView->setSelectionMode(QAbstractItemView::SingleSelection);
   m_Controls.treeView->setEditTriggers(QAbstractItemView::SelectedClicked | QAbstractItemView::DoubleClicked);
 
   const int ICON_SIZE = 32;
 
   auto icon = berry::QtStyleManager::ThemeIcon(QStringLiteral(":/org_mitk_icons/icons/awesome/scalable/tags.svg"));
   m_Controls.tagsLabel->setPixmap(icon.pixmap(ICON_SIZE));
 
   icon = berry::QtStyleManager::ThemeIcon(QStringLiteral(":/org_mitk_icons/icons/awesome/scalable/tag.svg"));
   m_Controls.tagLabel->setPixmap(icon.pixmap(ICON_SIZE));
 
   icon = berry::QtStyleManager::ThemeIcon(QStringLiteral(":/org_mitk_icons/icons/awesome/scalable/actions/document-save.svg"));
   m_Controls.saveLabel->setPixmap(icon.pixmap(ICON_SIZE));
 
   connect(m_Controls.singleSlot, &QmitkSingleNodeSelectionWidget::CurrentSelectionChanged,
     this, &QmitkPropertyTreeView::OnCurrentSelectionChanged);
   connect(m_Controls.filterLineEdit, &QLineEdit::textChanged,
     this, &QmitkPropertyTreeView::OnFilterTextChanged);
   connect(m_Controls.propertyListComboBox, static_cast<void (QComboBox::*)(int)>(&QComboBox::currentIndexChanged),
     this, &QmitkPropertyTreeView::OnPropertyListChanged);
   connect(m_Controls.newButton, &QPushButton::clicked,
     this, &QmitkPropertyTreeView::OnAddNewProperty);
   connect(m_Controls.treeView->selectionModel(), &QItemSelectionModel::currentRowChanged,
     this, &QmitkPropertyTreeView::OnCurrentRowChanged);
   connect(m_Model, &QmitkPropertyItemModel::modelReset,
     this, &QmitkPropertyTreeView::OnModelReset);
 }
 
-void QmitkPropertyTreeView::OnPreferencesChanged(const berry::IBerryPreferences* preferences)
-{
-  bool showAliases = preferences->GetBool(QmitkPropertiesPreferencePage::SHOW_ALIASES, true);
-  bool showDescriptions = preferences->GetBool(QmitkPropertiesPreferencePage::SHOW_DESCRIPTIONS, true);
-  bool showAliasesInDescription = preferences->GetBool(QmitkPropertiesPreferencePage::SHOW_ALIASES_IN_DESCRIPTION, true);
-  bool showPersistenceInDescription = preferences->GetBool(QmitkPropertiesPreferencePage::SHOW_PERSISTENCE_IN_DESCRIPTION, true);
-  bool developerMode = preferences->GetBool(QmitkPropertiesPreferencePage::DEVELOPER_MODE, false);
-  bool filterProperties = preferences->GetBool(QmitkPropertiesPreferencePage::FILTER_PROPERTIES, true);
-
-  m_Model->SetFilterProperties(filterProperties);
-  m_Model->SetShowAliases(showAliases);
-
-  bool updateAliases = showAliases != (m_PropertyAliases != nullptr);
-  bool updateDescriptions = showDescriptions != (m_PropertyDescriptions != nullptr);
-  bool updateAliasesInDescription = showAliasesInDescription != m_ShowAliasesInDescription;
-  bool updatePersistenceInDescription = showPersistenceInDescription != m_ShowPersistenceInDescription;
-  bool updateDeveloperMode = developerMode != m_DeveloperMode;
-
-  if (updateAliases)
-    m_PropertyAliases = showAliases
-    ? mitk::GetPropertyService<mitk::IPropertyAliases>()
-    : nullptr;
-
-  if (updateDescriptions)
-    m_PropertyDescriptions = showDescriptions
-    ? mitk::GetPropertyService<mitk::IPropertyDescriptions>()
-    : nullptr;
-
-  if (showPersistenceInDescription)
-    m_PropertyPersistence = mitk::GetPropertyService<mitk::IPropertyPersistence>();
-
-  if (updateAliasesInDescription)
-    m_ShowAliasesInDescription = showAliasesInDescription;
-
-  if (updatePersistenceInDescription)
-    m_ShowPersistenceInDescription = showPersistenceInDescription;
-
-  if (updateDescriptions || updateAliasesInDescription || updatePersistenceInDescription)
-  {
-    QModelIndexList selection = m_Controls.treeView->selectionModel()->selectedRows();
-
-    if (!selection.isEmpty())
-      this->OnCurrentRowChanged(selection[0], selection[0]);
-  }
-
-  if (updateDeveloperMode)
-  {
-    m_DeveloperMode = developerMode;
-
-    if (!developerMode)
-      m_Controls.propertyListComboBox->setCurrentIndex(0);
-
-    m_Controls.propertyListLabel->setVisible(developerMode);
-    m_Controls.propertyListComboBox->setVisible(developerMode);
-    m_Controls.newButton->setVisible(developerMode);
-  }
-
-  m_Model->OnPreferencesChanged();
-}
-
 void QmitkPropertyTreeView::SetAsSelectionListener(bool checked)
 {
   if (checked)
   {
     m_SelectionServiceConnector->AddPostSelectionListener(GetSite()->GetWorkbenchWindow()->GetSelectionService());
     connect(m_SelectionServiceConnector.get(), &QmitkSelectionServiceConnector::ServiceSelectionChanged, m_Controls.singleSlot, &QmitkSingleNodeSelectionWidget::SetCurrentSelection);
   }
   else
   {
     m_SelectionServiceConnector->RemovePostSelectionListener();
     disconnect(m_SelectionServiceConnector.get(), &QmitkSelectionServiceConnector::ServiceSelectionChanged, m_Controls.singleSlot, &QmitkSingleNodeSelectionWidget::SetCurrentSelection);
   }
 }
 
 QString QmitkPropertyTreeView::GetPropertyNameOrAlias(const QModelIndex& index)
 {
   QString propertyName;
 
   if (index.isValid())
   {
     QModelIndex current = index;
 
     while (current.isValid())
     {
       QString name = m_ProxyModel->data(m_ProxyModel->index(current.row(), 0, current.parent())).toString();
 
       propertyName.prepend(propertyName.isEmpty()
         ? name
         : name.append('.'));
 
       current = current.parent();
     }
   }
 
   return propertyName;
 }
 
 void QmitkPropertyTreeView::OnCurrentSelectionChanged(QList<mitk::DataNode::Pointer> nodes)
 {
   if (nodes.empty() || nodes.front().IsNull())
   {
     m_SelectedNode = nullptr;
 
     this->SetPartName("Properties");
     m_Model->SetPropertyList(nullptr);
     m_Delegate->SetPropertyList(nullptr);
 
     m_Controls.newButton->setEnabled(false);
 
     return;
   }
 
   // node is selected, create tree with node properties
   m_SelectedNode = nodes.front();
   mitk::PropertyList* propertyList = m_Model->GetPropertyList();
   if (m_Renderer == nullptr && m_Controls.propertyListComboBox->currentText() == "Base data")
   {
     propertyList = m_SelectedNode->GetData() != nullptr
       ? m_SelectedNode->GetData()->GetPropertyList()
       : nullptr;
   }
   else
   {
     propertyList = m_SelectedNode->GetPropertyList(m_Renderer);
   }
 
   QString selectionClassName = m_SelectedNode->GetData() != nullptr
     ? m_SelectedNode->GetData()->GetNameOfClass()
     : "";
 
   m_SelectionClassName = selectionClassName.toStdString();
 
   m_Model->SetPropertyList(propertyList, selectionClassName);
   m_Delegate->SetPropertyList(propertyList);
 
   m_Controls.newButton->setEnabled(true);
 
   if (!m_ProxyModel->filterRegExp().isEmpty())
   {
     m_Controls.treeView->expandAll();
   }
 }
 
 void QmitkPropertyTreeView::HideAllIcons()
 {
   m_Controls.tagLabel->hide();
   m_Controls.tagsLabel->hide();
   m_Controls.saveLabel->hide();
 }
 
 void QmitkPropertyTreeView::OnCurrentRowChanged(const QModelIndex& current, const QModelIndex&)
 {
-  if (m_PropertyDescriptions != nullptr && current.isValid())
+  if (current.isValid())
   {
     QString name = this->GetPropertyNameOrAlias(current);
 
     if (!name.isEmpty())
     {
       QString alias;
       bool isTrueName = true;
 
-      if (m_PropertyAliases != nullptr)
-      {
-        std::string trueName = m_PropertyAliases->GetPropertyName(name.toStdString());
+      std::string trueName = m_PropertyAliases->GetPropertyName(name.toStdString());
 
-        if (trueName.empty() && !m_SelectionClassName.empty())
-          trueName = m_PropertyAliases->GetPropertyName(name.toStdString(), m_SelectionClassName);
+      if (trueName.empty() && !m_SelectionClassName.empty())
+        trueName = m_PropertyAliases->GetPropertyName(name.toStdString(), m_SelectionClassName);
 
-        if (!trueName.empty())
-        {
-          alias = name;
-          name = QString::fromStdString(trueName);
-          isTrueName = false;
-        }
+      if (!trueName.empty())
+      {
+        alias = name;
+        name = QString::fromStdString(trueName);
+        isTrueName = false;
       }
 
       QString description = QString::fromStdString(m_PropertyDescriptions->GetDescription(name.toStdString()));
       std::vector<std::string> aliases;
 
-      if (!isTrueName && m_PropertyAliases != nullptr)
+      if (!isTrueName)
       {
         aliases = m_PropertyAliases->GetAliases(name.toStdString(), m_SelectionClassName);
 
         if (aliases.empty() && !m_SelectionClassName.empty())
           aliases = m_PropertyAliases->GetAliases(name.toStdString());
       }
 
-      bool isPersistent = false;
-
-      if (m_PropertyPersistence != nullptr)
-        isPersistent = m_PropertyPersistence->HasInfo(name.toStdString());
+      bool isPersistent = m_PropertyPersistence->HasInfo(name.toStdString());
 
       if (!description.isEmpty() || !aliases.empty() || isPersistent)
       {
         QString customizedDescription;
 
-        if (m_ShowAliasesInDescription && !aliases.empty())
+        if (!aliases.empty())
         {
           customizedDescription = "<h3 style=\"margin-bottom:0\">" + name + "</h3>";
 
           std::size_t numAliases = aliases.size();
           std::size_t lastAlias = numAliases - 1;
 
           for (std::size_t i = 0; i < numAliases; ++i)
           {
             customizedDescription += i != lastAlias
               ? "<h5 style=\"margin-top:0;margin-bottom:0\">"
               : "<h5 style=\"margin-top:0;margin-bottom:10px\">";
 
             customizedDescription += QString::fromStdString(aliases[i]) + "</h5>";
           }
         }
         else
         {
           customizedDescription = "<h3 style=\"margin-bottom:10px\">" + name + "</h3>";
         }
 
         if (!description.isEmpty())
           customizedDescription += "<p>" + description + "</p>";
 
         m_Controls.tagsLabel->setVisible(!aliases.empty() && aliases.size() > 1);
         m_Controls.tagLabel->setVisible(!aliases.empty() && aliases.size() == 1);
         m_Controls.saveLabel->setVisible(isPersistent);
 
         m_Controls.descriptionLabel->setText(customizedDescription);
         m_Controls.descriptionLabel->show();
 
         return;
       }
     }
   }
 
   m_Controls.descriptionLabel->hide();
   this->HideAllIcons();
 }
 
 void QmitkPropertyTreeView::OnPropertyListChanged(int index)
 {
   if (index == -1)
     return;
 
   QString renderer = m_Controls.propertyListComboBox->itemText(index);
 
   if (renderer.startsWith("Data node: "))
     renderer = QString::fromStdString(renderer.toStdString().substr(11));
 
   m_Renderer = renderer != "common" && renderer != "Base data"
     ? this->GetRenderWindowPart()->GetQmitkRenderWindow(renderer)->GetRenderer()
     : nullptr;
 
   QList<mitk::DataNode::Pointer> nodes;
 
   if (m_SelectedNode.IsNotNull())
     nodes << m_SelectedNode;
 
   this->OnCurrentSelectionChanged(nodes);
 }
 
 void QmitkPropertyTreeView::OnAddNewProperty()
 {
   std::unique_ptr<QmitkAddNewPropertyDialog> dialog(m_Controls.propertyListComboBox->currentText() != "Base data"
     ? new QmitkAddNewPropertyDialog(m_SelectedNode, m_Renderer)
     : new QmitkAddNewPropertyDialog(m_SelectedNode->GetData()));
 
   if (dialog->exec() == QDialog::Accepted)
     this->m_Model->Update();
 }
 
 void QmitkPropertyTreeView::OnFilterTextChanged(const QString& filter)
 {
   m_ProxyModel->setFilterWildcard(filter);
 
   if (filter.isEmpty())
     m_Controls.treeView->collapseAll();
   else
     m_Controls.treeView->expandAll();
 }
 
 void QmitkPropertyTreeView::OnModelReset()
 {
   m_Controls.descriptionLabel->hide();
   this->HideAllIcons();
 }
diff --git a/Plugins/org.mitk.gui.qt.properties/src/internal/QmitkPropertyTreeView.h b/Plugins/org.mitk.gui.qt.properties/src/internal/QmitkPropertyTreeView.h
index f0621609a7..7750155927 100644
--- a/Plugins/org.mitk.gui.qt.properties/src/internal/QmitkPropertyTreeView.h
+++ b/Plugins/org.mitk.gui.qt.properties/src/internal/QmitkPropertyTreeView.h
@@ -1,99 +1,95 @@
 /*============================================================================
 
 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 QmitkPropertyTreeView_h
 #define QmitkPropertyTreeView_h
 
 #include <ui_QmitkPropertyTreeView.h>
 
 // mitk core module
+#include <mitkCoreServices.h>
 #include <mitkDataNode.h>
 
 // mitk gui common plugin
 #include <mitkIRenderWindowPartListener.h>
 
 // mitk gui qt common plugin
 #include <QmitkAbstractView.h>
 #include "QmitkSelectionServiceConnector.h"
 
 class QmitkPropertyItemDelegate;
 class QmitkPropertyItemModel;
 class QmitkPropertyItemSortFilterProxyModel;
 
 namespace mitk
 {
   class IPropertyAliases;
   class IPropertyDescriptions;
   class IPropertyPersistence;
 }
 
 class QmitkPropertyTreeView : public QmitkAbstractView, public mitk::IRenderWindowPartListener
 {
   Q_OBJECT
 
 public:
 
   static const std::string VIEW_ID;
 
   berryObjectMacro(QmitkPropertyTreeView);
 
   QmitkPropertyTreeView();
   ~QmitkPropertyTreeView() override;
 
   void SetFocus() override;
 
   void RenderWindowPartActivated(mitk::IRenderWindowPart* renderWindowPart) override;
   void RenderWindowPartDeactivated(mitk::IRenderWindowPart*) override;
 
 protected:
 
   void CreateQtPartControl(QWidget* parent) override;
 
 private:
 
-  void OnPreferencesChanged(const berry::IBerryPreferences* preferences) override;
-
   void SetAsSelectionListener(bool checked);
 
   QString GetPropertyNameOrAlias(const QModelIndex& index);
 
   void OnCurrentSelectionChanged(QList<mitk::DataNode::Pointer> nodes);
   void HideAllIcons();
 
 private Q_SLOTS:
 
   void OnCurrentRowChanged(const QModelIndex& current, const QModelIndex& previous);
   void OnPropertyListChanged(int index);
   void OnAddNewProperty();
   void OnFilterTextChanged(const QString& filter);
   void OnModelReset();
 
 private:
 
   std::string m_SelectionClassName;
-  mitk::IPropertyAliases* m_PropertyAliases;
-  mitk::IPropertyDescriptions* m_PropertyDescriptions;
-  mitk::IPropertyPersistence* m_PropertyPersistence;
-  bool m_ShowAliasesInDescription;
-  bool m_ShowPersistenceInDescription;
-  bool m_DeveloperMode;
+  mitk::CoreServicePointer<mitk::IPropertyAliases> m_PropertyAliases;
+  mitk::CoreServicePointer<mitk::IPropertyDescriptions> m_PropertyDescriptions;
+  mitk::CoreServicePointer<mitk::IPropertyPersistence> m_PropertyPersistence;
   Ui::QmitkPropertyTreeView m_Controls;
   QmitkPropertyItemSortFilterProxyModel* m_ProxyModel;
   QmitkPropertyItemModel* m_Model;
   QmitkPropertyItemDelegate* m_Delegate;
   mitk::DataNode::Pointer m_SelectedNode;
   mitk::BaseRenderer* m_Renderer;
 
   std::unique_ptr<QmitkSelectionServiceConnector> m_SelectionServiceConnector;
 };
 
 #endif
diff --git a/Plugins/org.mitk.gui.qt.properties/src/internal/mitkGetPropertyService.h b/Plugins/org.mitk.gui.qt.properties/src/internal/mitkGetPropertyService.h
deleted file mode 100644
index e9f423bc01..0000000000
--- a/Plugins/org.mitk.gui.qt.properties/src/internal/mitkGetPropertyService.h
+++ /dev/null
@@ -1,32 +0,0 @@
-/*============================================================================
-
-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 mitkGetPropertyService_h
-#define mitkGetPropertyService_h
-
-#include "org_mitk_gui_qt_properties_Activator.h"
-
-namespace mitk
-{
-  template <class T>
-  T* GetPropertyService()
-  {
-    ctkPluginContext* context = mitk::org_mitk_gui_qt_properties_Activator::GetContext();
-    ctkServiceReference serviceRef = context->getServiceReference<T>();
-
-    return serviceRef
-      ? context->getService<T>(serviceRef)
-      : nullptr;
-  }
-}
-
-#endif
diff --git a/Plugins/org.mitk.gui.qt.properties/src/internal/org_mitk_gui_qt_properties_Activator.cpp b/Plugins/org.mitk.gui.qt.properties/src/internal/org_mitk_gui_qt_properties_Activator.cpp
index 2211f4f2d1..0f96026582 100644
--- a/Plugins/org.mitk.gui.qt.properties/src/internal/org_mitk_gui_qt_properties_Activator.cpp
+++ b/Plugins/org.mitk.gui.qt.properties/src/internal/org_mitk_gui_qt_properties_Activator.cpp
@@ -1,34 +1,32 @@
 /*============================================================================
 
 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 "org_mitk_gui_qt_properties_Activator.h"
-#include "QmitkPropertiesPreferencePage.h"
 #include "QmitkPropertyTreeView.h"
 
 ctkPluginContext* mitk::org_mitk_gui_qt_properties_Activator::m_Context = nullptr;
 
 ctkPluginContext* mitk::org_mitk_gui_qt_properties_Activator::GetContext()
 {
   return m_Context;
 }
 
 void mitk::org_mitk_gui_qt_properties_Activator::start(ctkPluginContext* context)
 {
-  BERRY_REGISTER_EXTENSION_CLASS(QmitkPropertiesPreferencePage, context);
   BERRY_REGISTER_EXTENSION_CLASS(QmitkPropertyTreeView, context);
   m_Context = context;
 }
 
 void mitk::org_mitk_gui_qt_properties_Activator::stop(ctkPluginContext*)
 {
   m_Context = nullptr;
 }