diff --git a/libs/store/KoZipStore.cpp b/libs/store/KoZipStore.cpp
index 8446d9c9d0..68b867af34 100644
--- a/libs/store/KoZipStore.cpp
+++ b/libs/store/KoZipStore.cpp
@@ -1,242 +1,273 @@
 /* This file is part of the KDE project
    Copyright (C) 2000-2002 David Faure <faure@kde.org>
    Copyright (C) 2010 C. Boemann <cbo@boemann.dk>
 
    This library is free software; you can redistribute it and/or
    modify it under the terms of the GNU Library General Public
    License as published by the Free Software Foundation; either
    version 2 of the License, or (at your option) any later version.
 
    This library is distributed in the hope that it will be useful,
    but WITHOUT ANY WARRANTY; without even the implied warranty of
    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
    Library General Public License for more details.
 
    You should have received a copy of the GNU Library General Public License
    along with this library; see the file COPYING.LIB.  If not, write to
    the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
  * Boston, MA 02110-1301, USA.
 */
 
 #include "KoZipStore.h"
 #include "KoStore_p.h"
 
 #include <QBuffer>
 #include <QByteArray>
 #include <QTemporaryFile>
 
 #include <kzip.h>
 #include <StoreDebug.h>
 
 #include <QUrl>
 
+class SaveZip : public KZip {
+public:
+    SaveZip(const QString &filename) : KZip(filename) {}
+    SaveZip(QIODevice *dev) : KZip(dev) {}
+    virtual ~SaveZip() {}
+    void resetDevice() {
+        closeArchive();
+        setDevice(0);
+    }
+};
+
 KoZipStore::KoZipStore(const QString & _filename, Mode mode, const QByteArray & appIdentification,
                        bool writeMimetype)
     : KoStore(mode, writeMimetype)
 {
-    debugStore << "KoZipStore Constructor filename =" << _filename
-               << " mode = " << int(mode)
-               << " mimetype = " << appIdentification << endl;
+//    qDebug() << "KoZipStore Constructor filename =" << _filename
+//               << " mode = " << int(mode)
+//               << " mimetype = " << appIdentification;
     Q_D(KoStore);
 
     d->localFileName = _filename;
 
-    m_pZip = new KZip(_filename);
+    m_pZip = new SaveZip(_filename);
 
     init(appIdentification);   // open the zip file and init some vars
 }
 
 KoZipStore::KoZipStore(QIODevice *dev, Mode mode, const QByteArray & appIdentification,
                        bool writeMimetype)
     : KoStore(mode, writeMimetype)
 {
-    m_pZip = new KZip(dev);
+//    qDebug() << "KoZipStore Constructor device =" << dev
+//               << " mode = " << int(mode)
+//               << " mimetype = " << appIdentification;
+
+    m_pZip = new SaveZip(dev);
     init(appIdentification);
 }
 
 KoZipStore::KoZipStore(QWidget* window, const QUrl &_url, const QString & _filename, Mode mode,
                        const QByteArray & appIdentification, bool writeMimetype)
     : KoStore(mode, writeMimetype)
 {
     debugStore << "KoZipStore Constructor url" << _url.url(QUrl::PreferLocalFile)
                << " filename = " << _filename
                << " mode = " << int(mode)
-               << " mimetype = " << appIdentification << endl;
+               << " mimetype = " << appIdentification;
     Q_D(KoStore);
 
     d->url = _url;
     d->window = window;
 
     if (mode == KoStore::Read) {
         d->localFileName = _filename;
     } else {
         QTemporaryFile f("kozip");
         f.open();
         d->localFileName = f.fileName();
         f.close();
     }
 
-    m_pZip = new KZip(d->localFileName);
+    m_pZip = new SaveZip(d->localFileName);
     init(appIdentification);   // open the zip file and init some vars
 }
 
 KoZipStore::~KoZipStore()
 {
     Q_D(KoStore);
-    debugStore << "KoZipStore::~KoZipStore";
-    if (!d->finalized)
-        finalize(); // ### no error checking when the app forgot to call finalize itself
+    bool sf = false;
+    if (m_pZip && m_pZip->device()) {
+        sf = true;
+    }
+
+//    qDebug() << "KoZipStore::~KoZipStore" << d->localFileName << m_pZip << m_pZip->device() << "savefile" << sf;
+    if (m_pZip->device() && m_pZip->device()->inherits("QSaveFile")) {
+        m_pZip->resetDevice(); // otherwise, kzip's destructor will call close(), which aborts on a qsavefile
+    }
+    else {
+        if (!d->finalized) {
+            finalize(); // ### no error checking when the app forgot to call finalize itself
+        }
+    }
     delete m_pZip;
 
     // When writing, we write to a temp file that then gets copied over the original filename
     if (d->mode == Write && (!d->localFileName.isEmpty() && !d->url.isEmpty())) {
         QFile f(d->localFileName);
         if (f.copy(d->url.toLocalFile())) {
             f.remove();
         }
     }
 }
 
 void KoZipStore::init(const QByteArray& appIdentification)
 {
     Q_D(KoStore);
 
     m_currentDir = 0;
     d->good = m_pZip->open(d->mode == Write ? QIODevice::WriteOnly : QIODevice::ReadOnly);
 
     if (!d->good)
         return;
 
     if (d->mode == Write) {
         //debugStore <<"KoZipStore::init writing mimetype" << appIdentification;
 
         m_pZip->setCompression(KZip::NoCompression);
         m_pZip->setExtraField(KZip::NoExtraField);
 
         // Write identification
         if (d->writeMimetype) {
             (void)m_pZip->writeFile(QLatin1String("mimetype"), appIdentification);
         }
 
         m_pZip->setCompression(KZip::DeflateCompression);
         // We don't need the extra field in Krita - so we leave it as "no extra field".
     } else {
         d->good = m_pZip->directory() != 0;
     }
 }
 
 void KoZipStore::setCompressionEnabled(bool e)
 {
     if (e) {
         m_pZip->setCompression(KZip::DeflateCompression);
     } else {
         m_pZip->setCompression(KZip::NoCompression);
     }
 }
 
 bool KoZipStore::doFinalize()
 {
-    return m_pZip->close();
+    if (m_pZip && m_pZip->device() && !m_pZip->device()->inherits("QSaveFile")) {
+        return m_pZip->close();
+    }
+    else {
+        return true;
+    }
 }
 
 bool KoZipStore::openWrite(const QString& name)
 {
     Q_D(KoStore);
     d->stream = 0; // Don't use!
     return m_pZip->prepareWriting(name, "", "" /*m_pZip->rootDir()->user(), m_pZip->rootDir()->group()*/, 0);
 }
 
 bool KoZipStore::openRead(const QString& name)
 {
     Q_D(KoStore);
     const KArchiveEntry * entry = m_pZip->directory()->entry(name);
     if (entry == 0) {
         return false;
     }
     if (entry->isDirectory()) {
         warnStore << name << " is a directory !";
         return false;
     }
     // Must cast to KZipFileEntry, not only KArchiveFile, because device() isn't virtual!
     const KZipFileEntry * f = static_cast<const KZipFileEntry *>(entry);
     delete d->stream;
     d->stream = f->createDevice();
     d->size = f->size();
     return true;
 }
 
 qint64 KoZipStore::write(const char* _data, qint64 _len)
 {
     Q_D(KoStore);
     if (_len == 0) return 0;
     //debugStore <<"KoZipStore::write" << _len;
 
     if (!d->isOpen) {
         errorStore << "KoStore: You must open before writing" << endl;
         return 0;
     }
     if (d->mode != Write) {
         errorStore << "KoStore: Can not write to store that is opened for reading" << endl;
         return 0;
     }
 
     d->size += _len;
     if (m_pZip->writeData(_data, _len))     // writeData returns a bool!
         return _len;
     return 0;
 }
 
 QStringList KoZipStore::directoryList() const
 {
     QStringList retval;
     const KArchiveDirectory *directory = m_pZip->directory();
     Q_FOREACH (const QString &name, directory->entries()) {
         const KArchiveEntry* fileArchiveEntry = m_pZip->directory()->entry(name);
         if (fileArchiveEntry->isDirectory()) {
             retval << name;
         }
     }
     return retval;
 }
 
 bool KoZipStore::closeWrite()
 {
     Q_D(KoStore);
     debugStore << "Wrote file" << d->fileName << " into ZIP archive. size" << d->size;
     return m_pZip->finishWriting(d->size);
 }
 
 bool KoZipStore::enterRelativeDirectory(const QString& dirName)
 {
     Q_D(KoStore);
     if (d->mode == Read) {
         if (!m_currentDir) {
             m_currentDir = m_pZip->directory(); // initialize
             Q_ASSERT(d->currentPath.isEmpty());
         }
         const KArchiveEntry *entry = m_currentDir->entry(dirName);
         if (entry && entry->isDirectory()) {
             m_currentDir = dynamic_cast<const KArchiveDirectory*>(entry);
             return m_currentDir != 0;
         }
         return false;
     } else // Write, no checking here
         return true;
 }
 
 bool KoZipStore::enterAbsoluteDirectory(const QString& path)
 {
     if (path.isEmpty()) {
         m_currentDir = 0;
         return true;
     }
     m_currentDir = dynamic_cast<const KArchiveDirectory*>(m_pZip->directory()->entry(path));
     Q_ASSERT(m_currentDir);
     return m_currentDir != 0;
 }
 
 bool KoZipStore::fileExists(const QString& absPath) const
 {
     const KArchiveEntry *entry = m_pZip->directory()->entry(absPath);
     return entry && entry->isFile();
 }
diff --git a/libs/store/KoZipStore.h b/libs/store/KoZipStore.h
index 43579abd10..b45964d139 100644
--- a/libs/store/KoZipStore.h
+++ b/libs/store/KoZipStore.h
@@ -1,74 +1,73 @@
 /* This file is part of the KDE project
    Copyright (C) 2002 David Faure <faure@kde.org>
 
    This library is free software; you can redistribute it and/or
    modify it under the terms of the GNU Library General Public
    License as published by the Free Software Foundation; either
    version 2 of the License, or (at your option) any later version.
 
    This library is distributed in the hope that it will be useful,
    but WITHOUT ANY WARRANTY; without even the implied warranty of
    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
    Library General Public License for more details.
 
    You should have received a copy of the GNU Library General Public License
    along with this library; see the file COPYING.LIB.  If not, write to
    the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
  * Boston, MA 02110-1301, USA.
 */
 
 #ifndef koZipStore_h
 #define koZipStore_h
 
 #include "KoStore.h"
 
-class KZip;
+class SaveZip;
 class KArchiveDirectory;
 class QUrl;
 
 class KoZipStore : public KoStore
 {
 public:
     KoZipStore(const QString & _filename, Mode _mode, const QByteArray & appIdentification,
                bool writeMimetype = true);
     KoZipStore(QIODevice *dev, Mode mode, const QByteArray & appIdentification,
                bool writeMimetype = true);
     /**
      * QUrl-constructor
      * @todo saving not completely implemented (fixed temporary file)
      */
     KoZipStore(QWidget* window, const QUrl &_url, const QString & _filename, Mode _mode,
                const QByteArray & appIdentification, bool writeMimetype = true);
     ~KoZipStore();
 
     virtual void setCompressionEnabled(bool e);
     virtual qint64 write(const char* _data, qint64 _len);
 
     virtual QStringList directoryList() const;
 
 protected:
     void init(const QByteArray& appIdentification);
     virtual bool doFinalize();
     virtual bool openWrite(const QString& name);
     virtual bool openRead(const QString& name);
     virtual bool closeWrite();
     virtual bool closeRead() {
         return true;
     }
     virtual bool enterRelativeDirectory(const QString& dirName);
     virtual bool enterAbsoluteDirectory(const QString& path);
     virtual bool fileExists(const QString& absPath) const;
 
 private:
 
-    /// The archive
-    KZip * m_pZip;
+    // The archive
+    SaveZip * m_pZip;
 
-    /** In "Read" mode this pointer is pointing to the
-    current directory in the archive to speed up the verification process */
+    // In "Read" mode this pointer is pointing to the  current directory in the archive to speed up the verification process
     const KArchiveDirectory* m_currentDir;
 
     Q_DECLARE_PRIVATE(KoStore)
 };
 
 #endif
diff --git a/libs/ui/CMakeLists.txt b/libs/ui/CMakeLists.txt
index 3cf92dbe6e..2444bafd0e 100644
--- a/libs/ui/CMakeLists.txt
+++ b/libs/ui/CMakeLists.txt
@@ -1,539 +1,541 @@
 include_directories(
     ${CMAKE_CURRENT_SOURCE_DIR}/qtlockedfile
     ${EXIV2_INCLUDE_DIR}
 )
 
 include_directories(SYSTEM
     ${EIGEN3_INCLUDE_DIR}
     ${OCIO_INCLUDE_DIR}
     ${Boost_INCLUDE_DIRS}
 )
 
 add_subdirectory( tests )
 
 if (APPLE)
     find_library(FOUNDATION_LIBRARY Foundation)
 endif ()
 
 set(kritaui_LIB_SRCS
     canvas/kis_canvas_widget_base.cpp
     canvas/kis_canvas2.cpp
     canvas/kis_canvas_updates_compressor.cpp
     canvas/kis_canvas_controller.cpp
     canvas/kis_paintop_transformation_connector.cpp
     canvas/kis_display_color_converter.cpp
     canvas/kis_display_filter.cpp
     canvas/kis_exposure_gamma_correction_interface.cpp
     canvas/kis_tool_proxy.cpp
     canvas/kis_canvas_decoration.cc
     canvas/kis_coordinates_converter.cpp
     canvas/kis_grid_manager.cpp
     canvas/kis_grid_decoration.cpp
     canvas/kis_grid_config.cpp
     canvas/kis_prescaled_projection.cpp
     canvas/kis_qpainter_canvas.cpp
     canvas/kis_projection_backend.cpp
     canvas/kis_update_info.cpp
     canvas/kis_image_patch.cpp
     canvas/kis_image_pyramid.cpp
     canvas/kis_infinity_manager.cpp
     canvas/kis_change_guides_command.cpp
     canvas/kis_guides_decoration.cpp
     canvas/kis_guides_manager.cpp
     canvas/kis_guides_config.cpp
     canvas/kis_snap_config.cpp
     canvas/kis_snap_line_strategy.cpp
     dialogs/kis_about_application.cpp
     dialogs/kis_dlg_adj_layer_props.cc
     dialogs/kis_dlg_adjustment_layer.cc
     dialogs/kis_dlg_filter.cpp
     dialogs/kis_dlg_generator_layer.cpp
     dialogs/kis_dlg_file_layer.cpp
     dialogs/kis_dlg_filter.cpp
     dialogs/kis_dlg_stroke_selection_properties.cpp
     dialogs/kis_dlg_image_properties.cc
     dialogs/kis_dlg_layer_properties.cc
     dialogs/kis_dlg_preferences.cc
     dialogs/slider_and_spin_box_sync.cpp
     dialogs/kis_dlg_blacklist_cleanup.cpp
     dialogs/kis_dlg_layer_style.cpp
     dialogs/kis_dlg_png_import.cpp
     dialogs/kis_dlg_import_image_sequence.cpp
     dialogs/kis_delayed_save_dialog.cpp
     dialogs/kis_dlg_internal_color_selector.cpp
     flake/kis_node_dummies_graph.cpp
     flake/kis_dummies_facade_base.cpp
     flake/kis_dummies_facade.cpp
     flake/kis_node_shapes_graph.cpp
     flake/kis_node_shape.cpp
     flake/kis_shape_controller.cpp
     flake/kis_shape_layer.cc
     flake/kis_shape_layer_canvas.cpp
     flake/kis_shape_selection.cpp
     flake/kis_shape_selection_canvas.cpp
     flake/kis_shape_selection_model.cpp
     flake/kis_take_all_shapes_command.cpp
     brushhud/kis_uniform_paintop_property_widget.cpp
     brushhud/kis_brush_hud.cpp
     brushhud/kis_round_hud_button.cpp
     brushhud/kis_dlg_brush_hud_config.cpp
     brushhud/kis_brush_hud_properties_list.cpp
     brushhud/kis_brush_hud_properties_config.cpp
     kis_aspect_ratio_locker.cpp
     kis_autogradient.cc
     kis_bookmarked_configurations_editor.cc
     kis_bookmarked_configurations_model.cc
     kis_bookmarked_filter_configurations_model.cc
     kis_base_option.cpp
     kis_canvas_resource_provider.cpp
     kis_derived_resources.cpp
     kis_categories_mapper.cpp
     kis_categorized_list_model.cpp
     kis_categorized_item_delegate.cpp
     kis_clipboard.cc
     kis_config.cc
     kis_config_notifier.cpp
     kis_control_frame.cpp
     kis_composite_ops_model.cc
     kis_paint_ops_model.cpp
     kis_cursor.cc
     kis_cursor_cache.cpp
     kis_custom_pattern.cc
     kis_file_layer.cpp
     kis_safe_document_loader.cpp
     kis_splash_screen.cpp
     kis_filter_manager.cc
     kis_filters_model.cc
     kis_histogram_view.cc
     kis_image_manager.cc
     kis_image_view_converter.cpp
     kis_import_catcher.cc
     kis_layer_manager.cc
     kis_mask_manager.cc
     kis_mimedata.cpp
     kis_node_commands_adapter.cpp
     kis_node_manager.cpp
     kis_node_juggler_compressed.cpp
     kis_node_selection_adapter.cpp
     kis_node_insertion_adapter.cpp
     kis_node_model.cpp
     kis_node_filter_proxy_model.cpp
     kis_model_index_converter_base.cpp
     kis_model_index_converter.cpp
     kis_model_index_converter_show_all.cpp
     kis_painting_assistant.cc
     kis_painting_assistants_decoration.cpp
     kis_painting_assistants_manager.cpp
     kis_paintop_box.cc
     kis_paintop_option.cpp
     kis_paintop_options_model.cpp
     kis_paintop_settings_widget.cpp
     kis_popup_palette.cpp
     kis_png_converter.cpp
     kis_preference_set_registry.cpp
     kis_script_manager.cpp
     kis_resource_server_provider.cpp
     kis_selection_decoration.cc
     kis_selection_manager.cc
     kis_statusbar.cc
     kis_zoom_manager.cc
     kis_favorite_resource_manager.cpp
     kis_workspace_resource.cpp
     kis_action.cpp
     kis_action_manager.cpp
     kis_view_plugin.cpp
     kis_canvas_controls_manager.cpp
     kis_tooltip_manager.cpp
     kis_multinode_property.cpp
     kis_stopgradient_editor.cpp
     kisexiv2/kis_exif_io.cpp
     kisexiv2/kis_exiv2.cpp
     kisexiv2/kis_iptc_io.cpp
     kisexiv2/kis_xmp_io.cpp
     opengl/kis_opengl.cpp
     opengl/kis_opengl_canvas2.cpp
     opengl/kis_opengl_canvas_debugger.cpp
     opengl/kis_opengl_image_textures.cpp
     opengl/kis_texture_tile.cpp
     opengl/kis_opengl_shader_loader.cpp
     kis_fps_decoration.cpp
     recorder/kis_node_query_path_editor.cc
     recorder/kis_recorded_action_creator.cc
     recorder/kis_recorded_action_creator_factory.cc
     recorder/kis_recorded_action_creator_factory_registry.cc
     recorder/kis_recorded_action_editor_factory.cc
     recorder/kis_recorded_action_editor_factory_registry.cc
     recorder/kis_recorded_filter_action_editor.cc
     recorder/kis_recorded_filter_action_creator.cpp
     recorder/kis_recorded_paint_action_editor.cc
     tool/kis_selection_tool_helper.cpp
     tool/kis_selection_tool_config_widget_helper.cpp
     tool/kis_rectangle_constraint_widget.cpp
     tool/kis_shape_tool_helper.cpp
     tool/kis_tool.cc
     tool/kis_delegated_tool_policies.cpp
     tool/kis_tool_freehand.cc
     tool/kis_speed_smoother.cpp
     tool/kis_painting_information_builder.cpp
     tool/kis_stabilized_events_sampler.cpp
     tool/kis_tool_freehand_helper.cpp
     tool/kis_tool_multihand_helper.cpp
     tool/kis_figure_painting_tool_helper.cpp
     tool/kis_recording_adapter.cpp
     tool/kis_tool_paint.cc
     tool/kis_tool_shape.cc
     tool/kis_tool_ellipse_base.cpp
     tool/kis_tool_rectangle_base.cpp
     tool/kis_tool_polyline_base.cpp
     tool/kis_tool_utils.cpp
     tool/kis_resources_snapshot.cpp
     tool/kis_smoothing_options.cpp
     tool/KisStabilizerDelayedPaintHelper.cpp
     tool/strokes/freehand_stroke.cpp
     tool/strokes/kis_painter_based_stroke_strategy.cpp
     tool/strokes/kis_filter_stroke_strategy.cpp
     tool/strokes/kis_color_picker_stroke_strategy.cpp
 
     widgets/kis_cmb_composite.cc
     widgets/kis_cmb_contour.cpp
     widgets/kis_cmb_gradient.cpp
     widgets/kis_paintop_list_widget.cpp
     widgets/kis_cmb_idlist.cc
     widgets/kis_color_space_selector.cc
     widgets/kis_advanced_color_space_selector.cc
     widgets/kis_cie_tongue_widget.cpp
     widgets/kis_tone_curve_widget.cpp
     widgets/kis_curve_widget.cpp
     widgets/kis_custom_image_widget.cc
     widgets/kis_image_from_clipboard_widget.cpp
     widgets/kis_double_widget.cc
     widgets/kis_filter_selector_widget.cc
     widgets/kis_gradient_chooser.cc
     widgets/kis_gradient_slider_widget.cc
     widgets/kis_gradient_slider.cpp
     widgets/kis_iconwidget.cc
     widgets/kis_mask_widgets.cpp
     widgets/kis_meta_data_merge_strategy_chooser_widget.cc
     widgets/kis_multi_bool_filter_widget.cc
     widgets/kis_multi_double_filter_widget.cc
     widgets/kis_multi_integer_filter_widget.cc
     widgets/kis_multipliers_double_slider_spinbox.cpp
     widgets/kis_paintop_presets_popup.cpp
     widgets/kis_tool_options_popup.cpp
     widgets/kis_paintop_presets_chooser_popup.cpp
     widgets/kis_pattern_chooser.cc
     widgets/kis_popup_button.cc
     widgets/kis_preset_chooser.cpp
     widgets/kis_progress_widget.cpp
     widgets/kis_selection_options.cc
     widgets/kis_scratch_pad.cpp
     widgets/kis_scratch_pad_event_filter.cpp
     widgets/kis_preset_selector_strip.cpp
     widgets/kis_slider_spin_box.cpp
     widgets/kis_size_group.cpp
     widgets/kis_size_group_p.cpp
     widgets/kis_wdg_generator.cpp
     widgets/kis_workspace_chooser.cpp
     widgets/squeezedcombobox.cpp
     widgets/kis_categorized_list_view.cpp
     widgets/kis_widget_chooser.cpp
     widgets/kis_tool_button.cpp
     widgets/kis_floating_message.cpp
     widgets/kis_lod_availability_widget.cpp
     widgets/kis_color_label_selector_widget.cpp
     widgets/kis_color_filter_combo.cpp
     widgets/kis_elided_label.cpp
     widgets/kis_stopgradient_slider_widget.cpp
     widgets/kis_spinbox_color_selector.cpp
     widgets/kis_screen_color_picker.cpp
     widgets/KoDualColorButton.cpp
     widgets/kis_color_input.cpp
     widgets/kis_color_button.cpp
     widgets/KisVisualColorSelector.cpp
     widgets/KisVisualColorSelectorShape.cpp
     widgets/KisVisualEllipticalSelectorShape.cpp
     widgets/KisVisualRectangleSelectorShape.cpp
     widgets/KisVisualTriangleSelectorShape.cpp
 
+    utils/kis_document_aware_spin_box_unit_manager.cpp
+
     input/kis_input_manager.cpp
     input/kis_input_manager_p.cpp
     input/kis_extended_modifiers_mapper.cpp
     input/kis_abstract_input_action.cpp
     input/kis_tool_invocation_action.cpp
     input/kis_pan_action.cpp
     input/kis_alternate_invocation_action.cpp
     input/kis_rotate_canvas_action.cpp
     input/kis_zoom_action.cpp
     input/kis_change_frame_action.cpp
     input/kis_gamma_exposure_action.cpp
     input/kis_show_palette_action.cpp
     input/kis_change_primary_setting_action.cpp
     input/kis_abstract_shortcut.cpp
     input/kis_single_action_shortcut.cpp
     input/kis_stroke_shortcut.cpp
     input/kis_shortcut_matcher.cpp
     input/kis_select_layer_action.cpp
 
     operations/kis_operation.cpp
     operations/kis_operation_configuration.cpp
     operations/kis_operation_registry.cpp
     operations/kis_operation_ui_factory.cpp
     operations/kis_operation_ui_widget.cpp
     operations/kis_filter_selection_operation.cpp
     actions/kis_selection_action_factories.cpp
     input/kis_touch_shortcut.cpp
     kis_document_undo_store.cpp
     kis_transaction_based_command.cpp
     kis_gui_context_command.cpp
     kis_gui_context_command_p.cpp
     input/kis_tablet_debugger.cpp
     input/kis_input_profile_manager.cpp
     input/kis_input_profile.cpp
     input/kis_shortcut_configuration.cpp
     input/config/kis_input_configuration_page.cpp
     input/config/kis_edit_profiles_dialog.cpp
     input/config/kis_input_profile_model.cpp
     input/config/kis_input_configuration_page_item.cpp
     input/config/kis_action_shortcuts_model.cpp
     input/config/kis_input_type_delegate.cpp
     input/config/kis_input_mode_delegate.cpp
     input/config/kis_input_button.cpp
     input/config/kis_input_editor_delegate.cpp
     input/config/kis_mouse_input_editor.cpp
     input/config/kis_wheel_input_editor.cpp
     input/config/kis_key_input_editor.cpp
     processing/fill_processing_visitor.cpp
     kis_asl_layer_style_serializer.cpp
     kis_psd_layer_style_resource.cpp
     canvas/kis_mirror_axis.cpp
 
     kis_abstract_perspective_grid.cpp
 
     KisApplication.cpp
     KisAutoSaveRecoveryDialog.cpp
     KisDetailsPane.cpp
     KisDocument.cpp
     KisNodeDelegate.cpp
     kis_node_view_visibility_delegate.cpp
     KisNodeToolTip.cpp
     KisNodeView.cpp
     kis_node_view_color_scheme.cpp
     KisImportExportFilter.cpp
     KisFilterEntry.cpp
     KisImportExportManager.cpp
     KisMainWindow.cpp
     KisOpenPane.cpp
     KisPart.cpp
     KisPrintJob.cpp
     KisTemplate.cpp
     KisTemplateCreateDia.cpp
     KisTemplateGroup.cpp
     KisTemplates.cpp
     KisTemplatesPane.cpp
     KisTemplateTree.cpp
     KisUndoStackAction.cpp
     KisView.cpp
 
     thememanager.cpp
 
     kis_mainwindow_observer.cpp
     KisViewManager.cpp
     kis_mirror_manager.cpp
 
     qtlockedfile/qtlockedfile.cpp
 
     qtsingleapplication/qtlocalpeer.cpp
     qtsingleapplication/qtsingleapplication.cpp
 
     KisResourceBundle.cpp
     KisResourceBundleManifest.cpp
 
     kis_md5_generator.cpp
     KisApplicationArguments.cpp
 
     KisNetworkAccessManager.cpp
     KisMultiFeedRSSModel.cpp
     KisRemoteFileFetcher.cpp
 
     KisPaletteModel.cpp
     kis_palette_delegate.cpp
     kis_palette_view.cpp
     KisColorsetChooser.cpp
     KisSaveGroupVisitor.cpp
 )
 
 if(WIN32)
     if (NOT Qt5Gui_PRIVATE_INCLUDE_DIRS)
         message(FATAL_ERROR "Qt5Gui Private header are missing!")
     endif()
     set(kritaui_LIB_SRCS
         ${kritaui_LIB_SRCS}
         input/kis_tablet_event.cpp
         input/wintab/kis_tablet_support_win.cpp
         input/wintab/kis_screen_size_choice_dialog.cpp
         qtlockedfile/qtlockedfile_win.cpp
         )
     include_directories(${Qt5Gui_PRIVATE_INCLUDE_DIRS})
 endif()
 
     set(kritaui_LIB_SRCS
         ${kritaui_LIB_SRCS}
         kis_animation_frame_cache.cpp
         kis_animation_cache_populator.cpp
         canvas/kis_animation_player.cpp
         kis_animation_exporter.cpp
         kis_animation_importer.cpp
         KisSyncedAudioPlayback.cpp
     )
 
 if(UNIX)
     set(kritaui_LIB_SRCS
         ${kritaui_LIB_SRCS}
         input/kis_tablet_event.cpp
         input/wintab/kis_tablet_support.cpp
         qtlockedfile/qtlockedfile_unix.cpp
         )
     if(NOT APPLE)
         set(kritaui_LIB_SRCS
             ${kritaui_LIB_SRCS}
             input/wintab/kis_tablet_support_x11.cpp
             input/wintab/qxcbconnection_xi2.cpp
             input/wintab/qxcbconnection.cpp
             input/wintab/kis_xi2_event_filter.cpp
             )
     endif()
 endif()
 
 
 ki18n_wrap_ui(kritaui_LIB_SRCS
     forms/wdgdlgpngimport.ui
     forms/wdgfullscreensettings.ui
     forms/wdgautogradient.ui
     forms/wdggeneralsettings.ui
     forms/wdgperformancesettings.ui
     forms/wdggenerators.ui
     forms/wdgbookmarkedconfigurationseditor.ui
     forms/wdgapplyprofile.ui
     forms/wdgcustompattern.ui
     forms/wdglayerproperties.ui
     forms/wdgcolorsettings.ui
     forms/wdgtabletsettings.ui
     forms/wdgcolorspaceselector.ui
     forms/wdgcolorspaceselectoradvanced.ui
     forms/wdgdisplaysettings.ui
     forms/kis_previewwidgetbase.ui
     forms/kis_matrix_widget.ui
     forms/wdgselectionoptions.ui
     forms/wdggeometryoptions.ui
     forms/wdgnewimage.ui
     forms/wdgimageproperties.ui
     forms/wdgmaskfromselection.ui
     forms/wdgmasksource.ui
     forms/wdgfilterdialog.ui
     forms/wdgmetadatamergestrategychooser.ui
     forms/wdgpaintoppresets.ui
     forms/wdgpaintopsettings.ui
     forms/wdgdlggeneratorlayer.ui
     forms/wdgdlgfilelayer.ui
     forms/wdgfilterselector.ui
     forms/wdgfilternodecreation.ui
     forms/wdgpaintactioneditor.ui
     forms/wdgmultipliersdoublesliderspinbox.ui
     forms/wdgnodequerypatheditor.ui
     forms/wdgpresetselectorstrip.ui
     forms/wdgdlgblacklistcleanup.ui
     forms/wdgrectangleconstraints.ui
     forms/wdgimportimagesequence.ui
     forms/wdgstrokeselectionproperties.ui
     forms/KisDetailsPaneBase.ui
     forms/KisOpenPaneBase.ui
     forms/wdgstopgradienteditor.ui
     brushhud/kis_dlg_brush_hud_config.ui
     forms/wdgdlginternalcolorselector.ui
     dialogs/kis_delayed_save_dialog.ui
     input/config/kis_input_configuration_page.ui
     input/config/kis_edit_profiles_dialog.ui
     input/config/kis_input_configuration_page_item.ui
     input/config/kis_mouse_input_editor.ui
     input/config/kis_wheel_input_editor.ui
     input/config/kis_key_input_editor.ui
 
     layerstyles/wdgBevelAndEmboss.ui
     layerstyles/wdgblendingoptions.ui
     layerstyles/WdgColorOverlay.ui
     layerstyles/wdgContour.ui
     layerstyles/wdgdropshadow.ui
     layerstyles/WdgGradientOverlay.ui
     layerstyles/wdgInnerGlow.ui
     layerstyles/wdglayerstyles.ui
     layerstyles/WdgPatternOverlay.ui
     layerstyles/WdgSatin.ui
     layerstyles/WdgStroke.ui
     layerstyles/wdgstylesselector.ui
     layerstyles/wdgTexture.ui
 
     wdgsplash.ui
     input/wintab/kis_screen_size_choice_dialog.ui
 
 )
 
 
 QT5_WRAP_CPP(kritaui_HEADERS_MOC KisNodePropertyAction_p.h)
 
 add_library(kritaui SHARED ${kritaui_HEADERS_MOC} ${kritaui_LIB_SRCS} )
 generate_export_header(kritaui BASE_NAME kritaui)
 
 target_link_libraries(kritaui KF5::CoreAddons KF5::Completion KF5::I18n KF5::ItemViews Qt5::Network
                       kritaimpex kritacolor kritaimage kritalibbrush kritawidgets kritawidgetutils ${PNG_LIBRARIES} ${EXIV2_LIBRARIES}
 )
 
 if (HAVE_QT_MULTIMEDIA)
     target_link_libraries(kritaui Qt5::Multimedia)
 endif()
 
 if (HAVE_KIO)
     target_link_libraries(kritaui KF5::KIOCore)
 endif() 
 
 if (NOT WIN32 AND NOT APPLE)
   target_link_libraries(kritaui ${X11_X11_LIB}
                                 ${X11_Xinput_LIB}
                                 ${XCB_LIBRARIES})
 endif()
 
 if(APPLE)
     target_link_libraries(kritaui ${FOUNDATION_LIBRARY})
 endif ()
 
 
 target_link_libraries(kritaui ${OPENEXR_LIBRARIES})
 
 # Add VSync disable workaround
 if(NOT WIN32 AND NOT APPLE)
     target_link_libraries(kritaui ${CMAKE_DL_LIBS} Qt5::X11Extras)
 endif()
 
 if(X11_FOUND)
     target_link_libraries(kritaui Qt5::X11Extras ${X11_LIBRARIES})
 endif()
 
 target_include_directories(kritaui
     PUBLIC
     $<BUILD_INTERFACE:${CMAKE_CURRENT_SOURCE_DIR}/canvas>
     $<BUILD_INTERFACE:${CMAKE_CURRENT_SOURCE_DIR}/flake>
     $<BUILD_INTERFACE:${CMAKE_CURRENT_SOURCE_DIR}/ora>
     $<BUILD_INTERFACE:${CMAKE_CURRENT_SOURCE_DIR}/tool>
     $<BUILD_INTERFACE:${CMAKE_CURRENT_SOURCE_DIR}/utils>
     $<BUILD_INTERFACE:${CMAKE_CURRENT_SOURCE_DIR}/widgets>
     $<BUILD_INTERFACE:${CMAKE_CURRENT_SOURCE_DIR}/input/wintab>
 )
 
 set_target_properties(kritaui
     PROPERTIES VERSION ${GENERIC_KRITA_LIB_VERSION} SOVERSION ${GENERIC_KRITA_LIB_SOVERSION}
 )
 install(TARGETS kritaui  ${INSTALL_TARGETS_DEFAULT_ARGS})
 
 
 if (APPLE)
     install(FILES osx.stylesheet DESTINATION ${DATA_INSTALL_DIR}/krita)
 endif ()
diff --git a/libs/ui/KisApplication.cpp b/libs/ui/KisApplication.cpp
index 2697b1c63a..6c979e4400 100644
--- a/libs/ui/KisApplication.cpp
+++ b/libs/ui/KisApplication.cpp
@@ -1,761 +1,768 @@
 /* This file is part of the KDE project
    Copyright (C) 1998, 1999 Torben Weis <weis@kde.org>
    Copyright (C) 2009 Thomas Zander <zander@kde.org>
    Copyright (C) 2012 Boudewijn Rempt <boud@valdyas.org>
 
    This library is free software; you can redistribute it and/or
    modify it under the terms of the GNU Library General Public
    License as published by the Free Software Foundation; either
    version 2 of the License, or (at your option) any later version.
 
    This library is distributed in the hope that it will be useful,
    but WITHOUT ANY WARRANTY; without even the implied warranty of
    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
    Library General Public License for more details.
 
    You should have received a copy of the GNU Library General Public License
    along with this library; see the file COPYING.LIB.  If not, write to
    the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
  * Boston, MA 02110-1301, USA.
 */
 
 #include "KisApplication.h"
 
 #include <stdlib.h>
 #ifdef Q_OS_WIN
 #include <windows.h>
 #include <tchar.h>
 #endif
 
 #include <QDesktopServices>
 #include <QDesktopWidget>
 #include <QDir>
 #include <QFile>
 #include <QLocale>
 #include <QMessageBox>
 #include <QMessageBox>
 #include <QProcessEnvironment>
 #include <QSettings>
 #include <QStandardPaths>
 #include <QStringList>
 #include <QStyle>
 #include <QStyleFactory>
 #include <QSysInfo>
 #include <QTimer>
 #include <QWidget>
 
 #include <klocalizedstring.h>
 #include <kdesktopfile.h>
 #include <kconfig.h>
 #include <kconfiggroup.h>
 
 #include <KoColorSpaceRegistry.h>
 #include <KoPluginLoader.h>
 #include <KoShapeRegistry.h>
 #include <KoDpi.h>
 #include "KoGlobal.h"
 #include "KoConfig.h"
 #include <resources/KoHashGeneratorProvider.h>
 #include <KoResourcePaths.h>
 #include <KisMimeDatabase.h>
 #include "thememanager.h"
 #include "KisPrintJob.h"
 #include "KisDocument.h"
 #include "KisMainWindow.h"
 #include "KisAutoSaveRecoveryDialog.h"
 #include "KisPart.h"
 #include <kis_icon.h>
 #include "kis_md5_generator.h"
 #include "kis_splash_screen.h"
 #include "kis_config.h"
 #include "flake/kis_shape_selection.h"
 #include <filter/kis_filter.h>
 #include <filter/kis_filter_registry.h>
 #include <filter/kis_filter_configuration.h>
 #include <generator/kis_generator_registry.h>
 #include <generator/kis_generator.h>
 #include <brushengine/kis_paintop_registry.h>
 #include <metadata/kis_meta_data_io_backend.h>
 #include "kisexiv2/kis_exiv2.h"
 #include "KisApplicationArguments.h"
 #include <kis_debug.h>
 #include "kis_action_registry.h"
 #include <kis_brush_server.h>
 #include <kis_resource_server_provider.h>
 #include <KoResourceServerProvider.h>
 #include "kis_image_barrier_locker.h"
 #include "opengl/kis_opengl.h"
+#include "kis_spin_box_unit_manager.h"
+#include "kis_document_aware_spin_box_unit_manager.h"
 
 #include <KritaVersionWrapper.h>
 namespace {
 const QTime appStartTime(QTime::currentTime());
 }
 
 class KisApplicationPrivate
 {
 public:
     KisApplicationPrivate()
         : splashScreen(0)
     {}
     QPointer<KisSplashScreen> splashScreen;
 };
 
 class KisApplication::ResetStarting
 {
 public:
     ResetStarting(KisSplashScreen *splash = 0)
         : m_splash(splash)
     {
     }
 
     ~ResetStarting()  {
         if (m_splash) {
 
             KConfigGroup cfg( KSharedConfig::openConfig(), "SplashScreen");
             bool hideSplash = cfg.readEntry("HideSplashAfterStartup", false);
 
             if (hideSplash) {
                 m_splash->hide();
             }
             else {
                 m_splash->setWindowFlags(Qt::Dialog);
                 QRect r(QPoint(), m_splash->size());
                 m_splash->move(QApplication::desktop()->availableGeometry().center() - r.center());
                 m_splash->setWindowTitle(qAppName());
                 m_splash->setParent(0);
                 Q_FOREACH (QObject *o, m_splash->children()) {
                     QWidget *w = qobject_cast<QWidget*>(o);
                     if (w && w->isHidden()) {
                         w->setVisible(true);
                     }
                 }
                 m_splash->show();
                 m_splash->activateWindow();
             }
         }
     }
 
     QPointer<KisSplashScreen> m_splash;
 };
 
 
 KisApplication::KisApplication(const QString &key, int &argc, char **argv)
     : QtSingleApplication(key, argc, argv)
     , d(new KisApplicationPrivate)
     , m_autosaveDialog(0)
     , m_mainWindow(0)
     , m_batchRun(false)
 {
     QCoreApplication::addLibraryPath(QCoreApplication::applicationDirPath());
 
     setApplicationDisplayName("Krita");
     setApplicationName("krita");
     // Note: Qt docs suggest we set this, but if we do, we get resource paths of the form of krita/krita, which is weird.
     //    setOrganizationName("krita");
     setOrganizationDomain("krita.org");
 
     QString version = KritaVersionWrapper::versionString(true);
     setApplicationVersion(version);
     setWindowIcon(KisIconUtils::loadIcon("calligrakrita"));
 
     if (qgetenv("KRITA_NO_STYLE_OVERRIDE").isEmpty()) {
         QStringList styles = QStringList() << "breeze" << "fusion" << "plastique";
         if (!styles.contains(style()->objectName().toLower())) {
             Q_FOREACH (const QString & style, styles) {
                 if (!setStyle(style)) {
                     qDebug() << "No" << style << "available.";
                 }
                 else {
                     qDebug() << "Set style" << style;
                     break;
                 }
             }
         }
     }
     else {
         qDebug() << "Style override disabled, using" << style()->objectName();
     }
 
     KisOpenGL::initialize();
     qDebug() << "krita has opengl" << KisOpenGL::hasOpenGL();
 }
 
 #if defined(Q_OS_WIN) && defined(ENV32BIT)
 typedef BOOL (WINAPI *LPFN_ISWOW64PROCESS) (HANDLE, PBOOL);
 
 LPFN_ISWOW64PROCESS fnIsWow64Process;
 
 BOOL isWow64()
 {
     BOOL bIsWow64 = FALSE;
 
     //IsWow64Process is not available on all supported versions of Windows.
     //Use GetModuleHandle to get a handle to the DLL that contains the function
     //and GetProcAddress to get a pointer to the function if available.
 
     fnIsWow64Process = (LPFN_ISWOW64PROCESS) GetProcAddress(
                 GetModuleHandle(TEXT("kernel32")),"IsWow64Process");
 
     if(0 != fnIsWow64Process)
     {
         if (!fnIsWow64Process(GetCurrentProcess(),&bIsWow64))
         {
             //handle error
         }
     }
     return bIsWow64;
 }
 #endif
 
 void KisApplication::initializeGlobals(const KisApplicationArguments &args)
 {
     int dpiX = args.dpiX();
     int dpiY = args.dpiY();
     if (dpiX > 0 && dpiY > 0) {
         KoDpi::setDPI(dpiX, dpiY);
     }
 }
 
 void KisApplication::addResourceTypes()
 {
     // All Krita's resource types
     KoResourcePaths::addResourceType("kis_pics", "data", "/pics/");
     KoResourcePaths::addResourceType("kis_images", "data", "/images/");
     KoResourcePaths::addResourceType("icc_profiles", "data", "/profiles/");
     KoResourcePaths::addResourceType("metadata_schema", "data", "/metadata/schemas/");
     KoResourcePaths::addResourceType("kis_brushes", "data", "/brushes/");
     KoResourcePaths::addResourceType("kis_taskset", "data", "/taskset/");
     KoResourcePaths::addResourceType("kis_taskset", "data", "/taskset/");
     KoResourcePaths::addResourceType("gmic_definitions", "data", "/gmic/");
     KoResourcePaths::addResourceType("kis_resourcebundles", "data", "/bundles/");
     KoResourcePaths::addResourceType("kis_defaultpresets", "data", "/defaultpresets/");
     KoResourcePaths::addResourceType("kis_paintoppresets", "data", "/paintoppresets/");
     KoResourcePaths::addResourceType("kis_workspaces", "data", "/workspaces/");
     KoResourcePaths::addResourceType("psd_layer_style_collections", "data", "/asl");
     KoResourcePaths::addResourceType("ko_patterns", "data", "/patterns/", true);
     KoResourcePaths::addResourceType("ko_gradients", "data", "/gradients/");
     KoResourcePaths::addResourceType("ko_gradients", "data", "/gradients/", true);
     KoResourcePaths::addResourceType("ko_palettes", "data", "/palettes/", true);
     KoResourcePaths::addResourceType("kis_shortcuts", "data", "/shortcuts/");
     KoResourcePaths::addResourceType("kis_actions", "data", "/actions");
     KoResourcePaths::addResourceType("icc_profiles", "data", "/color/icc");
     KoResourcePaths::addResourceType("ko_effects", "data", "/effects/");
     KoResourcePaths::addResourceType("tags", "data", "/tags/");
     KoResourcePaths::addResourceType("templates", "data", "/templates");
     KoResourcePaths::addResourceType("pythonscripts", "data", "/pykrita");
 
     //    // Extra directories to look for create resources. (Does anyone actually use that anymore?)
     //    KoResourcePaths::addResourceDir("ko_gradients", "/usr/share/create/gradients/gimp");
     //    KoResourcePaths::addResourceDir("ko_gradients", QDir::homePath() + QString("/.create/gradients/gimp"));
     //    KoResourcePaths::addResourceDir("ko_patterns", "/usr/share/create/patterns/gimp");
     //    KoResourcePaths::addResourceDir("ko_patterns", QDir::homePath() + QString("/.create/patterns/gimp"));
     //    KoResourcePaths::addResourceDir("kis_brushes", "/usr/share/create/brushes/gimp");
     //    KoResourcePaths::addResourceDir("kis_brushes", QDir::homePath() + QString("/.create/brushes/gimp"));
     //    KoResourcePaths::addResourceDir("ko_palettes", "/usr/share/create/swatches");
     //    KoResourcePaths::addResourceDir("ko_palettes", QDir::homePath() + QString("/.create/swatches"));
 
     // Make directories for all resources we can save, and tags
     QDir d;
     d.mkpath(QStandardPaths::writableLocation(QStandardPaths::AppDataLocation) + "/tags/");
     d.mkpath(QStandardPaths::writableLocation(QStandardPaths::AppDataLocation) + "/asl/");
     d.mkpath(QStandardPaths::writableLocation(QStandardPaths::AppDataLocation) + "/bundles/");
     d.mkpath(QStandardPaths::writableLocation(QStandardPaths::AppDataLocation) + "/gradients/");
     d.mkpath(QStandardPaths::writableLocation(QStandardPaths::AppDataLocation) + "/paintoppresets/");
     d.mkpath(QStandardPaths::writableLocation(QStandardPaths::AppDataLocation) + "/palettes/");
     d.mkpath(QStandardPaths::writableLocation(QStandardPaths::AppDataLocation) + "/patterns/");
     d.mkpath(QStandardPaths::writableLocation(QStandardPaths::AppDataLocation) + "/taskset/");
     d.mkpath(QStandardPaths::writableLocation(QStandardPaths::AppDataLocation) + "/workspaces/");
     d.mkpath(QStandardPaths::writableLocation(QStandardPaths::AppDataLocation) + "/input/");
 }
 
 void KisApplication::loadResources()
 {
     setSplashScreenLoadingText(i18n("Loading Gradients..."));
     processEvents();
     KoResourceServerProvider::instance()->gradientServer(true);
 
 
     // Load base resources
     setSplashScreenLoadingText(i18n("Loading Patterns..."));
     processEvents();
     KoResourceServerProvider::instance()->patternServer(true);
 
     setSplashScreenLoadingText(i18n("Loading Palettes..."));
     processEvents();
     KoResourceServerProvider::instance()->paletteServer(false);
 
     setSplashScreenLoadingText(i18n("Loading Brushes..."));
     processEvents();
     KisBrushServer::instance()->brushServer(true);
 
     // load paintop presets
     setSplashScreenLoadingText(i18n("Loading Paint Operations..."));
     processEvents();
     KisResourceServerProvider::instance()->paintOpPresetServer(true);
 
     setSplashScreenLoadingText(i18n("Loading Resource Bundles..."));
     processEvents();
     KisResourceServerProvider::instance()->resourceBundleServer();
 }
 
 void KisApplication::loadPlugins()
 {
     KoShapeRegistry* r = KoShapeRegistry::instance();
     r->add(new KisShapeSelectionFactory());
 
     KisActionRegistry::instance();
     KisFilterRegistry::instance();
     KisGeneratorRegistry::instance();
     KisPaintOpRegistry::instance();
     KoColorSpaceRegistry::instance();
 
     // Load the krita-specific tools
     setSplashScreenLoadingText(i18n("Loading Plugins for Krita/Tool..."));
     processEvents();
     KoPluginLoader::instance()->load(QString::fromLatin1("Krita/Tool"),
                                      QString::fromLatin1("[X-Krita-Version] == 28"));
 
 
     // Load dockers
     setSplashScreenLoadingText(i18n("Loading Plugins for Krita/Dock..."));
     processEvents();
     KoPluginLoader::instance()->load(QString::fromLatin1("Krita/Dock"),
                                      QString::fromLatin1("[X-Krita-Version] == 28"));
 
     // XXX_EXIV: make the exiv io backends real plugins
     setSplashScreenLoadingText(i18n("Loading Plugins Exiv/IO..."));
     processEvents();
     KisExiv2::initialize();
 }
 
 
 bool KisApplication::start(const KisApplicationArguments &args)
 {
     KisConfig cfg;
 
 #if defined(Q_OS_WIN)
 #ifdef ENV32BIT
 
     if (isWow64() && !cfg.readEntry("WarnedAbout32Bits", false)) {
         QMessageBox::information(0,
                                  i18nc("@title:window", "Krita: Warning"),
                                  i18n("You are running a 32 bits build on a 64 bits Windows.\n"
                                       "This is not recommended.\n"
                                       "Please download and install the x64 build instead."));
         cfg.writeEntry("WarnedAbout32Bits", true);
 
     }
 #endif
 #endif
 
     QString opengl = cfg.canvasState();
     if (opengl == "OPENGL_NOT_TRIED" ) {
         cfg.setCanvasState("TRY_OPENGL");
     }
     else if (opengl != "OPENGL_SUCCESS") {
         cfg.setCanvasState("OPENGL_FAILED");
     }
 
     setSplashScreenLoadingText(i18n("Initializing Globals"));
     processEvents();
     initializeGlobals(args);
 
     const bool doTemplate = args.doTemplate();
     const bool print = args.print();
     const bool exportAs = args.exportAs();
     const bool exportAsPdf = args.exportAsPdf();
     const QString exportFileName = args.exportFileName();
 
     m_batchRun = (print || exportAs || exportAsPdf || !exportFileName.isEmpty());
     // print & exportAsPdf do user interaction ATM
     const bool needsMainWindow = !exportAs;
     // only show the mainWindow when no command-line mode option is passed
     // TODO: fix print & exportAsPdf to work without mainwindow shown
     const bool showmainWindow = !exportAs; // would be !batchRun;
 
     const bool showSplashScreen = !m_batchRun && qEnvironmentVariableIsEmpty("NOSPLASH");// &&  qgetenv("XDG_CURRENT_DESKTOP") != "GNOME";
     if (showSplashScreen && d->splashScreen) {
         d->splashScreen->show();
         d->splashScreen->repaint();
         processEvents();
     }
 
     KoHashGeneratorProvider::instance()->setGenerator("MD5", new KisMD5Generator());
 
     // Initialize all Krita directories etc.
     KoGlobal::initialize();
 
     KConfigGroup group(KSharedConfig::openConfig(), "theme");
     Digikam::ThemeManager themeManager;
     themeManager.setCurrentTheme(group.readEntry("Theme", "Krita dark"));
 
     ResetStarting resetStarting(d->splashScreen); // remove the splash when done
     Q_UNUSED(resetStarting);
 
     // Make sure we can save resources and tags
     setSplashScreenLoadingText(i18n("Adding resource types"));
     processEvents();
     addResourceTypes();
 
     // Load all resources and tags before the plugins do that
     loadResources();
 
     // Load the plugins
     loadPlugins();
 
     if (needsMainWindow) {
         // show a mainWindow asap, if we want that
         setSplashScreenLoadingText(i18n("Loading Main Window..."));
         processEvents();
         m_mainWindow = KisPart::instance()->createMainWindow();
 
         if (showmainWindow) {
             m_mainWindow->initializeGeometry();
             m_mainWindow->show();
         }
     }
     short int numberOfOpenDocuments = 0; // number of documents open
 
     // Check for autosave files that can be restored, if we're not running a batchrun (test, print, export to pdf)
     if (!m_batchRun) {
         checkAutosaveFiles();
     }
 
     setSplashScreenLoadingText(QString()); // done loading, so clear out label
     processEvents();
 
+    //configure the unit manager
+    KisSpinBoxUnitManagerFactory::setDefaultUnitManagerBuilder(new KisDocumentAwareSpinBoxUnitManagerBuilder());
+    connect(this, &KisApplication::aboutToQuit, &KisSpinBoxUnitManagerFactory::clearUnitManagerBuilder); //ensure the builder is destroyed when the application leave.
+    //the new syntax slot syntax allow to connect to a non q_object static method.
+
     // Get the command line arguments which we have to parse
     int argsCount = args.filenames().count();
     if (argsCount > 0) {
 
         // Loop through arguments
         short int nPrinted = 0;
         for (int argNumber = 0; argNumber < argsCount; argNumber++) {
             QString fileName = args.filenames().at(argNumber);
             // are we just trying to open a template?
             if (doTemplate) {
                 // called in mix with batch options? ignore and silently skip
                 if (m_batchRun) {
                     continue;
                 }
                 if (createNewDocFromTemplate(fileName, m_mainWindow)) {
                     ++numberOfOpenDocuments;
                 }
                 // now try to load
             }
             else {
 
                 if (exportAs) {
                     QString outputMimetype = KisMimeDatabase::mimeTypeForFile(exportFileName);
                     if (outputMimetype == "application/octetstream") {
                         dbgKrita << i18n("Mimetype not found, try using the -mimetype option") << endl;
                         return 1;
                     }
 
                     KisDocument *doc = KisPart::instance()->createDocument();
                     doc->setFileBatchMode(m_batchRun);
                     doc->openUrl(QUrl::fromLocalFile(fileName));
 
                     qApp->processEvents(); // For vector layers to be updated
 
                     doc->setFileBatchMode(true);
                     doc->setOutputMimeType(outputMimetype.toLatin1());
                     if (!doc->exportDocument(QUrl::fromLocalFile(exportFileName))) {
                         dbgKrita << "Could not export " << fileName << "to" << exportFileName << ":" << doc->errorMessage();
                     }
                     nPrinted++;
                     QTimer::singleShot(0, this, SLOT(quit()));
                 }
                 else if (m_mainWindow) {
                     KisDocument *doc = KisPart::instance()->createDocument();
                     doc->setFileBatchMode(m_batchRun);
                     if (m_mainWindow->openDocumentInternal(QUrl::fromLocalFile(fileName), doc)) {
                         if (print) {
                             m_mainWindow->slotFilePrint();
                             nPrinted++;
                             // TODO: trigger closing of app once printing is done
                         }
                         else if (exportAsPdf) {
                             KisPrintJob *job = m_mainWindow->exportToPdf(exportFileName);
                             if (job)
                                 connect (job, SIGNAL(destroyed(QObject*)), m_mainWindow,
                                          SLOT(slotFileQuit()), Qt::QueuedConnection);
                             nPrinted++;
                         } else {
                             // Normal case, success
                             numberOfOpenDocuments++;
                         }
                     } else {
                         // .... if failed
                         // delete doc; done by openDocument
                     }
                 }
             }
         }
 
         if (m_batchRun) {
             return nPrinted > 0;
         }
     }
 
     // fixes BUG:369308  - Krita crashing on splash screen when loading.
     // trying to open a file before Krita has loaded can cause it to hang and crash
     if (d->splashScreen) {
         d->splashScreen->displayLinks();
         d->splashScreen->displayRecentFiles();
     }
 
 
     // not calling this before since the program will quit there.
     return true;
 }
 
 KisApplication::~KisApplication()
 {
     delete d;
 }
 
 void KisApplication::setSplashScreen(QWidget *splashScreen)
 {
     d->splashScreen = qobject_cast<KisSplashScreen*>(splashScreen);
 }
 
 void KisApplication::setSplashScreenLoadingText(QString textToLoad)
 {
     if (d->splashScreen) {
         d->splashScreen->loadingLabel->setText(textToLoad);
         d->splashScreen->repaint();
     }
 }
 
 void KisApplication::hideSplashScreen()
 {
     if (d->splashScreen) {
         // hide the splashscreen to see the dialog
         d->splashScreen->hide();
     }
 }
 
 bool KisApplication::notify(QObject *receiver, QEvent *event)
 {
     try {
         return QApplication::notify(receiver, event);
     } catch (std::exception &e) {
         qWarning("Error %s sending event %i to object %s",
                  e.what(), event->type(), qPrintable(receiver->objectName()));
     } catch (...) {
         qWarning("Error <unknown> sending event %i to object %s",
                  event->type(), qPrintable(receiver->objectName()));
     }
     return false;
 }
 
 
 void KisApplication::remoteArguments(QByteArray message, QObject *socket)
 {
     Q_UNUSED(socket);
 
     // check if we have any mainwindow
     KisMainWindow *mw = qobject_cast<KisMainWindow*>(qApp->activeWindow());
     if (!mw) {
         mw = KisPart::instance()->mainWindows().first();
     }
 
     if (!mw) {
         return;
     }
 
     KisApplicationArguments args = KisApplicationArguments::deserialize(message);
     const bool doTemplate = args.doTemplate();
     const int argsCount = args.filenames().count();
 
     if (argsCount > 0) {
         // Loop through arguments
         for (int argNumber = 0; argNumber < argsCount; ++argNumber) {
             QString filename = args.filenames().at(argNumber);
             // are we just trying to open a template?
             if (doTemplate) {
                 createNewDocFromTemplate(filename, mw);
             }
             else if (QFile(filename).exists()) {
                 KisDocument *doc = KisPart::instance()->createDocument();
                 doc->setFileBatchMode(m_batchRun);
                 mw->openDocumentInternal(QUrl::fromLocalFile(filename), doc);
             }
         }
     }
 }
 
 void KisApplication::fileOpenRequested(const QString &url)
 {
     KisMainWindow *mainWindow = KisPart::instance()->mainWindows().first();
     if (mainWindow) {
         KisDocument *doc = KisPart::instance()->createDocument();
         doc->setFileBatchMode(m_batchRun);
         mainWindow->openDocumentInternal(QUrl::fromLocalFile(url), doc);
     }
 }
 
 
 void KisApplication::checkAutosaveFiles()
 {
     if (m_batchRun) return;
 
     // Check for autosave files from a previous run. There can be several, and
     // we want to offer a restore for every one. Including a nice thumbnail!
 
     QStringList filters;
     filters << QString(".krita-*-*-autosave.kra");
 
 #ifdef Q_OS_WIN
     QDir dir = QDir::temp();
 #else
     QDir dir = QDir::home();
 #endif
 
     // all autosave files for our application
     m_autosaveFiles = dir.entryList(filters, QDir::Files | QDir::Hidden);
 
     // Allow the user to make their selection
     if (m_autosaveFiles.size() > 0) {
         if (d->splashScreen) {
             // hide the splashscreen to see the dialog
             d->splashScreen->hide();
         }
         m_autosaveDialog = new KisAutoSaveRecoveryDialog(m_autosaveFiles, activeWindow());
         QDialog::DialogCode result = (QDialog::DialogCode) m_autosaveDialog->exec();
 
         if (result == QDialog::Accepted) {
             QStringList filesToRecover = m_autosaveDialog->recoverableFiles();
             Q_FOREACH (const QString &autosaveFile, m_autosaveFiles) {
                 if (!filesToRecover.contains(autosaveFile)) {
                     QFile::remove(dir.absolutePath() + "/" + autosaveFile);
                 }
             }
             m_autosaveFiles = filesToRecover;
         } else {
             m_autosaveFiles.clear();
         }
 
         if (m_autosaveFiles.size() > 0) {
             QList<QUrl> autosaveUrls;
             Q_FOREACH (const QString &autoSaveFile, m_autosaveFiles) {
                 const QUrl url = QUrl::fromLocalFile(dir.absolutePath() + QLatin1Char('/') + autoSaveFile);
                 autosaveUrls << url;
             }
             if (m_mainWindow) {
                 Q_FOREACH (const QUrl &url, autosaveUrls) {
                     KisDocument *doc = KisPart::instance()->createDocument();
                     doc->setFileBatchMode(m_batchRun);
                     m_mainWindow->openDocumentInternal(url, doc);
                 }
             }
         }
         // cleanup
         delete m_autosaveDialog;
         m_autosaveDialog = nullptr;
     }
 }
 
 bool KisApplication::createNewDocFromTemplate(const QString &fileName, KisMainWindow *mainWindow)
 {
     QString templatePath;
 
     const QUrl templateUrl = QUrl::fromLocalFile(fileName);
     if (QFile::exists(fileName)) {
         templatePath = templateUrl.toLocalFile();
         dbgUI << "using full path...";
     }
     else {
         QString desktopName(fileName);
         const QString templatesResourcePath =  QStringLiteral("templates/");
 
         QStringList paths = KoResourcePaths::findAllResources("data", templatesResourcePath + "*/" + desktopName);
         if (paths.isEmpty()) {
             paths = KoResourcePaths::findAllResources("data", templatesResourcePath + desktopName);
         }
 
         if (paths.isEmpty()) {
             QMessageBox::critical(0, i18nc("@title:window", "Krita"),
                                   i18n("No template found for: %1", desktopName));
         } else if (paths.count() > 1) {
             QMessageBox::critical(0, i18nc("@title:window", "Krita"),
                                   i18n("Too many templates found for: %1", desktopName));
         } else {
             templatePath = paths.at(0);
         }
     }
 
     if (!templatePath.isEmpty()) {
         QUrl templateBase;
         templateBase.setPath(templatePath);
         KDesktopFile templateInfo(templatePath);
 
         QString templateName = templateInfo.readUrl();
         QUrl templateURL;
         templateURL.setPath(templateBase.adjusted(QUrl::RemoveFilename|QUrl::StripTrailingSlash).path() + '/' + templateName);
 
         KisDocument *doc = KisPart::instance()->createDocument();
         doc->setFileBatchMode(m_batchRun);
         if (mainWindow->openDocumentInternal(templateURL, doc)) {
             doc->resetURL();
             doc->setTitleModified();
             dbgUI << "Template loaded...";
             return true;
         }
         else {
             QMessageBox::critical(0, i18nc("@title:window", "Krita"),
                                   i18n("Template %1 failed to load.", templateURL.toDisplayString()));
         }
     }
 
     return false;
 }
 
 void KisApplication::clearConfig()
 {
     KIS_ASSERT_RECOVER_RETURN(qApp->thread() == QThread::currentThread());
 
     KSharedConfigPtr config =  KSharedConfig::openConfig();
 
     // find user settings file
     bool createDir = false;
     QString kritarcPath = KoResourcePaths::locateLocal("config", "kritarc", createDir);
 
     QFile configFile(kritarcPath);
     if (configFile.exists()) {
         // clear file
         if (configFile.open(QFile::WriteOnly)) {
             configFile.close();
         }
         else {
             QMessageBox::warning(0,
                                  i18nc("@title:window", "Krita"),
                                  i18n("Failed to clear %1\n\n"
                                       "Please make sure no other program is using the file and try again.",
                                       kritarcPath),
                                  QMessageBox::Ok, QMessageBox::Ok);
         }
     }
 
     // reload from disk; with the user file settings cleared,
     // this should load any default configuration files shipping with the program
     config->reparseConfiguration();
     config->sync();
 }
 
 void KisApplication::askClearConfig()
 {
     Qt::KeyboardModifiers mods = QApplication::queryKeyboardModifiers();
     bool askClearConfig = (mods & Qt::ControlModifier) && (mods & Qt::ShiftModifier) && (mods & Qt::AltModifier);
 
     if (askClearConfig) {
         bool ok = QMessageBox::question(0,
                                         i18nc("@title:window", "Krita"),
                                         i18n("Do you want to clear the settings file?"),
                                         QMessageBox::Yes | QMessageBox::No, QMessageBox::No) == QMessageBox::Yes;
         if (ok) {
             clearConfig();
         }
     }
 }
diff --git a/libs/ui/KisDocument.cpp b/libs/ui/KisDocument.cpp
index a96ca4f0a2..960fa6b7c9 100644
--- a/libs/ui/KisDocument.cpp
+++ b/libs/ui/KisDocument.cpp
@@ -1,1780 +1,1737 @@
-/* This file is part of the Krita project
+/* This file is part of the Krita project
  *
  * Copyright (C) 2014 Boudewijn Rempt <boud@kogmbh.com>
  *
  * This library is free software; you can redistribute it and/or
  * modify it under the terms of the GNU Library General Public
  * License as published by the Free Software Foundation; either
  * version 2 of the License, or (at your option) any later version.
  *
  * This library is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  * Library General Public License for more details.
  *
  * You should have received a copy of the GNU Library General Public License
  * along with this library; see the file COPYING.LIB.  If not, write to
  * the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
  * Boston, MA 02110-1301, USA.
  */
 
 #include "KisMainWindow.h" // XXX: remove
 #include <QMessageBox> // XXX: remove
 
 #include <KisMimeDatabase.h>
 
 #include <KoCanvasBase.h>
 #include <KoColor.h>
 #include <KoColorProfile.h>
 #include <KoColorSpaceEngine.h>
 #include <KoColorSpace.h>
 #include <KoColorSpaceRegistry.h>
 #include <KoDocumentInfoDlg.h>
 #include <KoDocumentInfo.h>
 #include <KoDpi.h>
 #include <KoUnit.h>
 #include <KoFileDialog.h>
 #include <KoID.h>
 #include <KoOdfReadStore.h>
 #include <KoProgressProxy.h>
 #include <KoProgressUpdater.h>
 #include <KoSelection.h>
 #include <KoShape.h>
 #include <KoShapeController.h>
 #include <KoStore.h>
 #include <KoUpdater.h>
 #include <KoXmlWriter.h>
 #include <KoXmlReader.h>
 #include <KoStoreDevice.h>
 
 #include <klocalizedstring.h>
 #include <kis_debug.h>
 #include <kdesktopfile.h>
 #include <kconfiggroup.h>
 #include <QTemporaryFile>
 #include <kbackup.h>
 
 #include <QTextBrowser>
 #include <QApplication>
 #include <QBuffer>
 #include <QDesktopServices>
 #include <QDir>
 #include <QDomDocument>
 #include <QDomElement>
 #include <QFileInfo>
 #include <QImage>
 #include <QList>
 #include <QPainter>
 #include <QRect>
 #include <QScopedPointer>
 #include <QSize>
 #include <QStringList>
 #include <QtGlobal>
 #include <QTimer>
 #include <QWidget>
 
 // Krita Image
 #include <kis_config.h>
 #include <flake/kis_shape_layer.h>
 #include <kis_debug.h>
 #include <kis_group_layer.h>
 #include <kis_image.h>
 #include <kis_layer.h>
 #include <kis_name_server.h>
 #include <kis_paint_layer.h>
 #include <kis_painter.h>
 #include <kis_selection.h>
 #include <kis_fill_painter.h>
 #include <kis_document_undo_store.h>
 #include <kis_painting_assistants_decoration.h>
 #include <kis_idle_watcher.h>
 #include <kis_signal_auto_connection.h>
 #include <kis_debug.h>
 #include <kis_canvas_widget_base.h>
 
 // Local
 #include "KisViewManager.h"
 #include "kis_clipboard.h"
 #include "widgets/kis_custom_image_widget.h"
 #include "canvas/kis_canvas2.h"
 #include "flake/kis_shape_controller.h"
 #include "kis_statusbar.h"
 #include "widgets/kis_progress_widget.h"
 #include "kis_canvas_resource_provider.h"
 #include "kis_resource_server_provider.h"
 #include "kis_node_manager.h"
 #include "KisPart.h"
 #include "KisApplication.h"
 #include "KisDocument.h"
 #include "KisImportExportManager.h"
 #include "KisPart.h"
 #include "KisView.h"
 #include "kis_grid_config.h"
 #include "kis_guides_config.h"
 #include "kis_image_barrier_lock_adapter.h"
 #include <mutex>
 
 
 // Define the protocol used here for embedded documents' URL
 // This used to "store" but QUrl didn't like it,
 // so let's simply make it "tar" !
 #define STORE_PROTOCOL "tar"
 // The internal path is a hack to make QUrl happy and for document children
 #define INTERNAL_PROTOCOL "intern"
 #define INTERNAL_PREFIX "intern:/"
 // Warning, keep it sync in koStore.cc
 
 #include <unistd.h>
 
 using namespace std;
 
 /**********************************************************
  *
  * KisDocument
  *
  **********************************************************/
 
 namespace {
 
 class DocumentProgressProxy : public KoProgressProxy {
 public:
     KisMainWindow *m_mainWindow;
     DocumentProgressProxy(KisMainWindow *mainWindow)
         : m_mainWindow(mainWindow)
     {
     }
 
     ~DocumentProgressProxy() override {
         // signal that the job is done
         setValue(-1);
     }
 
     int maximum() const override {
         return 100;
     }
 
     void setValue(int value) override {
         if (m_mainWindow) {
             m_mainWindow->slotProgress(value);
         }
     }
 
     void setRange(int /*minimum*/, int /*maximum*/) override {
 
     }
 
     void setFormat(const QString &/*format*/) override {
 
     }
 };
 }
 
 //static
 QString KisDocument::newObjectName()
 {
     static int s_docIFNumber = 0;
     QString name; name.setNum(s_docIFNumber++); name.prepend("document_");
     return name;
 }
 
 
 class UndoStack : public KUndo2Stack
 {
 public:
     UndoStack(KisDocument *doc)
         : m_doc(doc)
     {
     }
 
     void setIndex(int idx) override {
         KisImageWSP image = this->image();
         image->requestStrokeCancellation();
         if(image->tryBarrierLock()) {
             KUndo2Stack::setIndex(idx);
             image->unlock();
         }
     }
 
     void notifySetIndexChangedOneCommand() override {
         KisImageWSP image = this->image();
         image->unlock();
 
         /**
          * Some very weird commands may emit blocking signals to
          * the GUI (e.g. KisGuiContextCommand). Here is the best thing
          * we can do to avoid the deadlock
          */
         while(!image->tryBarrierLock()) {
             QApplication::processEvents();
         }
     }
 
     void undo() override {
         KisImageWSP image = this->image();
         image->requestUndoDuringStroke();
 
         if (image->tryUndoUnfinishedLod0Stroke() == UNDO_OK) {
             return;
         }
 
         if(image->tryBarrierLock()) {
             KUndo2Stack::undo();
             image->unlock();
         }
     }
 
     void redo() override {
         KisImageWSP image = this->image();
         if(image->tryBarrierLock()) {
             KUndo2Stack::redo();
             image->unlock();
         }
     }
 
 private:
     KisImageWSP image() {
         KisImageWSP currentImage = m_doc->image();
         Q_ASSERT(currentImage);
         return currentImage;
     }
 
 private:
     KisDocument *m_doc;
 };
 
 class Q_DECL_HIDDEN KisDocument::Private
 {
 public:
     Private() :
         docInfo(0),
         progressUpdater(0),
         progressProxy(0),
         importExportManager(0),
         isImporting(false),
         isExporting(false),
         password(QString()),
         modifiedAfterAutosave(false),
         isAutosaving(false),
         backupFile(true),
         doNotSaveExtDoc(false),
         undoStack(0),
         m_saveOk(false),
         m_waitForSave(false),
         m_duringSaveAs(false),
         m_bAutoDetectedMime(false),
         modified(false),
         readwrite(true),
         disregardAutosaveFailure(false),
         nserver(0),
         macroNestDepth(0),
         imageIdleWatcher(2000 /*ms*/),
         suppressProgress(false),
         fileProgressProxy(0),
         savingLock(&savingMutex)
     {
         if (QLocale().measurementSystem() == QLocale::ImperialSystem) {
             unit = KoUnit::Inch;
         } else {
             unit = KoUnit::Centimeter;
         }
     }
 
     ~Private() {
         // Don't delete m_d->shapeController because it's in a QObject hierarchy.
         delete nserver;
     }
 
     KoDocumentInfo *docInfo;
 
     KoProgressUpdater *progressUpdater;
     KoProgressProxy *progressProxy;
 
     KoUnit unit;
 
     KisImportExportManager *importExportManager; // The filter-manager to use when loading/saving [for the options]
 
     QByteArray mimeType; // The actual mimetype of the document
     QByteArray outputMimeType; // The mimetype to use when saving
 
     bool isImporting;
     bool isExporting; // File --> Import/Export vs File --> Open/Save
     QString password; // The password used to encrypt an encrypted document
 
     QTimer autoSaveTimer;
     QString lastErrorMessage; // see openFile()
     QString lastWarningMessage;
     int autoSaveDelay {300}; // in seconds, 0 to disable.
     bool modifiedAfterAutosave;
     bool isAutosaving;
     bool backupFile;
     bool doNotSaveExtDoc; // makes it possible to save only internally stored child documents
 
     KUndo2Stack *undoStack;
 
     KisGuidesConfig guidesConfig;
 
     QUrl m_originalURL; // for saveAs
     QString m_originalFilePath; // for saveAs
     bool m_saveOk;
     bool m_waitForSave;
     bool m_duringSaveAs;
     bool m_bAutoDetectedMime; // whether the mimetype in the arguments was detected by the part itself
     QUrl m_url; // local url - the one displayed to the user.
     QString m_file; // Local file - the only one the part implementation should deal with.
     QEventLoop m_eventLoop;
     QMutex savingMutex;
 
     bool modified;
     bool readwrite;
 
     QDateTime firstMod;
     QDateTime lastMod;
 
     bool disregardAutosaveFailure;
 
     KisNameServer *nserver;
     qint32 macroNestDepth;
 
     KisImageSP image;
     KisImageSP savingImage;
 
     KisNodeSP preActivatedNode;
     KisShapeController* shapeController;
     KoShapeController* koShapeController;
     KisIdleWatcher imageIdleWatcher;
     QScopedPointer<KisSignalAutoConnection> imageIdleConnection;
 
     bool suppressProgress;
     KoProgressProxy* fileProgressProxy;
 
     QList<KisPaintingAssistantSP> assistants;
     KisGridConfig gridConfig;
 
     StdLockableWrapper<QMutex> savingLock;
 
     void setImageAndInitIdleWatcher(KisImageSP _image) {
         image = _image;
 
         imageIdleWatcher.setTrackedImage(image);
 
         if (image) {
             imageIdleConnection.reset(
                         new KisSignalAutoConnection(
                             &imageIdleWatcher, SIGNAL(startedIdleMode()),
                             image.data(), SLOT(explicitRegenerateLevelOfDetail())));
         }
     }
 
     class SafeSavingLocker;
 };
 
 class KisDocument::Private::SafeSavingLocker {
 public:
     SafeSavingLocker(KisDocument::Private *_d, KisDocument *document)
         : d(_d)
         , m_document(document)
         , m_locked(false)
         , m_imageLock(d->image, true)
     {
         const int realAutoSaveInterval = KisConfig().autoSaveInterval();
         const int emergencyAutoSaveInterval = 10; // sec
 
         /**
          * Initial try to lock both objects. Locking the image guards
          * us from any image composition threads running in the
          * background, while savingMutex guards us from entering the
          * saving code twice by autosave and main threads.
          *
          * Since we are trying to lock multiple objects, so we should
          * do it in a safe manner.
          */
         m_locked = std::try_lock(m_imageLock, d->savingLock) < 0;
 
         if (!m_locked) {
             if (d->isAutosaving) {
                 d->disregardAutosaveFailure = true;
                 if (realAutoSaveInterval) {
                     m_document->setAutoSaveDelay(emergencyAutoSaveInterval);
                 }
             } else {
                 d->image->requestStrokeEnd();
                 QApplication::processEvents();
 
                 // one more try...
                 m_locked = std::try_lock(m_imageLock, d->savingLock) < 0;
             }
         }
 
         if (m_locked) {
             d->disregardAutosaveFailure = false;
         }
     }
 
     ~SafeSavingLocker() {
          if (m_locked) {
              m_imageLock.unlock();
              d->savingLock.unlock();
 
              const int realAutoSaveInterval = KisConfig().autoSaveInterval();
              m_document->setAutoSaveDelay(realAutoSaveInterval);
          }
      }
 
     bool successfullyLocked() const {
         return m_locked;
     }
 
 private:
     KisDocument::Private *d;
     KisDocument *m_document;
     bool m_locked;
 
     KisImageBarrierLockAdapter m_imageLock;
 };
 
 KisDocument::KisDocument()
     : d(new Private())
 {
     d->undoStack = new UndoStack(this);
     d->undoStack->setParent(this);
 
     d->importExportManager = new KisImportExportManager(this);
     d->importExportManager->setProgresUpdater(d->progressUpdater);
 
     connect(&d->autoSaveTimer, SIGNAL(timeout()), this, SLOT(slotAutoSave()));
     KisConfig cfg;
     setAutoSaveDelay(cfg.autoSaveInterval());
 
     setObjectName(newObjectName());
 
     d->docInfo = new KoDocumentInfo(this);
 
     d->firstMod = QDateTime::currentDateTime();
     d->lastMod = QDateTime::currentDateTime();
 
 
     // preload the krita resources
     KisResourceServerProvider::instance();
 
     d->nserver = new KisNameServer(1);
 
     d->shapeController = new KisShapeController(this, d->nserver);
     d->koShapeController = new KoShapeController(0, d->shapeController);
 
     undoStack()->setUndoLimit(KisConfig().undoStackLimit());
     connect(d->undoStack, SIGNAL(indexChanged(int)), this, SLOT(slotUndoStackIndexChanged(int)));
     setBackupFile(KisConfig().backupFile());
 }
 
 KisDocument::~KisDocument()
 {
     /**
      * Push a timebomb, which will try to release the memory after
      * the document has been deleted
      */
     KisPaintDevice::createMemoryReleaseObject()->deleteLater();
 
     d->autoSaveTimer.disconnect(this);
     d->autoSaveTimer.stop();
 
     delete d->importExportManager;
 
     // Despite being QObject they needs to be deleted before the image
     delete d->shapeController;
 
     delete d->koShapeController;
 
     if (d->image) {
         d->image->notifyAboutToBeDeleted();
 
         /**
          * WARNING: We should wait for all the internal image jobs to
          * finish before entering KisImage's destructor. The problem is,
          * while execution of KisImage::~KisImage, all the weak shared
          * pointers pointing to the image enter an inconsistent
          * state(!). The shared counter is already zero and destruction
          * has started, but the weak reference doesn't know about it,
          * because KisShared::~KisShared hasn't been executed yet. So all
          * the threads running in background and having weak pointers will
          * enter the KisImage's destructor as well.
          */
 
         d->image->requestStrokeCancellation();
         d->image->waitForDone();
 
         // clear undo commands that can still point to the image
         d->undoStack->clear();
         d->image->waitForDone();
 
         KisImageWSP sanityCheckPointer = d->image;
         Q_UNUSED(sanityCheckPointer);
         // The following line trigger the deletion of the image
         d->image.clear();
 
         // check if the image has actually been deleted
         KIS_SAFE_ASSERT_RECOVER_NOOP(!sanityCheckPointer.isValid());
     }
 
 
     delete d;
 }
 
 bool KisDocument::reload()
 {
     // XXX: reimplement!
     return false;
 }
 
 bool KisDocument::exportDocument(const QUrl &_url, KisPropertiesConfigurationSP exportConfiguration)
 {
     //qDebug() << "exportDocument" << _url.toDisplayString() << "is autosaving" << d->isAutosaving;
     bool ret;
 
     d->isExporting = true;
 
     //
     // Preserve a lot of state here because we need to restore it in order to
     // be able to fake a File --> Export.  Can't do this in saveFile() because,
     // for a start, KParts has already set url and m_file and because we need
     // to restore the modified flag etc. and don't want to put a load on anyone
     // reimplementing saveFile() (Note: importDocument() and exportDocument()
     // will remain non-virtual).
     //
     QUrl oldURL = url();
     QString oldFile = localFilePath();
 
     //qDebug() << "\toldUrl" << oldURL << "oldFile" << oldFile << "export url" << _url;
 
     bool wasModified = isModified();
 
     // save...
     ret = saveAs(_url, exportConfiguration);
 
     //
     // This is sooooo hacky :(
     // Hopefully we will restore enough state.
     //
     dbgUI << "Restoring KisDocument state to before export";
 
     // always restore url & m_file regardless of failure or success
     //qDebug() << "\tafter saveAs: url" << url() << "local file path" << localFilePath();
     setUrl(oldURL);
     setLocalFilePath(oldFile);
     //qDebug() << "\tafter restoring: url" << url() << "local file path" << localFilePath();
 
 
     // on successful export we need to restore modified etc. too
     // on failed export, mimetype/modified hasn't changed anyway
     if (ret) {
         setModified(wasModified);
    }
 
     d->isExporting = false;
 
     return ret;
 }
 
 bool KisDocument::saveAs(const QUrl &url, KisPropertiesConfigurationSP exportConfiguration)
 {
     //qDebug() << "saveAs" << url;
     if (!url.isValid() || !url.isLocalFile()) {
         errKrita << "saveAs: Malformed URL " << url.url() << endl;
         return false;
     }
     d->m_duringSaveAs = true;
     d->m_originalURL = d->m_url;
     d->m_originalFilePath = d->m_file;
     d->m_url = url; // Store where to upload in saveToURL
     d->m_file = d->m_url.toLocalFile();
 
     bool result = save(exportConfiguration); // Save local file and upload local file
 
     if (!result) {
         d->m_url = d->m_originalURL;
         d->m_file = d->m_originalFilePath;
         d->m_duringSaveAs = false;
         d->m_originalURL = QUrl();
         d->m_originalFilePath.clear();
     }
 
     return result;
 }
 
 bool KisDocument::save(KisPropertiesConfigurationSP exportConfiguration)
 {
     //qDebug() << "save" << d->m_file << d->m_url << url() << localFilePath();
 
     d->m_saveOk = false;
+
     if (d->m_file.isEmpty()) { // document was created empty
         d->m_file = d->m_url.toLocalFile();
     }
 
     updateEditingTime(true);
 
     setFileProgressProxy();
     setUrl(url());
 
     bool ok = saveFile(localFilePath(), exportConfiguration);
 
     clearFileProgressProxy();
 
     if (ok) {
         setModified( false );
         emit completed();
         d->m_saveOk = true;
         d->m_duringSaveAs = false;
         d->m_originalURL = QUrl();
         d->m_originalFilePath.clear();
         return true; // Nothing to do
     }
     else {
         emit canceled(QString());
     }
     return false;
 }
 
 bool KisDocument::saveFile(const QString &filePath, KisPropertiesConfigurationSP exportConfiguration)
 {
     if (!prepareLocksForSaving()) {
         return false;
     }
 
     // Unset the error message
     setErrorMessage("");
 
     // Save it to be able to restore it after a failed save
     const bool wasModified = isModified();
+    bool ret = false;
+    bool suppressErrorDialog = fileBatchMode();
+    KisImportExportFilter::ConversionStatus status = KisImportExportFilter::OK;
 
-    // The output format is set by KisMainWindow, and by openFile
-    QByteArray outputMimeType = d->outputMimeType;
+    //qDebug() << "saveFile" << localFilePath() << QFileInfo(localFilePath()).exists() << !QFileInfo(localFilePath()).isWritable();
 
-    if (outputMimeType.isEmpty()) {
-        outputMimeType = d->outputMimeType = nativeFormatMimeType();
+    if (QFileInfo(localFilePath()).exists() && !QFileInfo(localFilePath()).isWritable()) {
+        setErrorMessage(i18n("%1 cannot be written to. Please save under a different name.", localFilePath()));
     }
+    else {
 
-    //qDebug() << "saveFile. Is Autosaving?" << isAutosaving() << "url" << filePath << d->outputMimeType;
-
-
-    if (d->backupFile) {
-        Q_ASSERT(url().isLocalFile());
-        KBackup::backupFile(url().toLocalFile());
-    }
+        // The output format is set by KisMainWindow, and by openFile
+        QByteArray outputMimeType = d->outputMimeType;
 
-    qApp->processEvents();
+        if (outputMimeType.isEmpty()) {
+            outputMimeType = d->outputMimeType = nativeFormatMimeType();
+        }
 
-    bool ret = false;
-    bool suppressErrorDialog = false;
-    KisImportExportFilter::ConversionStatus status = KisImportExportFilter::OK;
+        //qDebug() << "saveFile. Is Autosaving?" << isAutosaving() << "url" << filePath << d->outputMimeType;
 
-    setFileProgressUpdater(i18n("Saving Document"));
 
-    QFileInfo fi(filePath);
-    QString tempororaryFileName;
-    {
-        QTemporaryFile tf(QDir::tempPath() + "/XXXXXX" + fi.baseName() + "." + fi.completeSuffix());
-        tf.open();
-        tempororaryFileName = tf.fileName();
-    }
-    Q_ASSERT(!tempororaryFileName.isEmpty());
+        if (d->backupFile) {
+            Q_ASSERT(url().isLocalFile());
+            KBackup::backupFile(url().toLocalFile());
+        }
 
-    //qDebug() << "saving to tempory file" << tempororaryFileName;
-    status = d->importExportManager->exportDocument(tempororaryFileName, filePath, outputMimeType, !d->isExporting , exportConfiguration);
+        qApp->processEvents();
 
-    ret = (status == KisImportExportFilter::OK);
-    suppressErrorDialog = (isAutosaving() || status == KisImportExportFilter::UserCancelled || status == KisImportExportFilter::BadConversionGraph);
-    //qDebug() << "Export status was" << status;
+        setFileProgressUpdater(i18n("Saving Document"));
 
-    if (ret) {
+        //qDebug() << "saving to tempory file" << tempororaryFileName;
+        status = d->importExportManager->exportDocument(localFilePath(), filePath, outputMimeType, !d->isExporting , exportConfiguration);
 
-        //qDebug() << "copying temporary file" << tempororaryFileName << "to" << filePath;
+        ret = (status == KisImportExportFilter::OK);
+        suppressErrorDialog = (fileBatchMode() || isAutosaving() || status == KisImportExportFilter::UserCancelled || status == KisImportExportFilter::BadConversionGraph);
+        //qDebug() << "Export status was" << status;
 
-        if (!d->isAutosaving && !d->suppressProgress) {
-            QPointer<KoUpdater> updater = d->progressUpdater->startSubtask(1, "clear undo stack");
-            updater->setProgress(0);
-            d->undoStack->setClean();
-            updater->setProgress(100);
-        } else {
-            d->undoStack->setClean();
-        }
+        if (ret) {
 
-        QFile tempFile(tempororaryFileName);
-        QString s = filePath;
-        QFile dstFile(s);
-        while (QFileInfo(s).exists()) {
-            s.append("_");
-        }
-        bool r;
-        if (s != filePath) {
-            r = dstFile.rename(s);
-            if (!r) {
-               setErrorMessage(i18n("Could not rename original file to %1: %2", dstFile.fileName(), dstFile. errorString()));
-                ret = false;
+            if (!d->isAutosaving && !d->suppressProgress) {
+                QPointer<KoUpdater> updater = d->progressUpdater->startSubtask(1, "clear undo stack");
+                updater->setProgress(0);
+                d->undoStack->setClean();
+                updater->setProgress(100);
+            } else {
+                d->undoStack->setClean();
             }
-         }
 
-        if (tempFile.exists()) {
-            r = tempFile.copy(filePath);
-            if (!r) {
-                setErrorMessage(i18n("Copying the temporary file failed: %1 to %2: %3", tempFile.fileName(), dstFile.fileName(), tempFile.errorString()));
-                ret = false;
+            if (errorMessage().isEmpty()) {
+                if (!isAutosaving()) {
+                    removeAutoSaveFiles();
+                }
             }
             else {
-                r = tempFile.remove();
-                if (!r) {
-                    setErrorMessage(i18n("Could not remove temporary file %1: %2", tempFile.fileName(), tempFile.errorString()));
-                    ret = false;
-                }
-                else if (s != filePath) {
-                    r = dstFile.remove();
-                    if (!r) {
-                        setErrorMessage(i18n("Could not remove saved original file: %1", dstFile.errorString()));
-                        ret = false;
-                    }
-                }
+                ret = false;
+                qWarning() << "Error while saving:" << errorMessage();
             }
-        }
-        else {
-            setErrorMessage(i18n("The temporary file %1 is gone before we could copy it!", tempFile.fileName()));
-            ret = false;
-        }
-
-        if (errorMessage().isEmpty()) {
+            // Restart the autosave timer
+            // (we don't want to autosave again 2 seconds after a real save)
             if (!isAutosaving()) {
-                removeAutoSaveFiles();
+                setAutoSaveDelay(d->autoSaveDelay);
             }
-        }
-        else {
-            ret = false;
-            qWarning() << "Error while saving:" << errorMessage();
-        }
-        // Restart the autosave timer
-        // (we don't want to autosave again 2 seconds after a real save)
-        if (!isAutosaving()) {
-            setAutoSaveDelay(d->autoSaveDelay);
-        }
 
-        d->mimeType = outputMimeType;
+            d->mimeType = outputMimeType;
+        }
     }
+
     if (!ret) {
         if (!suppressErrorDialog) {
 
             if (errorMessage().isEmpty()) {
                 setErrorMessage(KisImportExportFilter::conversionStatusString(status));
             }
 
             if (errorMessage().isEmpty()) {
                 QMessageBox::critical(0, i18nc("@title:window", "Krita"), i18n("Could not save\n%1", filePath));
             } else {
                 QMessageBox::critical(0, i18nc("@title:window", "Krita"), i18n("Could not save %1\nReason: %2", filePath, errorMessage()));
             }
 
         }
 
         // couldn't save file so this new URL is invalid
         // FIXME: we should restore the current document's true URL instead of
         // setting it to nothing otherwise anything that depends on the URL
         // being correct will not work (i.e. the document will be called
         // "Untitled" which may not be true)
         //
         // Update: now the URL is restored in KisMainWindow but really, this
         // should still be fixed in KisDocument/KParts (ditto for file).
         // We still resetURL() here since we may or may not have been called
         // by KisMainWindow - Clarence
         resetURL();
 
         // As we did not save, restore the "was modified" status
         setModified(wasModified);
     }
 
     emit sigSavingFinished();
     clearFileProgressUpdater();
 
     unlockAfterSaving();
     return ret;
 }
 
 
 QByteArray KisDocument::mimeType() const
 {
     return d->mimeType;
 }
 
 void KisDocument::setMimeType(const QByteArray & mimeType)
 {
     d->mimeType = mimeType;
 }
 
 void KisDocument::setOutputMimeType(const QByteArray & mimeType)
 {
     d->outputMimeType = mimeType;
 }
 
 QByteArray KisDocument::outputMimeType() const
 {
     return d->outputMimeType;
 }
 
 bool KisDocument::fileBatchMode() const
 {
     return d->importExportManager->batchMode();
 }
 
 void KisDocument::setFileBatchMode(const bool batchMode)
 {
     d->importExportManager->setBatchMode(batchMode);
 }
 
 bool KisDocument::isImporting() const
 {
     return d->isImporting;
 }
 
 bool KisDocument::isExporting() const
 {
     return d->isExporting;
 }
 
 void KisDocument::slotAutoSave()
 {
     //qDebug() << "slotAutoSave. Modified:"  << d->modified << "modifiedAfterAutosave" << d->modified << "url" << url() << localFilePath();
 
     if (!d->isAutosaving && d->modified && d->modifiedAfterAutosave) {
 
         connect(this, SIGNAL(sigProgress(int)), KisPart::instance()->currentMainwindow(), SLOT(slotProgress(int)));
         emit statusBarMessage(i18n("Autosaving..."));
         d->isAutosaving = true;
         QString autoSaveFileName = generateAutoSaveFileName(localFilePath());
 
         QByteArray mimetype = d->outputMimeType;
         d->outputMimeType = nativeFormatMimeType();
         bool ret = exportDocument(QUrl::fromLocalFile(autoSaveFileName));
         d->outputMimeType = mimetype;
 
         if (ret) {
             d->modifiedAfterAutosave = false;
             d->autoSaveTimer.stop(); // until the next change
         }
         d->isAutosaving = false;
 
         emit clearStatusBarMessage();
         disconnect(this, SIGNAL(sigProgress(int)), KisPart::instance()->currentMainwindow(), SLOT(slotProgress(int)));
 
         if (!ret && !d->disregardAutosaveFailure) {
             emit statusBarMessage(i18n("Error during autosave! Partition full?"));
         }
     }
 }
 
 void KisDocument::setReadWrite(bool readwrite)
 {
     d->readwrite = readwrite;
     setAutoSaveDelay(d->autoSaveDelay);
 
     Q_FOREACH (KisMainWindow *mainWindow, KisPart::instance()->mainWindows()) {
         mainWindow->setReadWrite(readwrite);
     }
 }
 
 void KisDocument::setAutoSaveDelay(int delay)
 {
     //qDebug() << "setting autosave delay from" << d->autoSaveDelay << "to" << delay;
     d->autoSaveDelay = delay;
     if (isReadWrite() && d->autoSaveDelay > 0) {
         d->autoSaveTimer.start(d->autoSaveDelay * 1000);
     }
     else {
         d->autoSaveTimer.stop();
     }
 }
 
 KoDocumentInfo *KisDocument::documentInfo() const
 {
     return d->docInfo;
 }
 
 bool KisDocument::isModified() const
 {
     return d->modified;
 }
 
 QPixmap KisDocument::generatePreview(const QSize& size)
 {
     KisImageSP image = d->image;
     if (d->savingImage) image = d->savingImage;
 
     if (image) {
         QRect bounds = image->bounds();
         QSize newSize = bounds.size();
         newSize.scale(size, Qt::KeepAspectRatio);
         QPixmap px = QPixmap::fromImage(image->convertToQImage(newSize, 0));
         if (px.size() == QSize(0,0)) {
             px = QPixmap(newSize);
             QPainter gc(&px);
             QBrush checkBrush = QBrush(KisCanvasWidgetBase::createCheckersImage(newSize.width() / 5));
             gc.fillRect(px.rect(), checkBrush);
             gc.end();
         }
         return px;
     }
     return QPixmap(size);
 }
 
 QString KisDocument::generateAutoSaveFileName(const QString & path) const
 {
     QString retval;
 
     // Using the extension allows to avoid relying on the mime magic when opening
     const QString extension (".kra");
 
     if (path.isEmpty()) {
         // Never saved?
 #ifdef Q_OS_WIN
         // On Windows, use the temp location (https://bugs.kde.org/show_bug.cgi?id=314921)
         retval = QString("%1%2.%3-%4-%5-autosave%6").arg(QDir::tempPath()).arg(QDir::separator()).arg("krita").arg(qApp->applicationPid()).arg(objectName()).arg(extension);
 #else
         // On Linux, use a temp file in $HOME then. Mark it with the pid so two instances don't overwrite each other's autosave file
         retval = QString("%1%2.%3-%4-%5-autosave%6").arg(QDir::homePath()).arg(QDir::separator()).arg("krita").arg(qApp->applicationPid()).arg(objectName()).arg(extension);
 #endif
     } else {
         QFileInfo fi(path);
         QString dir = fi.absolutePath();
         QString filename = fi.fileName();
         retval = QString("%1%2.%3-autosave%4").arg(dir).arg(QDir::separator()).arg(filename).arg(extension);
     }
 
     //qDebug() << "generateAutoSaveFileName() for path" << path << ":" << retval;
     return retval;
 }
 
 bool KisDocument::importDocument(const QUrl &_url)
 {
     bool ret;
 
     dbgUI << "url=" << _url.url();
     d->isImporting = true;
 
     // open...
     ret = openUrl(_url);
 
     // reset url & m_file (kindly? set by KisParts::openUrl()) to simulate a
     // File --> Import
     if (ret) {
         dbgUI << "success, resetting url";
         resetURL();
         setTitleModified();
     }
 
     d->isImporting = false;
 
     return ret;
 }
 
 
 bool KisDocument::openUrl(const QUrl &_url, KisDocument::OpenUrlFlags flags)
 {
     if (!_url.isLocalFile()) {
         return false;
     }
     dbgUI << "url=" << _url.url();
     d->lastErrorMessage.clear();
 
     // Reimplemented, to add a check for autosave files and to improve error reporting
     if (!_url.isValid()) {
         d->lastErrorMessage = i18n("Malformed URL\n%1", _url.url());  // ## used anywhere ?
         return false;
     }
 
     QUrl url(_url);
     bool autosaveOpened = false;
     if (url.isLocalFile() && !fileBatchMode()) {
         QString file = url.toLocalFile();
         QString asf = generateAutoSaveFileName(file);
         if (QFile::exists(asf)) {
             KisApplication *kisApp = static_cast<KisApplication*>(qApp);
             kisApp->hideSplashScreen();
             //dbgUI <<"asf=" << asf;
             // ## TODO compare timestamps ?
             int res = QMessageBox::warning(0,
                                            i18nc("@title:window", "Krita"),
                                            i18n("An autosaved file exists for this document.\nDo you want to open it instead?"),
                                            QMessageBox::Yes | QMessageBox::No | QMessageBox::Cancel, QMessageBox::Yes);
             switch (res) {
             case QMessageBox::Yes :
                 url.setPath(asf);
                 autosaveOpened = true;
                 break;
             case QMessageBox::No :
                 QFile::remove(asf);
                 break;
             default: // Cancel
                 return false;
             }
         }
     }
 
     bool ret = openUrlInternal(url);
 
     if (autosaveOpened) {
         resetURL(); // Force save to act like 'Save As'
         setReadWrite(true); // enable save button
         setModified(true);
     }
     else {
         if( !(flags & OPEN_URL_FLAG_DO_NOT_ADD_TO_RECENT_FILES) ) {
             KisPart::instance()->addRecentURLToAllMainWindows(_url);
         }
 
         if (ret) {
             // Detect readonly local-files; remote files are assumed to be writable
             QFileInfo fi(url.toLocalFile());
             setReadWrite(fi.isWritable());
         }
     }
     return ret;
 }
 
 class DlgLoadMessages : public KoDialog {
 public:
     DlgLoadMessages(const QString &title, const QString &message, const QStringList &warnings) {
         setWindowTitle(title);
         setWindowIcon(KisIconUtils::loadIcon("dialog-warning"));
         QWidget *page = new QWidget(this);
         QVBoxLayout *layout = new QVBoxLayout(page);
         QHBoxLayout *hlayout = new QHBoxLayout();
         QLabel *labelWarning= new QLabel();
         labelWarning->setPixmap(KisIconUtils::loadIcon("dialog-warning").pixmap(32, 32));
         hlayout->addWidget(labelWarning);
         hlayout->addWidget(new QLabel(message));
         layout->addLayout(hlayout);
         QTextBrowser *browser = new QTextBrowser();
         QString warning = "<html><body><p><b>";
         if (warnings.size() == 1) {
             warning += "</b> Reason:</p>";
         }
         else {
             warning += "</b> Reasons:</p>";
         }
         warning += "<p/><ul>";
 
         Q_FOREACH(const QString &w, warnings) {
             warning += "\n<li>" + w + "</li>";
         }
         warning += "</ul>";
         browser->setHtml(warning);
         browser->setMinimumHeight(200);
         browser->setMinimumWidth(400);
         layout->addWidget(browser);
         setMainWidget(page);
         setButtons(KoDialog::Ok);
         resize(minimumSize());
     }
 };
 
 bool KisDocument::openFile()
 {
     //dbgUI <<"for" << localFilePath();
     if (!QFile::exists(localFilePath())) {
         QMessageBox::critical(0, i18nc("@title:window", "Krita"), i18n("File %1 does not exist.", localFilePath()));
         return false;
     }
 
     QString filename = localFilePath();
     QString typeName = mimeType();
 
     if (typeName.isEmpty()) {
         typeName = KisMimeDatabase::mimeTypeForFile(filename);
     }
 
     //qDebug() << "mimetypes 4:" << typeName;
 
     // Allow to open backup files, don't keep the mimetype application/x-trash.
     if (typeName == "application/x-trash") {
         QString path = filename;
         while (path.length() > 0) {
             path.chop(1);
             typeName = KisMimeDatabase::mimeTypeForFile(path);
             //qDebug() << "\t" << path << typeName;
             if (!typeName.isEmpty()) {
                 break;
             }
         }
         //qDebug() << "chopped" << filename  << "to" << path << "Was trash, is" << typeName;
     }
     dbgUI << localFilePath() << "type:" << typeName;
 
     setFileProgressUpdater(i18n("Opening Document"));
 
     KisImportExportFilter::ConversionStatus status;
 
     status = d->importExportManager->importDocument(localFilePath(), typeName);
     if (status != KisImportExportFilter::OK) {
         QString msg = KisImportExportFilter::conversionStatusString(status);
         if (!msg.isEmpty()) {
             DlgLoadMessages dlg(i18nc("@title:window", "Krita"),
                                 i18n("Could not open %2.\nReason: %1.", msg, prettyPathOrUrl()),
                                 errorMessage().split("\n") + warningMessage().split("\n"));
             dlg.exec();
         }
         clearFileProgressUpdater();
         return false;
     }
     else if (!warningMessage().isEmpty()) {
         DlgLoadMessages dlg(i18nc("@title:window", "Krita"),
                             i18n("There were problems opening %1.", prettyPathOrUrl()),
                             warningMessage().split("\n"));
         dlg.exec();
         setUrl(QUrl());
     }
 
     setMimeTypeAfterLoading(typeName);
     emit sigLoadingFinished();
 
     if (!d->suppressProgress && d->progressUpdater) {
         QPointer<KoUpdater> updater = d->progressUpdater->startSubtask(1, "clear undo stack");
         updater->setProgress(0);
         undoStack()->clear();
         updater->setProgress(100);
 
         clearFileProgressUpdater();
     } else {
         undoStack()->clear();
     }
 
     return true;
 }
 
 KoProgressUpdater *KisDocument::progressUpdater() const
 {
     return d->progressUpdater;
 }
 
 void KisDocument::setProgressProxy(KoProgressProxy *progressProxy)
 {
     d->progressProxy = progressProxy;
 }
 
 KoProgressProxy* KisDocument::progressProxy() const
 {
     if (!d->progressProxy) {
         KisMainWindow *mainWindow = 0;
         if (KisPart::instance()->mainwindowCount() > 0) {
             mainWindow = KisPart::instance()->mainWindows()[0];
         }
         d->progressProxy = new DocumentProgressProxy(mainWindow);
     }
     return d->progressProxy;
 }
 
 // shared between openFile and koMainWindow's "create new empty document" code
 void KisDocument::setMimeTypeAfterLoading(const QString& mimeType)
 {
     d->mimeType = mimeType.toLatin1();
     d->outputMimeType = d->mimeType;
 }
 
 
 bool KisDocument::loadNativeFormat(const QString & file_)
 {
     return openUrl(QUrl::fromLocalFile(file_));
 }
 
 void KisDocument::setModified()
 {
     d->modified = true;
 }
 
 void KisDocument::setModified(bool mod)
 {
     if (mod) {
         updateEditingTime(false);
     }
 
     if (d->isAutosaving)   // ignore setModified calls due to autosaving
         return;
 
     if ( !d->readwrite && d->modified ) {
         errKrita << "Can't set a read-only document to 'modified' !" << endl;
         return;
     }
 
     //dbgUI<<" url:" << url.path();
     //dbgUI<<" mod="<<mod<<" MParts mod="<<KisParts::ReadWritePart::isModified()<<" isModified="<<isModified();
 
     if (mod && !d->modifiedAfterAutosave) {
         // First change since last autosave -> start the autosave timer
         setAutoSaveDelay(d->autoSaveDelay);
     }
     d->modifiedAfterAutosave = mod;
 
     if (mod == isModified())
         return;
 
     d->modified = mod;
 
     if (mod) {
         documentInfo()->updateParameters();
     }
 
     // This influences the title
     setTitleModified();
     emit modified(mod);
 }
 
 void KisDocument::updateEditingTime(bool forceStoreElapsed)
 {
     QDateTime now = QDateTime::currentDateTime();
     int firstModDelta = d->firstMod.secsTo(now);
     int lastModDelta = d->lastMod.secsTo(now);
 
     if (lastModDelta > 30) {
         d->docInfo->setAboutInfo("editing-time", QString::number(d->docInfo->aboutInfo("editing-time").toInt() + d->firstMod.secsTo(d->lastMod)));
         d->firstMod = now;
     } else if (firstModDelta > 60 || forceStoreElapsed) {
         d->docInfo->setAboutInfo("editing-time", QString::number(d->docInfo->aboutInfo("editing-time").toInt() + firstModDelta));
         d->firstMod = now;
     }
 
     d->lastMod = now;
 }
 
 QString KisDocument::prettyPathOrUrl() const
 {
     QString _url(url().toDisplayString());
 #ifdef Q_OS_WIN
     if (url().isLocalFile()) {
         _url = QDir::toNativeSeparators(_url);
     }
 #endif
     return _url;
 }
 
 // Get caption from document info (title(), in about page)
 QString KisDocument::caption() const
 {
     QString c;
     if (documentInfo()) {
         c = documentInfo()->aboutInfo("title");
     }
     const QString _url(url().fileName());
     if (!c.isEmpty() && !_url.isEmpty()) {
         c = QString("%1 - %2").arg(c).arg(_url);
     }
     else if (c.isEmpty()) {
         c = _url; // Fall back to document URL
     }
     return c;
 }
 
 void KisDocument::setTitleModified()
 {
     emit titleModified(caption(), isModified());
 }
 
 QDomDocument KisDocument::createDomDocument(const QString& tagName, const QString& version) const
 {
     return createDomDocument("krita", tagName, version);
 }
 
 //static
 QDomDocument KisDocument::createDomDocument(const QString& appName, const QString& tagName, const QString& version)
 {
     QDomImplementation impl;
     QString url = QString("http://www.calligra.org/DTD/%1-%2.dtd").arg(appName).arg(version);
     QDomDocumentType dtype = impl.createDocumentType(tagName,
                                                      QString("-//KDE//DTD %1 %2//EN").arg(appName).arg(version),
                                                      url);
     // The namespace URN doesn't need to include the version number.
     QString namespaceURN = QString("http://www.calligra.org/DTD/%1").arg(appName);
     QDomDocument doc = impl.createDocument(namespaceURN, tagName, dtype);
     doc.insertBefore(doc.createProcessingInstruction("xml", "version=\"1.0\" encoding=\"UTF-8\""), doc.documentElement());
     return doc;
 }
 
 bool KisDocument::isNativeFormat(const QByteArray& mimetype) const
 {
     if (mimetype == nativeFormatMimeType())
         return true;
     return extraNativeMimeTypes().contains(mimetype);
 }
 
 void KisDocument::setErrorMessage(const QString& errMsg)
 {
     d->lastErrorMessage = errMsg;
 }
 
 QString KisDocument::errorMessage() const
 {
     return d->lastErrorMessage;
 }
 
 void KisDocument::setWarningMessage(const QString& warningMsg)
 {
     d->lastWarningMessage = warningMsg;
 }
 
 QString KisDocument::warningMessage() const
 {
     return d->lastWarningMessage;
 }
 
 
 void KisDocument::removeAutoSaveFiles()
 {
     //qDebug() << "removeAutoSaveFiles";
     // Eliminate any auto-save file
     QString asf = generateAutoSaveFileName(localFilePath());   // the one in the current dir
     //qDebug() << "\tfilename:" << asf << "exists:" << QFile::exists(asf);
     if (QFile::exists(asf)) {
         //qDebug() << "\tremoving autosavefile" << asf;
         QFile::remove(asf);
     }
     asf = generateAutoSaveFileName(QString());   // and the one in $HOME
     //qDebug() << "Autsavefile in $home" << asf;
     if (QFile::exists(asf)) {
         //qDebug() << "\tremoving autsavefile 2" << asf;
         QFile::remove(asf);
     }
 }
 
 void KisDocument::setBackupFile(bool saveBackup)
 {
     d->backupFile = saveBackup;
 }
 
 KoUnit KisDocument::unit() const
 {
     return d->unit;
 }
 
 void KisDocument::setUnit(const KoUnit &unit)
 {
     if (d->unit != unit) {
         d->unit = unit;
         emit unitChanged(unit);
     }
 }
 
 KUndo2Stack *KisDocument::undoStack()
 {
     return d->undoStack;
 }
 
 KisImportExportManager *KisDocument::importExportManager() const
 {
     return d->importExportManager;
 }
 
 void KisDocument::addCommand(KUndo2Command *command)
 {
     if (command)
         d->undoStack->push(command);
 }
 
 void KisDocument::beginMacro(const KUndo2MagicString & text)
 {
     d->undoStack->beginMacro(text);
 }
 
 void KisDocument::endMacro()
 {
     d->undoStack->endMacro();
 }
 
 void KisDocument::slotUndoStackIndexChanged(int idx)
 {
     // even if the document was already modified, call setModified to re-start autosave timer
     setModified(idx != d->undoStack->cleanIndex());
 }
 
 void KisDocument::clearUndoHistory()
 {
     d->undoStack->clear();
 }
 
 KisGridConfig KisDocument::gridConfig() const
 {
     return d->gridConfig;
 }
 
 void KisDocument::setGridConfig(const KisGridConfig &config)
 {
     d->gridConfig = config;
 }
 
 const KisGuidesConfig& KisDocument::guidesConfig() const
 {
     return d->guidesConfig;
 }
 
 void KisDocument::setGuidesConfig(const KisGuidesConfig &data)
 {
     if (d->guidesConfig == data) return;
 
     d->guidesConfig = data;
     emit sigGuidesConfigChanged(d->guidesConfig);
 }
 
 void KisDocument::resetURL() {
     setUrl(QUrl());
     setLocalFilePath(QString());
 }
 
 KoDocumentInfoDlg *KisDocument::createDocumentInfoDialog(QWidget *parent, KoDocumentInfo *docInfo) const
 {
     return new KoDocumentInfoDlg(parent, docInfo);
 }
 
 bool KisDocument::isReadWrite() const
 {
     return d->readwrite;
 }
 
 QUrl KisDocument::url() const
 {
     return d->m_url;
 }
 
 bool KisDocument::closeUrl(bool promptToSave)
 {
     if (promptToSave) {
         if ( isReadWrite() && isModified()) {
             Q_FOREACH (KisView *view, KisPart::instance()->views()) {
                 if (view && view->document() == this) {
                     if (!view->queryClose()) {
                         return false;
                     }
                 }
             }
         }
     }
     // Not modified => ok and delete temp file.
     d->mimeType = QByteArray();
 
     // It always succeeds for a read-only part,
     // but the return value exists for reimplementations
     // (e.g. pressing cancel for a modified read-write part)
     return true;
 }
 
 
 
 void KisDocument::setUrl(const QUrl &url)
 {
     d->m_url = url;
 }
 
 QString KisDocument::localFilePath() const
 {
     return d->m_file;
 }
 
 
 void KisDocument::setLocalFilePath( const QString &localFilePath )
 {
     d->m_file = localFilePath;
 }
 
 bool KisDocument::openUrlInternal(const QUrl &url)
 {
     if ( !url.isValid() )
         return false;
 
     if (d->m_bAutoDetectedMime) {
         d->mimeType = QByteArray();
         d->m_bAutoDetectedMime = false;
     }
 
     QByteArray mimetype = d->mimeType;
 
     if ( !closeUrl() )
         return false;
 
     d->mimeType = mimetype;
     setUrl(url);
 
     d->m_file.clear();
 
     if (d->m_url.isLocalFile()) {
         d->m_file = d->m_url.toLocalFile();
         bool ret;
         // set the mimetype only if it was not already set (for example, by the host application)
         if (d->mimeType.isEmpty()) {
             // get the mimetype of the file
             // using findByUrl() to avoid another string -> url conversion
             QString mime = KisMimeDatabase::mimeTypeForFile(d->m_url.toLocalFile());
             d->mimeType = mime.toLocal8Bit();
             d->m_bAutoDetectedMime = true;
         }
         setFileProgressProxy();
         setUrl(d->m_url);
         ret = openFile();
         clearFileProgressProxy();
 
         if (ret) {
             emit completed();
         } else {
             emit canceled(QString());
         }
         return ret;
     }
     return false;
 }
 
 bool KisDocument::newImage(const QString& name,
                            qint32 width, qint32 height,
                            const KoColorSpace* cs,
                            const KoColor &bgColor, bool backgroundAsLayer,
                            int numberOfLayers,
                            const QString &description, const double imageResolution)
 {
     Q_ASSERT(cs);
 
     KisConfig cfg;
 
     KisImageSP image;
     KisPaintLayerSP layer;
 
     if (!cs) return false;
 
     QApplication::setOverrideCursor(Qt::BusyCursor);
 
     image = new KisImage(createUndoStore(), width, height, cs, name);
 
     Q_CHECK_PTR(image);
 
     connect(image, SIGNAL(sigImageModified()), this, SLOT(setImageModified()), Qt::UniqueConnection);
     image->setResolution(imageResolution, imageResolution);
 
     image->assignImageProfile(cs->profile());
     documentInfo()->setAboutInfo("title", name);
     if (name != i18n("Unnamed") && !name.isEmpty()) {
         setUrl(QUrl::fromLocalFile(QDesktopServices::storageLocation(QDesktopServices::PicturesLocation) + '/' + name + ".kra"));
     }
     documentInfo()->setAboutInfo("abstract", description);
 
     layer = new KisPaintLayer(image.data(), image->nextLayerName(), OPACITY_OPAQUE_U8, cs);
     Q_CHECK_PTR(layer);
 
     if (backgroundAsLayer) {
         image->setDefaultProjectionColor(KoColor(cs));
 
         if (bgColor.opacityU8() == OPACITY_OPAQUE_U8) {
             layer->paintDevice()->setDefaultPixel(bgColor);
         } else {
             // Hack: with a semi-transparent background color, the projection isn't composited right if we just set the default pixel
             KisFillPainter painter;
             painter.begin(layer->paintDevice());
             painter.fillRect(0, 0, width, height, bgColor, bgColor.opacityU8());
         }
     } else {
         image->setDefaultProjectionColor(bgColor);
     }
     layer->setDirty(QRect(0, 0, width, height));
 
     image->addNode(layer.data(), image->rootLayer().data());
     setCurrentImage(image);
 
     for(int i = 1; i < numberOfLayers; ++i) {
         KisPaintLayerSP layer = new KisPaintLayer(image, image->nextLayerName(), OPACITY_OPAQUE_U8, cs);
         image->addNode(layer, image->root(), i);
         layer->setDirty(QRect(0, 0, width, height));
     }
 
     cfg.defImageWidth(width);
     cfg.defImageHeight(height);
     cfg.defImageResolution(imageResolution);
     cfg.defColorModel(image->colorSpace()->colorModelId().id());
     cfg.setDefaultColorDepth(image->colorSpace()->colorDepthId().id());
     cfg.defColorProfile(image->colorSpace()->profile()->name());
 
     QApplication::restoreOverrideCursor();
 
     return true;
 }
 
 KoShapeBasedDocumentBase *KisDocument::shapeController() const
 {
     return d->shapeController;
 }
 
 KoShapeLayer* KisDocument::shapeForNode(KisNodeSP layer) const
 {
     return d->shapeController->shapeForNode(layer);
 }
 
 vKisNodeSP KisDocument::activeNodes() const
 {
     vKisNodeSP nodes;
     Q_FOREACH (KisView *v, KisPart::instance()->views()) {
         if (v->document() == this && v->viewManager()) {
             KisNodeSP activeNode = v->viewManager()->activeNode();
             if (activeNode && !nodes.contains(activeNode)) {
                 if (activeNode->inherits("KisMask")) {
                     activeNode = activeNode->parent();
                 }
                 nodes.append(activeNode);
             }
         }
     }
     return nodes;
 }
 
 QList<KisPaintingAssistantSP> KisDocument::assistants() const
 {
     return d->assistants;
 }
 
 void KisDocument::setAssistants(const QList<KisPaintingAssistantSP> value)
 {
     d->assistants = value;
 }
 
 void KisDocument::setPreActivatedNode(KisNodeSP activatedNode)
 {
     d->preActivatedNode = activatedNode;
 }
 
 KisNodeSP KisDocument::preActivatedNode() const
 {
     return d->preActivatedNode;
 }
 
 void KisDocument::setFileProgressUpdater(const QString &text)
 {
     d->suppressProgress = d->importExportManager->batchMode();
 
     if (!d->suppressProgress) {
         d->progressUpdater = new KoProgressUpdater(d->progressProxy, KoProgressUpdater::Unthreaded);
         d->progressUpdater->start(100, text);
         d->importExportManager->setProgresUpdater(d->progressUpdater);
         if (KisPart::instance()->currentMainwindow()) {
             connect(this, SIGNAL(sigProgress(int)), KisPart::instance()->currentMainwindow(), SLOT(slotProgress(int)));
             connect(KisPart::instance()->currentMainwindow(), SIGNAL(sigProgressCanceled()), this, SIGNAL(sigProgressCanceled()));
         }
     }
 }
 
 void KisDocument::clearFileProgressUpdater()
 {
     if (!d->suppressProgress && d->progressUpdater) {
         if (KisPart::instance()->currentMainwindow()) {
             disconnect(KisPart::instance()->currentMainwindow(), SIGNAL(sigProgressCanceled()), this, SIGNAL(sigProgressCanceled()));
             disconnect(this, SIGNAL(sigProgress(int)), KisPart::instance()->currentMainwindow(), SLOT(slotProgress(int)));
         }
         delete d->progressUpdater;
         d->importExportManager->setProgresUpdater(0);
         d->progressUpdater = 0;
     }
 }
 
 void KisDocument::setFileProgressProxy()
 {
     if (!d->progressProxy && !d->importExportManager->batchMode()) {
         d->fileProgressProxy = progressProxy();
     } else {
         d->fileProgressProxy = 0;
     }
 }
 
 void KisDocument::clearFileProgressProxy()
 {
     if (d->fileProgressProxy) {
         setProgressProxy(0);
         delete d->fileProgressProxy;
         d->fileProgressProxy = 0;
     }
 }
 
 KisImageWSP KisDocument::image() const
 {
     return d->image;
 }
 
 KisImageSP KisDocument::savingImage() const
 {
     return d->savingImage;
 }
 
 
 void KisDocument::setCurrentImage(KisImageSP image)
 {
     if (d->image) {
         // Disconnect existing sig/slot connections
         d->image->disconnect(this);
         d->shapeController->setImage(0);
         d->image = 0;
     }
 
     if (!image) return;
 
     d->setImageAndInitIdleWatcher(image);
     d->shapeController->setImage(image);
     setModified(false);
     connect(d->image, SIGNAL(sigImageModified()), this, SLOT(setImageModified()), Qt::UniqueConnection);
     d->image->initialRefreshGraph();
     setAutoSaveDelay(KisConfig().autoSaveInterval());
 }
 
 void KisDocument::setImageModified()
 {
     setModified(true);
 }
 
 
 KisUndoStore* KisDocument::createUndoStore()
 {
     return new KisDocumentUndoStore(this);
 }
 
 bool KisDocument::isAutosaving() const
 {
     return d->isAutosaving;
 }
 
 bool KisDocument::prepareLocksForSaving()
 {
     KisImageSP copiedImage;
     // XXX: Restore this when
     // a) cloning works correctly and
     // b) doesn't take ages because it needs to refresh its entire graph and finally,
     // c) we do use the saving image to save in the background.
     {
         Private::SafeSavingLocker locker(d, this);
         if (locker.successfullyLocked()) {
 
             copiedImage = d->image; //->clone(true);
         }
         else if (!isAutosaving()) {
             // even though it is a recovery operation, we should ensure we do not enter saving twice!
             std::unique_lock<StdLockableWrapper<QMutex>> l(d->savingLock, std::try_to_lock);
 
             if (l.owns_lock()) {
                 d->lastErrorMessage = i18n("The image was still busy while saving. Your saved image might be incomplete.");
                 d->image->lock();
                 copiedImage = d->image; //->clone(true);
                 //copiedImage->initialRefreshGraph();
                 d->image->unlock();
             }
         }
     }
 
     bool result = false;
 
     // ensure we do not enter saving twice
     if (copiedImage && d->savingMutex.tryLock()) {
         d->savingImage = copiedImage;
         result = true;
     } else {
         qWarning() << "Could not lock the document for saving!";
         d->lastErrorMessage = i18n("Could not lock the image for saving.");
     }
 
     return result;
 }
 
 void KisDocument::unlockAfterSaving()
 {
     d->savingImage = 0;
     d->savingMutex.unlock();
 }
 
diff --git a/libs/ui/KisImportExportFilter.h b/libs/ui/KisImportExportFilter.h
index 2cf439499c..0c163f7662 100644
--- a/libs/ui/KisImportExportFilter.h
+++ b/libs/ui/KisImportExportFilter.h
@@ -1,176 +1,179 @@
 /* This file is part of the Calligra libraries
    Copyright (C) 2001 Werner Trobin <trobin@kde.org>
                  2002 Werner Trobin <trobin@kde.org>
 
 This library is free software; you can redistribute it and/or
 modify it under the terms of the GNU Library General Public
 License as published by the Free Software Foundation; either
 version 2 of the License, or (at your option) any later version.
 
 This library is distributed in the hope that it will be useful,
 but WITHOUT ANY WARRANTY; without even the implied warranty of
 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 Library General Public License for more details.
 
 You should have received a copy of the GNU Library General Public License
 along with this library; see the file COPYING.LIB.  If not, write to
 the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
 Boston, MA 02110-1301, USA.
 */
 
 #ifndef KIS_IMPORT_EXPORT_FILTER_H
 #define KIS_IMPORT_EXPORT_FILTER_H
 
 #include <QObject>
 #include <QIODevice>
 #include <QMap>
 #include <QPointer>
 #include <QString>
 #include <QPair>
 #include <QList>
 #include <KoID.h>
 #include <QSharedPointer>
 #include <kis_properties_configuration.h>
 #include <kis_types.h>
 #include <KisExportCheckBase.h>
 
 class KoUpdater;
 class KisDocument;
 class KisConfigWidget;
 
 #include "kritaui_export.h"
 
 
 /**
  * @brief The base class for import and export filters.
  *
  * Derive your filter class from this base class and implement
  * the @ref convert() method. Don't forget to specify the Q_OBJECT
  * macro in your class even if you don't use signals or slots.
  * This is needed as filters are created on the fly.
  *
  * @note Take care: The m_chain pointer is invalid while the constructor
  * runs due to the implementation -- @em don't use it in the constructor.
  * After the constructor, when running the @ref convert() method it's
  * guaranteed to be valid, so no need to check against 0.
  *
  * @note If the code is compiled in debug mode, setting CALLIGRA_DEBUG_FILTERS
  * environment variable to any value disables deletion of temporary files while
  * importing/exporting. This is useful for testing purposes.
  *
  * @author Werner Trobin <trobin@kde.org>
  * @todo the class has no constructor and therefore cannot initialize its private class
  */
 class KRITAUI_EXPORT KisImportExportFilter : public QObject
 {
     Q_OBJECT
 
 public:
     /**
      * This enum is used to signal the return state of your filter.
      * Return OK in @ref convert() in case everything worked as expected.
      * Feel free to add some more error conditions @em before the last item
      * if it's needed.
      */
     enum ConversionStatus { OK,
                             UsageError,
                             CreationError,
                             FileNotFound,
                             StorageCreationError,
                             BadMimeType,
                             BadConversionGraph,
                             WrongFormat,
                             NotImplemented,
                             ParsingError,
                             InternalError,
                             UserCancelled,
                             InvalidFormat,
                             FilterCreationError,
                             ProgressCancelled,
                             UnsupportedVersion,
                             JustInCaseSomeBrokenCompilerUsesLessThanAByte = 255
                           };
 
     virtual ~KisImportExportFilter();
 
     void setBatchMode(bool batchmode);
     void setFilename(const QString &filename);
     void setRealFilename(const QString &filename);
     void setMimeType(const QString &mime);
     void setUpdater(QPointer<KoUpdater> updater);
 
     /**
      * The filter chain calls this method to perform the actual conversion.
      * The passed mimetypes should be a pair of those you specified in your
      * .desktop file.
      * You @em have to implement this method to make the filter work.
      *
      * @return The error status, see the @ref #ConversionStatus enum.
      *         KisImportExportFilter::OK means that everything is alright.
      */
     virtual ConversionStatus convert(KisDocument *document, QIODevice *io, KisPropertiesConfigurationSP configuration = 0) = 0;
 
     /**
      * Get the text version of the status value
      */
     static QString conversionStatusString(ConversionStatus status);
 
     /**
      * @brief defaultConfiguration defines the default settings for the given import export filter
      * @param from The mimetype of the source file/document
      * @param to The mimetype of the destination file/document
      * @return a serializable KisPropertiesConfiguration object
      */
     virtual KisPropertiesConfigurationSP defaultConfiguration(const QByteArray& from = "", const QByteArray& to = "") const;
 
     /**
      * @brief lastSavedConfiguration return the last saved configuration for this filter
      * @param from The mimetype of the source file/document
      * @param to The mimetype of the destination file/document
      * @return a serializable KisPropertiesConfiguration object
      */
     virtual KisPropertiesConfigurationSP lastSavedConfiguration(const QByteArray &from = "", const QByteArray &to = "") const;
 
     /**
      * @brief createConfigurationWidget creates a widget that can be used to define the settings for a given import/export filter
      * @param parent the ownder of the widget; the caller is responsible for deleting
      * @param from The mimetype of the source file/document
      * @param to The mimetype of the destination file/document
      *
      * @return the widget
      */
     virtual KisConfigWidget *createConfigurationWidget(QWidget *parent, const QByteArray& from = "", const QByteArray& to = "") const;
 
     /**
      * @brief generate and return the list of capabilities of this export filter. The list
      * @return returns the list of capabilities of this export filter
      */
     virtual QMap<QString, KisExportCheckBase*> exportChecks();
 
+    /// Override and return false for the filters that use a library that cannot handle file handles, only file names.
+    virtual bool supportsIO() const { return true; }
+
 protected:
     /**
      * This is the constructor your filter has to call, obviously.
      */
     KisImportExportFilter(QObject *parent = 0);
 
     QString filename() const;
     QString realFilename() const;
     bool batchMode() const;
     QByteArray mimeType() const;
 
     void setProgress(int value);
     virtual void initializeCapabilities();
     void addCapability(KisExportCheckBase *capability);
     void addSupportedColorModels(QList<QPair<KoID, KoID> > supportedColorModels, const QString &name, KisExportCheckBase::Level level = KisExportCheckBase::PARTIALLY);
 
 private:
 
     KisImportExportFilter(const KisImportExportFilter& rhs);
     KisImportExportFilter& operator=(const KisImportExportFilter& rhs);
 
     class Private;
     Private *const d;
 
 };
 
 #endif
diff --git a/libs/ui/KisImportExportManager.cpp b/libs/ui/KisImportExportManager.cpp
index 06c2e67906..d91be7cb6f 100644
--- a/libs/ui/KisImportExportManager.cpp
+++ b/libs/ui/KisImportExportManager.cpp
@@ -1,458 +1,480 @@
 /*
  * Copyright (C) 2016 Boudewijn Rempt <boud@valdyas.org>
  *
  * This library is free software; you can redistribute it and/or
  * modify it under the terms of the GNU Library General Public
  * License as published by the Free Software Foundation; either
  * version 2 of the License, or (at your option) any later version.
  *
  * This library is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  * Library General Public License for more details.
  *
  * You should have received a copy of the GNU Library General Public License
  * along with this library; see the file COPYING.LIB.  If not, write to
  * the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
  * Boston, MA 02110-1301, USA.
  */
 
 #include "KisImportExportManager.h"
 
 #include <QFile>
 #include <QLabel>
 #include <QVBoxLayout>
 #include <QList>
 #include <QApplication>
 #include <QByteArray>
 #include <QPluginLoader>
 #include <QFileInfo>
 #include <QMessageBox>
 #include <QJsonObject>
 #include <QTextBrowser>
 #include <QCheckBox>
+#include <QSaveFile>
 #include <QGroupBox>
 
 #include <klocalizedstring.h>
 #include <ksqueezedtextlabel.h>
 #include <kpluginfactory.h>
 
 #include <KoFileDialog.h>
 #include <kis_icon_utils.h>
 #include <KoDialog.h>
 #include <KoProgressUpdater.h>
 #include <KoJsonTrader.h>
 #include <KisMimeDatabase.h>
 #include <kis_config_widget.h>
 #include <kis_debug.h>
 #include <KisMimeDatabase.h>
 #include <KisPreExportChecker.h>
 #include <KisPart.h>
 #include "kis_config.h"
 #include "KisImportExportFilter.h"
 #include "KisDocument.h"
 #include <kis_image.h>
 #include <kis_paint_layer.h>
 #include "kis_guides_config.h"
 #include "kis_grid_config.h"
 #include "kis_popup_button.h"
 #include <kis_iterator_ng.h>
 
 // static cache for import and export mimetypes
 QStringList KisImportExportManager::m_importMimeTypes;
 QStringList KisImportExportManager::m_exportMimeTypes;
 
 class Q_DECL_HIDDEN KisImportExportManager::Private
 {
 public:
     bool batchMode {false};
     QPointer<KoProgressUpdater> progressUpdater {0};
 };
 
 KisImportExportManager::KisImportExportManager(KisDocument* document)
     : m_document(document)
     , d(new Private)
 {
 }
 
 KisImportExportManager::~KisImportExportManager()
 {
     delete d;
 }
 
 KisImportExportFilter::ConversionStatus KisImportExportManager::importDocument(const QString& location, const QString& mimeType)
 {
     return convert(Import, location, location, mimeType, false, 0);
 }
 
 KisImportExportFilter::ConversionStatus KisImportExportManager::exportDocument(const QString& location, const QString& realLocation, QByteArray& mimeType, bool showWarnings, KisPropertiesConfigurationSP exportConfiguration)
 {
     return convert(Export, location, realLocation, mimeType, showWarnings, exportConfiguration);
 }
 
 // The static method to figure out to which parts of the
 // graph this mimetype has a connection to.
 QStringList KisImportExportManager::mimeFilter(Direction direction)
 {
     // Find the right mimetype by the extension
     QSet<QString> mimeTypes;
     //    mimeTypes << KisDocument::nativeFormatMimeType() << "application/x-krita-paintoppreset" << "image/openraster";
 
     if (direction == KisImportExportManager::Import) {
         if (m_importMimeTypes.isEmpty()) {
             KoJsonTrader trader;
             QList<QPluginLoader *>list = trader.query("Krita/FileFilter", "");
             Q_FOREACH(QPluginLoader *loader, list) {
                 QJsonObject json = loader->metaData().value("MetaData").toObject();
                 Q_FOREACH(const QString &mimetype, json.value("X-KDE-Import").toString().split(",", QString::SkipEmptyParts)) {
                     //qDebug() << "Adding  import mimetype" << mimetype << KisMimeDatabase::descriptionForMimeType(mimetype) << "from plugin" << loader;
                     mimeTypes << mimetype;
                 }
             }
             qDeleteAll(list);
             m_importMimeTypes = mimeTypes.toList();
         }
         return m_importMimeTypes;
     }
     else if (direction == KisImportExportManager::Export) {
         if (m_exportMimeTypes.isEmpty()) {
             KoJsonTrader trader;
             QList<QPluginLoader *>list = trader.query("Krita/FileFilter", "");
             Q_FOREACH(QPluginLoader *loader, list) {
                 QJsonObject json = loader->metaData().value("MetaData").toObject();
                 Q_FOREACH(const QString &mimetype, json.value("X-KDE-Export").toString().split(",", QString::SkipEmptyParts)) {
                     //qDebug() << "Adding  export mimetype" << mimetype << KisMimeDatabase::descriptionForMimeType(mimetype) << "from plugin" << loader;
                     mimeTypes << mimetype;
                 }
             }
             qDeleteAll(list);
             m_exportMimeTypes = mimeTypes.toList();
         }
         return m_exportMimeTypes;
     }
     return QStringList();
 }
 
 KisImportExportFilter *KisImportExportManager::filterForMimeType(const QString &mimetype, KisImportExportManager::Direction direction)
 {
     int weight = -1;
     KisImportExportFilter *filter = 0;
     KoJsonTrader trader;
     QList<QPluginLoader *>list = trader.query("Krita/FileFilter", "");
     Q_FOREACH(QPluginLoader *loader, list) {
         QJsonObject json = loader->metaData().value("MetaData").toObject();
         QString directionKey = direction == Export ? "X-KDE-Export" : "X-KDE-Import";
         if (json.value(directionKey).toString().split(",", QString::SkipEmptyParts).contains(mimetype)) {
             KLibFactory *factory = qobject_cast<KLibFactory *>(loader->instance());
 
             if (!factory) {
                 warnUI << loader->errorString();
                 continue;
             }
 
             QObject* obj = factory->create<KisImportExportFilter>(0);
             if (!obj || !obj->inherits("KisImportExportFilter")) {
                 delete obj;
                 continue;
             }
 
             KisImportExportFilter *f = qobject_cast<KisImportExportFilter*>(obj);
             if (!f) {
                 delete obj;
                 continue;
             }
 
             int w = json.value("X-KDE-Weight").toInt();
             if (w > weight) {
                 delete filter;
                 filter = f;
                 f->setObjectName(loader->fileName());
                 weight = w;
             }
         }
     }
     qDeleteAll(list);
     if (filter) {
         filter->setMimeType(mimetype);
     }
     return filter;
 }
 
 void KisImportExportManager::setBatchMode(const bool batch)
 {
     d->batchMode = batch;
 }
 
 bool KisImportExportManager::batchMode(void) const
 {
     return d->batchMode;
 }
 
 void KisImportExportManager::setProgresUpdater(KoProgressUpdater *updater)
 {
     d->progressUpdater = updater;
 }
 
 QString KisImportExportManager::askForAudioFileName(const QString &defaultDir, QWidget *parent)
 {
     KoFileDialog dialog(parent, KoFileDialog::ImportFiles, "ImportAudio");
 
     if (!defaultDir.isEmpty()) {
         dialog.setDefaultDir(defaultDir);
     }
 
     QStringList mimeTypes;
     mimeTypes << "audio/mpeg";
     mimeTypes << "audio/ogg";
     mimeTypes << "audio/vorbis";
     mimeTypes << "audio/vnd.wave";
     mimeTypes << "audio/flac";
 
     dialog.setMimeTypeFilters(mimeTypes);
     dialog.setCaption(i18nc("@titile:window", "Open Audio"));
 
     return dialog.filename();
 }
 
 KisImportExportFilter::ConversionStatus KisImportExportManager::convert(KisImportExportManager::Direction direction, const QString &location, const QString& realLocation, const QString &mimeType, bool showWarnings, KisPropertiesConfigurationSP exportConfiguration)
 {
 
     QString typeName = mimeType;
     if (typeName.isEmpty()) {
         typeName = KisMimeDatabase::mimeTypeForFile(location);
     }
 
     QSharedPointer<KisImportExportFilter> filter(filterForMimeType(typeName, direction));
     if (!filter) {
         return KisImportExportFilter::FilterCreationError;
     }
 
     filter->setFilename(location);
     filter->setRealFilename(realLocation);
     filter->setBatchMode(batchMode());
     filter->setMimeType(typeName);
 
     if (d->progressUpdater) {
         filter->setUpdater(d->progressUpdater->startSubtask());
     }
 
     QByteArray from, to;
     if (direction == Export) {
         from = m_document->nativeFormatMimeType();
         to = mimeType.toLatin1();
     }
     else {
         from = mimeType.toLatin1();
         to = m_document->nativeFormatMimeType();
     }
 
     if (!exportConfiguration) {
         exportConfiguration = filter->lastSavedConfiguration(from, to);
         if (exportConfiguration) {
             // Fill with some meta information about the image
             KisImageWSP image = m_document->image();
             KisPaintDeviceSP pd = image->projection();
 
             bool isThereAlpha = false;
             KisSequentialConstIterator it(pd, image->bounds());
             const KoColorSpace* cs = pd->colorSpace();
             do {
                 if (cs->opacityU8(it.oldRawData()) != OPACITY_OPAQUE_U8) {
                     isThereAlpha = true;
                     break;
                 }
             } while (it.nextPixel());
 
             exportConfiguration->setProperty("ImageContainsTransparency", isThereAlpha);
             exportConfiguration->setProperty("ColorModelID", cs->colorModelId().id());
             exportConfiguration->setProperty("ColorDepthID", cs->colorDepthId().id());
             bool sRGB = (cs->profile()->name().contains(QLatin1String("srgb"), Qt::CaseInsensitive) && !cs->profile()->name().contains(QLatin1String("g10")));
             exportConfiguration->setProperty("sRGB", sRGB);
         }
 
     }
 
     KisPreExportChecker checker;
     if (direction == Export) {
         checker.check(m_document->image(), filter->exportChecks());
     }
 
     KisConfigWidget *wdg = filter->createConfigurationWidget(0, from, to);
     bool alsoAsKra = false;
 
     QStringList warnings = checker.warnings();
     QStringList errors = checker.errors();
 
     // Extra checks that cannot be done by the checker, because the checker only has access to the image.
     if (!m_document->assistants().isEmpty() && typeName != m_document->nativeFormatMimeType()) {
         warnings.append(i18nc("image conversion warning", "The image contains <b>assistants</b>. The assistants will not be saved."));
     }
     if (m_document->guidesConfig().hasGuides() && typeName != m_document->nativeFormatMimeType()) {
         warnings.append(i18nc("image conversion warning", "The image contains <b>guides</b>. The guides will not be saved."));
     }
     if (!m_document->gridConfig().isDefault() && typeName != m_document->nativeFormatMimeType()) {
         warnings.append(i18nc("image conversion warning", "The image contains a <b>custom grid configuration</b>. The configuration will not be saved."));
     }
 
     if (!batchMode() && !errors.isEmpty()) {
         QString error =  "<html><body><p><b>"
                 + i18n("Error: cannot save this image as a %1.", KisMimeDatabase::descriptionForMimeType(typeName))
                 + "</b> Reasons:</p>"
                 + "<p/><ul>";
         Q_FOREACH(const QString &w, errors) {
             error += "\n<li>" + w + "</li>";
         }
 
         error += "</ul>";
 
         QMessageBox::critical(KisPart::instance()->currentMainwindow(), i18nc("@title:window", "Krita: Export Error"), error);
         return KisImportExportFilter::UserCancelled;
     }
 
     if (!batchMode() && (wdg || !warnings.isEmpty())) {
 
         KoDialog dlg;
 
         dlg.setButtons(KoDialog::Ok | KoDialog::Cancel);
         dlg.setWindowTitle(KisMimeDatabase::descriptionForMimeType(mimeType));
 
         QWidget *page = new QWidget(&dlg);
         QVBoxLayout *layout = new QVBoxLayout(page);
 
         if (!checker.warnings().isEmpty()) {
 
             if (showWarnings) {
 
                 QHBoxLayout *hLayout = new QHBoxLayout();
 
                 QLabel *labelWarning = new QLabel();
                 labelWarning->setPixmap(KisIconUtils::loadIcon("dialog-warning").pixmap(32, 32));
                 hLayout->addWidget(labelWarning);
 
                 KisPopupButton *bn = new KisPopupButton(0);
 
                 bn->setText(i18nc("Keep the extra space at the end of the sentence, please", "Warning: saving as %1 will lose information from your image.    ", KisMimeDatabase::descriptionForMimeType(mimeType)));
 
 
                 hLayout->addWidget(bn);
 
                 layout->addLayout(hLayout);
 
                 QTextBrowser *browser = new QTextBrowser();
                 browser->setMinimumWidth(bn->width());
                 bn->setPopupWidget(browser);
 
                 QString warning = "<html><body><p><b>"
                         + i18n("You will lose information when saving this image as a %1.", KisMimeDatabase::descriptionForMimeType(typeName));
 
                 if (warnings.size() == 1) {
                     warning += "</b> Reason:</p>";
                 }
                 else {
                     warning += "</b> Reasons:</p>";
                 }
                 warning += "<p/><ul>";
 
                 Q_FOREACH(const QString &w, warnings) {
                     warning += "\n<li>" + w + "</li>";
                 }
 
                 warning += "</ul>";
                 browser->setHtml(warning);
             }
         }
 
         if (wdg) {
             QGroupBox *box = new QGroupBox(i18n("Options"));
             QVBoxLayout *boxLayout = new QVBoxLayout(box);
             wdg->setConfiguration(exportConfiguration);
             boxLayout->addWidget(wdg);
             layout->addWidget(box);
         }
 
 
         QCheckBox *chkAlsoAsKra = 0;
         if (showWarnings) {
             if (!checker.warnings().isEmpty()) {
                 chkAlsoAsKra = new QCheckBox(i18n("Also save your image as a Krita file."));
                 chkAlsoAsKra->setChecked(KisConfig().readEntry<bool>("AlsoSaveAsKra", false));
                 layout->addWidget(chkAlsoAsKra);
             }
         }
 
         dlg.setMainWidget(page);
         dlg.resize(dlg.minimumSize());
 
         if (showWarnings || wdg) {
             if (!dlg.exec()) {
                 return KisImportExportFilter::UserCancelled;
             }
         }
 
         if (chkAlsoAsKra) {
             KisConfig().writeEntry<bool>("AlsoSaveAsKra", chkAlsoAsKra->isChecked());
             alsoAsKra = chkAlsoAsKra->isChecked();
         }
 
         if (wdg) {
             exportConfiguration = wdg->configuration();
         }
 
     }
 
     QFile io(location);
+    QSaveFile out(location);
 
     if (direction == Import) {
         if (!io.exists()) {
             return KisImportExportFilter::FileNotFound;
         }
 
-        if (!io.open(QFile::ReadOnly)) {
+        if (!io.open(QFile::ReadOnly) ) {
             return KisImportExportFilter::FileNotFound;
         }
     }
     else if (direction == Export) {
-        if (!io.open(QFile::WriteOnly)) {
-            return KisImportExportFilter::CreationError;
+        if (filter->supportsIO()) {
+            out.setDirectWriteFallback(true);
+            if (!out.open(QFile::WriteOnly)) {
+                out.cancelWriting();
+                return KisImportExportFilter::CreationError;
+            }
         }
     }
     else {
         return KisImportExportFilter::BadConversionGraph;
     }
 
     if (!batchMode()) {
         QApplication::setOverrideCursor(Qt::WaitCursor);
     }
 
-    KisImportExportFilter::ConversionStatus status = filter->convert(m_document, &io, exportConfiguration);
-    io.close();
+    KisImportExportFilter::ConversionStatus status;
+    if (direction == Import || !filter->supportsIO()) {
+         status = filter->convert(m_document, &io, exportConfiguration);
+         if (io.isOpen()) io.close();
+    }
+    else {
+        status = filter->convert(m_document, &out, exportConfiguration);
+        if (status != KisImportExportFilter::OK) {
+            out.cancelWriting();
+        }
+        else {
+            out.commit();
+        }
+    }
 
     if (exportConfiguration) {
         KisConfig().setExportConfiguration(typeName, exportConfiguration);
     }
 
     if (alsoAsKra) {
         QString l = location + ".kra";
         QByteArray ba = m_document->nativeFormatMimeType();
         KisImportExportFilter *filter = filterForMimeType(QString::fromLatin1(ba), Export);
-        QFile f(l);
+        QSaveFile f(l);
         f.open(QIODevice::WriteOnly);
         if (filter) {
             filter->setFilename(l);
-            filter->convert(m_document, &f);
+            if (filter->convert(m_document, &f) == KisImportExportFilter::OK) {
+                f.commit();
+            }
+            else {
+                f.cancelWriting();
+            }
         }
-        f.close();
         delete filter;
 
     }
 
     if (!batchMode()) {
         QApplication::restoreOverrideCursor();
     }
 
     return status;
 
 }
 
 
 #include <KisMimeDatabase.h>
diff --git a/libs/ui/KisMainWindow.cpp b/libs/ui/KisMainWindow.cpp
index b2ff17e89d..6e39cf477d 100644
--- a/libs/ui/KisMainWindow.cpp
+++ b/libs/ui/KisMainWindow.cpp
@@ -1,2404 +1,2404 @@
 /* This file is part of the KDE project
    Copyright (C) 1998, 1999 Torben Weis <weis@kde.org>
    Copyright (C) 2000-2006 David Faure <faure@kde.org>
    Copyright (C) 2007, 2009 Thomas zander <zander@kde.org>
    Copyright (C) 2010 Benjamin Port <port.benjamin@gmail.com>
 
    This library is free software; you can redistribute it and/or
    modify it under the terms of the GNU Library General Public
    License as published by the Free Software Foundation; either
    version 2 of the License, or (at your option) any later version.
 
    This library is distributed in the hope that it will be useful,
    but WITHOUT ANY WARRANTY; without even the implied warranty of
    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
    Library General Public License for more details.
 
    You should have received a copy of the GNU Library General Public License
    along with this library; see the file COPYING.LIB.  If not, write to
    the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
  * Boston, MA 02110-1301, USA.
 */
 
 #include "KisMainWindow.h"
 
 #include <KoConfig.h>
 
 // qt includes
 #include <QApplication>
 #include <QByteArray>
 #include <QCloseEvent>
 #include <QDesktopServices>
 #include <QDesktopWidget>
 #include <QDockWidget>
 #include <QIcon>
 #include <QLabel>
 #include <QLayout>
 #include <QMdiArea>
 #include <QMdiSubWindow>
 #include <QMutex>
 #include <QMutexLocker>
 #include <QPointer>
 #include <QPrintDialog>
 #include <QPrinter>
 #include <QPrintPreviewDialog>
 #include <QProgressBar>
 #include <QToolButton>
 #include <QSignalMapper>
 #include <QTabBar>
 #include <QMoveEvent>
 #include <QUrl>
 #include <QMessageBox>
 #include <QTemporaryFile>
 #include <QStatusBar>
 #include <QMenu>
 #include <QMenuBar>
 #include <KisMimeDatabase.h>
 #include <QMimeData>
 
 #include <kactioncollection.h>
 #include <QAction>
 #include <kactionmenu.h>
 #include <kis_debug.h>
 #include <kedittoolbar.h>
 #include <khelpmenu.h>
 #include <klocalizedstring.h>
 #include <kaboutdata.h>
 
 #ifdef HAVE_KIO
 #include <krecentdocument.h>
 #endif
 #include <krecentfilesaction.h>
 #include <KoResourcePaths.h>
 #include <ktoggleaction.h>
 #include <ktoolbar.h>
 #include <kmainwindow.h>
 #include <kxmlguiwindow.h>
 #include <kxmlguifactory.h>
 #include <kxmlguiclient.h>
 #include <kguiitem.h>
 #include <kwindowconfig.h>
 
 #include "KoDockFactoryBase.h"
 #include "KoDockWidgetTitleBar.h"
 #include "KoDocumentInfoDlg.h"
 #include "KoDocumentInfo.h"
 #include "KoFileDialog.h"
 #include <kis_icon.h>
 #include <KoPageLayoutDialog.h>
 #include <KoPageLayoutWidget.h>
 #include <KoToolManager.h>
 #include <KoZoomController.h>
 #include "KoToolDocker.h"
 #include <KoToolBoxFactory.h>
 #include <KoDockRegistry.h>
 #include <KoPluginLoader.h>
 #include <KoColorSpaceEngine.h>
 
 #include <KisMimeDatabase.h>
 #include <brushengine/kis_paintop_settings.h>
 #include "dialogs/kis_about_application.h"
 #include "dialogs/kis_delayed_save_dialog.h"
 #include "dialogs/kis_dlg_preferences.h"
 #include "kis_action.h"
 #include "kis_action_manager.h"
 #include "KisApplication.h"
 #include "kis_canvas2.h"
 #include "kis_canvas_controller.h"
 #include "kis_canvas_resource_provider.h"
 #include "kis_clipboard.h"
 #include "kis_config.h"
 #include "kis_config_notifier.h"
 #include "kis_custom_image_widget.h"
 #include <KisDocument.h>
 #include "KisDocument.h"
 #include "KisDocument.h"
 #include "kis_group_layer.h"
 #include "kis_icon_utils.h"
 #include "kis_image_from_clipboard_widget.h"
 #include "kis_image.h"
 #include <KisImportExportFilter.h>
 #include "KisImportExportManager.h"
 #include "kis_mainwindow_observer.h"
 #include "kis_node.h"
 #include "KisOpenPane.h"
 #include "kis_paintop_box.h"
 #include "KisPart.h"
 #include "KisPrintJob.h"
 #include "kis_resource_server_provider.h"
 #include "kis_signal_compressor_with_param.h"
 #include "KisView.h"
 #include "KisViewManager.h"
 #include "thememanager.h"
 #include "kis_animation_importer.h"
 #include "dialogs/kis_dlg_import_image_sequence.h"
 #include "kis_animation_exporter.h"
 
 #include <mutex>
 
 #ifdef Q_OS_WIN
   #include <QtPlatformHeaders/QWindowsWindowFunctions>
 #endif
 
 class ToolDockerFactory : public KoDockFactoryBase
 {
 public:
     ToolDockerFactory() : KoDockFactoryBase() { }
 
     QString id() const override {
         return "sharedtooldocker";
     }
 
     QDockWidget* createDockWidget() override {
         KoToolDocker* dockWidget = new KoToolDocker();
         dockWidget->setTabEnabled(false);
         return dockWidget;
     }
 
     DockPosition defaultDockPosition() const override {
         return DockRight;
     }
 };
 
 class Q_DECL_HIDDEN KisMainWindow::Private
 {
 public:
     Private(KisMainWindow *parent)
         : q(parent)
         , dockWidgetMenu(new KActionMenu(i18nc("@action:inmenu", "&Dockers"), parent))
         , windowMenu(new KActionMenu(i18nc("@action:inmenu", "&Window"), parent))
         , documentMenu(new KActionMenu(i18nc("@action:inmenu", "New &View"), parent))
         , mdiArea(new QMdiArea(parent))
         , windowMapper(new QSignalMapper(parent))
         , documentMapper(new QSignalMapper(parent))
     {
     }
 
     ~Private() {
         qDeleteAll(toolbarList);
     }
 
     KisMainWindow *q {0};
     KisViewManager *viewManager {0};
 
     QPointer<KisView> activeView;
 
     QPointer<QProgressBar> progress;
     QPointer<QToolButton> progressCancel;
     QMutex progressMutex;
 
     QList<QAction *> toolbarList;
 
     bool firstTime {true};
     bool windowSizeDirty {false};
     bool readOnly {false};
     bool isImporting {false};
     bool isExporting {false};
     bool noCleanup {false};
 
     KisAction *showDocumentInfo {0};
     KisAction *saveAction {0};
     KisAction *saveActionAs {0};
 //    KisAction *printAction;
 //    KisAction *printActionPreview;
 //    KisAction *exportPdf {0};
     KisAction *importAnimation {0};
     KisAction *closeAll {0};
 //    KisAction *reloadFile;
     KisAction *importFile {0};
     KisAction *exportFile {0};
     KisAction *undo {0};
     KisAction *redo {0};
     KisAction *newWindow {0};
     KisAction *close {0};
     KisAction *mdiCascade {0};
     KisAction *mdiTile {0};
     KisAction *mdiNextWindow {0};
     KisAction *mdiPreviousWindow {0};
     KisAction *toggleDockers {0};
     KisAction *toggleDockerTitleBars {0};
 
     KisAction *expandingSpacers[2];
 
     KActionMenu *dockWidgetMenu;
     KActionMenu *windowMenu;
     KActionMenu *documentMenu;
 
     KHelpMenu *helpMenu  {0};
 
     KRecentFilesAction *recentFiles {0};
 
     QUrl lastExportUrl;
 
     QMap<QString, QDockWidget *> dockWidgetsMap;
     QMap<QDockWidget *, bool> dockWidgetVisibilityMap;
     QByteArray dockerStateBeforeHiding;
     KoToolDocker *toolOptionsDocker {0};
 
     QCloseEvent *deferredClosingEvent {0};
 
     Digikam::ThemeManager *themeManager {0};
 
     QMdiArea *mdiArea;
     QMdiSubWindow *activeSubWindow  {0};
     QSignalMapper *windowMapper;
     QSignalMapper *documentMapper;
 
     QByteArray lastExportedFormat;
     QScopedPointer<KisSignalCompressorWithParam<int> > tabSwitchCompressor;
     QMutex savingEntryMutex;
 
     KisActionManager * actionManager() {
         return viewManager->actionManager();
     }
 
     QTabBar* findTabBarHACK() {
         QObjectList objects = mdiArea->children();
         Q_FOREACH (QObject *object, objects) {
             QTabBar *bar = qobject_cast<QTabBar*>(object);
             if (bar) {
                 return bar;
             }
         }
         return 0;
     }
 };
 
 KisMainWindow::KisMainWindow()
     : KXmlGuiWindow()
     , d(new Private(this))
 {
     KisConfig cfg;
 
     d->viewManager = new KisViewManager(this, actionCollection());
     KConfigGroup group( KSharedConfig::openConfig(), "theme");
     d->themeManager = new Digikam::ThemeManager(group.readEntry("Theme", "Krita dark"), this);
 
     setAcceptDrops(true);
     setStandardToolBarMenuEnabled(true);
     setTabPosition(Qt::AllDockWidgetAreas, QTabWidget::North);
     setDockNestingEnabled(true);
 
     qApp->setStartDragDistance(25);     // 25 px is a distance that works well for Tablet and Mouse events
 
 #ifdef Q_OS_OSX
     setUnifiedTitleAndToolBarOnMac(true);
 #endif
 
     connect(this, SIGNAL(restoringDone()), this, SLOT(forceDockTabFonts()));
     connect(this, SIGNAL(themeChanged()), d->viewManager, SLOT(updateIcons()));
     connect(KisPart::instance(), SIGNAL(documentClosed(QString)), SLOT(updateWindowMenu()));
     connect(KisPart::instance(), SIGNAL(documentOpened(QString)), SLOT(updateWindowMenu()));
     connect(KisConfigNotifier::instance(), SIGNAL(configChanged()), this, SLOT(configChanged()));
 
     actionCollection()->addAssociatedWidget(this);
 
     KoPluginLoader::instance()->load("Krita/ViewPlugin", "Type == 'Service' and ([X-Krita-Version] == 28)", KoPluginLoader::PluginsConfig(), d->viewManager);
 
     KoToolBoxFactory toolBoxFactory;
     QDockWidget *toolbox = createDockWidget(&toolBoxFactory);
     toolbox->setFeatures(QDockWidget::DockWidgetMovable | QDockWidget::DockWidgetFloatable | QDockWidget::DockWidgetClosable);
 
     if (cfg.toolOptionsInDocker()) {
         ToolDockerFactory toolDockerFactory;
         d->toolOptionsDocker = qobject_cast<KoToolDocker*>(createDockWidget(&toolDockerFactory));
         d->toolOptionsDocker->toggleViewAction()->setEnabled(true);
     }
 
     QMap<QString, QAction*> dockwidgetActions;
     dockwidgetActions[toolbox->toggleViewAction()->text()] = toolbox->toggleViewAction();
     Q_FOREACH (const QString & docker, KoDockRegistry::instance()->keys()) {
         KoDockFactoryBase *factory = KoDockRegistry::instance()->value(docker);
         QDockWidget *dw = createDockWidget(factory);
         dockwidgetActions[dw->toggleViewAction()->text()] = dw->toggleViewAction();
     }
 
     if (d->toolOptionsDocker) {
         dockwidgetActions[d->toolOptionsDocker->toggleViewAction()->text()] = d->toolOptionsDocker->toggleViewAction();
     }
     connect(KoToolManager::instance(), SIGNAL(toolOptionWidgetsChanged(KoCanvasController*, QList<QPointer<QWidget> >)), this, SLOT(newOptionWidgets(KoCanvasController*, QList<QPointer<QWidget> >)));
 
     Q_FOREACH (QString title, dockwidgetActions.keys()) {
         d->dockWidgetMenu->addAction(dockwidgetActions[title]);
     }
 
 
     Q_FOREACH (QDockWidget *wdg, dockWidgets()) {
         if ((wdg->features() & QDockWidget::DockWidgetClosable) == 0) {
             wdg->setVisible(true);
         }
     }
 
     Q_FOREACH (KoCanvasObserverBase* observer, canvasObservers()) {
         observer->setObservedCanvas(0);
         KisMainwindowObserver* mainwindowObserver = dynamic_cast<KisMainwindowObserver*>(observer);
         if (mainwindowObserver) {
             mainwindowObserver->setMainWindow(d->viewManager);
         }
     }
 
     d->mdiArea->setHorizontalScrollBarPolicy(Qt::ScrollBarAsNeeded);
     d->mdiArea->setVerticalScrollBarPolicy(Qt::ScrollBarAsNeeded);
     d->mdiArea->setTabPosition(QTabWidget::North);
     d->mdiArea->setTabsClosable(true);
 
     setCentralWidget(d->mdiArea);
 
     connect(d->mdiArea, SIGNAL(subWindowActivated(QMdiSubWindow*)), this, SLOT(subWindowActivated()));
     connect(d->windowMapper, SIGNAL(mapped(QWidget*)), this, SLOT(setActiveSubWindow(QWidget*)));
     connect(d->documentMapper, SIGNAL(mapped(QObject*)), this, SLOT(newView(QObject*)));
 
     createActions();
 
     setAutoSaveSettings("krita", false);
 
 
     subWindowActivated();
     updateWindowMenu();
 
 
     if (isHelpMenuEnabled() && !d->helpMenu) {
         // workaround for KHelpMenu (or rather KAboutData::applicationData()) internally
         // not using the Q*Application metadata ATM, which results e.g. in the bugreport wizard
         // not having the app version preset
         // fixed hopefully in KF5 5.22.0, patch pending
         QGuiApplication *app = qApp;
         KAboutData aboutData(app->applicationName(), app->applicationDisplayName(), app->applicationVersion());
         aboutData.setOrganizationDomain(app->organizationDomain().toUtf8());
         d->helpMenu = new KHelpMenu(this, aboutData, false);
         // workaround-less version:
         // d->helpMenu = new KHelpMenu(this, QString()/*unused*/, false);
 
         // The difference between using KActionCollection->addAction() is that
         // these actions do not get tied to the MainWindow.  What does this all do?
         KActionCollection *actions = d->viewManager->actionCollection();
         QAction *helpContentsAction = d->helpMenu->action(KHelpMenu::menuHelpContents);
         QAction *whatsThisAction = d->helpMenu->action(KHelpMenu::menuWhatsThis);
         QAction *reportBugAction = d->helpMenu->action(KHelpMenu::menuReportBug);
         QAction *switchLanguageAction = d->helpMenu->action(KHelpMenu::menuSwitchLanguage);
         QAction *aboutAppAction = d->helpMenu->action(KHelpMenu::menuAboutApp);
         QAction *aboutKdeAction = d->helpMenu->action(KHelpMenu::menuAboutKDE);
 
         if (helpContentsAction) {
             actions->addAction(helpContentsAction->objectName(), helpContentsAction);
         }
         if (whatsThisAction) {
             actions->addAction(whatsThisAction->objectName(), whatsThisAction);
         }
         if (reportBugAction) {
             actions->addAction(reportBugAction->objectName(), reportBugAction);
         }
         if (switchLanguageAction) {
             actions->addAction(switchLanguageAction->objectName(), switchLanguageAction);
         }
         if (aboutAppAction) {
             actions->addAction(aboutAppAction->objectName(), aboutAppAction);
         }
         if (aboutKdeAction) {
             actions->addAction(aboutKdeAction->objectName(), aboutKdeAction);
         }
 
         connect(d->helpMenu, SIGNAL(showAboutApplication()), SLOT(showAboutApplication()));
     }
 
     // KDE' libs 4''s help contents action is broken outside kde, for some reason... We can handle it just as easily ourselves
     QAction *helpAction = actionCollection()->action("help_contents");
     helpAction->disconnect();
     connect(helpAction, SIGNAL(triggered()), this, SLOT(showManual()));
 
 
 #if 0
     //check for colliding shortcuts
     QSet<QKeySequence> existingShortcuts;
     Q_FOREACH (QAction* action, actionCollection()->actions()) {
         if(action->shortcut() == QKeySequence(0)) {
             continue;
         }
         dbgKrita << "shortcut " << action->text() << " " << action->shortcut();
         Q_ASSERT(!existingShortcuts.contains(action->shortcut()));
         existingShortcuts.insert(action->shortcut());
     }
 #endif
 
     configChanged();
 
     // If we have customized the toolbars, load that first
     setLocalXMLFile(KoResourcePaths::locateLocal("data", "krita.xmlgui"));
     setXMLFile(":/kxmlgui5/krita.xmlgui");
 
     guiFactory()->addClient(this);
 
     // Create and plug toolbar list for Settings menu
     QList<QAction *> toolbarList;
     Q_FOREACH (QWidget* it, guiFactory()->containers("ToolBar")) {
         KToolBar * toolBar = ::qobject_cast<KToolBar *>(it);
 
         if (toolBar) {
             if (toolBar->objectName() == "BrushesAndStuff") {
                 toolBar->setEnabled(false);
             }
 
             KToggleAction* act = new KToggleAction(i18n("Show %1 Toolbar", toolBar->windowTitle()), this);
             actionCollection()->addAction(toolBar->objectName().toUtf8(), act);
             act->setCheckedState(KGuiItem(i18n("Hide %1 Toolbar", toolBar->windowTitle())));
             connect(act, SIGNAL(toggled(bool)), this, SLOT(slotToolbarToggled(bool)));
             act->setChecked(!toolBar->isHidden());
             toolbarList.append(act);
         } else
             warnUI << "Toolbar list contains a " << it->metaObject()->className() << " which is not a toolbar!";
     }
     plugActionList("toolbarlist", toolbarList);
     setToolbarList(toolbarList);
 
     applyToolBarLayout();
 
     d->viewManager->updateGUI();
     d->viewManager->updateIcons();
 
 #ifdef Q_OS_WIN
     auto w = qApp->activeWindow();
     if (w) QWindowsWindowFunctions::setHasBorderInFullScreen(w->windowHandle(), true);
 #endif
 
     QTimer::singleShot(1000, this, SLOT(checkSanity()));
 
     {
         using namespace std::placeholders; // For _1 placeholder
         std::function<void (int)> callback(
             std::bind(&KisMainWindow::switchTab, this, _1));
 
         d->tabSwitchCompressor.reset(
             new KisSignalCompressorWithParam<int>(500, callback, KisSignalCompressor::FIRST_INACTIVE));
     }
 
 
 
 }
 
 void KisMainWindow::setNoCleanup(bool noCleanup)
 {
     d->noCleanup = noCleanup;
 }
 
 KisMainWindow::~KisMainWindow()
 {
 //    Q_FOREACH (QAction *ac, actionCollection()->actions()) {
 //        QAction *action = qobject_cast<QAction*>(ac);
 //        if (action) {
 //        dbgKrita << "<Action"
 //                 << "name=" << action->objectName()
 //                 << "icon=" << action->icon().name()
 //                 << "text="  << action->text().replace("&", "&amp;")
 //                 << "whatsThis="  << action->whatsThis()
 //                 << "toolTip="  << action->toolTip().replace("<html>", "").replace("</html>", "")
 //                 << "iconText="  << action->iconText().replace("&", "&amp;")
 //                 << "shortcut="  << action->shortcut(QAction::ActiveShortcut).toString()
 //                 << "defaultShortcut="  << action->shortcut(QAction::DefaultShortcut).toString()
 //                 << "isCheckable="  << QString((action->isChecked() ? "true" : "false"))
 //                 << "statusTip=" << action->statusTip()
 //                 << "/>"   ;
 //        }
 //        else {
 //            dbgKrita << "Got a QAction:" << ac->objectName();
 //        }
 
 //    }
 
     // The doc and view might still exist (this is the case when closing the window)
     KisPart::instance()->removeMainWindow(this);
 
     if (d->noCleanup)
         return;
 
     delete d->viewManager;
     delete d;
 
 }
 
 void KisMainWindow::addView(KisView *view)
 {
     if (d->activeView == view) return;
 
     if (d->activeView) {
         d->activeView->disconnect(this);
     }
 
     showView(view);
     updateCaption();
     emit restoringDone();
 
     if (d->activeView) {
         connect(d->activeView, SIGNAL(titleModified(QString,bool)), SLOT(slotDocumentTitleModified(QString,bool)));
     }
 }
 
 void KisMainWindow::showView(KisView *imageView)
 {
     if (imageView && activeView() != imageView ) {
         // XXX: find a better way to initialize this!
         imageView->setViewManager(d->viewManager);
 
         imageView->canvasBase()->setFavoriteResourceManager(d->viewManager->paintOpBox()->favoriteResourcesManager());
         imageView->slotLoadingFinished();
 
         QMdiSubWindow *subwin = d->mdiArea->addSubWindow(imageView);
         subwin->setAttribute(Qt::WA_DeleteOnClose, true);
         connect(subwin, SIGNAL(destroyed()), SLOT(updateWindowMenu()));
 
         KisConfig cfg;
         subwin->setOption(QMdiSubWindow::RubberBandMove, cfg.readEntry<int>("mdi_rubberband", cfg.useOpenGL()));
         subwin->setOption(QMdiSubWindow::RubberBandResize, cfg.readEntry<int>("mdi_rubberband", cfg.useOpenGL()));
         subwin->setWindowIcon(qApp->windowIcon());
 
         /**
          * Hack alert!
          *
          * Here we explicitly request KoToolManager to emit all the tool
          * activation signals, to reinitialize the tool options docker.
          *
          * That is needed due to a design flaw we have in the
          * initialization procedure.  The tool in the KoToolManager is
          * initialized in KisView::setViewManager() calls, which
          * happens early enough. During this call the tool manager
          * requests KoCanvasControllerWidget to emit the signal to
          * update the widgets in the tool docker. *But* at that moment
          * of time the view is not yet connected to the main window,
          * because it happens in KisViewManager::setCurrentView a bit
          * later. This fact makes the widgets updating signals be lost
          * and never reach the tool docker.
          *
          * So here we just explicitly call the tool activation stub.
          */
 
         KoToolManager::instance()->initializeCurrentToolForCanvas();
 
         if (d->mdiArea->subWindowList().size() == 1) {
             imageView->showMaximized();
         }
         else {
             imageView->show();
         }
 
         // No, no, no: do not try to call this _before_ the show() has
         // been called on the view; only when that has happened is the
         // opengl context active, and very bad things happen if we tell
         // the dockers to update themselves with a view if the opengl
         // context is not active.
         setActiveView(imageView);
 
         updateWindowMenu();
         updateCaption();
     }
 }
 
 void KisMainWindow::slotPreferences()
 {
     if (KisDlgPreferences::editPreferences()) {
         KisConfigNotifier::instance()->notifyConfigChanged();
 
         // XXX: should this be changed for the views in other windows as well?
         Q_FOREACH (QPointer<KisView> koview, KisPart::instance()->views()) {
             KisViewManager *view = qobject_cast<KisViewManager*>(koview);
             if (view) {
                 // Update the settings for all nodes -- they don't query
                 // KisConfig directly because they need the settings during
                 // compositing, and they don't connect to the config notifier
                 // because nodes are not QObjects (because only one base class
                 // can be a QObject).
                 KisNode* node = dynamic_cast<KisNode*>(view->image()->rootLayer().data());
                 node->updateSettings();
             }
 
         }
 
         d->viewManager->showHideScrollbars();
     }
 }
 
 void KisMainWindow::slotThemeChanged()
 {
     // save theme changes instantly
     KConfigGroup group( KSharedConfig::openConfig(), "theme");
     group.writeEntry("Theme", d->themeManager->currentThemeName());
 
     // reload action icons!
     Q_FOREACH (QAction *action, actionCollection()->actions()) {
         KisIconUtils::updateIcon(action);
     }
 
     emit themeChanged();
 }
 
 void KisMainWindow::updateReloadFileAction(KisDocument *doc)
 {
     Q_UNUSED(doc);
 //    d->reloadFile->setEnabled(doc && !doc->url().isEmpty());
 }
 
 void KisMainWindow::setReadWrite(bool readwrite)
 {
     d->saveAction->setEnabled(readwrite);
     d->importFile->setEnabled(readwrite);
     d->readOnly = !readwrite;
     updateCaption();
 }
 
 void KisMainWindow::addRecentURL(const QUrl &url)
 {
     dbgUI << "KisMainWindow::addRecentURL url=" << url.toDisplayString();
     // Add entry to recent documents list
     // (call coming from KisDocument because it must work with cmd line, template dlg, file/open, etc.)
     if (!url.isEmpty()) {
         bool ok = true;
         if (url.isLocalFile()) {
             QString path = url.adjusted(QUrl::StripTrailingSlash).toLocalFile();
             const QStringList tmpDirs = KoResourcePaths::resourceDirs("tmp");
             for (QStringList::ConstIterator it = tmpDirs.begin() ; ok && it != tmpDirs.end() ; ++it)
                 if (path.contains(*it))
                     ok = false; // it's in the tmp resource
 #ifdef HAVE_KIO
             if (ok) {
                 KRecentDocument::add(QUrl::fromLocalFile(path));
             }
 #endif
         }
 #ifdef HAVE_KIO
         else {
             KRecentDocument::add(url.adjusted(QUrl::StripTrailingSlash));
         }
 #endif
         if (ok) {
             d->recentFiles->addUrl(url);
         }
         saveRecentFiles();
 
     }
 }
 
 void KisMainWindow::saveRecentFiles()
 {
     // Save list of recent files
     KSharedConfigPtr config =  KSharedConfig::openConfig();
     d->recentFiles->saveEntries(config->group("RecentFiles"));
     config->sync();
 
     // Tell all windows to reload their list, after saving
     // Doesn't work multi-process, but it's a start
     Q_FOREACH (KMainWindow* window, KMainWindow::memberList())
         static_cast<KisMainWindow *>(window)->reloadRecentFileList();
 }
 
 void KisMainWindow::reloadRecentFileList()
 {
     d->recentFiles->loadEntries( KSharedConfig::openConfig()->group("RecentFiles"));
 }
 
 void KisMainWindow::updateCaption()
 {
     if (!d->mdiArea->activeSubWindow()) {
         updateCaption(QString(), false);
     }
     else if (d->activeView && d->activeView->document()){
         QString caption( d->activeView->document()->caption() );
         if (d->readOnly) {
             caption += ' ' + i18n("(write protected)");
         }
 
         d->activeView->setWindowTitle(caption);
 
         updateCaption(caption, d->activeView->document()->isModified());
 
         if (!d->activeView->document()->url().fileName().isEmpty())
             d->saveAction->setToolTip(i18n("Save as %1", d->activeView->document()->url().fileName()));
         else
             d->saveAction->setToolTip(i18n("Save"));
     }
 }
 
 void KisMainWindow::updateCaption(const QString & caption, bool mod)
 {
     dbgUI << "KisMainWindow::updateCaption(" << caption << "," << mod << ")";
 #ifdef KRITA_ALPHA
     setCaption(QString("ALPHA %1: %2").arg(KRITA_ALPHA).arg(caption), mod);
     return;
 #endif
 #ifdef KRITA_BETA
     setCaption(QString("BETA %1: %2").arg(KRITA_BETA).arg(caption), mod);
     return;
 #endif
 #ifdef KRITA_RC
     setCaption(QString("RELEASE CANDIDATE %1: %2").arg(KRITA_RC).arg(caption), mod);
     return;
 #endif
 
     setCaption(caption, mod);
 }
 
 
 KisView *KisMainWindow::activeView() const
 {
     if (d->activeView) {
         return d->activeView;
     }
     return 0;
 }
 
 bool KisMainWindow::openDocument(const QUrl &url)
 {
     if (!QFile(url.toLocalFile()).exists()) {
         QMessageBox::critical(0, i18nc("@title:window", "Krita"), i18n("The file %1 does not exist.", url.url()));
         d->recentFiles->removeUrl(url); //remove the file from the recent-opened-file-list
         saveRecentFiles();
         return false;
     }
     return openDocumentInternal(url);
 }
 
 bool KisMainWindow::openDocumentInternal(const QUrl &url, KisDocument *newdoc)
 {
     if (!url.isLocalFile()) {
         qDebug() << "KisMainWindow::openDocumentInternal. Not a local file:" << url;
         return false;
     }
 
     if (!newdoc) {
         newdoc = KisPart::instance()->createDocument();
     }
 
     d->firstTime = true;
     connect(newdoc, SIGNAL(sigProgress(int)), this, SLOT(slotProgress(int)));
     connect(newdoc, SIGNAL(completed()), this, SLOT(slotLoadCompleted()));
     connect(newdoc, SIGNAL(canceled(const QString &)), this, SLOT(slotLoadCanceled(const QString &)));
     bool openRet = (!d->isImporting) ? newdoc->openUrl(url) : newdoc->importDocument(url);
     if (!openRet) {
         delete newdoc;
         return false;
     }
 
     KisPart::instance()->addDocument(newdoc);
     updateReloadFileAction(newdoc);
 
     if (!QFileInfo(url.toLocalFile()).isWritable()) {
         setReadWrite(false);
     }
     return true;
 }
 
 void KisMainWindow::addViewAndNotifyLoadingCompleted(KisDocument *document)
 {
     KisView *view = KisPart::instance()->createView(document, resourceManager(), actionCollection(), this);
     addView(view);
 
     emit guiLoadingFinished();
 }
 
 QStringList KisMainWindow::showOpenFileDialog()
 {
     KoFileDialog dialog(this, KoFileDialog::ImportFiles, "OpenDocument");
     dialog.setDefaultDir(QDesktopServices::storageLocation(QDesktopServices::PicturesLocation));
     dialog.setMimeTypeFilters(KisImportExportManager::mimeFilter(KisImportExportManager::Import));
     dialog.setCaption(d->isImporting ? i18n("Import Images") : i18n("Open Images"));
 
     return dialog.filenames();
 }
 
 // Separate from openDocument to handle async loading (remote URLs)
 void KisMainWindow::slotLoadCompleted()
 {
     KisDocument *newdoc = qobject_cast<KisDocument*>(sender());
     if (newdoc && newdoc->image()) {
         addViewAndNotifyLoadingCompleted(newdoc);
 
         disconnect(newdoc, SIGNAL(sigProgress(int)), this, SLOT(slotProgress(int)));
         disconnect(newdoc, SIGNAL(completed()), this, SLOT(slotLoadCompleted()));
         disconnect(newdoc, SIGNAL(canceled(const QString &)), this, SLOT(slotLoadCanceled(const QString &)));
 
         emit loadCompleted();
     }
 }
 
 void KisMainWindow::slotLoadCanceled(const QString & errMsg)
 {
     dbgUI << "KisMainWindow::slotLoadCanceled";
     if (!errMsg.isEmpty())   // empty when canceled by user
         QMessageBox::critical(this, i18nc("@title:window", "Krita"), errMsg);
     // ... can't delete the document, it's the one who emitted the signal...
 
     KisDocument* doc = qobject_cast<KisDocument*>(sender());
     Q_ASSERT(doc);
     disconnect(doc, SIGNAL(sigProgress(int)), this, SLOT(slotProgress(int)));
     disconnect(doc, SIGNAL(completed()), this, SLOT(slotLoadCompleted()));
     disconnect(doc, SIGNAL(canceled(const QString &)), this, SLOT(slotLoadCanceled(const QString &)));
 }
 
 void KisMainWindow::slotSaveCanceled(const QString &errMsg)
 {
     dbgUI << "KisMainWindow::slotSaveCanceled";
     if (!errMsg.isEmpty())   // empty when canceled by user
         QMessageBox::critical(this, i18nc("@title:window", "Krita"), errMsg);
     slotSaveCompleted();
 }
 
 void KisMainWindow::slotSaveCompleted()
 {
     dbgUI << "KisMainWindow::slotSaveCompleted";
     KisDocument* doc = qobject_cast<KisDocument*>(sender());
     Q_ASSERT(doc);
     disconnect(doc, SIGNAL(sigProgress(int)), this, SLOT(slotProgress(int)));
     disconnect(doc, SIGNAL(completed()), this, SLOT(slotSaveCompleted()));
     disconnect(doc, SIGNAL(canceled(const QString &)), this, SLOT(slotSaveCanceled(const QString &)));
 
     if (d->deferredClosingEvent) {
         KXmlGuiWindow::closeEvent(d->deferredClosingEvent);
     }
 }
 
 bool KisMainWindow::hackIsSaving() const
 {
     StdLockableWrapper<QMutex> wrapper(&d->savingEntryMutex);
     std::unique_lock<StdLockableWrapper<QMutex>> l(wrapper, std::try_to_lock);
     return !l.owns_lock();
 }
 
 bool KisMainWindow::saveDocument(KisDocument *document, bool saveas)
 {
     if (!document) {
         return true;
     }
 
     /**
      * Make sure that we cannot enter this method twice!
      *
      * The lower level functions may call processEvents() so
      * double-entry is quite possible to achieve. Here we try to lock
      * the mutex, and if it is failed, just cancel saving.
      */
     StdLockableWrapper<QMutex> wrapper(&d->savingEntryMutex);
     std::unique_lock<StdLockableWrapper<QMutex>> l(wrapper, std::try_to_lock);
     if (!l.owns_lock()) return false;
 
     // no busy wait for saving because it is dangerous!
     KisDelayedSaveDialog dlg(document->image(), KisDelayedSaveDialog::SaveDialog, 0, this);
     dlg.blockIfImageIsBusy();
 
     if (dlg.result() != QDialog::Accepted) {
         return false;
     }
 
     bool reset_url;
 
     if (document->url().isEmpty()) {
         reset_url = true;
         saveas = true;
     } else {
         reset_url = false;
     }
 
     connect(document, SIGNAL(sigProgress(int)), this, SLOT(slotProgress(int)));
     connect(document, SIGNAL(completed()), this, SLOT(slotSaveCompleted()));
     connect(document, SIGNAL(canceled(const QString &)), this, SLOT(slotSaveCanceled(const QString &)));
 
     QUrl oldURL = document->url();
     QString oldFile = document->localFilePath();
 
     QByteArray _native_format = document->nativeFormatMimeType();
     QByteArray oldOutputFormat = document->outputMimeType();
 
     QUrl suggestedURL = document->url();
 
     QStringList mimeFilter;
 
     mimeFilter = KisImportExportManager::mimeFilter(KisImportExportManager::Export);
 
     if (!mimeFilter.contains(oldOutputFormat) && !d->isExporting) {
         dbgUI << "KisMainWindow::saveDocument no export filter for" << oldOutputFormat;
 
         // --- don't setOutputMimeType in case the user cancels the Save As
         // dialog and then tries to just plain Save ---
 
         // suggest a different filename extension (yes, we fortunately don't all live in a world of magic :))
         QString suggestedFilename = suggestedURL.fileName();
 
         if (!suggestedFilename.isEmpty()) {  // ".kra" looks strange for a name
             int c = suggestedFilename.lastIndexOf('.');
 
             const QString ext = KisMimeDatabase::suffixesForMimeType(_native_format).first();
             if (!ext.isEmpty()) {
                 if (c < 0)
                     suggestedFilename = suggestedFilename + "." + ext;
                 else
                     suggestedFilename = suggestedFilename.left(c) + "." + ext;
             } else { // current filename extension wrong anyway
                 if (c > 0) {
                     // this assumes that a . signifies an extension, not just a .
                     suggestedFilename = suggestedFilename.left(c);
                 }
             }
 
             suggestedURL = suggestedURL.adjusted(QUrl::RemoveFilename);
             suggestedURL.setPath(suggestedURL.path() + suggestedFilename);
         }
 
         // force the user to choose outputMimeType
         saveas = true;
     }
 
     bool ret = false;
 
     if (document->url().isEmpty() || saveas) {
         // if you're just File/Save As'ing to change filter options you
         // don't want to be reminded about overwriting files etc.
         bool justChangingFilterOptions = false;
 
         KoFileDialog dialog(this, KoFileDialog::SaveFile, "SaveAs");
         dialog.setCaption(i18n("untitled"));
         if (d->isExporting && !d->lastExportUrl.isEmpty()) {
             dialog.setDefaultDir(d->lastExportUrl.toLocalFile());
         }
         else {
             dialog.setDefaultDir(suggestedURL.toLocalFile());
         }
         // Default to all supported file types if user is exporting, otherwise use Krita default
         dialog.setMimeTypeFilters(mimeFilter, QString(_native_format));
         QUrl newURL = QUrl::fromUserInput(dialog.filename());
 
         if (newURL.isLocalFile()) {
             QString fn = newURL.toLocalFile();
             if (QFileInfo(fn).completeSuffix().isEmpty()) {
                 fn.append(KisMimeDatabase::suffixesForMimeType(_native_format).first());
                 newURL = QUrl::fromLocalFile(fn);
             }
         }
 
         if (document->documentInfo()->aboutInfo("title") == i18n("Unnamed")) {
             QString fn = newURL.toLocalFile();
             QFileInfo info(fn);
             document->documentInfo()->setAboutInfo("title", info.baseName());
         }
 
         QByteArray outputFormat = _native_format;
 
         QString outputFormatString = KisMimeDatabase::mimeTypeForFile(newURL.toLocalFile());
         outputFormat = outputFormatString.toLatin1();
 
 
         if (!d->isExporting) {
             justChangingFilterOptions = (newURL == document->url()) && (outputFormat == document->mimeType());
         }
         else {
             justChangingFilterOptions = (newURL == d->lastExportUrl) && (outputFormat == d->lastExportedFormat);
         }
 
         bool bOk = true;
         if (newURL.isEmpty()) {
             bOk = false;
         }
 
         if (bOk) {
             bool wantToSave = true;
 
             // don't change this line unless you know what you're doing :)
             if (!justChangingFilterOptions) {
                 if (!document->isNativeFormat(outputFormat))
                     wantToSave = true;
             }
 
             if (wantToSave) {
                 //
                 // Note:
                 // If the user is stupid enough to Export to the current URL,
                 // we do _not_ change this operation into a Save As.  Reasons
                 // follow:
                 //
                 // 1. A check like "d->isExporting && oldURL == newURL"
                 //    doesn't _always_ work on case-insensitive filesystems
                 //    and inconsistent behaviour is bad.
                 // 2. It is probably not a good idea to change document->mimeType
                 //    and friends because the next time the user File/Save's,
                 //    (not Save As) they won't be expecting that they are
                 //    using their File/Export settings
                 //
                 // As a bad side-effect of this, the modified flag will not
                 // be updated and it is possible that what is currently on
                 // their screen is not what is stored on disk (through loss
                 // of formatting).  But if you are dumb enough to change
                 // mimetype but not the filename, then arguably, _you_ are
                 // the "bug" :)
                 //
                 // - Clarence
                 //
                 document->setOutputMimeType(outputFormat);
                 if (!d->isExporting) {  // Save As
                     ret = document->saveAs(newURL);
 
                     if (ret) {
                         dbgUI << "Successful Save As!";
                         addRecentURL(newURL);
                         setReadWrite(true);
                     } else {
                         dbgUI << "Failed Save As!";
                         document->setUrl(oldURL);
                         document->setLocalFilePath(oldFile);
                         document->setOutputMimeType(oldOutputFormat);
                     }
                 } else { // Export
                     ret = document->exportDocument(newURL);
 
                     if (ret) {
                         // a few file dialog convenience things
                         d->lastExportUrl = newURL;
                         d->lastExportedFormat = outputFormat;
                     }
 
                     // always restore output format
                     document->setOutputMimeType(oldOutputFormat);
                 }
 
             }   // if (wantToSave)  {
             else
                 ret = false;
         }   // if (bOk) {
         else
             ret = false;
     } else { // saving
 
         // be sure document has the correct outputMimeType!
         if (d->isExporting || document->isModified()) {
             ret = document->save();
         }
 
         if (!ret) {
             dbgUI << "Failed Save!";
             document->setUrl(oldURL);
             document->setLocalFilePath(oldFile);
         }
     }
 
 
     if (!ret && reset_url)
         document->resetURL(); //clean the suggested filename as the save dialog was rejected
 
     updateReloadFileAction(document);
     updateCaption();
 
     return ret;
 }
 
 void KisMainWindow::undo()
 {
     if (activeView()) {
         activeView()->undoAction()->trigger();
         d->undo->setText(activeView()->undoAction()->text());
     }
 }
 
 void KisMainWindow::redo()
 {
     if (activeView()) {
         activeView()->redoAction()->trigger();
         d->redo->setText(activeView()->redoAction()->text());
     }
 }
 
 void KisMainWindow::closeEvent(QCloseEvent *e)
 {
     d->mdiArea->closeAllSubWindows();
 
     QAction *action= d->viewManager->actionCollection()->action("view_show_canvas_only");
 
     if ((action) && (action->isChecked())) {
         action->setChecked(false);
     }
     KConfigGroup cfg( KSharedConfig::openConfig(), "MainWindow");
     cfg.writeEntry("ko_geometry", saveGeometry().toBase64());
     cfg.writeEntry("ko_windowstate", saveState().toBase64());
 
     {
         KConfigGroup group( KSharedConfig::openConfig(), "theme");
         group.writeEntry("Theme", d->themeManager->currentThemeName());
     }
 
     QList<QMdiSubWindow*> childrenList = d->mdiArea->subWindowList();
 
     if (childrenList.isEmpty()) {
         d->deferredClosingEvent = e;
 
         if (!d->dockerStateBeforeHiding.isEmpty()) {
             restoreState(d->dockerStateBeforeHiding);
         }
         statusBar()->setVisible(true);
         menuBar()->setVisible(true);
 
         saveWindowSettings();
 
         if (d->noCleanup)
             return;
 
         Q_FOREACH (QMdiSubWindow *subwin, d->mdiArea->subWindowList()) {
             KisView *view = dynamic_cast<KisView*>(subwin);
             if (view) {
                 KisPart::instance()->removeView(view);
             }
         }
 
         if (!d->dockWidgetVisibilityMap.isEmpty()) { // re-enable dockers for persistency
             Q_FOREACH (QDockWidget* dockWidget, d->dockWidgetsMap)
                 dockWidget->setVisible(d->dockWidgetVisibilityMap.value(dockWidget));
         }
     } else {
         e->setAccepted(false);
     }
 }
 
 void KisMainWindow::saveWindowSettings()
 {
     KSharedConfigPtr config =  KSharedConfig::openConfig();
 
     if (d->windowSizeDirty ) {
         dbgUI << "KisMainWindow::saveWindowSettings";
         KConfigGroup group = config->group("MainWindow");
         KWindowConfig::saveWindowSize(windowHandle(), group);
         config->sync();
         d->windowSizeDirty = false;
     }
 
     if (!d->activeView || d->activeView->document()) {
 
         // Save toolbar position into the config file of the app, under the doc's component name
         KConfigGroup group =  KSharedConfig::openConfig()->group("krita");
         saveMainWindowSettings(group);
 
         // Save collapsable state of dock widgets
         for (QMap<QString, QDockWidget*>::const_iterator i = d->dockWidgetsMap.constBegin();
              i != d->dockWidgetsMap.constEnd(); ++i) {
             if (i.value()->widget()) {
                 KConfigGroup dockGroup = group.group(QString("DockWidget ") + i.key());
                 dockGroup.writeEntry("Collapsed", i.value()->widget()->isHidden());
                 dockGroup.writeEntry("Locked", i.value()->property("Locked").toBool());
                 dockGroup.writeEntry("DockArea", (int) dockWidgetArea(i.value()));
                 dockGroup.writeEntry("xPosition", (int) i.value()->widget()->x());
                 dockGroup.writeEntry("yPosition", (int) i.value()->widget()->y());
 
                 dockGroup.writeEntry("width", (int) i.value()->widget()->width());
                 dockGroup.writeEntry("height", (int) i.value()->widget()->height());
             }
         }
 
     }
 
      KSharedConfig::openConfig()->sync();
     resetAutoSaveSettings(); // Don't let KMainWindow override the good stuff we wrote down
 
 }
 
 void KisMainWindow::resizeEvent(QResizeEvent * e)
 {
     d->windowSizeDirty = true;
     KXmlGuiWindow::resizeEvent(e);
 }
 
 void KisMainWindow::setActiveView(KisView* view)
 {
     d->activeView = view;
     updateCaption();
     actionCollection()->action("edit_undo")->setText(activeView()->undoAction()->text());
     actionCollection()->action("edit_redo")->setText(activeView()->redoAction()->text());
     d->viewManager->setCurrentView(view);
 }
 
 void KisMainWindow::dragEnterEvent(QDragEnterEvent *event)
 {
     if (event->mimeData()->hasUrls() ||
         event->mimeData()->hasFormat("application/x-krita-node") ||
         event->mimeData()->hasFormat("application/x-qt-image")) {
 
         event->accept();
     }
 }
 
 void KisMainWindow::dropEvent(QDropEvent *event)
 {
     if (event->mimeData()->hasUrls() && event->mimeData()->urls().size() > 0) {
         Q_FOREACH (const QUrl &url, event->mimeData()->urls()) {
             openDocument(url);
         }
     }
 }
 
 void KisMainWindow::dragMoveEvent(QDragMoveEvent * event)
 {
     QTabBar *tabBar = d->findTabBarHACK();
 
     if (!tabBar && d->mdiArea->viewMode() == QMdiArea::TabbedView) {
         qWarning() << "WARNING!!! Cannot find QTabBar in the main window! Looks like Qt has changed behavior. Drag & Drop between multiple tabs might not work properly (tabs will not switch automatically)!";
     }
 
     if (tabBar && tabBar->isVisible()) {
         QPoint pos = tabBar->mapFromGlobal(mapToGlobal(event->pos()));
         if (tabBar->rect().contains(pos)) {
             const int tabIndex = tabBar->tabAt(pos);
 
             if (tabIndex >= 0 && tabBar->currentIndex() != tabIndex) {
                 d->tabSwitchCompressor->start(tabIndex);
             }
         } else if (d->tabSwitchCompressor->isActive()) {
             d->tabSwitchCompressor->stop();
         }
     }
 }
 
 void KisMainWindow::dragLeaveEvent(QDragLeaveEvent * /*event*/)
 {
     if (d->tabSwitchCompressor->isActive()) {
         d->tabSwitchCompressor->stop();
     }
 }
 
 void KisMainWindow::switchTab(int index)
 {
     QTabBar *tabBar = d->findTabBarHACK();
     if (!tabBar) return;
 
     tabBar->setCurrentIndex(index);
 }
 
 void KisMainWindow::slotFileNew()
 {
     const QStringList mimeFilter = KisImportExportManager::mimeFilter(KisImportExportManager::Import);
 
     KisOpenPane *startupWidget = new KisOpenPane(this, mimeFilter, QStringLiteral("templates/"));
     startupWidget->setWindowModality(Qt::WindowModal);
 
     KisConfig cfg;
 
     int w = cfg.defImageWidth();
     int h = cfg.defImageHeight();
     const double resolution = cfg.defImageResolution();
     const QString colorModel = cfg.defColorModel();
     const QString colorDepth = cfg.defaultColorDepth();
     const QString colorProfile = cfg.defColorProfile();
 
 
     CustomDocumentWidgetItem item;
     item.widget = new KisCustomImageWidget(startupWidget,
                                            w,
                                            h,
                                            resolution,
                                            colorModel,
                                            colorDepth,
                                            colorProfile,
                                            i18n("Unnamed"));
 
     item.icon = "document-new";
 
     startupWidget->addCustomDocumentWidget(item.widget, item.title, item.icon);
 
     QSize sz = KisClipboard::instance()->clipSize();
     if (sz.isValid() && sz.width() != 0 && sz.height() != 0) {
         w = sz.width();
         h = sz.height();
     }
 
     item.widget = new KisImageFromClipboard(startupWidget,
                                             w,
                                             h,
                                             resolution,
                                             colorModel,
                                             colorDepth,
                                             colorProfile,
                                             i18n("Unnamed"));
 
     item.title = i18n("Create from Clipboard");
     item.icon = "tab-new";
 
     startupWidget->addCustomDocumentWidget(item.widget, item.title, item.icon);
 
     // calls deleteLater
     connect(startupWidget, SIGNAL(documentSelected(KisDocument*)), KisPart::instance(), SLOT(startCustomDocument(KisDocument*)));
     // calls deleteLater
     connect(startupWidget, SIGNAL(openTemplate(const QUrl&)), KisPart::instance(), SLOT(openTemplate(const QUrl&)));
 
     startupWidget->exec();
 
     // Cancel calls deleteLater...
 
 }
 
 void KisMainWindow::slotFileOpen()
 {
     QStringList urls = showOpenFileDialog();
 
     if (urls.isEmpty())
         return;
 
     Q_FOREACH (const QString& url, urls) {
 
         if (!url.isEmpty()) {
             bool res = openDocument(QUrl::fromLocalFile(url));
             if (!res) {
                 warnKrita << "Loading" << url << "failed";
             }
         }
     }
 }
 
 void KisMainWindow::slotFileOpenRecent(const QUrl &url)
 {
     (void) openDocument(QUrl::fromLocalFile(url.toLocalFile()));
 }
 
 void KisMainWindow::slotFileSave()
 {
     if (saveDocument(d->activeView->document())) {
         emit documentSaved();
     }
 }
 
 void KisMainWindow::slotFileSaveAs()
 {
     if (saveDocument(d->activeView->document(), true)) {
         emit documentSaved();
     }
 }
 
 KoCanvasResourceManager *KisMainWindow::resourceManager() const
 {
     return d->viewManager->resourceProvider()->resourceManager();
 }
 
 int KisMainWindow::viewCount() const
 {
     return d->mdiArea->subWindowList().size();
 }
 
 bool KisMainWindow::restoreWorkspace(const QByteArray &state)
 {
     QByteArray oldState = saveState();
     const bool showTitlebars = KisConfig().showDockerTitleBars();
 
     // needed because otherwise the layout isn't correctly restored in some situations
     Q_FOREACH (QDockWidget *dock, dockWidgets()) {
         dock->hide();
         dock->titleBarWidget()->setVisible(showTitlebars);
     }
 
     bool success = KXmlGuiWindow::restoreState(state);
 
     if (!success) {
         KXmlGuiWindow::restoreState(oldState);
         Q_FOREACH (QDockWidget *dock, dockWidgets()) {
             if (dock->titleBarWidget()) {
                 dock->titleBarWidget()->setVisible(showTitlebars || dock->isFloating());
             }
         }
         return false;
     }
 
 
     Q_FOREACH (QDockWidget *dock, dockWidgets()) {
         if (dock->titleBarWidget()) {
             const bool isCollapsed = (dock->widget() && dock->widget()->isHidden()) || !dock->widget();
             dock->titleBarWidget()->setVisible(showTitlebars || (dock->isFloating() && isCollapsed));
         }
     }
 
     return success;
 }
 
 KisViewManager *KisMainWindow::viewManager() const
 {
     return d->viewManager;
 }
 
 void KisMainWindow::slotDocumentInfo()
 {
     if (!d->activeView->document())
         return;
 
     KoDocumentInfo *docInfo = d->activeView->document()->documentInfo();
 
     if (!docInfo)
         return;
 
     KoDocumentInfoDlg *dlg = d->activeView->document()->createDocumentInfoDialog(this, docInfo);
 
     if (dlg->exec()) {
         if (dlg->isDocumentSaved()) {
             d->activeView->document()->setModified(false);
         } else {
             d->activeView->document()->setModified(true);
         }
         d->activeView->document()->setTitleModified();
     }
 
     delete dlg;
 }
 
 bool KisMainWindow::slotFileCloseAll()
 {
     Q_FOREACH (QMdiSubWindow *subwin, d->mdiArea->subWindowList()) {
         if (subwin) {
             if(!subwin->close())
                 return false;
         }
     }
 
     updateCaption();
     return true;
 }
 
 void KisMainWindow::slotFileQuit()
 {
     if(!slotFileCloseAll())
         return;
 
     close();
 
     Q_FOREACH (QPointer<KisMainWindow> mainWin, KisPart::instance()->mainWindows()) {
         if (mainWin != this) {
             if(!mainWin->slotFileCloseAll())
                 return;
 
             mainWin->close();
         }
     }
 }
 
 void KisMainWindow::slotFilePrint()
 {
     if (!activeView())
         return;
     KisPrintJob *printJob = activeView()->createPrintJob();
     if (printJob == 0)
         return;
     applyDefaultSettings(printJob->printer());
     QPrintDialog *printDialog = activeView()->createPrintDialog( printJob, this );
     if (printDialog && printDialog->exec() == QDialog::Accepted) {
         printJob->printer().setPageMargins(0.0, 0.0, 0.0, 0.0, QPrinter::Point);
         printJob->printer().setPaperSize(QSizeF(activeView()->image()->width() / (72.0 * activeView()->image()->xRes()),
                                                 activeView()->image()->height()/ (72.0 * activeView()->image()->yRes())),
                                          QPrinter::Inch);
         printJob->startPrinting(KisPrintJob::DeleteWhenDone);
     }
     else {
         delete printJob;
     }
     delete printDialog;
 }
 
 void KisMainWindow::slotFilePrintPreview()
 {
     if (!activeView())
         return;
     KisPrintJob *printJob = activeView()->createPrintJob();
     if (printJob == 0)
         return;
 
     /* Sets the startPrinting() slot to be blocking.
      The Qt print-preview dialog requires the printing to be completely blocking
      and only return when the full document has been printed.
      By default the KisPrintingDialog is non-blocking and
      multithreading, setting blocking to true will allow it to be used in the preview dialog */
     printJob->setProperty("blocking", true);
     QPrintPreviewDialog *preview = new QPrintPreviewDialog(&printJob->printer(), this);
     printJob->setParent(preview); // will take care of deleting the job
     connect(preview, SIGNAL(paintRequested(QPrinter*)), printJob, SLOT(startPrinting()));
     preview->exec();
     delete preview;
 }
 
 KisPrintJob* KisMainWindow::exportToPdf(QString pdfFileName)
 {
     if (!activeView())
         return 0;
 
     if (!activeView()->document())
         return 0;
 
     KoPageLayout pageLayout;
     pageLayout.width = 0;
     pageLayout.height = 0;
     pageLayout.topMargin = 0;
     pageLayout.bottomMargin = 0;
     pageLayout.leftMargin = 0;
     pageLayout.rightMargin = 0;
 
     if (pdfFileName.isEmpty()) {
         KConfigGroup group =  KSharedConfig::openConfig()->group("File Dialogs");
         QString defaultDir = group.readEntry("SavePdfDialog");
         if (defaultDir.isEmpty())
             defaultDir = QDesktopServices::storageLocation(QDesktopServices::DocumentsLocation);
         QUrl startUrl = QUrl::fromLocalFile(defaultDir);
         KisDocument* pDoc = d->activeView->document();
         /** if document has a file name, take file name and replace extension with .pdf */
         if (pDoc && pDoc->url().isValid()) {
             startUrl = pDoc->url();
             QString fileName = startUrl.toLocalFile();
             fileName = fileName.replace( QRegExp( "\\.\\w{2,5}$", Qt::CaseInsensitive ), ".pdf" );
             startUrl = startUrl.adjusted(QUrl::RemoveFilename);
             startUrl.setPath(startUrl.path() +  fileName );
         }
 
         QPointer<KoPageLayoutDialog> layoutDlg(new KoPageLayoutDialog(this, pageLayout));
         layoutDlg->setWindowModality(Qt::WindowModal);
         if (layoutDlg->exec() != QDialog::Accepted || !layoutDlg) {
             delete layoutDlg;
             return 0;
         }
         pageLayout = layoutDlg->pageLayout();
         delete layoutDlg;
 
         KoFileDialog dialog(this, KoFileDialog::SaveFile, "OpenDocument");
         dialog.setCaption(i18n("Export as PDF"));
         dialog.setDefaultDir(startUrl.toLocalFile());
         dialog.setMimeTypeFilters(QStringList() << "application/pdf");
         QUrl url = QUrl::fromUserInput(dialog.filename());
 
         pdfFileName = url.toLocalFile();
         if (pdfFileName.isEmpty())
             return 0;
     }
 
     KisPrintJob *printJob = activeView()->createPrintJob();
     if (printJob == 0)
         return 0;
     if (isHidden()) {
         printJob->setProperty("noprogressdialog", true);
     }
 
     applyDefaultSettings(printJob->printer());
     // TODO for remote files we have to first save locally and then upload.
     printJob->printer().setOutputFileName(pdfFileName);
     printJob->printer().setDocName(pdfFileName);
     printJob->printer().setColorMode(QPrinter::Color);
 
     if (pageLayout.format == KoPageFormat::CustomSize) {
         printJob->printer().setPaperSize(QSizeF(pageLayout.width, pageLayout.height), QPrinter::Millimeter);
     } else {
         printJob->printer().setPaperSize(KoPageFormat::printerPageSize(pageLayout.format));
     }
 
     printJob->printer().setPageMargins(pageLayout.leftMargin, pageLayout.topMargin, pageLayout.rightMargin, pageLayout.bottomMargin, QPrinter::Millimeter);
 
     switch (pageLayout.orientation) {
     case KoPageFormat::Portrait:
         printJob->printer().setOrientation(QPrinter::Portrait);
         break;
     case KoPageFormat::Landscape:
         printJob->printer().setOrientation(QPrinter::Landscape);
         break;
     }
 
     //before printing check if the printer can handle printing
     if (!printJob->canPrint()) {
         QMessageBox::critical(this, i18nc("@title:window", "Krita"), i18n("Cannot export to the specified file"));
     }
 
     printJob->startPrinting(KisPrintJob::DeleteWhenDone);
     return printJob;
 }
 
 void KisMainWindow::importAnimation()
 {
     if (!activeView()) return;
 
     KisDocument *document = activeView()->document();
     if (!document) return;
 
     KisDlgImportImageSequence dlg(this, document);
 
     if (dlg.exec() == QDialog::Accepted) {
         QStringList files = dlg.files();
         int firstFrame = dlg.firstFrame();
         int step = dlg.step();
 
         document->setFileProgressProxy();
         document->setFileProgressUpdater(i18n("Import frames"));
         KisAnimationImporter importer(document);
         KisImportExportFilter::ConversionStatus status = importer.import(files, firstFrame, step);
         document->clearFileProgressUpdater();
         document->clearFileProgressProxy();
 
         if (status != KisImportExportFilter::OK && status != KisImportExportFilter::InternalError) {
             QString msg = KisImportExportFilter::conversionStatusString(status);
 
             if (!msg.isEmpty())
                 QMessageBox::critical(0, i18nc("@title:window", "Krita"), i18n("Could not finish import animation:\n%1", msg));
         }
         activeView()->canvasBase()->refetchDataFromImage();
     }
 }
 
 void KisMainWindow::slotConfigureToolbars()
 {
     KConfigGroup group =  KSharedConfig::openConfig()->group("krita");
     saveMainWindowSettings(group);
     KEditToolBar edit(factory(), this);
     connect(&edit, SIGNAL(newToolBarConfig()), this, SLOT(slotNewToolbarConfig()));
     (void) edit.exec();
     applyToolBarLayout();
 }
 
 void KisMainWindow::slotNewToolbarConfig()
 {
     applyMainWindowSettings(KSharedConfig::openConfig()->group("krita"));
 
     KXMLGUIFactory *factory = guiFactory();
     Q_UNUSED(factory);
 
     // Check if there's an active view
     if (!d->activeView)
         return;
 
     plugActionList("toolbarlist", d->toolbarList);
     applyToolBarLayout();
 }
 
 void KisMainWindow::slotToolbarToggled(bool toggle)
 {
     //dbgUI <<"KisMainWindow::slotToolbarToggled" << sender()->name() <<" toggle=" << true;
     // The action (sender) and the toolbar have the same name
     KToolBar * bar = toolBar(sender()->objectName());
     if (bar) {
         if (toggle) {
             bar->show();
         }
         else {
             bar->hide();
         }
 
         if (d->activeView && d->activeView->document()) {
             KConfigGroup group =  KSharedConfig::openConfig()->group("krita");
             saveMainWindowSettings(group);
         }
     } else
         warnUI << "slotToolbarToggled : Toolbar " << sender()->objectName() << " not found!";
 }
 
 void KisMainWindow::viewFullscreen(bool fullScreen)
 {
     KisConfig cfg;
     cfg.setFullscreenMode(fullScreen);
 
     if (fullScreen) {
         setWindowState(windowState() | Qt::WindowFullScreen);   // set
     } else {
         setWindowState(windowState() & ~Qt::WindowFullScreen);   // reset
     }
 }
 
 void KisMainWindow::slotProgress(int value)
 {
     qApp->processEvents();
 
     StdLockableWrapper<QMutex> wrapper(&d->progressMutex);
     std::unique_lock<StdLockableWrapper<QMutex>> l(wrapper, std::try_to_lock);
     if (!l.owns_lock()) return;
 
 
     dbgUI << "KisMainWindow::slotProgress" << value;
     if (value <= -1 || value >= 100) {
         if (d->progress) {
             statusBar()->removeWidget(d->progress);
             delete d->progress;
             d->progress = 0;
 
             disconnect(d->progressCancel, SIGNAL(clicked()), this, SLOT(slotProgressCanceled()));
             statusBar()->removeWidget(d->progressCancel);
             delete d->progressCancel;
             d->progressCancel = 0;
         }
         d->firstTime = true;
         return;
     }
     if (d->firstTime || !d->progress) {
         // The statusbar might not even be created yet.
         // So check for that first, and create it if necessary
         QStatusBar *bar = findChild<QStatusBar *>();
         if (!bar) {
             statusBar()->show();
             QApplication::sendPostedEvents(this, QEvent::ChildAdded);
         }
 
         if (d->progress) {
             statusBar()->removeWidget(d->progress);
             delete d->progress;
             d->progress = 0;
 
             disconnect(d->progressCancel, SIGNAL(clicked()), this, SLOT(slotProgressCanceled()));
             statusBar()->removeWidget(d->progressCancel);
             delete d->progressCancel;
             d->progress = 0;
         }
 
         d->progressCancel = new QToolButton(statusBar());
         d->progressCancel->setMaximumHeight(statusBar()->fontMetrics().height());
         d->progressCancel->setIcon(KisIconUtils::loadIcon("process-stop"));
         statusBar()->addPermanentWidget(d->progressCancel);
 
         d->progress = new QProgressBar(statusBar());
         d->progress->setMaximumHeight(statusBar()->fontMetrics().height());
         d->progress->setRange(0, 100);
         statusBar()->addPermanentWidget(d->progress);
 
         connect(d->progressCancel, SIGNAL(clicked()), this, SLOT(slotProgressCanceled()));
 
         d->progress->show();
         d->progressCancel->show();
         d->firstTime = false;
     }
     if (!d->progress.isNull()) {
         d->progress->setValue(value);
     }
     qApp->processEvents();
 }
 
 void KisMainWindow::slotProgressCanceled()
 {
     emit sigProgressCanceled();
 }
 
 void KisMainWindow::setMaxRecentItems(uint _number)
 {
     d->recentFiles->setMaxItems(_number);
 }
 
 void KisMainWindow::slotReloadFile()
 {
     KisDocument* document = d->activeView->document();
     if (!document || document->url().isEmpty())
         return;
 
     if (document->isModified()) {
         bool ok = QMessageBox::question(this,
                                         i18nc("@title:window", "Krita"),
                                         i18n("You will lose all changes made since your last save\n"
                                              "Do you want to continue?"),
                                         QMessageBox::Yes | QMessageBox::No, QMessageBox::Yes) == QMessageBox::Yes;
         if (!ok)
             return;
     }
 
     QUrl url = document->url();
 
     saveWindowSettings();
     if (!document->reload()) {
         QMessageBox::critical(this, i18nc("@title:window", "Krita"), i18n("Error: Could not reload this document"));
     }
 
     return;
 
 }
 
 void KisMainWindow::slotImportFile()
 {
     dbgUI << "slotImportFile()";
 
     d->isImporting = true;
     slotFileOpen();
     d->isImporting = false;
 }
 
 void KisMainWindow::slotExportFile()
 {
     dbgUI << "slotExportFile()";
 
     d->isExporting = true;
     slotFileSaveAs();
     d->isExporting = false;
 }
 
 
 QDockWidget* KisMainWindow::createDockWidget(KoDockFactoryBase* factory)
 {
     QDockWidget* dockWidget = 0;
 
     if (!d->dockWidgetsMap.contains(factory->id())) {
         dockWidget = factory->createDockWidget();
 
         // It is quite possible that a dock factory cannot create the dock; don't
         // do anything in that case.
         if (!dockWidget) {
             warnKrita << "Could not create docker for" << factory->id();
             return 0;
         }
 
         KoDockWidgetTitleBar *titleBar = dynamic_cast<KoDockWidgetTitleBar*>(dockWidget->titleBarWidget());
 
         // Check if the dock widget is supposed to be collapsable
         if (!dockWidget->titleBarWidget()) {
             titleBar = new KoDockWidgetTitleBar(dockWidget);
             dockWidget->setTitleBarWidget(titleBar);
             titleBar->setCollapsable(factory->isCollapsable());
         }
         titleBar->setFont(KoDockRegistry::dockFont());
 
         dockWidget->setObjectName(factory->id());
         dockWidget->setParent(this);
 
         if (dockWidget->widget() && dockWidget->widget()->layout())
             dockWidget->widget()->layout()->setContentsMargins(1, 1, 1, 1);
 
         Qt::DockWidgetArea side = Qt::RightDockWidgetArea;
         bool visible = true;
 
         switch (factory->defaultDockPosition()) {
         case KoDockFactoryBase::DockTornOff:
             dockWidget->setFloating(true); // position nicely?
             break;
         case KoDockFactoryBase::DockTop:
             side = Qt::TopDockWidgetArea; break;
         case KoDockFactoryBase::DockLeft:
             side = Qt::LeftDockWidgetArea; break;
         case KoDockFactoryBase::DockBottom:
             side = Qt::BottomDockWidgetArea; break;
         case KoDockFactoryBase::DockRight:
             side = Qt::RightDockWidgetArea; break;
         case KoDockFactoryBase::DockMinimized:
         default:
             side = Qt::RightDockWidgetArea;
             visible = false;
         }
 
         KConfigGroup group =  KSharedConfig::openConfig()->group("krita").group("DockWidget " + factory->id());
         side = static_cast<Qt::DockWidgetArea>(group.readEntry("DockArea", static_cast<int>(side)));
         if (side == Qt::NoDockWidgetArea) side = Qt::RightDockWidgetArea;
 
         addDockWidget(side, dockWidget);
         if (!visible) {
             dockWidget->hide();
         }
         bool collapsed = factory->defaultCollapsed();
 
         bool locked = false;
         group =  KSharedConfig::openConfig()->group("krita").group("DockWidget " + factory->id());
         collapsed = group.readEntry("Collapsed", collapsed);
         locked = group.readEntry("Locked", locked);
 
         //dbgKrita << "docker" << factory->id() << dockWidget << "collapsed" << collapsed << "locked" << locked << "titlebar" << titleBar;
 
         if (titleBar && collapsed)
             titleBar->setCollapsed(true);
 
         if (titleBar && locked)
             titleBar->setLocked(true);
 
         d->dockWidgetsMap.insert(factory->id(), dockWidget);
     }
     else {
         dockWidget = d->dockWidgetsMap[factory->id()];
     }
 
 #ifdef Q_OS_OSX
     dockWidget->setAttribute(Qt::WA_MacSmallSize, true);
 #endif
     dockWidget->setFont(KoDockRegistry::dockFont());
 
     connect(dockWidget, SIGNAL(dockLocationChanged(Qt::DockWidgetArea)), this, SLOT(forceDockTabFonts()));
 
     return dockWidget;
 }
 
 void KisMainWindow::forceDockTabFonts()
 {
     Q_FOREACH (QObject *child, children()) {
         if (child->inherits("QTabBar")) {
             ((QTabBar *)child)->setFont(KoDockRegistry::dockFont());
         }
     }
 }
 
 QList<QDockWidget*> KisMainWindow::dockWidgets() const
 {
     return d->dockWidgetsMap.values();
 }
 
 QDockWidget* KisMainWindow::dockWidget(const QString &id)
 {
     if (!d->dockWidgetsMap.contains(id)) return 0;
     return d->dockWidgetsMap[id];
 }
 
 QList<KoCanvasObserverBase*> KisMainWindow::canvasObservers() const
 {
     QList<KoCanvasObserverBase*> observers;
 
     Q_FOREACH (QDockWidget *docker, dockWidgets()) {
         KoCanvasObserverBase *observer = dynamic_cast<KoCanvasObserverBase*>(docker);
         if (observer) {
             observers << observer;
         }
         else {
             warnKrita << docker << "is not a canvas observer";
         }
     }
     return observers;
 }
 
 
 void KisMainWindow::toggleDockersVisibility(bool visible)
 {
     if (!visible) {
         d->dockerStateBeforeHiding = saveState();
 
         Q_FOREACH (QObject* widget, children()) {
             if (widget->inherits("QDockWidget")) {
                 QDockWidget* dw = static_cast<QDockWidget*>(widget);
                 if (dw->isVisible()) {
                     dw->hide();
                 }
             }
         }
     }
     else {
         restoreState(d->dockerStateBeforeHiding);
     }
 }
 
 void KisMainWindow::setToolbarList(QList<QAction *> toolbarList)
 {
     qDeleteAll(d->toolbarList);
     d->toolbarList = toolbarList;
 }
 
 void KisMainWindow::slotDocumentTitleModified(const QString &caption, bool mod)
 {
     updateCaption();
     updateCaption(caption, mod);
     updateReloadFileAction(d->activeView ? d->activeView->document() : 0);
 }
 
 
 void KisMainWindow::subWindowActivated()
 {
     bool enabled = (activeKisView() != 0);
 
     d->mdiCascade->setEnabled(enabled);
     d->mdiNextWindow->setEnabled(enabled);
     d->mdiPreviousWindow->setEnabled(enabled);
     d->mdiTile->setEnabled(enabled);
     d->close->setEnabled(enabled);
     d->closeAll->setEnabled(enabled);
 
     setActiveSubWindow(d->mdiArea->activeSubWindow());
     Q_FOREACH (QToolBar *tb, toolBars()) {
         if (tb->objectName() == "BrushesAndStuff") {
             tb->setEnabled(enabled);
         }
     }
 
     updateCaption();
     d->actionManager()->updateGUI();
 }
 
 void KisMainWindow::updateWindowMenu()
 {
     QMenu *menu = d->windowMenu->menu();
     menu->clear();
 
     menu->addAction(d->newWindow);
     menu->addAction(d->documentMenu);
 
     QMenu *docMenu = d->documentMenu->menu();
     docMenu->clear();
 
     Q_FOREACH (QPointer<KisDocument> doc, KisPart::instance()->documents()) {
         if (doc) {
             QString title = doc->url().toDisplayString();
             if (title.isEmpty() && doc->image()) {
                 title = doc->image()->objectName();
             }
             QAction *action = docMenu->addAction(title);
             action->setIcon(qApp->windowIcon());
             connect(action, SIGNAL(triggered()), d->documentMapper, SLOT(map()));
             d->documentMapper->setMapping(action, doc);
         }
     }
 
     menu->addSeparator();
     menu->addAction(d->close);
     menu->addAction(d->closeAll);
     if (d->mdiArea->viewMode() == QMdiArea::SubWindowView) {
         menu->addSeparator();
         menu->addAction(d->mdiTile);
         menu->addAction(d->mdiCascade);
     }
     menu->addSeparator();
     menu->addAction(d->mdiNextWindow);
     menu->addAction(d->mdiPreviousWindow);
     menu->addSeparator();
 
     QList<QMdiSubWindow *> windows = d->mdiArea->subWindowList();
     for (int i = 0; i < windows.size(); ++i) {
         QPointer<KisView>child = qobject_cast<KisView*>(windows.at(i)->widget());
         if (child && child->document()) {
             QString text;
             if (i < 9) {
                 text = i18n("&%1 %2", i + 1, child->document()->url().toDisplayString());
             }
             else {
                 text = i18n("%1 %2", i + 1, child->document()->url().toDisplayString());
             }
 
             QAction *action  = menu->addAction(text);
             action->setIcon(qApp->windowIcon());
             action->setCheckable(true);
             action->setChecked(child == activeKisView());
             connect(action, SIGNAL(triggered()), d->windowMapper, SLOT(map()));
             d->windowMapper->setMapping(action, windows.at(i));
         }
     }
 
     updateCaption();
 }
 
 void KisMainWindow::setActiveSubWindow(QWidget *window)
 {
     if (!window) return;
     QMdiSubWindow *subwin = qobject_cast<QMdiSubWindow *>(window);
     //dbgKrita << "setActiveSubWindow();" << subwin << d->activeSubWindow;
 
     if (subwin && subwin != d->activeSubWindow) {
         KisView *view = qobject_cast<KisView *>(subwin->widget());
         //dbgKrita << "\t" << view << activeView();
         if (view && view != activeView()) {
              d->mdiArea->setActiveSubWindow(subwin);
             setActiveView(view);
         }
         d->activeSubWindow = subwin;
     }
     updateWindowMenu();
     d->actionManager()->updateGUI();
 }
 
 void KisMainWindow::configChanged()
 {
     KisConfig cfg;
     QMdiArea::ViewMode viewMode = (QMdiArea::ViewMode)cfg.readEntry<int>("mdi_viewmode", (int)QMdiArea::TabbedView);
     d->mdiArea->setViewMode(viewMode);
     Q_FOREACH (QMdiSubWindow *subwin, d->mdiArea->subWindowList()) {
         subwin->setOption(QMdiSubWindow::RubberBandMove, cfg.readEntry<int>("mdi_rubberband", cfg.useOpenGL()));
         subwin->setOption(QMdiSubWindow::RubberBandResize, cfg.readEntry<int>("mdi_rubberband", cfg.useOpenGL()));
     }
 
     KConfigGroup group( KSharedConfig::openConfig(), "theme");
     d->themeManager->setCurrentTheme(group.readEntry("Theme", "Krita dark"));
     d->actionManager()->updateGUI();
 
     QBrush brush(cfg.getMDIBackgroundColor());
     d->mdiArea->setBackground(brush);
 
     QString backgroundImage = cfg.getMDIBackgroundImage();
     if (backgroundImage != "") {
         QImage image(backgroundImage);
         QBrush brush(image);
         d->mdiArea->setBackground(brush);
     }
 
     d->mdiArea->update();
 }
 
 void KisMainWindow::newView(QObject *document)
 {
     KisDocument *doc = qobject_cast<KisDocument*>(document);
     addViewAndNotifyLoadingCompleted(doc);
     d->actionManager()->updateGUI();
 }
 
 void KisMainWindow::newWindow()
 {
     KisPart::instance()->createMainWindow()->show();
 }
 
 void KisMainWindow::closeCurrentWindow()
 {
     d->mdiArea->currentSubWindow()->close();
     d->actionManager()->updateGUI();
 }
 
 void KisMainWindow::checkSanity()
 {
     // print error if the lcms engine is not available
     if (!KoColorSpaceEngineRegistry::instance()->contains("icc")) {
         // need to wait 1 event since exiting here would not work.
-        m_errorMessage = i18n("The Calligra LittleCMS color management plugin is not installed. Krita will quit now.");
+        m_errorMessage = i18n("The Krita LittleCMS color management plugin is not installed. Krita will quit now.");
         m_dieOnError = true;
         QTimer::singleShot(0, this, SLOT(showErrorAndDie()));
         return;
     }
 
     KisPaintOpPresetResourceServer * rserver = KisResourceServerProvider::instance()->paintOpPresetServer();
     if (rserver->resources().isEmpty()) {
         m_errorMessage = i18n("Krita cannot find any brush presets! Krita will quit now.");
         m_dieOnError = true;
         QTimer::singleShot(0, this, SLOT(showErrorAndDie()));
         return;
     }
 }
 
 void KisMainWindow::showErrorAndDie()
 {
     QMessageBox::critical(0, i18nc("@title:window", "Installation error"), m_errorMessage);
     if (m_dieOnError) {
         exit(10);
     }
 }
 
 void KisMainWindow::showAboutApplication()
 {
     KisAboutApplication dlg(this);
     dlg.exec();
 }
 
 QPointer<KisView>KisMainWindow::activeKisView()
 {
     if (!d->mdiArea) return 0;
     QMdiSubWindow *activeSubWindow = d->mdiArea->activeSubWindow();
     //dbgKrita << "activeKisView" << activeSubWindow;
     if (!activeSubWindow) return 0;
     return qobject_cast<KisView*>(activeSubWindow->widget());
 }
 
 void KisMainWindow::newOptionWidgets(KoCanvasController *controller, const QList<QPointer<QWidget> > &optionWidgetList)
 {
     KIS_ASSERT_RECOVER_NOOP(controller == KoToolManager::instance()->activeCanvasController());
     bool isOurOwnView = false;
 
     Q_FOREACH (QPointer<KisView> view, KisPart::instance()->views()) {
         if (view && view->canvasController() == controller) {
             isOurOwnView = view->mainWindow() == this;
         }
     }
 
     if (!isOurOwnView) return;
 
     Q_FOREACH (QWidget *w, optionWidgetList) {
 #ifdef Q_OS_OSX
         w->setAttribute(Qt::WA_MacSmallSize, true);
 #endif
         w->setFont(KoDockRegistry::dockFont());
     }
 
     if (d->toolOptionsDocker) {
         d->toolOptionsDocker->setOptionWidgets(optionWidgetList);
     }
     else {
         d->viewManager->paintOpBox()->newOptionWidgets(optionWidgetList);
     }
 }
 
 void KisMainWindow::applyDefaultSettings(QPrinter &printer) {
 
     if (!d->activeView) return;
 
     QString title = d->activeView->document()->documentInfo()->aboutInfo("title");
     if (title.isEmpty()) {
         title = d->activeView->document()->url().fileName();
         // strip off the native extension (I don't want foobar.kwd.ps when printing into a file)
         QString extension = KisMimeDatabase::suffixesForMimeType(d->activeView->document()->outputMimeType()).first();
         if (title.endsWith(extension)) {
             title.chop(extension.length());
         }
     }
 
     if (title.isEmpty()) {
         // #139905
         title = i18n("%1 unsaved document (%2)", qApp->applicationDisplayName(),
                      QLocale().toString(QDate::currentDate(), QLocale::ShortFormat));
     }
     printer.setDocName(title);
 }
 
 void KisMainWindow::createActions()
 {
     KisActionManager *actionManager = d->actionManager();
     KisConfig cfg;
 
     actionManager->createStandardAction(KStandardAction::New, this, SLOT(slotFileNew()));
     actionManager->createStandardAction(KStandardAction::Open, this, SLOT(slotFileOpen()));
     actionManager->createStandardAction(KStandardAction::Quit, this, SLOT(slotFileQuit()));
     actionManager->createStandardAction(KStandardAction::ConfigureToolbars, this, SLOT(slotConfigureToolbars()));
     actionManager->createStandardAction(KStandardAction::FullScreen, this, SLOT(viewFullscreen(bool)));
 
     d->recentFiles = KStandardAction::openRecent(this, SLOT(slotFileOpenRecent(QUrl)), actionCollection());
     connect(d->recentFiles, SIGNAL(recentListCleared()), this, SLOT(saveRecentFiles()));
     KSharedConfigPtr configPtr =  KSharedConfig::openConfig();
     d->recentFiles->loadEntries(configPtr->group("RecentFiles"));
 
     d->saveAction = actionManager->createStandardAction(KStandardAction::Save, this, SLOT(slotFileSave()));
     d->saveAction->setActivationFlags(KisAction::ACTIVE_IMAGE);
 
     d->saveActionAs = actionManager->createStandardAction(KStandardAction::SaveAs, this, SLOT(slotFileSaveAs()));
     d->saveActionAs->setActivationFlags(KisAction::ACTIVE_IMAGE);
 
 //    d->printAction = actionManager->createStandardAction(KStandardAction::Print, this, SLOT(slotFilePrint()));
 //    d->printAction->setActivationFlags(KisAction::ACTIVE_IMAGE);
 
 //    d->printActionPreview = actionManager->createStandardAction(KStandardAction::PrintPreview, this, SLOT(slotFilePrintPreview()));
 //    d->printActionPreview->setActivationFlags(KisAction::ACTIVE_IMAGE);
 
     d->undo = actionManager->createStandardAction(KStandardAction::Undo, this, SLOT(undo()));
     d->undo ->setActivationFlags(KisAction::ACTIVE_IMAGE);
 
     d->redo = actionManager->createStandardAction(KStandardAction::Redo, this, SLOT(redo()));
     d->redo->setActivationFlags(KisAction::ACTIVE_IMAGE);
 
 //    d->exportPdf  = actionManager->createAction("file_export_pdf");
 //    connect(d->exportPdf, SIGNAL(triggered()), this, SLOT(exportToPdf()));
 
     d->importAnimation  = actionManager->createAction("file_import_animation");
     connect(d->importAnimation, SIGNAL(triggered()), this, SLOT(importAnimation()));
 
     d->closeAll = actionManager->createAction("file_close_all");
     connect(d->closeAll, SIGNAL(triggered()), this, SLOT(slotFileCloseAll()));
 
 //    d->reloadFile  = actionManager->createAction("file_reload_file");
 //    d->reloadFile->setActivationFlags(KisAction::CURRENT_IMAGE_MODIFIED);
 //    connect(d->reloadFile, SIGNAL(triggered(bool)), this, SLOT(slotReloadFile()));
 
     d->importFile  = actionManager->createAction("file_import_file");
     connect(d->importFile, SIGNAL(triggered(bool)), this, SLOT(slotImportFile()));
 
     d->exportFile  = actionManager->createAction("file_export_file");
     connect(d->exportFile, SIGNAL(triggered(bool)), this, SLOT(slotExportFile()));
 
     /* The following entry opens the document information dialog.  Since the action is named so it
         intends to show data this entry should not have a trailing ellipses (...).  */
     d->showDocumentInfo  = actionManager->createAction("file_documentinfo");
     connect(d->showDocumentInfo, SIGNAL(triggered(bool)), this, SLOT(slotDocumentInfo()));
 
 
     d->themeManager->setThemeMenuAction(new KActionMenu(i18nc("@action:inmenu", "&Themes"), this));
     d->themeManager->registerThemeActions(actionCollection());
     connect(d->themeManager, SIGNAL(signalThemeChanged()), this, SLOT(slotThemeChanged()));
 
 
     d->toggleDockers = actionManager->createAction("view_toggledockers");
     cfg.showDockers(true);
     d->toggleDockers->setChecked(true);
     connect(d->toggleDockers, SIGNAL(toggled(bool)), SLOT(toggleDockersVisibility(bool)));
 
     d->toggleDockerTitleBars = actionManager->createAction("view_toggledockertitlebars");
     d->toggleDockerTitleBars->setChecked(cfg.showDockerTitleBars());
     connect(d->toggleDockerTitleBars, SIGNAL(toggled(bool)), SLOT(showDockerTitleBars(bool)));
 
     actionCollection()->addAction("settings_dockers_menu", d->dockWidgetMenu);
     actionCollection()->addAction("window", d->windowMenu);
 
     d->mdiCascade = actionManager->createAction("windows_cascade");
     connect(d->mdiCascade, SIGNAL(triggered()), d->mdiArea, SLOT(cascadeSubWindows()));
 
     d->mdiTile = actionManager->createAction("windows_tile");
     connect(d->mdiTile, SIGNAL(triggered()), d->mdiArea, SLOT(tileSubWindows()));
 
     d->mdiNextWindow = actionManager->createAction("windows_next");
     connect(d->mdiNextWindow, SIGNAL(triggered()), d->mdiArea, SLOT(activateNextSubWindow()));
 
     d->mdiPreviousWindow = actionManager->createAction("windows_previous");
     connect(d->mdiPreviousWindow, SIGNAL(triggered()), d->mdiArea, SLOT(activatePreviousSubWindow()));
 
     d->newWindow = actionManager->createAction("view_newwindow");
     connect(d->newWindow, SIGNAL(triggered(bool)), this, SLOT(newWindow()));
 
     d->close = actionManager->createAction("file_close");
     connect(d->close, SIGNAL(triggered()), SLOT(closeCurrentWindow()));
 
     actionManager->createStandardAction(KStandardAction::Preferences, this, SLOT(slotPreferences()));
 
     for (int i = 0; i < 2; i++) {
         d->expandingSpacers[i] = new KisAction(i18n("Expanding Spacer"));
         d->expandingSpacers[i]->setDefaultWidget(new QWidget(this));
         d->expandingSpacers[i]->defaultWidget()->setSizePolicy(QSizePolicy::Expanding, QSizePolicy::Expanding);
         actionManager->addAction(QString("expanding_spacer_%1").arg(i), d->expandingSpacers[i]);
     }
 }
 
 void KisMainWindow::applyToolBarLayout()
 {
     const bool isPlastiqueStyle = style()->objectName() == "plastique";
 
     Q_FOREACH (KToolBar *toolBar, toolBars()) {
         toolBar->layout()->setSpacing(4);
         if (isPlastiqueStyle) {
             toolBar->setContentsMargins(0, 0, 0, 2);
         }
         //Hide text for buttons with an icon in the toolbar
         Q_FOREACH (QAction *ac, toolBar->actions()){
             if (ac->icon().pixmap(QSize(1,1)).isNull() == false){
                 ac->setPriority(QAction::LowPriority);
             }else {
                 ac->setIcon(QIcon());
             }
         }
     }
 }
 
 void KisMainWindow::initializeGeometry()
 {
     // if the user didn's specify the geometry on the command line (does anyone do that still?),
     // we first figure out some good default size and restore the x,y position. See bug 285804Z.
     KConfigGroup cfg( KSharedConfig::openConfig(), "MainWindow");
     QByteArray geom = QByteArray::fromBase64(cfg.readEntry("ko_geometry", QByteArray()));
     if (!restoreGeometry(geom)) {
         const int scnum = QApplication::desktop()->screenNumber(parentWidget());
         QRect desk = QApplication::desktop()->availableGeometry(scnum);
         // if the desktop is virtual then use virtual screen size
         if (QApplication::desktop()->isVirtualDesktop()) {
             desk = QApplication::desktop()->availableGeometry(QApplication::desktop()->screen(scnum));
         }
 
         quint32 x = desk.x();
         quint32 y = desk.y();
         quint32 w = 0;
         quint32 h = 0;
 
         // Default size -- maximize on small screens, something useful on big screens
         const int deskWidth = desk.width();
         if (deskWidth > 1024) {
             // a nice width, and slightly less than total available
             // height to componensate for the window decs
             w = (deskWidth / 3) * 2;
             h = (desk.height() / 3) * 2;
         }
         else {
             w = desk.width();
             h = desk.height();
         }
 
         x += (desk.width() - w) / 2;
         y += (desk.height() - h) / 2;
 
         move(x,y);
         setGeometry(geometry().x(), geometry().y(), w, h);
     }
     restoreWorkspace(QByteArray::fromBase64(cfg.readEntry("ko_windowstate", QByteArray())));
 }
 
 void KisMainWindow::showManual()
 {
     QDesktopServices::openUrl(QUrl("https://docs.krita.org"));
 }
 
 void KisMainWindow::showDockerTitleBars(bool show)
 {
     Q_FOREACH (QDockWidget *dock, dockWidgets()) {
         if (dock->titleBarWidget()) {
             const bool isCollapsed = (dock->widget() && dock->widget()->isHidden()) || !dock->widget();
             dock->titleBarWidget()->setVisible(show || (dock->isFloating() && isCollapsed));
         }
     }
 
     KisConfig cfg;
     cfg.setShowDockerTitleBars(show);
 }
 
 void KisMainWindow::moveEvent(QMoveEvent *e)
 {
     if (qApp->desktop()->screenNumber(this) != qApp->desktop()->screenNumber(e->oldPos())) {
         KisConfigNotifier::instance()->notifyConfigChanged();
     }
 }
 
 
 
 #include <moc_KisMainWindow.cpp>
diff --git a/libs/ui/canvas/kis_guides_manager.cpp b/libs/ui/canvas/kis_guides_manager.cpp
index bd251f4271..2ebf8150ac 100644
--- a/libs/ui/canvas/kis_guides_manager.cpp
+++ b/libs/ui/canvas/kis_guides_manager.cpp
@@ -1,743 +1,765 @@
 /*
  *  Copyright (c) 2016 Dmitry Kazakov <dimula73@gmail.com>
  *
  *  This program is free software; you can redistribute it and/or modify
  *  it under the terms of the GNU General Public License as published by
  *  the Free Software Foundation; either version 2 of the License, or
  *  (at your option) any later version.
  *
  *  This program is distributed in the hope that it will be useful,
  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  *  GNU General Public License for more details.
  *
  *  You should have received a copy of the GNU General Public License
  *  along with this program; if not, write to the Free Software
  *  Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
  */
 
 #include "kis_guides_manager.h"
 
 #include <QMenu>
 #include <QGuiApplication>
 #include "kis_guides_decoration.h"
 #include <KoRuler.h>
 #include "kis_guides_config.h"
 #include "kis_action_manager.h"
 #include "kis_action.h"
 #include "kis_signals_blocker.h"
 #include "input/kis_input_manager.h"
 #include "kis_coordinates_converter.h"
 #include "kis_zoom_manager.h"
 #include "kis_signal_auto_connection.h"
 #include "KisViewManager.h"
 #include "KisDocument.h"
 #include "kis_algebra_2d.h"
 #include <KoSnapGuide.h>
 #include "kis_snap_line_strategy.h"
 #include "kis_change_guides_command.h"
 #include "kis_snap_config.h"
 #include "kis_coordinates_converter.h"
 #include  "kis_canvas2.h"
+#include "kis_signal_compressor.h"
 
 struct KisGuidesManager::Private
 {
     Private(KisGuidesManager *_q)
         : q(_q),
           decoration(0),
           invalidGuide(Qt::Horizontal, -1),
           currentGuide(invalidGuide),
           cursorSwitched(false),
-          dragStartGuidePos(0) {}
+          dragStartGuidePos(0),
+          updateDocumentCompressor(40, KisSignalCompressor::FIRST_ACTIVE),
+          shouldSetModified(false) {}
 
     KisGuidesManager *q;
 
     KisGuidesDecoration *decoration;
     KisGuidesConfig guidesConfig;
     KisSnapConfig snapConfig;
     QPointer<KisView> view;
 
     typedef QPair<Qt::Orientation, int> GuideHandle;
 
     GuideHandle findGuide(const QPointF &docPos);
     bool isGuideValid(const GuideHandle &h);
     qreal guideValue(const GuideHandle &h);
     void setGuideValue(const GuideHandle &h, qreal value);
     void deleteGuide(const GuideHandle &h);
     const GuideHandle invalidGuide;
 
     bool updateCursor(const QPointF &docPos);
 
     void initDragStart(const GuideHandle &guide,
                        const QPointF &dragStart,
                        qreal guideValue,
                        bool snapToStart);
     bool mouseMoveHandler(const QPointF &docPos, Qt::KeyboardModifiers modifiers);
     bool mouseReleaseHandler(const QPointF &docPos);
 
     void updateSnappingStatus(const KisGuidesConfig &value);
     QPointF alignToPixels(const QPointF docPoint);
     QPointF getDocPointFromEvent(QEvent *event);
     Qt::MouseButton getButtonFromEvent(QEvent *event);
     QAction* createShortenedAction(const QString &text, const QString &parentId, QObject *parent);
     void syncAction(const QString &actionName, bool value);
 
     GuideHandle currentGuide;
 
     bool cursorSwitched;
     QCursor oldCursor;
 
     QPointF dragStartDoc;
     QPointF dragPointerOffset;
     qreal dragStartGuidePos;
 
     KisSignalAutoConnectionsStore viewConnections;
+
+    KisSignalCompressor updateDocumentCompressor;
+    bool shouldSetModified;
 };
 
 KisGuidesManager::KisGuidesManager(QObject *parent)
     : QObject(parent),
       m_d(new Private(this))
 {
+    connect(&m_d->updateDocumentCompressor, SIGNAL(timeout()), SLOT(slotUploadConfigToDocument()));
 }
 
 KisGuidesManager::~KisGuidesManager()
 {
 }
 
 void KisGuidesManager::setGuidesConfig(const KisGuidesConfig &config)
 {
     if (config == m_d->guidesConfig) return;
     setGuidesConfigImpl(config, true);
 }
 
 void KisGuidesManager::slotDocumentRequestedConfig(const KisGuidesConfig &config)
 {
     if (config == m_d->guidesConfig) return;
     setGuidesConfigImpl(config, false);
 }
 
-void KisGuidesManager::setGuidesConfigImpl(const KisGuidesConfig &value, bool emitModified)
+void KisGuidesManager::slotUploadConfigToDocument()
 {
-    m_d->guidesConfig = value;
-
-    if (m_d->decoration && value != m_d->decoration->guidesConfig()) {
-        m_d->decoration->setVisible(value.showGuides());
-        m_d->decoration->setGuidesConfig(value);
-    }
+    const KisGuidesConfig &value = m_d->guidesConfig;
 
     KisDocument *doc = m_d->view ? m_d->view->document() : 0;
     if (doc) {
         KisSignalsBlocker b(doc);
 
-        if (emitModified) {
+        if (m_d->shouldSetModified) {
             KUndo2Command *cmd = new KisChangeGuidesCommand(doc, value);
             doc->addCommand(cmd);
         } else {
             doc->setGuidesConfig(value);
         }
 
         value.saveStaticData();
     }
 
+    m_d->shouldSetModified = false;
+}
+
+void KisGuidesManager::setGuidesConfigImpl(const KisGuidesConfig &value, bool emitModified)
+{
+    m_d->guidesConfig = value;
+
+    if (m_d->decoration && value != m_d->decoration->guidesConfig()) {
+        m_d->decoration->setVisible(value.showGuides());
+        m_d->decoration->setGuidesConfig(value);
+    }
+
+    m_d->shouldSetModified |= emitModified;
+    m_d->updateDocumentCompressor.start();
+
     const bool shouldFilterEvent =
         value.showGuides() && !value.lockGuides() && value.hasGuides();
 
     attachEventFilterImpl(shouldFilterEvent);
     syncActionsStatus();
 
     if (!m_d->isGuideValid(m_d->currentGuide)) {
         m_d->updateSnappingStatus(value);
     }
 
     emit sigRequestUpdateGuidesConfig(m_d->guidesConfig);
 }
 
 void KisGuidesManager::attachEventFilterImpl(bool value)
 {
     if (!m_d->view) return;
 
     KisInputManager *inputManager = m_d->view->globalInputManager();
     if (inputManager) {
         if (value) {
             inputManager->attachPriorityEventFilter(this, 100);
         } else {
             inputManager->detachPriorityEventFilter(this);
         }
     }
 }
 
 void KisGuidesManager::Private::syncAction(const QString &actionName, bool value)
 {
     KisActionManager *actionManager = view->viewManager()->actionManager();
     KisAction *action = actionManager->actionByName(actionName);
     KIS_ASSERT_RECOVER_RETURN(action);
     KisSignalsBlocker b(action);
     action->setChecked(value);
 }
 
 void KisGuidesManager::syncActionsStatus()
 {
     if (!m_d->view) return;
 
     m_d->syncAction("view_show_guides", m_d->guidesConfig.showGuides());
     m_d->syncAction("view_lock_guides", m_d->guidesConfig.lockGuides());
     m_d->syncAction("view_snap_to_guides", m_d->guidesConfig.snapToGuides());
 
     m_d->syncAction("view_snap_orthogonal", m_d->snapConfig.orthogonal());
     m_d->syncAction("view_snap_node", m_d->snapConfig.node());
     m_d->syncAction("view_snap_extension", m_d->snapConfig.extension());
     m_d->syncAction("view_snap_intersection", m_d->snapConfig.intersection());
     m_d->syncAction("view_snap_bounding_box", m_d->snapConfig.boundingBox());
     m_d->syncAction("view_snap_image_bounds", m_d->snapConfig.imageBounds());
     m_d->syncAction("view_snap_image_center", m_d->snapConfig.imageCenter());
 }
 
 void KisGuidesManager::Private::updateSnappingStatus(const KisGuidesConfig &value)
 {
     if (!view) return;
 
     KoSnapGuide *snapGuide = view->canvasBase()->snapGuide();
     KisSnapLineStrategy *guidesSnap = 0;
 
     if (value.snapToGuides()) {
         guidesSnap = new KisSnapLineStrategy(KoSnapGuide::GuideLineSnapping);
         guidesSnap->setHorizontalLines(value.horizontalGuideLines());
         guidesSnap->setVerticalLines(value.verticalGuideLines());
     }
 
     snapGuide->overrideSnapStrategy(KoSnapGuide::GuideLineSnapping, guidesSnap);
     snapGuide->enableSnapStrategy(KoSnapGuide::GuideLineSnapping, guidesSnap);
 
     snapGuide->enableSnapStrategy(KoSnapGuide::OrthogonalSnapping, snapConfig.orthogonal());
     snapGuide->enableSnapStrategy(KoSnapGuide::NodeSnapping, snapConfig.node());
     snapGuide->enableSnapStrategy(KoSnapGuide::ExtensionSnapping, snapConfig.extension());
     snapGuide->enableSnapStrategy(KoSnapGuide::IntersectionSnapping, snapConfig.intersection());
     snapGuide->enableSnapStrategy(KoSnapGuide::BoundingBoxSnapping, snapConfig.boundingBox());
     snapGuide->enableSnapStrategy(KoSnapGuide::DocumentBoundsSnapping, snapConfig.imageBounds());
     snapGuide->enableSnapStrategy(KoSnapGuide::DocumentCenterSnapping, snapConfig.imageCenter());
 
     snapConfig.saveStaticData();
 }
 
 bool KisGuidesManager::showGuides() const
 {
     return m_d->guidesConfig.showGuides();
 }
 
 void KisGuidesManager::setShowGuides(bool value)
 {
     m_d->guidesConfig.setShowGuides(value);
     setGuidesConfigImpl(m_d->guidesConfig);
 }
 
 bool KisGuidesManager::lockGuides() const
 {
     return m_d->guidesConfig.lockGuides();
 }
 
 void KisGuidesManager::setLockGuides(bool value)
 {
     m_d->guidesConfig.setLockGuides(value);
     setGuidesConfigImpl(m_d->guidesConfig);
 }
 
 bool KisGuidesManager::snapToGuides() const
 {
     return m_d->guidesConfig.snapToGuides();
 }
 
 void KisGuidesManager::setSnapToGuides(bool value)
 {
     m_d->guidesConfig.setSnapToGuides(value);
     setGuidesConfigImpl(m_d->guidesConfig);
 }
 
 void KisGuidesManager::setup(KisActionManager *actionManager)
 {
     KisAction *action = 0;
 
     action = actionManager->createAction("view_show_guides");
     connect(action, SIGNAL(toggled(bool)), this, SLOT(setShowGuides(bool)));
 
     action = actionManager->createAction("view_lock_guides");
     connect(action, SIGNAL(toggled(bool)), this, SLOT(setLockGuides(bool)));
 
     action = actionManager->createAction("view_snap_to_guides");
     connect(action, SIGNAL(toggled(bool)), this, SLOT(setSnapToGuides(bool)));
 
     action = actionManager->createAction("show_snap_options_popup");
     connect(action, SIGNAL(triggered()), this, SLOT(slotShowSnapOptions()));
 
     action = actionManager->createAction("view_snap_orthogonal");
     connect(action, SIGNAL(toggled(bool)), this, SLOT(setSnapOrthogonal(bool)));
 
     action = actionManager->createAction("view_snap_node");
     connect(action, SIGNAL(toggled(bool)), this, SLOT(setSnapNode(bool)));
 
     action = actionManager->createAction("view_snap_extension");
     connect(action, SIGNAL(toggled(bool)), this, SLOT(setSnapExtension(bool)));
 
     action = actionManager->createAction("view_snap_intersection");
     connect(action, SIGNAL(toggled(bool)), this, SLOT(setSnapIntersection(bool)));
 
     action = actionManager->createAction("view_snap_bounding_box");
     connect(action, SIGNAL(toggled(bool)), this, SLOT(setSnapBoundingBox(bool)));
 
     action = actionManager->createAction("view_snap_image_bounds");
     connect(action, SIGNAL(toggled(bool)), this, SLOT(setSnapImageBounds(bool)));
 
     action = actionManager->createAction("view_snap_image_center");
     connect(action, SIGNAL(toggled(bool)), this, SLOT(setSnapImageCenter(bool)));
 
     m_d->updateSnappingStatus(m_d->guidesConfig);
     syncActionsStatus();
 }
 
 void KisGuidesManager::setView(QPointer<KisView> view)
 {
     if (m_d->view) {
         KoSnapGuide *snapGuide = m_d->view->canvasBase()->snapGuide();
         snapGuide->overrideSnapStrategy(KoSnapGuide::GuideLineSnapping, 0);
         snapGuide->enableSnapStrategy(KoSnapGuide::GuideLineSnapping, false);
 
+        if (m_d->updateDocumentCompressor.isActive()) {
+            m_d->updateDocumentCompressor.stop();
+            slotUploadConfigToDocument();
+        }
+
         m_d->decoration = 0;
         m_d->viewConnections.clear();
         attachEventFilterImpl(false);
     }
 
     m_d->view = view;
 
     if (m_d->view) {
         KisGuidesDecoration* decoration = qobject_cast<KisGuidesDecoration*>(m_d->view->canvasBase()->decoration(GUIDES_DECORATION_ID).data());
         if (!decoration) {
             decoration = new KisGuidesDecoration(m_d->view);
             m_d->view->canvasBase()->addDecoration(decoration);
         }
         m_d->decoration = decoration;
 
         m_d->guidesConfig = m_d->view->document()->guidesConfig();
         setGuidesConfigImpl(m_d->guidesConfig, false);
 
         m_d->viewConnections.addUniqueConnection(
             m_d->view->zoomManager()->horizontalRuler(), SIGNAL(guideCreationInProgress(Qt::Orientation, const QPoint&)),
             this, SLOT(slotGuideCreationInProgress(Qt::Orientation, const QPoint&)));
 
         m_d->viewConnections.addUniqueConnection(
             m_d->view->zoomManager()->horizontalRuler(), SIGNAL(guideCreationFinished(Qt::Orientation, const QPoint&)),
             this, SLOT(slotGuideCreationFinished(Qt::Orientation, const QPoint&)));
 
         m_d->viewConnections.addUniqueConnection(
             m_d->view->zoomManager()->verticalRuler(), SIGNAL(guideCreationInProgress(Qt::Orientation, const QPoint&)),
             this, SLOT(slotGuideCreationInProgress(Qt::Orientation, const QPoint&)));
 
         m_d->viewConnections.addUniqueConnection(
             m_d->view->zoomManager()->verticalRuler(), SIGNAL(guideCreationFinished(Qt::Orientation, const QPoint&)),
             this, SLOT(slotGuideCreationFinished(Qt::Orientation, const QPoint&)));
 
         m_d->viewConnections.addUniqueConnection(
             m_d->view->document(), SIGNAL(sigGuidesConfigChanged(const KisGuidesConfig &)),
             this, SLOT(slotDocumentRequestedConfig(const KisGuidesConfig &)));
     }
 }
 
 KisGuidesManager::Private::GuideHandle
 KisGuidesManager::Private::findGuide(const QPointF &docPos)
 {
     const int snapRadius = 16;
 
     GuideHandle nearestGuide = invalidGuide;
     qreal nearestRadius = std::numeric_limits<int>::max();
 
     for (int i = 0; i < guidesConfig.horizontalGuideLines().size(); i++) {
         const qreal guide = guidesConfig.horizontalGuideLines()[i];
         const qreal radius = qAbs(docPos.y() - guide);
         if (radius < snapRadius && radius < nearestRadius) {
             nearestGuide = GuideHandle(Qt::Horizontal, i);
             nearestRadius = radius;
         }
     }
 
     for (int i = 0; i < guidesConfig.verticalGuideLines().size(); i++) {
         const qreal guide = guidesConfig.verticalGuideLines()[i];
         const qreal radius = qAbs(docPos.x() - guide);
         if (radius < snapRadius && radius < nearestRadius) {
             nearestGuide = GuideHandle(Qt::Vertical, i);
             nearestRadius = radius;
         }
     }
 
     return nearestGuide;
 }
 
 bool KisGuidesManager::Private::isGuideValid(const GuideHandle &h)
 {
     return h.second >= 0;
 }
 
 qreal KisGuidesManager::Private::guideValue(const GuideHandle &h)
 {
     return h.first == Qt::Horizontal ?
         guidesConfig.horizontalGuideLines()[h.second] :
         guidesConfig.verticalGuideLines()[h.second];
 }
 
 void KisGuidesManager::Private::setGuideValue(const GuideHandle &h, qreal value)
 {
     if (h.first == Qt::Horizontal) {
         QList<qreal> guides = guidesConfig.horizontalGuideLines();
         guides[h.second] = value;
         guidesConfig.setHorizontalGuideLines(guides);
     } else {
         QList<qreal> guides = guidesConfig.verticalGuideLines();
         guides[h.second] = value;
         guidesConfig.setVerticalGuideLines(guides);
     }
 }
 
 void KisGuidesManager::Private::deleteGuide(const GuideHandle &h)
 {
     if (h.first == Qt::Horizontal) {
         QList<qreal> guides = guidesConfig.horizontalGuideLines();
         guides.removeAt(h.second);
         guidesConfig.setHorizontalGuideLines(guides);
     } else {
         QList<qreal> guides = guidesConfig.verticalGuideLines();
         guides.removeAt(h.second);
         guidesConfig.setVerticalGuideLines(guides);
     }
 }
 
 bool KisGuidesManager::Private::updateCursor(const QPointF &docPos)
 {
     KisCanvas2 *canvas = view->canvasBase();
 
     const GuideHandle guide = findGuide(docPos);
     const bool guideValid = isGuideValid(guide);
 
     if (guideValid && !cursorSwitched) {
         oldCursor = canvas->canvasWidget()->cursor();
     }
 
     if (guideValid) {
         cursorSwitched = true;
         QCursor newCursor = guide.first == Qt::Horizontal ?
             Qt::SizeVerCursor : Qt::SizeHorCursor;
         canvas->canvasWidget()->setCursor(newCursor);
     }
 
     if (!guideValid && cursorSwitched) {
         canvas->canvasWidget()->setCursor(oldCursor);
         cursorSwitched = false;
     }
 
     return guideValid;
 }
 
 void KisGuidesManager::Private::initDragStart(const GuideHandle &guide,
                                               const QPointF &dragStart,
                                               qreal guideValue,
                                               bool snapToStart)
 {
     currentGuide = guide;
     dragStartDoc = dragStart;
     dragStartGuidePos = guideValue;
     dragPointerOffset =
         guide.first == Qt::Horizontal ?
         QPointF(0, dragStartGuidePos - dragStartDoc.y()) :
         QPointF(dragStartGuidePos - dragStartDoc.x(), 0);
 
     KoSnapGuide *snapGuide = view->canvasBase()->snapGuide();
     snapGuide->reset();
 
     if (snapToStart) {
         KisSnapLineStrategy *strategy = new KisSnapLineStrategy();
         strategy->addLine(guide.first, guideValue);
         snapGuide->addCustomSnapStrategy(strategy);
     }
 }
 
 QPointF KisGuidesManager::Private::alignToPixels(const QPointF docPoint)
 {
     KisCanvas2 *canvas = view->canvasBase();
     const KisCoordinatesConverter *converter = canvas->coordinatesConverter();
     QPoint imagePoint = converter->documentToImage(docPoint).toPoint();
     return converter->imageToDocument(imagePoint);
 }
 
 bool KisGuidesManager::Private::mouseMoveHandler(const QPointF &docPos, Qt::KeyboardModifiers modifiers)
 {
     if (isGuideValid(currentGuide)) {
         KoSnapGuide *snapGuide = view->canvasBase()->snapGuide();
         const QPointF snappedPos = snapGuide->snap(docPos, dragPointerOffset, modifiers);
         const QPointF offset = snappedPos - dragStartDoc;
         const qreal newValue = dragStartGuidePos +
             (currentGuide.first == Qt::Horizontal ?
              offset.y() : offset.x());
 
         setGuideValue(currentGuide, newValue);
         q->setGuidesConfigImpl(guidesConfig);
 
     }
 
     return updateCursor(docPos);
 }
 
 bool KisGuidesManager::Private::mouseReleaseHandler(const QPointF &docPos)
 {
     bool result = false;
     KisCanvas2 *canvas = view->canvasBase();
     const KisCoordinatesConverter *converter = canvas->coordinatesConverter();
 
     if (isGuideValid(currentGuide)) {
         const QRectF docRect = converter->imageRectInDocumentPixels();
         // TODO: enable work rect after we fix painting guides
         //       outside canvas in openGL mode
         const QRectF workRect = KisAlgebra2D::blowRect(docRect, 0 /*0.2*/);
         if (!workRect.contains(docPos)) {
             deleteGuide(currentGuide);
             q->setGuidesConfigImpl(guidesConfig);
 
             /**
              * When we delete a guide, it might happen that we are
              * delting the last guide. Therefore we should eat the
              * corresponding event so that the event filter would stop
              * the filter processing.
              */
             result = true;
         }
 
         currentGuide = invalidGuide;
         dragStartDoc = QPointF();
         dragPointerOffset = QPointF();
         dragStartGuidePos = 0;
 
         KoSnapGuide *snapGuide = view->canvasBase()->snapGuide();
         snapGuide->reset();
 
         updateSnappingStatus(guidesConfig);
     }
 
     return updateCursor(docPos) | result;
 }
 
 QPointF KisGuidesManager::Private::getDocPointFromEvent(QEvent *event)
 {
     QPointF result;
 
     KisCanvas2 *canvas = view->canvasBase();
     const KisCoordinatesConverter *converter = canvas->coordinatesConverter();
 
     if (event->type() == QEvent::MouseMove ||
         event->type() == QEvent::MouseButtonPress ||
         event->type() == QEvent::MouseButtonRelease) {
 
         QMouseEvent *mouseEvent = static_cast<QMouseEvent*>(event);
         result = alignToPixels(converter->widgetToDocument(mouseEvent->pos()));
 
     } else if (event->type() == QEvent::TabletMove ||
                event->type() == QEvent::TabletPress ||
                event->type() == QEvent::TabletRelease) {
 
         QTabletEvent *tabletEvent = static_cast<QTabletEvent*>(event);
         result = alignToPixels(converter->widgetToDocument(tabletEvent->pos()));
     }
 
     return result;
 }
 
 Qt::MouseButton KisGuidesManager::Private::getButtonFromEvent(QEvent *event)
 {
     Qt::MouseButton button = Qt::NoButton;
 
     if (event->type() == QEvent::MouseMove ||
         event->type() == QEvent::MouseButtonPress ||
         event->type() == QEvent::MouseButtonRelease) {
 
         QMouseEvent *mouseEvent = static_cast<QMouseEvent*>(event);
         button = mouseEvent->button();
 
     } else if (event->type() == QEvent::TabletMove ||
                event->type() == QEvent::TabletPress ||
                event->type() == QEvent::TabletRelease) {
 
         QTabletEvent *tabletEvent = static_cast<QTabletEvent*>(event);
         button = tabletEvent->button();
     }
 
     return button;
 }
 
 bool KisGuidesManager::eventFilter(QObject *obj, QEvent *event)
 {
     if (!m_d->view || obj != m_d->view->canvasBase()->canvasWidget()) return false;
 
     bool retval = false;
 
     switch (event->type()) {
     case QEvent::Enter:
     case QEvent::Leave:
     case QEvent::TabletMove:
     case QEvent::MouseMove: {
         const QPointF docPos = m_d->getDocPointFromEvent(event);
         const Qt::KeyboardModifiers modifiers = qApp->keyboardModifiers();
         retval = m_d->mouseMoveHandler(docPos, modifiers);
 
         break;
     }
     case QEvent::TabletPress:
     case QEvent::MouseButtonPress: {
         if (m_d->getButtonFromEvent(event) != Qt::LeftButton) break;
 
         const QPointF docPos = m_d->getDocPointFromEvent(event);
         const Private::GuideHandle guide = m_d->findGuide(docPos);
         const bool guideValid = m_d->isGuideValid(guide);
 
         if (guideValid) {
             m_d->initDragStart(guide, docPos, m_d->guideValue(guide), true);
         }
 
         retval = m_d->updateCursor(docPos);
 
         break;
     }
     case QEvent::TabletRelease:
     case QEvent::MouseButtonRelease: {
         if (m_d->getButtonFromEvent(event) != Qt::LeftButton) break;
 
         const QPointF docPos = m_d->getDocPointFromEvent(event);
         retval = m_d->mouseReleaseHandler(docPos);
 
         break;
     }
     default:
         break;
     }
 
     return !retval ? QObject::eventFilter(obj, event) : true;
 }
 
 void KisGuidesManager::slotGuideCreationInProgress(Qt::Orientation orientation, const QPoint &globalPos)
 {
     if (m_d->guidesConfig.lockGuides()) return;
 
     KisCanvas2 *canvas = m_d->view->canvasBase();
     const KisCoordinatesConverter *converter = canvas->coordinatesConverter();
     const QPointF widgetPos = canvas->canvasWidget()->mapFromGlobal(globalPos);
     const QPointF docPos = m_d->alignToPixels(converter->widgetToDocument(widgetPos));
 
     if (m_d->isGuideValid(m_d->currentGuide)) {
         const Qt::KeyboardModifiers modifiers = qApp->keyboardModifiers();
         m_d->mouseMoveHandler(docPos, modifiers);
     } else {
         m_d->guidesConfig.setShowGuides(true);
 
         if (orientation == Qt::Horizontal) {
             QList<qreal> guides = m_d->guidesConfig.horizontalGuideLines();
             guides.append(docPos.y());
             m_d->currentGuide.first = orientation;
             m_d->currentGuide.second = guides.size() - 1;
             m_d->guidesConfig.setHorizontalGuideLines(guides);
             m_d->initDragStart(m_d->currentGuide, docPos, docPos.y(), false);
         } else {
             QList<qreal> guides = m_d->guidesConfig.verticalGuideLines();
             guides.append(docPos.x());
             m_d->currentGuide.first = orientation;
             m_d->currentGuide.second = guides.size() - 1;
             m_d->guidesConfig.setVerticalGuideLines(guides);
             m_d->initDragStart(m_d->currentGuide, docPos, docPos.x(), false);
         }
 
         setGuidesConfigImpl(m_d->guidesConfig);
     }
 }
 
 void KisGuidesManager::slotGuideCreationFinished(Qt::Orientation orientation, const QPoint &globalPos)
 {
     Q_UNUSED(orientation);
     if (m_d->guidesConfig.lockGuides()) return;
 
     KisCanvas2 *canvas = m_d->view->canvasBase();
     const KisCoordinatesConverter *converter = canvas->coordinatesConverter();
     const QPointF widgetPos = canvas->canvasWidget()->mapFromGlobal(globalPos);
     const QPointF docPos = m_d->alignToPixels(converter->widgetToDocument(widgetPos));
 
     m_d->mouseReleaseHandler(docPos);
 }
 
 QAction* KisGuidesManager::Private::createShortenedAction(const QString &text, const QString &parentId, QObject *parent)
 {
     KisActionManager *actionManager = view->viewManager()->actionManager();
     QAction *action = 0;
     KisAction *parentAction = 0;
 
     action = new QAction(text, parent);
     action->setCheckable(true);
     parentAction = actionManager->actionByName(parentId);
     action->setChecked(parentAction->isChecked());
     connect(action, SIGNAL(toggled(bool)), parentAction, SLOT(setChecked(bool)));
 
     return action;
 }
 
 void KisGuidesManager::slotShowSnapOptions()
 {
     const QPoint pos = QCursor::pos();
     QMenu menu;
 
     menu.addSection(i18n("Snap to:"));
     menu.addAction(m_d->createShortenedAction(i18n("Grid"), "view_snap_to_grid", &menu));
     menu.addAction(m_d->createShortenedAction(i18n("Guides"), "view_snap_to_guides", &menu));
     menu.addAction(m_d->createShortenedAction(i18n("Orthogonal"), "view_snap_orthogonal", &menu));
 
     menu.addAction(m_d->createShortenedAction(i18n("Node"), "view_snap_node", &menu));
     menu.addAction(m_d->createShortenedAction(i18n("Extension"), "view_snap_extension", &menu));
     menu.addAction(m_d->createShortenedAction(i18n("Intersection"), "view_snap_intersection", &menu));
 
     menu.addAction(m_d->createShortenedAction(i18n("Bounding Box"), "view_snap_bounding_box", &menu));
     menu.addAction(m_d->createShortenedAction(i18n("Image Bounds"), "view_snap_image_bounds", &menu));
     menu.addAction(m_d->createShortenedAction(i18n("Image Center"), "view_snap_image_center", &menu));
 
     menu.exec(pos);
 }
 
 void KisGuidesManager::setSnapOrthogonal(bool value)
 {
     m_d->snapConfig.setOrthogonal(value);
     m_d->updateSnappingStatus(m_d->guidesConfig);
 }
 
 void KisGuidesManager::setSnapNode(bool value)
 {
     m_d->snapConfig.setNode(value);
     m_d->updateSnappingStatus(m_d->guidesConfig);
 }
 
 void KisGuidesManager::setSnapExtension(bool value)
 {
     m_d->snapConfig.setExtension(value);
     m_d->updateSnappingStatus(m_d->guidesConfig);
 }
 
 void KisGuidesManager::setSnapIntersection(bool value)
 {
     m_d->snapConfig.setIntersection(value);
     m_d->updateSnappingStatus(m_d->guidesConfig);
 }
 
 void KisGuidesManager::setSnapBoundingBox(bool value)
 {
     m_d->snapConfig.setBoundingBox(value);
     m_d->updateSnappingStatus(m_d->guidesConfig);
 }
 
 void KisGuidesManager::setSnapImageBounds(bool value)
 {
     m_d->snapConfig.setImageBounds(value);
     m_d->updateSnappingStatus(m_d->guidesConfig);
 }
 
 void KisGuidesManager::setSnapImageCenter(bool value)
 {
     m_d->snapConfig.setImageCenter(value);
     m_d->updateSnappingStatus(m_d->guidesConfig);
 }
diff --git a/libs/ui/canvas/kis_guides_manager.h b/libs/ui/canvas/kis_guides_manager.h
index 0046e95fa4..fe9aede60b 100644
--- a/libs/ui/canvas/kis_guides_manager.h
+++ b/libs/ui/canvas/kis_guides_manager.h
@@ -1,81 +1,84 @@
 /*
  *  Copyright (c) 2016 Dmitry Kazakov <dimula73@gmail.com>
  *
  *  This program is free software; you can redistribute it and/or modify
  *  it under the terms of the GNU General Public License as published by
  *  the Free Software Foundation; either version 2 of the License, or
  *  (at your option) any later version.
  *
  *  This program is distributed in the hope that it will be useful,
  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  *  GNU General Public License for more details.
  *
  *  You should have received a copy of the GNU General Public License
  *  along with this program; if not, write to the Free Software
  *  Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
  */
 
 #ifndef __KIS_GUIDES_MANAGER_H
 #define __KIS_GUIDES_MANAGER_H
 
 #include <QScopedPointer>
 #include <QObject>
 #include "kritaui_export.h"
 
 class KisView;
 class KisActionManager;
 class KisCanvasDecoration;
 class KisGuidesConfig;
 
 
 class KRITAUI_EXPORT KisGuidesManager : public QObject
 {
     Q_OBJECT
 public:
     KisGuidesManager(QObject *parent = 0);
     ~KisGuidesManager();
 
     void setup(KisActionManager *actionManager);
     void setView(QPointer<KisView> view);
 
     bool showGuides() const;
     bool lockGuides() const;
     bool snapToGuides() const;
 
     bool eventFilter(QObject *obj, QEvent *event);
 
 Q_SIGNALS:
     void sigRequestUpdateGuidesConfig(const KisGuidesConfig &config);
 
 public Q_SLOTS:
     void setGuidesConfig(const KisGuidesConfig &config);
     void slotDocumentRequestedConfig(const KisGuidesConfig &config);
 
     void setShowGuides(bool value);
     void setLockGuides(bool value);
     void setSnapToGuides(bool value);
 
     void slotGuideCreationInProgress(Qt::Orientation orientation, const QPoint &globalPos);
     void slotGuideCreationFinished(Qt::Orientation orientation, const QPoint &globalPos);
 
     void slotShowSnapOptions();
 
     void setSnapOrthogonal(bool value);
     void setSnapNode(bool value);
     void setSnapExtension(bool value);
     void setSnapIntersection(bool value);
     void setSnapBoundingBox(bool value);
     void setSnapImageBounds(bool value);
     void setSnapImageCenter(bool value);
+
+    void slotUploadConfigToDocument();
+
 private:
     void setGuidesConfigImpl(const KisGuidesConfig &value, bool emitModified = true);
     void attachEventFilterImpl(bool value);
     void syncActionsStatus();
 
 private:
     struct Private;
     const QScopedPointer<Private> m_d;
 };
 
 #endif /* __KIS_GUIDES_MANAGER_H */
diff --git a/libs/ui/dialogs/kis_dlg_image_properties.cc b/libs/ui/dialogs/kis_dlg_image_properties.cc
index ab3b110bbf..7243891c01 100644
--- a/libs/ui/dialogs/kis_dlg_image_properties.cc
+++ b/libs/ui/dialogs/kis_dlg_image_properties.cc
@@ -1,177 +1,177 @@
 /*
  *  Copyright (c) 2004 Boudewijn Rempt <boud@valdyas.org>
  *
  *  This program is free software; you can redistribute it and/or modify
  *  it under the terms of the GNU General Public License as published by
  *  the Free Software Foundation; either version 2 of the License, or
  *  (at your option) any later version.
  *
  *  This program is distributed in the hope that it will be useful,
  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  *  GNU General Public License for more details.
  *
  *  You should have received a copy of the GNU General Public License
  *  along with this program; if not, write to the Free Software
  *  Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
  */
 
 #include "kis_dlg_image_properties.h"
 
 #include <QPushButton>
 #include <QRadioButton>
 #include <QLayout>
 #include <QLabel>
 #include <QSpinBox>
 #include <QSlider>
 #include <QCheckBox>
 #include <QPlainTextEdit>
 #include <QTextEdit>
 
 #include <klocalizedstring.h>
 
 
 #include <KoColorSpace.h>
 #include "KoColorProfile.h"
 #include "KoColorSpaceRegistry.h"
 #include "KoColor.h"
 #include "KoColorConversionTransformation.h"
 #include "KoColorPopupAction.h"
 #include "kis_icon_utils.h"
 #include "KoID.h"
 #include "kis_image.h"
 #include "kis_annotation.h"
 #include "kis_config.h"
 #include "kis_signal_compressor.h"
 #include "widgets/kis_cmb_idlist.h"
 #include "widgets/squeezedcombobox.h"
 #include "kis_layer_utils.h"
 
 KisDlgImageProperties::KisDlgImageProperties(KisImageWSP image, QWidget *parent, const char *name)
     : KoDialog(parent)
 {
     setButtons(Ok | Cancel);
     setDefaultButton(Ok);
     setObjectName(name);
     setCaption(i18n("Image Properties"));
     m_page = new WdgImageProperties(this);
 
     m_image = image;
 
     setMainWidget(m_page);
     resize(m_page->sizeHint());
 
     KisConfig cfg;
 
     m_page->lblWidthValue->setText(QString::number(image->width()));
     m_page->lblHeightValue->setText(QString::number(image->height()));
 
     m_page->lblResolutionValue->setText(QLocale().toString(image->xRes()*72, 2)); // XXX: separate values for x & y?
 
     //Set the canvas projection color:    backgroundColor
     KoColor background = m_image->defaultProjectionColor();
     background.setOpacity(1.0);
     m_page->bnBackgroundColor->setColor(background);
     m_page->sldBackgroundColor->setRange(0.0,1.0,2);
     m_page->sldBackgroundColor->setSingleStep(0.05);
     m_page->sldBackgroundColor->setValue(m_image->defaultProjectionColor().opacityF());
 
     KisSignalCompressor *compressor = new KisSignalCompressor(500 /* ms */, KisSignalCompressor::POSTPONE, this);
     connect(m_page->bnBackgroundColor, SIGNAL(changed(KoColor)), compressor, SLOT(start()));
     connect(m_page->sldBackgroundColor, SIGNAL(valueChanged(qreal)), compressor, SLOT(start()));
     connect(compressor, SIGNAL(timeout()), this, SLOT(setCurrentColor()));
 
     //Set the color space
     m_page->colorSpaceSelector->setCurrentColorSpace(image->colorSpace());
 
     //set the proofing space
     m_proofingConfig = m_image->proofingConfiguration();
-    m_page->proofSpaceSelector->setCurrentColorSpace(KoColorSpaceRegistry::instance()->colorSpace(m_proofingConfig->proofingModel, m_proofingConfig->proofingDepth,m_proofingConfig->proofingProfile));
+    m_page->proofSpaceSelector->setCurrentColorSpace(KoColorSpaceRegistry::instance()->colorSpace(m_proofingConfig->proofingModel, m_proofingConfig->proofingDepth, m_proofingConfig->proofingProfile));
 
     m_page->cmbIntent->setCurrentIndex((int)m_proofingConfig->intent);
 
     m_page->ckbBlackPointComp->setChecked(m_proofingConfig->conversionFlags.testFlag(KoColorConversionTransformation::BlackpointCompensation));
 
     m_page->gamutAlarm->setColor(m_proofingConfig->warningColor);
     m_page->gamutAlarm->setToolTip(i18n("Set color used for warning"));
     m_page->sldAdaptationState->setMaximum(20);
     m_page->sldAdaptationState->setMinimum(0);
     m_page->sldAdaptationState->setValue((int)m_proofingConfig->adaptationState*20);
 
     KisSignalCompressor *softProofConfigCompressor = new KisSignalCompressor(500, KisSignalCompressor::POSTPONE,this);
 
     connect(m_page->gamutAlarm, SIGNAL(changed(KoColor)), softProofConfigCompressor, SLOT(start()));
     connect(m_page->proofSpaceSelector, SIGNAL(colorSpaceChanged(const KoColorSpace*)), softProofConfigCompressor, SLOT(start()));
     connect(m_page->cmbIntent, SIGNAL(currentIndexChanged(int)), softProofConfigCompressor, SLOT(start()));
     connect(m_page->ckbBlackPointComp, SIGNAL(stateChanged(int)), softProofConfigCompressor, SLOT(start()));
     connect(m_page->sldAdaptationState, SIGNAL(valueChanged(int)), softProofConfigCompressor, SLOT(start()));
 
     connect(softProofConfigCompressor, SIGNAL(timeout()), this, SLOT(setProofingConfig()));
 
     //annotations
     vKisAnnotationSP_it beginIt = image->beginAnnotations();
     vKisAnnotationSP_it endIt = image->endAnnotations();
 
     vKisAnnotationSP_it it = beginIt;
     while (it != endIt) {
 
         if (!(*it) || (*it)->type().isEmpty()) {
             dbgFile << "Warning: empty annotation";
             it++;
             continue;
         }
 
         m_page->cmbAnnotations->addItem((*it) -> type());
         it++;
     }
     connect(m_page->cmbAnnotations, SIGNAL(activated(QString)), SLOT(setAnnotation(QString)));
     setAnnotation(m_page->cmbAnnotations->currentText());
 
 }
 
 KisDlgImageProperties::~KisDlgImageProperties()
 {
     delete m_page;
 }
 
 const KoColorSpace * KisDlgImageProperties::colorSpace()
 {
     return m_page->colorSpaceSelector->currentColorSpace();
 }
 
 void KisDlgImageProperties::setCurrentColor()
 {
     KoColor background = m_page->bnBackgroundColor->color();
     background.setOpacity(m_page->sldBackgroundColor->value());
     KisLayerUtils::changeImageDefaultProjectionColor(m_image, background);
 }
 
 void KisDlgImageProperties::setProofingConfig()
 {
     m_proofingConfig->conversionFlags = KoColorConversionTransformation::HighQuality;
     if (m_page->ckbBlackPointComp) m_proofingConfig->conversionFlags |= KoColorConversionTransformation::BlackpointCompensation;
     m_proofingConfig->intent = (KoColorConversionTransformation::Intent)m_page->cmbIntent->currentIndex();
     m_proofingConfig->proofingProfile = m_page->proofSpaceSelector->currentColorSpace()->profile()->name();
     m_proofingConfig->proofingModel = m_page->proofSpaceSelector->currentColorSpace()->colorModelId().id();
     m_proofingConfig->proofingDepth = "U8";//default to this
     m_proofingConfig->warningColor = m_page->gamutAlarm->color();
     m_proofingConfig->adaptationState = (double)m_page->sldAdaptationState->value()/20.0;
     qDebug()<<"set proofing config in properties: "<<m_proofingConfig->proofingProfile;
     m_image->setProofingConfiguration(m_proofingConfig);
 }
 
 void KisDlgImageProperties::setAnnotation(const QString &type)
 {
     KisAnnotationSP annotation = m_image->annotation(type);
     if (annotation) {
         m_page->lblDescription->clear();
         m_page->txtAnnotation->clear();
         m_page->lblDescription->setText(annotation->description());
         m_page->txtAnnotation->appendPlainText(annotation->displayText());
     }
     else {
         m_page->lblDescription->clear();
         m_page->txtAnnotation->clear();
     }
 }
 
diff --git a/libs/ui/dialogs/kis_dlg_preferences.cc b/libs/ui/dialogs/kis_dlg_preferences.cc
index 81b758ed46..d021935844 100644
--- a/libs/ui/dialogs/kis_dlg_preferences.cc
+++ b/libs/ui/dialogs/kis_dlg_preferences.cc
@@ -1,1116 +1,1120 @@
 /*
  *  preferencesdlg.cc - part of KImageShop
  *
  *  Copyright (c) 1999 Michael Koch <koch@kde.org>
  *  Copyright (c) 2003-2011 Boudewijn Rempt <boud@valdyas.org>
  *
  *  This program is free software; you can redistribute it and/or modify
  *  it under the terms of the GNU General Public License as published by
  *  the Free Software Foundation; either version 2 of the License, or
  *  (at your option) any later version.
  *
  *  This program is distributed in the hope that it will be useful,
  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  *  GNU General Public License for more details.
  *
  *  You should have received a copy of the GNU General Public License
  *  along with this program; if not, write to the Free Software
  *  Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
  */
 
 #include "kis_dlg_preferences.h"
 
 #include <opengl/kis_opengl.h>
 
 #include <QBitmap>
 #include <QCheckBox>
 #include <QCursor>
 #include <QLabel>
 #include <QLayout>
 #include <QLineEdit>
 #include <QPushButton>
 #include <QSlider>
 #include <QToolButton>
 #include <QThread>
 #include <QDesktopServices>
 #include <QGridLayout>
 #include <QRadioButton>
 #include <QGroupBox>
 #include <QMdiArea>
 #include <QMessageBox>
 #include <QDesktopWidget>
 #include <QFileDialog>
 #include <QFormLayout>
 #include <QSettings>
 
 #include <KisDocument.h>
 #include <KoColorProfile.h>
 #include <KisApplication.h>
 #include <KoFileDialog.h>
 #include <KisPart.h>
 #include <KoColorSpaceEngine.h>
 #include <kis_icon.h>
 #include <KoConfig.h>
 #include "KoID.h"
 #include <KoConfigAuthorPage.h>
 #include <KoVBox.h>
 
 #include <klocalizedstring.h>
 #include <kundo2stack.h>
 #include <KoResourcePaths.h>
 #include "kis_action_registry.h"
 
 #include "widgets/squeezedcombobox.h"
 #include "kis_clipboard.h"
 #include "widgets/kis_cmb_idlist.h"
 #include "KoColorSpace.h"
 #include "KoColorSpaceRegistry.h"
 #include "KoColorConversionTransformation.h"
 #include "kis_cursor.h"
 #include "kis_config.h"
 #include "kis_canvas_resource_provider.h"
 #include "kis_preference_set_registry.h"
 #include "kis_color_manager.h"
 #include "KisProofingConfiguration.h"
 #include "kis_image_config.h"
 
 #include "slider_and_spin_box_sync.h"
 
 // for the performance update
 #include <kis_cubic_curve.h>
 
 #include "input/config/kis_input_configuration_page.h"
 
 
 GeneralTab::GeneralTab(QWidget *_parent, const char *_name)
     : WdgGeneralSettings(_parent, _name)
 {
     KisConfig cfg;
 
     m_cmbCursorShape->addItem(i18n("No Cursor"));
     m_cmbCursorShape->addItem(i18n("Tool Icon"));
     m_cmbCursorShape->addItem(i18n("Arrow"));
     m_cmbCursorShape->addItem(i18n("Small Circle"));
     m_cmbCursorShape->addItem(i18n("Crosshair"));
     m_cmbCursorShape->addItem(i18n("Triangle Righthanded"));
     m_cmbCursorShape->addItem(i18n("Triangle Lefthanded"));
     m_cmbCursorShape->addItem(i18n("Black Pixel"));
     m_cmbCursorShape->addItem(i18n("White Pixel"));
 
     m_cmbOutlineShape->addItem(i18n("No Outline"));
     m_cmbOutlineShape->addItem(i18n("Circle Outline"));
     m_cmbOutlineShape->addItem(i18n("Preview Outline"));
     m_cmbOutlineShape->addItem(i18n("Tilt Outline"));
 
     m_cmbCursorShape->setCurrentIndex(cfg.newCursorStyle());
     m_cmbOutlineShape->setCurrentIndex(cfg.newOutlineStyle());
 
     chkShowRootLayer->setChecked(cfg.showRootLayer());
 
     int autosaveInterval = cfg.autoSaveInterval();
     //convert to minutes
     m_autosaveSpinBox->setValue(autosaveInterval / 60);
     m_autosaveCheckBox->setChecked(autosaveInterval > 0);
     m_undoStackSize->setValue(cfg.undoStackLimit());
     m_backupFileCheckBox->setChecked(cfg.backupFile());
     m_showOutlinePainting->setChecked(cfg.showOutlineWhilePainting());
     m_hideSplashScreen->setChecked(cfg.hideSplashScreen());
 
     KConfigGroup group = KSharedConfig::openConfig()->group("File Dialogs");
     m_chkNativeFileDialog->setChecked(!group.readEntry("DontUseNativeFileDialog", true));
 
     intMaxBrushSize->setValue(cfg.readEntry("maximumBrushSize", 1000));
 
     m_cmbMDIType->setCurrentIndex(cfg.readEntry<int>("mdi_viewmode", (int)QMdiArea::TabbedView));
     m_chkRubberBand->setChecked(cfg.readEntry<int>("mdi_rubberband", cfg.useOpenGL()));
     m_favoritePresetsSpinBox->setValue(cfg.favoritePresets());
     KoColor mdiColor;
     mdiColor.fromQColor(cfg.getMDIBackgroundColor());
     m_mdiColor->setColor(mdiColor);
     m_backgroundimage->setText(cfg.getMDIBackgroundImage());
     m_chkCanvasMessages->setChecked(cfg.showCanvasMessages());
     m_chkCompressKra->setChecked(cfg.compressKra());
 
     const QString configPath = QStandardPaths::writableLocation(QStandardPaths::GenericConfigLocation);
     QSettings kritarc(configPath + QStringLiteral("/kritadisplayrc"), QSettings::IniFormat);
     m_chkHiDPI->setChecked(kritarc.value("EnableHiDPI", false).toBool());
     m_chkSingleApplication->setChecked(kritarc.value("EnableSingleApplication", true).toBool());
 
     m_radioToolOptionsInDocker->setChecked(cfg.toolOptionsInDocker());
     m_chkSwitchSelectionCtrlAlt->setChecked(cfg.switchSelectionCtrlAlt());
     m_chkConvertOnImport->setChecked(cfg.convertToImageColorspaceOnImport());
 
     connect(m_bnFileName, SIGNAL(clicked()), SLOT(getBackgroundImage()));
     connect(clearBgImageButton, SIGNAL(clicked()), SLOT(clearBackgroundImage()));
 }
 
 void GeneralTab::setDefault()
 {
     KisConfig cfg;
 
     m_cmbCursorShape->setCurrentIndex(cfg.newCursorStyle(true));
     m_cmbOutlineShape->setCurrentIndex(cfg.newOutlineStyle(true));
     chkShowRootLayer->setChecked(cfg.showRootLayer(true));
     m_autosaveCheckBox->setChecked(cfg.autoSaveInterval(true) > 0);
     //convert to minutes
     m_autosaveSpinBox->setValue(cfg.autoSaveInterval(true) / 60);
     m_undoStackSize->setValue(cfg.undoStackLimit(true));
     m_backupFileCheckBox->setChecked(cfg.backupFile(true));
     m_showOutlinePainting->setChecked(cfg.showOutlineWhilePainting(true));
     m_hideSplashScreen->setChecked(cfg.hideSplashScreen(true));
     m_chkNativeFileDialog->setChecked(false);
     intMaxBrushSize->setValue(1000);
 
     m_cmbMDIType->setCurrentIndex((int)QMdiArea::TabbedView);
     m_chkRubberBand->setChecked(cfg.useOpenGL(true));
     m_favoritePresetsSpinBox->setValue(cfg.favoritePresets(true));
     KoColor mdiColor;
     mdiColor.fromQColor(cfg.getMDIBackgroundColor(true));
     m_mdiColor->setColor(mdiColor);
     m_backgroundimage->setText(cfg.getMDIBackgroundImage(true));
     m_chkCanvasMessages->setChecked(cfg.showCanvasMessages(true));
     m_chkCompressKra->setChecked(cfg.compressKra(true));
     m_chkHiDPI->setChecked(false);
     m_chkSingleApplication->setChecked(true);
 
     m_chkHiDPI->setChecked(true);
     m_radioToolOptionsInDocker->setChecked(cfg.toolOptionsInDocker(true));
     m_chkSwitchSelectionCtrlAlt->setChecked(cfg.switchSelectionCtrlAlt(true));
     m_chkConvertOnImport->setChecked(cfg.convertToImageColorspaceOnImport(true));
 
 }
 
 CursorStyle GeneralTab::cursorStyle()
 {
     return (CursorStyle)m_cmbCursorShape->currentIndex();
 }
 
 OutlineStyle GeneralTab::outlineStyle()
 {
     return (OutlineStyle)m_cmbOutlineShape->currentIndex();
 }
 
 bool GeneralTab::showRootLayer()
 {
     return chkShowRootLayer->isChecked();
 }
 
 int GeneralTab::autoSaveInterval()
 {
     //convert to seconds
     return m_autosaveCheckBox->isChecked() ? m_autosaveSpinBox->value() * 60 : 0;
 }
 
 int GeneralTab::undoStackSize()
 {
     return m_undoStackSize->value();
 }
 
 bool GeneralTab::showOutlineWhilePainting()
 {
     return m_showOutlinePainting->isChecked();
 }
 
 bool GeneralTab::hideSplashScreen()
 {
     return m_hideSplashScreen->isChecked();
 }
 
 int GeneralTab::mdiMode()
 {
     return m_cmbMDIType->currentIndex();
 }
 
 int GeneralTab::favoritePresets()
 {
     return m_favoritePresetsSpinBox->value();
 }
 
 bool GeneralTab::showCanvasMessages()
 {
     return m_chkCanvasMessages->isChecked();
 }
 
 bool GeneralTab::compressKra()
 {
     return m_chkCompressKra->isChecked();
 }
 
 bool GeneralTab::toolOptionsInDocker()
 {
     return m_radioToolOptionsInDocker->isChecked();
 }
 
 bool GeneralTab::switchSelectionCtrlAlt()
 {
     return m_chkSwitchSelectionCtrlAlt->isChecked();
 
 }
 
 bool GeneralTab::convertToImageColorspaceOnImport()
 {
     return m_chkConvertOnImport->isChecked();
 }
 
 
 void GeneralTab::getBackgroundImage()
 {
     KoFileDialog dialog(this, KoFileDialog::OpenFile, "BackgroundImages");
     dialog.setCaption(i18n("Select a Background Image"));
     dialog.setDefaultDir(QDesktopServices::storageLocation(QDesktopServices::PicturesLocation));
     dialog.setImageFilters();
 
     QString fn = dialog.filename();
     // dialog box was canceled or somehow no file was selected
     if (fn.isEmpty()) {
         return;
     }
 
     QImage image(fn);
     if (image.isNull()) {
         QMessageBox::warning(this, i18nc("@title:window", "Krita"), i18n("%1 is not a valid image file!", fn));
     }
     else {
         m_backgroundimage->setText(fn);
     }
 }
 
 void GeneralTab::clearBackgroundImage()
 {
     // clearing the background image text will implicitly make the background color be used
     m_backgroundimage->setText("");
 }
 
 #include "kactioncollection.h"
 #include "KisActionsSnapshot.h"
 
 ShortcutSettingsTab::ShortcutSettingsTab(QWidget *parent, const char *name)
     : QWidget(parent)
 {
     setObjectName(name);
 
     QGridLayout * l = new QGridLayout(this);
     l->setMargin(0);
     m_page = new WdgShortcutSettings(this);
     l->addWidget(m_page, 0, 0);
 
 
     m_snapshot.reset(new KisActionsSnapshot);
 
     KActionCollection *collection =
         KisPart::instance()->currentMainwindow()->actionCollection();
 
     Q_FOREACH (QAction *action, collection->actions()) {
         m_snapshot->addAction(action->objectName(), action);
     }
 
     QMap<QString, KActionCollection*> sortedCollections =
         m_snapshot->actionCollections();
 
     for (auto it = sortedCollections.constBegin(); it != sortedCollections.constEnd(); ++it) {
         m_page->addCollection(it.value(), it.key());
     }
 }
 
 ShortcutSettingsTab::~ShortcutSettingsTab()
 {
 }
 
 void ShortcutSettingsTab::setDefault()
 {
     m_page->allDefault();
 }
 
 void ShortcutSettingsTab::saveChanges()
 {
     m_page->save();
     KisActionRegistry::instance()->settingsPageSaved();
 }
 
 void ShortcutSettingsTab::cancelChanges()
 {
     m_page->undo();
 }
 
 ColorSettingsTab::ColorSettingsTab(QWidget *parent, const char *name)
     : QWidget(parent)
 {
     setObjectName(name);
 
     // XXX: Make sure only profiles that fit the specified color model
     // are shown in the profile combos
 
     QGridLayout * l = new QGridLayout(this);
     l->setMargin(0);
     m_page = new WdgColorSettings(this);
     l->addWidget(m_page, 0, 0);
 
     KisConfig cfg;
 
     m_page->chkUseSystemMonitorProfile->setChecked(cfg.useSystemMonitorProfile());
     connect(m_page->chkUseSystemMonitorProfile, SIGNAL(toggled(bool)), this, SLOT(toggleAllowMonitorProfileSelection(bool)));
 
     m_page->cmbWorkingColorSpace->setIDList(KoColorSpaceRegistry::instance()->listKeys());
     m_page->cmbWorkingColorSpace->setCurrent(cfg.workingColorSpace());
 
     m_page->bnAddColorProfile->setIcon(KisIconUtils::loadIcon("document-open"));
     m_page->bnAddColorProfile->setToolTip( i18n("Open Color Profile") );
     connect(m_page->bnAddColorProfile, SIGNAL(clicked()), SLOT(installProfile()));
 
     QFormLayout *monitorProfileGrid = new QFormLayout(m_page->monitorprofileholder);
     for(int i = 0; i < QApplication::desktop()->screenCount(); ++i) {
         QLabel *lbl = new QLabel(i18nc("The number of the screen", "Screen %1:", i + 1));
         m_monitorProfileLabels << lbl;
         SqueezedComboBox *cmb = new SqueezedComboBox();
         cmb->setSizePolicy(QSizePolicy::MinimumExpanding, QSizePolicy::Fixed);
         monitorProfileGrid->addRow(lbl, cmb);
         m_monitorProfileWidgets << cmb;
     }
 
     refillMonitorProfiles(KoID("RGBA", ""));
 
     for(int i = 0; i < QApplication::desktop()->screenCount(); ++i) {
         if (m_monitorProfileWidgets[i]->contains(cfg.monitorProfile(i))) {
             m_monitorProfileWidgets[i]->setCurrent(cfg.monitorProfile(i));
         }
     }
 
     m_page->chkBlackpoint->setChecked(cfg.useBlackPointCompensation());
     m_page->chkAllowLCMSOptimization->setChecked(cfg.allowLCMSOptimization());
 
     KisImageConfig cfgImage;
 
     KisProofingConfigurationSP proofingConfig = cfgImage.defaultProofingconfiguration();
     m_page->sldAdaptationState->setMaximum(20);
     m_page->sldAdaptationState->setMinimum(0);
     m_page->sldAdaptationState->setValue((int)proofingConfig->adaptationState*20);
 
     //probably this should become the screenprofile?
     KoColor ga(KoColorSpaceRegistry::instance()->rgb8());
     ga.fromKoColor(proofingConfig->warningColor);
     m_page->gamutAlarm->setColor(ga);
 
     const KoColorSpace *proofingSpace =  KoColorSpaceRegistry::instance()->colorSpace(proofingConfig->proofingModel,
                                                                                       proofingConfig->proofingDepth,
                                                                                       proofingConfig->proofingProfile);
-    m_page->proofingSpaceSelector->setCurrentColorSpace(proofingSpace);
+    if (proofingSpace) {
+        m_page->proofingSpaceSelector->setCurrentColorSpace(proofingSpace);
+    }
 
     m_page->cmbProofingIntent->setCurrentIndex((int)proofingConfig->intent);
     m_page->ckbProofBlackPoint->setChecked(proofingConfig->conversionFlags.testFlag(KoColorConversionTransformation::BlackpointCompensation));
 
     m_pasteBehaviourGroup.addButton(m_page->radioPasteWeb, PASTE_ASSUME_WEB);
     m_pasteBehaviourGroup.addButton(m_page->radioPasteMonitor, PASTE_ASSUME_MONITOR);
     m_pasteBehaviourGroup.addButton(m_page->radioPasteAsk, PASTE_ASK);
 
     QAbstractButton *button = m_pasteBehaviourGroup.button(cfg.pasteBehaviour());
     Q_ASSERT(button);
 
     if (button) {
         button->setChecked(true);
     }
 
     m_page->cmbMonitorIntent->setCurrentIndex(cfg.monitorRenderIntent());
 
     toggleAllowMonitorProfileSelection(cfg.useSystemMonitorProfile());
 
 }
 
 void ColorSettingsTab::installProfile()
 {
     KoFileDialog dialog(this, KoFileDialog::OpenFiles, "OpenDocumentICC");
     dialog.setCaption(i18n("Install Color Profiles"));
     dialog.setDefaultDir(QDesktopServices::storageLocation(QDesktopServices::HomeLocation));
     dialog.setMimeTypeFilters(QStringList() << "application/vnd.iccprofile", "application/vnd.iccprofile");
     QStringList profileNames = dialog.filenames();
 
     KoColorSpaceEngine *iccEngine = KoColorSpaceEngineRegistry::instance()->get("icc");
     Q_ASSERT(iccEngine);
 
     QString saveLocation = KoResourcePaths::saveLocation("icc_profiles");
 
     Q_FOREACH (const QString &profileName, profileNames) {
         if (!QFile::copy(profileName, saveLocation + QFileInfo(profileName).fileName())) {
             qWarning() << "Could not install profile!" << saveLocation + QFileInfo(profileName).fileName();
             continue;
         }
         iccEngine->addProfile(saveLocation + QFileInfo(profileName).fileName());
     }
 
     KisConfig cfg;
     refillMonitorProfiles(KoID("RGBA", ""));
 
     for(int i = 0; i < QApplication::desktop()->screenCount(); ++i) {
         if (m_monitorProfileWidgets[i]->contains(cfg.monitorProfile(i))) {
             m_monitorProfileWidgets[i]->setCurrent(cfg.monitorProfile(i));
         }
     }
 
 }
 
 void ColorSettingsTab::toggleAllowMonitorProfileSelection(bool useSystemProfile)
 {
     if (useSystemProfile) {
         KisConfig cfg;
         QStringList devices = KisColorManager::instance()->devices();
         if (devices.size() == QApplication::desktop()->screenCount()) {
             for(int i = 0; i < QApplication::desktop()->screenCount(); ++i) {
                 m_monitorProfileWidgets[i]->clear();
                 QString monitorForScreen = cfg.monitorForScreen(i, devices[i]);
                 Q_FOREACH (const QString &device, devices) {
                     m_monitorProfileLabels[i]->setText(i18nc("The display/screen we got from Qt", "Screen %1:", i + 1));
                     m_monitorProfileWidgets[i]->addSqueezedItem(KisColorManager::instance()->deviceName(device), device);
                     if (devices[i] == monitorForScreen) {
                         m_monitorProfileWidgets[i]->setCurrentIndex(i);
                     }
                 }
             }
         }
     }
     else {
         KisConfig cfg;
         refillMonitorProfiles(KoID("RGBA", ""));
 
         for(int i = 0; i < QApplication::desktop()->screenCount(); ++i) {
             if (m_monitorProfileWidgets[i]->contains(cfg.monitorProfile(i))) {
                 m_monitorProfileWidgets[i]->setCurrent(cfg.monitorProfile(i));
             }
         }
     }
 }
 
 void ColorSettingsTab::setDefault()
 {
     m_page->cmbWorkingColorSpace->setCurrent("RGBA");
 
     refillMonitorProfiles(KoID("RGBA", ""));
 
     KisConfig cfg;
     KisImageConfig cfgImage;
     KisProofingConfigurationSP proofingConfig =  cfgImage.defaultProofingconfiguration();
     const KoColorSpace *proofingSpace =  KoColorSpaceRegistry::instance()->colorSpace(proofingConfig->proofingModel,proofingConfig->proofingDepth,proofingConfig->proofingProfile);
-    m_page->proofingSpaceSelector->setCurrentColorSpace(proofingSpace);
+    if (proofingSpace) {
+        m_page->proofingSpaceSelector->setCurrentColorSpace(proofingSpace);
+    }
     m_page->cmbProofingIntent->setCurrentIndex((int)proofingConfig->intent);
     m_page->ckbProofBlackPoint->setChecked(proofingConfig->conversionFlags.testFlag(KoColorConversionTransformation::BlackpointCompensation));
     m_page->sldAdaptationState->setValue(0);
 
     //probably this should become the screenprofile?
     KoColor ga(KoColorSpaceRegistry::instance()->rgb8());
     ga.fromKoColor(proofingConfig->warningColor);
     m_page->gamutAlarm->setColor(ga);
 
     m_page->chkBlackpoint->setChecked(cfg.useBlackPointCompensation(true));
     m_page->chkAllowLCMSOptimization->setChecked(cfg.allowLCMSOptimization(true));
     m_page->cmbMonitorIntent->setCurrentIndex(cfg.monitorRenderIntent(true));
     m_page->chkUseSystemMonitorProfile->setChecked(cfg.useSystemMonitorProfile(true));
     QAbstractButton *button = m_pasteBehaviourGroup.button(cfg.pasteBehaviour(true));
     Q_ASSERT(button);
     if (button) {
         button->setChecked(true);
     }
 }
 
 
 void ColorSettingsTab::refillMonitorProfiles(const KoID & s)
 {
     const KoColorSpaceFactory * csf = KoColorSpaceRegistry::instance()->colorSpaceFactory(s.id());
 
     for (int i = 0; i < QApplication::desktop()->screenCount(); ++i) {
         m_monitorProfileWidgets[i]->clear();
     }
 
     if (!csf)
         return;
 
     QMap<QString, const KoColorProfile *>  profileList;
     Q_FOREACH(const KoColorProfile *profile, KoColorSpaceRegistry::instance()->profilesFor(csf)) {
         profileList[profile->name()] = profile;
     }
 
     Q_FOREACH (const KoColorProfile *profile, profileList.values()) {
         //qDebug() << "Profile" << profile->name() << profile->isSuitableForDisplay() << csf->defaultProfile();
         if (profile->isSuitableForDisplay()) {
             for (int i = 0; i < QApplication::desktop()->screenCount(); ++i) {
                 m_monitorProfileWidgets[i]->addSqueezedItem(profile->name());
             }
         }
     }
 
     for (int i = 0; i < QApplication::desktop()->screenCount(); ++i) {
         m_monitorProfileLabels[i]->setText(i18nc("The number of the screen", "Screen %1:", i + 1));
         m_monitorProfileWidgets[i]->setCurrent(csf->defaultProfile());
     }
 }
 
 
 //---------------------------------------------------------------------------------------------------
 
 void TabletSettingsTab::setDefault()
 {
     KisCubicCurve curve;
     curve.fromString(DEFAULT_CURVE_STRING);
     m_page->pressureCurve->setCurve(curve);
 }
 
 TabletSettingsTab::TabletSettingsTab(QWidget* parent, const char* name): QWidget(parent)
 {
     setObjectName(name);
 
     QGridLayout * l = new QGridLayout(this);
     l->setMargin(0);
     m_page = new WdgTabletSettings(this);
     l->addWidget(m_page, 0, 0);
 
     KisConfig cfg;
     KisCubicCurve curve;
     curve.fromString( cfg.pressureTabletCurve() );
 
     m_page->pressureCurve->setMaximumSize(QSize(QWIDGETSIZE_MAX, QWIDGETSIZE_MAX));
     m_page->pressureCurve->setCurve(curve);
 }
 
 
 //---------------------------------------------------------------------------------------------------
 #include "kis_acyclic_signal_connector.h"
 
 int getTotalRAM() {
     KisImageConfig cfg;
     return cfg.totalRAM();
 }
 
 int PerformanceTab::realTilesRAM()
 {
     return intMemoryLimit->value() - intPoolLimit->value();
 }
 
 PerformanceTab::PerformanceTab(QWidget *parent, const char *name)
     : WdgPerformanceSettings(parent, name)
 {
     KisImageConfig cfg;
     const int totalRAM = cfg.totalRAM();
     lblTotalMemory->setText(i18n("%1 MiB", totalRAM));
 
     sliderMemoryLimit->setSuffix(i18n(" %"));
     sliderMemoryLimit->setRange(1, 100, 2);
     sliderMemoryLimit->setSingleStep(0.01);
 
     sliderPoolLimit->setSuffix(i18n(" %"));
     sliderPoolLimit->setRange(0, 20, 2);
     sliderMemoryLimit->setSingleStep(0.01);
 
     sliderUndoLimit->setSuffix(i18n(" %"));
     sliderUndoLimit->setRange(0, 50, 2);
     sliderMemoryLimit->setSingleStep(0.01);
 
     intMemoryLimit->setMinimumWidth(80);
     intPoolLimit->setMinimumWidth(80);
     intUndoLimit->setMinimumWidth(80);
 
 
     SliderAndSpinBoxSync *sync1 =
         new SliderAndSpinBoxSync(sliderMemoryLimit,
                                  intMemoryLimit,
                                  getTotalRAM);
 
     sync1->slotParentValueChanged();
     m_syncs << sync1;
 
     SliderAndSpinBoxSync *sync2 =
         new SliderAndSpinBoxSync(sliderPoolLimit,
                                  intPoolLimit,
                                  std::bind(&KisIntParseSpinBox::value,
                                              intMemoryLimit));
 
 
     connect(intMemoryLimit, SIGNAL(valueChanged(int)), sync2, SLOT(slotParentValueChanged()));
     sync2->slotParentValueChanged();
     m_syncs << sync2;
 
     SliderAndSpinBoxSync *sync3 =
         new SliderAndSpinBoxSync(sliderUndoLimit,
                                  intUndoLimit,
                                  std::bind(&PerformanceTab::realTilesRAM,
                                              this));
 
 
     connect(intPoolLimit, SIGNAL(valueChanged(int)), sync3, SLOT(slotParentValueChanged()));
     sync3->slotParentValueChanged();
     m_syncs << sync3;
 
     sliderSwapSize->setSuffix(i18n(" GiB"));
     sliderSwapSize->setRange(1, 64);
     intSwapSize->setRange(1, 64);
 
 
     KisAcyclicSignalConnector *swapSizeConnector = new KisAcyclicSignalConnector(this);
 
     swapSizeConnector->connectForwardInt(sliderSwapSize, SIGNAL(valueChanged(int)),
                                          intSwapSize, SLOT(setValue(int)));
 
     swapSizeConnector->connectBackwardInt(intSwapSize, SIGNAL(valueChanged(int)),
                                           sliderSwapSize, SLOT(setValue(int)));
 
     lblSwapFileLocation->setText(cfg.swapDir());
     connect(bnSwapFile, SIGNAL(clicked()), SLOT(selectSwapDir()));
 
     load(false);
 }
 
 PerformanceTab::~PerformanceTab()
 {
     qDeleteAll(m_syncs);
 }
 
 void PerformanceTab::load(bool requestDefault)
 {
     KisImageConfig cfg;
 
     sliderMemoryLimit->setValue(cfg.memoryHardLimitPercent(requestDefault));
     sliderPoolLimit->setValue(cfg.memoryPoolLimitPercent(requestDefault));
     sliderUndoLimit->setValue(cfg.memorySoftLimitPercent(requestDefault));
 
     chkPerformanceLogging->setChecked(cfg.enablePerfLog(requestDefault));
     chkProgressReporting->setChecked(cfg.enableProgressReporting(requestDefault));
 
     sliderSwapSize->setValue(cfg.maxSwapSize(requestDefault) / 1024);
     lblSwapFileLocation->setText(cfg.swapDir(requestDefault));
 
     {
         KisConfig cfg2;
         chkOpenGLLogging->setChecked(cfg2.enableOpenGLDebugging(requestDefault));
         chkDisableVectorOptimizations->setChecked(cfg2.enableAmdVectorizationWorkaround(requestDefault));
     }
 }
 
 void PerformanceTab::save()
 {
     KisImageConfig cfg;
 
     cfg.setMemoryHardLimitPercent(sliderMemoryLimit->value());
     cfg.setMemorySoftLimitPercent(sliderUndoLimit->value());
     cfg.setMemoryPoolLimitPercent(sliderPoolLimit->value());
 
     cfg.setEnablePerfLog(chkPerformanceLogging->isChecked());
     cfg.setEnableProgressReporting(chkProgressReporting->isChecked());
 
     cfg.setMaxSwapSize(sliderSwapSize->value() * 1024);
 
     cfg.setSwapDir(lblSwapFileLocation->text());
 
     {
         KisConfig cfg2;
         cfg2.setEnableOpenGLDebugging(chkOpenGLLogging->isChecked());
         cfg2.setEnableAmdVectorizationWorkaround(chkDisableVectorOptimizations->isChecked());
     }
 }
 
 void PerformanceTab::selectSwapDir()
 {
     KisImageConfig cfg;
     QString swapDir = cfg.swapDir();
     swapDir = QFileDialog::getExistingDirectory(0, i18nc("@title:window", "Select a swap directory"), swapDir);
     lblSwapFileLocation->setText(swapDir);
 }
 
 //---------------------------------------------------------------------------------------------------
 
 #include "KoColor.h"
 
 DisplaySettingsTab::DisplaySettingsTab(QWidget *parent, const char *name)
     : WdgDisplaySettings(parent, name)
 {
     KisConfig cfg;
 
     if (!KisOpenGL::hasOpenGL()) {
         grpOpenGL->setEnabled(false);
         grpOpenGL->setChecked(false);
         chkUseTextureBuffer->setEnabled(false);
         chkDisableVsync->setEnabled(false);
         cmbFilterMode->setEnabled(false);
     } else {
         grpOpenGL->setEnabled(true);
         grpOpenGL->setChecked(cfg.useOpenGL());
         chkUseTextureBuffer->setEnabled(cfg.useOpenGL());
         chkUseTextureBuffer->setChecked(cfg.useOpenGLTextureBuffer());
         chkDisableVsync->setVisible(cfg.showAdvancedOpenGLSettings());
         chkDisableVsync->setEnabled(cfg.useOpenGL());
         chkDisableVsync->setChecked(cfg.disableVSync());
         cmbFilterMode->setEnabled(cfg.useOpenGL());
         cmbFilterMode->setCurrentIndex(cfg.openGLFilteringMode());
         // Don't show the high quality filtering mode if it's not available
         if (!KisOpenGL::supportsLoD()) {
             cmbFilterMode->removeItem(3);
         }
     }
     if (qApp->applicationName() == "kritasketch" || qApp->applicationName() == "kritagemini") {
        grpOpenGL->setVisible(false);
        grpOpenGL->setMaximumHeight(0);
     }
 
     KoColor c;
     c.fromQColor(cfg.selectionOverlayMaskColor());
     c.setOpacity(1.0);
     btnSelectionOverlayColor->setColor(c);
     sldSelectionOverlayOpacity->setRange(0.0, 1.0, 2);
     sldSelectionOverlayOpacity->setSingleStep(0.05);
     sldSelectionOverlayOpacity->setValue(cfg.selectionOverlayMaskColor().alphaF());
 
     intCheckSize->setValue(cfg.checkSize());
     chkMoving->setChecked(cfg.scrollCheckers());
     KoColor ck1(KoColorSpaceRegistry::instance()->rgb8());
     ck1.fromQColor(cfg.checkersColor1());
     colorChecks1->setColor(ck1);
     KoColor ck2(KoColorSpaceRegistry::instance()->rgb8());
     ck2.fromQColor(cfg.checkersColor2());
     colorChecks2->setColor(ck2);
     KoColor cb(KoColorSpaceRegistry::instance()->rgb8());
     cb.fromQColor(cfg.canvasBorderColor());
     canvasBorder->setColor(cb);
     hideScrollbars->setChecked(cfg.hideScrollbars());
     chkCurveAntialiasing->setChecked(cfg.antialiasCurves());
     chkSelectionOutlineAntialiasing->setChecked(cfg.antialiasSelectionOutline());
     chkChannelsAsColor->setChecked(cfg.showSingleChannelAsColor());
     chkHidePopups->setChecked(cfg.hidePopups());
 
     connect(grpOpenGL, SIGNAL(toggled(bool)), SLOT(slotUseOpenGLToggled(bool)));
 }
 
 void DisplaySettingsTab::setDefault()
 {
     KisConfig cfg;
     if (!KisOpenGL::hasOpenGL()) {
         grpOpenGL->setEnabled(false);
         grpOpenGL->setChecked(false);
         chkUseTextureBuffer->setEnabled(false);
         chkDisableVsync->setEnabled(false);
         cmbFilterMode->setEnabled(false);
     }
     else {
         grpOpenGL->setEnabled(true);
         grpOpenGL->setChecked(cfg.useOpenGL(true));
         chkUseTextureBuffer->setChecked(cfg.useOpenGLTextureBuffer(true));
         chkUseTextureBuffer->setEnabled(true);
         chkDisableVsync->setEnabled(true);
         chkDisableVsync->setChecked(cfg.disableVSync(true));
         cmbFilterMode->setEnabled(true);
         cmbFilterMode->setCurrentIndex(cfg.openGLFilteringMode(true));
     }
 
     chkMoving->setChecked(cfg.scrollCheckers(true));
     intCheckSize->setValue(cfg.checkSize(true));
     KoColor ck1(KoColorSpaceRegistry::instance()->rgb8());
     ck1.fromQColor(cfg.checkersColor1(true));
     colorChecks1->setColor(ck1);
     KoColor ck2(KoColorSpaceRegistry::instance()->rgb8());
     ck2.fromQColor(cfg.checkersColor2(true));
     colorChecks2->setColor(ck2);
     KoColor cvb(KoColorSpaceRegistry::instance()->rgb8());
     cvb.fromQColor(cfg.canvasBorderColor(true));
     canvasBorder->setColor(cvb);
     hideScrollbars->setChecked(cfg.hideScrollbars(true));
     chkCurveAntialiasing->setChecked(cfg.antialiasCurves(true));
     chkSelectionOutlineAntialiasing->setChecked(cfg.antialiasSelectionOutline(true));
     chkChannelsAsColor->setChecked(cfg.showSingleChannelAsColor(true));
     chkHidePopups->setChecked(cfg.hidePopups(true));
 
 }
 
 void DisplaySettingsTab::slotUseOpenGLToggled(bool isChecked)
 {
     chkUseTextureBuffer->setEnabled(isChecked);
     chkDisableVsync->setEnabled(isChecked);
     cmbFilterMode->setEnabled(isChecked);
 }
 
 //---------------------------------------------------------------------------------------------------
 FullscreenSettingsTab::FullscreenSettingsTab(QWidget* parent) : WdgFullscreenSettingsBase(parent)
 {
     KisConfig cfg;
 
     chkDockers->setChecked(cfg.hideDockersFullscreen());
     chkMenu->setChecked(cfg.hideMenuFullscreen());
     chkScrollbars->setChecked(cfg.hideScrollbarsFullscreen());
     chkStatusbar->setChecked(cfg.hideStatusbarFullscreen());
     chkTitlebar->setChecked(cfg.hideTitlebarFullscreen());
     chkToolbar->setChecked(cfg.hideToolbarFullscreen());
 
 }
 
 void FullscreenSettingsTab::setDefault()
 {
     KisConfig cfg;
     chkDockers->setChecked(cfg.hideDockersFullscreen(true));
     chkMenu->setChecked(cfg.hideMenuFullscreen(true));
     chkScrollbars->setChecked(cfg.hideScrollbarsFullscreen(true));
     chkStatusbar->setChecked(cfg.hideStatusbarFullscreen(true));
     chkTitlebar->setChecked(cfg.hideTitlebarFullscreen(true));
     chkToolbar->setChecked(cfg.hideToolbarFullscreen(true));
 }
 
 
 //---------------------------------------------------------------------------------------------------
 
 KisDlgPreferences::KisDlgPreferences(QWidget* parent, const char* name)
     : KPageDialog(parent)
 {
     Q_UNUSED(name);
     setWindowTitle(i18n("Configure Krita"));
     setStandardButtons(QDialogButtonBox::Ok | QDialogButtonBox::Cancel | QDialogButtonBox::RestoreDefaults);
     button(QDialogButtonBox::Ok)->setDefault(true);
 
     setFaceType(KPageDialog::List);
 
     // General
     KoVBox *vbox = new KoVBox();
     KPageWidgetItem *page = new KPageWidgetItem(vbox, i18n("General"));
     page->setObjectName("general");
     page->setHeader(i18n("General"));
     page->setIcon(KisIconUtils::loadIcon("go-home"));
     addPage(page);
     m_general = new GeneralTab(vbox);
 
     // Shortcuts
     vbox = new KoVBox();
     page = new KPageWidgetItem(vbox, i18n("Keyboard Shortcuts"));
     page->setObjectName("shortcuts");
     page->setHeader(i18n("Shortcuts"));
     page->setIcon(KisIconUtils::loadIcon("document-export"));
     addPage(page);
     m_shortcutSettings = new ShortcutSettingsTab(vbox);
     connect(this, SIGNAL(accepted()), m_shortcutSettings, SLOT(saveChanges()));
     connect(this, SIGNAL(rejected()), m_shortcutSettings, SLOT(cancelChanges()));
 
     // Canvas input settings
     m_inputConfiguration = new KisInputConfigurationPage();
     page = addPage(m_inputConfiguration, i18n("Canvas Input Settings"));
     page->setHeader(i18n("Canvas Input"));
     page->setObjectName("canvasinput");
     page->setIcon(KisIconUtils::loadIcon("configure"));
 
     // Display
     vbox = new KoVBox();
     page = new KPageWidgetItem(vbox, i18n("Display"));
     page->setObjectName("display");
     page->setHeader(i18n("Display"));
     page->setIcon(KisIconUtils::loadIcon("preferences-desktop-display"));
     addPage(page);
     m_displaySettings = new DisplaySettingsTab(vbox);
 
     // Color
     vbox = new KoVBox();
     page = new KPageWidgetItem(vbox, i18n("Color Management"));
     page->setObjectName("colormanagement");
     page->setHeader(i18n("Color"));
     page->setIcon(KisIconUtils::loadIcon("preferences-desktop-color"));
     addPage(page);
     m_colorSettings = new ColorSettingsTab(vbox);
 
     // Performance
     vbox = new KoVBox();
     page = new KPageWidgetItem(vbox, i18n("Performance"));
     page->setObjectName("performance");
     page->setHeader(i18n("Performance"));
     page->setIcon(KisIconUtils::loadIcon("applications-system"));
     addPage(page);
     m_performanceSettings = new PerformanceTab(vbox);
 
     // Tablet
     vbox = new KoVBox();
     page = new KPageWidgetItem(vbox, i18n("Tablet settings"));
     page->setObjectName("tablet");
     page->setHeader(i18n("Tablet"));
     page->setIcon(KisIconUtils::loadIcon("document-edit"));
     addPage(page);
     m_tabletSettings = new TabletSettingsTab(vbox);
 
     // full-screen mode
     vbox = new KoVBox();
     page = new KPageWidgetItem(vbox, i18n("Canvas-only settings"));
     page->setObjectName("canvasonly");
     page->setHeader(i18n("Canvas-only"));
     page->setIcon(KisIconUtils::loadIcon("folder-pictures"));
     addPage(page);
     m_fullscreenSettings = new FullscreenSettingsTab(vbox);
 
     // Author profiles
     m_authorPage = new KoConfigAuthorPage();
     page = addPage(m_authorPage, i18nc("@title:tab Author page", "Author" ));
     page->setObjectName("author");
     page->setHeader(i18n("Author"));
     page->setIcon(KisIconUtils::loadIcon("im-user"));
 
 
     QPushButton *restoreDefaultsButton = button(QDialogButtonBox::RestoreDefaults);
 
     connect(this, SIGNAL(accepted()), m_inputConfiguration, SLOT(saveChanges()));
     connect(this, SIGNAL(rejected()), m_inputConfiguration, SLOT(revertChanges()));
 
     KisPreferenceSetRegistry *preferenceSetRegistry = KisPreferenceSetRegistry::instance();
     Q_FOREACH (KisAbstractPreferenceSetFactory *preferenceSetFactory, preferenceSetRegistry->values()) {
         KisPreferenceSet* preferenceSet = preferenceSetFactory->createPreferenceSet();
         vbox = new KoVBox();
         page = new KPageWidgetItem(vbox, preferenceSet->name());
         page->setHeader(preferenceSet->header());
         page->setIcon(preferenceSet->icon());
         addPage(page);
         preferenceSet->setParent(vbox);
         preferenceSet->loadPreferences();
 
         connect(restoreDefaultsButton, SIGNAL(clicked(bool)), preferenceSet, SLOT(loadDefaultPreferences()), Qt::UniqueConnection);
         connect(this, SIGNAL(accepted()), preferenceSet, SLOT(savePreferences()), Qt::UniqueConnection);
     }
 
 
     connect(restoreDefaultsButton, SIGNAL(clicked(bool)), this, SLOT(slotDefault()));
 
 }
 
 KisDlgPreferences::~KisDlgPreferences()
 {
 }
 
 void KisDlgPreferences::slotDefault()
 {
     if (currentPage()->objectName() == "general") {
         m_general->setDefault();
     }
     else if (currentPage()->objectName() == "shortcuts") {
         m_shortcutSettings->setDefault();
     }
     else if (currentPage()->objectName() == "display") {
         m_displaySettings->setDefault();
     }
     else if (currentPage()->objectName() == "colormanagement") {
         m_colorSettings->setDefault();
     }
     else if (currentPage()->objectName() == "performance") {
         m_performanceSettings->load(true);
     }
     else if (currentPage()->objectName() == "tablet") {
         m_tabletSettings->setDefault();
     }
     else if (currentPage()->objectName() == "canvasonly") {
         m_fullscreenSettings->setDefault();
     }
     else if (currentPage()->objectName() == "canvasinput") {
         m_inputConfiguration->setDefaults();
     }
 }
 
 bool KisDlgPreferences::editPreferences()
 {
     KisDlgPreferences* dialog;
 
     dialog = new KisDlgPreferences();
     bool baccept = (dialog->exec() == Accepted);
     if (baccept) {
         // General settings
         KisConfig cfg;
         cfg.setNewCursorStyle(dialog->m_general->cursorStyle());
         cfg.setNewOutlineStyle(dialog->m_general->outlineStyle());
         cfg.setShowRootLayer(dialog->m_general->showRootLayer());
         cfg.setShowOutlineWhilePainting(dialog->m_general->showOutlineWhilePainting());
         cfg.setHideSplashScreen(dialog->m_general->hideSplashScreen());
 
         KConfigGroup group = KSharedConfig::openConfig()->group("File Dialogs");
         group.writeEntry("DontUseNativeFileDialog", !dialog->m_general->m_chkNativeFileDialog->isChecked());
 
         cfg.writeEntry<int>("maximumBrushSize", dialog->m_general->intMaxBrushSize->value());
 
         cfg.writeEntry<int>("mdi_viewmode", dialog->m_general->mdiMode());
         cfg.setMDIBackgroundColor(dialog->m_general->m_mdiColor->color().toQColor());
         cfg.setMDIBackgroundImage(dialog->m_general->m_backgroundimage->text());
         cfg.setAutoSaveInterval(dialog->m_general->autoSaveInterval());
         cfg.setBackupFile(dialog->m_general->m_backupFileCheckBox->isChecked());
         cfg.setShowCanvasMessages(dialog->m_general->showCanvasMessages());
         cfg.setCompressKra(dialog->m_general->compressKra());
 
         const QString configPath = QStandardPaths::writableLocation(QStandardPaths::GenericConfigLocation);
         QSettings kritarc(configPath + QStringLiteral("/kritadisplayrc"), QSettings::IniFormat);
         kritarc.setValue("EnableHiDPI", dialog->m_general->m_chkHiDPI->isChecked());
         kritarc.setValue("EnableSingleApplication", dialog->m_general->m_chkSingleApplication->isChecked());
 
         cfg.setToolOptionsInDocker(dialog->m_general->toolOptionsInDocker());
         cfg.setSwitchSelectionCtrlAlt(dialog->m_general->switchSelectionCtrlAlt());
         cfg.setConvertToImageColorspaceOnImport(dialog->m_general->convertToImageColorspaceOnImport());
 
         KisPart *part = KisPart::instance();
         if (part) {
             Q_FOREACH (QPointer<KisDocument> doc, part->documents()) {
                 if (doc) {
                     doc->setAutoSaveDelay(dialog->m_general->autoSaveInterval());
                     doc->setBackupFile(dialog->m_general->m_backupFileCheckBox->isChecked());
                     doc->undoStack()->setUndoLimit(dialog->m_general->undoStackSize());
                 }
             }
         }
         cfg.setUndoStackLimit(dialog->m_general->undoStackSize());
         cfg.setFavoritePresets(dialog->m_general->favoritePresets());
 
         // Color settings
         cfg.setUseSystemMonitorProfile(dialog->m_colorSettings->m_page->chkUseSystemMonitorProfile->isChecked());
         for (int i = 0; i < QApplication::desktop()->screenCount(); ++i) {
             if (dialog->m_colorSettings->m_page->chkUseSystemMonitorProfile->isChecked()) {
                 int currentIndex = dialog->m_colorSettings->m_monitorProfileWidgets[i]->currentIndex();
                 QString monitorid = dialog->m_colorSettings->m_monitorProfileWidgets[i]->itemData(currentIndex).toString();
                 cfg.setMonitorForScreen(i, monitorid);
             }
             else {
                 cfg.setMonitorProfile(i,
                                       dialog->m_colorSettings->m_monitorProfileWidgets[i]->itemHighlighted(),
                                       dialog->m_colorSettings->m_page->chkUseSystemMonitorProfile->isChecked());
             }
         }
         cfg.setWorkingColorSpace(dialog->m_colorSettings->m_page->cmbWorkingColorSpace->currentItem().id());
 
         KisImageConfig cfgImage;
         cfgImage.setDefaultProofingConfig(dialog->m_colorSettings->m_page->proofingSpaceSelector->currentColorSpace(),
                                           dialog->m_colorSettings->m_page->cmbProofingIntent->currentIndex(),
                                           dialog->m_colorSettings->m_page->ckbProofBlackPoint->isChecked(),
                                           dialog->m_colorSettings->m_page->gamutAlarm->color(),
                                           (double)dialog->m_colorSettings->m_page->sldAdaptationState->value()/20);
         cfg.setUseBlackPointCompensation(dialog->m_colorSettings->m_page->chkBlackpoint->isChecked());
         cfg.setAllowLCMSOptimization(dialog->m_colorSettings->m_page->chkAllowLCMSOptimization->isChecked());
         cfg.setPasteBehaviour(dialog->m_colorSettings->m_pasteBehaviourGroup.checkedId());
         cfg.setRenderIntent(dialog->m_colorSettings->m_page->cmbMonitorIntent->currentIndex());
 
         // Tablet settings
         cfg.setPressureTabletCurve( dialog->m_tabletSettings->m_page->pressureCurve->curve().toString() );
 
         dialog->m_performanceSettings->save();
 
         if (!cfg.useOpenGL() && dialog->m_displaySettings->grpOpenGL->isChecked())
             cfg.setCanvasState("TRY_OPENGL");
         cfg.setUseOpenGL(dialog->m_displaySettings->grpOpenGL->isChecked());
         cfg.setUseOpenGLTextureBuffer(dialog->m_displaySettings->chkUseTextureBuffer->isChecked());
         cfg.setOpenGLFilteringMode(dialog->m_displaySettings->cmbFilterMode->currentIndex());
         cfg.setDisableVSync(dialog->m_displaySettings->chkDisableVsync->isChecked());
 
         cfg.setCheckSize(dialog->m_displaySettings->intCheckSize->value());
         cfg.setScrollingCheckers(dialog->m_displaySettings->chkMoving->isChecked());
         cfg.setCheckersColor1(dialog->m_displaySettings->colorChecks1->color().toQColor());
         cfg.setCheckersColor2(dialog->m_displaySettings->colorChecks2->color().toQColor());
         cfg.setCanvasBorderColor(dialog->m_displaySettings->canvasBorder->color().toQColor());
         cfg.setHideScrollbars(dialog->m_displaySettings->hideScrollbars->isChecked());
         KoColor c = dialog->m_displaySettings->btnSelectionOverlayColor->color();
         c.setOpacity(dialog->m_displaySettings->sldSelectionOverlayOpacity->value());
         cfg.setSelectionOverlayMaskColor(c.toQColor());
         cfg.setAntialiasCurves(dialog->m_displaySettings->chkCurveAntialiasing->isChecked());
         cfg.setAntialiasSelectionOutline(dialog->m_displaySettings->chkSelectionOutlineAntialiasing->isChecked());
         cfg.setShowSingleChannelAsColor(dialog->m_displaySettings->chkChannelsAsColor->isChecked());
         cfg.setHidePopups(dialog->m_displaySettings->chkHidePopups->isChecked());
 
         cfg.setHideDockersFullscreen(dialog->m_fullscreenSettings->chkDockers->checkState());
         cfg.setHideMenuFullscreen(dialog->m_fullscreenSettings->chkMenu->checkState());
         cfg.setHideScrollbarsFullscreen(dialog->m_fullscreenSettings->chkScrollbars->checkState());
         cfg.setHideStatusbarFullscreen(dialog->m_fullscreenSettings->chkStatusbar->checkState());
         cfg.setHideTitlebarFullscreen(dialog->m_fullscreenSettings->chkTitlebar->checkState());
         cfg.setHideToolbarFullscreen(dialog->m_fullscreenSettings->chkToolbar->checkState());
 
         dialog->m_authorPage->apply();
 
     }
     delete dialog;
     return baccept;
 }
 
diff --git a/libs/ui/kis_png_converter.cpp b/libs/ui/kis_png_converter.cpp
index 726d0a6f02..6117269b91 100644
--- a/libs/ui/kis_png_converter.cpp
+++ b/libs/ui/kis_png_converter.cpp
@@ -1,1287 +1,1286 @@
 /*
  *  Copyright (c) 2005-2007 Cyrille Berger <cberger@cberger.net>
  *
  *  This program is free software; you can redistribute it and/or modify
  *  it under the terms of the GNU General Public License as published by
  *  the Free Software Foundation; either version 2 of the License, or
  *  (at your option) any later version.
  *
  *  This program is distributed in the hope that it will be useful,
  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  *  GNU General Public License for more details.
  *
  *  You should have received a copy of the GNU General Public License
  *  along with this program; if not, write to the Free Software
  *  Foundation, Inc., 51 Franklin Street, Fifth Floor,
  * Boston, MA 02110-1301, USA.
  */
 
 #include "kis_png_converter.h"
 // A big thank to Glenn Randers-Pehrson for his wonderful
 // documentation of libpng available at
 // http://www.libpng.org/pub/png/libpng-1.2.5-manual.html
 
 #ifndef PNG_MAX_UINT // Removed in libpng 1.4
 #define PNG_MAX_UINT PNG_UINT_31_MAX
 #endif
 
 #include <KoConfig.h> // WORDS_BIGENDIAN
 #include <KoStore.h>
 #include <KoStoreDevice.h>
 
 #include <limits.h>
 #include <stdio.h>
 #include <zlib.h>
 
 #include <QBuffer>
 #include <QFile>
 #include <QApplication>
 
 #include <klocalizedstring.h>
 #include <QUrl>
 
 #include <KoColorSpace.h>
 #include <KoDocumentInfo.h>
 #include <KoID.h>
 #include <KoColorSpaceRegistry.h>
 #include <KoColorProfile.h>
 #include <KoColorSpace.h>
 #include <KoColor.h>
 #include <KoUnit.h>
 
 #include <kis_config.h>
 #include <kis_painter.h>
 #include <KisDocument.h>
 #include <kis_image.h>
 #include <kis_iterator_ng.h>
 #include <kis_layer.h>
 #include <kis_paint_device.h>
 #include <kis_transaction.h>
 #include <kis_paint_layer.h>
 #include <kis_group_layer.h>
 #include <metadata/kis_meta_data_io_backend.h>
 #include <metadata/kis_meta_data_store.h>
 #include <KoColorModelStandardIds.h>
 #include "dialogs/kis_dlg_png_import.h"
 #include "kis_clipboard.h"
 
 namespace
 {
 
 
 int getColorTypeforColorSpace(const KoColorSpace * cs , bool alpha)
 {
 
     QString id = cs->id();
 
     if (id == "GRAYA" || id == "GRAYAU16" || id == "GRAYA16") {
         return alpha ? PNG_COLOR_TYPE_GRAY_ALPHA : PNG_COLOR_TYPE_GRAY;
     }
     if (id == "RGBA" || id == "RGBA16") {
         return alpha ? PNG_COLOR_TYPE_RGB_ALPHA : PNG_COLOR_TYPE_RGB;
     }
 
     return -1;
 
 }
 
 bool colorSpaceIdSupported(const QString &id)
 {
     return id == "RGBA" || id == "RGBA16" ||
         id == "GRAYA" || id == "GRAYAU16" || id == "GRAYA16";
 }
 
 QPair<QString, QString> getColorSpaceForColorType(int color_type, int color_nb_bits)
 {
     QPair<QString, QString> r;
 
     if (color_type ==  PNG_COLOR_TYPE_PALETTE) {
         r.first = RGBAColorModelID.id();
         r.second = Integer8BitsColorDepthID.id();
     } else {
         if (color_type == PNG_COLOR_TYPE_GRAY || color_type == PNG_COLOR_TYPE_GRAY_ALPHA) {
             r.first = GrayAColorModelID.id();
         } else if (color_type == PNG_COLOR_TYPE_RGB_ALPHA || color_type == PNG_COLOR_TYPE_RGB) {
             r.first = RGBAColorModelID.id();
         }
         if (color_nb_bits == 16) {
             r.second = Integer16BitsColorDepthID.id();
         } else if (color_nb_bits <= 8) {
             r.second = Integer8BitsColorDepthID.id();
         }
     }
     return r;
 }
 
 
 void fillText(png_text* p_text, const char* key, QString& text)
 {
     p_text->compression = PNG_TEXT_COMPRESSION_zTXt;
     p_text->key = const_cast<char *>(key);
     char* textc = new char[text.length()+1];
     strcpy(textc, text.toLatin1());
     p_text->text = textc;
     p_text->text_length = text.length() + 1;
 }
 
 long formatStringList(char *string, const size_t length, const char *format, va_list operands)
 {
     int n = vsnprintf(string, length, format, operands);
 
     if (n < 0)
         string[length-1] = '\0';
 
     return((long) n);
 }
 
 long formatString(char *string, const size_t length, const char *format, ...)
 {
     long n;
 
     va_list operands;
 
     va_start(operands, format);
     n = (long) formatStringList(string, length, format, operands);
     va_end(operands);
     return(n);
 }
 
 void writeRawProfile(png_struct *ping, png_info *ping_info, QString profile_type, QByteArray profile_data)
 {
 
     png_textp      text;
 
     png_uint_32    allocated_length, description_length;
 
     const uchar hex[16] = {'0', '1', '2', '3', '4', '5', '6', '7', '8', '9', 'a', 'b', 'c', 'd', 'e', 'f'};
 
     dbgFile << "Writing Raw profile: type=" << profile_type << ", length=" << profile_data.length() << endl;
 
     text               = (png_textp) png_malloc(ping, (png_uint_32) sizeof(png_text));
     description_length = profile_type.length();
     allocated_length   = (png_uint_32)(profile_data.length() * 2 + (profile_data.length() >> 5) + 20 + description_length);
 
     text[0].text   = (png_charp) png_malloc(ping, allocated_length);
 
     QString key = QLatin1Literal("Raw profile type ") + profile_type.toLatin1();
     QByteArray keyData = key.toLatin1();
     text[0].key = keyData.data();
 
     uchar* sp = (uchar*)profile_data.data();
     png_charp dp = text[0].text;
     *dp++ = '\n';
 
     memcpy(dp, profile_type.toLatin1().constData(), profile_type.length());
 
     dp += description_length;
     *dp++ = '\n';
 
     formatString(dp, allocated_length - strlen(text[0].text), "%8lu ", profile_data.length());
 
     dp += 8;
 
     for (long i = 0; i < (long) profile_data.length(); i++) {
         if (i % 36 == 0)
             *dp++ = '\n';
 
         *(dp++) = (char) hex[((*sp >> 4) & 0x0f)];
         *(dp++) = (char) hex[((*sp++) & 0x0f)];
     }
 
     *dp++ = '\n';
     *dp = '\0';
     text[0].text_length = (png_size_t)(dp - text[0].text);
     text[0].compression = -1;
 
     if (text[0].text_length <= allocated_length)
         png_set_text(ping, ping_info, text, 1);
 
     png_free(ping, text[0].text);
     png_free(ping, text);
 }
 
 QByteArray png_read_raw_profile(png_textp text)
 {
     QByteArray profile;
 
     static const unsigned char unhex[103] = {
         0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
         0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
         0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 0, 0,
         0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
         0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 10, 11, 12,
         13, 14, 15
     };
 
     png_charp sp = text[0].text + 1;
     /* look for newline */
     while (*sp != '\n')
         sp++;
     /* look for length */
     while (*sp == '\0' || *sp == ' ' || *sp == '\n')
         sp++;
     png_uint_32 length = (png_uint_32) atol(sp);
     while (*sp != ' ' && *sp != '\n')
         sp++;
     if (length == 0) {
         return profile;
     }
     profile.resize(length);
     /* copy profile, skipping white space and column 1 "=" signs */
     unsigned char *dp = (unsigned char*)profile.data();
     png_uint_32 nibbles = length * 2;
     for (png_uint_32 i = 0; i < nibbles; i++) {
         while (*sp < '0' || (*sp > '9' && *sp < 'a') || *sp > 'f') {
             if (*sp == '\0') {
                 return QByteArray();
             }
             sp++;
         }
         if (i % 2 == 0)
             *dp = (unsigned char)(16 * unhex[(int) *sp++]);
         else
             (*dp++) += unhex[(int) *sp++];
     }
     return profile;
 }
 
 void decode_meta_data(png_textp text, KisMetaData::Store* store, QString type, int headerSize)
 {
     dbgFile << "Decoding " << type << " " << text[0].key;
     KisMetaData::IOBackend* exifIO = KisMetaData::IOBackendRegistry::instance()->value(type);
     Q_ASSERT(exifIO);
 
     QByteArray rawProfile = png_read_raw_profile(text);
     if (headerSize > 0) {
         rawProfile.remove(0, headerSize);
     }
     if (rawProfile.size() > 0) {
         QBuffer buffer;
         buffer.setData(rawProfile);
         exifIO->loadFrom(store, &buffer);
     } else {
         dbgFile << "Decoding failed";
     }
 }
 }
 
 KisPNGConverter::KisPNGConverter(KisDocument *doc, bool batchMode)
 {
     //     Q_ASSERT(doc);
     //     Q_ASSERT(adapter);
 
     m_doc = doc;
     m_stop = false;
     m_max_row = 0;
     m_image = 0;
     m_batchMode = batchMode;
 }
 
 KisPNGConverter::~KisPNGConverter()
 {
 }
 
 class KisPNGReadStream
 {
 public:
     KisPNGReadStream(quint8* buf,  quint32 depth) : m_posinc(8), m_depth(depth), m_buf(buf) {
     }
     int nextValue() {
         if (m_posinc == 0) {
             m_posinc = 8;
             m_buf++;
         }
         m_posinc -= m_depth;
         return (((*m_buf) >> (m_posinc)) & ((1 << m_depth) - 1));
     }
 private:
     quint32 m_posinc, m_depth;
     quint8* m_buf;
 };
 
 class KisPNGWriteStream
 {
 public:
     KisPNGWriteStream(quint8* buf,  quint32 depth) : m_posinc(8), m_depth(depth), m_buf(buf) {
         *m_buf = 0;
     }
     void setNextValue(int v) {
         if (m_posinc == 0) {
             m_posinc = 8;
             m_buf++;
             *m_buf = 0;
         }
         m_posinc -= m_depth;
         *m_buf = (v << m_posinc) | *m_buf;
     }
 private:
     quint32 m_posinc, m_depth;
     quint8* m_buf;
 };
 
 class KisPNGReaderAbstract
 {
 public:
     KisPNGReaderAbstract(png_structp _png_ptr, int _width, int _height) : png_ptr(_png_ptr), width(_width), height(_height) {}
     virtual ~KisPNGReaderAbstract() {}
     virtual png_bytep readLine() = 0;
 protected:
     png_structp png_ptr;
     int width, height;
 };
 
 class KisPNGReaderLineByLine : public KisPNGReaderAbstract
 {
 public:
     KisPNGReaderLineByLine(png_structp _png_ptr, png_infop info_ptr, int _width, int _height) : KisPNGReaderAbstract(_png_ptr, _width, _height) {
         png_uint_32 rowbytes = png_get_rowbytes(png_ptr, info_ptr);
         row_pointer = new png_byte[rowbytes];
     }
     ~KisPNGReaderLineByLine() override {
         delete[] row_pointer;
     }
     png_bytep readLine() override {
         png_read_row(png_ptr, row_pointer, 0);
         return row_pointer;
     }
 private:
     png_bytep row_pointer;
 };
 
 class KisPNGReaderFullImage : public KisPNGReaderAbstract
 {
 public:
     KisPNGReaderFullImage(png_structp _png_ptr, png_infop info_ptr, int _width, int _height) : KisPNGReaderAbstract(_png_ptr, _width, _height), y(0) {
         row_pointers = new png_bytep[height];
         png_uint_32 rowbytes = png_get_rowbytes(png_ptr, info_ptr);
         for (int i = 0; i < height; i++) {
             row_pointers[i] = new png_byte[rowbytes];
         }
         png_read_image(png_ptr, row_pointers);
     }
     ~KisPNGReaderFullImage() override {
         for (int i = 0; i < height; i++) {
             delete[] row_pointers[i];
         }
         delete[] row_pointers;
     }
     png_bytep readLine() override {
         return row_pointers[y++];
     }
 private:
     png_bytepp row_pointers;
     int y;
 };
 
 
 static
 void _read_fn(png_structp png_ptr, png_bytep data, png_size_t length)
 {
     QIODevice *in = (QIODevice *)png_get_io_ptr(png_ptr);
 
     while (length) {
         int nr = in->read((char*)data, length);
         if (nr <= 0) {
             png_error(png_ptr, "Read Error");
             return;
         }
         length -= nr;
     }
 }
 
 static
 void _write_fn(png_structp png_ptr, png_bytep data, png_size_t length)
 {
     QIODevice* out = (QIODevice*)png_get_io_ptr(png_ptr);
 
     uint nr = out->write((char*)data, length);
     if (nr != length) {
         png_error(png_ptr, "Write Error");
         return;
     }
 }
 
 static
 void _flush_fn(png_structp png_ptr)
 {
     Q_UNUSED(png_ptr);
 }
 
 
 KisImageBuilder_Result KisPNGConverter::buildImage(QIODevice* iod)
 {
     dbgFile << "Start decoding PNG File";
 
     png_byte signature[8];
     iod->peek((char*)signature, 8);
 
 #if PNG_LIBPNG_VER < 10400
     if (!png_check_sig(signature, 8)) {
 #else
     if (png_sig_cmp(signature, 0, 8) != 0) {
 #endif
         iod->close();
         return (KisImageBuilder_RESULT_BAD_FETCH);
     }
 
     // Initialize the internal structures
     png_structp png_ptr =  png_create_read_struct(PNG_LIBPNG_VER_STRING, 0, 0, 0);
     if (!png_ptr) {
         iod->close();
     }
 
     png_infop info_ptr = png_create_info_struct(png_ptr);
     if (!info_ptr) {
         png_destroy_read_struct(&png_ptr, (png_infopp)0, (png_infopp)0);
         iod->close();
         return (KisImageBuilder_RESULT_FAILURE);
     }
 
     png_infop end_info = png_create_info_struct(png_ptr);
     if (!end_info) {
         png_destroy_read_struct(&png_ptr, &info_ptr, (png_infopp)0);
         iod->close();
         return (KisImageBuilder_RESULT_FAILURE);
     }
 
     // Catch errors
     if (setjmp(png_jmpbuf(png_ptr))) {
         png_destroy_read_struct(&png_ptr, &info_ptr, &end_info);
         iod->close();
         return (KisImageBuilder_RESULT_FAILURE);
     }
 
     // Initialize the special
     png_set_read_fn(png_ptr, iod, _read_fn);
 
 #if defined(PNG_SKIP_sRGB_CHECK_PROFILE) && defined(PNG_SET_OPTION_SUPPORTED)
     png_set_option(png_ptr, PNG_SKIP_sRGB_CHECK_PROFILE, PNG_OPTION_ON);
 #endif
 
     // read all PNG info up to image data
     png_read_info(png_ptr, info_ptr);
 
 
     if (png_get_color_type(png_ptr, info_ptr) == PNG_COLOR_TYPE_GRAY && png_get_bit_depth(png_ptr, info_ptr) < 8) {
         png_set_expand(png_ptr);
     }
 
     if (png_get_color_type(png_ptr, info_ptr) == PNG_COLOR_TYPE_PALETTE && png_get_bit_depth(png_ptr, info_ptr) < 8) {
         png_set_packing(png_ptr);
     }
 
 
     if (png_get_color_type(png_ptr, info_ptr) != PNG_COLOR_TYPE_PALETTE &&
             (png_get_valid(png_ptr, info_ptr, PNG_INFO_tRNS))) {
         png_set_expand(png_ptr);
     }
     png_read_update_info(png_ptr, info_ptr);
 
     // Read information about the png
     png_uint_32 width, height;
     int color_nb_bits, color_type, interlace_type;
     png_get_IHDR(png_ptr, info_ptr, &width, &height, &color_nb_bits, &color_type, &interlace_type, 0, 0);
     dbgFile << "width = " << width << " height = " << height << " color_nb_bits = " << color_nb_bits << " color_type = " << color_type << " interlace_type = " << interlace_type << endl;
     // swap byteorder on little endian machines.
 #ifndef WORDS_BIGENDIAN
     if (color_nb_bits > 8)
         png_set_swap(png_ptr);
 #endif
 
     // Determine the colorspace
     QPair<QString, QString> csName = getColorSpaceForColorType(color_type, color_nb_bits);
     if (csName.first.isEmpty()) {
         png_destroy_read_struct(&png_ptr, &info_ptr, &end_info);
         iod->close();
         return KisImageBuilder_RESULT_UNSUPPORTED_COLORSPACE;
     }
     bool hasalpha = (color_type == PNG_COLOR_TYPE_RGB_ALPHA || color_type == PNG_COLOR_TYPE_GRAY_ALPHA);
 
     // Read image profile
     png_charp profile_name;
 #if PNG_LIBPNG_VER_MAJOR >= 1 && PNG_LIBPNG_VER_MINOR >= 5
     png_bytep profile_data;
 #else
     png_charp profile_data;
 #endif
     int compression_type;
     png_uint_32 proflen;
 
     // Get the various optional chunks
 
     // https://www.w3.org/TR/PNG/#11cHRM
 #if defined(PNG_cHRM_SUPPORTED)
     double whitePointX, whitePointY;
     double redX, redY;
     double greenX, greenY;
     double blueX, blueY;
     png_get_cHRM(png_ptr,info_ptr, &whitePointX, &whitePointY, &redX, &redY, &greenX, &greenY, &blueX, &blueY);
     qDebug() << "cHRM:" << whitePointX << whitePointY << redX << redY << greenX << greenY << blueX << blueY;
 #endif
 
     // https://www.w3.org/TR/PNG/#11gAMA
 #if defined(PNG_GAMMA_SUPPORTED)
     double gamma;
     png_get_gAMA(png_ptr, info_ptr, &gamma);
     qDebug() << "gAMA" << gamma;
 #endif
 
     // https://www.w3.org/TR/PNG/#11sRGB
 #if defined(PNG_sRGB_SUPPORTED)
     int sRGBIntent;
     png_get_sRGB(png_ptr, info_ptr, &sRGBIntent);
     qDebug() << "sRGB" << sRGBIntent;
 #endif
 
 bool fromBlender = false;
 
 png_text* text_ptr;
     int num_comments;
 png_get_text(png_ptr, info_ptr, &text_ptr, &num_comments);
 
         for (int i = 0; i < num_comments; i++) {
             QString key = QString(text_ptr[i].key).toLower();
             if (key == "file") {
                 QString relatedFile = text_ptr[i].text;
                 if (relatedFile.contains(".blend", Qt::CaseInsensitive)){
                     fromBlender=true;
                 }
             }
         }
 
     const KoColorProfile* profile = 0;
     if (png_get_iCCP(png_ptr, info_ptr, &profile_name, &compression_type, &profile_data, &proflen)) {
         QByteArray profile_rawdata;
         // XXX: Hardcoded for icc type -- is that correct for us?
         profile_rawdata.resize(proflen);
         memcpy(profile_rawdata.data(), profile_data, proflen);
         profile = KoColorSpaceRegistry::instance()->createColorProfile(csName.first, csName.second, profile_rawdata);
         Q_CHECK_PTR(profile);
         if (profile) {
             //                 dbgFile << "profile name: " << profile->productName() << " profile description: " << profile->productDescription() << " information sur le produit: " << profile->productInfo();
             if (!profile->isSuitableForOutput()) {
                 dbgFile << "the profile is not suitable for output and therefore cannot be used in krita, we need to convert the image to a standard profile"; // TODO: in ko2 popup a selection menu to inform the user
             }
         }
     }
     else {
         dbgFile << "no embedded profile, will use the default profile";
         if (color_nb_bits == 16 && !fromBlender && !qAppName().toLower().contains("test") && !m_batchMode) {
             KisConfig cfg;
             quint32 behaviour = cfg.pasteBehaviour();
             if (behaviour == PASTE_ASK) {
                 KisDlgPngImport dlg(m_path, csName.first, csName.second);
                 QApplication::restoreOverrideCursor();
                 dlg.exec();
                 if (!dlg.profile().isEmpty()) {
 
                     QString s = KoColorSpaceRegistry::instance()->colorSpaceId(csName.first, csName.second);
 
                     const KoColorSpaceFactory * csf = KoColorSpaceRegistry::instance()->colorSpaceFactory(s);
                     if (csf) {
                         QList<const KoColorProfile *>  profileList = KoColorSpaceRegistry::instance()->profilesFor(csf);
                         Q_FOREACH (const KoColorProfile *p, profileList) {
                             if (p->name() == dlg.profile()) {
                                 profile = p;
                                 break;
                             }
                         }
                     }
                 }
                 QApplication::setOverrideCursor(Qt::WaitCursor);
 
             }
         }
         dbgFile << "no embedded profile, will use the default profile";
     }
 
     // Check that the profile is used by the color space
     if (profile && !KoColorSpaceRegistry::instance()->colorSpaceFactory(
                 KoColorSpaceRegistry::instance()->colorSpaceId(
                     csName.first, csName.second))->profileIsCompatible(profile)) {
         warnFile << "The profile " << profile->name() << " is not compatible with the color space model " << csName.first << " " << csName.second;
         profile = 0;
     }
 
     // Retrieve a pointer to the colorspace
     const KoColorSpace* cs;
     if (profile && profile->isSuitableForOutput()) {
         dbgFile << "image has embedded profile: " << profile->name() << "\n";
         cs = KoColorSpaceRegistry::instance()->colorSpace(csName.first, csName.second, profile);
     }
     else {
         if (csName.first == RGBAColorModelID.id()) {
             cs = KoColorSpaceRegistry::instance()->colorSpace(csName.first, csName.second, "sRGB-elle-V2-srgbtrc.icc");
         }
         else {
             cs = KoColorSpaceRegistry::instance()->colorSpace(csName.first, csName.second, 0);
         }
     }
 
     if (cs == 0) {
         png_destroy_read_struct(&png_ptr, &info_ptr, &end_info);
         return KisImageBuilder_RESULT_UNSUPPORTED_COLORSPACE;
     }
     //TODO: two fixes : one tell the user about the problem and ask for a solution, and two once the kocolorspace include KoColorTransformation, use that instead of hacking a lcms transformation
     // Create the cmsTransform if needed
     KoColorTransformation* transform = 0;
     if (profile && !profile->isSuitableForOutput()) {
         transform = KoColorSpaceRegistry::instance()->colorSpace(csName.first, csName.second, profile)->createColorConverter(cs, KoColorConversionTransformation::internalRenderingIntent(), KoColorConversionTransformation::internalConversionFlags());
     }
 
     // Creating the KisImageWSP
     if (m_image == 0) {
         m_image = new KisImage(m_doc->createUndoStore(), width, height, cs, "built image");
         Q_CHECK_PTR(m_image);
     }
 
     // Read resolution
     int unit_type;
     png_uint_32 x_resolution, y_resolution;
 
     png_get_pHYs(png_ptr, info_ptr, &x_resolution, &y_resolution, &unit_type);
     if (x_resolution > 0 && y_resolution > 0 && unit_type == PNG_RESOLUTION_METER) {
         m_image->setResolution((double) POINT_TO_CM(x_resolution) / 100.0, (double) POINT_TO_CM(y_resolution) / 100.0); // It is the "invert" macro because we convert from pointer-per-inchs to points
     }
 
     double coeff = quint8_MAX / (double)(pow((double)2, color_nb_bits) - 1);
     KisPaintLayerSP layer = new KisPaintLayer(m_image.data(), m_image -> nextLayerName(), UCHAR_MAX);
 
     // Read comments/texts...
     png_get_text(png_ptr, info_ptr, &text_ptr, &num_comments);
     if (m_doc) {
         KoDocumentInfo * info = m_doc->documentInfo();
         dbgFile << "There are " << num_comments << " comments in the text";
         for (int i = 0; i < num_comments; i++) {
             QString key = QString(text_ptr[i].key).toLower();
             dbgFile << "key is |" << text_ptr[i].key << "| containing " << text_ptr[i].text << " " << (key ==  "Raw profile type exif ");
             if (key == "title") {
                 info->setAboutInfo("title", text_ptr[i].text);
             } else if (key == "description") {
                 info->setAboutInfo("comment", text_ptr[i].text);
             } else if (key == "author") {
         qDebug()<<"Author:"<<text_ptr[i].text;
                 info->setAuthorInfo("creator", text_ptr[i].text);
             } else if (key.contains("Raw profile type exif")) {
                 decode_meta_data(text_ptr + i, layer->metaData(), "exif", 6);
             } else if (key.contains("Raw profile type iptc")) {
                 decode_meta_data(text_ptr + i, layer->metaData(), "iptc", 14);
             } else if (key.contains("Raw profile type xmp")) {
                 decode_meta_data(text_ptr + i, layer->metaData(), "xmp", 0);
             } else if (key == "version") {
                 m_image->addAnnotation(new KisAnnotation("kpp_version", "version", QByteArray(text_ptr[i].text)));
             } else if (key == "preset") {
                 m_image->addAnnotation(new KisAnnotation("kpp_preset", "preset", QByteArray(text_ptr[i].text)));
             }
         }
     }
 
     // Read image data
     KisPNGReaderAbstract* reader = 0;
     try {
         if (interlace_type == PNG_INTERLACE_ADAM7) {
             reader = new KisPNGReaderFullImage(png_ptr, info_ptr, width, height);
         } else {
             reader = new KisPNGReaderLineByLine(png_ptr, info_ptr, width, height);
         }
     } catch (std::bad_alloc& e) {
         // new png_byte[] may raise such an exception if the image
         // is invalid / to large.
         dbgFile << "bad alloc: " << e.what();
         // Free only the already allocated png_byte instances.
         png_destroy_read_struct(&png_ptr, &info_ptr, &end_info);
         return (KisImageBuilder_RESULT_FAILURE);
     }
 
     // Read the palette if the file is indexed
     png_colorp palette ;
     int num_palette;
     if (color_type == PNG_COLOR_TYPE_PALETTE) {
         png_get_PLTE(png_ptr, info_ptr, &palette, &num_palette);
     }
 
     // Read the transparency palette
     quint8 palette_alpha[256];
     memset(palette_alpha, 255, 256);
     if (png_get_valid(png_ptr, info_ptr, PNG_INFO_tRNS)) {
         if (color_type == PNG_COLOR_TYPE_PALETTE) {
             png_bytep alpha_ptr;
             int num_alpha;
             png_get_tRNS(png_ptr, info_ptr, &alpha_ptr, &num_alpha, 0);
             for (int i = 0; i < num_alpha; ++i) {
                 palette_alpha[i] = alpha_ptr[i];
             }
         }
     }
 
     for (png_uint_32 y = 0; y < height; y++) {
         KisHLineIteratorSP it = layer -> paintDevice() -> createHLineIteratorNG(0, y, width);
 
         png_bytep row_pointer = reader->readLine();
 
         switch (color_type) {
         case PNG_COLOR_TYPE_GRAY:
         case PNG_COLOR_TYPE_GRAY_ALPHA:
             if (color_nb_bits == 16) {
                 quint16 *src = reinterpret_cast<quint16 *>(row_pointer);
                 do {
                     quint16 *d = reinterpret_cast<quint16 *>(it->rawData());
                     d[0] = *(src++);
                     if (transform) transform->transform(reinterpret_cast<quint8*>(d), reinterpret_cast<quint8*>(d), 1);
                     if (hasalpha) {
                         d[1] = *(src++);
                     } else {
                         d[1] = quint16_MAX;
                     }
                 } while (it->nextPixel());
             } else  {
                 KisPNGReadStream stream(row_pointer, color_nb_bits);
                 do {
                     quint8 *d = it->rawData();
                     d[0] = (quint8)(stream.nextValue() * coeff);
                     if (transform) transform->transform(d, d, 1);
                     if (hasalpha) {
                         d[1] = (quint8)(stream.nextValue() * coeff);
                     } else {
                         d[1] = UCHAR_MAX;
                     }
                 } while (it->nextPixel());
             }
             // FIXME:should be able to read 1 and 4 bits depth and scale them to 8 bits"
             break;
         case PNG_COLOR_TYPE_RGB:
         case PNG_COLOR_TYPE_RGB_ALPHA:
             if (color_nb_bits == 16) {
                 quint16 *src = reinterpret_cast<quint16 *>(row_pointer);
                 do {
                     quint16 *d = reinterpret_cast<quint16 *>(it->rawData());
                     d[2] = *(src++);
                     d[1] = *(src++);
                     d[0] = *(src++);
                     if (transform) transform->transform(reinterpret_cast<quint8 *>(d), reinterpret_cast<quint8*>(d), 1);
                     if (hasalpha) d[3] = *(src++);
                     else d[3] = quint16_MAX;
                 } while (it->nextPixel());
             } else {
                 KisPNGReadStream stream(row_pointer, color_nb_bits);
                 do {
                     quint8 *d = it->rawData();
                     d[2] = (quint8)(stream.nextValue() * coeff);
                     d[1] = (quint8)(stream.nextValue() * coeff);
                     d[0] = (quint8)(stream.nextValue() * coeff);
                     if (transform) transform->transform(d, d, 1);
                     if (hasalpha) d[3] = (quint8)(stream.nextValue() * coeff);
                     else d[3] = UCHAR_MAX;
                 } while (it->nextPixel());
             }
             break;
         case PNG_COLOR_TYPE_PALETTE: {
             KisPNGReadStream stream(row_pointer, color_nb_bits);
             do {
                 quint8 *d = it->rawData();
                 quint8 index = stream.nextValue();
                 quint8 alpha = palette_alpha[ index ];
                 if (alpha == 0) {
                     memset(d, 0, 4);
                 } else {
                     png_color c = palette[ index ];
                     d[2] = c.red;
                     d[1] = c.green;
                     d[0] = c.blue;
                     d[3] = alpha;
                 }
             } while (it->nextPixel());
         }
             break;
         default:
             return KisImageBuilder_RESULT_UNSUPPORTED;
         }
     }
     m_image->addNode(layer.data(), m_image->rootLayer().data());
 
     png_read_end(png_ptr, end_info);
     iod->close();
 
     // Freeing memory
     png_destroy_read_struct(&png_ptr, &info_ptr, &end_info);
 
     delete reader;
     return KisImageBuilder_RESULT_OK;
 
 }
 
 KisImageBuilder_Result KisPNGConverter::buildImage(const QString &filename)
 {
     m_path = filename;
 
     QFile fp(filename);
     if (fp.exists()) {
         if (!fp.open(QIODevice::ReadOnly)) {
             dbgFile << "Failed to open PNG File";
             return (KisImageBuilder_RESULT_FAILURE);
         }
 
         return buildImage(&fp);
     }
     return (KisImageBuilder_RESULT_NOT_EXIST);
 
 }
 
 
 KisImageSP KisPNGConverter::image()
 {
     return m_image;
 }
 
 bool KisPNGConverter::saveDeviceToStore(const QString &filename, const QRect &imageRect, const qreal xRes, const qreal yRes, KisPaintDeviceSP dev, KoStore *store, KisMetaData::Store* metaData)
 {
     if (store->open(filename)) {
         KoStoreDevice io(store);
         if (!io.open(QIODevice::WriteOnly)) {
             dbgFile << "Could not open for writing:" << filename;
             return false;
         }
         KisPNGConverter pngconv(0);
         vKisAnnotationSP_it annotIt = 0;
         KisMetaData::Store* metaDataStore = 0;
         if (metaData) {
             metaDataStore = new KisMetaData::Store(*metaData);
         }
         KisPNGOptions options;
         options.compression = 0;
         options.interlace = false;
         options.tryToSaveAsIndexed = false;
         options.alpha = true;
         options.saveSRGBProfile = false;
 
         if (dev->colorSpace()->id() != "RGBA") {
             dev = new KisPaintDevice(*dev.data());
             KUndo2Command *cmd = dev->convertTo(KoColorSpaceRegistry::instance()->rgb8());
             delete cmd;
         }
 
         bool success = pngconv.buildFile(&io, imageRect, xRes, yRes, dev, annotIt, annotIt, options, metaDataStore);
         if (success != KisImageBuilder_RESULT_OK) {
             dbgFile << "Saving PNG failed:" << filename;
             delete metaDataStore;
             return false;
         }
         delete metaDataStore;
         io.close();
         if (!store->close()) {
             return false;
         }
     } else {
         dbgFile << "Opening of data file failed :" << filename;
         return false;
     }
     return true;
 
 }
 
 
 KisImageBuilder_Result KisPNGConverter::buildFile(const QString &filename, const QRect &imageRect, const qreal xRes, const qreal yRes, KisPaintDeviceSP device, vKisAnnotationSP_it annotationsStart, vKisAnnotationSP_it annotationsEnd, KisPNGOptions options, KisMetaData::Store* metaData)
 {
     dbgFile << "Start writing PNG File " << filename;
     // Open a QIODevice for writing
     QFile fp (filename);
     if (!fp.open(QIODevice::WriteOnly)) {
         dbgFile << "Failed to open PNG File for writing";
         return (KisImageBuilder_RESULT_FAILURE);
     }
 
     KisImageBuilder_Result result = buildFile(&fp, imageRect, xRes, yRes, device, annotationsStart, annotationsEnd, options, metaData);
 
     return result;
 }
 
 KisImageBuilder_Result KisPNGConverter::buildFile(QIODevice* iodevice, const QRect &imageRect, const qreal xRes, const qreal yRes, KisPaintDeviceSP device, vKisAnnotationSP_it annotationsStart, vKisAnnotationSP_it annotationsEnd, KisPNGOptions options, KisMetaData::Store* metaData)
 {
     if (!device)
         return KisImageBuilder_RESULT_INVALID_ARG;
 
     if (!options.alpha) {
         KisPaintDeviceSP tmp = new KisPaintDevice(device->colorSpace());
         KoColor c(options.transparencyFillColor, device->colorSpace());
         tmp->fill(imageRect, c);
         KisPainter gc(tmp);
         gc.bitBlt(imageRect.topLeft(), device, imageRect);
         gc.end();
         device = tmp;
     }
 
     if (device->colorSpace()->colorDepthId() == Float16BitsColorDepthID
             || device->colorSpace()->colorDepthId() == Float32BitsColorDepthID
             || device->colorSpace()->colorDepthId() == Float64BitsColorDepthID) {
         const KoColorSpace *dstcs = KoColorSpaceRegistry::instance()->colorSpace(device->colorSpace()->colorModelId().id(), Integer8BitsColorDepthID.id(), "");
         KisPaintDeviceSP tmp = new KisPaintDevice(dstcs);
         KisPainter gc(tmp);
         gc.bitBlt(imageRect.topLeft(), device, imageRect);
         gc.end();
         device = tmp;
     }
 
     if (options.forceSRGB) {
         const KoColorSpace* cs = KoColorSpaceRegistry::instance()->colorSpace(RGBAColorModelID.id(), device->colorSpace()->colorDepthId().id(), "sRGB built-in - (lcms internal)");
         device = new KisPaintDevice(*device);
         device->convertTo(cs);
     }
 
     // Initialize structures
     png_structp png_ptr =  png_create_write_struct(PNG_LIBPNG_VER_STRING, 0, 0, 0);
     if (!png_ptr) {
         return (KisImageBuilder_RESULT_FAILURE);
     }
 
 #if defined(PNG_SKIP_sRGB_CHECK_PROFILE) && defined(PNG_SET_OPTION_SUPPORTED)
     png_set_option(png_ptr, PNG_SKIP_sRGB_CHECK_PROFILE, PNG_OPTION_ON);
 #endif
 
 
 #ifdef PNG_READ_CHECK_FOR_INVALID_INDEX_SUPPORTED
     png_set_check_for_invalid_index(png_ptr, 0);
 #endif
 
     png_infop info_ptr = png_create_info_struct(png_ptr);
     if (!info_ptr) {
         png_destroy_write_struct(&png_ptr, (png_infopp)0);
         return (KisImageBuilder_RESULT_FAILURE);
     }
 
     // If an error occurs during writing, libpng will jump here
     if (setjmp(png_jmpbuf(png_ptr))) {
         png_destroy_write_struct(&png_ptr, &info_ptr);
         return (KisImageBuilder_RESULT_FAILURE);
     }
     // Initialize the writing
     //     png_init_io(png_ptr, fp);
     // Setup the progress function
     // XXX: Implement progress updating -- png_set_write_status_fn(png_ptr, progress);"
     //     setProgressTotalSteps(100/*height*/);
 
     /* set the zlib compression level */
     png_set_compression_level(png_ptr, options.compression);
 
     png_set_write_fn(png_ptr, (void*)iodevice, _write_fn, _flush_fn);
 
     /* set other zlib parameters */
     png_set_compression_mem_level(png_ptr, 8);
     png_set_compression_strategy(png_ptr, Z_DEFAULT_STRATEGY);
     png_set_compression_window_bits(png_ptr, 15);
     png_set_compression_method(png_ptr, 8);
     png_set_compression_buffer_size(png_ptr, 8192);
 
     int color_nb_bits = 8 * device->pixelSize() / device->channelCount();
     int color_type = getColorTypeforColorSpace(device->colorSpace(), options.alpha);
 
     Q_ASSERT(color_type > -1);
 
     // Try to compute a table of color if the colorspace is RGB8f
     png_colorp palette = 0;
     int num_palette = 0;
     if (!options.alpha && options.tryToSaveAsIndexed && KoID(device->colorSpace()->id()) == KoID("RGBA")) { // png doesn't handle indexed images and alpha, and only have indexed for RGB8
         palette = new png_color[255];
 
         KisSequentialIterator it(device, imageRect);
 
         bool toomuchcolor = false;
         do {
             const quint8* c = it.oldRawData();
             bool findit = false;
             for (int i = 0; i < num_palette; i++) {
                 if (palette[i].red == c[2] &&
                         palette[i].green == c[1] &&
                         palette[i].blue == c[0]) {
                     findit = true;
                     break;
                 }
             }
             if (!findit) {
                 if (num_palette == 255) {
                     toomuchcolor = true;
                     break;
                 }
                 palette[num_palette].red = c[2];
                 palette[num_palette].green = c[1];
                 palette[num_palette].blue = c[0];
                 num_palette++;
             }
         }  while (it.nextPixel());
 
         if (!toomuchcolor) {
             dbgFile << "Found a palette of " << num_palette << " colors";
             color_type = PNG_COLOR_TYPE_PALETTE;
             if (num_palette <= 2) {
                 color_nb_bits = 1;
             } else if (num_palette <= 4) {
                 color_nb_bits = 2;
             } else if (num_palette <= 16) {
                 color_nb_bits = 4;
             } else {
                 color_nb_bits = 8;
             }
         } else {
             delete [] palette;
         }
     }
 
     int interlacetype = options.interlace ? PNG_INTERLACE_ADAM7 : PNG_INTERLACE_NONE;
 
     png_set_IHDR(png_ptr, info_ptr,
                  imageRect.width(),
                  imageRect.height(),
                  color_nb_bits,
                  color_type, interlacetype,
                  PNG_COMPRESSION_TYPE_DEFAULT, PNG_FILTER_TYPE_DEFAULT);
 
     // set sRGB only if the profile is sRGB  -- http://www.w3.org/TR/PNG/#11sRGB says sRGB and iCCP should not both be present
 
     bool sRGB = device->colorSpace()->profile()->name().contains(QLatin1String("srgb"), Qt::CaseInsensitive);
     /*
      * This automatically writes the correct gamma and chroma chunks along with the sRGB chunk, but firefox's
      * color management is bugged, so once you give it any incentive to start color managing an sRGB image it
      * will turn, for example, a nice desaturated rusty red into bright poppy red. So this is disabled for now.
      */
     /*if (!options.saveSRGBProfile && sRGB) {
         png_set_sRGB_gAMA_and_cHRM(png_ptr, info_ptr, PNG_sRGB_INTENT_PERCEPTUAL);
     }*/
     // set the palette
     if (color_type == PNG_COLOR_TYPE_PALETTE) {
         png_set_PLTE(png_ptr, info_ptr, palette, num_palette);
     }
     // Save annotation
     vKisAnnotationSP_it it = annotationsStart;
     while (it != annotationsEnd) {
         if (!(*it) || (*it)->type().isEmpty()) {
             dbgFile << "Warning: empty annotation";
             it++;
             continue;
         }
 
         dbgFile << "Trying to store annotation of type " << (*it) -> type() << " of size " << (*it) -> annotation() . size();
 
         if ((*it) -> type().startsWith(QString("krita_attribute:"))) { //
             // Attribute
             // XXX: it should be possible to save krita_attributes in the \"CHUNKs\""
             dbgFile << "cannot save this annotation : " << (*it) -> type();
         } else if ((*it)->type() == "kpp_version" || (*it)->type() == "kpp_preset" ) {
             dbgFile << "Saving preset information " << (*it)->description();
             png_textp      text = (png_textp) png_malloc(png_ptr, (png_uint_32) sizeof(png_text));
 
             QByteArray keyData = (*it)->description().toLatin1();
             text[0].key = keyData.data();
             text[0].text = (char*)(*it)->annotation().data();
             text[0].text_length = (*it)->annotation().size();
             text[0].compression = -1;
 
             png_set_text(png_ptr, info_ptr, text, 1);
             png_free(png_ptr, text);
         }
         it++;
     }
 
     // Save the color profile
     const KoColorProfile* colorProfile = device->colorSpace()->profile();
     QByteArray colorProfileData = colorProfile->rawData();
     if (!sRGB || options.saveSRGBProfile) {
 #if PNG_LIBPNG_VER_MAJOR >= 1 && PNG_LIBPNG_VER_MINOR >= 5
         png_set_iCCP(png_ptr, info_ptr, (char*)"icc", PNG_COMPRESSION_TYPE_BASE, (const png_bytep)colorProfileData.constData(), colorProfileData . size());
 #else
         png_set_iCCP(png_ptr, info_ptr, (char*)"icc", PNG_COMPRESSION_TYPE_BASE, (char*)colorProfileData.constData(), colorProfileData . size());
 #endif
     }
 
     // read comments from the document information
     // warning: according to the official png spec, the keys need to be capitalised!
     if (m_doc) {
         png_text texts[3];
         int nbtexts = 0;
         KoDocumentInfo * info = m_doc->documentInfo();
         QString title = info->aboutInfo("title");
         if (!title.isEmpty()) {
             fillText(texts + nbtexts, "Title", title);
             nbtexts++;
         }
         QString abstract = info->aboutInfo("comment");
         if (!abstract.isEmpty()) {
             fillText(texts + nbtexts, "Description", abstract);
             nbtexts++;
         }
         QString author = info->authorInfo("creator");
         if (!author.isEmpty()) {
             fillText(texts + nbtexts, "Author", author);
             nbtexts++;
         }
 
         png_set_text(png_ptr, info_ptr, texts, nbtexts);
     }
 
     // Save metadata following imagemagick way
 
     // Save exif
     if (metaData && !metaData->empty()) {
         if (options.exif) {
             dbgFile << "Trying to save exif information";
 
             KisMetaData::IOBackend* exifIO = KisMetaData::IOBackendRegistry::instance()->value("exif");
             Q_ASSERT(exifIO);
 
             QBuffer buffer;
             exifIO->saveTo(metaData, &buffer, KisMetaData::IOBackend::JpegHeader);
             writeRawProfile(png_ptr, info_ptr, "exif", buffer.data());
         }
         // Save IPTC
         if (options.iptc) {
             dbgFile << "Trying to save exif information";
             KisMetaData::IOBackend* iptcIO = KisMetaData::IOBackendRegistry::instance()->value("iptc");
             Q_ASSERT(iptcIO);
 
             QBuffer buffer;
             iptcIO->saveTo(metaData, &buffer, KisMetaData::IOBackend::JpegHeader);
 
             dbgFile << "IPTC information size is" << buffer.data().size();
             writeRawProfile(png_ptr, info_ptr, "iptc", buffer.data());
         }
         // Save XMP
         if (options.xmp) {
             dbgFile << "Trying to save XMP information";
             KisMetaData::IOBackend* xmpIO = KisMetaData::IOBackendRegistry::instance()->value("xmp");
             Q_ASSERT(xmpIO);
 
             QBuffer buffer;
             xmpIO->saveTo(metaData, &buffer, KisMetaData::IOBackend::NoHeader);
 
             dbgFile << "XMP information size is" << buffer.data().size();
             writeRawProfile(png_ptr, info_ptr, "xmp", buffer.data());
         }
     }
 #if 0 // Unimplemented?
     // Save resolution
     int unit_type;
     png_uint_32 x_resolution, y_resolution;
 #endif
     png_set_pHYs(png_ptr, info_ptr, CM_TO_POINT(xRes) * 100.0, CM_TO_POINT(yRes) * 100.0, PNG_RESOLUTION_METER); // It is the "invert" macro because we convert from pointer-per-inchs to points
 
     // Save the information to the file
     png_write_info(png_ptr, info_ptr);
     png_write_flush(png_ptr);
 
     // swap byteorder on little endian machines.
 #ifndef WORDS_BIGENDIAN
     if (color_nb_bits > 8)
         png_set_swap(png_ptr);
 #endif
 
     // Write the PNG
     //     png_write_png(png_ptr, info_ptr, PNG_TRANSFORM_IDENTITY, 0);
 
     // Fill the data structure
     png_byte** row_pointers = new png_byte*[imageRect.height()];
     int row = 0;
     for (int y = imageRect.y(); y < imageRect.y() + imageRect.height(); y++, row++) {
         KisHLineConstIteratorSP it = device->createHLineConstIteratorNG(imageRect.x(), y, imageRect.width());
 
         row_pointers[row] = new png_byte[imageRect.width() * device->pixelSize()];
 
         switch (color_type) {
         case PNG_COLOR_TYPE_GRAY:
         case PNG_COLOR_TYPE_GRAY_ALPHA:
             if (color_nb_bits == 16) {
                 quint16 *dst = reinterpret_cast<quint16 *>(row_pointers[row]);
                 do {
                     const quint16 *d = reinterpret_cast<const quint16 *>(it->oldRawData());
                     *(dst++) = d[0];
                     if (options.alpha) *(dst++) = d[1];
                 } while (it->nextPixel());
             } else {
                 quint8 *dst = row_pointers[row];
                 do {
                     const quint8 *d = it->oldRawData();
                     *(dst++) = d[0];
                     if (options.alpha) *(dst++) = d[1];
                 } while (it->nextPixel());
             }
             break;
         case PNG_COLOR_TYPE_RGB:
         case PNG_COLOR_TYPE_RGB_ALPHA:
             if (color_nb_bits == 16) {
                 quint16 *dst = reinterpret_cast<quint16 *>(row_pointers[row]);
                 do {
                     const quint16 *d = reinterpret_cast<const quint16 *>(it->oldRawData());
                     *(dst++) = d[2];
                     *(dst++) = d[1];
                     *(dst++) = d[0];
                     if (options.alpha) *(dst++) = d[3];
                 } while (it->nextPixel());
             } else {
                 quint8 *dst = row_pointers[row];
                 do {
                     const quint8 *d = it->oldRawData();
                     *(dst++) = d[2];
                     *(dst++) = d[1];
                     *(dst++) = d[0];
                     if (options.alpha) *(dst++) = d[3];
                 } while (it->nextPixel());
             }
             break;
         case PNG_COLOR_TYPE_PALETTE: {
             quint8 *dst = row_pointers[row];
             KisPNGWriteStream writestream(dst, color_nb_bits);
             do {
                 const quint8 *d = it->oldRawData();
                 int i;
                 for (i = 0; i < num_palette; i++) {
                     if (palette[i].red == d[2] &&
                             palette[i].green == d[1] &&
                             palette[i].blue == d[0]) {
                         break;
                     }
                 }
                 writestream.setNextValue(i);
             } while (it->nextPixel());
         }
             break;
         default:
             delete[] row_pointers;
             return KisImageBuilder_RESULT_UNSUPPORTED;
         }
     }
 
     png_write_image(png_ptr, row_pointers);
 
     // Writing is over
     png_write_end(png_ptr, info_ptr);
 
     // Free memory
     png_destroy_write_struct(&png_ptr, &info_ptr);
     for (int y = 0; y < imageRect.height(); y++) {
         delete[] row_pointers[y];
     }
     delete[] row_pointers;
 
     if (color_type == PNG_COLOR_TYPE_PALETTE) {
         delete [] palette;
     }
-    iodevice->close();
     return KisImageBuilder_RESULT_OK;
 }
 
 
 void KisPNGConverter::cancel()
 {
     m_stop = true;
 }
 
 void KisPNGConverter::progress(png_structp png_ptr, png_uint_32 row_number, int pass)
 {
     if (png_ptr == 0 || row_number > PNG_MAX_UINT || pass > 7) return;
     //     setProgress(row_number);
 }
 
 bool KisPNGConverter::isColorSpaceSupported(const KoColorSpace *cs)
 {
     return colorSpaceIdSupported(cs->id());
 }
 
 
diff --git a/libs/ui/opengl/kis_opengl.cpp b/libs/ui/opengl/kis_opengl.cpp
index 8819ee25d7..18578809eb 100644
--- a/libs/ui/opengl/kis_opengl.cpp
+++ b/libs/ui/opengl/kis_opengl.cpp
@@ -1,225 +1,225 @@
 /*
  *  Copyright (c) 2007 Adrian Page <adrian@pagenet.plus.com>
  *
  *  This program is free software; you can redistribute it and/or modify
  *  it under the terms of the GNU General Public License as published by
  *  the Free Software Foundation; either version 2 of the License, or
  *  (at your option) any later version.
  *
  *  This program is distributed in the hope that it will be useful,
  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  *  GNU General Public License for more details.
  *
  *  You should have received a copy of the GNU General Public License
  *  along with this program; if not, write to the Free Software
  *  Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
  */
 
 #include "opengl/kis_opengl.h"
 
 #include <QOpenGLContext>
 #include <QOpenGLFunctions>
 
 #include <QApplication>
 #include <QDesktopWidget>
 #include <QPixmapCache>
 
 #include <QDir>
 #include <QFile>
 #include <QDesktopServices>
 #include <QMessageBox>
 #include <QWindow>
 
 #include <klocalizedstring.h>
 
 #include <kis_debug.h>
 #include <kis_config.h>
 
 namespace
 {
     bool initialized = false;
     bool NeedsFenceWorkaround = false;
     bool NeedsPixmapCacheWorkaround = false;
     int glMajorVersion = 0;
     int glMinorVersion = 0;
     bool supportsDeprecatedFunctions = false;
 
     QString Renderer;
 }
 
 void KisOpenGL::initialize()
 {
     if (initialized) return;
 
     setDefaultFormat();
 
     // we need a QSurface active to get our GL functions from the context
     QWindow  surface;
     surface.setSurfaceType( QSurface::OpenGLSurface );
     surface.create();
 
     QOpenGLContext context;
     context.create();
     if (!context.isValid()) return;
 
     context.makeCurrent( &surface );
 
     QOpenGLFunctions  *funcs = context.functions();
     funcs->initializeOpenGLFunctions();
 
+#ifndef GL_RENDERER
+#  define GL_RENDERER 0x1F01
+#endif
+    Renderer = QString((const char*)funcs->glGetString(GL_RENDERER));
+    /**
+     * Warn about Intel's broken video drivers
+     */
+#if defined Q_OS_WIN
+    KisConfig cfg;
+    if (cfg.useOpenGL() && Renderer.startsWith("Intel") && !cfg.readEntry("WarnedAboutIntel", false)) {
+        QMessageBox::information(0,
+                                 i18nc("@title:window", "Krita: Warning"),
+                                 i18n("You have an Intel(R) HD Graphics video adapter.\n"
+                                      "If you experience problems like a crash, a black or blank screen,"
+                                      "please update your display driver to the latest version.\n\n"
+                                      "If Krita crashes, it will disable OpenGL rendering. Please restart Krita in that case.\n After updating your drivers you can re-enable OpenGL in Krita's Settings.\n"));
+        cfg.writeEntry("WarnedAboutIntel", true);
+    }
+#endif
     qDebug() << "OpenGL Info";
     qDebug() << "  Vendor: " << reinterpret_cast<const char *>(funcs->glGetString(GL_VENDOR));
-    qDebug() << "  Renderer: " << reinterpret_cast<const char *>(funcs->glGetString(GL_RENDERER));
+    qDebug() << "  Renderer: " << Renderer;
     qDebug() << "  Version: " << reinterpret_cast<const char *>(funcs->glGetString(GL_VERSION));
     qDebug() << "  Shading language: " << reinterpret_cast<const char *>(funcs->glGetString(GL_SHADING_LANGUAGE_VERSION));
     qDebug() << "  Requested format: " << QSurfaceFormat::defaultFormat();
     qDebug() << "  Current format:   " << context.format();
-
+    
     glMajorVersion = context.format().majorVersion();
     glMinorVersion = context.format().minorVersion();
     supportsDeprecatedFunctions = (context.format().options() & QSurfaceFormat::DeprecatedFunctions);
 
     qDebug() << "     Version:" << glMajorVersion << "." << glMinorVersion;
     qDebug() << "     Supports deprecated functions" << supportsDeprecatedFunctions;
 
     initialized = true;
 }
 
 void KisOpenGL::initializeContext(QOpenGLContext *ctx)
 {
+    KisConfig cfg;
     initialize();
 
     dbgUI << "OpenGL: Opening new context";
 
     // Double check we were given the version we requested
     QSurfaceFormat format = ctx->format();
     QOpenGLFunctions *f = ctx->functions();
     f->initializeOpenGLFunctions();
 
-#ifndef GL_RENDERER
-#  define GL_RENDERER 0x1F01
-#endif
-    Renderer = QString((const char*)f->glGetString(GL_RENDERER));
-
     QFile log(QDesktopServices::storageLocation(QDesktopServices::TempLocation) + "/krita-opengl.txt");
     log.open(QFile::WriteOnly);
     QString vendor((const char*)f->glGetString(GL_VENDOR));
     log.write(vendor.toLatin1());
     log.write(", ");
     log.write(Renderer.toLatin1());
     log.write(", ");
     QString version((const char*)f->glGetString(GL_VERSION));
     log.write(version.toLatin1());
     log.close();
 
     // Check if we have a bugged driver that needs fence workaround
     bool isOnX11 = false;
 #ifdef HAVE_X11
     isOnX11 = true;
 #endif
-    KisConfig cfg;
+    
     if ((isOnX11 && Renderer.startsWith("AMD")) || cfg.forceOpenGLFenceWorkaround()) {
         NeedsFenceWorkaround = true;
     }
 
 
     /**
      * NVidia + Qt's openGL don't play well together and one cannot
      * draw a pixmap on a widget more than once in one rendering cycle.
      *
      * It can be workarounded by drawing strictly via QPixmapCache and
      * only when the pixmap size in bigger than doubled size of the
      * display framebuffer. That is for 8-bit HD display, you should have
      * a cache bigger than 16 MiB. Don't ask me why. (DK)
      *
      * See bug: https://bugs.kde.org/show_bug.cgi?id=361709
      *
      * TODO: check if this workaround is still needed after merging
      *       Qt5+openGL3 branch.
      */
 
     if (vendor.toUpper().contains("NVIDIA")) {
         NeedsPixmapCacheWorkaround = true;
 
         const QRect screenSize = QApplication::desktop()->screenGeometry();
         const int minCacheSize = 20 * 1024;
         const int cacheSize = 2048 + 2 * 4 * screenSize.width() * screenSize.height() / 1024; //KiB
 
         QPixmapCache::setCacheLimit(qMax(minCacheSize, cacheSize));
     }
 
 
-    /**
-     * Warn about Intel's broken video drivers
-     */
-#if defined Q_OS_WIN
-    if (cfg.useOpenGL() && Renderer.startsWith("Intel") && !cfg.readEntry("WarnedAboutIntel", false)) {
-        QMessageBox::information(0,
-                                 i18nc("@title:window", "Krita: Warning"),
-                                 i18n("You have an Intel(R) HD Graphics video adapter.\n"
-                                      "If you experience problems like a crash, a black or blank screen,"
-                                      "please update your display driver to the latest version.\n\n"
-                                      "If Krita crashes, it will disable OpenGL rendering. Please restart Krita in that case.\n After updating your drivers you can re-enable OpenGL in Krita's Settings.\n"));
-        cfg.writeEntry("WarnedAboutIntel", true);
-    }
-#endif
-
 }
 
 // XXX Temporary function to allow LoD on OpenGL3 without triggering
 // all of the other 3.2 functionality, can be removed once we move to Qt5.7
 bool KisOpenGL::supportsLoD()
 {
     initialize();
     return (glMajorVersion * 100 + glMinorVersion) >= 300;
 }
 
 bool KisOpenGL::hasOpenGL3()
 {
     initialize();
     return (glMajorVersion * 100 + glMinorVersion) >= 302;
 }
 
 bool KisOpenGL::supportsFenceSync()
 {
     initialize();
     return glMajorVersion >= 3;
 }
 
 bool KisOpenGL::needsFenceWorkaround()
 {
     initialize();
     return NeedsFenceWorkaround;
 }
 
 bool KisOpenGL::needsPixmapCacheWorkaround()
 {
     initialize();
     return NeedsPixmapCacheWorkaround;
 }
 
 void KisOpenGL::setDefaultFormat()
 {
     QSurfaceFormat format;
 #ifdef Q_OS_OSX
     format.setVersion(3, 2);
     format.setProfile(QSurfaceFormat::CoreProfile);
 #else
     // XXX This can be removed once we move to Qt5.7
     format.setVersion(3, 0);
     format.setProfile(QSurfaceFormat::CompatibilityProfile);
     format.setOptions(QSurfaceFormat::DeprecatedFunctions);
 #endif
     format.setDepthBufferSize(24);
     format.setStencilBufferSize(8);
     format.setSwapBehavior(QSurfaceFormat::DoubleBuffer);
     format.setSwapInterval(0); // Disable vertical refresh syncing
     QSurfaceFormat::setDefaultFormat(format);
 }
 
 bool KisOpenGL::hasOpenGL()
 {
     return ((glMajorVersion * 100 + glMinorVersion) >= 201);
     //return (glMajorVersion >= 3 && supportsDeprecatedFunctions);
 }
diff --git a/libs/ui/utils/kis_document_aware_spin_box_unit_manager.cpp b/libs/ui/utils/kis_document_aware_spin_box_unit_manager.cpp
new file mode 100644
index 0000000000..23858a32ae
--- /dev/null
+++ b/libs/ui/utils/kis_document_aware_spin_box_unit_manager.cpp
@@ -0,0 +1,163 @@
+/*
+ *  Copyright (c) 2017 Laurent Valentin Jospin <laurent.valentin@famillejospin.ch>
+ *
+ *  This program is free software; you can redistribute it and/or modify
+ *  it under the terms of the GNU General Public License as published by
+ *  the Free Software Foundation; either version 2 of the License, or
+ *  (at your option) any later version.
+ *
+ *  This program is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *  GNU General Public License for more details.
+ *
+ *  You should have received a copy of the GNU General Public License
+ *  along with this program; if not, write to the Free Software
+ *  Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
+ */
+
+#include "kis_document_aware_spin_box_unit_manager.h"
+
+#include "KisPart.h"
+#include "KisMainWindow.h"
+#include "KisView.h"
+#include "KisDocument.h"
+#include "kis_types.h"
+#include "kis_image.h"
+#include "kis_image_animation_interface.h"
+#include "kis_time_range.h"
+
+
+KisSpinBoxUnitManager* KisDocumentAwareSpinBoxUnitManagerBuilder::buildUnitManager(QObject* parent)
+{
+    return new KisDocumentAwareSpinBoxUnitManager(parent);
+}
+
+void KisDocumentAwareSpinBoxUnitManager::setDocumentAwarnessToExistingUnitSpinBox(KisDoubleParseUnitSpinBox* spinBox, bool setUnitFromOutsideToggle)
+{
+    KisDocumentAwareSpinBoxUnitManager* manager = new KisDocumentAwareSpinBoxUnitManager(spinBox);
+    spinBox->setUnitManager(manager);
+    spinBox->setUnitChangeFromOutsideBehavior(setUnitFromOutsideToggle);
+}
+
+KisDoubleParseUnitSpinBox* KisDocumentAwareSpinBoxUnitManager::createUnitSpinBoxWithDocumentAwarness(QWidget* parent)
+{
+    KisDoubleParseUnitSpinBox* spinBox = new KisDoubleParseUnitSpinBox(parent);
+    setDocumentAwarnessToExistingUnitSpinBox(spinBox);
+
+    return spinBox;
+}
+
+KisDocumentAwareSpinBoxUnitManager::KisDocumentAwareSpinBoxUnitManager(QObject *parent, int pPixDir):
+    KisSpinBoxUnitManager(parent)
+{
+    if (pPixDir == PIX_DIR_Y) {
+        pixDir = PIX_DIR_Y;
+    } else {
+        pixDir = PIX_DIR_X;
+    }
+
+    grantDocumentRelativeUnits(); //the purpose of this class is to manage document relative units.
+}
+
+
+qreal KisDocumentAwareSpinBoxUnitManager::getConversionFactor(int dim, QString symbol) const
+{
+    qreal factor = KisSpinBoxUnitManager::getConversionFactor(dim, symbol);
+
+    if (factor > 0) {
+        //no errors occured at a lower level, so the conversion factor has been get.
+        return factor;
+    }
+
+    factor = 1; //fall back to something natural in case document is unreachable (1 px = 1 pt = 1vw = 1vh). So a virtual document of 100x100 with a resolution of 1.
+
+    KisView* view = KisPart::instance()->currentMainwindow()->activeView();
+
+    if (view == nullptr) {
+        return factor;
+    }
+
+    KisDocument* doc = view->document();
+
+    if (doc == nullptr) {
+        return factor;
+    }
+
+    KisImage* img = doc->image().data();
+
+    if (img == nullptr) {
+        return factor;
+    }
+
+    qreal resX = img->xRes();
+    qreal resY = img->yRes();
+    qreal sizeX = img->width();
+    qreal sizeY = img->height();
+
+    switch (dim) {
+
+    case LENGTH:
+        if (symbol == "px") {
+
+            if (pixDir == PIX_DIR_X) {
+                factor = resX;
+            } else {
+                factor = resY;
+            }
+        } else if (symbol == "vw") {
+            qreal docWidth = sizeX/resX;
+
+            factor = 100.0/docWidth; //1 vw is 1% of document width, 1 vw in point is docWidth/100 so 1 point in vw is the inverse.
+        } else if (symbol == "vh") {
+            qreal docHeight = sizeY/resY;
+
+            factor = 100.0/docHeight;
+        }
+        break;
+
+    case IMLENGTH:
+
+        if (symbol == "vw") {
+            factor = 100.0/sizeX; //1 vw is 1% of document width, 1 vw in pixel is sizeX/100 so 1 pixel in vw is the inverse.
+
+        } else if (symbol == "vh") {
+            factor = 100.0/sizeY;
+        }
+        break;
+
+    case TIME:
+    {
+        if (symbol == "s") {
+            qreal fps = img->animationInterface()->framerate();
+
+            factor = 1/fps;
+        } else if (symbol == "%") {
+            const KisTimeRange & time_range = img->animationInterface()->fullClipRange();
+            qreal n_frame = time_range.end() - time_range.start();
+
+            factor = 100/n_frame;
+        }
+    }
+        break;
+
+    default:
+        break;
+
+    }
+
+    return factor;
+}
+
+qreal KisDocumentAwareSpinBoxUnitManager::getConversionConstant(int dim, QString symbol) const
+{
+    if (dim == TIME && symbol == "%") {
+        KisImage* img = KisPart::instance()->currentMainwindow()->activeView()->document()->image().data();
+        const KisTimeRange & time_range = img->animationInterface()->fullClipRange();
+        qreal n_frame = time_range.end() - time_range.start();
+
+        return -time_range.start()*100.0/n_frame;
+    }
+
+    return KisSpinBoxUnitManager::getConversionConstant(dim, symbol);
+}
diff --git a/libs/ui/utils/kis_document_aware_spin_box_unit_manager.h b/libs/ui/utils/kis_document_aware_spin_box_unit_manager.h
new file mode 100644
index 0000000000..1456ed692a
--- /dev/null
+++ b/libs/ui/utils/kis_document_aware_spin_box_unit_manager.h
@@ -0,0 +1,67 @@
+/*
+ *  Copyright (c) 2017 Laurent Valentin Jospin <laurent.valentin@famillejospin.ch>
+ *
+ *  This program is free software; you can redistribute it and/or modify
+ *  it under the terms of the GNU General Public License as published by
+ *  the Free Software Foundation; either version 2 of the License, or
+ *  (at your option) any later version.
+ *
+ *  This program is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *  GNU General Public License for more details.
+ *
+ *  You should have received a copy of the GNU General Public License
+ *  along with this program; if not, write to the Free Software
+ *  Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
+ */
+
+#ifndef KISDOCUMENTAWARESPINBOXUNITMANAGER_H
+#define KISDOCUMENTAWARESPINBOXUNITMANAGER_H
+
+#include "kis_spin_box_unit_manager.h"
+#include "kis_double_parse_unit_spin_box.h"
+
+#include "kritaui_export.h"
+class KisDocumentAwareSpinBoxUnitManagerBuilder : public KisSpinBoxUnitManagerBuilder
+{
+
+public:
+
+    KisSpinBoxUnitManager* buildUnitManager(QObject* parent);
+};
+
+/*!
+ * \brief The KisDocumentAwareSpinBoxUnitManager class is a KisSpinBoxUnitManager that is able to connect to the current document to compute transformation for document relative units (the ones that depend of the resolution, or the size in pixels of the image).
+ * \see KisSpinBoxUnitManager
+ */
+class KRITAUI_EXPORT KisDocumentAwareSpinBoxUnitManager : public KisSpinBoxUnitManager
+{
+    Q_OBJECT
+
+public:
+
+    enum PixDir {
+        PIX_DIR_X,
+        PIX_DIR_Y
+    }; //in case the image has not the same x and y resolution, indicate on which direction get the resolution.
+
+    //! \brief configure a KisDocumentAwareSpinBoxUnitManager for the given spinbox (make the manager a child of the spinbox and attach it to the spinbox).
+    static void setDocumentAwarnessToExistingUnitSpinBox(KisDoubleParseUnitSpinBox* spinBox, bool setUnitFromOutsideToggle = false);
+
+    //! \brief create a unitSpinBox that is already document aware.
+    static KisDoubleParseUnitSpinBox* createUnitSpinBoxWithDocumentAwarness(QWidget* parent = 0);
+
+    KisDocumentAwareSpinBoxUnitManager(QObject *parent = 0, int pPixDir = PIX_DIR_X);
+
+    //! \reimp \see KisSpinBoxUnitManager
+    virtual qreal getConversionFactor(int dim, QString symbol) const;
+    //! \reimp \see KisSpinBoxUnitManager
+    virtual qreal getConversionConstant(int dim, QString symbol) const;
+
+private:
+
+    PixDir pixDir;
+};
+
+#endif // KISDOCUMENTAWARESPINBOXUNITMANAGER_H
diff --git a/libs/ui/widgets/kis_advanced_color_space_selector.cc b/libs/ui/widgets/kis_advanced_color_space_selector.cc
index 2e6595e9f5..dee04ed433 100644
--- a/libs/ui/widgets/kis_advanced_color_space_selector.cc
+++ b/libs/ui/widgets/kis_advanced_color_space_selector.cc
@@ -1,793 +1,796 @@
 /*
  *  Copyright (C) 2007 Cyrille Berger <cberger@cberger.net>
  *  Copyright (C) 2011 Boudewijn Rempt <boud@valdyas.org>
  *  Copyright (C) 2011 Srikanth Tiyyagura <srikanth.tulasiram@gmail.com>
  *  Copyright (C) 2015 Wolthera van Hövell tot Westerflier <griffinvalley@gmail.com>
  *
  *  This program is free software; you can redistribute it and/or modify
  *  it under the terms of the GNU General Public License as published by
  *  the Free Software Foundation; either version 2 of the License, or
  *  (at your option) any later version.
  *
  *  This program is distributed in the hope that it will be useful,
  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  *  GNU General Public License for more details.
  *
  *  You should have received a copy of the GNU General Public License
  *  along with this program; if not, write to the Free Software
  *  Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
  */
 
 #include "kis_advanced_color_space_selector.h"
 
 #include <KoFileDialog.h>
 #include <KoColorProfile.h>
 #include <KoColorSpace.h>
 #include <KoColorSpaceRegistry.h>
 #include <KoColorSpaceEngine.h>
 #include <KoColorModelStandardIds.h>
 #include <KoID.h>
 
 #include <KoConfig.h>
 #include <kis_icon.h>
 
 #include <QDesktopServices>
 #include <QTextBrowser>
 #include <QScrollBar>
 
 #include <KoResourcePaths.h>
 
 #include <QUrl>
 
 #include "ui_wdgcolorspaceselectoradvanced.h"
 
 #include <kis_debug.h>
 
 struct KisAdvancedColorSpaceSelector::Private {
     Ui_WdgColorSpaceSelectorAdvanced* colorSpaceSelector;
     QString knsrcFile;
 };
 
 KisAdvancedColorSpaceSelector::KisAdvancedColorSpaceSelector(QWidget* parent, const QString &caption)
     : QDialog(parent)
     , d(new Private)
 {
     setWindowTitle(caption);
 
     d->colorSpaceSelector = new Ui_WdgColorSpaceSelectorAdvanced;
     d->colorSpaceSelector->setupUi(this);
 
     d->colorSpaceSelector->cmbColorModels->setIDList(KoColorSpaceRegistry::instance()->colorModelsList(KoColorSpaceRegistry::OnlyUserVisible));
     fillCmbDepths(d->colorSpaceSelector->cmbColorModels->currentItem());
 
     d->colorSpaceSelector->bnInstallProfile->setIcon(KisIconUtils::loadIcon("document-open"));
     d->colorSpaceSelector->bnInstallProfile->setToolTip( i18n("Open Color Profile") );
 
     connect(d->colorSpaceSelector->cmbColorModels, SIGNAL(activated(const KoID &)),
             this, SLOT(fillCmbDepths(const KoID &)));
     connect(d->colorSpaceSelector->cmbColorDepth, SIGNAL(activated(const KoID &)),
             this, SLOT(fillLstProfiles()));
     connect(d->colorSpaceSelector->cmbColorModels, SIGNAL(activated(const KoID &)),
             this, SLOT(fillLstProfiles()));
     connect(d->colorSpaceSelector->lstProfile, SIGNAL(currentItemChanged(QListWidgetItem*, QListWidgetItem*)),
             this, SLOT(colorSpaceChanged()));
     connect(this, SIGNAL(selectionChanged(bool)),
             this, SLOT(fillDescription()));
     connect(this, SIGNAL(selectionChanged(bool)), d->colorSpaceSelector->TongueWidget, SLOT(repaint()));
     connect(this, SIGNAL(selectionChanged(bool)), d->colorSpaceSelector->TRCwidget, SLOT(repaint()));
 
     connect(d->colorSpaceSelector->bnInstallProfile, SIGNAL(clicked()), this, SLOT(installProfile()));
 
     connect(d->colorSpaceSelector->bnOK, SIGNAL(accepted()), this, SLOT(accept()));
     connect(d->colorSpaceSelector->bnOK, SIGNAL(rejected()), this, SLOT(reject()));
 
     fillLstProfiles();
 }
 
 KisAdvancedColorSpaceSelector::~KisAdvancedColorSpaceSelector()
 {
     delete d->colorSpaceSelector;
     delete d;
 }
 
 void KisAdvancedColorSpaceSelector::fillLstProfiles()
 {
     d->colorSpaceSelector->lstProfile->blockSignals(true);
     QString s = KoColorSpaceRegistry::instance()->colorSpaceId(d->colorSpaceSelector->cmbColorModels->currentItem(), d->colorSpaceSelector->cmbColorDepth->currentItem());
     d->colorSpaceSelector->lstProfile->clear();
 
     const KoColorSpaceFactory * csf = KoColorSpaceRegistry::instance()->colorSpaceFactory(s);
     if (csf == 0) return;//TODO: make this give better feedback.
 
     QList<const KoColorProfile *>  profileList = KoColorSpaceRegistry::instance()->profilesFor(csf);
     QStringList profileNames;
     Q_FOREACH (const KoColorProfile *profile, profileList) {
         profileNames.append(profile->name());
     }
     qSort(profileNames);
     QListWidgetItem *defaultProfile = new QListWidgetItem;
     defaultProfile->setText(csf->defaultProfile() + " " + i18nc("This is appended to the color profile which is the default for the given colorspace and bit-depth","(Default)"));
     Q_FOREACH (QString stringName, profileNames) {
         if (stringName==csf->defaultProfile()) {
             d->colorSpaceSelector->lstProfile->addItem(defaultProfile);
         } else {
             d->colorSpaceSelector->lstProfile->addItem(stringName);
         }
     }
     d->colorSpaceSelector->lstProfile->setCurrentItem(defaultProfile);
     d->colorSpaceSelector->lstProfile->blockSignals(false);
     colorSpaceChanged();
 }
 
 void KisAdvancedColorSpaceSelector::fillCmbDepths(const KoID& id)
 {
     KoID activeDepth = d->colorSpaceSelector->cmbColorDepth->currentItem();
     d->colorSpaceSelector->cmbColorDepth->clear();
     QList<KoID> depths = KoColorSpaceRegistry::instance()->colorDepthList(id, KoColorSpaceRegistry::OnlyUserVisible);
     QList<KoID> sortedDepths;
     if (depths.contains(Integer8BitsColorDepthID)) {
         sortedDepths << Integer8BitsColorDepthID;
     }
     if (depths.contains(Integer16BitsColorDepthID)) {
         sortedDepths << Integer16BitsColorDepthID;
     }
     if (depths.contains(Float16BitsColorDepthID)) {
         sortedDepths << Float16BitsColorDepthID;
     }
     if (depths.contains(Float32BitsColorDepthID)) {
         sortedDepths << Float32BitsColorDepthID;
     }
     if (depths.contains(Float64BitsColorDepthID)) {
         sortedDepths << Float64BitsColorDepthID;
     }
 
     d->colorSpaceSelector->cmbColorDepth->setIDList(sortedDepths);
     if (sortedDepths.contains(activeDepth)) {
         d->colorSpaceSelector->cmbColorDepth->setCurrent(activeDepth);
     }
 }
 
 void KisAdvancedColorSpaceSelector::fillDescription()
 {
     QString notApplicable = i18nc("Not Applicable, used where there's no colorants or gamma curve found","N/A");
     QString notApplicableTooltip = i18nc("@info:tooltip","This profile has no colorants.");
     QString profileName = i18nc("Shows up instead of the name when there's no profile","No Profile Found");
     QString whatIsColorant = i18n("Colorant in d50-adapted xyY.");
     //set colorants
     QString s = KoColorSpaceRegistry::instance()->colorSpaceId(d->colorSpaceSelector->cmbColorModels->currentItem(), d->colorSpaceSelector->cmbColorDepth->currentItem());
     const KoColorSpaceFactory * csf = KoColorSpaceRegistry::instance()->colorSpaceFactory(s);
     if (csf == 0) return;
     QList<const KoColorProfile *>  profileList = KoColorSpaceRegistry::instance()->profilesFor(csf);
     if (profileList.isEmpty()==false) {
         profileName = currentColorSpace()->profile()->name();
         if (currentColorSpace()->profile()->hasColorants()){
             QVector <double> colorants = currentColorSpace()->profile()->getColorantsxyY();
             QVector <double> whitepoint = currentColorSpace()->profile()->getWhitePointxyY();
             //QString text = currentColorSpace()->profile()->info() + " =" +
             d->colorSpaceSelector->lblXYZ_W->setText(nameWhitePoint(whitepoint));
             d->colorSpaceSelector->lblXYZ_W->setToolTip(QString::number(whitepoint[0], 'f', 4) + ", " + QString::number(whitepoint[1], 'f', 4) + ", " + QString::number(whitepoint[2], 'f', 4));
             d->colorSpaceSelector->TongueWidget->setToolTip("<html><head/><body><table><tr><th colspan='4'>"+i18nc("@info:tooltip","This profile has the following xyY colorants:")+"</th></tr><tr><td>"+
                i18n("Red:")  +"</td><td>"+QString::number(colorants[0], 'f', 4) + "</td><td>" + QString::number(colorants[1], 'f', 4) + "</td><td>" + QString::number(colorants[2], 'f', 4)+"</td></tr><tr><td>"+
                i18n("Green:")+"</td><td>"+QString::number(colorants[3], 'f', 4) + "</td><td>" + QString::number(colorants[4], 'f', 4) + "</td><td>" + QString::number(colorants[5], 'f', 4)+"</th></tr><tr><td>"+
                i18n("Blue:") +"</td><td>"+QString::number(colorants[6], 'f', 4) + "</td><td>" + QString::number(colorants[7], 'f', 4) + "</td><td>" + QString::number(colorants[8], 'f', 4)+"</th></tr></table></body></html>");
         } else {
             QVector <double> whitepoint2 = currentColorSpace()->profile()->getWhitePointxyY();
             d->colorSpaceSelector->lblXYZ_W->setText(nameWhitePoint(whitepoint2));
             d->colorSpaceSelector->lblXYZ_W->setToolTip(QString::number(whitepoint2[0], 'f', 4) + ", " + QString::number(whitepoint2[1], 'f', 4) + ", " + QString::number(whitepoint2[2], 'f', 4));
             d->colorSpaceSelector->TongueWidget->setToolTip(notApplicableTooltip);
         }
     } else {
         d->colorSpaceSelector->lblXYZ_W->setText(notApplicable);
         d->colorSpaceSelector->lblXYZ_W->setToolTip(notApplicableTooltip);
         d->colorSpaceSelector->TongueWidget->setToolTip(notApplicableTooltip);
     }
 
     //set TRC
     QVector <double> estimatedTRC(3);
     QString estimatedGamma = i18nc("Estimated Gamma indicates how the TRC (Tone Response Curve or Tone Reproduction Curve) is bent. A Gamma of 1.0 means linear.", "<b>Estimated Gamma</b>: ");
     QString estimatedsRGB = i18nc("This is for special Gamma types that LCMS cannot differentiate between", "<b>Estimated Gamma</b>: sRGB, L* or rec709 TRC");
     QString whatissRGB = i18nc("@info:tooltip","The Tone Response Curve of this color space is either sRGB, L* or rec709 TRC.");
     QString currentModelStr = d->colorSpaceSelector->cmbColorModels->currentItem().id();
 
     if (profileList.isEmpty()) {
         d->colorSpaceSelector->TongueWidget->setProfileDataAvailable(false);
         d->colorSpaceSelector->TRCwidget->setProfileDataAvailable(false);
     }
     else if (currentModelStr == "RGBA") {
         QVector <qreal> colorants = currentColorSpace()->profile()->getColorantsxyY();
         QVector <qreal> whitepoint = currentColorSpace()->profile()->getWhitePointxyY();
         if (currentColorSpace()->profile()->hasColorants()){
             d->colorSpaceSelector->TongueWidget->setRGBData(whitepoint, colorants);
         } else {
             colorants.fill(0.0);
             d->colorSpaceSelector->TongueWidget->setRGBData(whitepoint, colorants);
         }
         d->colorSpaceSelector->TongueWidget->setGamut(currentColorSpace()->gamutXYY());
         estimatedTRC = currentColorSpace()->profile()->getEstimatedTRC();
         QString estimatedCurve = " Estimated curve: ";
         QPolygonF redcurve;
         QPolygonF greencurve;
         QPolygonF bluecurve;
         if (currentColorSpace()->profile()->hasTRC()){
             for (int i=0; i<=10; i++) {
                 QVector <qreal> linear(3);
                 linear.fill(i*0.1);
                 currentColorSpace()->profile()->linearizeFloatValue(linear);
                 estimatedCurve = estimatedCurve + ", " + QString::number(linear[0]);
                 QPointF tonepoint(linear[0],i*0.1);
                 redcurve<<tonepoint;
                 tonepoint.setX(linear[1]);
                 greencurve<<tonepoint;
                 tonepoint.setX(linear[2]);
                 bluecurve<<tonepoint;
             }
             d->colorSpaceSelector->TRCwidget->setRGBCurve(redcurve, greencurve, bluecurve);
         } else {
             QPolygonF curve = currentColorSpace()->estimatedTRCXYY();
             redcurve << curve.at(0) << curve.at(1) << curve.at(2) << curve.at(3) << curve.at(4);
             greencurve << curve.at(5) << curve.at(6) << curve.at(7) << curve.at(8) << curve.at(9);
             bluecurve << curve.at(10) << curve.at(11) << curve.at(12) << curve.at(13) << curve.at(14);
             d->colorSpaceSelector->TRCwidget->setRGBCurve(redcurve, greencurve, bluecurve);
         }
 
         if (estimatedTRC[0] == -1) {
             d->colorSpaceSelector->TRCwidget->setToolTip("<html><head/><body>"+whatissRGB+"<br />"+estimatedCurve+"</body></html>");
         } else {
             d->colorSpaceSelector->TRCwidget->setToolTip("<html><head/><body>"+estimatedGamma + QString::number(estimatedTRC[0]) + "," + QString::number(estimatedTRC[1]) + "," + QString::number(estimatedTRC[2])+"<br />"+estimatedCurve+"</body></html>");
         }
     }
     else if (currentModelStr == "GRAYA") {
         QVector <qreal> whitepoint = currentColorSpace()->profile()->getWhitePointxyY();
         d->colorSpaceSelector->TongueWidget->setGrayData(whitepoint);
         d->colorSpaceSelector->TongueWidget->setGamut(currentColorSpace()->gamutXYY());
         estimatedTRC = currentColorSpace()->profile()->getEstimatedTRC();
         QString estimatedCurve = " Estimated curve: ";
         QPolygonF tonecurve;
         if (currentColorSpace()->profile()->hasTRC()){
             for (int i=0; i<=10; i++) {
                 QVector <qreal> linear(3);
                 linear.fill(i*0.1);
                 currentColorSpace()->profile()->linearizeFloatValue(linear);
                 estimatedCurve = estimatedCurve + ", " + QString::number(linear[0]);
                 QPointF tonepoint(linear[0],i*0.1);
                 tonecurve<<tonepoint;
             }
         } else {
             d->colorSpaceSelector->TRCwidget->setProfileDataAvailable(false);
         }
         d->colorSpaceSelector->TRCwidget->setGreyscaleCurve(tonecurve);
         if (estimatedTRC[0] == -1) {
             d->colorSpaceSelector->TRCwidget->setToolTip("<html><head/><body>"+whatissRGB+"<br />"+estimatedCurve+"</body></html>");
         } else {
             d->colorSpaceSelector->TRCwidget->setToolTip("<html><head/><body>"+estimatedGamma + QString::number(estimatedTRC[0])+"<br />"+estimatedCurve+"</body></html>");
         }
     }
     else if (currentModelStr == "CMYKA") {
         QVector <qreal> whitepoint = currentColorSpace()->profile()->getWhitePointxyY();
         d->colorSpaceSelector->TongueWidget->setCMYKData(whitepoint);
         d->colorSpaceSelector->TongueWidget->setGamut(currentColorSpace()->gamutXYY());
         QString estimatedCurve = " Estimated curve: ";
         QPolygonF tonecurve;
         QPolygonF cyancurve;
         QPolygonF magentacurve;
         QPolygonF yellowcurve;
         if (currentColorSpace()->profile()->hasTRC()){
             for (int i=0; i<=10; i++) {
                 QVector <qreal> linear(3);
                 linear.fill(i*0.1);
                 currentColorSpace()->profile()->linearizeFloatValue(linear);
                 estimatedCurve = estimatedCurve + ", " + QString::number(linear[0]);
                 QPointF tonepoint(linear[0],i*0.1);
                 tonecurve<<tonepoint;
             }
             d->colorSpaceSelector->TRCwidget->setGreyscaleCurve(tonecurve);
         } else {
             QPolygonF curve = currentColorSpace()->estimatedTRCXYY();
             cyancurve << curve.at(0) << curve.at(1) << curve.at(2) << curve.at(3) << curve.at(4);
             magentacurve << curve.at(5) << curve.at(6) << curve.at(7) << curve.at(8) << curve.at(9);
             yellowcurve << curve.at(10) << curve.at(11) << curve.at(12) << curve.at(13) << curve.at(14);
             tonecurve << curve.at(15) << curve.at(16) << curve.at(17) << curve.at(18) << curve.at(19);
             d->colorSpaceSelector->TRCwidget->setCMYKCurve(cyancurve, magentacurve, yellowcurve, tonecurve);
         }
         d->colorSpaceSelector->TRCwidget->setToolTip(i18nc("@info:tooltip","Estimated Gamma cannot be retrieved for CMYK."));
     }
     else if (currentModelStr == "XYZA") {
         QString estimatedCurve = " Estimated curve: ";
         estimatedTRC = currentColorSpace()->profile()->getEstimatedTRC();
         QPolygonF tonecurve;
         if (currentColorSpace()->profile()->hasTRC()){
             for (int i=0; i<=10; i++) {
                 QVector <qreal> linear(3);
                 linear.fill(i*0.1);
                 currentColorSpace()->profile()->linearizeFloatValue(linear);
                 estimatedCurve = estimatedCurve + ", " + QString::number(linear[0]);
                 QPointF tonepoint(linear[0],i*0.1);
                 tonecurve<<tonepoint;
             }
             d->colorSpaceSelector->TRCwidget->setGreyscaleCurve(tonecurve);
         } else {
             d->colorSpaceSelector->TRCwidget->setProfileDataAvailable(false);
         }
         QVector <qreal> whitepoint = currentColorSpace()->profile()->getWhitePointxyY();
         d->colorSpaceSelector->TongueWidget->setXYZData(whitepoint);
         d->colorSpaceSelector->TongueWidget->setGamut(currentColorSpace()->gamutXYY());
         d->colorSpaceSelector->TRCwidget->setToolTip("<html><head/><body>"+estimatedGamma + QString::number(estimatedTRC[0])+"< br />"+estimatedCurve+"</body></html>");
     }
     else if (currentModelStr == "LABA") {
         estimatedTRC = currentColorSpace()->profile()->getEstimatedTRC();
         QString estimatedCurve = " Estimated curve: ";
         QPolygonF tonecurve;
         if (currentColorSpace()->profile()->hasTRC()){
             for (int i=0; i<=10; i++) {
                 QVector <qreal> linear(3);
                 linear.fill(i*0.1);
                 currentColorSpace()->profile()->linearizeFloatValue(linear);
                 estimatedCurve = estimatedCurve + ", " + QString::number(linear[0]);
                 QPointF tonepoint(linear[0],i*0.1);
                 tonecurve<<tonepoint;
             }
             d->colorSpaceSelector->TRCwidget->setGreyscaleCurve(tonecurve);
         } else {
             d->colorSpaceSelector->TRCwidget->setProfileDataAvailable(false);
         }
         QVector <qreal> whitepoint = currentColorSpace()->profile()->getWhitePointxyY();
         d->colorSpaceSelector->TongueWidget->setLABData(whitepoint);
         d->colorSpaceSelector->TongueWidget->setGamut(currentColorSpace()->gamutXYY());
         d->colorSpaceSelector->TRCwidget->setToolTip("<html><head/><body>"+i18nc("@info:tooltip","This is assumed to be the L * TRC. ")+"<br />"+estimatedCurve+"</body></html>");
     }
     else if (currentModelStr == "YCbCrA") {
         QVector <qreal> whitepoint = currentColorSpace()->profile()->getWhitePointxyY();
         d->colorSpaceSelector->TongueWidget->setYCbCrData(whitepoint);
         QString estimatedCurve = " Estimated curve: ";
         QPolygonF tonecurve;
         if (currentColorSpace()->profile()->hasTRC()){
             for (int i=0; i<=10; i++) {
                 QVector <qreal> linear(3);
                 linear.fill(i*0.1);
                 currentColorSpace()->profile()->linearizeFloatValue(linear);
                 estimatedCurve = estimatedCurve + ", " + QString::number(linear[0]);
                 QPointF tonepoint(linear[0],i*0.1);
                 tonecurve<<tonepoint;
             }
             d->colorSpaceSelector->TRCwidget->setGreyscaleCurve(tonecurve);
         } else {
             d->colorSpaceSelector->TRCwidget->setProfileDataAvailable(false);
         }
         d->colorSpaceSelector->TongueWidget->setGamut(currentColorSpace()->gamutXYY());
         d->colorSpaceSelector->TRCwidget->setToolTip(i18nc("@info:tooltip","Estimated Gamma cannot be retrieved for YCrCb."));
     }
 
     d->colorSpaceSelector->textProfileDescription->clear();
     if (profileList.isEmpty()==false) {
         d->colorSpaceSelector->textProfileDescription->append("<h3>"+i18nc("About <Profilename>","About ")  +  currentColorSpace()->name()  +  "/"  +  profileName  +  "</h3>");
         d->colorSpaceSelector->textProfileDescription->append("<p>"+ i18nc("ICC profile version","ICC Version: ")  + QString::number(currentColorSpace()->profile()->version())  +  "</p>");
         //d->colorSpaceSelector->textProfileDescription->append("<p>"+ i18nc("Who made the profile?","Manufacturer: ")  + currentColorSpace()->profile()->manufacturer()  +  "</p>"); //This would work if people actually wrote the manufacturer into the manufacturer fiedl...
         d->colorSpaceSelector->textProfileDescription->append("<p>"+ i18nc("What is the copyright? These are from embedded strings from the icc profile, so they default to english.","Copyright: ")  + currentColorSpace()->profile()->copyright()  +  "</p>");
     } else {
         d->colorSpaceSelector->textProfileDescription->append("<h3>" + profileName  +  "</h3>");
     }
 
     if (currentModelStr == "RGBA") {
         d->colorSpaceSelector->textProfileDescription->append("<p>"+i18nc("If the selected model is RGB",
                                                                     "<b><a href=\"https://en.wikipedia.org/wiki/RGB_color_space\">RGB (Red, Green, Blue)</a></b>, is the color model used by screens and other light-based media.<br/>"
                                                                     "RGB is an additive color model: adding colors together makes them brighter. This color "
                                                                     "model is the most extensive of all color models, and is recommended as a model for painting,"
                                                                     "that you can later convert to other spaces. RGB is also the recommended colorspace for HDR editing.")+"</p>");
     } else if (currentModelStr == "CMYKA") {
         d->colorSpaceSelector->textProfileDescription->append("<p>"+i18nc("If the selected model is CMYK",
                                                                     "<b><a href=\"https://en.wikipedia.org/wiki/CMYK_color_model\">CMYK (Cyan, Magenta, Yellow, Key)</a></b>, "
                                                                     "is the model used by printers and other ink-based media.<br/>"
                                                                     "CMYK is a subtractive model, meaning that adding colors together will turn them darker. Because of CMYK "
                                                                     "profiles being very specific per printer, it is recommended to work in RGB space, and then later convert "
                                                                     "to a CMYK profile, preferably one delivered by your printer. <br/>"
                                                                     "CMYK is <b>not</b> recommended for painting."
                                                                     "Unfortunately, Krita cannot retrieve colorants or the TRC for this space.")+"</p>");
     } else if (currentModelStr == "XYZA") {
         d->colorSpaceSelector->textProfileDescription->append("<p>"+i18nc("If the selected model is XYZ",
                                                                     "<b><a href=\"https://en.wikipedia.org/wiki/CIE_1931_color_space\">CIE XYZ</a></b>"
                                                                     "is the space determined by the CIE as the space that encompasses all other colors, and used to "
                                                                     "convert colors between profiles. XYZ is an additive color model, meaning that adding colors together "
                                                                     "makes them brighter. XYZ is <b>not</b> recommended for painting, but can be useful to encode in. The Tone Response "
                                                                     "Curve is assumed to be linear.")+"</p>");
     } else if (currentModelStr == "GRAYA") {
         d->colorSpaceSelector->textProfileDescription->append("<p>"+i18nc("If the selected model is Grayscale",
                                                                     "<b><a href=\"https://en.wikipedia.org/wiki/Grayscale\">Grayscale</a></b> only allows for "
                                                                     "gray values and transparent values. Grayscale images use half "
                                                                     "the memory and disk space compared to an RGB image of the same bit-depth.<br/>"
                                                                     "Grayscale is useful for inking and greyscale images. In "
                                                                     "Krita, you can mix Grayscale and RGB layers in the same image.")+"</p>");
     } else if (currentModelStr == "LABA") {
         d->colorSpaceSelector->textProfileDescription->append("<p>"+i18nc("If the selected model is LAB",
                                                                     "<b><a href=\"https://en.wikipedia.org/wiki/Lab_color_space\">L*a*b</a></b>. <b>L<b> stands for Lightness, "
                                                                     "the <b>a</b> and <b>b</b> components represent color channels.<br/>"
                                                                     "L*a*b is a special model for color correction. It is based on human perception, meaning that it "
                                                                     "tries to encode the difference in lightness, red-green balance and yellow-blue balance. "
                                                                     "This makes it useful for color correction, but the vast majority of color maths in the blending "
                                                                     "modes do <b>not</b> work as expected here.<br/>"
                                                                     "Similarly, Krita does not support HDR in LAB, meaning that HDR images converted to LAB lose color "
                                                                     "information. This colorspace is <b>not</b> recommended for painting, nor for export, "
                                                                     "but best as a space to do post-processing in. The TRC is assumed to be the L* TRC.")+"</p>");
     } else if (currentModelStr == "YCbCrA") {
         d->colorSpaceSelector->textProfileDescription->append("<p>"+i18nc("If the selected model is YCbCr",
                                                                     "<b><a href=\"https://en.wikipedia.org/wiki/YCbCr\">YCbCr (Luma, Blue Chroma, Red Chroma)</a></b>, is a "
                                                                     "model designed for video encoding. It is based on human perception, meaning that it tries to "
                                                                     "encode the difference in lightness, red-green balance and yellow-blue balance. Chroma in "
                                                                     "this case is then a word indicating a special type of saturation, in these cases the saturation "
                                                                     "of Red and Blue, of which the desaturated equivalents are Green and Yellow respectively. It "
                                                                     "is available to open up certain images correctly, but Krita does not currently ship a profile for "
                                                                     "this due to lack of open source ICC profiles for YCrCb.")+"</p>");
     }
 
     QString currentDepthStr = d->colorSpaceSelector->cmbColorDepth->currentItem().id();
 
     if (currentDepthStr == "U8") {
         d->colorSpaceSelector->textProfileDescription->append("<p>"+i18nc("When the selected Bitdepth is 8",
                                                                     "<b>8 bit integer</b>: The default amount of colors per channel. Each channel will have 256 values available, "
                                                                     "leading to a total amount of 256*amount of channels. Recommended to use for images intended for the web, "
                                                                     "or otherwise simple images.")+"</p>");
     }
     else if (currentDepthStr == "U16") {
         d->colorSpaceSelector->textProfileDescription->append("<p>"+i18nc("When the selected Bitdepth is 16",
                                                                     "<b>16 bit integer</b>: Also known as 'deep color'. 16 bit is ideal for editing images with a linear TRC, large "
                                                                     "color space, or just when you need more precise color blending. This does take twice as much space on "
                                                                     "the RAM and hard-drive than any given 8 bit image of the same properties, and for some devices it "
                                                                     "takes much more processing power. We recommend watching the RAM usage of the file carefully, or "
                                                                     "otherwise use 8 bit if your computer slows down. Take care to disable conversion optimization "
                                                                     "when converting from 16 bit/channel to 8 bit/channel.")+"</p>");
     }
     else if (currentDepthStr == "F16") {
         d->colorSpaceSelector->textProfileDescription->append("<p>"+i18nc("When the selected Bitdepth is 16 bit float",
                                                                     "<b>16 bit floating point</b>: Also known as 'Half Floating Point', and the standard in VFX industry images. "
                                                                     "16 bit float is ideal for editing images with a linear Tone Response Curve, large color space, or just when you need "
                                                                     "more precise color blending. It being floating point is an absolute requirement for Scene Referred "
                                                                     "(HDR) images. This does take twice as much space on the RAM and hard-drive than any given 8 bit image "
                                                                     "of the same properties, and for some devices it takes much more processing power. We recommend watching "
                                                                     "the RAM usage of the file carefully, or otherwise use 8 bit if your computer slows down.")+"</p>");
     }
     else if (currentDepthStr == "F32") {
         d->colorSpaceSelector->textProfileDescription->append("<p>"+i18nc("When the selected Bitdepth is 32bit float",
                                                                     "<b>32 bit float point</b>: Also known as 'Full Floating Point'. 32 bit float is ideal for editing images "
                                                                     "with a linear TRC, large color space, or just when you need more precise color blending. It being "
                                                                     "floating point is an absolute requirement for Scene Referred (HDR) images. This does take four times "
                                                                     "as much space on the RAM and hard-drive than any given 8 bit image of the same properties, and for "
                                                                     "some devices it takes much more processing power. We recommend watching the RAM usage of the file "
                                                                     "carefully, or otherwise use 8 bit if your computer slows down.")+"</p>");
     }
     else if (currentDepthStr == "F64") {
         d->colorSpaceSelector->textProfileDescription->append("<p>"+i18nc("When the selected Bitdepth is 64bit float, but this isn't actually available in Krita at the moment.",\
                                                                     "<b>64 bit float point</b>: 64 bit float is as precise as it gets in current technology, and this depth is used "
                                                                     "most of the time for images that are generated or used as an input for software. It being floating point "
                                                                     "is an absolute requirement for Scene Referred (HDR) images. This does take eight times as much space on "
                                                                     "the RAM and hard-drive than any given 8 bit image of the same properties, and for some devices it takes "
                                                                     "much more processing power. We recommend watching the RAM usage of the file carefully, or otherwise use "
                                                                     "8 bit if your computer slows down.")+"</p>");
     }
     if (profileList.isEmpty()==false) {
         QString possibleConversionIntents = "<p>"+i18n("The following conversion intents are possible: ")+"<ul>";
         if (currentColorSpace()->profile()->supportsPerceptual()){
             possibleConversionIntents += "<li>"+i18n("Perceptual")+"</li>";
         }
         if (currentColorSpace()->profile()->supportsRelative()){
             possibleConversionIntents +=  "<li>"+i18n("Relative Colorimetric")+"</li>";
         }
         if (currentColorSpace()->profile()->supportsAbsolute()){
             possibleConversionIntents += "<li>"+i18n("Absolute Colorimetric")+"</li>";
         }
         if (currentColorSpace()->profile()->supportsSaturation()){
             possibleConversionIntents += "<li>"+i18n("Saturation")+"</li>";
         }
         possibleConversionIntents += "</ul></ul></p>";
         d->colorSpaceSelector->textProfileDescription->append(possibleConversionIntents);
     }
     if (profileName.contains("-elle-")) {
 
         d->colorSpaceSelector->textProfileDescription->append("<p>"+i18nc("These are Elle Stone's notes on her profiles that we ship.",
                                                                     "<p><b>Extra notes on profiles by Elle Stone:</b></p>"
                                                                     "<p><i>Krita comes with a number of high quality profiles created by "
                                                                     "<a href=\"http://ninedegreesbelow.com\">Elle Stone</a>. This is a summary. Please check "
                                                                     "<a href=\"http://ninedegreesbelow.com/photography/lcms-make-icc-profiles.html\">the full documentation</a> as well.</i></p>"));
 
                 if (profileName.contains("ACES-")) {
 
             d->colorSpaceSelector->textProfileDescription->append(i18nc("From Elle's notes.",
                                                                         "<p>Quoting Wikipedia, 'Academy Color Encoding System (ACES) is a color image "
                                                                         "encoding system proposed by the Academy of Motion Picture Arts and Sciences that will allow for "
                                                                         "a fully encompassing color accurate workflow, with 'seamless interchange of high quality motion "
                                                                         "picture images regardless of source'.</p>"));
         }
         if (profileName.contains("ACEScg-")) {
 
             d->colorSpaceSelector->textProfileDescription->append(i18nc("From Elle's notes.",
                                                                         "<p>The ACEScg color space is smaller than the ACES color space, but large enough to contain the 'Rec-2020 gamut "
                                                                         "and the DCI-P3 gamut', unlike the ACES color space it has no negative values and contains only few colors "
                                                                         "that fall just barely outside the area of real colors humans can see</p>"));
         }
         if (profileName.contains("ClayRGB-")) {
 
             d->colorSpaceSelector->textProfileDescription->append(i18nc("From Elle's notes.",
                                                                         "<p>To avoid possible copyright infringement issues, I used 'ClayRGB' (following ArgyllCMS) as the base name "
                                                                         "for these profiles. As used below, 'Compatible with Adobe RGB 1998' is terminology suggested in the preamble "
                                                                         "to the AdobeRGB 1998 color space specifications.</p><p>"
                                                                         "The Adobe RGB 1998 color gamut covers a higher "
                                                                         "percentage of real-world cyans, greens, and yellow-greens than sRGB, but still doesn't include all printable "
                                                                         "cyans, greens, yellow-greens, especially when printing using today's high-end, wider gamut, ink jet printers. "
                                                                         "BetaRGB (not included in the profile pack) and Rec.2020 are better matches for the color gamuts of today's "
                                                                         "wide gamut printers.</p><p>"
                                                                         "The Adobe RGB 1998 color gamut is a reasonable approximation to some of today's "
                                                                         "high-end wide gamut monitors.</p>"));
         }
         if (profileName.contains("AllColorsRGB-")) {
 
             d->colorSpaceSelector->textProfileDescription->append(i18nc("From Elle's notes.",
                                                                         "<p>This profile's color gamut is roughly the same size and shape as the ACES color space gamut, "
                                                                         "and like the ACES color space, AllColorsRGB holds all possible real colors. But AllColorsRGB "
                                                                         "actually has a slightly larger color gamut (to capture some fringe colors that barely qualify "
                                                                         "as real when viewed by the standard observer) and uses the D50 white point.</p><p>"
                                                                         "Just like the ACES color space, AllColorsRGB holds a high percentage of imaginary colors. See the Completely "
                                                                         "<a href=\"http://ninedegreesbelow.com/photography/xyz-rgb.html\">"
                                                                         "Painless Programmer's Guide to XYZ, RGB, ICC, xyY, and TRCs</a> for more information about imaginary "
                                                                         "colors.</p><p>"
                                                                         "There is no particular reason why anyone would want to use this profile "
                                                                         "for editing, unless one needs to make sure your color space really does hold all "
                                                                         "possible real colors.</p>"));
         }
         if (profileName.contains("CIERGB-")) {
 
             d->colorSpaceSelector->textProfileDescription->append(i18nc("From Elle's notes.",
                                                                         "<p>This profile is included mostly for its historical significance. "
                                                                         "It's the color space that was used in the original color matching experiments "
                                                                         "that led to the creation of the XYZ reference color space.</p><p>"
                                                                         "The ASTM E white point "
                                                                         "is probably the right E white point to use when making the CIERGB color space profile. "
                                                                         "It's not clear to me what the correct CIERGB primaries really are. "
                                                                         "Lindbloom gives one set. The LCMS version 1 tutorial gives a different set. "
                                                                         "Experts in the field contend that the real primaries "
                                                                         "should be calculated from the spectral wavelengths, so I did.</p>"));
         }
         if (profileName.contains("IdentityRGB-")) {
 
             d->colorSpaceSelector->textProfileDescription->append(i18nc("From Elle's notes.",
                                                                         "<p>The IdentityRGB working space is included in the profile pack because it's a mathematically "
                                                                         "obvious way to include all possible visible colors, though it has a higher percentage of "
                                                                         "imaginary colors than the ACES and AllColorsRGB color spaces. I cannot think of any reason "
                                                                         "why you'd ever want to actually edit images in the IdentityRGB working space.</p>"));
         }
         if (profileName.contains("LargeRGB-")) {
 
             d->colorSpaceSelector->textProfileDescription->append(i18nc("From Elle's notes.",
                                                                         "<p>To avoid possible copyright infringement issues, I used 'LargeRGB' (following RawTherapee) "
                                                                         "as the base name for these profiles.<p>"
                                                                         "Kodak designed the RIMM/ROMM (ProPhotoRGB) color "
                                                                         "gamut to include all printable and most real world colors. It includes some imaginary colors "
                                                                         "and excludes some of the real world blues and violet blues that can be captured by digital "
                                                                         "cameras. It also excludes some very saturated 'camera-captured' yellows as interpreted by "
                                                                         "some (and probably many) camera matrix input profiles.<p>"
                                                                         "The ProPhotoRGB primaries are "
                                                                         "hard-coded into Adobe products such as Lightroom and the Dng-DCP camera 'profiles'. However, "
                                                                         "other than being large enough to hold a lot of colors, ProPhotoRGB has no particular merit "
                                                                         "as an RGB working space. Personally and for most editing purposes, I recommend BetaRGB, Rec2020, "
                                                                         "or the ACEScg profiles ProPhotoRGB.</p>"));
         }
         if (profileName.contains("Rec2020-")) {
 
             d->colorSpaceSelector->textProfileDescription->append(i18nc("From Elle's notes.",
                                                                         "<p>Rec.2020 is the up-and-coming replacement for the thoroughly outdated sRGB color space. As of "
                                                                         "June 2015, very few (if any) display devices (and certainly no affordable display devices) can "
                                                                         "display all of Rec.2020. However, display technology is closing in on Rec.2020, movies are "
                                                                         "already being made for Rec.2020, and various cameras offer support for Rec.2020. And in the "
                                                                         "digital darkroom Rec.2020 is much more suitable as a general RGB working space than the "
                                                                         "exceedingly small sRGB color space.</p>"));
         }
         if (profileName.contains("sRGB-")) {
             d->colorSpaceSelector->textProfileDescription->append(i18nc("From Elle's notes.",
                                                                         "<p>Hewlett-Packard and Microsoft designed sRGB to match the color gamut of consumer-grade CRTs "
                                                                         "from the 1990s. sRGB is the standard color space for the world wide web and is still the best "
                                                                         "choice for exporting images to the internet.</p><p>"
                                                                         "The sRGB color gamut was a good match to "
                                                                         "calibrated decent quality CRTs. But sRGB is not a good match to many consumer-grade LCD monitors, "
                                                                         "which often cannot display the more saturated sRGB blues and magentas (the good news: as technology "
                                                                         "progresses, wider gamuts are trickling down to consumer grade monitors).</p><p>"
                                                                         "Printer color gamuts can easily exceed the sRGB color gamut in cyans, greens, and yellow-greens. Colors from interpolated "
                                                                         "camera raw files also often exceed the sRGB color gamut.</p><p>"
                                                                         "As a very relevant aside, using perceptual "
                                                                         "intent when converting to sRGB does not magically makes otherwise out of gamut colors fit inside the "
                                                                         "sRGB color gamut! The standard sRGB color space (along with all the other the RGB profiles provided "
                                                                         "in my profile pack) is a matrix profile, and matrix profiles don't have perceptual intent tables.</p>"));
         }
         if (profileName.contains("WideRGB-")) {
             d->colorSpaceSelector->textProfileDescription->append(i18nc("From Elle's notes.",
                                                                         "<p>To avoid possible copyright infringement issues, I used 'WideRGB' as the base name for these profiles.</p><p>"
                                                                         "WideGamutRGB was designed by Adobe to be a wide gamut color space that uses spectral colors "
                                                                         "as its primaries. Pascale's primary values produce a profile that matches old V2 Widegamut profiles "
                                                                         "from Adobe and Canon. It is an interesting color space, but shortly after its introduction, Adobe "
                                                                         "switched their emphasis to the ProPhotoRGB color space.</p>"));
         }
         if (profileName.contains("Gray-")) {
             d->colorSpaceSelector->textProfileDescription->append(i18nc("From Elle's notes.",
                                                                         "<p>These profiles are for use with RGB images that have been converted to monotone gray (black and white). "
                                                                         "The main reason to convert from RGB to Gray is to save the file space needed to encode the image. "
                                                                         "Google places a premium on fast-loading web pages, and images are one of the slower-loading elements "
                                                                         "of a web page. So converting black and white images to Grayscale images does save some kilobytes. "
                                                                         " For grayscale images uploaded to the internet, convert the image to the V2 Gray profile with the sRGB TRC.</p>"));
         }
         if (profileName.contains("-g10")) {
             d->colorSpaceSelector->textProfileDescription->append(i18nc("From Elle's notes.",
                                                                         "<p>The profiles that end in '-g10.icc' are linear gamma (gamma=1.0, 'linear light', etc) profiles and "
                                                                         "should only be used when editing at high bit depths (16-bit floating point, 16-bit integer, 32-bit "
                                                                         "floating point, 32-bit integer). Many editing operations produce better results in linear gamma color "
                                                                         "spaces.</p>"));
         }
         if (profileName.contains("-labl")) {
             d->colorSpaceSelector->textProfileDescription->append(i18nc("From Elle's notes.",
                                                                         "<p>The profiles that end in '-labl.icc' have perceptually uniform TRCs. A few editing operations really "
                                                                         "should be done on perceptually uniform RGB. Make sure you use the V4 versions for editing high bit depth "
                                                                         "images.</p>"));
         }
         if (profileName.contains("-srgbtrc") || profileName.contains("-g22") || profileName.contains("-g18") || profileName.contains("-bt709")) {
             d->colorSpaceSelector->textProfileDescription->append(i18nc("From Elle's notes.",
                                                                         "<p>The profiles that end in '-srgbtrc.icc', '-g22.icc', and '-bt709.icc' have approximately but not exactly "
                                                                         "perceptually uniform TRCs. ProPhotoRGB's gamma=1.8 TRC is not quite as close to being perceptually uniform.</p>"));
         }
         if (d->colorSpaceSelector->cmbColorDepth->currentItem().id()=="U8") {
             d->colorSpaceSelector->textProfileDescription->append(i18nc("From Elle's notes.",
                                                                         "<p>When editing 8-bit images, you should use a profile with a small color gamut and an approximately or "
                                                                         "exactly perceptually uniform TRC. Of the profiles supplied in my profile pack, only the sRGB and AdobeRGB1998 "
                                                                         "(ClayRGB) color spaces are small enough for 8-bit editing. Even with the AdobeRGB1998 color space you need to "
                                                                         "be careful to not cause posterization. And of course you cannot use the linear gamma versions of these profiles "
                                                                         "for 8-bit editing.</p>"));
         }
         if (profileName.contains("-V4-")) {
             d->colorSpaceSelector->textProfileDescription->append(i18nc("From Elle's notes.",
                                                                         "<p>Use V4 profiles for editing images using high bit depth image editors that use LCMS as the Color Management Module. "
                                                                         "This includes Krita, digiKam/showFoto, and GIMP 2.9.</p>"));
         }
         if (profileName.contains("-V2-")) {
             d->colorSpaceSelector->textProfileDescription->append(i18nc("From Elle's notes.",
                                                                         "<p>Use V2 profiles for exporting finished images to be uploaded to the web or for use with imaging software that "
                                                                         "cannot read V4 profiles.</p>"));
         }
     }
 
 
     d->colorSpaceSelector->textProfileDescription->moveCursor(QTextCursor::Start);
 
 }
 
 QString KisAdvancedColorSpaceSelector::nameWhitePoint(QVector <double> whitePoint) {
     QString name=(QString::number(whitePoint[0]) + ", " + QString::number(whitePoint[1], 'f', 4));
     //A   (0.451170, 0.40594) (2856K)(tungsten)
     if ((whitePoint[0]>0.451170-0.005 && whitePoint[0]<0.451170 + 0.005) &&
             (whitePoint[1]>0.40594-0.005 && whitePoint[1]<0.40594 + 0.005)){
         name="A";
         return name;
     }
     //B   (0.34980, 0.35270) (4874K) (Direct Sunlight at noon)(obsolete)
     //C   (0.31039, 0.31905) (6774K) (avarage/north sky daylight)(obsolete)
     //D50 (0.34773, 0.35952) (5003K) (Horizon Light, default color of white paper, ICC profile standard illuminant)
     if ((whitePoint[0]>0.34773-0.005 && whitePoint[0]<0.34773 + 0.005) &&
             (whitePoint[1]>0.35952-0.005 && whitePoint[1]<0.35952 + 0.005)){
         name="D50";
         return name;
     }
     //D55 (0.33411,	0.34877) (5503K) (Mid-morning / Mid-afternoon Daylight)
     if ((whitePoint[0]>0.33411-0.001 && whitePoint[0]<0.33411 + 0.001) &&
             (whitePoint[1]>0.34877-0.005 && whitePoint[1]<0.34877 + 0.005)){
         name="D55";
         return name;
     }
     //D60 (0.3217, 0.3378) (~6000K) (ACES colorspace default)
     if ((whitePoint[0]>0.3217-0.001 && whitePoint[0]<0.3217 + 0.001) &&
             (whitePoint[1]>0.3378-0.005 && whitePoint[1]<0.3378 + 0.005)){
         name="D60";
         return name;
     }
     //D65 (0.31382, 0.33100) (6504K) (Noon Daylight, default for computer and tv screens, sRGB default)
     //Elle's are old school with 0.3127 and 0.3289
     if ((whitePoint[0]>0.31382-0.002 && whitePoint[0]<0.31382 + 0.002) &&
             (whitePoint[1]>0.33100-0.005 && whitePoint[1]<0.33100 + 0.002)){
         name="D65";
         return name;
     }
     //D75 (0.29968, 0.31740) (7504K) (North sky Daylight)
     if ((whitePoint[0]>0.29968-0.001 && whitePoint[0]<0.29968 + 0.001) &&
             (whitePoint[1]>0.31740-0.005 && whitePoint[1]<0.31740 + 0.005)){
         name="D75";
         return name;
     }
     //E   (1/3, 1/3)         (5454K) (Equal Energy. CIERGB default)
     if ((whitePoint[0]>(1.0/3.0)-0.001 && whitePoint[0]<(1.0/3.0) + 0.001) &&
             (whitePoint[1]>(1.0/3.0)-0.001 && whitePoint[1]<(1.0/3.0) + 0.001)){
         name="E";
         return name;
     }
     //The F series seems to sorta overlap with the D series, so I'll just leave them in comment here.//
     //F1  (0.31811, 0.33559) (6430K) (Daylight Fluorescent)
     //F2  (0.37925, 0.36733) (4230K) (Cool White Fluorescent)
     //F3  (0.41761, 0.38324) (3450K) (White Florescent)
     //F4  (0.44920, 0.39074) (2940K) (Warm White Fluorescent)
     //F5  (0.31975, 0.34246) (6350K) (Daylight Fluorescent)
     //F6  (0.38660, 0.37847) (4150K) (Lite White Fluorescent)
     //F7  (0.31569, 0.32960) (6500K) (D65 simulator, Daylight simulator)
     //F8  (0.34902, 0.35939) (5000K) (D50 simulator)
     //F9  (0.37829, 0.37045) (4150K) (Cool White Deluxe Fluorescent)
     //F10 (0.35090, 0.35444) (5000K) (Philips TL85, Ultralume 50)
     //F11 (0.38541, 0.37123) (4000K) (Philips TL84, Ultralume 40)
     //F12 (0.44256, 0.39717) (3000K) (Philips TL83, Ultralume 30)
 
     return name;
 }
 
 const KoColorSpace* KisAdvancedColorSpaceSelector::currentColorSpace()
 {
     QString check = "";
     if (d->colorSpaceSelector->lstProfile->currentItem()) {
         check = d->colorSpaceSelector->lstProfile->currentItem()->text();
     } else if (d->colorSpaceSelector->lstProfile->item(0)) {
         check = d->colorSpaceSelector->lstProfile->item(0)->text();
     }
     return KoColorSpaceRegistry::instance()->colorSpace(d->colorSpaceSelector->cmbColorModels->currentItem().id(),
                                                         d->colorSpaceSelector->cmbColorDepth->currentItem().id(),
                                                         check);
 }
 
 void KisAdvancedColorSpaceSelector::setCurrentColorModel(const KoID& id)
 {
     d->colorSpaceSelector->cmbColorModels->setCurrent(id);
     fillLstProfiles();
     fillCmbDepths(id);
 }
 
 void KisAdvancedColorSpaceSelector::setCurrentColorDepth(const KoID& id)
 {
     d->colorSpaceSelector->cmbColorDepth->setCurrent(id);
     fillLstProfiles();
 }
 
 void KisAdvancedColorSpaceSelector::setCurrentProfile(const QString& name)
 {
     QList<QListWidgetItem *> Items= d->colorSpaceSelector->lstProfile->findItems(name, Qt::MatchStartsWith);
     d->colorSpaceSelector->lstProfile->setCurrentItem(Items.at(0));
 }
 
 void KisAdvancedColorSpaceSelector::setCurrentColorSpace(const KoColorSpace* colorSpace)
 {
+    if (!colorSpace) {
+        return;
+    }
     setCurrentColorModel(colorSpace->colorModelId());
     setCurrentColorDepth(colorSpace->colorDepthId());
     setCurrentProfile(colorSpace->profile()->name());
 }
 
 void KisAdvancedColorSpaceSelector::colorSpaceChanged()
 {
     bool valid = d->colorSpaceSelector->lstProfile->count() != 0;
     emit(selectionChanged(valid));
     if (valid) {
         emit colorSpaceChanged(currentColorSpace());
     }
 }
 
 void KisAdvancedColorSpaceSelector::installProfile()
 {
     KoFileDialog dialog(this, KoFileDialog::OpenFiles, "OpenDocumentICC");
     dialog.setCaption(i18n("Install Color Profiles"));
     dialog.setDefaultDir(QDesktopServices::storageLocation(QDesktopServices::HomeLocation));
     dialog.setMimeTypeFilters(QStringList() << "application/vnd.iccprofile", "application/vnd.iccprofile");
     QStringList profileNames = dialog.filenames();
 
     KoColorSpaceEngine *iccEngine = KoColorSpaceEngineRegistry::instance()->get("icc");
     Q_ASSERT(iccEngine);
 
     QString saveLocation = KoResourcePaths::saveLocation("icc_profiles");
 
     Q_FOREACH (const QString &profileName, profileNames) {
         QUrl file(profileName);
         if (!QFile::copy(profileName, saveLocation  +  file.fileName())) {
             dbgKrita << "Could not install profile!";
             return;
         }
         iccEngine->addProfile(saveLocation  +  file.fileName());
 
     }
 
     fillLstProfiles();
 }
diff --git a/libs/ui/widgets/kis_color_space_selector.cc b/libs/ui/widgets/kis_color_space_selector.cc
index a63e7aebdb..0896d42ebd 100644
--- a/libs/ui/widgets/kis_color_space_selector.cc
+++ b/libs/ui/widgets/kis_color_space_selector.cc
@@ -1,270 +1,275 @@
 /*
  *  Copyright (C) 2007 Cyrille Berger <cberger@cberger.net>
  *  Copyright (C) 2011 Boudewijn Rempt <boud@valdyas.org>
  *  Copyright (C) 2011 Srikanth Tiyyagura <srikanth.tulasiram@gmail.com>
  *
  *  This program is free software; you can redistribute it and/or modify
  *  it under the terms of the GNU General Public License as published by
  *  the Free Software Foundation; either version 2 of the License, or
  *  (at your option) any later version.
  *
  *  This program is distributed in the hope that it will be useful,
  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  *  GNU General Public License for more details.
  *
  *  You should have received a copy of the GNU General Public License
  *  along with this program; if not, write to the Free Software
  *  Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
  */
 
 #include "kis_color_space_selector.h"
 #include "kis_advanced_color_space_selector.h"
 
 
 #include <QUrl>
 
 #include <KoFileDialog.h>
 #include <KoColorProfile.h>
 #include <KoColorSpace.h>
 #include <KoColorSpaceRegistry.h>
 #include <KoColorSpaceEngine.h>
 #include <KoID.h>
 
 #include <KoConfig.h>
 #include <kis_icon.h>
 
 #include <QDesktopServices>
 
 #include <KoResourcePaths.h>
 
 
 #include <kis_debug.h>
 
 #include "ui_wdgcolorspaceselector.h"
 
 struct KisColorSpaceSelector::Private {
     Ui_WdgColorSpaceSelector* colorSpaceSelector;
     QString knsrcFile;
     bool profileValid;
     QString defaultsuffix;
 };
 
 KisColorSpaceSelector::KisColorSpaceSelector(QWidget* parent) : QWidget(parent), m_advancedSelector(0), d(new Private)
 {
     setObjectName("KisColorSpaceSelector");
     d->colorSpaceSelector = new Ui_WdgColorSpaceSelector;
     d->colorSpaceSelector->setupUi(this);
     d->colorSpaceSelector->cmbColorModels->setIDList(KoColorSpaceRegistry::instance()->colorModelsList(KoColorSpaceRegistry::OnlyUserVisible));
     fillCmbDepths(d->colorSpaceSelector->cmbColorModels->currentItem());
 
     d->colorSpaceSelector->bnInstallProfile->setIcon(KisIconUtils::loadIcon("document-open"));
     d->colorSpaceSelector->bnInstallProfile->setToolTip( i18n("Open Color Profile") );
 
     connect(d->colorSpaceSelector->cmbColorModels, SIGNAL(activated(const KoID &)),
             this, SLOT(fillCmbDepths(const KoID &)));
     connect(d->colorSpaceSelector->cmbColorDepth, SIGNAL(activated(const KoID &)),
             this, SLOT(fillCmbProfiles()));
     connect(d->colorSpaceSelector->cmbColorModels, SIGNAL(activated(const KoID &)),
             this, SLOT(fillCmbProfiles()));
     connect(d->colorSpaceSelector->cmbProfile, SIGNAL(activated(const QString &)),
             this, SLOT(colorSpaceChanged()));
-    connect(d->colorSpaceSelector->bnInstallProfile, SIGNAL(clicked()), 
+    connect(d->colorSpaceSelector->bnInstallProfile, SIGNAL(clicked()),
             this, SLOT(installProfile()));
 
     d->defaultsuffix = " "+i18nc("This is appended to the color profile which is the default for the given colorspace and bit-depth","(Default)");
 
     connect(d->colorSpaceSelector->bnAdvanced, SIGNAL(clicked()), this,  SLOT(slotOpenAdvancedSelector()));
 
     fillCmbProfiles();
 }
 
 KisColorSpaceSelector::~KisColorSpaceSelector()
 {
     delete d->colorSpaceSelector;
     delete d;
 }
 
 
 void KisColorSpaceSelector::fillCmbProfiles()
 {
     QString s = KoColorSpaceRegistry::instance()->colorSpaceId(d->colorSpaceSelector->cmbColorModels->currentItem(), d->colorSpaceSelector->cmbColorDepth->currentItem());
     d->colorSpaceSelector->cmbProfile->clear();
 
     const KoColorSpaceFactory * csf = KoColorSpaceRegistry::instance()->colorSpaceFactory(s);
     if (csf == 0) return;
 
     QList<const KoColorProfile *>  profileList = KoColorSpaceRegistry::instance()->profilesFor(csf);
     QStringList profileNames;
     Q_FOREACH (const KoColorProfile *profile, profileList) {
         profileNames.append(profile->name());
     }
     qSort(profileNames);
     Q_FOREACH (QString stringName, profileNames) {
         if (stringName==csf->defaultProfile()) {
             d->colorSpaceSelector->cmbProfile->addSqueezedItem(stringName+d->defaultsuffix);
         } else {
             d->colorSpaceSelector->cmbProfile->addSqueezedItem(stringName);
         }
     }
     d->colorSpaceSelector->cmbProfile->setCurrent(csf->defaultProfile()+d->defaultsuffix);
     colorSpaceChanged();
 }
 
 void KisColorSpaceSelector::fillCmbDepths(const KoID& id)
 {
     KoID activeDepth = d->colorSpaceSelector->cmbColorDepth->currentItem();
     d->colorSpaceSelector->cmbColorDepth->clear();
     QList<KoID> depths = KoColorSpaceRegistry::instance()->colorDepthList(id, KoColorSpaceRegistry::OnlyUserVisible);
 
     // order the depth by name
     qSort(depths.begin(), depths.end(), sortBitDepthsComparer);
 
     d->colorSpaceSelector->cmbColorDepth->setIDList(depths);
     if (depths.contains(activeDepth)) {
         d->colorSpaceSelector->cmbColorDepth->setCurrent(activeDepth);
     }
 }
 
 
 bool KisColorSpaceSelector::sortBitDepthsComparer(KoID depthOne, KoID depthTwo) {
 
     // to order these right, we need to first order by bit depth, then by if it is floating or not
     QString bitDepthOne = depthOne.name().split(" ")[0];
     QString bitDepthTwo = depthTwo.name().split(" ")[0];
 
 
     if (bitDepthOne.toInt() > bitDepthTwo.toInt()) {
         return false;
     }
 
     if (bitDepthOne.toInt() == bitDepthTwo.toInt()) {
         // bit depth number is the same, so now we need to compare if it is a floating type or not
         // the second value [1], just says 'bits', so that is why we look for [2] which has the float word
         QString bitDepthOneType = "";
         QString bitDepthTwoType = "";
 
         if (depthOne.name().split(" ").length() > 2) {
-             bitDepthOneType = depthOne.name().split(" ")[2];
+            bitDepthOneType = depthOne.name().split(" ")[2];
         }
         if (depthTwo.name().split(" ").length() > 2) {
-             bitDepthTwoType = depthTwo.name().split(" ")[2];
+            bitDepthTwoType = depthTwo.name().split(" ")[2];
         }
 
         if (bitDepthOneType.length() > bitDepthTwoType.length()) {
             return false;
         }
     }
 
 
     return true;
 }
 
 
 const KoColorSpace* KisColorSpaceSelector::currentColorSpace()
 {
     QString profilenamestring = d->colorSpaceSelector->cmbProfile->itemHighlighted();
     if (profilenamestring.contains(d->defaultsuffix)) {
         profilenamestring.remove(d->defaultsuffix);
         return KoColorSpaceRegistry::instance()->colorSpace(
-               d->colorSpaceSelector->cmbColorModels->currentItem().id(),
-               d->colorSpaceSelector->cmbColorDepth->currentItem().id(),
-               profilenamestring);
+                    d->colorSpaceSelector->cmbColorModels->currentItem().id(),
+                    d->colorSpaceSelector->cmbColorDepth->currentItem().id(),
+                    profilenamestring);
     } else {
         return KoColorSpaceRegistry::instance()->colorSpace(
-               d->colorSpaceSelector->cmbColorModels->currentItem().id(),
-               d->colorSpaceSelector->cmbColorDepth->currentItem().id(),
-               profilenamestring);
+                    d->colorSpaceSelector->cmbColorModels->currentItem().id(),
+                    d->colorSpaceSelector->cmbColorDepth->currentItem().id(),
+                    profilenamestring);
     }
 }
 
 void KisColorSpaceSelector::setCurrentColorModel(const KoID& id)
 {
     d->colorSpaceSelector->cmbColorModels->setCurrent(id);
     fillCmbDepths(id);
 }
 
 void KisColorSpaceSelector::setCurrentColorDepth(const KoID& id)
 {
     d->colorSpaceSelector->cmbColorDepth->setCurrent(id);
     fillCmbProfiles();
 }
 
 void KisColorSpaceSelector::setCurrentProfile(const QString& name)
 {
     d->colorSpaceSelector->cmbProfile->setCurrent(name);
 }
 
 void KisColorSpaceSelector::setCurrentColorSpace(const KoColorSpace* colorSpace)
 {
-  setCurrentColorModel(colorSpace->colorModelId());
-  setCurrentColorDepth(colorSpace->colorDepthId());
-  setCurrentProfile(colorSpace->profile()->name());
+    if (!colorSpace) {
+        return;
+    }
+    setCurrentColorModel(colorSpace->colorModelId());
+    setCurrentColorDepth(colorSpace->colorDepthId());
+    setCurrentProfile(colorSpace->profile()->name());
 }
 
 void KisColorSpaceSelector::showColorBrowserButton(bool showButton) {
- d->colorSpaceSelector->bnAdvanced->setVisible(showButton);
+    d->colorSpaceSelector->bnAdvanced->setVisible(showButton);
 }
 
 void KisColorSpaceSelector::colorSpaceChanged()
 {
     bool valid = d->colorSpaceSelector->cmbProfile->count() != 0;
     d->profileValid = valid;
     emit(selectionChanged(valid));
     if(valid) {
         emit colorSpaceChanged(currentColorSpace());
         QString text = currentColorSpace()->profile()->name();
     }
 }
 
 void KisColorSpaceSelector::installProfile()
 {
     QStringList mime;
     KoFileDialog dialog(this, KoFileDialog::OpenFiles, "OpenDocumentICC");
     dialog.setCaption(i18n("Install Color Profiles"));
     dialog.setDefaultDir(QDesktopServices::storageLocation(QDesktopServices::HomeLocation));
     dialog.setMimeTypeFilters(QStringList() << "application/vnd.iccprofile", "application/vnd.iccprofile");
-    
+
     QStringList profileNames = dialog.filenames();
 
     KoColorSpaceEngine *iccEngine = KoColorSpaceEngineRegistry::instance()->get("icc");
     Q_ASSERT(iccEngine);
 
     QString saveLocation = KoResourcePaths::saveLocation("icc_profiles");
 
     Q_FOREACH (const QString &profileName, profileNames) {
         QUrl file(profileName);
         if (!QFile::copy(profileName, saveLocation + file.fileName())) {
             dbgKrita << "Could not install profile!";
             return;
         }
         iccEngine->addProfile(saveLocation + file.fileName());
 
     }
 
     fillCmbProfiles();
 }
 
 void KisColorSpaceSelector::slotOpenAdvancedSelector()
 {
     if (!m_advancedSelector) {
         m_advancedSelector = new KisAdvancedColorSpaceSelector(this, "Select a Colorspace");
         m_advancedSelector->setModal(true);
-        m_advancedSelector->setCurrentColorSpace(currentColorSpace());
+        if (currentColorSpace()) {
+            m_advancedSelector->setCurrentColorSpace(currentColorSpace());
+        }
         connect(m_advancedSelector, SIGNAL(selectionChanged(bool)), this, SLOT(slotProfileValid(bool)) );
     }
 
     QDialog::DialogCode result = (QDialog::DialogCode)m_advancedSelector->exec();
 
     if (result) {
         if (d->profileValid==true) {
             setCurrentColorSpace(m_advancedSelector->currentColorSpace());
         }
     }
 }
 
 void KisColorSpaceSelector::slotProfileValid(bool valid)
 {
     d->profileValid = valid;
 }
 
diff --git a/libs/widgets/KoShadowConfigWidget.cpp b/libs/widgets/KoShadowConfigWidget.cpp
index 4807d08105..6e7ff4b785 100644
--- a/libs/widgets/KoShadowConfigWidget.cpp
+++ b/libs/widgets/KoShadowConfigWidget.cpp
@@ -1,231 +1,241 @@
 /* This file is part of the KDE project
  * Copyright (C) 2012 C. Boemann <cbo@boemann.dk>
  * Copyright (C) 2008 Jan Hambrecht <jaham@gmx.net>
  *
  * This library is free software; you can redistribute it and/or
  * modify it under the terms of the GNU Library General Public
  * License as published by the Free Software Foundation; either
  * version 2 of the License, or (at your option) any later version.
  *
  * This library is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  * Library General Public License for more details.
  *
  * You should have received a copy of the GNU Library General Public License
  * along with this library; see the file COPYING.LIB.  If not, write to
  * the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
  * Boston, MA 02110-1301, USA.
  */
 
 #include "KoShadowConfigWidget.h"
 #include "ui_KoShadowConfigWidget.h"
 
 #include <KoIcon.h>
 #include <KoUnit.h>
 #include <KoColorPopupAction.h>
 #include <KoCanvasBase.h>
 #include <KoCanvasResourceManager.h>
 #include <KoSelection.h>
 #include <KoShapeShadow.h>
 #include <KoShapeShadowCommand.h>
 #include <KoShapeManager.h>
 
 #include <klocalizedstring.h>
 
 #include <QCheckBox>
 
 #include <math.h>
 
 class Q_DECL_HIDDEN KoShadowConfigWidget::Private
 {
 public:
     Private()
     {
     }
     Ui_KoShadowConfigWidget widget;
     KoColorPopupAction *actionShadowColor;
     KoCanvasBase *canvas;
 };
 
 KoShadowConfigWidget::KoShadowConfigWidget(QWidget *parent)
     : QWidget(parent)
     , d(new Private())
 {
     d->widget.setupUi(this);
     d->widget.shadowOffset->setValue(8.0);
     d->widget.shadowBlur->setValue(8.0);
     d->widget.shadowBlur->setMinimum(0.0);
     d->widget.shadowAngle->setValue(315.0);
     d->widget.shadowAngle->setMinimum(0.0);
     d->widget.shadowAngle->setMaximum(360.0);
     d->widget.shadowVisible->setChecked(false);
     visibilityChanged();
 
     d->actionShadowColor = new KoColorPopupAction(this);
     d->actionShadowColor->setCurrentColor(QColor(0, 0, 0, 192)); // some reasonable default for shadow
     d->actionShadowColor->setIcon(koIcon("format-stroke-color"));
     d->actionShadowColor->setToolTip(i18n("Change the color of the shadow"));
     d->widget.shadowColor->setDefaultAction(d->actionShadowColor);
 
     connect(d->widget.shadowVisible, SIGNAL(toggled(bool)), this, SLOT(applyChanges()));
     connect(d->widget.shadowVisible, SIGNAL(toggled(bool)), this, SLOT(visibilityChanged()));
     connect(d->actionShadowColor, SIGNAL(colorChanged(const KoColor&)), this, SLOT(applyChanges()));
     connect(d->widget.shadowAngle, SIGNAL(valueChanged(int)), this, SLOT(applyChanges()));
     connect(d->widget.shadowOffset, SIGNAL(valueChangedPt(qreal)), this, SLOT(applyChanges()));
     connect(d->widget.shadowBlur, SIGNAL(valueChangedPt(qreal)), this, SLOT(applyChanges()));
 }
 
 KoShadowConfigWidget::~KoShadowConfigWidget()
 {
     delete d;
 }
 
 void KoShadowConfigWidget::setShadowColor(const QColor &color)
 {
     d->widget.shadowColor->blockSignals(true);
     d->actionShadowColor->blockSignals(true);
 
     d->actionShadowColor->setCurrentColor( color );
 
     d->actionShadowColor->blockSignals(false);
     d->widget.shadowColor->blockSignals(false);
 }
 
 QColor KoShadowConfigWidget::shadowColor() const
 {
     return d->actionShadowColor->currentColor();
 }
 
 void KoShadowConfigWidget::setShadowOffset(const QPointF &offset)
 {
     qreal length = sqrt(offset.x()*offset.x() + offset.y()*offset.y());
     qreal angle = atan2(-offset.y(), offset.x());
     if (angle < 0.0) {
         angle += 2*M_PI;
     }
 
     d->widget.shadowAngle->blockSignals(true);
     d->widget.shadowAngle->setValue(-90 - angle * 180.0 / M_PI);
     d->widget.shadowAngle->blockSignals(false);
 
     d->widget.shadowOffset->blockSignals(true);
     d->widget.shadowOffset->changeValue(length);
     d->widget.shadowOffset->blockSignals(false);
 }
 
 QPointF KoShadowConfigWidget::shadowOffset() const
 {
     QPointF offset(d->widget.shadowOffset->value(), 0);
     QTransform m;
     m.rotate(d->widget.shadowAngle->value() + 90);
     return m.map(offset);
 }
 
 void KoShadowConfigWidget::setShadowBlur(const qreal &blur)
 {
     d->widget.shadowBlur->blockSignals(true);
     d->widget.shadowBlur->changeValue(blur);
     d->widget.shadowBlur->blockSignals(false);
 }
 
 qreal KoShadowConfigWidget::shadowBlur() const
 {
     return d->widget.shadowBlur->value();
 }
 
 void KoShadowConfigWidget::setShadowVisible(bool visible)
 {
     d->widget.shadowVisible->blockSignals(true);
     d->widget.shadowVisible->setChecked(visible);
     d->widget.shadowVisible->blockSignals(false);
     visibilityChanged();
 }
 
 bool KoShadowConfigWidget::shadowVisible() const
 {
     return d->widget.shadowVisible->isChecked();
 }
 
 void KoShadowConfigWidget::visibilityChanged()
 {
     d->widget.shadowAngle->setEnabled( d->widget.shadowVisible->isChecked() );
     d->widget.shadowBlur->setEnabled( d->widget.shadowVisible->isChecked() );
     d->widget.shadowColor->setEnabled( d->widget.shadowVisible->isChecked() );
     d->widget.shadowOffset->setEnabled( d->widget.shadowVisible->isChecked() );
 }
 
 void KoShadowConfigWidget::applyChanges()
 {
     if (d->canvas) {
         KoSelection *selection = d->canvas->shapeManager()->selection();
         KoShape * shape = selection->firstSelectedShape(KoFlake::TopLevelSelection);
         if (! shape) {
             return;
         }
 
         KoShapeShadow *newShadow = new KoShapeShadow();
         newShadow->setVisible(shadowVisible());
         newShadow->setColor(shadowColor());
         newShadow->setOffset(shadowOffset());
         newShadow->setBlur(shadowBlur());
         d->canvas->addCommand(new KoShapeShadowCommand(selection->selectedShapes(KoFlake::TopLevelSelection), newShadow));
     }
 }
 
 void KoShadowConfigWidget::selectionChanged()
 {
     if (! d->canvas) {
         return;
     }
 
     KoSelection *selection = d->canvas->shapeManager()->selection();
     KoShape * shape = selection->firstSelectedShape(KoFlake::TopLevelSelection);
 
     setEnabled(shape != 0);
 
     if (! shape) {
         setShadowVisible(false);
         return;
     }
 
     KoShapeShadow * shadow = shape->shadow();
     if (! shadow) {
         setShadowVisible(false);
         return;
     }
 
     setShadowVisible(shadow->isVisible());
     setShadowOffset(shadow->offset());
     setShadowColor(shadow->color());
     setShadowBlur(shadow->blur());
 }
 
 void KoShadowConfigWidget::setCanvas(KoCanvasBase *canvas)
 {
     d->canvas = canvas;
     connect(canvas->shapeManager(), SIGNAL(selectionChanged()), this, SLOT(selectionChanged()));
     connect(canvas->shapeManager(), SIGNAL(selectionContentChanged()), this, SLOT(selectionChanged()));
 
     setUnit(canvas->unit());
 
     connect( d->canvas->resourceManager(), SIGNAL( canvasResourceChanged( int, const QVariant& ) ),
              this, SLOT( resourceChanged( int, const QVariant& ) ) );
 }
 
+void KoShadowConfigWidget::setUnitManagers(KisSpinBoxUnitManager* managerBlur, KisSpinBoxUnitManager *managerOffset)
+{
+    d->widget.shadowOffset->blockSignals(true);
+    d->widget.shadowBlur->blockSignals(true);
+    d->widget.shadowOffset->setUnitManager(managerOffset);
+    d->widget.shadowBlur->setUnitManager(managerBlur);
+    d->widget.shadowOffset->blockSignals(false);
+    d->widget.shadowBlur->blockSignals(false);
+}
+
 void KoShadowConfigWidget::setUnit(const KoUnit &unit)
 {
     d->widget.shadowOffset->blockSignals(true);
     d->widget.shadowBlur->blockSignals(true);
     d->widget.shadowOffset->setUnit(unit);
     d->widget.shadowBlur->setUnit(unit);
     d->widget.shadowOffset->blockSignals(false);
     d->widget.shadowBlur->blockSignals(false);
 }
 
 void KoShadowConfigWidget::resourceChanged( int key, const QVariant & res )
 {
     if( key == KoCanvasResourceManager::Unit ) {
         setUnit(res.value<KoUnit>());
     }
 }
diff --git a/libs/widgets/KoShadowConfigWidget.h b/libs/widgets/KoShadowConfigWidget.h
index ba6e7a5aa5..3786268ecf 100644
--- a/libs/widgets/KoShadowConfigWidget.h
+++ b/libs/widgets/KoShadowConfigWidget.h
@@ -1,77 +1,80 @@
 /* This file is part of the KDE project
  * Copyright (C) 2012 C. Boemann <cbo@boemann.dk>
  * Copyright (C) 2008 Jan Hambrecht <jaham@gmx.net>
  *
  * This library is free software; you can redistribute it and/or
  * modify it under the terms of the GNU Library General Public
  * License as published by the Free Software Foundation; either
  * version 2 of the License, or (at your option) any later version.
  *
  * This library is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  * Library General Public License for more details.
  *
  * You should have received a copy of the GNU Library General Public License
  * along with this library; see the file COPYING.LIB.  If not, write to
  * the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
  * Boston, MA 02110-1301, USA.
  */
 
 #ifndef KOSHADOWCONFIGWIDGET_H
 #define KOSHADOWCONFIGWIDGET_H
 
 #include "kritawidgets_export.h"
 #include <QWidget>
 
 class KoUnit;
 class KoCanvasBase;
+class KisSpinBoxUnitManager;
 
 /// A widget for configuring the shadow of a shape
 class KRITAWIDGETS_EXPORT KoShadowConfigWidget : public QWidget
 {
     Q_OBJECT
 public:
     explicit KoShadowConfigWidget(QWidget *parent);
     ~KoShadowConfigWidget();
 
     /// Sets the shadow color
     void setShadowColor(const QColor &color);
 
     /// Returns the shadow color
     QColor shadowColor() const;
 
     /// Sets the shadow offset
     void setShadowOffset(const QPointF &offset);
 
     /// Returns the shadow offset
     QPointF shadowOffset() const;
 
     /// Sets the shadow blur radius
     void setShadowBlur(const qreal &blur);
 
     /// Returns the shadow blur radius
     qreal shadowBlur() const;
 
     /// Sets if the shadow is visible
     void setShadowVisible(bool visible);
 
     /// Returns if shadow is visible
     bool shadowVisible() const;
 
 public Q_SLOTS:
+
+    void setUnitManagers(KisSpinBoxUnitManager* managerBlur, KisSpinBoxUnitManager* managerOffset);
     void setUnit( const KoUnit &unit );
     void setCanvas(KoCanvasBase *canvas);
 
 private Q_SLOTS:
     void visibilityChanged();
     void applyChanges();
     void selectionChanged();
     void resourceChanged( int key, const QVariant & res );
 
 private:
     class Private;
     Private *const d;
 };
 
 #endif // KOSHADOWCONFIGWIDGET_H
diff --git a/libs/widgets/KoStrokeConfigWidget.cpp b/libs/widgets/KoStrokeConfigWidget.cpp
index 8f9088fc54..22c3135849 100644
--- a/libs/widgets/KoStrokeConfigWidget.cpp
+++ b/libs/widgets/KoStrokeConfigWidget.cpp
@@ -1,552 +1,571 @@
 /* This file is part of the KDE project
  * Made by Tomislav Lukman (tomislav.lukman@ck.tel.hr)
  * Copyright (C) 2002 Tomislav Lukman <tomislav.lukman@ck.t-com.hr>
  * Copyright (C) 2002-2003 Rob Buis <buis@kde.org>
  * Copyright (C) 2005-2006 Tim Beaulen <tbscope@gmail.com>
  * Copyright (C) 2005-2007 Thomas Zander <zander@kde.org>
  * Copyright (C) 2005-2006, 2011 Inge Wallin <inge@lysator.liu.se>
  * Copyright (C) 2005-2008 Jan Hambrecht <jaham@gmx.net>
  * Copyright (C) 2006 C. Boemann <cbo@boemann.dk>
  * Copyright (C) 2006 Peter Simonsson <psn@linux.se>
  * Copyright (C) 2006 Laurent Montel <montel@kde.org>
  * Copyright (C) 2007,2011 Thorsten Zachmann <t.zachmann@zagge.de>
  * Copyright (C) 2011 Jean-Nicolas Artaud <jeannicolasartaud@gmail.com>
  *
  * This library is free software; you can redistribute it and/or
  * modify it under the terms of the GNU Library General Public
  * License as published by the Free Software Foundation; either
  * version 2 of the License, or (at your option) any later version.
  *
  * This library is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  * Library General Public License for more details.
  *
  * You should have received a copy of the GNU Library General Public License
  * along with this library; see the file COPYING.LIB.  If not, write to
  * the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
  * Boston, MA 02110-1301, USA.
  */
 
 // Own
 #include "KoStrokeConfigWidget.h"
 
 // Qt
 #include <QMenu>
 #include <QLabel>
 #include <QToolButton>
 #include <QButtonGroup>
 #include <QVBoxLayout>
 #include <QHBoxLayout>
 #include <QSizePolicy>
 
 // KDE
 #include <klocalizedstring.h>
 
 // Calligra
 #include <KoIcon.h>
 #include <KoUnit.h>
 #include <KoLineStyleSelector.h>
 #include <KoUnitDoubleSpinBox.h>
 #include <KoMarkerSelector.h>
 #include <KoColorPopupAction.h>
 #include <KoMarker.h>
 #include <KoShapeStroke.h>
 #include <KoPathShape.h>
 #include <KoMarkerCollection.h>
 #include <KoPathShapeMarkerCommand.h>
 #include <KoCanvasBase.h>
 #include <KoCanvasController.h>
 #include <KoCanvasResourceManager.h>
 #include <KoDocumentResourceManager.h>
 #include <KoToolManager.h>
 #include <KoSelection.h>
 #include <KoShapeController.h>
 #include <KoShapeManager.h>
 #include <KoShapeStrokeCommand.h>
 #include <KoShapeStrokeModel.h>
 
 // Krita
 #include "kis_double_parse_unit_spin_box.h"
 
 class CapNJoinMenu : public QMenu
 {
 public:
     CapNJoinMenu(QWidget *parent = 0);
     QSize sizeHint() const override;
 
     KisDoubleParseUnitSpinBox *miterLimit;
     QButtonGroup        *capGroup;
     QButtonGroup        *joinGroup;
 };
 
 CapNJoinMenu::CapNJoinMenu(QWidget *parent)
     : QMenu(parent)
 {
     QGridLayout *mainLayout = new QGridLayout();
     mainLayout->setMargin(2);
 
-     // The cap group
+    // The cap group
     capGroup = new QButtonGroup(this);
     capGroup->setExclusive(true);
 
     QToolButton *button = 0;
 
     button = new QToolButton(this);
     button->setIcon(koIcon("stroke-cap-butt"));
     button->setCheckable(true);
     button->setToolTip(i18n("Butt cap"));
     capGroup->addButton(button, Qt::FlatCap);
     mainLayout->addWidget(button, 2, 0);
 
     button = new QToolButton(this);
     button->setIcon(koIcon("stroke-cap-round"));
     button->setCheckable(true);
     button->setToolTip(i18n("Round cap"));
     capGroup->addButton(button, Qt::RoundCap);
     mainLayout->addWidget(button, 2, 1);
 
     button = new QToolButton(this);
     button->setIcon(koIcon("stroke-cap-square"));
     button->setCheckable(true);
     button->setToolTip(i18n("Square cap"));
     capGroup->addButton(button, Qt::SquareCap);
     mainLayout->addWidget(button, 2, 2, Qt::AlignLeft);
 
     // The join group
     joinGroup = new QButtonGroup(this);
     joinGroup->setExclusive(true);
 
     button = new QToolButton(this);
     button->setIcon(koIcon("stroke-join-miter"));
     button->setCheckable(true);
     button->setToolTip(i18n("Miter join"));
     joinGroup->addButton(button, Qt::MiterJoin);
     mainLayout->addWidget(button, 3, 0);
 
     button = new QToolButton(this);
     button->setIcon(koIcon("stroke-join-round"));
     button->setCheckable(true);
     button->setToolTip(i18n("Round join"));
     joinGroup->addButton(button, Qt::RoundJoin);
     mainLayout->addWidget(button, 3, 1);
 
     button = new QToolButton(this);
     button->setIcon(koIcon("stroke-join-bevel"));
     button->setCheckable(true);
     button->setToolTip(i18n("Bevel join"));
     joinGroup->addButton(button, Qt::BevelJoin);
     mainLayout->addWidget(button, 3, 2, Qt::AlignLeft);
 
     // Miter limit
     // set min/max/step and value in points, then set actual unit
     miterLimit = new KisDoubleParseUnitSpinBox(this);
     miterLimit->setMinMaxStep(0.0, 1000.0, 0.5);
     miterLimit->setDecimals(2);
-    miterLimit->setUnit(KoUnit(KoUnit::Point));
     miterLimit->setToolTip(i18n("Miter limit"));
+    miterLimit->setUnitChangeFromOutsideBehavior(false);
     mainLayout->addWidget(miterLimit, 4, 0, 1, 3);
 
     mainLayout->setSizeConstraint(QLayout::SetMinAndMaxSize);
     setLayout(mainLayout);
 }
 
 QSize CapNJoinMenu::sizeHint() const
 {
     return layout()->sizeHint();
 }
 
 
 class Q_DECL_HIDDEN KoStrokeConfigWidget::Private
 {
 public:
     Private()
         : canvas(0),
-        active(true)
+          active(true),
+          allowLocalUnitManagement(true)
     {
     }
 
     KoLineStyleSelector *lineStyle;
     KisDoubleParseUnitSpinBox *lineWidth;
     KoMarkerSelector    *startMarkerSelector;
     KoMarkerSelector    *endMarkerSelector;
 
     CapNJoinMenu *capNJoinMenu;
     QToolButton *colorButton;
     KoColorPopupAction *colorAction;
 
     QWidget *spacer;
 
     KoCanvasBase *canvas;
 
     bool active;
+    bool allowLocalUnitManagement;
 };
 
 KoStrokeConfigWidget::KoStrokeConfigWidget(QWidget * parent)
     : QWidget(parent)
     , d(new Private())
 {
     setObjectName("Stroke widget");
     QVBoxLayout *mainLayout = new QVBoxLayout(this);
     mainLayout->setMargin(0);
 
     QHBoxLayout *firstLineLayout = new QHBoxLayout();
 
     // Start marker
     QList<KoMarker*> markers;
 
     d->startMarkerSelector = new KoMarkerSelector(KoMarkerData::MarkerStart, this);
     d->startMarkerSelector->updateMarkers(markers);
     d->startMarkerSelector->setMaximumWidth(50);
     firstLineLayout->addWidget(d->startMarkerSelector);
 
     // Line style
     d->lineStyle = new KoLineStyleSelector(this);
     d->lineStyle->setMinimumWidth(70);
     firstLineLayout->addWidget(d->lineStyle);
 
     // End marker
     d->endMarkerSelector = new KoMarkerSelector(KoMarkerData::MarkerEnd, this);
     d->endMarkerSelector->updateMarkers(markers);
     d->endMarkerSelector->setMaximumWidth(50);
     firstLineLayout->addWidget(d->endMarkerSelector);
 
     QHBoxLayout *secondLineLayout = new QHBoxLayout();
 
     // Line width
     QLabel *l = new QLabel(this);
     l->setText(i18n("Thickness:"));
     l->setAlignment(Qt::AlignRight | Qt::AlignVCenter);
     l->setSizePolicy(QSizePolicy::Fixed, QSizePolicy::Fixed);
     secondLineLayout->addWidget(l);
 
     // set min/max/step and value in points, then set actual unit
     d->lineWidth = new KisDoubleParseUnitSpinBox(this);
     d->lineWidth->setMinMaxStep(0.0, 1000.0, 0.5);
     d->lineWidth->setDecimals(2);
-    d->lineWidth->setUnit(KoUnit(KoUnit::Point));
+    d->lineWidth->setUnitChangeFromOutsideBehavior(false);
     d->lineWidth->setToolTip(i18n("Set line width of actual selection"));
     secondLineLayout->addWidget(d->lineWidth);
 
     QToolButton *capNJoinButton = new QToolButton(this);
     capNJoinButton->setMinimumHeight(25);
     d->capNJoinMenu = new CapNJoinMenu(this);
     capNJoinButton->setMenu(d->capNJoinMenu);
     capNJoinButton->setText("...");
     capNJoinButton->setPopupMode(QToolButton::InstantPopup);
 
     secondLineLayout->addWidget(capNJoinButton);
 
     d->colorButton = new QToolButton(this);
     secondLineLayout->addWidget(d->colorButton);
     d->colorAction = new KoColorPopupAction(this);
     d->colorAction->setIcon(koIcon("format-stroke-color"));
     d->colorAction->setToolTip(i18n("Change the color of the line/border"));
     d->colorButton->setDefaultAction(d->colorAction);
 
     mainLayout->addLayout(firstLineLayout);
     mainLayout->addLayout(secondLineLayout);
 
     // Spacer
     d->spacer = new QWidget();
     d->spacer->setObjectName("SpecialSpacer");
     mainLayout->addWidget(d->spacer);
 
 
     // set sensitive defaults
     d->lineStyle->setLineStyle(Qt::SolidLine);
     d->lineWidth->changeValue(1);
     d->colorAction->setCurrentColor(Qt::black);
 
     // Make the signals visible on the outside of this widget.
     connect(d->lineStyle,  SIGNAL(currentIndexChanged(int)), this, SLOT(applyChanges()));
     connect(d->lineWidth,  SIGNAL(valueChangedPt(qreal)),    this, SLOT(applyChanges()));
     connect(d->colorAction, SIGNAL(colorChanged(const KoColor &)), this, SLOT(applyChanges()));
     connect(d->capNJoinMenu->capGroup,   SIGNAL(buttonClicked(int)),       this, SLOT(applyChanges()));
     connect(d->capNJoinMenu->joinGroup,  SIGNAL(buttonClicked(int)),       this, SLOT(applyChanges()));
     connect(d->capNJoinMenu->miterLimit, SIGNAL(valueChangedPt(qreal)),    this, SLOT(applyChanges()));
     connect(d->startMarkerSelector,  SIGNAL(currentIndexChanged(int)), this, SLOT(startMarkerChanged()));
     connect(d->endMarkerSelector,  SIGNAL(currentIndexChanged(int)), this, SLOT(endMarkerChanged()));
 }
 
 KoStrokeConfigWidget::~KoStrokeConfigWidget()
 {
     delete d;
 }
 
 // ----------------------------------------------------------------
 //                         getters and setters
 
 
 Qt::PenStyle KoStrokeConfigWidget::lineStyle() const
 {
     return d->lineStyle->lineStyle();
 }
 
 QVector<qreal> KoStrokeConfigWidget::lineDashes() const
 {
     return d->lineStyle->lineDashes();
 }
 
 qreal KoStrokeConfigWidget::lineWidth() const
 {
     return d->lineWidth->value();
 }
 
 QColor KoStrokeConfigWidget::color() const
 {
     return d->colorAction->currentColor();
 }
 
 qreal KoStrokeConfigWidget::miterLimit() const
 {
     return d->capNJoinMenu->miterLimit->value();
 }
 
 KoMarker *KoStrokeConfigWidget::startMarker() const
 {
     return d->startMarkerSelector->marker();
 }
 
 KoMarker *KoStrokeConfigWidget::endMarker() const
 {
     return d->endMarkerSelector->marker();
 }
 
 Qt::PenCapStyle KoStrokeConfigWidget::capStyle() const
 {
     return static_cast<Qt::PenCapStyle>(d->capNJoinMenu->capGroup->checkedId());
 }
 
 Qt::PenJoinStyle KoStrokeConfigWidget::joinStyle() const
 {
     return static_cast<Qt::PenJoinStyle>(d->capNJoinMenu->joinGroup->checkedId());
 }
 
 KoShapeStroke* KoStrokeConfigWidget::createShapeStroke() const
 {
     KoShapeStroke *stroke = new KoShapeStroke();
 
     stroke->setColor(color());
     stroke->setLineWidth(lineWidth());
     stroke->setCapStyle(capStyle());
     stroke->setJoinStyle(joinStyle());
     stroke->setMiterLimit(miterLimit());
     stroke->setLineStyle(lineStyle(), lineDashes());
 
     return stroke;
 }
 
 // ----------------------------------------------------------------
 //                         Other public functions
 
 void KoStrokeConfigWidget::updateControls(KoShapeStrokeModel *stroke, KoMarker *startMarker, KoMarker *endMarker)
 {
     blockChildSignals(true);
 
     const KoShapeStroke *lineStroke = dynamic_cast<const KoShapeStroke*>(stroke);
     if (lineStroke) {
         d->lineWidth->changeValue(lineStroke->lineWidth());
         QAbstractButton *button = d->capNJoinMenu->capGroup->button(lineStroke->capStyle());
         if (button) {
             button->setChecked(true);
         }
         button = d->capNJoinMenu->joinGroup->button(lineStroke->joinStyle());
         if (button) {
             button->setChecked(true);
         }
         d->capNJoinMenu->miterLimit->changeValue(lineStroke->miterLimit());
         d->capNJoinMenu->miterLimit->setEnabled(lineStroke->joinStyle() == Qt::MiterJoin);
         d->lineStyle->setLineStyle(lineStroke->lineStyle(), lineStroke->lineDashes());
         d->colorAction->setCurrentColor(lineStroke->color());
     }
     else {
         d->lineWidth->changeValue(0.0);
         d->capNJoinMenu->capGroup->button(Qt::FlatCap)->setChecked(true);
         d->capNJoinMenu->joinGroup->button(Qt::MiterJoin)->setChecked(true);
         d->capNJoinMenu->miterLimit->changeValue(0.0);
         d->capNJoinMenu->miterLimit->setEnabled(true);
         d->lineStyle->setLineStyle(Qt::NoPen, QVector<qreal>());
     }
 
     d->startMarkerSelector->setMarker(startMarker);
     d->endMarkerSelector->setMarker(endMarker);
 
     blockChildSignals(false);
 }
 
 void KoStrokeConfigWidget::setUnit(const KoUnit &unit)
 {
+    if (!d->allowLocalUnitManagement) {
+        return; //the unit management is completly transfered to the unitManagers.
+    }
+
     blockChildSignals(true);
 
     KoCanvasController* canvasController = KoToolManager::instance()->activeCanvasController();
     KoSelection *selection = canvasController->canvas()->shapeManager()->selection();
     KoShape * shape = selection->firstSelectedShape();
 
     /**
      * KoStrokeShape knows nothing about the transformations applied
      * to the shape, which doesn't prevent the shape to apply them and
      * display the stroke differently. So just take that into account
      * and show the user correct values using the multiplier in KoUnit.
      */
     KoUnit newUnit(unit);
     if (shape) {
         newUnit.adjustByPixelTransform(shape->absoluteTransformation(0));
     }
 
     d->lineWidth->setUnit(newUnit);
     d->capNJoinMenu->miterLimit->setUnit(newUnit);
 
     blockChildSignals(false);
 }
 
 void KoStrokeConfigWidget::updateMarkers(const QList<KoMarker*> &markers)
 {
     d->startMarkerSelector->updateMarkers(markers);
     d->endMarkerSelector->updateMarkers(markers);
 }
 
 void KoStrokeConfigWidget::blockChildSignals(bool block)
 {
     d->colorAction->blockSignals(block);
     d->lineWidth->blockSignals(block);
     d->capNJoinMenu->capGroup->blockSignals(block);
     d->capNJoinMenu->joinGroup->blockSignals(block);
     d->capNJoinMenu->miterLimit->blockSignals(block);
     d->lineStyle->blockSignals(block);
     d->startMarkerSelector->blockSignals(block);
     d->endMarkerSelector->blockSignals(block);
 }
 
 void KoStrokeConfigWidget::setActive(bool active)
 {
     d->active = active;
 }
 
+void KoStrokeConfigWidget::setUnitManagers(KisSpinBoxUnitManager* managerLineWidth,
+                                           KisSpinBoxUnitManager *managerMitterLimit)
+{
+    blockChildSignals(true);
+
+    d->allowLocalUnitManagement = false;
+
+    d->lineWidth->setUnitManager(managerLineWidth);
+    d->capNJoinMenu->miterLimit->setUnitManager(managerMitterLimit);
+
+    blockChildSignals(false);
+}
+
 //------------------------
 void KoStrokeConfigWidget::applyChanges()
 {
     KoCanvasController* canvasController = KoToolManager::instance()->activeCanvasController();
     KoSelection *selection = canvasController->canvas()->shapeManager()->selection();
 
     //FIXME d->canvas->resourceManager()->setActiveStroke( d->stroke );
 
     if (!selection || !selection->count()) {
         return;
     }
 
     KoShapeStroke *newStroke = new KoShapeStroke();
     KoShapeStroke *oldStroke = dynamic_cast<KoShapeStroke*>( selection->firstSelectedShape()->stroke() );
     if (oldStroke) {
         newStroke->setLineBrush(oldStroke->lineBrush());
     }
     newStroke->setColor(color());
     newStroke->setLineWidth(lineWidth());
     newStroke->setCapStyle(static_cast<Qt::PenCapStyle>(d->capNJoinMenu->capGroup->checkedId()));
     newStroke->setJoinStyle(static_cast<Qt::PenJoinStyle>(d->capNJoinMenu->joinGroup->checkedId()));
     newStroke->setMiterLimit(miterLimit());
     newStroke->setLineStyle(lineStyle(), lineDashes());
 
     if (d->active) {
         KoShapeStrokeCommand *cmd = new KoShapeStrokeCommand(selection->selectedShapes(), newStroke);
         canvasController->canvas()->addCommand(cmd);
     }
 }
 
 void KoStrokeConfigWidget::applyMarkerChanges(KoMarkerData::MarkerPosition position)
 {
     KoMarker *marker = 0;
     if (position == KoMarkerData::MarkerStart) {
         marker = startMarker();
     }
     else if (position == KoMarkerData::MarkerEnd) {
         marker = endMarker();
     }
 
     KoCanvasController* canvasController = KoToolManager::instance()->activeCanvasController();
     KoSelection *selection = canvasController->canvas()->shapeManager()->selection();
 
     if (! selection || !selection->count()) {
         return;
     }
 
     QList<KoShape*> shapeList = selection->selectedShapes();
     QList<KoPathShape*> pathShapeList;
     for (QList<KoShape*>::iterator itShape = shapeList.begin(); itShape != shapeList.end(); ++itShape) {
         KoPathShape* pathShape = dynamic_cast<KoPathShape*>(*itShape);
         if (pathShape) {
             pathShapeList << pathShape;
         }
     }
 
     if (pathShapeList.size()) {
         KoPathShapeMarkerCommand* cmdMarker = new KoPathShapeMarkerCommand(pathShapeList, marker, position);
         canvasController->canvas()->addCommand(cmdMarker);
     }
 }
 
 void KoStrokeConfigWidget::startMarkerChanged()
 {
     applyMarkerChanges(KoMarkerData::MarkerStart);
 }
 
 void KoStrokeConfigWidget::endMarkerChanged()
 {
     applyMarkerChanges(KoMarkerData::MarkerEnd);
 }
 // ----------------------------------------------------------------
 
 
 
 void KoStrokeConfigWidget::selectionChanged()
 {
     // see a comment in setUnit()
     setUnit(d->canvas->unit());
 
 
     KoCanvasController* canvasController = KoToolManager::instance()->activeCanvasController();
     KoSelection *selection = canvasController->canvas()->shapeManager()->selection();
     KoShape * shape = selection->firstSelectedShape();
     if (shape && shape->stroke()) {
         KoPathShape *pathShape = dynamic_cast<KoPathShape *>(shape);
         if (pathShape) {
             updateControls(shape->stroke(), pathShape->marker(KoMarkerData::MarkerStart),
-                                             pathShape->marker(KoMarkerData::MarkerEnd));
+                           pathShape->marker(KoMarkerData::MarkerEnd));
         }
         else {
             updateControls(shape->stroke(), 0 ,0);
         }
     }
 }
 
 void KoStrokeConfigWidget::setCanvas( KoCanvasBase *canvas )
 {
     if (canvas) {
         connect(canvas->shapeManager()->selection(), SIGNAL(selectionChanged()),
                 this, SLOT(selectionChanged()));
         connect(canvas->shapeManager(), SIGNAL(selectionContentChanged()),
                 this, SLOT(selectionChanged()));
         connect(canvas->resourceManager(), SIGNAL(canvasResourceChanged(int, const QVariant&)),
                 this, SLOT(canvasResourceChanged(int, const QVariant &)));
         setUnit(canvas->unit());
 
         KoDocumentResourceManager *resourceManager = canvas->shapeController()->resourceManager();
         if (resourceManager) {
             KoMarkerCollection *collection = resourceManager->resource(KoDocumentResourceManager::MarkerCollection).value<KoMarkerCollection*>();
             if (collection) {
                 updateMarkers(collection->markers());
             }
         }
     }
 
     d->canvas = canvas;
 }
 
 void KoStrokeConfigWidget::canvasResourceChanged(int key, const QVariant &value)
 {
     switch (key) {
     case KoCanvasResourceManager::Unit:
         setUnit(value.value<KoUnit>());
         break;
     }
 }
diff --git a/libs/widgets/KoStrokeConfigWidget.h b/libs/widgets/KoStrokeConfigWidget.h
index 129a074c19..18b8b27f08 100644
--- a/libs/widgets/KoStrokeConfigWidget.h
+++ b/libs/widgets/KoStrokeConfigWidget.h
@@ -1,104 +1,108 @@
 /* This file is part of the KDE project
  * Made by Tomislav Lukman (tomislav.lukman@ck.tel.hr)
  * Copyright (C) 2002 Tomislav Lukman <tomislav.lukman@ck.t-com.hr>
  * Copyright (C) 2002 Rob Buis <buis@kde.org>
  * Copyright (C) 2004 Laurent Montel <montel@kde.org>
  * Copyright (C) 2005-2006 Tim Beaulen <tbscope@gmail.com>
  * Copyright (C) 2005 Inge Wallin <inge@lysator.liu.se>
  * Copyright (C) 2005, 2011 Thomas Zander <zander@kde.org>
  * Copyright (C) 2005-2008 Jan Hambrecht <jaham@gmx.net>
  * Copyright (C) 2006 C. Boemann <cbo@boemann.dk>
  * Copyright (C) 2011 Jean-Nicolas Artaud <jeannicolasartaud@gmail.com>
  * Copyright (C) 2011 Thorsten Zachmann <zachmann@kde.com>
  *
  * This library is free software; you can redistribute it and/or
  * modify it under the terms of the GNU Library General Public
  * License as published by the Free Software Foundation; either
  * version 2 of the License, or (at your option) any later version.
  *
  * This library is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  * Library General Public License for more details.
  *
  * You should have received a copy of the GNU Library General Public License
  * along with this library; see the file COPYING.LIB.  If not, write to
  * the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
  * Boston, MA 02110-1301, USA.
  */
 
 #ifndef STROKECONFIGWIDGET_H
 #define STROKECONFIGWIDGET_H
 
 #include "kritawidgets_export.h"
 
 #include <QWidget>
 #include <KoMarkerData.h>
 
 class KoUnit;
 class KoShapeStrokeModel;
 class KoMarker;
 class KoCanvasBase;
 class KoShapeStroke;
 
+class KisSpinBoxUnitManager;
+
 /// A widget for configuring the stroke of a shape
 class KRITAWIDGETS_EXPORT KoStrokeConfigWidget : public QWidget
 {
     Q_OBJECT
 public:
     explicit KoStrokeConfigWidget(QWidget *parent);
     ~KoStrokeConfigWidget();
 
     // Getters
     Qt::PenStyle lineStyle() const;
     QVector<qreal> lineDashes() const;
     qreal lineWidth() const;
     QColor color() const;
     qreal miterLimit() const;
     KoMarker *startMarker() const;
     KoMarker *endMarker() const;
     Qt::PenCapStyle capStyle() const;
     Qt::PenJoinStyle joinStyle() const;
 
     /**
      * Creates KoShapeStroke object filled with the options
      * configured by the widget. The caller is in charge of
      * deletion of the returned object
      */
     KoShapeStroke* createShapeStroke() const;
 
     void setCanvas(KoCanvasBase *canvas);
     void setActive(bool active);
 
+    void setUnitManagers(KisSpinBoxUnitManager* managerLineWidth, KisSpinBoxUnitManager* managerMitterLimit);
+
 private Q_SLOTS:
     void updateControls(KoShapeStrokeModel *stroke, KoMarker *startMarker, KoMarker *endMarker);
 
     void updateMarkers(const QList<KoMarker*> &markers);
 
     /// start marker has changed
     void startMarkerChanged();
     /// end marker has changed
     void endMarkerChanged();
 
     void canvasResourceChanged(int key, const QVariant &value);
 
     /// selection has changed
     void selectionChanged();
 
     /// apply line changes to the selected shape
     void applyChanges();
 
 private:
     void setUnit(const KoUnit &unit);
 
     /// apply marker changes to the selected shape
     void applyMarkerChanges(KoMarkerData::MarkerPosition position);
 
     void blockChildSignals(bool block);
 
 private:
     class Private;
     Private * const d;
 };
 
 #endif // SHADOWCONFIGWIDGET_H
diff --git a/libs/widgets/kis_double_parse_spin_box.cpp b/libs/widgets/kis_double_parse_spin_box.cpp
index 801d9cca2f..5b9551ee86 100644
--- a/libs/widgets/kis_double_parse_spin_box.cpp
+++ b/libs/widgets/kis_double_parse_spin_box.cpp
@@ -1,235 +1,240 @@
 /*
  *  Copyright (c) 2016 Laurent Valentin Jospin <laurent.valentin@famillejospin.ch>
  *
  *  This program is free software; you can redistribute it and/or modify
  *  it under the terms of the GNU General Public License as published by
  *  the Free Software Foundation; either version 2 of the License, or
  *  (at your option) any later version.
  *
  *  This program is distributed in the hope that it will be useful,
  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  *  GNU General Public License for more details.
  *
  *  You should have received a copy of the GNU General Public License
  *  along with this program; if not, write to the Free Software
  *  Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
  */
 
 #include "kis_double_parse_spin_box.h"
 
 #include "kis_num_parser.h"
 
 #include <QLabel>
 #include <QPixmap>
 #include <QIcon>
 #include <QFile>
 #include <QLineEdit>
 #include <qnumeric.h> // for qIsNaN
 
 KisDoubleParseSpinBox::KisDoubleParseSpinBox(QWidget *parent) :
     QDoubleSpinBox(parent),
     boolLastValid(true),
     lastExprParsed(QStringLiteral("0.0"))
 {
     connect(this, SIGNAL(noMoreParsingError()),
                     this, SLOT(clearErrorStyle()));
 
     //hack to let the clearError be called, even if the value changed method is the one from QDoubleSpinBox.
     connect(this, SIGNAL(valueChanged(double)),
                     this, SLOT(clearError()));
 
     connect(this, SIGNAL(errorWhileParsing(QString)),
                     this, SLOT(setErrorStyle()));
 
     oldValue = value();
 
     warningIcon = new QLabel(this);
 
     if (QFile(":/./16_light_warning.svg").exists()) {
         warningIcon->setPixmap(QIcon(":/./16_light_warning.svg").pixmap(16, 16));
     } else {
         warningIcon->setText("!");
     }
 
     warningIcon->setStyleSheet("background:transparent;");
     warningIcon->move(1, 1);
     warningIcon->setVisible(false);
 
     isOldPaletteSaved = false;
     areOldMarginsSaved = false;
 
 }
 
 KisDoubleParseSpinBox::~KisDoubleParseSpinBox()
 {
 }
 
 double KisDoubleParseSpinBox::valueFromText(const QString & text) const
 {
     lastExprParsed = text;
 
     bool ok;
 
     double ret;
 
     if ( (suffix().isEmpty() || !text.endsWith(suffix())) &&
          (prefix().isEmpty() || !text.startsWith(prefix())) ) {
 
         ret = KisNumericParser::parseSimpleMathExpr(text, &ok);
 
     } else {
 
         QString expr = text;
 
         if (text.endsWith(suffix())) {
             expr.remove(text.size()-suffix().size(), suffix().size());
         }
 
         if(text.startsWith(prefix())){
             expr.remove(0, prefix().size());
         }
 
         lastExprParsed = expr;
         ret = KisNumericParser::parseSimpleMathExpr(expr, &ok);
     }
 
     if(qIsNaN(ret) || qIsInf(ret)){
         ok = false;
     }
 
     if (!ok) {
         if (boolLastValid) {
             oldValue = value();
         }
 
         boolLastValid = false;
         ret = oldValue; //in case of error set to minimum.
     } else {
 
         if (!boolLastValid) {
             oldValue = ret;
         }
 
         boolLastValid = true;
     }
 
     return ret;
 
 }
 QString KisDoubleParseSpinBox::textFromValue(double val) const
 {
 
     if (!boolLastValid) {
         emit errorWhileParsing(lastExprParsed);
         return lastExprParsed;
     }
     emit noMoreParsingError();
 
-    double v = KisNumericParser::parseSimpleMathExpr(cleanText());
+    double v = KisNumericParser::parseSimpleMathExpr(veryCleanText());
     v = QString("%1").arg(v, 0, 'f', decimals()).toDouble();
-    if (hasFocus() && (v == value() || (v >= maximum() && value() == maximum()) || (v <= minimum() && value() == minimum())) ) { //solve a very annoying bug where the formula can collapse while editing. With this trick the formula is not lost until focus is lost.
-        return cleanText();
+    if (hasFocus() && (v == value() || (v > maximum() && value() == maximum()) || (v < minimum() && value() == minimum())) ) { //solve a very annoying bug where the formula can collapse while editing. With this trick the formula is not lost until focus is lost.
+        return veryCleanText();
     }
 
     return QDoubleSpinBox::textFromValue(val);
 }
 
+QString KisDoubleParseSpinBox::veryCleanText() const
+{
+    return cleanText();
+}
+
 QValidator::State KisDoubleParseSpinBox::validate ( QString & input, int & pos ) const
 {
 
     Q_UNUSED(input);
     Q_UNUSED(pos);
 
     return QValidator::Acceptable;
 
 }
 
 void KisDoubleParseSpinBox::stepBy(int steps)
 {
 
     boolLastValid = true; //reset to valid state so we can use the up and down buttons.
     emit noMoreParsingError();
 
     QDoubleSpinBox::stepBy(steps);
 
 }
 
 void KisDoubleParseSpinBox::setValue(double value)
 {
     if(value == oldValue && hasFocus()){ //avoid to reset the button when it set the value of something that will recall this slot.
         return;
     }
 
     if (!hasFocus()) {
         clearError();
     }
 
     QDoubleSpinBox::setValue(value);
 }
 
 void KisDoubleParseSpinBox::setErrorStyle()
 {
 
     if (!boolLastValid) {
         //setStyleSheet(_oldStyleSheet + "Background: red; color: white; padding-left: 18px;");
 
         if (!isOldPaletteSaved) {
             oldPalette = palette();
         }
         isOldPaletteSaved = true;
 
         QPalette nP = oldPalette;
         nP.setColor(QPalette::Background, Qt::red);
         nP.setColor(QPalette::Base, Qt::red);
         nP.setColor(QPalette::Text, Qt::white);
         setPalette(nP);
 
         if (!areOldMarginsSaved) {
             oldMargins = lineEdit()->textMargins();
         }
         areOldMarginsSaved = true;
 
         if (width() - height() >= 3*height()) { //if we have twice as much place as needed by the warning icon then display it.
             QMargins newMargins = oldMargins;
             newMargins.setLeft( newMargins.left() + height() - 4 );
             lineEdit()->setTextMargins(newMargins);
 
             int h = warningIcon->height();
             int hp = height()-2;
 
             if (h != hp) {
                 warningIcon->resize(hp, hp);
 
                 if (QFile(":/./16_light_warning.svg").exists()) {
                     warningIcon->setPixmap(QIcon(":/./16_light_warning.svg").pixmap(hp-7, hp-7));
                 }
             }
 
             warningIcon->move(oldMargins.left()+4, 1);
             warningIcon->setVisible(true);
         }
     }
 }
 
 void KisDoubleParseSpinBox::clearErrorStyle()
 {
     if (boolLastValid) {
         warningIcon->setVisible(false);
 
         //setStyleSheet(QString());
 
         setPalette(oldPalette);
         isOldPaletteSaved = false;
 
         lineEdit()->setTextMargins(oldMargins);
         areOldMarginsSaved = false;
     }
 }
 void KisDoubleParseSpinBox::clearError()
 {
     boolLastValid = true;
     emit noMoreParsingError();
     oldValue = value();
     clearErrorStyle();
 }
diff --git a/libs/widgets/kis_double_parse_spin_box.h b/libs/widgets/kis_double_parse_spin_box.h
index 29085af972..bc3310f5e6 100644
--- a/libs/widgets/kis_double_parse_spin_box.h
+++ b/libs/widgets/kis_double_parse_spin_box.h
@@ -1,82 +1,85 @@
 /*
  *  Copyright (c) 2016 Laurent Valentin Jospin <laurent.valentin@famillejospin.ch>
  *
  *  This program is free software; you can redistribute it and/or modify
  *  it under the terms of the GNU General Public License as published by
  *  the Free Software Foundation; either version 2 of the License, or
  *  (at your option) any later version.
  *
  *  This program is distributed in the hope that it will be useful,
  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  *  GNU General Public License for more details.
  *
  *  You should have received a copy of the GNU General Public License
  *  along with this program; if not, write to the Free Software
  *  Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
  */
 
 #ifndef KISDOUBLEPARSESPINBOX_H
 #define KISDOUBLEPARSESPINBOX_H
 
 #include <QDoubleSpinBox>
 
 #include "kritawidgets_export.h"
 
 class QLabel;
 
 /*!
  * \brief The KisDoubleParseSpinBox class is a cleverer doubleSpinBox, able to parse arithmetic expressions.
  *
  * Use this spinbox instead of the basic one from Qt if you want it to be able to parse arithmetic expressions.
  */
 class KRITAWIDGETS_EXPORT KisDoubleParseSpinBox : public QDoubleSpinBox
 {
 
     Q_OBJECT
 public:
     KisDoubleParseSpinBox(QWidget* parent = 0);
-    ~KisDoubleParseSpinBox();
+    virtual ~KisDoubleParseSpinBox(); //KisDoubleParseSpinBox may be used polymorphycally as a QDoubleSpinBox.
 
     virtual double valueFromText(const QString & text) const;
     virtual QString textFromValue(double val) const;
     virtual QValidator::State validate ( QString & input, int & pos ) const;
 
     virtual void stepBy(int steps);
 
     void setValue(double value); //polymorphism won't work directly, we use a signal/slot hack to do so but if signals are disabled this function will still be useful.
 
     bool isLastValid() const{ return boolLastValid; }
 
+    //! \brief this virtual function is similar to cleanText(); for KisDoubleParseSpinBox. But child class may remove additional artifacts.
+    virtual QString veryCleanText() const;
+
 Q_SIGNALS:
 
     //! \brief signal emmitted when the last parsed expression create an error.
     void errorWhileParsing(QString expr) const;
     //! \brief signal emmitted when the last parsed expression is valid.
     void noMoreParsingError() const;
 
 public Q_SLOTS:
 
     //! \brief useful to let the widget change it's stylesheet when an error occured in the last expression.
     void setErrorStyle();
     //! \brief useful to let the widget reset it's stylesheet when there's no more error.
     void clearErrorStyle();
     //! \brief say the widget to return to an error free state.
     void clearError();
 
 protected:
 
     mutable bool boolLastValid;
     mutable double oldValue;
     mutable QString lastExprParsed;
 
     QLabel* warningIcon;
 
     QPalette oldPalette;
     bool isOldPaletteSaved;
 
     QMargins oldMargins;
     bool areOldMarginsSaved;
 };
 
 #endif // KISDOUBLEPARSESPINBOX_H
diff --git a/libs/widgets/kis_double_parse_unit_spin_box.cpp b/libs/widgets/kis_double_parse_unit_spin_box.cpp
index 47c10515dc..21d05ad526 100644
--- a/libs/widgets/kis_double_parse_unit_spin_box.cpp
+++ b/libs/widgets/kis_double_parse_unit_spin_box.cpp
@@ -1,172 +1,422 @@
 /*
  *  Copyright (c) 2016 Laurent Valentin Jospin <laurent.valentin@famillejospin.ch>
  *
  *  This program is free software; you can redistribute it and/or modify
  *  it under the terms of the GNU General Public License as published by
  *  the Free Software Foundation; either version 2 of the License, or
  *  (at your option) any later version.
  *
  *  This program is distributed in the hope that it will be useful,
  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  *  GNU General Public License for more details.
  *
  *  You should have received a copy of the GNU General Public License
  *  along with this program; if not, write to the Free Software
  *  Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
  */
 
 #include "kis_double_parse_unit_spin_box.h"
+#include "kis_spin_box_unit_manager.h"
 
+#include <QLineEdit>
 
 class Q_DECL_HIDDEN KisDoubleParseUnitSpinBox::Private
 {
 public:
-    Private(double low, double up, double step)
+    Private(double low, double up, double step, KisSpinBoxUnitManager* unitManager)
         : lowerInPoints(low),
-        upperInPoints(up),
-        stepInPoints(step),
-        unit(KoUnit(KoUnit::Point))
+          upperInPoints(up),
+          stepInPoints(step),
+          unit(KoUnit(KoUnit::Point)),
+          outPutSymbol(""),
+          unitManager(unitManager),
+          defaultUnitManager(unitManager),
+          isDeleting(false),
+          unitHasBeenChangedFromOutSideOnce(false),
+          letUnitBeChangedFromOutsideMoreThanOnce(true),
+          displayUnit(true)
     {
     }
 
     double lowerInPoints; ///< lowest value in points
     double upperInPoints; ///< highest value in points
     double stepInPoints;  ///< step in points
     KoUnit unit;
+
+    double previousValueInPoint; ///< allow to store the previous value in point, usefull in some cases, even if, usually, we prefere to refer to the actual value (in selected unit) and convert it, since this is not alway updated.
+    QString previousSymbol;
+    QString outPutSymbol;
+
+    KisSpinBoxUnitManager* unitManager; //manage more units than permitted by KoUnit.
+    KisSpinBoxUnitManager* defaultUnitManager; //the default unit manager is the one the spinbox rely on and go back to if a connected unit manager is destroyed before the spinbox.
+
+    bool isDeleting;
+
+    bool unitHasBeenChangedFromOutSideOnce; //in some part of the code the unit is reset. We want to prevent this overriding the unit defined by the user. We use this switch to do so.
+    bool letUnitBeChangedFromOutsideMoreThanOnce;
+
+    bool displayUnit;
+
 };
 
 KisDoubleParseUnitSpinBox::KisDoubleParseUnitSpinBox(QWidget *parent) :
     KisDoubleParseSpinBox(parent),
-    d(new Private(-9999, 9999, 1))
+    d(new Private(-9999, 9999, 1, KisSpinBoxUnitManagerFactory::buildDefaultUnitManager(this)))
 {
     setUnit( KoUnit(KoUnit::Point) );
     setAlignment( Qt::AlignRight );
 
-    connect(this, SIGNAL(valueChanged( double )), SLOT(privateValueChanged()));
+    connect(this, SIGNAL(valueChanged( double )), this, SLOT(privateValueChanged()));
+    connect(lineEdit(), SIGNAL(textChanged(QString)),
+            this, SLOT(detectUnitChanges()) );
+
+    connect(d->unitManager, (void (KisSpinBoxUnitManager::*)()) &KisSpinBoxUnitManager::unitAboutToChange, this, (void (KisDoubleParseUnitSpinBox::*)()) &KisDoubleParseUnitSpinBox::prepareUnitChange);
+    connect(d->unitManager, (void (KisSpinBoxUnitManager::*)( QString )) &KisSpinBoxUnitManager::unitChanged, this, (void (KisDoubleParseUnitSpinBox::*)( QString const& )) &KisDoubleParseUnitSpinBox::internalUnitChange);
+
 }
 
 KisDoubleParseUnitSpinBox::~KisDoubleParseUnitSpinBox()
 {
+    d->isDeleting = true;
+    delete d->defaultUnitManager;
     delete d;
 }
 
+void KisDoubleParseUnitSpinBox::setUnitManager(KisSpinBoxUnitManager* unitManager)
+{
+    qreal oldVal = d->unitManager->getReferenceValue(KisDoubleParseSpinBox::value());
+    QString oldSymbol = d->unitManager->getApparentUnitSymbol();
+
+    qreal newVal;
+
+    double newMin;
+    double newMax;
+    double newStep;
+
+    if (oldSymbol == unitManager->getApparentUnitSymbol() &&
+            d->unitManager->getUnitDimensionType() == unitManager->getUnitDimensionType())
+    {
+        d->unitManager = unitManager; //set the new unitmanager anyway, since it may be a subclass, so change the behavior anyway.
+        goto connect_signals;
+    }
+
+    if (d->unitManager->getUnitDimensionType() == unitManager->getUnitDimensionType()) {
+        //dimension is the same, calculate the new value
+        newVal = unitManager->getApparentValue(oldVal);
+    } else {
+        newVal = unitManager->getApparentValue(d->lowerInPoints);
+    }
+
+    newMin = unitManager->getApparentValue(d->lowerInPoints);
+    newMax = unitManager->getApparentValue(d->upperInPoints);
+    newStep = unitManager->getApparentValue(d->stepInPoints);
+
+    if (unitManager->getApparentUnitSymbol() == KoUnit(KoUnit::Pixel).symbol()) {
+        // limit the pixel step by 1.0
+        newStep = qMax(qreal(1.0), newStep);
+    }
+
+    KisDoubleParseSpinBox::setMinimum(newMin);
+    KisDoubleParseSpinBox::setMaximum(newMax);
+    KisDoubleParseSpinBox::setSingleStep(newStep);
+
+connect_signals:
+
+    if (d->unitManager != d->defaultUnitManager) {
+        disconnect(d->unitManager, &QObject::destroyed,
+                   this, &KisDoubleParseUnitSpinBox::disconnectExternalUnitManager); //there's no dependance anymore.
+    }
+    disconnect(d->unitManager, (void (KisSpinBoxUnitManager::*)()) &KisSpinBoxUnitManager::unitAboutToChange, this, (void (KisDoubleParseUnitSpinBox::*)()) &KisDoubleParseUnitSpinBox::prepareUnitChange);
+    disconnect(d->unitManager, (void (KisSpinBoxUnitManager::*)( QString )) &KisSpinBoxUnitManager::unitChanged, this, (void (KisDoubleParseUnitSpinBox::*)( QString const& )) &KisDoubleParseUnitSpinBox::internalUnitChange);
+
+    d->unitManager = unitManager;
+
+    connect(d->unitManager, &QObject::destroyed,
+            this, &KisDoubleParseUnitSpinBox::disconnectExternalUnitManager);
+
+
+    connect(d->unitManager, (void (KisSpinBoxUnitManager::*)()) &KisSpinBoxUnitManager::unitAboutToChange, this, (void (KisDoubleParseUnitSpinBox::*)()) &KisDoubleParseUnitSpinBox::prepareUnitChange);
+    connect(d->unitManager, (void (KisSpinBoxUnitManager::*)( QString )) &KisSpinBoxUnitManager::unitChanged, this, (void (KisDoubleParseUnitSpinBox::*)( QString const& )) &KisDoubleParseUnitSpinBox::internalUnitChange);
+
+    KisDoubleParseSpinBox::setValue(newVal);
+}
+
 void KisDoubleParseUnitSpinBox::changeValue( double newValue )
 {
-    if (d->unit.toUserValue(newValue) == oldValue) {
+    double apparentValue;
+    double fact;
+    double cons;
+
+    if (d->outPutSymbol.isEmpty()) {
+        apparentValue = d->unitManager->getApparentValue(newValue);
+    } else {
+
+        fact = d->unitManager->getConversionFactor(d->unitManager->getUnitDimensionType(), d->outPutSymbol);
+        cons = d->unitManager->getConversionConstant(d->unitManager->getUnitDimensionType(), d->outPutSymbol);
+
+        apparentValue = fact*newValue + cons;
+    }
+
+    if (apparentValue == KisDoubleParseSpinBox::value()) {
         return;
     }
 
-    KisDoubleParseSpinBox::setValue( d->unit.toUserValue(newValue) );
+    if (d->outPutSymbol.isEmpty()) {
+        KisDoubleParseSpinBox::setValue( d->unitManager->getApparentValue(newValue) );
+    } else {
+
+        KisDoubleParseSpinBox::setValue( d->unitManager->getApparentValue((newValue - cons)/fact) );
+    }
 }
 
 void KisDoubleParseUnitSpinBox::setUnit( const KoUnit & unit)
 {
-    if( unit == d->unit) return;
-    double oldValue = d->unit.fromUserValue( KisDoubleParseSpinBox::value() );
+    if (d->unitHasBeenChangedFromOutSideOnce && !d->letUnitBeChangedFromOutsideMoreThanOnce) {
+        return;
+    }
 
-    KisDoubleParseSpinBox::setMinimum( unit.toUserValue( d->lowerInPoints ) );
-    KisDoubleParseSpinBox::setMaximum( unit.toUserValue( d->upperInPoints ) );
+    if (d->unitManager->getUnitDimensionType() != KisSpinBoxUnitManager::LENGTH) {
+        d->unitManager->setUnitDimension(KisSpinBoxUnitManager::LENGTH); //setting the unit using a KoUnit mean you want to use a length.
+    }
 
-    qreal step = unit.toUserValue( d->stepInPoints );
+    setUnit(unit.symbol());
+    d->unit = unit;
+}
+void KisDoubleParseUnitSpinBox::setUnit(const QString &symbol)
+{
+    d->unitManager->setApparentUnitFromSymbol(symbol); //via signals and slots, the correct functions should be called.
+}
+void KisDoubleParseUnitSpinBox::setReturnUnit(const QString & symbol)
+{
+    d->outPutSymbol = symbol;
+}
+
+void KisDoubleParseUnitSpinBox::prepareUnitChange() {
+
+    d->previousValueInPoint = d->unitManager->getReferenceValue(KisDoubleParseSpinBox::value());
+    d->previousSymbol = d->unitManager->getApparentUnitSymbol();
+
+}
+
+void KisDoubleParseUnitSpinBox::internalUnitChange(const QString &symbol) {
 
-    if (unit.type() == KoUnit::Pixel) {
+    //d->unitManager->setApparentUnitFromSymbol(symbol);
+
+    if (d->unitManager->getApparentUnitSymbol() == d->previousSymbol) { //the setApparentUnitFromSymbol is a bit clever, for example in regard of Casesensitivity. So better check like this.
+        return;
+    }
+
+    KisDoubleParseSpinBox::setMinimum( d->unitManager->getApparentValue( d->lowerInPoints ) );
+    KisDoubleParseSpinBox::setMaximum( d->unitManager->getApparentValue( d->upperInPoints ) );
+
+    qreal step = d->unitManager->getApparentValue( d->stepInPoints );
+
+    if (symbol == KoUnit(KoUnit::Pixel).symbol()) {
         // limit the pixel step by 1.0
         step = qMax(qreal(1.0), step);
     }
 
     KisDoubleParseSpinBox::setSingleStep( step );
-    d->unit = unit;
-    KisDoubleParseSpinBox::setValue( KoUnit::ptToUnit( oldValue, unit ) );
-    setSuffix( unit.symbol().prepend(QLatin1Char(' ')) );
+    KisDoubleParseSpinBox::setValue( d->unitManager->getApparentValue( d->previousValueInPoint ) );
+
+    d->unitHasBeenChangedFromOutSideOnce = true;
+}
+
+void KisDoubleParseUnitSpinBox::setDimensionType(int dim)
+{
+    if (!KisSpinBoxUnitManager::isUnitId(dim)) {
+        return;
+    }
+
+    d->unitManager->setUnitDimension((KisSpinBoxUnitManager::UnitDimension) dim);
 }
 
 double KisDoubleParseUnitSpinBox::value( ) const
 {
-    return d->unit.fromUserValue( KisDoubleParseSpinBox::value() );
+    if (d->outPutSymbol.isEmpty()) {
+        return d->unitManager->getReferenceValue( KisDoubleParseSpinBox::value() );
+    }
+
+    double ref = d->unitManager->getReferenceValue( KisDoubleParseSpinBox::value() );
+    double fact = d->unitManager->getConversionFactor(d->unitManager->getUnitDimensionType(), d->outPutSymbol);
+    double cons = d->unitManager->getConversionConstant(d->unitManager->getUnitDimensionType(), d->outPutSymbol);
+
+    return fact*ref + cons;
 }
 
 void KisDoubleParseUnitSpinBox::setMinimum(double min)
 {
     d->lowerInPoints = min;
-    KisDoubleParseSpinBox::setMinimum( d->unit.toUserValue( min ) );
+    KisDoubleParseSpinBox::setMinimum( d->unitManager->getApparentValue( min ) );
 }
 
 void KisDoubleParseUnitSpinBox::setMaximum(double max)
 {
     d->upperInPoints = max;
-    KisDoubleParseSpinBox::setMaximum( d->unit.toUserValue( max ) );
+    KisDoubleParseSpinBox::setMaximum( d->unitManager->getApparentValue( max ) );
 }
 
 void KisDoubleParseUnitSpinBox::setLineStep(double step)
 {
-    d->stepInPoints = KoUnit(KoUnit::Point).toUserValue(step);
+    d->stepInPoints = d->unitManager->getReferenceValue(step);
     KisDoubleParseSpinBox::setSingleStep( step );
 }
 
 void KisDoubleParseUnitSpinBox::setLineStepPt(double step)
 {
     d->stepInPoints = step;
-    KisDoubleParseSpinBox::setSingleStep( d->unit.toUserValue( step ) );
+    KisDoubleParseSpinBox::setSingleStep( d->unitManager->getApparentValue( step ) );
 }
 
 
 void KisDoubleParseUnitSpinBox::setMinMaxStep( double min, double max, double step )
 {
     setMinimum( min );
     setMaximum( max );
     setLineStepPt( step );
 }
 
 
 QValidator::State KisDoubleParseUnitSpinBox::validate(QString &input, int &pos) const
 {
     Q_UNUSED(pos);
 
     QRegExp regexp ("([ a-zA-Z]+)$"); // Letters or spaces at end
     const int res = input.indexOf( regexp );
 
-    if ( res == -1 ) {
+    /*if ( res == -1 ) {
         // Nothing like an unit? The user is probably editing the unit
         return QValidator::Intermediate;
-    }
+    }*/
 
-    QString expr ( input.left( res ) );
-    const QString unitName ( regexp.cap( 1 ).trimmed().toLower() );
+    QString expr ( (res > 0) ? input.left( res ) : input );
+    const QString unitName ( (res > 0) ? regexp.cap( 1 ).trimmed().toLower() : "" );
 
     bool ok = true;
     bool interm = false;
 
     QValidator::State exprState = KisDoubleParseSpinBox::validate(expr, pos);
 
+    if (res < 0) {
+        return exprState;
+    }
+
     if (exprState == QValidator::Invalid) {
         return exprState;
     } else if (exprState == QValidator::Intermediate) {
         interm = true;
     }
 
     //check if we can parse the unit.
-    KoUnit::fromSymbol(unitName, &ok);
+    QStringList listOfSymbol = d->unitManager->getsUnitSymbolList();
+    ok = listOfSymbol.contains(unitName);
 
     if (!ok || interm) {
         return QValidator::Intermediate;
     }
 
     return QValidator::Acceptable;
 }
 
 QString KisDoubleParseUnitSpinBox::textFromValue( double value ) const
 {
-    return KisDoubleParseSpinBox::textFromValue(value);
+    QString txt = KisDoubleParseSpinBox::textFromValue(value);
+    if (d->displayUnit) {
+        if (!txt.endsWith(d->unitManager->getApparentUnitSymbol())) {
+            txt += " " + d->unitManager->getApparentUnitSymbol();
+        }
+    }
+    return txt;
+}
+
+QString KisDoubleParseUnitSpinBox::veryCleanText() const
+{
+
+    return makeTextClean(cleanText());
+
 }
 
 double KisDoubleParseUnitSpinBox::valueFromText( const QString& str ) const
 {
-    //KisDoubleParseSpinBox is supposed to remove the suffix and prefix by itself.
-    return KisDoubleParseSpinBox::valueFromText(str);
+
+    QString txt = makeTextClean(str);
+
+    return KisDoubleParseSpinBox::valueFromText(txt); //this function will take care of prefix (and don't mind if suffix has been removed.
+}
+
+void KisDoubleParseUnitSpinBox::setUnitChangeFromOutsideBehavior(bool toggle) {
+    d->letUnitBeChangedFromOutsideMoreThanOnce = toggle;
+}
+
+void KisDoubleParseUnitSpinBox::setDisplayUnit(bool toggle) {
+
+    d->displayUnit = toggle;
+
 }
 
 void KisDoubleParseUnitSpinBox::privateValueChanged()
 {
     emit valueChangedPt( value() );
 }
+
+QString KisDoubleParseUnitSpinBox::detectUnit()
+{
+    QString str = veryCleanText().trimmed(); //text with the new unit but not the old one.
+
+    QRegExp regexp ("([ ]*[a-zA-Z]+[ ]*)$"); // Letters or spaces at end
+    int res = str.indexOf( regexp );
+
+    if (res > -1) {
+        QString expr ( str.right( str.size() - res ) );
+        expr = expr.trimmed();
+        return expr;
+    }
+
+    return "";
+}
+
+void KisDoubleParseUnitSpinBox::detectUnitChanges()
+{
+    QString unitSymb = detectUnit();
+
+    if (unitSymb.isEmpty()) {
+        return;
+    }
+
+    QString oldUnitSymb = d->unitManager->getApparentUnitSymbol();
+
+    setUnit(unitSymb);
+    setValue(valueFromText(cleanText())); //change value keep the old value, but converted to new unit... which is different from the value the user entered in the new unit. So we need to set the new value.
+
+    if (oldUnitSymb != d->unitManager->getApparentUnitSymbol()) {
+        // the user has changed the unit, so we block changes from outside.
+        setUnitChangeFromOutsideBehavior(false);
+    }
+}
+
+QString KisDoubleParseUnitSpinBox::makeTextClean(QString const& txt) const
+{
+    QString expr = txt;
+    QString symbol = d->unitManager->getApparentUnitSymbol();
+
+    if ( expr.endsWith(suffix()) ) {
+        expr.remove(expr.size()-suffix().size(), suffix().size());
+    }
+
+    expr = expr.trimmed();
+
+    if ( expr.endsWith(symbol) ) {
+        expr.remove(expr.size()-symbol.size(), symbol.size());
+    }
+
+    return expr.trimmed();
+}
+
+void KisDoubleParseUnitSpinBox::disconnectExternalUnitManager()
+{
+    if (!d->isDeleting)
+    {
+        setUnitManager(d->defaultUnitManager); //go back to default unit manager.
+    }
+}
diff --git a/libs/widgets/kis_double_parse_unit_spin_box.h b/libs/widgets/kis_double_parse_unit_spin_box.h
index 83094f8e85..a8efac06df 100644
--- a/libs/widgets/kis_double_parse_unit_spin_box.h
+++ b/libs/widgets/kis_double_parse_unit_spin_box.h
@@ -1,100 +1,137 @@
 /*
  *  Copyright (c) 2016 Laurent Valentin Jospin <laurent.valentin@famillejospin.ch>
  *
  *  This program is free software; you can redistribute it and/or modify
  *  it under the terms of the GNU General Public License as published by
  *  the Free Software Foundation; either version 2 of the License, or
  *  (at your option) any later version.
  *
  *  This program is distributed in the hope that it will be useful,
  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  *  GNU General Public License for more details.
  *
  *  You should have received a copy of the GNU General Public License
  *  along with this program; if not, write to the Free Software
  *  Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
  */
 
 #ifndef KIS_DOUBLEPARSEUNITSPINBOX_H
 #define KIS_DOUBLEPARSEUNITSPINBOX_H
 
 #include <KoUnit.h>
 
 #include "kis_double_parse_spin_box.h"
 #include "kritawidgets_export.h"
 
+class KisSpinBoxUnitManager;
+
 /*!
  * \brief The KisDoubleParseUnitSpinBox class is an evolution of the \see KoUnitDoubleSpinBox, but inherit from \see KisDoubleParseSpinBox to be able to parse math expressions.
  *
  * This class store the
  */
 class KRITAWIDGETS_EXPORT  KisDoubleParseUnitSpinBox : public KisDoubleParseSpinBox
 {
 
     Q_OBJECT
 
 public:
     KisDoubleParseUnitSpinBox(QWidget* parent = 0);
-    ~KisDoubleParseUnitSpinBox();
+    virtual ~KisDoubleParseUnitSpinBox();
+
+    void setUnitManager(KisSpinBoxUnitManager* unitManager);
 
     /**
-     * Set the new value in points which will then be converted to the current unit for display
+     * Set the new value in points (or other reference unit) which will then be converted to the current unit for display
      * @param newValue the new value
      * @see value()
      */
     virtual void changeValue( double newValue );
+
     /**
      * This spinbox shows the internal value after a conversion to the unit set here.
      */
     virtual void setUnit(const KoUnit &unit);
+    virtual void setUnit(const QString & symbol);
+    /*!
+     * \brief setReturnUnit set a unit, such that the spinbox now return values in this unit instead of the reference unit for the current dimension.
+     * \param symbol the symbol of the new unit.
+     */
+    void setReturnUnit(const QString & symbol);
+
+    /**
+     * @brief setDimensionType set the dimension (for example length or angle) of the units the spinbox manage
+     * @param dim the dimension id. (if not an id in KisSpinBoxUnitManager::UnitDimension, then the function does nothing).
+     */
+    virtual void setDimensionType(int dim);
 
     /// @return the current value, converted in points
     double value( ) const;
 
     /// Set minimum value in points.
     void setMinimum(double min);
 
     /// Set maximum value in points.
     void setMaximum(double max);
 
     /// Set step size in the current unit.
     void setLineStep(double step);
 
     /// Set step size in points.
     void setLineStepPt(double step);
 
     /// Set minimum, maximum value and the step size (all in points)
     void setMinMaxStep( double min, double max, double step );
 
     /// reimplemented from superclass, will forward to KoUnitDoubleValidator
     virtual QValidator::State validate(QString &input, int &pos) const;
 
     /**
      * Transform the double in a nice text, using locale symbols
      * @param value the number as double
      * @return the resulting string
      */
     virtual QString textFromValue( double value ) const;
+
+    //! \brief get the text in the spinbox without prefix or suffix, and remove unit symbol if present.
+    virtual QString veryCleanText() const;
+
     /**
      * Transfrom a string into a double, while taking care of locale specific symbols.
      * @param str the string to transform into a number
      * @return the value as double
      */
     virtual double valueFromText( const QString& str ) const;
 
+    void setUnitChangeFromOutsideBehavior(bool toggle); //if set to false, setting the unit using KoUnit won't have any effect.
+
+    //! \brief display the unit symbol in the spinbox or not. For example if the unit is displayed in a combobox connected to the unit manager.
+    void setDisplayUnit(bool toggle);
+
 Q_SIGNALS:
-    /// emitted like valueChanged in the parent, but this one emits the point value
+    /// emitted like valueChanged in the parent, but this one emits the point value, or converted to another reference unit.
     void valueChangedPt( qreal );
 
 
 private:
     class Private;
     Private * const d;
 
+    QString detectUnit();
+    QString makeTextClean(QString const& txt) const;
+
+    //thoses functions are usefull to sync the spinbox with it's unitmanager.
+    //! \brief change the unit, reset the spin box everytime. From the outside it's alway set unit that should be called.
+    void internalUnitChange(QString const& symbol);
+    void prepareUnitChange();
+
 private Q_SLOTS:
     // exists to do emits for valueChangedPt
     void privateValueChanged();
+    void detectUnitChanges();
+    void disconnectExternalUnitManager();
+
 };
 
 #endif // KIS_DOUBLEPARSEUNITSPINBOX_H
diff --git a/libs/widgetutils/CMakeLists.txt b/libs/widgetutils/CMakeLists.txt
index ede32a1558..a8577f39f3 100644
--- a/libs/widgetutils/CMakeLists.txt
+++ b/libs/widgetutils/CMakeLists.txt
@@ -1,128 +1,130 @@
 add_subdirectory(tests)
 
 configure_file(xmlgui/config-xmlgui.h.cmake ${CMAKE_CURRENT_BINARY_DIR}/config-xmlgui.h )
 
 include_directories(${CMAKE_CURRENT_SOURCE_DIR}/config)
 include_directories(${CMAKE_CURRENT_SOURCE_DIR}/xmlgui)
 
 set(kritawidgetutils_LIB_SRCS
 
     WidgetUtilsDebug.cpp
 
     kis_icon_utils.cpp
     kis_action_registry.cpp
     KisActionsSnapshot.cpp
     KoGroupButton.cpp
     KoProgressBar.cpp
     KoProgressUpdater.cpp
     KoUpdater.cpp
     KoUpdaterPrivate_p.cpp
     KoProperties.cpp
     KoFileDialog.cpp
     KoResourcePaths.cpp
 
     kis_num_parser.cpp
+    kis_spin_box_unit_manager.cpp
 
     config/kcolorscheme.cpp
     config/kcolorschememanager.cpp
     config/khelpclient.cpp
     config/klanguagebutton.cpp
     config/krecentfilesaction.cpp
     config/kstandardaction.cpp
 
     xmlgui/KisShortcutsEditorItem.cpp
     xmlgui/KisShortcutEditWidget.cpp
     xmlgui/KisShortcutsEditorDelegate.cpp
     xmlgui/KisShortcutsDialog.cpp
     xmlgui/KisShortcutsDialog_p.cpp
     xmlgui/KisShortcutsEditor.cpp
     xmlgui/KisShortcutsEditor_p.cpp
 
     xmlgui/kshortcutschemeseditor.cpp
     xmlgui/kshortcutschemeshelper.cpp
 
     xmlgui/kaboutkdedialog_p.cpp
     xmlgui/kactioncategory.cpp
     xmlgui/kactioncollection.cpp
     xmlgui/kactionconflictdetector.cpp
     xmlgui/kbugreport.cpp
     xmlgui/kcheckaccelerators.cpp
     xmlgui/kedittoolbar.cpp
     xmlgui/kgesture.cpp
     xmlgui/kgesturemap.cpp
     xmlgui/khelpmenu.cpp
     xmlgui/kkeysequencewidget.cpp
     xmlgui/kmainwindow.cpp
     xmlgui/kmenumenuhandler_p.cpp
     xmlgui/kshortcutwidget.cpp
     xmlgui/kswitchlanguagedialog_p.cpp
     xmlgui/ktoggletoolbaraction.cpp
     xmlgui/ktoolbar.cpp
     xmlgui/ktoolbarhandler.cpp
     xmlgui/kundoactions.cpp
     xmlgui/kxmlguibuilder.cpp
     xmlgui/kxmlguiclient.cpp
     xmlgui/kxmlguifactory.cpp
     xmlgui/kxmlguifactory_p.cpp
     xmlgui/kxmlguiversionhandler.cpp
     xmlgui/kxmlguiwindow.cpp
 )
 
 if (HAVE_DBUS)
     set(kritawidgetutils_LIB_SRCS ${kritawidgetutils_LIB_SRCS}
         xmlgui/kmainwindowiface.cpp
     )
 endif()
 
 ki18n_wrap_ui(kritawidgetutils_LIB_SRCS
     xmlgui/KisShortcutsDialog.ui
     xmlgui/kshortcutwidget.ui
 )
 
 qt5_add_resources(kritawidgetutils_LIB_SRCS xmlgui/kxmlgui.qrc)
 
 add_library(kritawidgetutils SHARED ${kritawidgetutils_LIB_SRCS})
 
 target_include_directories(kritawidgetutils
     PUBLIC
     $<BUILD_INTERFACE:${CMAKE_CURRENT_SOURCE_DIR}/config>
     $<BUILD_INTERFACE:${CMAKE_CURRENT_SOURCE_DIR}/xmlgui>
 )
 
 generate_export_header(kritawidgetutils BASE_NAME kritawidgetutils)
 
 if (HAVE_DBUS)
    set (KRITA_WIDGET_UTILS_EXTRA_LIBS ${KRITA_WIDGET_UTILS_EXTRA_LIBS} Qt5::DBus)
 endif ()
 
 if (APPLE)
     find_library(FOUNDATION_LIBRARY Foundation)
     set(KRITA_WIDGET_UTILS_EXTRA_LIBS ${KRITA_WIDGET_UTILS_EXTRA_LIBS} ${FOUNDATION_LIBRARY})
 endif ()
 
 target_link_libraries(kritawidgetutils
     PUBLIC
         Qt5::Widgets
         Qt5::Gui
         Qt5::Xml
         Qt5::Core
         KF5::ItemViews
         kritaglobal
     PRIVATE
         Qt5::PrintSupport
         KF5::I18n
         KF5::ConfigCore
         KF5::CoreAddons
         KF5::ConfigGui
         KF5::GuiAddons
         KF5::WidgetsAddons
         KF5::WindowSystem
         kritaplugin
+        kritaodf
         ${KRITA_WIDGET_UTILS_EXTRA_LIBS}
 )
 
 set_target_properties(kritawidgetutils
     PROPERTIES VERSION ${GENERIC_KRITA_LIB_VERSION} SOVERSION ${GENERIC_KRITA_LIB_SOVERSION}
 )
 
 install(TARGETS kritawidgetutils ${INSTALL_TARGETS_DEFAULT_ARGS})
diff --git a/libs/widgetutils/kis_num_parser.cpp b/libs/widgetutils/kis_num_parser.cpp
index 262c4cf404..99576c9c4c 100644
--- a/libs/widgetutils/kis_num_parser.cpp
+++ b/libs/widgetutils/kis_num_parser.cpp
@@ -1,567 +1,574 @@
 /*
  *  Copyright (c) 2016 Laurent Valentin Jospin <laurent.valentin@famillejospin.ch>
  *
  *  This program is free software; you can redistribute it and/or modify
  *  it under the terms of the GNU General Public License as published by
  *  the Free Software Foundation; either version 2 of the License, or
  *  (at your option) any later version.
  *
  *  This program is distributed in the hope that it will be useful,
  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  *  GNU General Public License for more details.
  *
  *  You should have received a copy of the GNU General Public License
  *  along with this program; if not, write to the Free Software
  *  Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
  */
 
 #include "kis_num_parser.h"
 
 #include <qnumeric.h> // for qIsNaN
 #include <qmath.h>
 #include <QVector>
 #include <QRegExp>
 #include <QStringList>
 #include <QVariant>
+#include <QLocale>
 
 #include <iostream>
 
 using namespace std;
 
 const QVector<char> opLevel1 = {'+', '-'};
 const QVector<char> opLevel2 = {'*', '/'};
 
 const QStringList supportedFuncs = {"", "cos", "sin", "tan", "acos", "asin", "atan", "exp", "ln", "log10", "abs"};
 
 const QRegExp funcExpr("(-)?([a-zA-Z]*[0-9]*)?\\((.+)\\)");
 const QRegExp numberExpr("(-)?([0-9]+\\.?[0-9]*(e[0-9]*)?)");
 
 const QRegExp funcExprInteger("(-)?\\((.+)\\)");
 const QRegExp integerExpr("(-)?([0-9]+)");
 
 //double functions
 double treatFuncs(QString const& expr, bool & noProblem);
 double treatLevel1(QString const& expr, bool & noProblem);
 double treatLevel2(QString const& expr, bool & noProblem);
 double treatLevel3(QString const& expr, bool & noProblem);
 
 //int functions
 double treatLevel1Int(QString const& expr, bool & noProblem);
 double treatLevel2Int(QString const& expr, bool & noProblem);
 double treatFuncsInt(QString const& expr, bool & noProblem);
 
 namespace KisNumericParser {
 
 /*!
  * \param expr the expression to parse
  * \param noProblem if provided, the value pointed to will be se to true is no problem appeared, false otherwise.
  * \return the numerical value the expression eval to (or 0 in case of error).
  */
 double parseSimpleMathExpr(const QString &expr, bool *noProblem)
 {
 
     bool ok = true; //intermediate variable to pass by reference to the sublevel parser (if no pointer is provided).
 
     //then go down each 3 levels of operation priority.
     if (noProblem != nullptr) {
         return treatLevel1(expr, *noProblem);
     }
 
     return treatLevel1(expr, ok);
 
 }
 
 /*!
  * \param expr the expression to parse
  * \param noProblem if provided, the value pointed to will be se to true is no problem appeared, false otherwise.
  * \return the numerical value the expression eval to (or 0 in case of error).
  */
 int parseIntegerMathExpr(QString const& expr, bool* noProblem)
 {
 
     bool ok = true; //intermediate variable to pass by reference to the sublevel parser (if no pointer is provided).
 
     if (noProblem != nullptr) {
         return qRound(treatLevel1Int(expr, *noProblem));
     }
 
     return qRound(treatLevel1Int(expr, ok));
 
 }
 
 } //namespace KisNumericParser.
 
 
 //intermediate functions
 
 /*!
  * \brief extractSubExprLevel1 extract from an expression the part of an expression that need to be treated recursivly before computing level 1 operations (+, -).
  * \param expr The expression to treat, the part returned will be removed.
  * \param nextOp This reference, in case of sucess, will hold the first level operation identified as separator ('+' or '-')
  * \param noProblem A reference to a bool, set to true if there was no problem, false otherwise.
  * \return The first part of the expression that doesn't contain first level operations not nested within parenthesis.
  */
 inline QString extractSubExprLevel1(QString & expr, char & nextOp, bool & noProblem){
 
     QString ret;
 
     int subCount = 0;
 
     bool lastMetIsNumber = false;
 
     for(int i = 0; i < expr.size(); i++){
 
     if (expr.at(i) == '(') {
         subCount++;
     }
 
     if (expr.at(i) == ')') {
         subCount--;
     }
 
     if (subCount < 0) {
         noProblem = false;
         return ret;
     }
 
     if(i == expr.size()-1 && subCount == 0){
         ret = expr;
         expr.clear();
         break;
     }
 
     if( (expr.at(i) == '+' || expr.at(i) == '-') &&
             subCount == 0) {
 
         if (expr.at(i) == '-' &&
                 i < expr.size()-1) {
 
             bool cond = !expr.at(i+1).isSpace();
 
             if (cond && !lastMetIsNumber) {
                 continue;
             }
 
         }
 
         ret = expr.mid(0, i).trimmed();
         nextOp = expr.at(i).toLatin1();
         expr = expr.mid(i+1);
         break;
 
     }
 
     if (expr.at(i).isDigit()) {
         lastMetIsNumber = true;
     } else if (expr.at(i) != '.' &&
               !expr.at(i).isSpace()) {
         lastMetIsNumber = false;
     }
 
     }
 
     noProblem = true;
     return ret;
 }
 
 
 /*!
  * \brief extractSubExprLevel2 extract from an expression the part of an expression that need to be treated recursivly before computing level 2 operations (*, /).
  * \param expr The expression to treat, the part returned will be removed.
  * \param nextOp This reference, in case of sucess, will hold the first level operation identified as separator ('*' or '/')
  * \param noProblem A reference to a bool, set to true if there was no problem, false otherwise.
  * \return The first part of the expression that doesn't contain second level operations not nested within parenthesis.
  */
 inline QString extractSubExprLevel2(QString & expr, char & nextOp, bool & noProblem){
 
     QString ret;
 
     int subCount = 0;
 
     for(int i = 0; i < expr.size(); i++){
 
     if (expr.at(i) == '(') {
         subCount++;
     }
 
     if (expr.at(i) == ')') {
         subCount--;
     }
 
     if (subCount < 0) {
         noProblem = false;
         return ret;
     }
 
     if(i == expr.size()-1 && subCount == 0){
         ret = expr;
         expr.clear();
         break;
     }
 
     if( (expr.at(i) == '*' || expr.at(i) == '/') &&
             subCount == 0) {
 
         ret = expr.mid(0, i).trimmed();
         nextOp = expr.at(i).toLatin1();
         expr = expr.mid(i+1);
         break;
 
     }
 
     }
 
     noProblem = true;
     return ret;
 }
 
 /*!
  * \brief treatLevel1 treat an expression at the first level of recursion.
  * \param expr The expression to treat.
  * \param noProblem A reference to a bool set to true if no problem happened, false otherwise.
  * \return The value of the parsed expression or subexpression or 0 in case of error.
  */
 double treatLevel1(const QString &expr, bool & noProblem)
 {
 
     noProblem = true;
 
     QString exprDestructable = expr;
 
     char nextOp = '+';
     double result = 0.0;
 
     while (!exprDestructable.isEmpty()) {
 
         double sign = (nextOp == '-') ? -1 : 1;
         QString part = extractSubExprLevel1(exprDestructable, nextOp, noProblem);
 
         if (!noProblem) {
         return 0.0;
         }
 
         if (sign > 0) {
         result += treatLevel2(part, noProblem);
         } else {
         result -= treatLevel2(part, noProblem);
         }
 
         if(!noProblem){
         return 0.0;
         }
     }
 
     return result;
 
 }
 
 /*!
  * \brief treatLevel2 treat a subexpression at the second level of recursion.
  * \param expr The subexpression to treat.
  * \param noProblem A reference to a bool set to true if no problem happened, false otherwise.
  * \return The value of the parsed subexpression or 0 in case of error.
  *
  * The expression should not contain first level operations not nested in parenthesis.
  */
 double treatLevel2(QString const& expr, bool & noProblem)
 {
 
     noProblem = true;
 
     QString exprDestructable = expr;
 
     char nextOp = '*';
 
     QString part = extractSubExprLevel2(exprDestructable, nextOp, noProblem);
 
     double result = treatLevel3(part, noProblem);
 
     while (!exprDestructable.isEmpty()) {
 
         if (!noProblem) {
         return 0.0;
         }
 
         bool needToMultiply = (nextOp == '*');
         part = extractSubExprLevel2(exprDestructable, nextOp, noProblem);
 
         if (!noProblem) {
         return 0.0;
         }
 
         if (needToMultiply) {
         result *= treatLevel3(part, noProblem);
         } else {
         result /= treatLevel3(part, noProblem);
         }
     }
 
     return result;
 }
 
 /*!
  * \brief treatLevel3 treat a subexpression at the third level of recursion.
  * \param expr The subexpression to treat.
  * \param noProblem A reference to a bool set to true if no problem happened, false otherwise.
  * \return The value of the parsed subexpression or 0 in case of error.
  *
  * The expression should not contain first or second level operations not nested in parenthesis.
  */
 double treatLevel3(const QString &expr, bool & noProblem)
 {
 
     noProblem = true;
 
     int indexPower = -1;
     int indexCount = 0;
     int subLevels = 0;
 
     for (int i = 0; i < expr.size(); i++) {
         if (expr.at(i) == '(') {
             subLevels++;
         } else if(expr.at(i) == ')') {
             subLevels--;
             if (subLevels < 0) {
                 noProblem = false;
                 return 0.0;
             }
         } else if (expr.at(i) == '^') {
             if (subLevels == 0) {
                 indexPower = i;
                 indexCount++;
             }
         }
     }
 
     if (indexCount > 1 || indexPower + 1 >= expr.size()) {
         noProblem = false;
         return 0.0;
     }
 
     if (indexPower > -1) {
 
         QStringList subExprs;
         subExprs << expr.mid(0,indexPower);
         subExprs << expr.mid(indexPower+1);
 
         bool noProb1 = true;
         bool noProb2 = true;
 
         double base = treatFuncs(subExprs[0], noProb1);
         double power = treatFuncs(subExprs[1], noProb2);
 
         return qPow(base, power);
 
     } else {
         return treatFuncs(expr, noProblem);
     }
 
     noProblem = false;
     return 0.0;
 
 }
 
 /*!
  * \brief treatFuncs treat the last level of recursion: parenthesis and functions.
  * \param expr The expression to parse.
  * \param noProblem A reference to a bool set to true if no problem happened, false otherwise.
  * \return The value of the parsed subexpression or 0 in case of error.
  *
  * The expression should not contain operators not nested anymore. The subexpressions within parenthesis will be treated by recalling the level 1 function.
  */
 double treatFuncs(QString const& expr, bool & noProblem)
 {
 
     noProblem = true;
 
     QRegExp funcExp = funcExpr; //copy the expression in the current execution stack, to avoid errors for example when multiple thread call this function.
     QRegExp numExp = numberExpr;
 
     if (funcExp.exactMatch(expr.trimmed())) {
 
         int sign = funcExp.capturedTexts()[1].isEmpty() ? 1 : -1;
         QString func = funcExp.capturedTexts()[2].toLower();
         QString subExpr = funcExp.capturedTexts()[3];
 
         double val = treatLevel1(subExpr, noProblem);
 
         if (!noProblem) {
             return 0.0;
         }
 
         if (func.isEmpty()) {
             return sign*val;
         }
 
         if (!supportedFuncs.contains(func)) {
             noProblem = false;
             return 0.0;
         }
 
         //trigonometry is done in degree
         if (func == "cos") {
             val = qCos(val/180*qAcos(-1));
         } else if (func == "sin") {
             val = qSin(val/180*qAcos(-1));
         } else if (func == "tan") {
             val = qTan(val/180*qAcos(-1));
         } else if(func == "acos") {
             val = qAcos(val)*180/qAcos(-1);
         } else if (func == "asin") {
             val = qAsin(val)*180/qAcos(-1);
         } else if (func == "atan") {
             val = qAtan(val)*180/qAcos(-1);
         } else if (func == "exp") {
             val = qExp(val);
         } else if (func == "ln") {
             val = qLn(val);
         } else if (func == "log10") {
             val = qLn(val)/qLn(10.0);
         } else if (func == "abs") {
             val = qAbs(val);
         }
 
         return sign*val;
     } else if(numExp.exactMatch(expr.trimmed())) {
         return expr.toDouble(&noProblem);
     }
 
+    double val = QLocale().toDouble(expr, &noProblem);
+
+    if(noProblem) {
+        return val;
+    }
+
     noProblem = false;
     return 0.0;
 
 }
 
 //int functions
 /*!
  * \brief treatLevel1 treat an expression at the first level of recursion.
  * \param expr The expression to treat.
  * \param noProblem A reference to a bool set to true if no problem happened, false otherwise.
  * \return The value of the parsed expression or subexpression or 0 in case of error.
  */
 double treatLevel1Int(QString const& expr, bool & noProblem)
 {
 
     noProblem = true;
 
     QString exprDestructable = expr;
 
     char nextOp = '+';
     double result = 0.0;
 
     while (!exprDestructable.isEmpty()) {
 
     double sign = (nextOp == '-') ? -1 : 1;
     QString part = extractSubExprLevel1(exprDestructable, nextOp, noProblem);
 
     if( !noProblem) {
         return 0.0;
     }
 
     if (sign > 0) {
         result += treatLevel2Int(part, noProblem);
     } else {
         result -= treatLevel2Int(part, noProblem);
     }
 
     if(!noProblem){
         return 0.0;
     }
     }
 
     return result;
 
 }
 
 /*!
  * \brief treatLevel2 treat a subexpression at the second level of recursion.
  * \param expr The subexpression to treat.
  * \param noProblem A reference to a bool set to true if no problem happened, false otherwise.
  * \return The value of the parsed subexpression or 0 in case of error.
  *
  * The expression should not contain first level operations not nested in parenthesis.
  */
 double treatLevel2Int(const QString &expr, bool &noProblem)
 {
 
     noProblem = true;
 
     QString exprDestructable = expr;
 
     char nextOp = '*';
 
     QString part = extractSubExprLevel2(exprDestructable, nextOp, noProblem);
 
     double result = treatFuncsInt(part, noProblem);
 
     while (!exprDestructable.isEmpty()) {
 
     if (!noProblem) {
         return 0.0;
     }
 
     bool needToMultiply = (nextOp == '*');
     part = extractSubExprLevel2(exprDestructable, nextOp, noProblem);
 
     if (!noProblem) {
         return 0.0;
     }
 
     if (needToMultiply) {
         result *= treatFuncsInt(part, noProblem);
     } else {
 
         double val = treatFuncsInt(part, noProblem);
 
         if(std::isinf(result/val) || qIsNaN(result/val)){
         noProblem = false;
         return 0.0;
         }
 
         result /= val;
     }
     }
 
     return result;
 
 }
 
 /*!
  * \brief treatFuncs treat the last level of recursion: parenthesis
  * \param expr The expression to parse.
  * \param noProblem A reference to a bool set to true if no problem happened, false otherwise.
  * \return The value of the parsed subexpression or 0 in case of error.
  *
  * The expression should not contain operators not nested anymore. The subexpressions within parenthesis will be treated by recalling the level 1 function.
  */
 double treatFuncsInt(QString const& expr, bool & noProblem)
 {
 
     noProblem = true;
 
     QRegExp funcExpInteger = funcExprInteger;
     QRegExp integerExp = integerExpr;
     QRegExp numberExp = numberExpr;
 
     if (funcExpInteger.exactMatch(expr.trimmed())) {
 
         int sign = funcExpInteger.capturedTexts()[1].isEmpty() ? 1 : -1;
         QString subExpr = funcExpInteger.capturedTexts()[2];
 
         double val = treatLevel1Int(subExpr, noProblem);
 
         if (!noProblem) {
             return 0;
         }
 
         return sign*val;
 
     } else if(numberExp.exactMatch(expr.trimmed())) {
         double value = QVariant(expr).toDouble(&noProblem);
         return value;
     }
 
     noProblem = false;
     return 0;
 
 }
diff --git a/libs/widgetutils/kis_spin_box_unit_manager.cpp b/libs/widgetutils/kis_spin_box_unit_manager.cpp
new file mode 100644
index 0000000000..acae8ac490
--- /dev/null
+++ b/libs/widgetutils/kis_spin_box_unit_manager.cpp
@@ -0,0 +1,524 @@
+/*
+ *  Copyright (c) 2017 Laurent Valentin Jospin <laurent.valentin@famillejospin.ch>
+ *
+ *  This program is free software; you can redistribute it and/or modify
+ *  it under the terms of the GNU General Public License as published by
+ *  the Free Software Foundation; either version 2 of the License, or
+ *  (at your option) any later version.
+ *
+ *  This program is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *  GNU General Public License for more details.
+ *
+ *  You should have received a copy of the GNU General Public License
+ *  along with this program; if not, write to the Free Software
+ *  Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
+ */
+
+#include "kis_spin_box_unit_manager.h"
+
+#include "KoUnit.h"
+#include <klocalizedstring.h>
+
+#include <QtMath>
+
+
+KisSpinBoxUnitManagerBuilder* KisSpinBoxUnitManagerFactory::builder = nullptr;
+
+KisSpinBoxUnitManager* KisSpinBoxUnitManagerFactory::buildDefaultUnitManager(QObject* parent)
+{
+    if (builder == nullptr) {
+        return new KisSpinBoxUnitManager(parent);
+    }
+
+    return builder->buildUnitManager(parent);
+}
+
+void KisSpinBoxUnitManagerFactory::setDefaultUnitManagerBuilder(KisSpinBoxUnitManagerBuilder* pBuilder)
+{
+    if (builder != nullptr) {
+        delete builder; //The factory took over the lifecycle of the builder, so it delete it when replaced.
+    }
+
+    builder = pBuilder;
+}
+
+void KisSpinBoxUnitManagerFactory::clearUnitManagerBuilder()
+{
+    if (builder != nullptr) {
+        delete builder; //The factory took over the lifecycle of the builder, so it delete it when replaced.
+    }
+
+    builder = nullptr;
+}
+
+const QStringList KisSpinBoxUnitManager::referenceUnitSymbols = {"pt", "px", "°", "frame"};
+
+const QStringList KisSpinBoxUnitManager::documentRelativeLengthUnitSymbols = {"px", "vw", "vh"}; //px are relative to the resolution, vw and vh to the width and height.
+const QStringList KisSpinBoxUnitManager::documentRelativeTimeUnitSymbols = {"s", "%"}; //secondes are relative to the framerate, % to the sequence length.
+
+class Q_DECL_HIDDEN KisSpinBoxUnitManager::Private
+{
+public:
+    Private(KisSpinBoxUnitManager::UnitDimension pDim = KisSpinBoxUnitManager::LENGTH,
+            QString pUnitSymbol = "pt",
+            double pConv = 1.0):
+        dim(pDim),
+        unitSymbol(pUnitSymbol),
+        conversionFactor(pConv),
+        conversionFactorIsFixed(true),
+        conversionConstant(0),
+        conversionConstantIsFixed(true),
+        constrains(0),
+        unitListCached(false),
+        hasHundredPercent(false),
+        canAccessDocument(false)
+    {
+
+    }
+
+    KisSpinBoxUnitManager::UnitDimension dim;
+
+    QString unitSymbol;
+    mutable double conversionFactor;
+    bool conversionFactorIsFixed; //tell if it's possible to trust the conversion factor stored or if it's needed to recompute it.
+    mutable double conversionConstant;
+    bool conversionConstantIsFixed; //tell if it's possible to trust the conversion constant stored or if it's needed to recompute it.
+
+    KisSpinBoxUnitManager::Constrains constrains;
+
+    mutable QStringList unitList;
+    mutable bool unitListCached;
+
+    mutable QStringList unitListWithName;
+    mutable bool unitListWithNameCached;
+
+    //it's possible to store a reference for the % unit, for lenght.
+    bool hasHundredPercent;
+    qreal hundredPercent;
+
+    bool canAccessDocument;
+};
+
+KisSpinBoxUnitManager::KisSpinBoxUnitManager(QObject *parent) : QAbstractListModel(parent)
+{
+    d = new Private();
+
+    connect(this, (void (KisSpinBoxUnitManager::*)( QString )) &KisSpinBoxUnitManager::unitChanged, this, &KisSpinBoxUnitManager::newUnitSymbolToUnitIndex);
+}
+KisSpinBoxUnitManager::~KisSpinBoxUnitManager()
+{
+    delete d;
+}
+
+int KisSpinBoxUnitManager::getUnitDimensionType() const
+{
+    return d->dim;
+}
+
+QString KisSpinBoxUnitManager::getReferenceUnitSymbol() const
+{
+    return referenceUnitSymbols[d->dim];
+}
+
+QString KisSpinBoxUnitManager::getApparentUnitSymbol() const
+{
+    return d->unitSymbol;
+}
+
+int KisSpinBoxUnitManager::getApparentUnitId() const
+{
+    QStringList list = getsUnitSymbolList();
+    return list.indexOf(d->unitSymbol);
+}
+
+QStringList KisSpinBoxUnitManager::getsUnitSymbolList(bool withName) const{
+
+    QStringList list;
+
+    if (withName) {
+        if (d->unitListWithNameCached) {
+            return d->unitListWithName;
+        }
+    } else {
+        if (d->unitListCached) {
+            return d->unitList;
+        }
+    }
+
+    switch (d->dim) {
+
+    case LENGTH:
+
+        for (int i = 0; i < KoUnit::TypeCount; i++) {
+
+            if (KoUnit::Type(i) == KoUnit::Pixel) {
+                continue; //skip pixel, which is a document relative unit, in the base classe.
+            }
+
+            if (withName) {
+                list << KoUnit::unitDescription(KoUnit::Type(i));
+            } else {
+                list << KoUnit(KoUnit::Type(i)).symbol();
+            }
+        }
+
+        if (d->canAccessDocument) {
+            // ad document relative units
+            if (withName) {
+                list << KoUnit::unitDescription(KoUnit::Pixel) << i18n("view width (vw)") << i18n("view height (vh)");
+            } else {
+                list << documentRelativeLengthUnitSymbols;
+            }
+        }
+
+        break;
+
+    case IMLENGTH:
+
+        if (withName) {
+            list << KoUnit::unitDescription(KoUnit::Pixel);
+        } else {
+            list << "px";
+        }
+
+        if (d->canAccessDocument) {
+            // ad document relative units
+            if (withName) {
+                list << i18n("view width (vw)") << i18n("view height (vh)");
+            } else {
+                list << "vw" << "vh";
+            }
+        }
+        break;
+
+    case ANGLE:
+
+        if (withName) {
+            list << i18n("degrees (°)") << i18n("radians (rad)") << i18n("gons (gon)") << i18n("percent of circle (%)");
+        } else {
+            list << "°" << "rad" << "gon" << "%";
+        }
+        break;
+
+    case TIME:
+
+        if (withName) {
+            list << i18n("frames (f)");
+        } else {
+            list << "f";
+        }
+
+        if (d->canAccessDocument) {
+            if (withName) {
+                list << i18n("seconds (s)") << i18n("percent of animation (%)");
+            } else {
+                list << documentRelativeTimeUnitSymbols;
+            }
+        }
+
+        break;
+
+    }
+
+    if (withName) {
+        d->unitListWithName = list;
+        d->unitListWithNameCached = true;
+    } else {
+        d->unitList = list;
+        d->unitListCached = true;
+    }
+
+    return list;
+
+}
+
+qreal KisSpinBoxUnitManager::getConversionConstant(int dim, QString symbol) const
+{
+    Q_UNUSED(dim);
+    Q_UNUSED(symbol);
+
+    return 0; // all units managed here are transform via a linear function, so this wll alway be 0 in this class.
+}
+
+qreal KisSpinBoxUnitManager::getReferenceValue(double apparentValue) const
+{
+    if (!d->conversionFactorIsFixed) {
+        recomputeConversionFactor();
+    }
+
+    if(!d->conversionConstantIsFixed) {
+        recomputeConvesrionConstant();
+    }
+
+    qreal v = (apparentValue - d->conversionConstant)/d->conversionFactor;
+
+    if (d->constrains &= REFISINT) {
+        v = qFloor(v);
+    }
+
+    return v;
+
+}
+
+int KisSpinBoxUnitManager::rowCount(const QModelIndex &parent) const {
+    if (parent == QModelIndex()) {
+        return getsUnitSymbolList().size();
+    }
+    return 0;
+}
+
+QVariant KisSpinBoxUnitManager::data(const QModelIndex &index, int role) const {
+
+    if (role == Qt::DisplayRole) {
+        return getsUnitSymbolList(false).at(index.row());
+    }
+
+    return QVariant();
+}
+
+qreal KisSpinBoxUnitManager::getApparentValue(double refValue) const
+{
+    if (!d->conversionFactorIsFixed) {
+        recomputeConversionFactor();
+    }
+
+    if(!d->conversionConstantIsFixed) {
+        recomputeConvesrionConstant();
+    }
+
+    qreal v = refValue*d->conversionFactor + d->conversionConstant;
+
+    if (d->constrains &= VALISINT) {
+        v = qFloor(v);
+    }
+
+    return v;
+}
+
+qreal KisSpinBoxUnitManager::getConversionFactor(int dim, QString symbol) const
+{
+
+    qreal factor = -1;
+
+    switch (dim) {
+
+    case LENGTH:
+        do {
+            if (symbol == "px") {
+                break;
+            }
+
+            bool ok;
+            KoUnit unit = KoUnit::fromSymbol(symbol, &ok);
+            if (! ok) {
+                break;
+            }
+            factor = unit.toUserValue(1.0);
+        } while (0) ;
+        break;
+
+    case IMLENGTH:
+        if (symbol == "px") {
+            factor = 1;
+        }
+        break;
+
+    case ANGLE:
+        if (symbol == "°") {
+            factor = 1.0;
+            break;
+        }
+        if (symbol == "rad") {
+            factor = acos(-1)/90.0;
+            break;
+        }
+        if (symbol == "gon") {
+            factor = 10.0/9.0;
+            break;
+        }
+        if (symbol == "%") {
+            factor = 2.5/9.0; //(25% of circle is 90°)
+            break;
+        }
+        break;
+
+    case TIME:
+
+        if (symbol != "f") { //we have only frames for the moment.
+            break;
+        }
+        factor = 1.0;
+        break;
+
+    default:
+        break;
+    }
+
+    return factor;
+}
+
+
+void KisSpinBoxUnitManager::setUnitDimension(UnitDimension dimension)
+{
+    if (dimension == d->dim) {
+        return;
+    }
+
+    d->dim = dimension;
+    d->unitSymbol = referenceUnitSymbols[d->dim]; //Active dim is reference dim when just changed.
+    d->conversionFactor = 1.0;
+
+    emit unitDimensionChanged(d->dim);
+
+}
+
+void KisSpinBoxUnitManager::setApparentUnitFromSymbol(QString pSymbol)
+{
+
+    QString symbol = pSymbol.trimmed();
+
+    if (symbol == d->unitSymbol) {
+        return;
+    }
+
+    emit unitAboutToChange();
+
+    QString newSymb = "";
+
+    switch (d->dim) {
+
+    case ANGLE:
+        if (symbol.toLower() == "deg") {
+            newSymb = "°";
+            break;
+        }
+        goto default_indentifier; //alway do default after handling possible special cases.
+
+default_indentifier:
+    default:
+        QStringList list = getsUnitSymbolList();
+        if (list.contains(symbol, Qt::CaseInsensitive)) {
+            for (QString str : list) {
+                if (str.toLower() == symbol.toLower()) {
+                    newSymb = str; //official symbol may contain capitals letters, so better take the official version.
+                    break;
+                }
+            }
+            break;
+        }
+
+    }
+
+    if(newSymb.isEmpty()) {
+        return; //abort if it was impossible to locate the correct symbol.
+    }
+
+    if (d->canAccessDocument) {
+        //manage document relative units.
+
+        QStringList speUnits;
+
+        switch (d->dim) {
+
+        case LENGTH:
+            speUnits = documentRelativeLengthUnitSymbols;
+            goto default_identifier_conv_fact;
+
+        case IMLENGTH:
+            speUnits << "vw" << "vh";
+            goto default_identifier_conv_fact;
+
+        case TIME:
+            speUnits = documentRelativeTimeUnitSymbols;
+            goto default_identifier_conv_fact;
+
+default_identifier_conv_fact:
+        default:
+
+            if (speUnits.isEmpty()) {
+                d->conversionFactorIsFixed = true;
+                break;
+            }
+
+            if (speUnits.contains(newSymb)) {
+                d->conversionFactorIsFixed = false;
+                break;
+            }
+
+            d->conversionFactorIsFixed = true;
+            break;
+        }
+
+        if (d->dim == TIME) {
+            if (newSymb == "%") {
+                d->conversionConstantIsFixed = false;
+            }
+        } else {
+            d->conversionConstantIsFixed = true;
+        }
+
+    }
+
+    qreal conversFact = getConversionFactor(d->dim, newSymb);
+    qreal oldConversFact = d->conversionFactor;
+
+    d->conversionFactor = conversFact;
+    emit conversionFactorChanged(d->conversionFactor, oldConversFact);
+
+    d->unitSymbol = newSymb;
+    emit unitChanged(newSymb);
+
+}
+
+void KisSpinBoxUnitManager::selectApparentUnitFromIndex(int index) {
+
+    if (index >= 0 && index < rowCount()) {
+        setApparentUnitFromSymbol(getsUnitSymbolList().at(index));
+    }
+
+}
+
+void KisSpinBoxUnitManager::newUnitSymbolToUnitIndex(QString symbol) {
+    int id = getsUnitSymbolList().indexOf(symbol);
+
+    if (id >= 0) {
+        emit unitChanged(id);
+    }
+}
+
+void KisSpinBoxUnitManager::recomputeConversionFactor() const
+{
+    if (d->conversionFactorIsFixed) {
+        return;
+    }
+
+    qreal oldConversionFactor = d->conversionFactor;
+
+    d->conversionFactor = getConversionFactor(d->dim, d->unitSymbol);
+
+    if (oldConversionFactor != d->conversionFactor) {
+        emit conversionFactorChanged(d->conversionFactor, oldConversionFactor);
+    }
+}
+
+void KisSpinBoxUnitManager::recomputeConvesrionConstant() const
+{
+    if (d->conversionConstantIsFixed) {
+        return;
+    }
+
+    qreal oldConversionConstant = d->conversionConstant;
+
+    d->conversionConstant = getConversionConstant(d->dim, d->unitSymbol);
+
+    if (oldConversionConstant != d->conversionConstant) {
+        emit conversionConstantChanged(d->conversionConstant, oldConversionConstant);
+    }
+}
+
+void KisSpinBoxUnitManager::grantDocumentRelativeUnits()
+{
+    d->canAccessDocument = true;
+}
diff --git a/libs/widgetutils/kis_spin_box_unit_manager.h b/libs/widgetutils/kis_spin_box_unit_manager.h
new file mode 100644
index 0000000000..c0d44ffeb1
--- /dev/null
+++ b/libs/widgetutils/kis_spin_box_unit_manager.h
@@ -0,0 +1,164 @@
+/*
+ *  Copyright (c) 2017 Laurent Valentin Jospin <laurent.valentin@famillejospin.ch>
+ *
+ *  This program is free software; you can redistribute it and/or modify
+ *  it under the terms of the GNU General Public License as published by
+ *  the Free Software Foundation; either version 2 of the License, or
+ *  (at your option) any later version.
+ *
+ *  This program is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *  GNU General Public License for more details.
+ *
+ *  You should have received a copy of the GNU General Public License
+ *  along with this program; if not, write to the Free Software
+ *  Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
+ */
+
+#ifndef KISSPINBOXUNITMANAGER_H
+#define KISSPINBOXUNITMANAGER_H
+
+#include <QObject>
+#include <QStringList>
+#include <QAbstractListModel>
+
+#include "kritawidgetutils_export.h"
+
+class KisSpinBoxUnitManager;
+class KisSpinBoxUnitManagerBuilder;
+class KisSpinBoxUnitManagerFactory;
+
+/*!
+ * \brief The KisSpinBoxUnitManagerFactory class is a factory that is used to build a default KisSpinBoxUnitManager.
+ * \see KisSpinBoxUnitManagerBuilder
+ */
+class KRITAWIDGETUTILS_EXPORT KisSpinBoxUnitManagerFactory
+{
+public:
+
+    static KisSpinBoxUnitManager* buildDefaultUnitManager(QObject* parent);
+    //! \brief set a builder the factory can use. The factory should take on the lifecycle of the builder, so to delete it call clearUnitManagerBuilder();
+    static void setDefaultUnitManagerBuilder(KisSpinBoxUnitManagerBuilder* pBuilder);
+    static void clearUnitManagerBuilder();
+
+private:
+
+    static KisSpinBoxUnitManagerBuilder* builder;
+
+};
+
+/*!
+ * \brief The KisSpinBoxUnitManagerBuilder class is the base class, used in the strategy pattern of KisSpinBoxUnitManagerFactory.
+ * \see KisSpinBoxUnitManagerFactory.
+ */
+class KRITAWIDGETUTILS_EXPORT KisSpinBoxUnitManagerBuilder
+{
+
+public:
+
+    virtual ~KisSpinBoxUnitManagerBuilder() {}
+
+    virtual KisSpinBoxUnitManager* buildUnitManager(QObject* parent) = 0; //this pure virtual function is used to build a unitmanager, it will be used by the unitManagerFactory.
+};
+
+/**
+ * @brief The KisSpinBoxUnitManager class is an abstract interface for the unitspinboxes classes to manage different type of units.
+ *
+ * The class make a difference between unit dimension (distance, angle, time).
+ *
+ * The class allow to convert values between reference unit and apparent unit, but also to get other informations like possible units symbols.
+ *
+ * This class don't allow to use relative units (units which conversion factor is dependant of the context), even if its private data are prepared to manage it.
+ * The reason for this is that from the library of this class it is very hard to acess easily the informations needed. So all will be managed by subclasses in other libs.
+ *
+ * The class is a subclass of QAbstractListModel, so that available list of units is easily acessed by other Qt standard components, like QComboBoxes.
+ *
+ */
+class KRITAWIDGETUTILS_EXPORT KisSpinBoxUnitManager : public  QAbstractListModel
+{
+    Q_OBJECT
+
+public:
+
+    enum UnitDimension{
+        LENGTH = 0, //length, print size, reference is point
+        IMLENGTH = 1, //length, image size, reference is pixel. This dimension is used when the printing units must be avoided
+        ANGLE = 2,
+        TIME = 3
+    };
+
+    static inline bool isUnitId(int code) { return (code == LENGTH || code == ANGLE || code == TIME); }
+
+    //! \brief this list hold the symbols of the referenc unit per dimension. The index is equal to the value in UnitDimension so that the dimension name can be used to index the list.
+    static const QStringList referenceUnitSymbols;
+
+    enum Constrain{
+        NOCONSTR = 0,
+        REFISINT = 1,
+        VALISINT = 2
+
+    };
+
+    Q_DECLARE_FLAGS(Constrains, Constrain)
+
+    explicit KisSpinBoxUnitManager(QObject *parent = 0);
+    virtual ~KisSpinBoxUnitManager();
+
+    int getUnitDimensionType() const;
+    QString getReferenceUnitSymbol() const;
+    QString getApparentUnitSymbol() const;
+
+    //! \brief get the position of the apparent unit in the list of units. It is usefull if we want to build a model for combo-box based unit management.
+    int getApparentUnitId() const;
+
+    virtual QStringList getsUnitSymbolList(bool withName = false) const;
+
+    qreal getReferenceValue(double apparentValue) const;
+    qreal getApparentValue(double refValue) const;
+
+    //! \brief gets the conversion factor of a managed unit, or -1 in case of error. This method is the one that need to be overridden to extend the ability of the KisSpinBoxUnitManager.
+    virtual qreal getConversionFactor(int dim, QString symbol) const;
+    //! \brief some units conversions are done via an affine transform, not just a linear transform. This function gives the constant of this affine transform (usually 0).
+    virtual qreal getConversionConstant(int dim, QString symbol) const;
+
+    virtual int rowCount(const QModelIndex &parent = QModelIndex()) const;
+    virtual QVariant data(const QModelIndex &index, int role = Qt::DisplayRole) const;
+
+Q_SIGNALS:
+
+    void unitDimensionChanged(int dimCode);
+    void unitAboutToChange();
+    void unitChanged(QString symbol);
+    void unitChanged(int index);
+    void conversionFactorChanged(qreal newConversionFactor, qreal oldConversionFactor) const;
+    void conversionConstantChanged(qreal newConversionFactor, qreal oldConversionFactor) const;
+    void unitListChanged();
+
+public Q_SLOTS:
+
+    void setUnitDimension(UnitDimension dimension);
+    void setApparentUnitFromSymbol(QString pSymbol);
+    void selectApparentUnitFromIndex(int index);
+
+protected:
+
+    class Private;
+    Private * d;
+
+    //! \brief convert a unitChanged signal with a QString to one with an index.
+    void newUnitSymbolToUnitIndex(QString symbol);
+
+    //unit's that may be used only if acess to the document informations exists.
+    static const QStringList documentRelativeLengthUnitSymbols;
+    static const QStringList documentRelativeTimeUnitSymbols;
+
+    void recomputeConversionFactor() const;
+    void recomputeConvesrionConstant() const;
+
+    //! \brief calling this method give acess to document relative units. Only subclasses that manage thoses units should call it.
+    void grantDocumentRelativeUnits();
+
+};
+
+#endif // KISSPINBOXUNITMANAGER_H
diff --git a/packaging/linux/appimage/build-deps.sh b/packaging/linux/appimage/build-deps.sh
index a106d5ed9b..4e4cc28bd7 100644
--- a/packaging/linux/appimage/build-deps.sh
+++ b/packaging/linux/appimage/build-deps.sh
@@ -1,123 +1,122 @@
 #!/bin/bash
 
 # Enter a CentOS 6 chroot (you could use other methods)
 # git clone https://github.com/probonopd/AppImageKit.git
 # ./AppImageKit/build.sh 
 # sudo ./AppImageKit/AppImageAssistant.AppDir/testappimage /isodevice/boot/iso/CentOS-6.5-x86_64-LiveCD.iso bash
 
 # Halt on errors
 set -e
 
 # Be verbose
 set -x
 
 # Now we are inside CentOS 6
 grep -r "CentOS release 6" /etc/redhat-release || exit 1
 
 # qjsonparser, used to add metadata to the plugins needs to work in a en_US.UTF-8 environment. That's
 # not always set correctly in CentOS 6.7
 export LC_ALL=en_US.UTF-8
 export LANG=en_us.UTF-8
 
 # Determine which architecture should be built
 if [[ "$(arch)" = "i686" || "$(arch)" = "x86_64" ]] ; then
   ARCH=$(arch)
 else
   echo "Architecture could not be determined"
   exit 1
 fi
 
 # if the library path doesn't point to our usr/lib, linking will be broken and we won't find all deps either
 export LD_LIBRARY_PATH=/usr/lib64/:/usr/lib:/krita.appdir/usr/lib
 
 git_pull_rebase_helper()
 {
 	git reset --hard HEAD
         git pull
 }
 
 yum -y install epel-release 
 # we need to be up to date in order to install the xcb-keysyms dependency
 yum -y update
 # base dependencies and Qt5.
-yum -y install wget tar bzip2 git libtool which fuse fuse-devel libpng-devel automake libtool mesa-libEGL cppunit-devel cmake3 glibc-headers libstdc++-devel gcc-c++ freetype-devel fontconfig-devel libxml2-devel libstdc++-devel libXrender-devel patch xcb-util-keysyms-devel libXi-devel mesa-libGL-devel mesa-libGLU-devel libxcb libxcb-devel xcb-util xcb-util-devel glibc-devel xkeyboard-config
+yum -y install wget tar bzip2 git libtool which fuse fuse-devel libpng-devel automake libtool mesa-libEGL cppunit-devel cmake3 glibc-headers libstdc++-devel gcc-c++ freetype-devel fontconfig-devel libxml2-devel libstdc++-devel libXrender-devel patch xcb-util-keysyms-devel libXi-devel mesa-libGL-devel libxcb libxcb-devel xcb-util xcb-util-devel
 
 
 # Newer compiler than what comes with CentOS 6
 yum -y install centos-release-scl-rh
 yum -y install devtoolset-3-gcc devtoolset-3-gcc-c++
 . /opt/rh/devtoolset-3/enable
 
 # Make sure we build from the /, parts of this script depends on that. We also need to run as root...
 cd  /
 
 # Build AppImageKit
 if [ ! -d AppImageKit ] ; then
   git clone  --depth 1 https://github.com/probonopd/AppImageKit.git /AppImageKit
 fi
 
 cd /AppImageKit/
 git_pull_rebase_helper
-git checkout stable/v1.0
 ./build.sh
 cd /
 
 
 # Workaround for: On CentOS 6, .pc files in /usr/lib/pkgconfig are not recognized
 # However, this is where .pc files get installed when bulding libraries... (FIXME)
 # I found this by comparing the output of librevenge's "make install" command
 # between Ubuntu and CentOS 6
 ln -sf /usr/share/pkgconfig /usr/lib/pkgconfig
 
 
 # A krita build layout looks like this:
 # krita/ -- the source directory
 # krita/3rdparty -- the cmake3 definitions for the dependencies
 # d -- downloads of the dependencies from files.kde.org
 # b -- build directory for the dependencies
 # krita_build -- build directory for krita itself
 # krita.appdir -- install directory for krita and the dependencies
 
 # Get Krita
 if [ ! -d /krita ] ; then
 	git clone  --depth 1 https://github.com/KDE/krita.git /krita
 fi
 
 cd /krita/
 git_pull_rebase_helper
 
 # Create the build dir for the 3rdparty deps
 if [ ! -d /b ] ; then
     mkdir /b
 fi    
 if [ ! -d /d ] ; then
     mkdir /d
 fi
 
 # start building the deps
 cd /b
 
 rm -rf /b/* || true
 
 cmake3 /krita/3rdparty \
     -DCMAKE_INSTALL_PREFIX:PATH=/usr \
     -DINSTALL_ROOT=/usr \
     -DEXTERNALS_DOWNLOAD_DIR=/d
     
 cmake3 --build . --config RelWithDebInfo --target ext_qt
-cmake3 --build . --config RelWithDebInfo --target ext_boost
-cmake3 --build . --config RelWithDebInfo --target ext_eigen3
-cmake3 --build . --config RelWithDebInfo --target ext_exiv2
-cmake3 --build . --config RelWithDebInfo --target ext_fftw3
-cmake3 --build . --config RelWithDebInfo --target ext_lcms2
-cmake3 --build . --config RelWithDebInfo --target ext_ocio
-cmake3 --build . --config RelWithDebInfo --target ext_openexr
-cmake3 --build . --config RelWithDebInfo --target ext_vc
+#cmake3 --build . --config RelWithDebInfo --target ext_boost
+#cmake3 --build . --config RelWithDebInfo --target ext_eigen3
+#cmake3 --build . --config RelWithDebInfo --target ext_exiv2
+#cmake3 --build . --config RelWithDebInfo --target ext_fftw3
+#cmake3 --build . --config RelWithDebInfo --target ext_lcms2
+#cmake3 --build . --config RelWithDebInfo --target ext_ocio
+#cmake3 --build . --config RelWithDebInfo --target ext_openexr
+#cmake3 --build . --config RelWithDebInfo --target ext_vc
 #cmake3 --build . --config RelWithDebInfo --target ext_png
-cmake3 --build . --config RelWithDebInfo --target ext_tiff
-cmake3 --build . --config RelWithDebInfo --target ext_jpeg
-cmake3 --build . --config RelWithDebInfo --target ext_libraw
-cmake3 --build . --config RelWithDebInfo --target ext_kcrash
-cmake3 --build . --config RelWithDebInfo --target ext_poppler
-cmake3 --build . --config RelWithDebInfo --target ext_gsl
+#cmake3 --build . --config RelWithDebInfo --target ext_tiff
+#cmake3 --build . --config RelWithDebInfo --target ext_jpeg
+#cmake3 --build . --config RelWithDebInfo --target ext_libraw
+#cmake3 --build . --config RelWithDebInfo --target ext_kcrash
+#cmake3 --build . --config RelWithDebInfo --target ext_poppler
+#cmake3 --build . --config RelWithDebInfo --target ext_gsl
 
diff --git a/packaging/linux/appimage/build-krita.sh b/packaging/linux/appimage/build-krita.sh
index 00a79f3913..fbde58da0e 100644
--- a/packaging/linux/appimage/build-krita.sh
+++ b/packaging/linux/appimage/build-krita.sh
@@ -1,87 +1,88 @@
 #!/bin/bash
 
 # Enter a CentOS 6 chroot (you could use other methods)
 # git clone https://github.com/probonopd/AppImageKit.git
 # ./AppImageKit/build.sh 
 # sudo ./AppImageKit/AppImageAssistant.AppDir/testappimage /isodevice/boot/iso/CentOS-6.5-x86_64-LiveCD.iso bash
 
 # Halt on errors
 set -e
 
 # Be verbose
 set -x
 
 # Now we are inside CentOS 6
 grep -r "CentOS release 6" /etc/redhat-release || exit 1
 
 # qjsonparser, used to add metadata to the plugins needs to work in a en_US.UTF-8 environment. That's
 # not always set correctly in CentOS 6.7
 export LC_ALL=en_US.UTF-8
 export LANG=en_us.UTF-8
 
 # Determine which architecture should be built
 if [[ "$(arch)" = "i686" || "$(arch)" = "x86_64" ]] ; then
   ARCH=$(arch)
 else
   echo "Architecture could not be determined"
   exit 1
 fi
 
 # if the library path doesn't point to our usr/lib, linking will be broken and we won't find all deps either
 export LD_LIBRARY_PATH=/usr/lib64/:/usr/lib:/krita.appdir/usr/lib
 
 git_pull_rebase_helper()
 {
 	git reset --hard HEAD
         git pull
 }
 
 # Use the new compiler
 . /opt/rh/devtoolset-3/enable
 
 
 # Workaround for: On CentOS 6, .pc files in /usr/lib/pkgconfig are not recognized
 # However, this is where .pc files get installed when bulding libraries... (FIXME)
 # I found this by comparing the output of librevenge's "make install" command
 # between Ubuntu and CentOS 6
 ln -sf /usr/share/pkgconfig /usr/lib/pkgconfig
 
 
 # A krita build layout looks like this:
 # krita/ -- the source directory
 # krita/3rdparty -- the cmake3 definitions for the dependencies
 # d -- downloads of the dependencies from files.kde.org
 # b -- build directory for the dependencies
 # krita_build -- build directory for krita itself
 # krita.appdir -- install directory for krita and the dependencies
 
 # Get Krita
 if [ ! -d /krita ] ; then
 	git clone  --depth 1 https://github.com/KDE/krita.git /krita
 fi
 
 cd /krita/
 git_pull_rebase_helper
 
 cd /
 
 # If the environment variable DO_NOT_BUILD_KRITA is set to something,
 # then stop here. This is for docker hub which has a timeout that
 # prevents us from building in one go.
 # if [ ! -z "$DO_NOT_BUILD_KRITA" ] ; then
 #  exit 0
 # fi
 
 mkdir -p /krita_build
 cd /krita_build
 cmake3 ../krita \
     -DCMAKE_INSTALL_PREFIX:PATH=/krita.appdir/usr \
     -DDEFINE_NO_DEPRECATED=1 \
     -DCMAKE_BUILD_TYPE=RelWithDebInfo \
+    -DPACKAGERS_BUILD=1 \
     -DBUILD_TESTING=FALSE \
     -DKDE4_BUILD_TESTS=FALSE \
     -DHAVE_MEMORY_LEAK_TRACKER=FALSE
     
 # build
 make -j4 
 
diff --git a/packaging/linux/appimage/build-release.sh b/packaging/linux/appimage/build-release.sh
index 1bf69d31b6..a8e8b8e159 100644
--- a/packaging/linux/appimage/build-release.sh
+++ b/packaging/linux/appimage/build-release.sh
@@ -1,258 +1,250 @@
 #!/bin/bash
 
-RELEASE=krita-3.0.99.90
+RELEASE=3.1.2.0
 
 # Enter a CentOS 6 chroot (you could use other methods)
 # git clone https://github.com/probonopd/AppImageKit.git
 # ./AppImageKit/build.sh 
 # sudo ./AppImageKit/AppImageAssistant.AppDir/testappimage /isodevice/boot/iso/CentOS-6.5-x86_64-LiveCD.iso bash
 
 # Halt on errors
 set -e
 
 # Be verbose
 set -x
 
 # Now we are inside CentOS 6
 grep -r "CentOS release 6" /etc/redhat-release || exit 1
 
 # If we are running inside Travis CI, then we want to build Krita
 # and we remove the $DO_NOT_BUILD_KRITA environment variable
 # that was used in the process of generating the Docker image.
 # Also we do not want to download and build the dependencies every
 # time we build Krita on travis in the docker image. In order to
 # use newer dependencies, we re-build the docker image instead.
 #unset DO_NOT_BUILD_KRITA
 #NO_DOWNLOAD=1
 
 # clean up
 rm -rf /out/*
 rm -rf /krita.appdir
+rm -rf /krita_build
+mkdir /krita_build
 
 # qjsonparser, used to add metadata to the plugins needs to work in a en_US.UTF-8 environment. That's
 # not always set correctly in CentOS 6.7
 export LC_ALL=en_US.UTF-8
 export LANG=en_us.UTF-8
 
 # Determine which architecture should be built
 if [[ "$(arch)" = "i686" || "$(arch)" = "x86_64" ]] ; then
   ARCH=$(arch)
 else
   echo "Architecture could not be determined"
   exit 1
 fi
 
 # if the library path doesn't point to our usr/lib, linking will be broken and we won't find all deps either
 export LD_LIBRARY_PATH=/usr/lib64/:/usr/lib:/krita.appdir/usr/lib
 
 cd /
 
 # Prepare the install location
 rm -rf /krita.appdir/ || true
 mkdir -p /krita.appdir/usr/bin
 
 # make sure lib and lib64 are the same thing
 mkdir -p /krita.appdir/usr/lib
 cd  /krita.appdir/usr
 ln -s lib lib64
 
 # Use the new compiler
 . /opt/rh/devtoolset-3/enable
 
 # fetch and build krita
 cd /
-wget http://files.kde.org/krita/3/source/$RELEASE.tar.xz
-tar -xf $RELEASE.tar.xz
+#wget http://files.kde.org/krita/krita-$RELEASE.tar.gz
+#wget http://www.valdyas.org/~boud/krita-$RELEASE.tar.gz
+wget http://download.kde.org/unstable/krita/$RELEASE/krita-$RELEASE.tar.gz
+tar -xf krita-$RELEASE.tar.gz
 cd /krita_build
-rm -rf *
-cmake3 ../$RELEASE \
+cmake3 ../krita-$RELEASE \
     -DCMAKE_INSTALL_PREFIX:PATH=/krita.appdir/usr \
     -DDEFINE_NO_DEPRECATED=1 \
     -DCMAKE_BUILD_TYPE=RelWithDebInfo \
+    -DPACKAGERS_BUILD=1 \
     -DBUILD_TESTING=FALSE \
     -DKDE4_BUILD_TESTS=FALSE \
     -DHAVE_MEMORY_LEAK_TRACKER=FALSE
 make -j4 install
 
 cd /krita.appdir
 
 # FIXME: How to find out which subset of plugins is really needed? I used strace when running the binary
 cp -r /usr/plugins ./usr/bin/
 # copy the Qt translation
 cp -r /usr/translations ./usr
 
 cp $(ldconfig -p | grep libsasl2.so.2 | cut -d ">" -f 2 | xargs) ./usr/lib/
 cp $(ldconfig -p | grep libGL.so.1 | cut -d ">" -f 2 | xargs) ./usr/lib/ # otherwise segfaults!?
 cp $(ldconfig -p | grep libGLU.so.1 | cut -d ">" -f 2 | xargs) ./usr/lib/ # otherwise segfaults!?
 # Fedora 23 seemed to be missing SOMETHING from the Centos 6.7. The only message was:
 # This application failed to start because it could not find or load the Qt platform plugin "xcb".
 # Setting export QT_DEBUG_PLUGINS=1 revealed the cause.
 # QLibraryPrivate::loadPlugin failed on "/usr/lib64/qt5/plugins/platforms/libqxcb.so" : 
 # "Cannot load library /usr/lib64/qt5/plugins/platforms/libqxcb.so: (/lib64/libEGL.so.1: undefined symbol: drmGetNodeTypeFromFd)"
 # Which means that we have to copy libEGL.so.1 in too
 cp $(ldconfig -p | grep libEGL.so.1 | cut -d ">" -f 2 | xargs) ./usr/lib/ # Otherwise F23 cannot load the Qt platform plugin "xcb"
 # let's not copy xcb itself, that breaks on dri3 systems https://bugs.kde.org/show_bug.cgi?id=360552
 #cp $(ldconfig -p | grep libxcb.so.1 | cut -d ">" -f 2 | xargs) ./usr/lib/ 
 cp $(ldconfig -p | grep libfreetype.so.6 | cut -d ">" -f 2 | xargs) ./usr/lib/ # For Fedora 20
 
 ldd usr/bin/krita | grep "=>" | awk '{print $3}' | xargs -I '{}' cp -v '{}' ./usr/lib || true
 #ldd usr/lib64/krita/*.so  | grep "=>" | awk '{print $3}' | xargs -I '{}' cp -v '{}' ./usr/lib || true
 #ldd usr/lib64/plugins/imageformats/*.so  | grep "=>" | awk '{print $3}' | xargs -I '{}' cp -v '{}' ./usr/lib || true
 
 ldd usr/bin/plugins/platforms/libqxcb.so | grep "=>" | awk '{print $3}'  |  xargs -I '{}' cp -v '{}' ./usr/lib || true
 
 # Copy in the indirect dependencies
 FILES=$(find . -type f -executable)
 
 for FILE in $FILES ; do
 	ldd "${FILE}" | grep "=>" | awk '{print $3}' | xargs -I '{}' cp -v '{}' usr/lib || true
 done
 
 #DEPS=""
 #for FILE in $FILES ; do
 #  ldd "${FILE}" | grep "=>" | awk '{print $3}' | xargs -I '{}' echo '{}' > DEPSFILE
 #done
 #DEPS=$(cat DEPSFILE  |sort | uniq)
 #for FILE in $DEPS ; do
 #  if [ -f $FILE ] ; then
 #    echo $FILE
 #    cp --parents -rfL $FILE ./
 #  fi
 #done
 #rm -f DEPSFILE
 
 
 # The following are assumed to be part of the base system
 rm -f usr/lib/libcom_err.so.2 || true
 rm -f usr/lib/libcrypt.so.1 || true
 rm -f usr/lib/libdl.so.2 || true
 rm -f usr/lib/libexpat.so.1 || true
 #rm -f usr/lib/libfontconfig.so.1 || true
 rm -f usr/lib/libgcc_s.so.1 || true
 rm -f usr/lib/libglib-2.0.so.0 || true
 rm -f usr/lib/libgpg-error.so.0 || true
 rm -f usr/lib/libgssapi_krb5.so.2 || true
 rm -f usr/lib/libgssapi.so.3 || true
 rm -f usr/lib/libhcrypto.so.4 || true
 rm -f usr/lib/libheimbase.so.1 || true
 rm -f usr/lib/libheimntlm.so.0 || true
 rm -f usr/lib/libhx509.so.5 || true
 rm -f usr/lib/libICE.so.6 || true
 rm -f usr/lib/libidn.so.11 || true
 rm -f usr/lib/libk5crypto.so.3 || true
 rm -f usr/lib/libkeyutils.so.1 || true
 rm -f usr/lib/libkrb5.so.26 || true
 rm -f usr/lib/libkrb5.so.3 || true
 rm -f usr/lib/libkrb5support.so.0 || true
 # rm -f usr/lib/liblber-2.4.so.2 || true # needed for debian wheezy
 # rm -f usr/lib/libldap_r-2.4.so.2 || true # needed for debian wheezy
 rm -f usr/lib/libm.so.6 || true
 rm -f usr/lib/libp11-kit.so.0 || true
 rm -f usr/lib/libpcre.so.3 || true
 rm -f usr/lib/libpthread.so.0 || true
 rm -f usr/lib/libresolv.so.2 || true
 rm -f usr/lib/libroken.so.18 || true
 rm -f usr/lib/librt.so.1 || true
 rm -f usr/lib/libsasl2.so.2 || true
 rm -f usr/lib/libSM.so.6 || true
 rm -f usr/lib/libusb-1.0.so.0 || true
 rm -f usr/lib/libuuid.so.1 || true
 rm -f usr/lib/libwind.so.0 || true
 rm -f usr/lib/libfontconfig.so.* || true
 
 # Remove these libraries, we need to use the system versions; this means 11.04 is not supported (12.04 is our baseline)
 rm -f usr/lib/libGL.so.* || true
 rm -f usr/lib/libdrm.so.* || true
 rm -f usr/lib/libX11.so.* || true
 #rm -f usr/lib/libz.so.1 || true
 
 # These seem to be available on most systems but not Ubuntu 11.04
 # rm -f usr/lib/libffi.so.6 usr/lib/libGL.so.1 usr/lib/libglapi.so.0 usr/lib/libxcb.so.1 usr/lib/libxcb-glx.so.0 || true
 
 # Delete potentially dangerous libraries
 rm -f usr/lib/libstdc* usr/lib/libgobject* usr/lib/libc.so.* || true
 rm -f usr/lib/libxcb.so.1
 
 # Do NOT delete libX* because otherwise on Ubuntu 11.04:
 # loaded library "Xcursor" malloc.c:3096: sYSMALLOc: Assertion (...) Aborted
 
 # We don't bundle the developer stuff
 rm -rf usr/include || true
 rm -rf usr/lib/cmake3 || true
 rm -rf usr/lib/pkgconfig || true
 rm -rf usr/share/ECM/ || true
 rm -rf usr/share/gettext || true
 rm -rf usr/share/pkgconfig || true
 
+mv usr/share/locale usr/share/krita || true
+
 strip usr/lib/kritaplugins/* usr/bin/* usr/lib/* || true
 
 # Since we set /krita.appdir as the prefix, we need to patch it away too (FIXME)
 # Probably it would be better to use /app as a prefix because it has the same length for all apps
 cd usr/ ; find . -type f -exec sed -i -e 's|/krita.appdir/usr/|./././././././././|g' {} \; ; cd  ..
 
 # On openSUSE Qt is picking up the wrong libqxcb.so
 # (the one from the system when in fact it should use the bundled one) - is this a Qt bug?
 # Also, Krita has a hardcoded /usr which we patch away
 cd usr/ ; find . -type f -exec sed -i -e 's|/usr|././|g' {} \; ; cd ..
 
 # We do not bundle this, so let's not search that inside the AppImage. 
 # Fixes "Qt: Failed to create XKB context!" and lets us enter text
 sed -i -e 's|././/share/X11/|/usr/share/X11/|g' ./usr/bin/plugins/platforminputcontexts/libcomposeplatforminputcontextplugin.so
 sed -i -e 's|././/share/X11/|/usr/share/X11/|g' ./usr/lib/libQt5XcbQpa.so.5
 
 # Workaround for:
 # D-Bus library appears to be incorrectly set up;
 # failed to read machine uuid: Failed to open
 # The file is more commonly in /etc/machine-id
 # sed -i -e 's|/var/lib/dbus/machine-id|//././././etc/machine-id|g' ./usr/lib/libdbus-1.so.3
 # or
 rm -f ./usr/lib/libdbus-1.so.3 || true
 
 cp ../AppImageKit/AppRun .
 cp ./usr/share/applications/org.kde.krita.desktop krita.desktop
 cp /krita/krita/pics/app/64-apps-calligrakrita.png calligrakrita.png
 
 # replace krita with the lib-checking startup script.
 #cd /krita.appdir/usr/bin
 #mv krita krita.real
 #wget https://raw.githubusercontent.com/boudewijnrempt/AppImages/master/recipes/krita/krita
 #chmod a+rx krita
 cd / 
 
 APP=krita
 
-# Source functions
-wget -q https://github.com/probonopd/AppImages/raw/master/functions.sh -O ./functions.sh
-. ./functions.sh
-
-# Install desktopintegration in usr/bin/krita.wrapper -- feel free to edit it
-cd /krita.appdir
-get_desktopintegration krita
-
 cd /
 
 VER=$(grep "#define KRITA_VERSION_STRING" krita_build/libs/version/kritaversion.h | cut -d '"' -f 2)
 VERSION=$VER
 VERSION="$(sed s/\ /-/g <<<$VERSION)"
 echo $VERSION
 
 if [[ "$ARCH" = "x86_64" ]] ; then
 	APPIMAGE=$APP"-"$VERSION"-x86_64.appimage"
 fi
 if [[ "$ARCH" = "i686" ]] ; then
 	APPIMAGE=$APP"-"$VERSION"-i386.appimage"
 fi
 echo $APPIMAGE
 
 mkdir -p /out
 
 rm -f /out/*.AppImage || true
 AppImageKit/AppImageAssistant.AppDir/package /krita.appdir/ /out/$APPIMAGE
 
 chmod a+rwx /out/$APPIMAGE # So that we can edit the AppImage outside of the Docker container
-
-cd /krita.appdir
-mv AppRun krita
-cd /
-mv krita.appdir $APP"-"$VERSION"-x86_64
-tar -czf $APP"-"$VERSION"-x86_64.tgz $APP"-"$VERSION"-x86_64
diff --git a/plugins/dockers/advancedcolorselector/kis_color_selector_settings.cpp b/plugins/dockers/advancedcolorselector/kis_color_selector_settings.cpp
index e5f0e1f4d8..73eeeab217 100644
--- a/plugins/dockers/advancedcolorselector/kis_color_selector_settings.cpp
+++ b/plugins/dockers/advancedcolorselector/kis_color_selector_settings.cpp
@@ -1,634 +1,634 @@
 /*
  *  Copyright (C) 2010 Celarek Adam <kdedev at xibo dot at>
  *
  *  This program is free software; you can redistribute it and/or modify
  *  it under the terms of the GNU General Public License as published by
  *  the Free Software Foundation; either version 2 of the License, or
  *  (at your option) any later version.
  *
  *  This program is distributed in the hope that it will be useful,
  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  *  GNU General Public License for more details.
  *
  *  You should have received a copy of the GNU General Public License
  *  along with this program; if not, write to the Free Software
  *  Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
  */
 
 #include "kis_color_selector_settings.h"
 #include "ui_wdg_color_selector_settings.h"
 
 #include <QVBoxLayout>
 #include <QDialogButtonBox>
 #include <QPushButton>
 #include <QComboBox>
 
 #include <kconfiggroup.h>
 
 
 #include <kis_icon.h>
 #include "KoColorSpace.h"
 #include "KoColorSpaceRegistry.h"
 #include "KoColorProfile.h"
 
 #include "kis_color_selector_combo_box.h"
 #include "kis_color_selector.h"
 #include "kis_config.h"
 
 
 KisColorSelectorSettings::KisColorSelectorSettings(QWidget *parent) :
     KisPreferenceSet(parent),
     ui(new Ui::KisColorSelectorSettings)
 {
     ui->setupUi(this);
 
     resize(minimumSize());
 
     ui->colorSelectorConfiguration->setColorSpace(ui->colorSpace->currentColorSpace());
     ui->useDifferentColorSpaceCheckbox->setChecked(false);
 
     connect(ui->useDifferentColorSpaceCheckbox, SIGNAL(clicked(bool)), this, SLOT(useDifferentColorSpaceChecked(bool)));
 
     /* color docker selector drop down */
     ui->dockerColorSettingsComboBox->addItem(i18n("Advanced Color Selector"));
     ui->dockerColorSettingsComboBox->addItem(i18n("Color Sliders"));
     ui->dockerColorSettingsComboBox->addItem(i18n("Color Hotkeys"));
     ui->dockerColorSettingsComboBox->setCurrentIndex(0); // start off seeing advanced color selector properties
 
     connect( ui->dockerColorSettingsComboBox, SIGNAL(currentIndexChanged(int)),this, SLOT(changedColorDocker(int)));
     changedColorDocker(0);
 
 
     /* advanced color docker options */
     ui->dockerResizeOptionsComboBox->addItem(i18n("Change to a Horizontal Layout"));
     ui->dockerResizeOptionsComboBox->addItem(i18n("Hide Shade Selector"));
     ui->dockerResizeOptionsComboBox->addItem(i18n("Do Nothing"));
     ui->dockerResizeOptionsComboBox->setCurrentIndex(0);
 
 
     ui->zoomSelectorOptionComboBox->addItem(i18n("When Pressing Middle Mouse Button"));
     ui->zoomSelectorOptionComboBox->addItem(i18n("On Mouse Over"));
     ui->zoomSelectorOptionComboBox->addItem(i18n("Never"));
     ui->zoomSelectorOptionComboBox->setCurrentIndex(0);
 
 
     ui->colorSelectorTypeComboBox->addItem(i18n("HSV"));
     ui->colorSelectorTypeComboBox->addItem(i18n("HSL"));
     ui->colorSelectorTypeComboBox->addItem(i18n("HSI"));
     ui->colorSelectorTypeComboBox->addItem(i18n("HSY'"));
     ui->colorSelectorTypeComboBox->setCurrentIndex(0);
     connect( ui->colorSelectorTypeComboBox, SIGNAL(currentIndexChanged(int)),this, SLOT(changedACSColorSelectorType(int)));
     changedACSColorSelectorType(0); // initialize everything to HSV at the start
 
 
     ui->ACSshadeSelectorMyPaintColorModelComboBox->addItem(i18n("HSV"));
     ui->ACSshadeSelectorMyPaintColorModelComboBox->addItem(i18n("HSL"));
     ui->ACSshadeSelectorMyPaintColorModelComboBox->addItem(i18n("HSI"));
     ui->ACSshadeSelectorMyPaintColorModelComboBox->addItem(i18n("HSY'"));
     ui->ACSshadeSelectorMyPaintColorModelComboBox->setCurrentIndex(0);
 
 
     ui->ACSShadeSelectorTypeComboBox->addItem(i18n("MyPaint"));
     ui->ACSShadeSelectorTypeComboBox->addItem(i18n("Minimal"));
     ui->ACSShadeSelectorTypeComboBox->addItem(i18n("Do Not Show"));
     ui->ACSShadeSelectorTypeComboBox->setCurrentIndex(0);
     changedACSShadeSelectorType(0); // show/hide UI elements for MyPaint settings
     connect( ui->ACSShadeSelectorTypeComboBox, SIGNAL(currentIndexChanged(int)),this, SLOT(changedACSShadeSelectorType(int)));
 
 
     ui->commonColorsAlignVertical->setChecked(true);
     ui->commonColorsAlignHorizontal->setChecked(true);
     connect( ui->commonColorsAlignHorizontal, SIGNAL(toggled(bool)), this, SLOT(changedACSColorAlignment(bool)));
     connect( ui->lastUsedColorsAlignHorizontal, SIGNAL(toggled(bool)), this, SLOT(changedACSLastUsedColorAlignment(bool)));
 
     changedACSColorAlignment(ui->commonColorsAlignHorizontal->isChecked());
     changedACSLastUsedColorAlignment(ui->lastUsedColorsAlignHorizontal->isChecked());
 
 
     connect(ui->colorSpace,                 SIGNAL(colorSpaceChanged(const KoColorSpace*)),
             ui->colorSelectorConfiguration, SLOT(setColorSpace(const KoColorSpace*)));
 
 
     connect(this, SIGNAL(hsxchanged(int)),
             ui->colorSelectorConfiguration, SLOT(setList(int)));
 
     connect(ui->minimalShadeSelectorLineCount,      SIGNAL(valueChanged(int)),
             ui->minimalShadeSelectorLineSettings,   SLOT(setLineCount(int)));
 
     connect(ui->minimalShadeSelectorLineSettings,   SIGNAL(lineCountChanged(int)),
             ui->minimalShadeSelectorLineCount,      SLOT(setValue(int)));
 
     connect(ui->minimalShadeSelectorAsGradient,     SIGNAL(toggled(bool)),
             ui->minimalShadeSelectorLineSettings,   SIGNAL(setGradient(bool)));
 
     connect(ui->minimalShadeSelectorAsColorPatches, SIGNAL(toggled(bool)),
             ui->minimalShadeSelectorLineSettings,   SIGNAL(setPatches(bool)));
 
     connect(ui->minimalShadeSelectorLineHeight,     SIGNAL(valueChanged(int)),
             ui->minimalShadeSelectorLineSettings,   SIGNAL(setLineHeight(int)));
 
     connect(ui->minimalShadeSelectorPatchesPerLine, SIGNAL(valueChanged(int)),
             ui->minimalShadeSelectorLineSettings,   SIGNAL(setPatchCount(int)));
 }
 
 KisColorSelectorSettings::~KisColorSelectorSettings()
 {
     delete ui;
 }
 
 QString KisColorSelectorSettings::id()
 {
     return QString("advancedColorSelector");
 }
 
 QString KisColorSelectorSettings::name()
 {
     return header();
 }
 
 QString KisColorSelectorSettings::header()
 {
     return QString(i18n("Color Selector Settings"));
 }
 
 
 QIcon KisColorSelectorSettings::icon()
 {
     return KisIconUtils::loadIcon("extended_color_selector");
 }
 
 
 void KisColorSelectorSettings::savePreferences() const
 {
     // write cfg
     KConfigGroup cfg =  KSharedConfig::openConfig()->group("advancedColorSelector");
     KConfigGroup hsxcfg =  KSharedConfig::openConfig()->group("hsxColorSlider");
     KConfigGroup hotkeycfg =  KSharedConfig::openConfig()->group("colorhotkeys");
 
     //  advanced color selector
     cfg.writeEntry("onDockerResize", ui->dockerResizeOptionsComboBox->currentIndex());
     cfg.writeEntry("zoomSelectorOptions", ui->zoomSelectorOptionComboBox->currentIndex() );
     cfg.writeEntry("zoomSize", ui->popupSize->value());
 
 
 
     bool useCustomColorSpace =  ui->useDifferentColorSpaceCheckbox->isChecked();
     const KoColorSpace* colorSpace = useCustomColorSpace ? ui->colorSpace->currentColorSpace() : 0;
 
 
     KisConfig kisconfig;
     kisconfig.setCustomColorSelectorColorSpace(colorSpace);
 
     //color patches
     cfg.writeEntry("lastUsedColorsShow", ui->lastUsedColorsShow->isChecked());
     cfg.writeEntry("lastUsedColorsAlignment", ui->lastUsedColorsAlignVertical->isChecked());
     cfg.writeEntry("lastUsedColorsScrolling", ui->lastUsedColorsAllowScrolling->isChecked());
     cfg.writeEntry("lastUsedColorsNumCols", ui->lastUsedColorsNumCols->value());
     cfg.writeEntry("lastUsedColorsNumRows", ui->lastUsedColorsNumRows->value());
     cfg.writeEntry("lastUsedColorsCount", ui->lastUsedColorsPatchCount->value());
     cfg.writeEntry("lastUsedColorsWidth", ui->lastUsedColorsWidth->value());
     cfg.writeEntry("lastUsedColorsHeight", ui->lastUsedColorsHeight->value());
 
     cfg.writeEntry("commonColorsShow", ui->commonColorsShow->isChecked());
     cfg.writeEntry("commonColorsAlignment", ui->commonColorsAlignVertical->isChecked());
     cfg.writeEntry("commonColorsScrolling", ui->commonColorsAllowScrolling->isChecked());
     cfg.writeEntry("commonColorsNumCols", ui->commonColorsNumCols->value());
     cfg.writeEntry("commonColorsNumRows", ui->commonColorsNumRows->value());
     cfg.writeEntry("commonColorsCount", ui->commonColorsPatchCount->value());
     cfg.writeEntry("commonColorsWidth", ui->commonColorsWidth->value());
     cfg.writeEntry("commonColorsHeight", ui->commonColorsHeight->value());
     cfg.writeEntry("commonColorsAutoUpdate", ui->commonColorsAutoUpdate->isChecked());
 
     //shade selector
 
 
 
     int shadeSelectorTypeIndex =  ui->ACSShadeSelectorTypeComboBox->currentIndex();
 
     if(shadeSelectorTypeIndex == 0) {
         cfg.writeEntry("shadeSelectorType", "MyPaint");
     } else if (shadeSelectorTypeIndex == 1) {
         cfg.writeEntry("shadeSelectorType", "Minimal");
     } else {
         cfg.writeEntry("shadeSelectorType", "Hidden");
     }
 
     cfg.writeEntry("shadeSelectorUpdateOnRightClick", ui->shadeSelectorUpdateOnRightClick->isChecked());
     cfg.writeEntry("shadeSelectorUpdateOnForeground", ui->shadeSelectorUpdateOnForeground->isChecked());
     cfg.writeEntry("shadeSelectorUpdateOnLeftClick", ui->shadeSelectorUpdateOnLeftClick->isChecked());
     cfg.writeEntry("shadeSelectorUpdateOnBackground", ui->shadeSelectorUpdateOnBackground->isChecked());
     cfg.writeEntry("hidePopupOnClickCheck", ui->hidePopupOnClickCheck->isChecked());
 
     //mypaint model
 
     int shadeMyPaintComboBoxIndex  = ui->ACSshadeSelectorMyPaintColorModelComboBox->currentIndex();
     if (shadeMyPaintComboBoxIndex == 0 ) {
         cfg.writeEntry("shadeMyPaintType",   "HSV");
     } else  if (shadeMyPaintComboBoxIndex == 1 ) {
         cfg.writeEntry("shadeMyPaintType",   "HSL");
     } else  if (shadeMyPaintComboBoxIndex == 2 ) {
         cfg.writeEntry("shadeMyPaintType",   "HSI");
     } else {   // HSY
         cfg.writeEntry("shadeMyPaintType",   "HSY");
     }
 
 
 
     cfg.writeEntry("minimalShadeSelectorAsGradient", ui->minimalShadeSelectorAsGradient->isChecked());
     cfg.writeEntry("minimalShadeSelectorPatchCount", ui->minimalShadeSelectorPatchesPerLine->value());
     cfg.writeEntry("minimalShadeSelectorLineConfig",  ui->minimalShadeSelectorLineSettings->toString());
     cfg.writeEntry("minimalShadeSelectorLineHeight", ui->minimalShadeSelectorLineHeight->value());
 
     //color selector
     KisColorSelectorComboBox* cstw = dynamic_cast<KisColorSelectorComboBox*>(ui->colorSelectorConfiguration);
     cfg.writeEntry("colorSelectorConfiguration", cstw->configuration().toString());
 
     cfg.writeEntry("hsxSettingType", ui->colorSelectorTypeComboBox->currentIndex());
 
     //luma//
     cfg.writeEntry("lumaR", ui->l_lumaR->value());
     cfg.writeEntry("lumaG", ui->l_lumaG->value());
     cfg.writeEntry("lumaB", ui->l_lumaB->value());
     cfg.writeEntry("gamma", ui->SP_Gamma->value());
 
     //slider//
     hsxcfg.writeEntry("hsvH", ui->csl_hsvH->isChecked());
     hsxcfg.writeEntry("hsvS", ui->csl_hsvS->isChecked());
     hsxcfg.writeEntry("hsvV", ui->csl_hsvV->isChecked());
     hsxcfg.writeEntry("hslH", ui->csl_hslH->isChecked());
     hsxcfg.writeEntry("hslS", ui->csl_hslS->isChecked());
     hsxcfg.writeEntry("hslL", ui->csl_hslL->isChecked());
     hsxcfg.writeEntry("hsiH", ui->csl_hsiH->isChecked());
     hsxcfg.writeEntry("hsiS", ui->csl_hsiS->isChecked());
     hsxcfg.writeEntry("hsiI", ui->csl_hsiI->isChecked());
     hsxcfg.writeEntry("hsyH", ui->csl_hsyH->isChecked());
     hsxcfg.writeEntry("hsyS", ui->csl_hsyS->isChecked());
     hsxcfg.writeEntry("hsyY", ui->csl_hsyY->isChecked());
 
     //hotkeys//
     hotkeycfg.writeEntry("steps_lightness", ui->sb_lightness->value());
     hotkeycfg.writeEntry("steps_saturation", ui->sb_saturation->value());
     hotkeycfg.writeEntry("steps_hue", ui->sb_hue->value());
     hotkeycfg.writeEntry("steps_redgreen", ui->sb_rg->value());
     hotkeycfg.writeEntry("steps_blueyellow", ui->sb_by->value());
 
     emit settingsChanged();
 }
 
 //void KisColorSelectorSettings::changeEvent(QEvent *e)
 //{
 //    QDialog::changeEvent(e);
 //    switch (e->type()) {
 //    case QEvent::LanguageChange:
 //        ui->retranslateUi(this);
 //        break;
 //    default:
 //        break;
 //    }
 //}
 
 
 void KisColorSelectorSettings::changedColorDocker(int index)
 {
     // having a situation where too many sections are visible makes the window too large. turn all off before turning more on
     ui->colorSliderOptions->hide();
     ui->advancedColorSelectorOptions->hide();
     ui->hotKeyOptions->hide();
 
     if (index == 0)     { // advanced color selector options selected
         ui->advancedColorSelectorOptions->show();
         ui->colorSliderOptions->hide();
         ui->hotKeyOptions->hide();
     }
     else if (index == 1) {  // color slider options selected
         ui->advancedColorSelectorOptions->hide();
         ui->hotKeyOptions->hide();
         ui->colorSliderOptions->show();
     } else {
        ui->colorSliderOptions->hide();
        ui->advancedColorSelectorOptions->hide();
        ui->hotKeyOptions->show();
     }
 }
 
 void KisColorSelectorSettings::changedACSColorSelectorType(int index)
 {
     ui->lumaCoefficientGroupbox->setVisible(false);
 
     if (index == 0)     {  // HSV
         ui->ACSTypeDescriptionLabel->setText(i18n("Values goes from black to white, or black to the most saturated colour. Saturation, in turn, goes from the most saturated colour to white, grey or black."));
     }
     else if (index == 1)     {  // HSL
         ui->ACSTypeDescriptionLabel->setText(i18n("Lightness goes from black to white, with middle grey being equal to the most saturated colour."));
     }
     else if (index == 2)     {  // HSI
         ui->ACSTypeDescriptionLabel->setText(i18n("Intensity maps to the sum of rgb components"));
     }
     else {  // HSY'
         ui->ACSTypeDescriptionLabel->setText(i18n("Luma(Y') is weighted by its coefficients which are configurable. Default values are set to 'rec 709'."));
         ui->lumaCoefficientGroupbox->setVisible(true);
     }
 
     ui->colorSelectorConfiguration->update();
     emit hsxchanged(index);
 
 }
 
 
 void KisColorSelectorSettings::changedACSColorAlignment(bool toggled)
 {
     // this slot is tied to the horizontal radio button's state being changed
     // you can infer the vertical state
 
     ui->lbl_commonColorsNumCols->setDisabled(toggled);
     ui->commonColorsNumCols->setDisabled(toggled);
 
     ui->lbl_commonColorsNumRows->setEnabled(toggled);
     ui->commonColorsNumRows->setEnabled(toggled);
 }
 
 void KisColorSelectorSettings::changedACSLastUsedColorAlignment(bool toggled)
 {
     // this slot is tied to the horizontal radio button's state being changed
     // you can infer the vertical state
 
     ui->lbl_lastUsedNumCols->setDisabled(toggled);
     ui->lastUsedColorsNumCols->setDisabled(toggled);
 
     ui->lbl_lastUsedNumRows->setEnabled(toggled);
     ui->lastUsedColorsNumRows->setEnabled(toggled);
 }
 
 
 
 void KisColorSelectorSettings::changedACSShadeSelectorType(int index)
 {
 
     if (index == 0)     {  // MyPaint
         ui->minimalShadeSelectorGroup->hide();
         ui->myPaintColorModelLabel->show();
         ui->ACSshadeSelectorMyPaintColorModelComboBox->show();
 
     } else if (index == 1) { // Minimal
         ui->minimalShadeSelectorGroup->show();
         ui->myPaintColorModelLabel->hide();
         ui->ACSshadeSelectorMyPaintColorModelComboBox->hide();
 
     }else { // do not show
         ui->minimalShadeSelectorGroup->hide();
         ui->myPaintColorModelLabel->hide();
         ui->ACSshadeSelectorMyPaintColorModelComboBox->hide();
     }
 }
 
 void KisColorSelectorSettings::useDifferentColorSpaceChecked(bool enabled)
 {
     ui->colorSpace->setEnabled(enabled);
 }
 
 void KisColorSelectorSettings::loadPreferences()
 {
     //read cfg
     //don't forget to also add a new entry to the default preferences
 
     KConfigGroup cfg =  KSharedConfig::openConfig()->group("advancedColorSelector");
     KConfigGroup hsxcfg =  KSharedConfig::openConfig()->group("hsxColorSlider");
     KConfigGroup hotkeycfg =  KSharedConfig::openConfig()->group("colorhotkeys");
 
 
     // Advanced color selector
     ui->dockerResizeOptionsComboBox->setCurrentIndex(  (int)cfg.readEntry("onDockerResize", 0) );
     ui->zoomSelectorOptionComboBox->setCurrentIndex(   (int) cfg.readEntry("zoomSelectorOptions", 0) );
     ui->popupSize->setValue(cfg.readEntry("zoomSize", 280));
 
 
     {
         KisConfig kisconfig;
         const KoColorSpace *cs = kisconfig.customColorSelectorColorSpace();
 
-        if(cs) {
+        if (cs) {
             ui->useDifferentColorSpaceCheckbox->setChecked(true);
             ui->colorSpace->setEnabled(true);
             ui->colorSpace->setCurrentColorSpace(cs);
         } else {
             ui->useDifferentColorSpaceCheckbox->setChecked(false);
             ui->colorSpace->setEnabled(false);
         }
     }
 
 
     //color patches
     ui->lastUsedColorsShow->setChecked(cfg.readEntry("lastUsedColorsShow", true));
     bool a = cfg.readEntry("lastUsedColorsAlignment", true);
     ui->lastUsedColorsAlignVertical->setChecked(a);
     ui->lastUsedColorsAlignHorizontal->setChecked(!a);
     ui->lastUsedColorsAllowScrolling->setChecked(cfg.readEntry("lastUsedColorsScrolling", true));
     ui->lastUsedColorsNumCols->setValue(cfg.readEntry("lastUsedColorsNumCols", 1));
     ui->lastUsedColorsNumRows->setValue(cfg.readEntry("lastUsedColorsNumRows", 1));
     ui->lastUsedColorsPatchCount->setValue(cfg.readEntry("lastUsedColorsCount", 20));
     ui->lastUsedColorsWidth->setValue(cfg.readEntry("lastUsedColorsWidth", 16));
     ui->lastUsedColorsHeight->setValue(cfg.readEntry("lastUsedColorsHeight", 16));
 
     ui->commonColorsShow->setChecked(cfg.readEntry("commonColorsShow", true));
     a = cfg.readEntry("commonColorsAlignment", false);
     ui->commonColorsAlignVertical->setChecked(a);
     ui->commonColorsAlignHorizontal->setChecked(!a);
     ui->commonColorsAllowScrolling->setChecked(cfg.readEntry("commonColorsScrolling", false));
     ui->commonColorsNumCols->setValue(cfg.readEntry("commonColorsNumCols", 1));
     ui->commonColorsNumRows->setValue(cfg.readEntry("commonColorsNumRows", 1));
     ui->commonColorsPatchCount->setValue(cfg.readEntry("commonColorsCount", 12));
     ui->commonColorsWidth->setValue(cfg.readEntry("commonColorsWidth", 16));
     ui->commonColorsHeight->setValue(cfg.readEntry("commonColorsHeight", 16));
     ui->commonColorsAutoUpdate->setChecked(cfg.readEntry("commonColorsAutoUpdate", false));
 
     //shade selector
     QString shadeSelectorType=cfg.readEntry("shadeSelectorType", "Minimal");
 
     if ( shadeSelectorType == "MyPaint") {
         ui->ACSShadeSelectorTypeComboBox->setCurrentIndex(0);
     } else if (shadeSelectorType == "Minimal") {
         ui->ACSShadeSelectorTypeComboBox->setCurrentIndex(1);
     } else {   // Hidden
         ui->ACSShadeSelectorTypeComboBox->setCurrentIndex(2);
     }
 
     ui->shadeSelectorUpdateOnRightClick->setChecked(cfg.readEntry("shadeSelectorUpdateOnRightClick", false));
     ui->shadeSelectorUpdateOnLeftClick->setChecked(cfg.readEntry("shadeSelectorUpdateOnLeftClick", false));
     ui->shadeSelectorUpdateOnForeground->setChecked(cfg.readEntry("shadeSelectorUpdateOnForeground", true));
     ui->shadeSelectorUpdateOnBackground->setChecked(cfg.readEntry("shadeSelectorUpdateOnBackground", true));
     ui->hidePopupOnClickCheck->setChecked(cfg.readEntry("hidePopupOnClickCheck", false));
 
     QString shadeMyPaintType = cfg.readEntry("shadeMyPaintType", "HSV");
 
     if (shadeMyPaintType == "HSV" ) {
         ui->ACSshadeSelectorMyPaintColorModelComboBox->setCurrentIndex(0);
     } else  if (shadeMyPaintType == "HSL" ) {
         ui->ACSshadeSelectorMyPaintColorModelComboBox->setCurrentIndex(1);
     } else  if (shadeMyPaintType == "HSI" ) {
         ui->ACSshadeSelectorMyPaintColorModelComboBox->setCurrentIndex(2);
     } else {   // HSY
         ui->ACSshadeSelectorMyPaintColorModelComboBox->setCurrentIndex(3);
     }
 
 
     bool asGradient = cfg.readEntry("minimalShadeSelectorAsGradient", true);
     if(asGradient) ui->minimalShadeSelectorAsGradient->setChecked(true);
     else ui->minimalShadeSelectorAsColorPatches->setChecked(true);
 
     ui->minimalShadeSelectorPatchesPerLine->setValue(cfg.readEntry("minimalShadeSelectorPatchCount", 10));
     ui->minimalShadeSelectorLineSettings->fromString(cfg.readEntry("minimalShadeSelectorLineConfig", "0|0.2|0|0|0|0|0;1|0|1|1|0|0|0;2|0|-1|1|0|0|0;"));
     ui->minimalShadeSelectorLineHeight->setValue(cfg.readEntry("minimalShadeSelectorLineHeight", 10));
 
     int hsxSettingType= (int)cfg.readEntry("hsxSettingType", 0);
     ui->colorSelectorTypeComboBox->setCurrentIndex(hsxSettingType);
 
 
     //color selector
     KisColorSelectorComboBox* cstw = dynamic_cast<KisColorSelectorComboBox*>(ui->colorSelectorConfiguration);
     cstw->setConfiguration(KisColorSelectorConfiguration::fromString(cfg.readEntry("colorSelectorConfiguration", "3|0|5|0"))); // triangle selector
 
     //luma values//
     ui->l_lumaR->setValue(cfg.readEntry("lumaR", 0.2126));
     ui->l_lumaG->setValue(cfg.readEntry("lumaG", 0.7152));
     ui->l_lumaB->setValue(cfg.readEntry("lumaB", 0.0722));
     ui->SP_Gamma->setValue(cfg.readEntry("gamma", 2.2));
 
     //color sliders//
     ui->csl_hsvH->setChecked(hsxcfg.readEntry("hsvH", false));
     ui->csl_hsvS->setChecked(hsxcfg.readEntry("hsvS", false));
     ui->csl_hsvV->setChecked(hsxcfg.readEntry("hsvV", false));
     ui->csl_hslH->setChecked(hsxcfg.readEntry("hslH", true));
     ui->csl_hslS->setChecked(hsxcfg.readEntry("hslS", true));
     ui->csl_hslL->setChecked(hsxcfg.readEntry("hslL", true));
     ui->csl_hsiH->setChecked(hsxcfg.readEntry("hsiH", false));
     ui->csl_hsiS->setChecked(hsxcfg.readEntry("hsiS", false));
     ui->csl_hsiI->setChecked(hsxcfg.readEntry("hsiI", false));
     ui->csl_hsyH->setChecked(hsxcfg.readEntry("hsyH", false));
     ui->csl_hsyS->setChecked(hsxcfg.readEntry("hsyS", false));
     ui->csl_hsyY->setChecked(hsxcfg.readEntry("hsyY", false));
 
     //hotkeys//
     ui->sb_lightness->setValue(hotkeycfg.readEntry("steps_lightness", 10));
     ui->sb_saturation->setValue(hotkeycfg.readEntry("steps_saturation", 10));
     ui->sb_hue->setValue(hotkeycfg.readEntry("steps_hue", 36));
     ui->sb_rg->setValue(hotkeycfg.readEntry("steps_redgreen", 10));
     ui->sb_by->setValue(hotkeycfg.readEntry("steps_blueyellow", 10));
 
 
 }
 
 void KisColorSelectorSettings::loadDefaultPreferences()
 {
     //set defaults
     //if you change something, don't forget that loadPreferences should be kept in sync
 
     // advanced color selector docker
     ui->dockerResizeOptionsComboBox->setCurrentIndex(0);
     ui->zoomSelectorOptionComboBox->setCurrentIndex(0);
     ui->popupSize->setValue(280);
 
 
     ui->useDifferentColorSpaceCheckbox->setChecked(false);
     ui->colorSpace->setCurrentColorModel(KoID("RGBA"));
     ui->colorSpace->setCurrentColorDepth(KoID("U8"));
     ui->colorSpace->setCurrentProfile(KoColorSpaceRegistry::instance()->rgb8()->profile()->name());
 
     //color patches
     ui->lastUsedColorsShow->setChecked(true);
     ui->lastUsedColorsAlignVertical->setChecked(true);
     ui->lastUsedColorsAlignHorizontal->setChecked(false);
     ui->lastUsedColorsAllowScrolling->setChecked(true);
     ui->lastUsedColorsNumCols->setValue(1);
     ui->lastUsedColorsNumRows->setValue(1);
     ui->lastUsedColorsPatchCount->setValue(20);
     ui->lastUsedColorsWidth->setValue(16);
     ui->lastUsedColorsHeight->setValue(16);
 
     ui->commonColorsShow->setChecked(true);
     ui->commonColorsAlignVertical->setChecked(false);
     ui->commonColorsAlignHorizontal->setChecked(true);
     ui->commonColorsAllowScrolling->setChecked(false);
     ui->commonColorsNumCols->setValue(1);
     ui->commonColorsNumRows->setValue(1);
     ui->commonColorsPatchCount->setValue(12);
     ui->commonColorsWidth->setValue(16);
     ui->commonColorsHeight->setValue(16);
     ui->commonColorsAutoUpdate->setChecked(false);
 
     //shade selector
     ui->ACSShadeSelectorTypeComboBox->setCurrentIndex(1); // Minimal
 
     ui->ACSshadeSelectorMyPaintColorModelComboBox->setCurrentIndex(0);
 
     ui->shadeSelectorUpdateOnRightClick->setChecked(false);
     ui->shadeSelectorUpdateOnLeftClick->setChecked(false);
     ui->shadeSelectorUpdateOnForeground->setChecked(true);
     ui->shadeSelectorUpdateOnBackground->setChecked(true);
 
     bool asGradient = true;
     if(asGradient) ui->minimalShadeSelectorAsGradient->setChecked(true);
     else ui->minimalShadeSelectorAsColorPatches->setChecked(true);
 
     ui->minimalShadeSelectorPatchesPerLine->setValue(10);
     ui->minimalShadeSelectorLineSettings->fromString("0|0.2|0|0|0|0|0;1|0|1|1|0|0|0;2|0|-1|1|0|0|0;");
     ui->minimalShadeSelectorLineHeight->setValue(10);
 
     // set advanced color selector to use HSV
     ui->colorSelectorTypeComboBox->setCurrentIndex(0);
 
     KisColorSelectorComboBox* cstw = dynamic_cast<KisColorSelectorComboBox*>(ui->colorSelectorConfiguration);
     cstw->setConfiguration(KisColorSelectorConfiguration("3|0|5|0")); // triangle selector
 
     //luma//
     ui->l_lumaR->setValue(0.2126);
     ui->l_lumaG->setValue(0.7152);
     ui->l_lumaB->setValue(0.0722);
     ui->SP_Gamma->setValue(2.2);
 
     //color sliders//
     ui->csl_hsvH->setChecked(false);
     ui->csl_hsvS->setChecked(false);
     ui->csl_hsvV->setChecked(false);
     ui->csl_hslH->setChecked(true);
     ui->csl_hslS->setChecked(true);
     ui->csl_hslL->setChecked(true);
     ui->csl_hsiH->setChecked(false);
     ui->csl_hsiS->setChecked(false);
     ui->csl_hsiI->setChecked(false);
     ui->csl_hsyH->setChecked(false);
     ui->csl_hsyS->setChecked(false);
     ui->csl_hsyY->setChecked(false);
 
     //hotkeys//
     ui->sb_lightness->setValue(10);
     ui->sb_saturation->setValue(10);
     ui->sb_hue->setValue(36);
     ui->sb_rg->setValue(10);
     ui->sb_by->setValue(10);
 
 }
 
 KisColorSelectorSettingsDialog::KisColorSelectorSettingsDialog(QWidget *parent) :
     QDialog(parent),
     m_widget(new KisColorSelectorSettings(this))
 {
     QLayout* l = new QVBoxLayout(this);
     l->addWidget(m_widget);
 
     m_widget->loadPreferences();
 
     QDialogButtonBox* buttonBox = new QDialogButtonBox(QDialogButtonBox::Ok|QDialogButtonBox::Cancel|QDialogButtonBox::RestoreDefaults,
                                                        Qt::Horizontal,
                                                        this);
     l->addWidget(buttonBox);
 
     connect(buttonBox, SIGNAL(accepted()), m_widget, SLOT(savePreferences()));
     connect(buttonBox, SIGNAL(accepted()), this,     SLOT(accept()));
     connect(buttonBox, SIGNAL(rejected()), this,     SLOT(reject()));
     connect(buttonBox->button(QDialogButtonBox::RestoreDefaults),
             SIGNAL(clicked()),  m_widget, SLOT(loadDefaultPreferences()));
 }
 
 
 
diff --git a/plugins/dockers/historydocker/HistoryDock.cpp b/plugins/dockers/historydocker/HistoryDock.cpp
index ce36a274cb..d174935fa4 100644
--- a/plugins/dockers/historydocker/HistoryDock.cpp
+++ b/plugins/dockers/historydocker/HistoryDock.cpp
@@ -1,84 +1,85 @@
 /* This file is part of the KDE project
  * Copyright (C) 2010 Matus Talcik <matus.talcik@gmail.com>
  *
  * This library is free software; you can redistribute it and/or
  * modify it under the terms of the GNU Library General Public
  * License as published by the Free Software Foundation; either
  * version 2 of the License, or (at your option) any later version.
  *
  * This library is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  * Library General Public License for more details.
  *
  * You should have received a copy of the GNU Library General Public License
  * along with this library; see the file COPYING.LIB.  If not, write to
  * the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
  * Boston, MA 02110-1301, USA.
  */
 
 #include "HistoryDock.h"
 #include <KoDocumentResourceManager.h>
 #include <kis_config.h>
 #include <kis_icon_utils.h>
 
 #include <QDebug>
 #include <QWidget>
 #include <QHBoxLayout>
 #include <QVBoxLayout>
 #include <QSpacerItem>
 
 #include <DlgConfigureHistoryDock.h>
 
 HistoryDock::HistoryDock()
     : QDockWidget()
     , m_historyCanvas(0)
 {
     QWidget *page = new QWidget(this);
     QVBoxLayout *vl = new QVBoxLayout(page);
     m_undoView = new KisUndoView(this);
     vl->addWidget(m_undoView);
-    QHBoxLayout *hl = new QHBoxLayout(page);
+    QHBoxLayout *hl = new QHBoxLayout();
     hl->addSpacerItem(new QSpacerItem(10, 1,  QSizePolicy::Expanding, QSizePolicy::Fixed));
     m_bnConfigure = new QToolButton(page);
     m_bnConfigure->setIcon(KisIconUtils::loadIcon("configure"));
     connect(m_bnConfigure, SIGNAL(clicked(bool)), SLOT(configure()));
     hl->addWidget(m_bnConfigure);
     vl->addItem(hl);
+    vl->addLayout(hl);
 
     setWidget(page);
     setWindowTitle(i18n("Undo History"));
 }
 
 void HistoryDock::setCanvas(KoCanvasBase *canvas)
 {
     setEnabled(canvas != 0);
     QPointer<KisCanvas2> myCanvas = dynamic_cast<KisCanvas2*>(canvas);
     if (myCanvas
             && myCanvas->shapeController()
             && myCanvas->shapeController()->resourceManager()
             && myCanvas->shapeController()->resourceManager()->undoStack()) {
         KUndo2Stack* undoStack = canvas->shapeController()->resourceManager()->undoStack();
 
         m_undoView->setStack(undoStack);
         KisConfig cfg;
         m_undoView->stack()->setUseCumulativeUndoRedo(cfg.useCumulativeUndoRedo());
         m_undoView->stack()->setTimeT1(cfg.stackT1());
         m_undoView->stack()->setTimeT2(cfg.stackT2());
         m_undoView->stack()->setStrokesN(cfg.stackN());
     }
     m_undoView->setCanvas( myCanvas );
 
 }
 void HistoryDock::configure()
 {
     DlgConfigureHistoryDock dlg(m_undoView, m_undoView->stack(), this);
     dlg.exec();
 }
 
 void HistoryDock::unsetCanvas()
 {
     m_historyCanvas = 0;
     setEnabled(false);
     m_undoView->setStack(0);
 }
diff --git a/plugins/extensions/colorspaceconversion/dlg_colorspaceconversion.cc b/plugins/extensions/colorspaceconversion/dlg_colorspaceconversion.cc
index 2598b6aeae..9382e2b9f9 100644
--- a/plugins/extensions/colorspaceconversion/dlg_colorspaceconversion.cc
+++ b/plugins/extensions/colorspaceconversion/dlg_colorspaceconversion.cc
@@ -1,98 +1,101 @@
 /*
  *  dlg_colorspaceconversion.cc - part of KimageShop^WKrayon^WKrita
  *
  *  Copyright (c) 2004 Boudewijn Rempt <boud@valdyas.org>
  *
  *  This program is free software; you can redistribute it and/or modify
  *  it under the terms of the GNU General Public License as published by
  *  the Free Software Foundation; either version 2 of the License, or
  *  (at your option) any later version.
  *
  *  This program is distributed in the hope that it will be useful,
  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  *  GNU General Public License for more details.
  *
  *  You should have received a copy of the GNU General Public License
  *  along with this program; if not, write to the Free Software
  *  Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
  */
 
 #include "dlg_colorspaceconversion.h"
 
 #include <QRadioButton>
 #include <QCheckBox>
 #include <QLabel>
 #include <QComboBox>
 #include <QList>
 
 #include <klocalizedstring.h>
 #include <kis_debug.h>
 
 #include "KoColorProfile.h"
 #include "KoColorSpace.h"
 #include "KoID.h"
 
 #include "widgets/kis_cmb_idlist.h"
 #include "widgets/squeezedcombobox.h"// TODO: add a label that would display if there isn't a good color conversion path (use KoColorConversionSystem::isGoodPath), all color spaces shiped with Calligra are expected to have a good path, but better warn the user in case
 
 DlgColorSpaceConversion::DlgColorSpaceConversion(QWidget *  parent,
         const char * name)
         : KoDialog(parent)
 {
     setButtons(Ok | Cancel);
     setDefaultButton(Ok);
     setObjectName(name);
     m_page = new WdgConvertColorSpace(this);
     Q_CHECK_PTR(m_page);
     m_page->setObjectName("colorspace_conversion");
 
     setMainWidget(m_page);
     resize(m_page->sizeHint());
 
     m_intentButtonGroup.addButton(m_page->radioAbsoluteColorimetric, KoColorConversionTransformation::IntentAbsoluteColorimetric);
     m_intentButtonGroup.addButton(m_page->radioPerceptual, KoColorConversionTransformation::IntentPerceptual);
     m_intentButtonGroup.addButton(m_page->radioRelativeColorimetric, KoColorConversionTransformation::IntentRelativeColorimetric);
     m_intentButtonGroup.addButton(m_page->radioSaturation, KoColorConversionTransformation::IntentSaturation);
 
     connect(this, SIGNAL(okClicked()),
             this, SLOT(okClicked()));
 
 
     connect(m_page->colorSpaceSelector, SIGNAL(selectionChanged(bool)), this, SLOT(selectionChanged(bool)));
 
 }
 
 
 
 DlgColorSpaceConversion::~DlgColorSpaceConversion()
 {
     delete m_page;
 }
 
 void DlgColorSpaceConversion::setInitialColorSpace(const KoColorSpace *cs)
 {
+    if (!cs) {
+        return;
+    }
     if (cs->profile()->getEstimatedTRC()[0]==1.0) {
     //this tries to automatically determine whether optimisations ought to be checked or not.
     //if the space you're converting from is linear TRC, uncheck.
         m_page->chkAllowLCMSOptimization->setCheckState(Qt::Unchecked);
     } else {
         m_page->chkAllowLCMSOptimization->setCheckState(Qt::Checked);
-    } 
+    }
     m_page->colorSpaceSelector->setCurrentColorSpace(cs);
 }
 
 void DlgColorSpaceConversion::selectionChanged(bool valid)
 {
     //TODO: Figure out how to uncheck when moving TO a linear TRC.
     Q_UNUSED(valid);
     enableButtonOk(m_page->colorSpaceSelector->currentColorSpace());
 }
 
 // SLOTS
 
 void DlgColorSpaceConversion::okClicked()
 {
     accept();
 }
 
diff --git a/plugins/extensions/imagesize/dlg_canvassize.cc b/plugins/extensions/imagesize/dlg_canvassize.cc
index af146bd26b..b394a041d9 100644
--- a/plugins/extensions/imagesize/dlg_canvassize.cc
+++ b/plugins/extensions/imagesize/dlg_canvassize.cc
@@ -1,705 +1,469 @@
 /*
  *
  *  Copyright (c) 2009 Edward Apap <schumifer@hotmail.com>
  *  Copyright (c) 2013 Juan Palacios <jpalaciosdev@gmail.com>
  *
  *  This program is free software; you can redistribute it and/or modify
  *  it under the terms of the GNU General Public License as published by
  *  the Free Software Foundation; either version 2 of the License, or
  *  (at your option) any later version.
  *
  *  This program is distributed in the hope that it will be useful,
  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  *  GNU General Public License for more details.
  *
  *  You should have received a copy of the GNU General Public License
  *  along with this program; if not, write to the Free Software
  *  Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
  */
 
 #include "dlg_canvassize.h"
 #include "kcanvaspreview.h"
 
 #include <KoUnit.h>
 #include <kis_icon.h>
 #include <kis_size_group.h>
 #include <klocalizedstring.h>
 
 #include <kis_config.h>
 
+#include <kis_document_aware_spin_box_unit_manager.h>
+
+#include <QComboBox>
+
 // used to extend KoUnit in comboboxes
 static const QString percentStr(i18n("Percent (%)"));
 
 DlgCanvasSize::DlgCanvasSize(QWidget *parent, int width, int height, double resolution)
-        : KoDialog(parent)
-        , m_keepAspect(true)
-        , m_aspectRatio((double)width / height)
-        , m_resolution(resolution)
-        , m_originalWidth(width)
-        , m_originalHeight(height)
-        , m_newWidth(width)
-        , m_newHeight(height)
-        , m_xOffset(0)
-        , m_yOffset(0)
+    : KoDialog(parent)
+    , m_keepAspect(true)
+    , m_aspectRatio((double)width / height)
+    , m_resolution(resolution)
+    , m_originalWidth(width)
+    , m_originalHeight(height)
+    , m_newWidth(width)
+    , m_newHeight(height)
+    , m_xOffset(0)
+    , m_yOffset(0)
 {
     setCaption(i18n("Resize Canvas"));
     setButtons(Ok | Cancel);
     setDefaultButton(Ok);
 
     m_page = new WdgCanvasSize(this);
     Q_CHECK_PTR(m_page);
     m_page->layout()->setMargin(0);
     m_page->setObjectName("canvas_size");
 
-    m_page->newWidth->setValue(width);
-    m_page->newWidth->setFocus();
-    m_page->newHeight->setValue(height);
+    _widthUnitManager = new KisDocumentAwareSpinBoxUnitManager(this);
+    _heightUnitManager = new KisDocumentAwareSpinBoxUnitManager(this, KisDocumentAwareSpinBoxUnitManager::PIX_DIR_Y);
+
+    _widthUnitManager->setApparentUnitFromSymbol("px");
+    _heightUnitManager->setApparentUnitFromSymbol("px");
+
+    m_page->newWidthDouble->setUnitManager(_widthUnitManager);
+    m_page->newHeightDouble->setUnitManager(_heightUnitManager);
+    m_page->newWidthDouble->setDecimals(2);
+    m_page->newHeightDouble->setDecimals(2);
+    m_page->newWidthDouble->setDisplayUnit(false);
+    m_page->newHeightDouble->setDisplayUnit(false);
 
-    m_page->newWidthDouble->setVisible(false);
-    m_page->newHeightDouble->setVisible(false);
+    m_page->newWidthDouble->setValue(width);
+    m_page->newWidthDouble->setFocus();
+    m_page->newHeightDouble->setValue(height);
 
-    m_page->widthUnit->addItems(KoUnit::listOfUnitNameForUi());
-    m_page->widthUnit->addItem(percentStr);
-    m_page->heightUnit->addItems(KoUnit::listOfUnitNameForUi());
-    m_page->heightUnit->addItem(percentStr);
+    m_page->widthUnit->setModel(_widthUnitManager);
+    m_page->heightUnit->setModel(_heightUnitManager);
 
-    const int pixelUnitIndex = KoUnit(KoUnit::Pixel).indexInListForUi();
+    const int pixelUnitIndex = _widthUnitManager->getsUnitSymbolList().indexOf("px"); //TODO: have a better way to identify units.
     m_page->widthUnit->setCurrentIndex(pixelUnitIndex);
     m_page->heightUnit->setCurrentIndex(pixelUnitIndex);
 
-    m_page->xOffsetDouble->setVisible(false);
-    m_page->yOffsetDouble->setVisible(false);
+    _xOffsetUnitManager = new KisDocumentAwareSpinBoxUnitManager(this);
+    _yOffsetUnitManager = new KisDocumentAwareSpinBoxUnitManager(this, KisDocumentAwareSpinBoxUnitManager::PIX_DIR_Y);
 
-    m_page->xOffUnit->addItems(KoUnit::listOfUnitNameForUi());
-    m_page->xOffUnit->addItem(percentStr);
-    m_page->yOffUnit->addItems(KoUnit::listOfUnitNameForUi());
-    m_page->yOffUnit->addItem(percentStr);
+    _xOffsetUnitManager->setApparentUnitFromSymbol("px");
+    _yOffsetUnitManager->setApparentUnitFromSymbol("px");
+
+    m_page->xOffsetDouble->setUnitManager(_xOffsetUnitManager);
+    m_page->yOffsetDouble->setUnitManager(_yOffsetUnitManager);
+    m_page->xOffsetDouble->setDecimals(2);
+    m_page->yOffsetDouble->setDecimals(2);
+    m_page->xOffsetDouble->setDisplayUnit(false);
+    m_page->yOffsetDouble->setDisplayUnit(false);
+
+    m_page->xOffUnit->setModel(_xOffsetUnitManager);
+    m_page->yOffUnit->setModel(_yOffsetUnitManager);
 
     m_page->xOffUnit->setCurrentIndex(pixelUnitIndex);
     m_page->yOffUnit->setCurrentIndex(pixelUnitIndex);
 
     m_page->canvasPreview->setImageSize(m_originalWidth, m_originalHeight);
     m_page->canvasPreview->setCanvasSize(m_originalWidth, m_originalHeight);
     m_page->canvasPreview->setImageOffset(m_xOffset, m_yOffset);
 
+    m_page->xOffsetDouble->changeValue(m_xOffset);
+    m_page->yOffsetDouble->changeValue(m_yOffset);
+
     KisConfig cfg;
 
     m_page->aspectRatioBtn->setKeepAspectRatio(cfg.readEntry("CanvasSize/KeepAspectRatio", false));
     m_page->constrainProportionsCkb->setChecked(cfg.readEntry("CanvasSize/ConstrainProportions", false));
     m_keepAspect = cfg.readEntry("CanvasSize/KeepAspectRatio", false);
 
 
     m_group = new QButtonGroup(m_page);
     m_group->addButton(m_page->topLeft, NORTH_WEST);
     m_group->addButton(m_page->topCenter, NORTH);
     m_group->addButton(m_page->topRight, NORTH_EAST);
 
     m_group->addButton(m_page->middleLeft, WEST);
     m_group->addButton(m_page->middleCenter, CENTER);
     m_group->addButton(m_page->middleRight, EAST);
 
     m_group->addButton(m_page->bottomLeft, SOUTH_WEST);
     m_group->addButton(m_page->bottomCenter, SOUTH);
     m_group->addButton(m_page->bottomRight, SOUTH_EAST);
 
     loadAnchorIcons();
     m_group->button(CENTER)->setChecked(true);
     updateAnchorIcons(CENTER);
 
     KisSizeGroup *labelsGroup = new KisSizeGroup(this);
     labelsGroup->addWidget(m_page->lblNewWidth);
     labelsGroup->addWidget(m_page->lblNewHeight);
     labelsGroup->addWidget(m_page->lblXOff);
     labelsGroup->addWidget(m_page->lblYOff);
     labelsGroup->addWidget(m_page->lblAnchor);
 
     KisSizeGroup *spinboxesGroup = new KisSizeGroup(this);
-    spinboxesGroup->addWidget(m_page->newWidth);
     spinboxesGroup->addWidget(m_page->newWidthDouble);
-    spinboxesGroup->addWidget(m_page->newHeight);
     spinboxesGroup->addWidget(m_page->newHeightDouble);
-    spinboxesGroup->addWidget(m_page->xOffset);
     spinboxesGroup->addWidget(m_page->xOffsetDouble);
-    spinboxesGroup->addWidget(m_page->yOffset);
     spinboxesGroup->addWidget(m_page->yOffsetDouble);
 
     KisSizeGroup *comboboxesGroup = new KisSizeGroup(this);
     comboboxesGroup->addWidget(m_page->widthUnit);
     comboboxesGroup->addWidget(m_page->heightUnit);
     comboboxesGroup->addWidget(m_page->xOffUnit);
     comboboxesGroup->addWidget(m_page->yOffUnit);
 
     setMainWidget(m_page);
     connect(this, SIGNAL(okClicked()), this, SLOT(accept()));
 
-    connect(m_page->newWidth, SIGNAL(valueChanged(int)), this, SLOT(slotWidthChanged(int)));
-    connect(m_page->newHeight, SIGNAL(valueChanged(int)), this, SLOT(slotHeightChanged(int)));
-    connect(m_page->newWidthDouble, SIGNAL(valueChanged(double)), this, SLOT(slotWidthChanged(double)));
-    connect(m_page->newHeightDouble, SIGNAL(valueChanged(double)), this, SLOT(slotHeightChanged(double)));
-    connect(m_page->widthUnit, SIGNAL(currentIndexChanged(int)), this, SLOT(slotWidthUnitChanged(int)));
-    connect(m_page->heightUnit, SIGNAL(currentIndexChanged(int)), this, SLOT(slotHeightUnitChanged(int)));
+    connect(m_page->newWidthDouble, SIGNAL(valueChangedPt(double)), this, SLOT(slotWidthChanged(double)));
+    connect(m_page->newHeightDouble, SIGNAL(valueChangedPt(double)), this, SLOT(slotHeightChanged(double)));
+    connect(m_page->widthUnit, SIGNAL(currentIndexChanged(int)), _widthUnitManager, SLOT(selectApparentUnitFromIndex(int)));
+    connect(m_page->heightUnit, SIGNAL(currentIndexChanged(int)), _heightUnitManager, SLOT(selectApparentUnitFromIndex(int)));
+    connect(_widthUnitManager, SIGNAL(unitChanged(int)), m_page->widthUnit, SLOT(setCurrentIndex(int)));
+    connect(_heightUnitManager, SIGNAL(unitChanged(int)), m_page->heightUnit, SLOT(setCurrentIndex(int)));
 
-    connect(m_page->xOffset, SIGNAL(valueChanged(int)), this, SLOT(slotXOffsetChanged(int)));
-    connect(m_page->yOffset, SIGNAL(valueChanged(int)), this, SLOT(slotYOffsetChanged(int)));
-    connect(m_page->xOffsetDouble, SIGNAL(valueChanged(double)), this, SLOT(slotXOffsetChanged(double)));
-    connect(m_page->yOffsetDouble, SIGNAL(valueChanged(double)), this, SLOT(slotYOffsetChanged(double)));
-    connect(m_page->xOffUnit, SIGNAL(currentIndexChanged(int)), this, SLOT(slotXOffsetUnitChanged(int)));
-    connect(m_page->yOffUnit, SIGNAL(currentIndexChanged(int)), this, SLOT(slotYOffsetUnitChanged(int)));
+    connect(m_page->xOffsetDouble, SIGNAL(valueChangedPt(double)), this, SLOT(slotXOffsetChanged(double)));
+    connect(m_page->yOffsetDouble, SIGNAL(valueChangedPt(double)), this, SLOT(slotYOffsetChanged(double)));
+    connect(m_page->xOffUnit, SIGNAL(currentIndexChanged(int)), _xOffsetUnitManager, SLOT(selectApparentUnitFromIndex(int)));
+    connect(m_page->yOffUnit, SIGNAL(currentIndexChanged(int)), _yOffsetUnitManager, SLOT(selectApparentUnitFromIndex(int)));
+    connect(_xOffsetUnitManager, SIGNAL(unitChanged(int)), m_page->xOffUnit, SLOT(setCurrentIndex(int)));
+    connect(_yOffsetUnitManager, SIGNAL(unitChanged(int)), m_page->yOffUnit, SLOT(setCurrentIndex(int)));
 
     connect(m_page->constrainProportionsCkb, SIGNAL(toggled(bool)), this, SLOT(slotAspectChanged(bool)));
     connect(m_page->aspectRatioBtn, SIGNAL(keepAspectRatioChanged(bool)), this, SLOT(slotAspectChanged(bool)));
-    connect(m_page->aspectRatioBtn, SIGNAL(keepAspectRatioChanged(bool)), this, SLOT(slotAspectChanged(bool)));
 
     connect(m_group, SIGNAL(buttonClicked(int)), SLOT(slotAnchorButtonClicked(int)));
     connect(m_page->canvasPreview, SIGNAL(sigModifiedXOffset(int)), this, SLOT(slotCanvasPreviewXOffsetChanged(int)));
     connect(m_page->canvasPreview, SIGNAL(sigModifiedYOffset(int)), this, SLOT(slotCanvasPreviewYOffsetChanged(int)));
 }
 
 DlgCanvasSize::~DlgCanvasSize()
 {
     KisConfig cfg;
     cfg.writeEntry<bool>("CanvasSize/KeepAspectRatio", m_page->aspectRatioBtn->keepAspectRatio());
     cfg.writeEntry<bool>("CanvasSize/ConstrainProportions", m_page->constrainProportionsCkb->isChecked());
 
     delete m_page;
 }
 
 qint32 DlgCanvasSize::width()
 {
-    return (qint32)m_newWidth;
+    return (qint32) m_newWidth;
 }
 
 qint32 DlgCanvasSize::height()
 {
-    return (qint32)m_newHeight;
+    return (qint32) m_newHeight;
 }
 
 qint32 DlgCanvasSize::xOffset()
 {
-    return (qint32)m_page->xOffset->value();
+    return (qint32) m_page->xOffsetDouble->value();
 }
 
 qint32 DlgCanvasSize::yOffset()
 {
-    return (qint32)m_page->yOffset->value();
+    return (qint32) m_page->yOffsetDouble->value();
 }
 
 void DlgCanvasSize::slotAspectChanged(bool keep)
 {
     m_page->aspectRatioBtn->blockSignals(true);
     m_page->constrainProportionsCkb->blockSignals(true);
 
     m_page->aspectRatioBtn->setKeepAspectRatio(keep);
     m_page->constrainProportionsCkb->setChecked(keep);
 
     m_page->aspectRatioBtn->blockSignals(false);
     m_page->constrainProportionsCkb->blockSignals(false);
 
     m_keepAspect = keep;
 
 
     if (keep) {
         // size values may be out of sync, so we need to reset it to defaults
         m_newWidth = m_originalWidth;
         m_newHeight = m_originalHeight;
         m_xOffset = 0;
         m_yOffset = 0;
 
-        updateWidthUIValue(m_newWidth);
-        updateHeightUIValue(m_newHeight);
-        updateXOffsetUIValue(m_xOffset);
-        updateYOffsetUIValue(m_yOffset);
-
         m_page->canvasPreview->blockSignals(true);
         m_page->canvasPreview->setCanvasSize(m_newWidth, m_newHeight);
         m_page->canvasPreview->setImageOffset(m_xOffset, m_yOffset);
         m_page->canvasPreview->blockSignals(false);
         updateOffset(CENTER);
         updateButtons(CENTER);
     }
 }
 
 void DlgCanvasSize::slotAnchorButtonClicked(int id)
 {
     updateOffset(id);
     updateButtons(id);
 }
 
-void DlgCanvasSize::slotWidthChanged(int v)
-{
-    slotWidthChanged((double) v);
-}
-
-void DlgCanvasSize::slotHeightChanged(int v)
-{
-    slotHeightChanged((double) v);
-}
-
 void DlgCanvasSize::slotWidthChanged(double v)
 {
-    if (m_page->widthUnit->currentText() == percentStr) {
-        m_newWidth = qRound((v * m_originalWidth) / 100.0);
-    } else {
-        const KoUnit selectedUnit = KoUnit::fromListForUi(m_page->widthUnit->currentIndex());
-        const double resValue = (selectedUnit == KoUnit(KoUnit::Pixel)) ? v : (v * m_resolution);
-        m_newWidth = qRound(selectedUnit.fromUserValue(resValue));
-    }
+    //this slot receiv values in pt from the unitspinbox, so just use the resolution.
+    const double resValue = v*_widthUnitManager->getConversionFactor(KisSpinBoxUnitManager::LENGTH, "px");
+    m_newWidth = qRound(resValue);
 
     if (m_keepAspect) {
         m_newHeight = qRound(m_newWidth / m_aspectRatio);
-        updateHeightUIValue(m_newHeight);
+        m_page->newHeightDouble->blockSignals(true);
+        m_page->newHeightDouble->changeValue(v / m_aspectRatio);
+        m_page->newHeightDouble->blockSignals(false);
     }
 
     int savedId = m_group->checkedId();
     m_page->canvasPreview->blockSignals(true);
     m_page->canvasPreview->setCanvasSize(m_newWidth, m_newHeight);
     m_page->canvasPreview->blockSignals(false);
     updateOffset(savedId);
     updateButtons(savedId);
 }
 
 void DlgCanvasSize::slotHeightChanged(double v)
 {
-    if (m_page->heightUnit->currentText() == percentStr) {
-        m_newHeight = qRound((v * m_originalHeight) / 100.0);
-    } else {
-        const KoUnit selectedUnit = KoUnit::fromListForUi(m_page->heightUnit->currentIndex());
-        const double resValue = (selectedUnit == KoUnit(KoUnit::Pixel)) ? v : (v * m_resolution);
-        m_newHeight = qRound(selectedUnit.fromUserValue(resValue));
-    }
+    //this slot receiv values in pt from the unitspinbox, so just use the resolution.
+    const double resValue = v*_heightUnitManager->getConversionFactor(KisSpinBoxUnitManager::LENGTH, "px");
+    m_newHeight = qRound(resValue);
 
     if (m_keepAspect) {
         m_newWidth = qRound(m_newHeight * m_aspectRatio);
-        updateWidthUIValue(m_newWidth);
+        m_page->newWidthDouble->blockSignals(true);
+        m_page->newWidthDouble->changeValue(v * m_aspectRatio);
+        m_page->newWidthDouble->blockSignals(false);
     }
 
     int savedId = m_group->checkedId();
     m_page->canvasPreview->blockSignals(true);
     m_page->canvasPreview->setCanvasSize(m_newWidth, m_newHeight);
     m_page->canvasPreview->blockSignals(false);
     updateOffset(savedId);
     updateButtons(savedId);
 }
 
-void DlgCanvasSize::slotWidthUnitChanged(int index)
-{
-    updateWidthUIValue(m_newWidth);
-
-    if (m_page->widthUnit->currentText() == percentStr) {
-        m_page->newWidth->setVisible(false);
-        m_page->newWidthDouble->setVisible(true);
-    } else {
-        const KoUnit selectedUnit = KoUnit::fromListForUi(index);
-        if (selectedUnit != KoUnit(KoUnit::Pixel)) {
-            m_page->newWidth->setVisible(false);
-            m_page->newWidthDouble->setVisible(true);
-        } else {
-            m_page->newWidth->setVisible(true);
-            m_page->newWidthDouble->setVisible(false);
-        }
-    }
-}
-
-void DlgCanvasSize::slotHeightUnitChanged(int index)
-{
-    updateHeightUIValue(m_newHeight);
-
-    if (m_page->heightUnit->currentText() == percentStr) {
-        m_page->newHeight->setVisible(false);
-        m_page->newHeightDouble->setVisible(true);
-    } else {
-        const KoUnit selectedUnit = KoUnit::fromListForUi(index);
-        if (selectedUnit != KoUnit(KoUnit::Pixel)) {
-            m_page->newHeight->setVisible(false);
-            m_page->newHeightDouble->setVisible(true);
-        } else {
-            m_page->newHeight->setVisible(true);
-            m_page->newHeightDouble->setVisible(false);
-        }
-    }
-}
-
-void DlgCanvasSize::slotXOffsetChanged(int v)
-{
-    slotXOffsetChanged((double) v);
-}
-
-void DlgCanvasSize::slotYOffsetChanged(int v)
-{
-    slotYOffsetChanged((double) v);
-}
-
 void DlgCanvasSize::slotXOffsetChanged(double v)
 {
-    if (m_page->xOffUnit->currentText() == percentStr) {
-        m_xOffset = qRound((v * m_newWidth) / 100.0);
-    } else {
-        const KoUnit selectedUnit = KoUnit::fromListForUi(m_page->xOffUnit->currentIndex());
-        const double resValue = (selectedUnit == KoUnit(KoUnit::Pixel)) ? v : (v * m_resolution);
-        m_xOffset = qRound(selectedUnit.fromUserValue(resValue));
-    }
+    //this slot receiv values in pt from the unitspinbox, so just use the resolution.
+    const double resValue = v*_xOffsetUnitManager->getConversionFactor(KisSpinBoxUnitManager::LENGTH, "px");
+    m_xOffset = qRound(resValue);
 
     m_page->canvasPreview->blockSignals(true);
     m_page->canvasPreview->setImageOffset(m_xOffset, m_yOffset);
     m_page->canvasPreview->blockSignals(false);
 
     updateButtons(-1);
 }
 
 void DlgCanvasSize::slotYOffsetChanged(double v)
 {
-    if (m_page->yOffUnit->currentText() == percentStr) {
-        m_yOffset = qRound((v * m_newHeight) / 100.0);
-    } else {
-        const KoUnit selectedUnit = KoUnit::fromListForUi(m_page->yOffUnit->currentIndex());
-        const double resValue = (selectedUnit == KoUnit(KoUnit::Pixel)) ? v : (v * m_resolution);
-        m_yOffset = qRound(selectedUnit.fromUserValue(resValue));
-    }
+    //this slot receiv values in pt from the unitspinbox, so just use the resolution.
+    const double resValue = v*_xOffsetUnitManager->getConversionFactor(KisSpinBoxUnitManager::LENGTH, "px");
+    m_yOffset = qRound(resValue);
+
 
     m_page->canvasPreview->blockSignals(true);
     m_page->canvasPreview->setImageOffset(m_xOffset, m_yOffset);
     m_page->canvasPreview->blockSignals(false);
 
     updateButtons(-1);
 }
 
-void DlgCanvasSize::slotXOffsetUnitChanged(int index)
-{
-    updateXOffsetUIValue(m_xOffset);
-
-    if (m_page->xOffUnit->currentText() == percentStr) {
-        m_page->xOffset->setVisible(false);
-        m_page->xOffsetDouble->setVisible(true);
-    } else {
-        const KoUnit selectedUnit = KoUnit::fromListForUi(index);
-        if (selectedUnit != KoUnit(KoUnit::Pixel)) {
-            m_page->xOffset->setVisible(false);
-            m_page->xOffsetDouble->setVisible(true);
-        } else {
-            m_page->xOffset->setVisible(true);
-            m_page->xOffsetDouble->setVisible(false);
-        }
-    }
-}
-
-void DlgCanvasSize::slotYOffsetUnitChanged(int index)
-{
-    updateYOffsetUIValue(m_yOffset);
-
-    if (m_page->yOffUnit->currentText() == percentStr) {
-        m_page->yOffset->setVisible(false);
-        m_page->yOffsetDouble->setVisible(true);
-    } else {
-        const KoUnit selectedUnit = KoUnit::fromListForUi(index);
-        if (selectedUnit != KoUnit(KoUnit::Pixel)) {
-            m_page->yOffset->setVisible(false);
-            m_page->yOffsetDouble->setVisible(true);
-        } else {
-            m_page->yOffset->setVisible(true);
-            m_page->yOffsetDouble->setVisible(false);
-        }
-    }
-}
-
 void DlgCanvasSize::slotCanvasPreviewXOffsetChanged(int v)
 {
-    // Convert input value to selected x offset unit.
-    // This will be undone later in slotXOffsetChanged (through spinboxes valueChanged signal).
-    if (m_page->xOffUnit->currentText() == percentStr) {
-        m_page->xOffsetDouble->setValue((v * 100.0) / m_newWidth);
-    } else {
-        const KoUnit pixelUnit(KoUnit::Pixel);
-        const KoUnit selectedUnit = KoUnit::fromListForUi(m_page->xOffUnit->currentIndex());
-        //const double convertedValue = xOffsetUnit.convertFromUnitToUnit(v, pixelUnit, xOffsetUnit);
-
-        if (selectedUnit != pixelUnit) {
-            m_page->xOffsetDouble->setValue(selectedUnit.toUserValue(v / m_resolution));
-        } else {
-            m_page->xOffset->setValue(v);
-        }
-    }
+    double newVal = v / _xOffsetUnitManager->getConversionFactor(KisSpinBoxUnitManager::LENGTH, "px");
+    m_page->xOffsetDouble->changeValue(newVal);
 }
 
 void DlgCanvasSize::slotCanvasPreviewYOffsetChanged(int v)
 {
-    // Convert input value to selected y offset unit.
-    // This will be undone later in slotYOffsetChanged (through spinboxes valueChanged signal).
-    if (m_page->yOffUnit->currentText() == percentStr) {
-        m_page->yOffsetDouble->setValue((v * 100.0) / m_newHeight);
-    } else {
-        const KoUnit pixelUnit(KoUnit::Pixel);
-        const KoUnit selectedUnit = KoUnit::fromListForUi(m_page->yOffUnit->currentIndex());
-        //const double convertedValue = yOffsetUnit.convertFromUnitToUnit(v, pixelUnit, yOffsetUnit);
 
-        if (selectedUnit != pixelUnit) {
-            m_page->yOffsetDouble->setValue(selectedUnit.toUserValue(v / m_resolution));
-        } else {
-            m_page->yOffset->setValue(v);
-        }
-    }
-}
-
-void DlgCanvasSize::updateWidthUIValue(double value)
-{
-    if (m_page->widthUnit->currentText() == percentStr) {
-        m_page->newWidthDouble->blockSignals(true);
-        m_page->newWidthDouble->setValue((value * 100.0) / m_originalWidth);
-        m_page->newWidthDouble->blockSignals(false);
-    } else {
-        const KoUnit selectedUnit = KoUnit::fromListForUi(m_page->widthUnit->currentIndex());
-        if (selectedUnit != KoUnit(KoUnit::Pixel)) {
-            m_page->newWidthDouble->blockSignals(true);
-            m_page->newWidthDouble->setValue(selectedUnit.toUserValue(value / m_resolution));
-            m_page->newWidthDouble->blockSignals(false);
-        } else {
-            m_page->newWidth->blockSignals(true);
-            m_page->newWidth->setValue(selectedUnit.toUserValue(value));
-            m_page->newWidth->blockSignals(false);
-        }
-    }
-}
-
-void DlgCanvasSize::updateHeightUIValue(double value)
-{
-    if (m_page->heightUnit->currentText() == percentStr) {
-        m_page->newHeightDouble->blockSignals(true);
-        m_page->newHeightDouble->setValue((value * 100.0) / m_originalHeight);
-        m_page->newHeightDouble->blockSignals(false);
-    } else {
-        const KoUnit selectedUnit = KoUnit::fromListForUi(m_page->heightUnit->currentIndex());
-        if (selectedUnit != KoUnit(KoUnit::Pixel)) {
-            m_page->newHeightDouble->blockSignals(true);
-            m_page->newHeightDouble->setValue(selectedUnit.toUserValue(value / m_resolution));
-            m_page->newHeightDouble->blockSignals(false);
-        } else {
-            m_page->newHeight->blockSignals(true);
-            m_page->newHeight->setValue(selectedUnit.toUserValue(value));
-            m_page->newHeight->blockSignals(false);
-        }
-    }
-}
-
-void DlgCanvasSize::updateXOffsetUIValue(double value)
-{
-    if (m_page->xOffUnit->currentText() == percentStr) {
-        m_page->xOffsetDouble->blockSignals(true);
-        m_page->xOffsetDouble->setValue((value * 100.0) / m_newWidth);
-        m_page->xOffsetDouble->blockSignals(false);
-    } else {
-        const KoUnit selectedUnit = KoUnit::fromListForUi(m_page->xOffUnit->currentIndex());
-        if (selectedUnit != KoUnit(KoUnit::Pixel)) {
-            m_page->xOffsetDouble->blockSignals(true);
-            m_page->xOffsetDouble->setValue(selectedUnit.toUserValue(value / m_resolution));
-            m_page->xOffsetDouble->blockSignals(false);
-        } else {
-            m_page->xOffset->blockSignals(true);
-            m_page->xOffset->setValue(qRound(selectedUnit.toUserValue(value)));
-            m_page->xOffset->blockSignals(false);
-        }
-    }
-}
-
-void DlgCanvasSize::updateYOffsetUIValue(double value)
-{
-    if (m_page->yOffUnit->currentText() == percentStr) {
-        m_page->yOffsetDouble->blockSignals(true);
-        m_page->yOffsetDouble->setValue((value * 100.0) / m_newHeight);
-        m_page->yOffsetDouble->blockSignals(false);
-    } else {
-        const KoUnit selectedUnit = KoUnit::fromListForUi(m_page->yOffUnit->currentIndex());
-        if (selectedUnit != KoUnit(KoUnit::Pixel)) {
-            m_page->yOffsetDouble->blockSignals(true);
-            m_page->yOffsetDouble->setValue(selectedUnit.toUserValue(value / m_resolution));
-            m_page->yOffsetDouble->blockSignals(false);
-        } else {
-            m_page->yOffset->blockSignals(true);
-            m_page->yOffset->setValue(qRound(selectedUnit.toUserValue(value)));
-            m_page->yOffset->blockSignals(false);
-        }
-    }
+    double newVal = v / _yOffsetUnitManager->getConversionFactor(KisSpinBoxUnitManager::LENGTH, "px");
+    m_page->yOffsetDouble->changeValue(newVal);
 }
 
 void DlgCanvasSize::loadAnchorIcons()
 {
 
     m_anchorIcons[NORTH_WEST] =  KisIconUtils::loadIcon("arrow-topleft");
     m_anchorIcons[NORTH] = KisIconUtils::loadIcon("arrow-up");
     m_anchorIcons[NORTH_EAST] = KisIconUtils::loadIcon("arrow-topright");
     m_anchorIcons[EAST] = KisIconUtils::loadIcon("arrow-right");
     m_anchorIcons[CENTER] = KisIconUtils::loadIcon("arrow_center");
     m_anchorIcons[WEST] = KisIconUtils::loadIcon("arrow-left");
     m_anchorIcons[SOUTH_WEST] = KisIconUtils::loadIcon("arrow-downleft");
     m_anchorIcons[SOUTH] = KisIconUtils::loadIcon("arrow-down");
     m_anchorIcons[SOUTH_EAST] = KisIconUtils::loadIcon("arrow-downright");
 
 }
 
 void DlgCanvasSize::updateAnchorIcons(int id)
 {
     anchor iconLayout[10][9] = {
         {NONE, EAST,  NONE, SOUTH, SOUTH_EAST, NONE, NONE, NONE, NONE},
         {WEST, NONE, EAST, SOUTH_WEST, SOUTH, SOUTH_EAST, NONE, NONE, NONE},
         {NONE, WEST, NONE, NONE, SOUTH_WEST, SOUTH, NONE, NONE, NONE},
         {NORTH, NORTH_EAST, NONE, NONE, EAST, NONE, SOUTH, SOUTH_EAST, NONE},
         {NORTH_WEST, NORTH, NORTH_EAST, WEST, NONE, EAST, SOUTH_WEST, SOUTH, SOUTH_EAST},
         {NONE, NORTH_WEST, NORTH, NONE, WEST, NONE, NONE, SOUTH_WEST, SOUTH},
         {NONE, NONE, NONE, NORTH, NORTH_EAST, NONE, NONE, EAST, NONE},
         {NONE, NONE, NONE, NORTH_WEST, NORTH, NORTH_EAST, WEST, NONE, EAST},
         {NONE, NONE, NONE, NONE, NORTH_WEST, NORTH, NONE, WEST, NONE},
         {NONE, NONE, NONE, NONE, NONE, NONE, NONE, NONE, NONE}
     };
 
     if (id == -1) {
         id = SOUTH_EAST + 1;
     }
 
     // we are going to swap arrows direction based on width and height shrinking
     bool shrinkWidth = (m_newWidth < m_originalWidth) ? true : false;
     bool shrinkHeight = (m_newHeight < m_originalHeight) ? true : false;
 
     for (int i = NORTH_WEST; i <= SOUTH_EAST; i++) {
         anchor iconId = iconLayout[id][i];
 
         // all corner arrows represents shrinking in some direction
         if (shrinkWidth || shrinkHeight) {
             switch (iconId) {
             case NORTH_WEST: iconId = SOUTH_EAST; break;
             case NORTH_EAST: iconId = SOUTH_WEST; break;
             case SOUTH_WEST: iconId = NORTH_EAST; break;
             case SOUTH_EAST: iconId = NORTH_WEST; break;
             default: break;
             }
         }
 
         if (shrinkWidth) {
             switch (iconId) {
             case WEST: iconId = EAST; break;
             case EAST: iconId = WEST; break;
             default: break;
             }
         }
 
         if (shrinkHeight) {
             switch (iconId) {
             case NORTH: iconId = SOUTH; break;
             case SOUTH: iconId = NORTH; break;
             default: break;
             }
         }
 
         QAbstractButton *button = m_group->button(i);
 
         if (iconId == NONE) {
             button->setIcon(QIcon());
         } else {
             button->setIcon(m_anchorIcons[iconId]);
         }
     }
 
 }
 
 void DlgCanvasSize::updateButtons(int forceId)
 {
     int id = m_group->checkedId();
 
     if (forceId != -1) {
         m_group->setExclusive(true);
         m_group->button(forceId)->setChecked(true);
         updateAnchorIcons(forceId);
     } else if (id != -1) {
         double xOffset, yOffset;
         expectedOffset(id, xOffset, yOffset);
 
         // convert values to internal unit
         int internalXOffset = 0;
         int internalYOffset = 0;
         if (m_page->xOffUnit->currentText() == percentStr) {
             internalXOffset = qRound((xOffset * m_newWidth) / 100.0);
             internalYOffset = qRound((yOffset * m_newHeight) / 100.0);
         } else {
             const KoUnit xOffsetUnit = KoUnit::fromListForUi(m_page->xOffUnit->currentIndex());
             internalXOffset = qRound(xOffsetUnit.fromUserValue(xOffset));
             const KoUnit yOffsetUnit = KoUnit::fromListForUi(m_page->yOffUnit->currentIndex());
             internalYOffset = qRound(yOffsetUnit.fromUserValue(yOffset));
         }
 
         bool offsetAsExpected =
-            internalXOffset == m_xOffset &&
-            internalYOffset == m_yOffset;
+                internalXOffset == m_xOffset &&
+                internalYOffset == m_yOffset;
 
         if (offsetAsExpected) {
             m_group->setExclusive(true);
         } else {
             m_group->setExclusive(false);
             m_group->button(id)->setChecked(false);
             id = -1;
         }
 
         updateAnchorIcons(id);
     } else {
         updateAnchorIcons(id);
     }
 }
 
 void DlgCanvasSize::updateOffset(int id)
 {
     if (id == -1) return;
 
     double xOffset;
     double yOffset;
     expectedOffset(id, xOffset, yOffset);
 
-    const KoUnit pixelUnit(KoUnit::Pixel);
-
-    // update spinbox value (other widgets will be autoupdated later through valueChanged signal)
-    if (m_page->xOffUnit->currentText() == percentStr) {
-        m_page->xOffsetDouble->setValue(xOffset);
-    } else {
-        const KoUnit selectedUnit = KoUnit::fromListForUi(m_page->xOffUnit->currentIndex());
-        if (pixelUnit != selectedUnit) {
-            m_page->xOffsetDouble->setValue(xOffset);
-        } else {
-            m_page->xOffset->setValue(qRound(xOffset));
-        }
-    }
-
-    // update spinbox value (other widgets will be autoupdated later through valueChanged signal)
-    if (m_page->yOffUnit->currentText() == percentStr) {
-        m_page->yOffsetDouble->setValue(yOffset);
-    } else {
-        const KoUnit selectedUnit = KoUnit::fromListForUi(m_page->yOffUnit->currentIndex());
-        if (pixelUnit != selectedUnit) {
-            m_page->yOffsetDouble->setValue(yOffset);
-        } else {
-            m_page->yOffset->setValue(qRound(yOffset));
-        }
-    }
+    m_page->xOffsetDouble->changeValue(xOffset);
+    m_page->yOffsetDouble->changeValue(yOffset);
 }
 
 void DlgCanvasSize::expectedOffset(int id, double &xOffset, double &yOffset)
 {
     const double xCoeff = (id % 3) * 0.5;
     const double yCoeff = (id / 3) * 0.5;
 
     const int xDiff = m_newWidth - m_originalWidth;
     const int yDiff = m_newHeight - m_originalHeight;
 
-    // use selected unit to convert expected values (the inverse will be do later)
-    // so output values are now considered as if they were regular user input
-    if (m_page->xOffUnit->currentText() == percentStr) {
-        xOffset = (xDiff * xCoeff * 100.0) / m_newWidth;
-    } else {
-        const KoUnit selectedUnit = KoUnit::fromListForUi(m_page->xOffUnit->currentIndex());
-        const double resXDiff = (selectedUnit != KoUnit(KoUnit::Pixel)) ? xDiff / m_resolution : xDiff;
-        xOffset = selectedUnit.toUserValue(resXDiff * xCoeff);
-    }
-
-    if (m_page->yOffUnit->currentText() == percentStr) {
-        yOffset = (yDiff * yCoeff * 100.0) / m_newHeight;
-    } else {
-        const KoUnit selectedUnit = KoUnit::fromListForUi(m_page->yOffUnit->currentIndex());
-        const double resYDiff = (selectedUnit != KoUnit(KoUnit::Pixel)) ? yDiff / m_resolution : yDiff;
-        yOffset = selectedUnit.toUserValue(resYDiff * yCoeff);
-    }
+    //convert to unitmanager default unit.
+    xOffset = xDiff * xCoeff / _xOffsetUnitManager->getConversionFactor(KisSpinBoxUnitManager::LENGTH, "px");
+    yOffset = yDiff * yCoeff / _yOffsetUnitManager->getConversionFactor(KisSpinBoxUnitManager::LENGTH, "px");
 }
diff --git a/plugins/extensions/imagesize/dlg_canvassize.h b/plugins/extensions/imagesize/dlg_canvassize.h
index 9b2ea69641..91ea435bed 100644
--- a/plugins/extensions/imagesize/dlg_canvassize.h
+++ b/plugins/extensions/imagesize/dlg_canvassize.h
@@ -1,106 +1,100 @@
 /*
  *
  *  Copyright (c) 2009 Edward Apap <schumifer@hotmail.com>
  *  Copyright (c) 2013 Juan Palacios <jpalaciosdev@gmail.com>
  *
  *  This program is free software; you can redistribute it and/or modify
  *  it under the terms of the GNU General Public License as published by
  *  the Free Software Foundation; either version 2 of the License, or
  *  (at your option) any later version.
  *
  *  This program is distributed in the hope that it will be useful,
  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  *  GNU General Public License for more details.
  *
  *  You should have received a copy of the GNU General Public License
  *  along with this program; if not, write to the Free Software
  *  Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
  */
 
 #ifndef DLG_CANVASSIZE
 #define DLG_CANVASSIZE
 
 #include <KoDialog.h>
 #include <QIcon>
 
 
 #include "ui_wdg_canvassize.h"
 
+class KisDocumentAwareSpinBoxUnitManager;
+
 class WdgCanvasSize : public QWidget, public Ui::WdgCanvasSize
 {
     Q_OBJECT
 
 public:
     WdgCanvasSize(QWidget *parent) : QWidget(parent) {
         setupUi(this);
     }
 };
 
 
 
 class DlgCanvasSize: public KoDialog
 {
 
     Q_OBJECT
 
 public:
     enum anchor { NORTH_WEST = 0, NORTH, NORTH_EAST, WEST, CENTER, EAST, SOUTH_WEST, SOUTH, SOUTH_EAST, NONE};
 
     DlgCanvasSize(QWidget * parent, int width, int height, double resolution);
     ~DlgCanvasSize();
 
     qint32 width();
     qint32 height();
     qint32 xOffset();
     qint32 yOffset();
 
 private Q_SLOTS:
     void slotAspectChanged(bool keep);
     void slotAnchorButtonClicked(int id);
 
-    void slotWidthChanged(int v);
-    void slotHeightChanged(int v);
     void slotWidthChanged(double v);
     void slotHeightChanged(double v);
 
-    void slotWidthUnitChanged(int index);
-    void slotHeightUnitChanged(int index);
-
-    void slotXOffsetChanged(int v);
-    void slotYOffsetChanged(int v);
     void slotXOffsetChanged(double v);
     void slotYOffsetChanged(double v);
 
-    void slotXOffsetUnitChanged(int index);
-    void slotYOffsetUnitChanged(int index);
-
     void slotCanvasPreviewXOffsetChanged(int v);
     void slotCanvasPreviewYOffsetChanged(int v);
 
 private:
-    void updateWidthUIValue(double value);
-    void updateHeightUIValue(double value);
-    void updateXOffsetUIValue(double value);
-    void updateYOffsetUIValue(double value);
 
     void loadAnchorIcons();
     void updateAnchorIcons(int id);
     void updateButtons(int forceId);
     void updateOffset(int id);
     void expectedOffset(int id, double &xOffset, double &yOffset);
 
     bool m_keepAspect;
     const double m_aspectRatio;
     const double m_resolution;
     const int m_originalWidth, m_originalHeight;
     int m_newWidth, m_newHeight;
     int m_xOffset, m_yOffset;
 
     WdgCanvasSize * m_page;
     QIcon m_anchorIcons[9];
     QButtonGroup *m_group;
+
+    KisDocumentAwareSpinBoxUnitManager* _widthUnitManager;
+    KisDocumentAwareSpinBoxUnitManager* _heightUnitManager;
+
+    KisDocumentAwareSpinBoxUnitManager* _xOffsetUnitManager;
+    KisDocumentAwareSpinBoxUnitManager* _yOffsetUnitManager;
 };
 
 
 #endif // DLG_CANVASSIZE
diff --git a/plugins/extensions/imagesize/dlg_imagesize.cc b/plugins/extensions/imagesize/dlg_imagesize.cc
index 1d38c57bdc..846c7fa66b 100644
--- a/plugins/extensions/imagesize/dlg_imagesize.cc
+++ b/plugins/extensions/imagesize/dlg_imagesize.cc
@@ -1,493 +1,422 @@
 /*
  *  dlg_imagesize.cc - part of KimageShop^WKrayon^WKrita
  *
  *  Copyright (c) 2004 Boudewijn Rempt <boud@valdyas.org>
  *  Copyright (c) 2009 C. Boemann <cbo@boemann.dk>
  *  Copyright (c) 2013 Juan Palacios <jpalaciosdev@gmail.com>
  *
  *  This program is free software; you can redistribute it and/or modify
  *  it under the terms of the GNU General Public License as published by
  *  the Free Software Foundation; either version 2 of the License, or
  *  (at your option) any later version.
  *
  *  This program is distributed in the hope that it will be useful,
  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  *  GNU General Public License for more details.
  *
  *  You should have received a copy of the GNU General Public License
  *  along with this program; if not, write to the Free Software
  *  Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
  */
 
 #include "dlg_imagesize.h"
 
 #include <QLocale>
 
 #include <KoUnit.h>
 #include <kis_size_group.h>
 #include <klocalizedstring.h>
 
 
 #include <kis_filter_strategy.h>
 
+#include "kis_double_parse_unit_spin_box.h"
+#include "kis_document_aware_spin_box_unit_manager.h"
+
 static const QString pixelStr(KoUnit::unitDescription(KoUnit::Pixel));
 static const QString percentStr(i18n("Percent (%)"));
 static const QString pixelsInchStr(i18n("Pixels/Inch"));
 static const QString pixelsCentimeterStr(i18n("Pixels/Centimeter"));
 
 DlgImageSize::DlgImageSize(QWidget *parent, int width, int height, double resolution)
     : KoDialog(parent)
     , m_aspectRatio(((double) width) / height)
     , m_originalWidth(width)
     , m_originalHeight(height)
     , m_width(width)
     , m_height(height)
     , m_printWidth(width / resolution)
     , m_printHeight(height / resolution)
     , m_originalResolution(resolution)
     , m_resolution(resolution)
     , m_keepAspect(true)
 {
     setCaption(i18n("Scale To New Size"));
     setButtons(Ok | Cancel);
     setDefaultButton(Ok);
 
     m_page = new WdgImageSize(this);
 
     Q_CHECK_PTR(m_page);
     m_page->layout()->setMargin(0);
     m_page->setObjectName("image_size");
 
-    m_page->pixelWidth->setValue(width);
-    m_page->pixelWidth->setFocus();
-    m_page->pixelHeight->setValue(height);
+    _widthUnitManager = new KisDocumentAwareSpinBoxUnitManager(this);
+    _heightUnitManager = new KisDocumentAwareSpinBoxUnitManager(this, KisDocumentAwareSpinBoxUnitManager::PIX_DIR_Y);
+
+    //configure the unit to image length, default unit is pixel and printing units are forbiden.
+    _widthUnitManager->setUnitDimension(KisSpinBoxUnitManager::IMLENGTH);
+    _heightUnitManager->setUnitDimension(KisSpinBoxUnitManager::IMLENGTH);
+
+    m_page->pixelWidthDouble->setUnitManager(_widthUnitManager);
+    m_page->pixelHeightDouble->setUnitManager(_heightUnitManager);
+
+    m_page->pixelWidthDouble->changeValue(width);
+    m_page->pixelHeightDouble->changeValue(height);
+    m_page->pixelWidthDouble->setDecimals(2);
+    m_page->pixelHeightDouble->setDecimals(2);
+    m_page->pixelWidthDouble->setDisplayUnit(false);
+    m_page->pixelHeightDouble->setDisplayUnit(false);
 
-    m_page->pixelWidthDouble->setVisible(false);
-    m_page->pixelHeightDouble->setVisible(false);
+    m_page->pixelWidthUnit->setModel(_widthUnitManager);
+    m_page->pixelHeightUnit->setModel(_widthUnitManager);
+    m_page->pixelWidthUnit->setCurrentText("px");
+    m_page->pixelHeightUnit->setCurrentText("px");
 
     m_page->pixelFilterCmb->setIDList(KisFilterStrategyRegistry::instance()->listKeys());
     m_page->pixelFilterCmb->setToolTip(KisFilterStrategyRegistry::instance()->formatedDescriptions());
     m_page->pixelFilterCmb->setCurrent("Bicubic");
 
-    m_page->pixelWidthUnit->addItem(pixelStr);
-    m_page->pixelWidthUnit->addItem(percentStr);
-    m_page->pixelWidthUnit->setCurrentIndex(0);
+    _printWidthUnitManager = new KisSpinBoxUnitManager(this);
+    _printHeightUnitManager = new KisSpinBoxUnitManager(this);
 
-    m_page->pixelHeightUnit->addItem(pixelStr);
-    m_page->pixelHeightUnit->addItem(percentStr);
-    m_page->pixelHeightUnit->setCurrentIndex(0);
+    m_page->printWidth->setUnitManager(_printWidthUnitManager);
+    m_page->printHeight->setUnitManager(_printHeightUnitManager);
+    m_page->printWidth->setDecimals(2);
+    m_page->printHeight->setDecimals(2);
+    m_page->printWidth->setDisplayUnit(false);
+    m_page->printHeight->setDisplayUnit(false);
+    m_page->printResolution->setDecimals(2);
+    m_page->printResolution->setAlignment(Qt::AlignRight);
 
-    m_page->printWidthUnit->addItems(KoUnit::listOfUnitNameForUi(KoUnit::HidePixel));
-    m_page->printWidthUnit->addItem(percentStr);
-    m_page->printHeightUnit->addItems(KoUnit::listOfUnitNameForUi(KoUnit::HidePixel));
-    m_page->printHeightUnit->addItem(percentStr);
+    m_page->printWidthUnit->setModel(_printWidthUnitManager);
+    m_page->printHeightUnit->setModel(_printHeightUnitManager);
 
+    m_page->printWidth->changeValue(m_printWidth);
+    m_page->printHeight->changeValue(m_printHeight);
+
+    //TODO: create a resolution dimension in the unit manager.
     m_page->printResolutionUnit->addItem(pixelsInchStr);
     m_page->printResolutionUnit->addItem(pixelsCentimeterStr);
 
-    // pick selected print units from user locale
-    if (QLocale().measurementSystem() == QLocale::MetricSystem) {
-        const int unitIndex = KoUnit(KoUnit::Centimeter).indexInListForUi(KoUnit::HidePixel);
-        m_page->printWidthUnit->setCurrentIndex(unitIndex);
-        m_page->printHeightUnit->setCurrentIndex(unitIndex);
-        m_page->printResolutionUnit->setCurrentIndex(0); // Pixels/Centimeter
-    } else { // Imperial
-        const int unitIndex = KoUnit(KoUnit::Inch).indexInListForUi(KoUnit::HidePixel);
-        m_page->printWidthUnit->setCurrentIndex(unitIndex);
-        m_page->printHeightUnit->setCurrentIndex(unitIndex);
-        m_page->printResolutionUnit->setCurrentIndex(1); // Pixels/Inch
-    }
-    updatePrintWidthUIValue(m_printWidth);
-    updatePrintHeightUIValue(m_printHeight);
-    updatePrintResolutionUIValue(m_resolution);
-
     m_page->pixelAspectRatioBtn->setKeepAspectRatio(true);
     m_page->printAspectRatioBtn->setKeepAspectRatio(true);
     m_page->constrainProportionsCkb->setChecked(true);
 
     KisSizeGroup *labelsGroup = new KisSizeGroup(this);
     labelsGroup->addWidget(m_page->lblPixelWidth);
     labelsGroup->addWidget(m_page->lblPixelHeight);
     labelsGroup->addWidget(m_page->lblPixelFilter);
     labelsGroup->addWidget(m_page->lblPrintWidth);
     labelsGroup->addWidget(m_page->lblPrintHeight);
     labelsGroup->addWidget(m_page->lblResolution);
 
     KisSizeGroup *spinboxesGroup = new KisSizeGroup(this);
-    spinboxesGroup->addWidget(m_page->pixelWidth);
     spinboxesGroup->addWidget(m_page->pixelWidthDouble);
-    spinboxesGroup->addWidget(m_page->pixelHeight);
     spinboxesGroup->addWidget(m_page->pixelHeightDouble);
     spinboxesGroup->addWidget(m_page->printWidth);
     spinboxesGroup->addWidget(m_page->printHeight);
     spinboxesGroup->addWidget(m_page->printResolution);
 
     KisSizeGroup *comboboxesGroup = new KisSizeGroup(this);
     comboboxesGroup->addWidget(m_page->pixelWidthUnit);
     comboboxesGroup->addWidget(m_page->pixelHeightUnit);
     comboboxesGroup->addWidget(m_page->printWidthUnit);
     comboboxesGroup->addWidget(m_page->printHeightUnit);
     comboboxesGroup->addWidget(m_page->printResolutionUnit);
     connect(this, SIGNAL(okClicked()), this, SLOT(accept()));
 
     connect(m_page->pixelAspectRatioBtn, SIGNAL(keepAspectRatioChanged(bool)), this, SLOT(slotAspectChanged(bool)));
     connect(m_page->printAspectRatioBtn, SIGNAL(keepAspectRatioChanged(bool)), this, SLOT(slotAspectChanged(bool)));
     connect(m_page->constrainProportionsCkb, SIGNAL(toggled(bool)), this, SLOT(slotAspectChanged(bool)));
 
-    connect(m_page->pixelWidth, SIGNAL(valueChanged(int)), this, SLOT(slotPixelWidthChanged(int)));
-    connect(m_page->pixelHeight, SIGNAL(valueChanged(int)), this, SLOT(slotPixelHeightChanged(int)));
-    connect(m_page->pixelWidthDouble, SIGNAL(valueChanged(double)), this, SLOT(slotPixelWidthChanged(double)));
-    connect(m_page->pixelHeightDouble, SIGNAL(valueChanged(double)), this, SLOT(slotPixelHeightChanged(double)));
-    connect(m_page->pixelWidthUnit, SIGNAL(currentIndexChanged(int)), this, SLOT(slotPixelWidthUnitChanged()));
-    connect(m_page->pixelHeightUnit, SIGNAL(currentIndexChanged(int)), this, SLOT(slotPixelHeightUnitChanged()));
+    connect(m_page->pixelWidthDouble, SIGNAL(valueChangedPt(double)), this, SLOT(slotPixelWidthChanged(double)));
+    connect(m_page->pixelHeightDouble, SIGNAL(valueChangedPt(double)), this, SLOT(slotPixelHeightChanged(double)));
+    connect(m_page->pixelWidthUnit, SIGNAL(currentIndexChanged(int)), _widthUnitManager, SLOT(selectApparentUnitFromIndex(int)));
+    connect(m_page->pixelHeightUnit, SIGNAL(currentIndexChanged(int)), _heightUnitManager, SLOT(selectApparentUnitFromIndex(int)));
+    connect(_widthUnitManager, SIGNAL(unitChanged(int)), m_page->pixelWidthUnit, SLOT(setCurrentIndex(int)));
+    connect(_heightUnitManager, SIGNAL(unitChanged(int)), m_page->pixelHeightUnit, SLOT(setCurrentIndex(int)));
 
-    connect(m_page->printWidth, SIGNAL(valueChanged(double)), this, SLOT(slotPrintWidthChanged(double)));
-    connect(m_page->printHeight, SIGNAL(valueChanged(double)), this, SLOT(slotPrintHeightChanged(double)));
-    connect(m_page->printWidthUnit, SIGNAL(currentIndexChanged(int)), this, SLOT(slotPrintWidthUnitChanged()));
-    connect(m_page->printHeightUnit, SIGNAL(currentIndexChanged(int)), this, SLOT(slotPrintHeightUnitChanged()));
+    connect(m_page->printWidth, SIGNAL(valueChangedPt(double)), this, SLOT(slotPrintWidthChanged(double)));
+    connect(m_page->printHeight, SIGNAL(valueChangedPt(double)), this, SLOT(slotPrintHeightChanged(double)));
+    connect(m_page->printWidthUnit, SIGNAL(currentIndexChanged(int)), _printWidthUnitManager, SLOT(selectApparentUnitFromIndex(int)));
+    connect(m_page->printHeightUnit, SIGNAL(currentIndexChanged(int)), _printHeightUnitManager, SLOT(selectApparentUnitFromIndex(int)));
+    connect(_printWidthUnitManager, SIGNAL(unitChanged(int)), m_page->printWidthUnit, SLOT(setCurrentIndex(int)));
+    connect(_printHeightUnitManager, SIGNAL(unitChanged(int)), m_page->printHeightUnit, SLOT(setCurrentIndex(int)));
 
     connect(m_page->printResolution, SIGNAL(valueChanged(double)), this, SLOT(slotPrintResolutionChanged(double)));
     connect(m_page->printResolution, SIGNAL(editingFinished()), this, SLOT(slotPrintResolutionEditFinished()));
     connect(m_page->printResolutionUnit, SIGNAL(currentIndexChanged(int)), this, SLOT(slotPrintResolutionUnitChanged()));
 
+    // pick selected print units from user locale (after slots connection, so the spinbox will be updated too).
+    if (QLocale().measurementSystem() == QLocale::MetricSystem) {
+        m_page->printWidthUnit->setCurrentText("cm");
+        m_page->printHeightUnit->setCurrentText("cm");
+        m_page->printResolutionUnit->setCurrentIndex(0); // Pixels/Centimeter
+        slotPrintResolutionUnitChanged(); //ensure the resolution is updated, even if the index didn't changed.
+    } else { // Imperial
+        m_page->printWidthUnit->setCurrentText("in");
+        m_page->printHeightUnit->setCurrentText("in");
+        m_page->printResolutionUnit->setCurrentIndex(1); // Pixels/Inch
+        slotPrintResolutionUnitChanged(); //ensure the resolution is updated, even if the index didn't changed.
+    }
+
     setMainWidget(m_page);
 }
 
 DlgImageSize::~DlgImageSize()
 {
     delete m_page;
 }
 
 qint32 DlgImageSize::width()
 {
     return (qint32)m_width;
 }
 
 qint32 DlgImageSize::height()
 {
     return (qint32)m_height;
 }
 
 double DlgImageSize::resolution()
 {
     return m_resolution;
 }
 
 KisFilterStrategy *DlgImageSize::filterType()
 {
     KoID filterID = m_page->pixelFilterCmb->currentItem();
     KisFilterStrategy *filter = KisFilterStrategyRegistry::instance()->value(filterID.id());
     return filter;
 }
 
 // SLOTS
 
-void DlgImageSize::slotPixelWidthChanged(int w)
-{
-    slotPixelWidthChanged((double) w);
-}
-
-void DlgImageSize::slotPixelHeightChanged(int h)
-{
-    slotPixelHeightChanged((double) h);
-}
-
 void DlgImageSize::slotPixelWidthChanged(double w)
 {
-    if (m_page->pixelWidthUnit->currentText() == percentStr) {
-        m_width = qRound((w * m_originalWidth) / 100.0);
-    } else {
-        m_width = w;
-    }
+    m_width = w;
 
     m_printWidth = m_width / m_resolution;
     updatePrintWidthUIValue(m_printWidth);
 
     if (m_keepAspect) {
         m_height = qRound(m_width / m_aspectRatio);
         updatePixelHeightUIValue(m_height);
 
         m_printHeight = m_height / m_resolution;
         updatePrintHeightUIValue(m_printHeight);
     }
 }
 
 void DlgImageSize::slotPixelHeightChanged(double h)
 {
-    if (m_page->pixelHeightUnit->currentText() == percentStr) {
-        m_height = qRound((h * m_originalHeight) / 100.0);
-    } else {
-        m_height = h;
-    }
+    m_height = h;
 
     m_printHeight = m_height / m_resolution;
     updatePrintHeightUIValue(m_printHeight);
 
     if (m_keepAspect) {
         m_width = qRound(m_height * m_aspectRatio);
         updatePixelWidthUIValue(m_width);
 
         m_printWidth = m_width / m_resolution;
         updatePrintWidthUIValue(m_printWidth);
     }
 }
 
-void DlgImageSize::slotPixelWidthUnitChanged()
-{
-    updatePixelWidthUIValue(m_width);
-
-    m_page->pixelWidth->setVisible(m_page->pixelWidthUnit->currentText() == pixelStr);
-    m_page->pixelWidthDouble->setVisible(m_page->pixelWidthUnit->currentText() == percentStr);
-}
-
-void DlgImageSize::slotPixelHeightUnitChanged()
-{
-    updatePixelHeightUIValue(m_height);
-
-    m_page->pixelHeight->setVisible(m_page->pixelHeightUnit->currentText() == pixelStr);
-    m_page->pixelHeightDouble->setVisible(m_page->pixelHeightUnit->currentText() == percentStr);
-}
-
 void DlgImageSize::slotPrintWidthChanged(double w)
 {
-    if (m_page->printWidthUnit->currentText() == percentStr) {
-        const double originalWidthPoint = m_originalWidth / m_originalResolution;
-        m_printWidth = (w * originalWidthPoint) / 100.0;
-    } else {
-        KoUnit selectedUnit = KoUnit::fromListForUi(m_page->printWidthUnit->currentIndex(), KoUnit::HidePixel);
-        m_printWidth = selectedUnit.fromUserValue(w);
-    }
+    m_printWidth = w;
 
     if (m_keepAspect) {
         m_printHeight = m_printWidth / m_aspectRatio;
         updatePrintHeightUIValue(m_printHeight);
     }
 
     if (m_page->adjustPrintSizeSeparatelyCkb->isChecked()) {
         m_resolution = m_width / m_printWidth;
         updatePrintResolutionUIValue(m_resolution);
 
         if (!m_keepAspect) {
             // compute and update a new image height value from the print size values
             const double printHeightInch = KoUnit::convertFromUnitToUnit(m_printHeight, KoUnit(KoUnit::Point), KoUnit(KoUnit::Inch));
             m_height = qRound(printHeightInch * 72 * m_resolution);
             updatePixelHeightUIValue(m_height);
         }
     } else {
         const double printWidthInch = KoUnit::convertFromUnitToUnit(m_printWidth, KoUnit(KoUnit::Point), KoUnit(KoUnit::Inch));
         m_width = qRound(printWidthInch * 72 * m_resolution);
         updatePixelWidthUIValue(m_width);
 
         if (m_keepAspect) {
             m_height = qRound(m_width / m_aspectRatio);
             updatePixelHeightUIValue(m_height);
         }
     }
 }
 
 void DlgImageSize::slotPrintHeightChanged(double h)
 {
-    if (m_page->printHeightUnit->currentText() == percentStr) {
-        const double originalHeightPoint = m_originalHeight / m_originalResolution;
-        m_printHeight = (h * originalHeightPoint) / 100.0;
-    } else {
-        KoUnit selectedUnit = KoUnit::fromListForUi(m_page->printHeightUnit->currentIndex(), KoUnit::HidePixel);
-        m_printHeight = selectedUnit.fromUserValue(h);
-    }
+    m_printHeight = h;
 
     if (m_keepAspect) {
         m_printWidth = m_printHeight * m_aspectRatio;
         updatePrintWidthUIValue(m_printWidth);
     }
 
     if (m_page->adjustPrintSizeSeparatelyCkb->isChecked()) {
         m_resolution = m_height / m_printHeight;
         updatePrintResolutionUIValue(m_resolution);
 
         if (!m_keepAspect) {
             // compute and update a new image width value from the print size values
             const double printWidthInch = KoUnit::convertFromUnitToUnit(m_printWidth, KoUnit(KoUnit::Point), KoUnit(KoUnit::Inch));
             m_width = qRound(printWidthInch * 72 * m_resolution);
             updatePixelWidthUIValue(m_width);
         }
     } else {
         const double printHeightInch = KoUnit::convertFromUnitToUnit(m_printHeight, KoUnit(KoUnit::Point), KoUnit(KoUnit::Inch));
         m_height = qRound(printHeightInch * 72 * m_resolution);
         updatePixelHeightUIValue(m_height);
 
         if (m_keepAspect) {
             m_width = qRound(m_height * m_aspectRatio);
             updatePixelWidthUIValue(m_width);
         }
     }
 }
 
-void DlgImageSize::slotPrintWidthUnitChanged()
-{
-    updatePrintWidthUIValue(m_printWidth);
-}
-
-void DlgImageSize::slotPrintHeightUnitChanged()
-{
-    updatePrintHeightUIValue(m_printHeight);
-}
-
 void DlgImageSize::slotAspectChanged(bool keep)
 {
     m_page->pixelAspectRatioBtn->blockSignals(true);
     m_page->printAspectRatioBtn->blockSignals(true);
     m_page->constrainProportionsCkb->blockSignals(true);
 
     m_page->pixelAspectRatioBtn->setKeepAspectRatio(keep);
     m_page->printAspectRatioBtn->setKeepAspectRatio(keep);
     m_page->constrainProportionsCkb->setChecked(keep);
 
     m_page->pixelAspectRatioBtn->blockSignals(false);
     m_page->printAspectRatioBtn->blockSignals(false);
     m_page->constrainProportionsCkb->blockSignals(false);
 
     m_keepAspect = keep;
 
     if (keep) {
         // values may be out of sync, so we need to reset it to defaults
         m_width = m_originalWidth;
         m_height = m_originalHeight;
         m_printWidth = m_originalWidth / m_originalResolution;
         m_printHeight = m_originalHeight / m_originalResolution;
         m_resolution = m_originalResolution;
 
         updatePixelWidthUIValue(m_width);
         updatePixelHeightUIValue(m_height);
         updatePrintWidthUIValue(m_printWidth);
         updatePrintHeightUIValue(m_printHeight);
         updatePrintResolutionUIValue(m_resolution);
     }
 }
 
 void DlgImageSize::slotPrintResolutionChanged(double r)
 {
     if (m_page->printResolutionUnit->currentText() == pixelsInchStr)
         m_resolution = KoUnit::convertFromUnitToUnit(r, KoUnit(KoUnit::Pixel), KoUnit(KoUnit::Inch));
     else
         m_resolution = KoUnit::convertFromUnitToUnit(r, KoUnit(KoUnit::Pixel), KoUnit(KoUnit::Centimeter));
 
     if (m_page->adjustPrintSizeSeparatelyCkb->isChecked()) {
         m_printWidth = m_width / m_resolution;
         m_printHeight = m_height / m_resolution;
 
         updatePrintWidthUIValue(m_printWidth);
         updatePrintHeightUIValue(m_printHeight);
     } else {
         // Do not commit m_width and m_height values yet. This is done to avoid
         // nasty results in image size values while the user is typing a resolution value
         const double printWidthInch = KoUnit::convertFromUnitToUnit(m_printWidth, KoUnit(KoUnit::Point), KoUnit(KoUnit::Inch));
         const int width = qRound(printWidthInch * 72 * m_resolution);
         const double printHeightInch = KoUnit::convertFromUnitToUnit(m_printHeight, KoUnit(KoUnit::Point), KoUnit(KoUnit::Inch));
         const int height = qRound(printHeightInch * 72 * m_resolution);
 
         updatePixelWidthUIValue(width);
         updatePixelHeightUIValue(height);
     }
 }
 
 void DlgImageSize::slotPrintResolutionEditFinished()
 {
     if (!m_page->adjustPrintSizeSeparatelyCkb->isChecked()) {
         const double printWidthInch = KoUnit::convertFromUnitToUnit(m_printWidth, KoUnit(KoUnit::Point), KoUnit(KoUnit::Inch));
         const double printHeightInch = KoUnit::convertFromUnitToUnit(m_printHeight, KoUnit(KoUnit::Point), KoUnit(KoUnit::Inch));
 
         // Commit width and height values
         m_width = qRound(printWidthInch * 72 * m_resolution);
         m_height = qRound(printHeightInch * 72 * m_resolution);
 
         // Note that spinbox values should be up to date
         // (updated through slotResolutionChanged())
     }
 }
 
 void DlgImageSize::slotPrintResolutionUnitChanged()
 {
     updatePrintResolutionUIValue(m_resolution);
 }
 
 void DlgImageSize::updatePixelWidthUIValue(double value)
 {
-    if (m_page->pixelWidthUnit->currentText() == percentStr) {
-        m_page->pixelWidthDouble->blockSignals(true);
-        m_page->pixelWidthDouble->setValue((value * 100.0) / m_originalWidth);
-        m_page->pixelWidthDouble->blockSignals(false);
-    } else {
-        m_page->pixelWidth->blockSignals(true);
-        m_page->pixelWidth->setValue(value);
-        m_page->pixelWidth->blockSignals(false);
-    }
+    m_page->pixelWidthDouble->blockSignals(true);
+    m_page->pixelWidthDouble->changeValue(value);
+    m_page->pixelWidthDouble->blockSignals(false);
 }
 
 void DlgImageSize::updatePixelHeightUIValue(double value)
 {
-    if (m_page->pixelHeightUnit->currentText() == percentStr) {
-        m_page->pixelHeightDouble->blockSignals(true);
-        m_page->pixelHeightDouble->setValue((value * 100.0) / m_originalHeight);
-        m_page->pixelHeightDouble->blockSignals(false);
-    } else {
-        m_page->pixelHeight->blockSignals(true);
-        m_page->pixelHeight->setValue(value);
-        m_page->pixelHeight->blockSignals(false);
-    }
+    m_page->pixelHeightDouble->blockSignals(true);
+    m_page->pixelHeightDouble->changeValue(value);
+    m_page->pixelHeightDouble->blockSignals(false);
 }
 
 void DlgImageSize::updatePrintWidthUIValue(double value)
 {
-    double uiValue = 0.0;
-    if (m_page->printWidthUnit->currentText() == percentStr) {
-        // We need to compute percent in point unit because:
-        // - originalWith is a value expressed in px (original resolution)
-        // - value is expressed in point unit (current resolution)
-        // - the percentage value should be based on the original print size
-        const double originalWidthPoint = m_originalWidth / m_originalResolution;
-        uiValue = (value * 100.0) / originalWidthPoint;
-    } else {
-        const KoUnit selectedUnit = KoUnit::fromListForUi(m_page->printWidthUnit->currentIndex());
-        uiValue = selectedUnit.toUserValue(value);
-    }
     m_page->printWidth->blockSignals(true);
-    m_page->printWidth->setValue(uiValue);
+    m_page->printWidth->changeValue(value);
     m_page->printWidth->blockSignals(false);
 }
 
 void DlgImageSize::updatePrintHeightUIValue(double value)
 {
-    double uiValue = 0.0;
-    if (m_page->printHeightUnit->currentText() == percentStr) {
-        // We need to compute percent in point unit because:
-        // - originalHeight is a value expressed in px (original resolution)
-        // - value is expressed in point unit (current resolution)
-        // - the percentage value should be based on the original print size
-        const double originalHeightPoint = m_originalHeight / m_originalResolution;
-        uiValue = (value * 100.0) / originalHeightPoint;
-    } else {
-        const KoUnit selectedUnit = KoUnit::fromListForUi(m_page->printHeightUnit->currentIndex());
-        uiValue = selectedUnit.toUserValue(value);
-    }
     m_page->printHeight->blockSignals(true);
-    m_page->printHeight->setValue(uiValue);
+    m_page->printHeight->changeValue(value);
     m_page->printHeight->blockSignals(false);
 }
 
 void DlgImageSize::updatePrintResolutionUIValue(double value)
 {
     double uiValue = 0.0;
     if (m_page->printResolutionUnit->currentText() == pixelsInchStr) {
         // show the value in pixel/inch unit
         uiValue = KoUnit::convertFromUnitToUnit(value, KoUnit(KoUnit::Inch), KoUnit(KoUnit::Pixel));
     } else {
         // show the value in pixel/centimeter unit
         uiValue = KoUnit::convertFromUnitToUnit(value, KoUnit(KoUnit::Centimeter), KoUnit(KoUnit::Pixel));
     }
 
     m_page->printResolution->blockSignals(true);
     m_page->printResolution->setValue(uiValue);
     m_page->printResolution->blockSignals(false);
 }
 
diff --git a/plugins/extensions/imagesize/dlg_imagesize.h b/plugins/extensions/imagesize/dlg_imagesize.h
index ba2d8c7667..77e4fbf527 100644
--- a/plugins/extensions/imagesize/dlg_imagesize.h
+++ b/plugins/extensions/imagesize/dlg_imagesize.h
@@ -1,89 +1,91 @@
 /*
  *  dlg_imagesize.h -- part of KimageShop^WKrayon^WKrita
  *
  *  Copyright (c) 2004 Boudewijn Rempt <boud@valdyas.org>
  *  Copyright (c) 2013 Juan Palacios <jpalaciosdev@gmail.com>
  *
  *  This program is free software; you can redistribute it and/or modify
  *  it under the terms of the GNU General Public License as published by
  *  the Free Software Foundation; either version 2 of the License, or
  *  (at your option) any later version.
  *
  *  This program is distributed in the hope that it will be useful,
  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  *  GNU General Public License for more details.
  *
  *  You should have received a copy of the GNU General Public License
  *  along with this program; if not, write to the Free Software
  *  Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
  */
 #ifndef DLG_IMAGESIZE
 #define DLG_IMAGESIZE
 
 #include <KoDialog.h>
 
 class KisFilterStrategy;
 class WdgImageSize;
+class KisDocumentAwareSpinBoxUnitManager;
+class KisSpinBoxUnitManager;
 
 #include "ui_wdg_imagesize.h"
 
 class WdgImageSize : public QWidget, public Ui::WdgImageSize
 {
     Q_OBJECT
 
 public:
     WdgImageSize(QWidget *parent) : QWidget(parent) {
         setupUi(this);
     }
 };
 
 class DlgImageSize: public KoDialog
 {
 
     Q_OBJECT
 
 public:
     DlgImageSize(QWidget * parent, int width, int height, double resolution);
     ~DlgImageSize();
 
     qint32 width();
     qint32 height();
     double resolution();
 
     KisFilterStrategy *filterType();
 
 private Q_SLOTS:
-    void slotPixelWidthChanged(int w);
-    void slotPixelHeightChanged(int h);
     void slotPixelWidthChanged(double w);
     void slotPixelHeightChanged(double h);
-    void slotPixelWidthUnitChanged();
-    void slotPixelHeightUnitChanged();
     void slotPrintWidthChanged(double w);
     void slotPrintHeightChanged(double h);
-    void slotPrintWidthUnitChanged();
-    void slotPrintHeightUnitChanged();
     void slotAspectChanged(bool keep);
     void slotPrintResolutionChanged(double r);
     void slotPrintResolutionEditFinished();
     void slotPrintResolutionUnitChanged();
 
 private:
     void updatePixelWidthUIValue(double value);
     void updatePixelHeightUIValue(double value);
     void updatePrintWidthUIValue(double value);
     void updatePrintHeightUIValue(double value);
     void updatePrintResolutionUIValue(double value);
 
     WdgImageSize *m_page;
     const double m_aspectRatio;
     const int m_originalWidth, m_originalHeight;
     int m_width, m_height;
     double m_printWidth, m_printHeight; // in points
     const double m_originalResolution;
     double m_resolution;
     bool m_keepAspect;
+
+    KisDocumentAwareSpinBoxUnitManager* _widthUnitManager;
+    KisDocumentAwareSpinBoxUnitManager* _heightUnitManager;
+
+    KisSpinBoxUnitManager* _printWidthUnitManager;
+    KisSpinBoxUnitManager* _printHeightUnitManager;
 };
 
 #endif // DLG_IMAGESIZE
diff --git a/plugins/extensions/imagesize/dlg_layersize.cc b/plugins/extensions/imagesize/dlg_layersize.cc
index 429dcdd72c..621eaf24e3 100644
--- a/plugins/extensions/imagesize/dlg_layersize.cc
+++ b/plugins/extensions/imagesize/dlg_layersize.cc
@@ -1,260 +1,197 @@
 /*
  *  dlg_layersize.cc - part of Krita
  *
  *  Copyright (c) 2004 Boudewijn Rempt <boud@valdyas.org>
  *  Copyright (c) 2005 Sven Langkamp <sven.langkamp@gmail.com>
  *  Copyright (c) 2013 Juan Palacios <jpalaciosdev@gmail.com>
  *
  *  This program is free software; you can redistribute it and/or modify
  *  it under the terms of the GNU General Public License as published by
  *  the Free Software Foundation; either version 2 of the License, or
  *  (at your option) any later version.
  *
  *  This program is distributed in the hope that it will be useful,
  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  *  GNU General Public License for more details.
  *
  *  You should have received a copy of the GNU General Public License
  *  along with this program; if not, write to the Free Software
  *  Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
  */
 
 #include "dlg_layersize.h"
 
 #include <KoUnit.h>
 
 #include <klocalizedstring.h>
 
+#include <kis_document_aware_spin_box_unit_manager.h>
+
 #include <kis_filter_strategy.h>// XXX: I'm really real bad at arithmetic, let alone math. Here
 // be rounding errors. (Boudewijn)
 
 static const QString pixelStr(KoUnit::unitDescription(KoUnit::Pixel));
 static const QString percentStr(i18n("Percent (%)"));
 
 DlgLayerSize::DlgLayerSize(QWidget *  parent, const char * name,
                            int width, int height, double resolution)
-        : KoDialog(parent)
-        , m_aspectRatio(((double) width) / height)
-        , m_originalWidth(width)
-        , m_originalHeight(height)
-        , m_width(width)
-        , m_height(height)
-        , m_resolution(resolution)
-        , m_keepAspect(true)
+    : KoDialog(parent)
+    , m_aspectRatio(((double) width) / height)
+    , m_originalWidth(width)
+    , m_originalHeight(height)
+    , m_width(width)
+    , m_height(height)
+    , m_resolution(resolution)
+    , m_keepAspect(true)
 {
     setCaption(i18n("Layer Size"));
     setObjectName(name);
     setButtons(Ok | Cancel);
     setDefaultButton(Ok);
 
     m_page = new WdgLayerSize(this);
     Q_CHECK_PTR(m_page);
     m_page->layout()->setMargin(0);
     m_page->setObjectName(name);
 
-    m_page->newWidth->setValue(width);
-    m_page->newWidth->setFocus();
-    m_page->newHeight->setValue(height);
+    _widthUnitManager = new KisDocumentAwareSpinBoxUnitManager(this);
+    _heightUnitManager = new KisDocumentAwareSpinBoxUnitManager(this, KisDocumentAwareSpinBoxUnitManager::PIX_DIR_Y);
+
+    _widthUnitManager->setApparentUnitFromSymbol("px");
+    _heightUnitManager->setApparentUnitFromSymbol("px");
+
+    m_page->newWidthDouble->setUnitManager(_widthUnitManager);
+    m_page->newHeightDouble->setUnitManager(_heightUnitManager);
+    m_page->newWidthDouble->setDecimals(2);
+    m_page->newHeightDouble->setDecimals(2);
+    m_page->newWidthDouble->setDisplayUnit(false);
+    m_page->newHeightDouble->setDisplayUnit(false);
 
-    m_page->newWidthDouble->setVisible(false);
-    m_page->newHeightDouble->setVisible(false);
+    m_page->newWidthDouble->setValue(width);
+    m_page->newWidthDouble->setFocus();
+    m_page->newHeightDouble->setValue(height);
 
     m_page->filterCmb->setIDList(KisFilterStrategyRegistry::instance()->listKeys());
     m_page->filterCmb->setToolTip(KisFilterStrategyRegistry::instance()->formatedDescriptions());
     m_page->filterCmb->setCurrent("Bicubic");
 
-    m_page->newWidthUnit->addItems(KoUnit::listOfUnitNameForUi());
-    m_page->newWidthUnit->addItem(percentStr);
+    m_page->newWidthUnit->setModel(_widthUnitManager);
+    m_page->newHeightUnit->setModel(_heightUnitManager);
 
-    m_page->newHeightUnit->addItems(KoUnit::listOfUnitNameForUi());
-    m_page->newHeightUnit->addItem(percentStr);
-
-    const int pixelUnitIndex = KoUnit(KoUnit::Pixel).indexInListForUi();
+    const int pixelUnitIndex = _widthUnitManager->getsUnitSymbolList().indexOf("px"); //TODO: have a better way to identify units.
     m_page->newWidthUnit->setCurrentIndex(pixelUnitIndex);
     m_page->newHeightUnit->setCurrentIndex(pixelUnitIndex);
 
     m_page->aspectRatioBtn->setKeepAspectRatio(true);
     m_page->constrainProportionsCkb->setChecked(true);
 
     setMainWidget(m_page);
     connect(this, SIGNAL(okClicked()), this, SLOT(accept()));
 
     connect(m_page->aspectRatioBtn, SIGNAL(keepAspectRatioChanged(bool)), this, SLOT(slotAspectChanged(bool)));
     connect(m_page->constrainProportionsCkb, SIGNAL(toggled(bool)), this, SLOT(slotAspectChanged(bool)));
 
-    connect(m_page->newWidth, SIGNAL(valueChanged(int)), this, SLOT(slotWidthChanged(int)));
-    connect(m_page->newHeight, SIGNAL(valueChanged(int)), this, SLOT(slotHeightChanged(int)));
-    connect(m_page->newWidthDouble, SIGNAL(valueChanged(double)), this, SLOT(slotWidthChanged(double)));
-    connect(m_page->newHeightDouble, SIGNAL(valueChanged(double)), this, SLOT(slotHeightChanged(double)));
-    connect(m_page->newWidthUnit, SIGNAL(currentIndexChanged(int)), this, SLOT(slotWidthUnitChanged(int)));
-    connect(m_page->newHeightUnit, SIGNAL(currentIndexChanged(int)), this, SLOT(slotHeightUnitChanged(int)));
+    connect(m_page->newWidthDouble, SIGNAL(valueChangedPt(double)), this, SLOT(slotWidthChanged(double)));
+    connect(m_page->newHeightDouble, SIGNAL(valueChangedPt(double)), this, SLOT(slotHeightChanged(double)));
+
+    connect(m_page->newWidthUnit, SIGNAL(currentIndexChanged(int)), _widthUnitManager, SLOT(selectApparentUnitFromIndex(int)));
+    connect(m_page->newHeightUnit, SIGNAL(currentIndexChanged(int)), _heightUnitManager, SLOT(selectApparentUnitFromIndex(int)));
+    connect(_widthUnitManager, SIGNAL(unitChanged(int)), m_page->newWidthUnit, SLOT(setCurrentIndex(int)));
+    connect(_heightUnitManager, SIGNAL(unitChanged(int)), m_page->newHeightUnit, SLOT(setCurrentIndex(int)));
 }
 
 DlgLayerSize::~DlgLayerSize()
 {
     delete m_page;
 }
 
 qint32 DlgLayerSize::width()
 {
     return (qint32)m_width;
 }
 
 qint32 DlgLayerSize::height()
 {
     return (qint32)m_height;
 }
 
 KisFilterStrategy *DlgLayerSize::filterType()
 {
     KoID filterID = m_page->filterCmb->currentItem();
     KisFilterStrategy *filter = KisFilterStrategyRegistry::instance()->value(filterID.id());
     return filter;
 }
 
 // SLOTS
 
-void DlgLayerSize::slotWidthChanged(int w)
-{
-    slotWidthChanged((double) w);
-}
-
-void DlgLayerSize::slotHeightChanged(int h)
-{
-    slotHeightChanged((double) h);
-}
-
 void DlgLayerSize::slotWidthChanged(double w)
 {
-    if (m_page->newWidthUnit->currentText() == percentStr) {
-        m_width = qRound((w * m_originalWidth) / 100.0);
-    } else {
-        const KoUnit selectedUnit = KoUnit::fromListForUi(m_page->newWidthUnit->currentIndex());
-        const double resValue = (selectedUnit == KoUnit(KoUnit::Pixel)) ? w : (w * m_resolution);
-        m_width = qRound(selectedUnit.fromUserValue(resValue));
-    }
+
+    //this slot receiv values in pt from the unitspinbox, so just use the resolution.
+    const double resValue = w*_widthUnitManager->getConversionFactor(KisSpinBoxUnitManager::LENGTH, "px");
+    m_width = qRound(resValue);
 
     if (m_keepAspect) {
         m_height = qRound(m_width / m_aspectRatio);
-        updateHeightUIValue(m_height);
+        m_page->newHeightDouble->blockSignals(true);
+        m_page->newHeightDouble->changeValue(w / m_aspectRatio);
+        m_page->newHeightDouble->blockSignals(false);
     }
+
 }
 
 void DlgLayerSize::slotHeightChanged(double h)
 {
-    if (m_page->newHeightUnit->currentText() == percentStr) {
-        m_height = qRound((h * m_originalHeight) / 100.0);
-    } else {
-        const KoUnit selectedUnit = KoUnit::fromListForUi(m_page->newHeightUnit->currentIndex());
-        const double resValue = (selectedUnit == KoUnit(KoUnit::Pixel)) ? h : (h * m_resolution);
-        m_height = qRound(selectedUnit.fromUserValue(resValue));
-    }
+
+    //this slot receiv values in pt from the unitspinbox, so just use the resolution.
+    const double resValue = h*_heightUnitManager->getConversionFactor(KisSpinBoxUnitManager::LENGTH, "px");
+    m_height = qRound(resValue);
 
     if (m_keepAspect) {
         m_width = qRound(m_height * m_aspectRatio);
-        updateWidthUIValue(m_width);
-    }
-}
-
-void DlgLayerSize::slotWidthUnitChanged(int index)
-{
-    updateWidthUIValue(m_width);
-
-    if (m_page->newWidthUnit->currentText() == percentStr) {
-        m_page->newWidth->setVisible(false);
-        m_page->newWidthDouble->setVisible(true);
-    } else {
-        const KoUnit selectedUnit = KoUnit::fromListForUi(index);
-        if (selectedUnit != KoUnit(KoUnit::Pixel)) {
-            m_page->newWidth->setVisible(false);
-            m_page->newWidthDouble->setVisible(true);
-        } else {
-            m_page->newWidth->setVisible(true);
-            m_page->newWidthDouble->setVisible(false);
-        }
-    }
-}
-
-void DlgLayerSize::slotHeightUnitChanged(int index)
-{
-    updateHeightUIValue(m_height);
-
-    if (m_page->newHeightUnit->currentText() == percentStr) {
-        m_page->newHeight->setVisible(false);
-        m_page->newHeightDouble->setVisible(true);
-    } else {
-        const KoUnit selectedUnit = KoUnit::fromListForUi(index);
-        if (selectedUnit != KoUnit(KoUnit::Pixel)) {
-            m_page->newHeight->setVisible(false);
-            m_page->newHeightDouble->setVisible(true);
-        } else {
-            m_page->newHeight->setVisible(true);
-            m_page->newHeightDouble->setVisible(false);
-        }
+        m_page->newWidthDouble->blockSignals(true);
+        m_page->newWidthDouble->changeValue(h * m_aspectRatio);
+        m_page->newWidthDouble->blockSignals(false);
     }
 }
 
 void DlgLayerSize::slotAspectChanged(bool keep)
 {
     m_page->aspectRatioBtn->blockSignals(true);
     m_page->constrainProportionsCkb->blockSignals(true);
 
     m_page->aspectRatioBtn->setKeepAspectRatio(keep);
     m_page->constrainProportionsCkb->setChecked(keep);
 
     m_page->aspectRatioBtn->blockSignals(false);
     m_page->constrainProportionsCkb->blockSignals(false);
 
     m_keepAspect = keep;
 
     if (keep) {
         // values may be out of sync, so we need to reset it to defaults
         m_width = m_originalWidth;
         m_height = m_originalHeight;
 
         updateWidthUIValue(m_width);
         updateHeightUIValue(m_height);
     }
 }
 
 void DlgLayerSize::updateWidthUIValue(double value)
 {
-    if (m_page->newWidthUnit->currentText() == percentStr) {
-        m_page->newWidthDouble->blockSignals(true);
-        m_page->newWidthDouble->setValue((value * 100.0) / m_originalWidth);
-        m_page->newWidthDouble->blockSignals(false);
-    } else {
-        const KoUnit selectedUnit = KoUnit::fromListForUi(m_page->newWidthUnit->currentIndex());
-        if (selectedUnit != KoUnit(KoUnit::Pixel)) {
-            m_page->newWidthDouble->blockSignals(true);
-            m_page->newWidthDouble->setValue(selectedUnit.toUserValue(value / m_resolution));
-            m_page->newWidthDouble->blockSignals(false);
-        } else {
-            m_page->newWidth->blockSignals(true);
-            m_page->newWidth->setValue(selectedUnit.toUserValue(value));
-            m_page->newWidth->blockSignals(false);
-        }
-    }
+    m_page->newWidthDouble->blockSignals(true);
+    const double resValue = value/_widthUnitManager->getConversionFactor(KisSpinBoxUnitManager::LENGTH, "px");
+    m_page->newWidthDouble->changeValue(resValue);
+    m_page->newWidthDouble->blockSignals(false);
 }
 
 void DlgLayerSize::updateHeightUIValue(double value)
 {
-    if (m_page->newHeightUnit->currentText() == percentStr) {
-        m_page->newHeightDouble->blockSignals(true);
-        m_page->newHeightDouble->setValue((value * 100.0) / m_originalHeight);
-        m_page->newHeightDouble->blockSignals(false);
-    } else {
-        const KoUnit selectedUnit = KoUnit::fromListForUi(m_page->newHeightUnit->currentIndex());
-        if (selectedUnit != KoUnit(KoUnit::Pixel)) {
-            m_page->newHeightDouble->blockSignals(true);
-            m_page->newHeightDouble->setValue(selectedUnit.toUserValue(value / m_resolution));
-            m_page->newHeightDouble->blockSignals(false);
-        } else {
-            m_page->newHeight->blockSignals(true);
-            m_page->newHeight->setValue(selectedUnit.toUserValue(value));
-            m_page->newHeight->blockSignals(false);
-        }
-    }
+    m_page->newHeightDouble->blockSignals(true);
+    const double resValue = value/_heightUnitManager->getConversionFactor(KisSpinBoxUnitManager::LENGTH, "px");
+    m_page->newHeightDouble->changeValue(resValue);
+    m_page->newHeightDouble->blockSignals(false);
 }
 
diff --git a/plugins/extensions/imagesize/dlg_layersize.h b/plugins/extensions/imagesize/dlg_layersize.h
index 73c943b10a..53fccdf309 100644
--- a/plugins/extensions/imagesize/dlg_layersize.h
+++ b/plugins/extensions/imagesize/dlg_layersize.h
@@ -1,78 +1,79 @@
 /*
  *  dlg_layersize.h -- part of Krita
  *
  *  Copyright (c) 2004 Boudewijn Rempt <boud@valdyas.org>
  *  Copyright (c) 2005 Sven Langkamp <sven.langkamp@gmail.com>
  *  Copyright (c) 2013 Juan Palacios <jpalaciosdev@gmail.com>
  *
  *  This program is free software; you can redistribute it and/or modify
  *  it under the terms of the GNU General Public License as published by
  *  the Free Software Foundation; either version 2 of the License, or
  *  (at your option) any later version.
  *
  *  This program is distributed in the hope that it will be useful,
  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  *  GNU General Public License for more details.
  *
  *  You should have received a copy of the GNU General Public License
  *  along with this program; if not, write to the Free Software
  *  Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
  */
 #ifndef DLG_LAYERSIZE
 #define DLG_LAYERSIZE
 
 #include <KoDialog.h>
 
 #include "ui_wdg_layersize.h"
 
+class KisDocumentAwareSpinBoxUnitManager;
+
 class WdgLayerSize : public QWidget, public Ui::WdgLayerSize
 {
     Q_OBJECT
 
 public:
     WdgLayerSize(QWidget *parent) : QWidget(parent) {
         setupUi(this);
     }
 };
 
 class KisFilterStrategy;
 
 class DlgLayerSize: public KoDialog
 {
 
     Q_OBJECT
 
 public:
 
     DlgLayerSize(QWidget * parent, const char* name,
                  int width, int height, double resolution);
     ~DlgLayerSize();
 
     qint32 width();
     qint32 height();
 
     KisFilterStrategy *filterType();
 
 private Q_SLOTS:
-    void slotWidthChanged(int w);
-    void slotHeightChanged(int h);
     void slotWidthChanged(double w);
     void slotHeightChanged(double h);
-    void slotWidthUnitChanged(int index);
-    void slotHeightUnitChanged(int index);
     void slotAspectChanged(bool keep);
 
 private:
     void updateWidthUIValue(double value);
     void updateHeightUIValue(double value);
 
     WdgLayerSize * m_page;
     const double m_aspectRatio;
     const int m_originalWidth, m_originalHeight;
     int m_width, m_height;
     const double m_resolution;
     bool m_keepAspect;
+
+    KisDocumentAwareSpinBoxUnitManager* _widthUnitManager;
+    KisDocumentAwareSpinBoxUnitManager* _heightUnitManager;
 };
 
 #endif // DLG_IMAGESIZE
diff --git a/plugins/extensions/imagesize/imagesize.cc b/plugins/extensions/imagesize/imagesize.cc
index ca21339e1a..83601304cf 100644
--- a/plugins/extensions/imagesize/imagesize.cc
+++ b/plugins/extensions/imagesize/imagesize.cc
@@ -1,166 +1,166 @@
 /*
  * imagesize.cc -- Part of Krita
  *
  * Copyright (c) 2004 Boudewijn Rempt (boud@valdyas.org)
  *
  *  This program is free software; you can redistribute it and/or modify
  *  it under the terms of the GNU General Public License as published by
  *  the Free Software Foundation; either version 2 of the License, or
  *  (at your option) any later version.
  *
  *  This program is distributed in the hope that it will be useful,
  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  *  GNU General Public License for more details.
  *
  *  You should have received a copy of the GNU General Public License
  *  along with this program; if not, write to the Free Software
  *  Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
  */
 
 #include "imagesize.h"
 
 #include <klocalizedstring.h>
 #include <kis_debug.h>
 #include <kpluginfactory.h>
 
 #include <kis_image.h>
 #include <kis_layer.h>
 #include <kis_global.h>
 #include <kis_types.h>
 #include <KisViewManager.h>
 
 #include <kis_image_manager.h>
 #include <kis_node_manager.h>
 #include <kis_group_layer.h>
 #include <kis_selection_mask.h>
 #include <kis_selection.h>
 
 #include "dlg_imagesize.h"
 #include "dlg_canvassize.h"
 #include "dlg_layersize.h"
 #include "kis_filter_strategy.h"
 #include "kis_action.h"
 #include "kis_action_manager.h"
 
 K_PLUGIN_FACTORY_WITH_JSON(ImageSizeFactory, "kritaimagesize.json", registerPlugin<ImageSize>();)
 
 ImageSize::ImageSize(QObject *parent, const QVariantList &)
-        : KisViewPlugin(parent)
+    : KisViewPlugin(parent)
 {
     KisAction *action  = createAction("imagesize");
     connect(action, SIGNAL(triggered()), this, SLOT(slotImageSize()));
 
     action = createAction("canvassize");
     connect(action, SIGNAL(triggered()), this, SLOT(slotCanvasSize()));
 
     action = createAction("layersize");
     connect(action, SIGNAL(triggered()), this, SLOT(slotLayerSize()));
 
     action  = createAction("selectionscale");
     connect(action, SIGNAL(triggered()), this, SLOT(slotSelectionScale()));
 }
 
 ImageSize::~ImageSize()
 {
 }
 
 void ImageSize::slotImageSize()
 {
     KisImageSP image = m_view->image().toStrongRef();
     if (!image) return;
 
     DlgImageSize * dlgImageSize = new DlgImageSize(m_view->mainWindow(), image->width(), image->height(), image->yRes());
     Q_CHECK_PTR(dlgImageSize);
     dlgImageSize->setObjectName("ImageSize");
 
     if (dlgImageSize->exec() == QDialog::Accepted) {
         qint32 w = dlgImageSize->width();
         qint32 h = dlgImageSize->height();
         double res = dlgImageSize->resolution();
 
         m_view->imageManager()->scaleCurrentImage(QSize(w, h), res, res, dlgImageSize->filterType());
     }
 
     delete dlgImageSize;
 }
 
 void ImageSize::slotCanvasSize()
 {
     KisImageWSP image = m_view->image();
 
     if (!image) return;
 
     DlgCanvasSize * dlgCanvasSize = new DlgCanvasSize(m_view->mainWindow(), image->width(), image->height(), image->yRes());
     Q_CHECK_PTR(dlgCanvasSize);
 
     if (dlgCanvasSize->exec() == QDialog::Accepted) {
         qint32 width = dlgCanvasSize->width();
         qint32 height = dlgCanvasSize->height();
         qint32 xOffset = dlgCanvasSize->xOffset();
         qint32 yOffset = dlgCanvasSize->yOffset();
 
         m_view->imageManager()->resizeCurrentImage(width, height, xOffset, yOffset);
     }
     delete dlgCanvasSize;
 }
 
 void ImageSize::slotLayerSize()
 {
     KisImageWSP image = m_view->image();
 
     if (!image) return;
 
     KisPaintDeviceSP dev = m_view->activeLayer()->projection();
     Q_ASSERT(dev);
     QRect rc = dev->exactBounds();
 
     DlgLayerSize * dlgLayerSize = new DlgLayerSize(m_view->mainWindow(), "LayerSize", rc.width(), rc.height(), image->yRes());
     Q_CHECK_PTR(dlgLayerSize);
     dlgLayerSize->setCaption(i18n("Resize Layer"));
 
     if (dlgLayerSize->exec() == QDialog::Accepted) {
         qint32 w = dlgLayerSize->width();
         qint32 h = dlgLayerSize->height();
 
         m_view->nodeManager()->scale((double)w / ((double)(rc.width())),
                                      (double)h / ((double)(rc.height())),
                                      dlgLayerSize->filterType());
     }
     delete dlgLayerSize;
 }
 
 void ImageSize::slotSelectionScale()
 {
     KisImageSP image = m_view->image();
     if (!image) {
         return;
     }
     KisLayerSP layer = m_view->activeLayer();
 
     KIS_ASSERT_RECOVER_RETURN(image && layer);
 
     KisSelectionMaskSP selectionMask = layer->selectionMask();
     if (!selectionMask) {
         selectionMask = image->rootLayer()->selectionMask();
     }
 
     KIS_ASSERT_RECOVER_RETURN(selectionMask);
 
     QRect rc = selectionMask->selection()->selectedExactRect();
     DlgLayerSize * dlgSize = new DlgLayerSize(m_view->mainWindow(), "SelectionScale", rc.width(), rc.height(), image->yRes());
     dlgSize->setCaption(i18n("Scale Selection"));
 
     if (dlgSize->exec() == QDialog::Accepted) {
         qint32 w = dlgSize->width();
         qint32 h = dlgSize->height();
 
         image->scaleNode(selectionMask,
                          qreal(w) / rc.width(),
                          qreal(h) / rc.height(),
                          dlgSize->filterType());
     }
     delete dlgSize;
 }
 
 #include "imagesize.moc"
diff --git a/plugins/extensions/imagesize/wdg_canvassize.ui b/plugins/extensions/imagesize/wdg_canvassize.ui
index 858140b589..466f45e393 100644
--- a/plugins/extensions/imagesize/wdg_canvassize.ui
+++ b/plugins/extensions/imagesize/wdg_canvassize.ui
@@ -1,692 +1,643 @@
 <?xml version="1.0" encoding="UTF-8"?>
 <ui version="4.0">
  <class>WdgCanvasSize</class>
  <widget class="QWidget" name="WdgCanvasSize">
   <property name="geometry">
    <rect>
     <x>0</x>
     <y>0</y>
     <width>395</width>
     <height>387</height>
    </rect>
   </property>
   <property name="windowTitle">
    <string>Canvas Size</string>
   </property>
   <layout class="QVBoxLayout" name="verticalLayout">
    <item>
     <widget class="QGroupBox" name="groupBox_2">
      <property name="title">
       <string>New Size</string>
      </property>
      <property name="flat">
       <bool>true</bool>
      </property>
      <layout class="QGridLayout" name="gridLayout_2">
-      <item row="0" column="2">
-       <widget class="KisIntParseSpinBox" name="newWidth">
-        <property name="minimum">
-         <number>1</number>
-        </property>
-        <property name="maximum">
-         <number>100000</number>
-        </property>
-       </widget>
-      </item>
       <item row="1" column="1">
        <widget class="QLabel" name="lblNewHeight">
         <property name="text">
          <string>Height:</string>
         </property>
         <property name="alignment">
          <set>Qt::AlignRight|Qt::AlignTrailing|Qt::AlignVCenter</set>
         </property>
        </widget>
       </item>
       <item row="1" column="3">
        <widget class="QComboBox" name="heightUnit"/>
       </item>
       <item row="0" column="4" rowspan="2">
        <widget class="KoAspectButton" name="aspectRatioBtn" native="true"/>
       </item>
-      <item row="1" column="2">
-       <widget class="KisIntParseSpinBox" name="newHeight">
-        <property name="minimum">
-         <number>1</number>
-        </property>
-        <property name="maximum">
-         <number>100000</number>
-        </property>
-       </widget>
-      </item>
       <item row="0" column="1">
        <widget class="QLabel" name="lblNewWidth">
         <property name="text">
          <string>Width:</string>
         </property>
         <property name="alignment">
          <set>Qt::AlignRight|Qt::AlignTrailing|Qt::AlignVCenter</set>
         </property>
        </widget>
       </item>
       <item row="0" column="2">
-       <widget class="KisDoubleParseSpinBox" name="newWidthDouble">
+       <widget class="KisDoubleParseUnitSpinBox" name="newWidthDouble">
         <property name="decimals">
          <number>4</number>
         </property>
         <property name="minimum">
          <double>0.000100000000000</double>
         </property>
         <property name="maximum">
          <double>10000.000000000000000</double>
         </property>
         <property name="singleStep">
          <double>0.100000000000000</double>
         </property>
        </widget>
       </item>
       <item row="1" column="2">
-       <widget class="KisDoubleParseSpinBox" name="newHeightDouble">
+       <widget class="KisDoubleParseUnitSpinBox" name="newHeightDouble">
         <property name="decimals">
          <number>4</number>
         </property>
         <property name="minimum">
          <double>0.000100000000000</double>
         </property>
         <property name="maximum">
          <double>10000.000000000000000</double>
         </property>
         <property name="singleStep">
          <double>0.100000000000000</double>
         </property>
        </widget>
       </item>
       <item row="1" column="0">
        <spacer name="horizontalSpacer_5">
         <property name="orientation">
          <enum>Qt::Horizontal</enum>
         </property>
         <property name="sizeType">
          <enum>QSizePolicy::Fixed</enum>
         </property>
         <property name="sizeHint" stdset="0">
          <size>
           <width>25</width>
           <height>20</height>
          </size>
         </property>
        </spacer>
       </item>
       <item row="0" column="3">
        <widget class="QComboBox" name="widthUnit"/>
       </item>
       <item row="1" column="5">
        <spacer name="horizontalSpacer_2">
         <property name="orientation">
          <enum>Qt::Horizontal</enum>
         </property>
         <property name="sizeType">
          <enum>QSizePolicy::MinimumExpanding</enum>
         </property>
         <property name="sizeHint" stdset="0">
          <size>
           <width>40</width>
           <height>20</height>
          </size>
         </property>
        </spacer>
       </item>
       <item row="2" column="2" colspan="4">
        <widget class="QCheckBox" name="constrainProportionsCkb">
         <property name="toolTip">
          <string>Constrain aspect ratio</string>
         </property>
         <property name="text">
          <string>Constrain proportions</string>
         </property>
         <property name="checked">
          <bool>true</bool>
         </property>
        </widget>
       </item>
      </layout>
     </widget>
    </item>
    <item>
     <widget class="QGroupBox" name="groupBox">
      <property name="title">
       <string>Offset</string>
      </property>
      <property name="flat">
       <bool>true</bool>
      </property>
      <layout class="QGridLayout" name="gridLayout">
       <item row="4" column="2">
        <spacer name="verticalSpacer">
         <property name="orientation">
          <enum>Qt::Vertical</enum>
         </property>
         <property name="sizeType">
          <enum>QSizePolicy::MinimumExpanding</enum>
         </property>
         <property name="sizeHint" stdset="0">
          <size>
           <width>20</width>
           <height>30</height>
          </size>
         </property>
        </spacer>
       </item>
       <item row="2" column="2">
        <spacer name="verticalSpacer_2">
         <property name="orientation">
          <enum>Qt::Vertical</enum>
         </property>
         <property name="sizeType">
          <enum>QSizePolicy::Fixed</enum>
         </property>
         <property name="sizeHint" stdset="0">
          <size>
           <width>20</width>
           <height>16</height>
          </size>
         </property>
        </spacer>
       </item>
       <item row="0" column="1">
        <widget class="QLabel" name="lblXOff">
         <property name="text">
          <string>X:</string>
         </property>
         <property name="alignment">
          <set>Qt::AlignRight|Qt::AlignTrailing|Qt::AlignVCenter</set>
         </property>
        </widget>
       </item>
       <item row="0" column="2">
-       <widget class="KisIntParseSpinBox" name="xOffset">
-        <property name="minimum">
-         <number>-100000</number>
-        </property>
-        <property name="maximum">
-         <number>100000</number>
-        </property>
-       </widget>
-      </item>
-      <item row="0" column="2">
-       <widget class="KisDoubleParseSpinBox" name="xOffsetDouble">
+       <widget class="KisDoubleParseUnitSpinBox" name="xOffsetDouble">
         <property name="decimals">
          <number>4</number>
         </property>
         <property name="minimum">
          <double>-10000.000000000000000</double>
         </property>
         <property name="maximum">
          <double>10000.000000000000000</double>
         </property>
         <property name="singleStep">
          <double>0.100000000000000</double>
         </property>
        </widget>
       </item>
       <item row="3" column="0">
        <spacer name="horizontalSpacer_6">
         <property name="orientation">
          <enum>Qt::Horizontal</enum>
         </property>
         <property name="sizeType">
          <enum>QSizePolicy::Fixed</enum>
         </property>
         <property name="sizeHint" stdset="0">
          <size>
           <width>25</width>
           <height>20</height>
          </size>
         </property>
        </spacer>
       </item>
       <item row="3" column="1">
        <widget class="QLabel" name="lblAnchor">
         <property name="text">
          <string>Anchor:</string>
         </property>
         <property name="alignment">
          <set>Qt::AlignRight|Qt::AlignTop|Qt::AlignTrailing</set>
         </property>
        </widget>
       </item>
       <item row="1" column="1">
        <widget class="QLabel" name="lblYOff">
         <property name="text">
          <string>Y:</string>
         </property>
         <property name="alignment">
          <set>Qt::AlignRight|Qt::AlignTrailing|Qt::AlignVCenter</set>
         </property>
        </widget>
       </item>
       <item row="1" column="2">
-       <widget class="KisIntParseSpinBox" name="yOffset">
-        <property name="minimum">
-         <number>-100000</number>
-        </property>
-        <property name="maximum">
-         <number>100000</number>
-        </property>
-       </widget>
-      </item>
-      <item row="1" column="2">
-       <widget class="KisDoubleParseSpinBox" name="yOffsetDouble">
+       <widget class="KisDoubleParseUnitSpinBox" name="yOffsetDouble">
         <property name="decimals">
          <number>4</number>
         </property>
         <property name="minimum">
          <double>-10000.000000000000000</double>
         </property>
         <property name="maximum">
          <double>10000.000000000000000</double>
         </property>
         <property name="singleStep">
          <double>0.100000000000000</double>
         </property>
        </widget>
       </item>
       <item row="1" column="3">
        <widget class="QComboBox" name="yOffUnit"/>
       </item>
       <item row="0" column="3">
        <widget class="QComboBox" name="xOffUnit"/>
       </item>
       <item row="3" column="3">
        <widget class="QFrame" name="previewCanvas">
         <property name="sizePolicy">
          <sizepolicy hsizetype="Preferred" vsizetype="Preferred">
           <horstretch>0</horstretch>
           <verstretch>0</verstretch>
          </sizepolicy>
         </property>
         <property name="minimumSize">
          <size>
           <width>0</width>
           <height>0</height>
          </size>
         </property>
         <property name="frameShape">
          <enum>QFrame::StyledPanel</enum>
         </property>
         <property name="frameShadow">
          <enum>QFrame::Sunken</enum>
         </property>
         <layout class="QVBoxLayout" name="verticalLayout_2">
          <property name="leftMargin">
           <number>2</number>
          </property>
          <property name="topMargin">
           <number>2</number>
          </property>
          <property name="rightMargin">
           <number>2</number>
          </property>
          <property name="bottomMargin">
           <number>2</number>
          </property>
          <item>
           <widget class="KCanvasPreview" name="canvasPreview" native="true"/>
          </item>
         </layout>
        </widget>
       </item>
       <item row="3" column="2">
        <layout class="QHBoxLayout" name="horizontalLayout">
         <item>
          <layout class="QGridLayout" name="gridLayout_3">
           <property name="spacing">
            <number>0</number>
           </property>
           <item row="0" column="0">
            <widget class="QPushButton" name="topLeft">
             <property name="sizePolicy">
              <sizepolicy hsizetype="Fixed" vsizetype="Fixed">
               <horstretch>0</horstretch>
               <verstretch>0</verstretch>
              </sizepolicy>
             </property>
             <property name="maximumSize">
              <size>
               <width>25</width>
               <height>25</height>
              </size>
             </property>
             <property name="text">
              <string/>
             </property>
             <property name="iconSize">
              <size>
               <width>15</width>
               <height>15</height>
              </size>
             </property>
             <property name="checkable">
              <bool>true</bool>
             </property>
            </widget>
           </item>
           <item row="1" column="0">
            <widget class="QPushButton" name="middleLeft">
             <property name="sizePolicy">
              <sizepolicy hsizetype="Fixed" vsizetype="Fixed">
               <horstretch>0</horstretch>
               <verstretch>0</verstretch>
              </sizepolicy>
             </property>
             <property name="maximumSize">
              <size>
               <width>25</width>
               <height>25</height>
              </size>
             </property>
             <property name="text">
              <string/>
             </property>
             <property name="iconSize">
              <size>
               <width>15</width>
               <height>15</height>
              </size>
             </property>
             <property name="checkable">
              <bool>true</bool>
             </property>
            </widget>
           </item>
           <item row="2" column="0">
            <widget class="QPushButton" name="bottomLeft">
             <property name="sizePolicy">
              <sizepolicy hsizetype="Fixed" vsizetype="Fixed">
               <horstretch>0</horstretch>
               <verstretch>0</verstretch>
              </sizepolicy>
             </property>
             <property name="maximumSize">
              <size>
               <width>25</width>
               <height>25</height>
              </size>
             </property>
             <property name="text">
              <string/>
             </property>
             <property name="iconSize">
              <size>
               <width>15</width>
               <height>15</height>
              </size>
             </property>
             <property name="checkable">
              <bool>true</bool>
             </property>
            </widget>
           </item>
           <item row="1" column="1">
            <widget class="QPushButton" name="middleCenter">
             <property name="sizePolicy">
              <sizepolicy hsizetype="Fixed" vsizetype="Fixed">
               <horstretch>0</horstretch>
               <verstretch>0</verstretch>
              </sizepolicy>
             </property>
             <property name="maximumSize">
              <size>
               <width>25</width>
               <height>25</height>
              </size>
             </property>
             <property name="text">
              <string/>
             </property>
             <property name="iconSize">
              <size>
               <width>15</width>
               <height>15</height>
              </size>
             </property>
             <property name="checkable">
              <bool>true</bool>
             </property>
            </widget>
           </item>
           <item row="2" column="1">
            <widget class="QPushButton" name="bottomCenter">
             <property name="sizePolicy">
              <sizepolicy hsizetype="Fixed" vsizetype="Fixed">
               <horstretch>0</horstretch>
               <verstretch>0</verstretch>
              </sizepolicy>
             </property>
             <property name="maximumSize">
              <size>
               <width>25</width>
               <height>25</height>
              </size>
             </property>
             <property name="text">
              <string/>
             </property>
             <property name="iconSize">
              <size>
               <width>15</width>
               <height>15</height>
              </size>
             </property>
             <property name="checkable">
              <bool>true</bool>
             </property>
            </widget>
           </item>
           <item row="1" column="2">
            <widget class="QPushButton" name="middleRight">
             <property name="sizePolicy">
              <sizepolicy hsizetype="Fixed" vsizetype="Fixed">
               <horstretch>0</horstretch>
               <verstretch>0</verstretch>
              </sizepolicy>
             </property>
             <property name="maximumSize">
              <size>
               <width>25</width>
               <height>25</height>
              </size>
             </property>
             <property name="text">
              <string/>
             </property>
             <property name="iconSize">
              <size>
               <width>15</width>
               <height>15</height>
              </size>
             </property>
             <property name="checkable">
              <bool>true</bool>
             </property>
            </widget>
           </item>
           <item row="0" column="1">
            <widget class="QPushButton" name="topCenter">
             <property name="sizePolicy">
              <sizepolicy hsizetype="Fixed" vsizetype="Fixed">
               <horstretch>0</horstretch>
               <verstretch>0</verstretch>
              </sizepolicy>
             </property>
             <property name="maximumSize">
              <size>
               <width>25</width>
               <height>25</height>
              </size>
             </property>
             <property name="text">
              <string/>
             </property>
             <property name="iconSize">
              <size>
               <width>15</width>
               <height>15</height>
              </size>
             </property>
             <property name="checkable">
              <bool>true</bool>
             </property>
            </widget>
           </item>
           <item row="0" column="2">
            <widget class="QPushButton" name="topRight">
             <property name="sizePolicy">
              <sizepolicy hsizetype="Fixed" vsizetype="Fixed">
               <horstretch>0</horstretch>
               <verstretch>0</verstretch>
              </sizepolicy>
             </property>
             <property name="maximumSize">
              <size>
               <width>25</width>
               <height>25</height>
              </size>
             </property>
             <property name="text">
              <string/>
             </property>
             <property name="iconSize">
              <size>
               <width>15</width>
               <height>15</height>
              </size>
             </property>
             <property name="checkable">
              <bool>true</bool>
             </property>
             <property name="flat">
              <bool>false</bool>
             </property>
            </widget>
           </item>
           <item row="2" column="2">
            <widget class="QPushButton" name="bottomRight">
             <property name="sizePolicy">
              <sizepolicy hsizetype="Fixed" vsizetype="Fixed">
               <horstretch>0</horstretch>
               <verstretch>0</verstretch>
              </sizepolicy>
             </property>
             <property name="maximumSize">
              <size>
               <width>25</width>
               <height>25</height>
              </size>
             </property>
             <property name="text">
              <string/>
             </property>
             <property name="iconSize">
              <size>
               <width>15</width>
               <height>15</height>
              </size>
             </property>
             <property name="checkable">
              <bool>true</bool>
             </property>
            </widget>
           </item>
          </layout>
         </item>
         <item>
          <spacer name="horizontalSpacer">
           <property name="orientation">
            <enum>Qt::Horizontal</enum>
           </property>
           <property name="sizeType">
            <enum>QSizePolicy::Maximum</enum>
           </property>
           <property name="sizeHint" stdset="0">
            <size>
             <width>16</width>
             <height>20</height>
            </size>
           </property>
          </spacer>
         </item>
        </layout>
       </item>
       <item row="3" column="4">
        <spacer name="horizontalSpacer_4">
         <property name="orientation">
          <enum>Qt::Horizontal</enum>
         </property>
         <property name="sizeType">
          <enum>QSizePolicy::MinimumExpanding</enum>
         </property>
         <property name="sizeHint" stdset="0">
          <size>
           <width>40</width>
           <height>20</height>
          </size>
         </property>
        </spacer>
       </item>
      </layout>
     </widget>
    </item>
   </layout>
  </widget>
  <customwidgets>
   <customwidget>
    <class>KoAspectButton</class>
    <extends>QWidget</extends>
    <header>KoAspectButton.h</header>
    <container>1</container>
   </customwidget>
   <customwidget>
    <class>KCanvasPreview</class>
    <extends>QWidget</extends>
    <header>kcanvaspreview.h</header>
    <container>1</container>
   </customwidget>
   <customwidget>
-   <class>KisDoubleParseSpinBox</class>
+   <class>KisDoubleParseUnitSpinBox</class>
    <extends>QDoubleSpinBox</extends>
-   <header>kis_double_parse_spin_box.h</header>
-  </customwidget>
-  <customwidget>
-   <class>KisIntParseSpinBox</class>
-   <extends>QSpinBox</extends>
-   <header>kis_int_parse_spin_box.h</header>
+   <header>kis_double_parse_unit_spin_box.h</header>
   </customwidget>
  </customwidgets>
  <tabstops>
-  <tabstop>newWidth</tabstop>
   <tabstop>newWidthDouble</tabstop>
   <tabstop>widthUnit</tabstop>
-  <tabstop>newHeight</tabstop>
   <tabstop>newHeightDouble</tabstop>
   <tabstop>heightUnit</tabstop>
   <tabstop>constrainProportionsCkb</tabstop>
-  <tabstop>xOffset</tabstop>
   <tabstop>xOffsetDouble</tabstop>
   <tabstop>xOffUnit</tabstop>
-  <tabstop>yOffset</tabstop>
   <tabstop>yOffsetDouble</tabstop>
   <tabstop>yOffUnit</tabstop>
   <tabstop>topLeft</tabstop>
   <tabstop>topCenter</tabstop>
   <tabstop>topRight</tabstop>
   <tabstop>middleLeft</tabstop>
   <tabstop>middleCenter</tabstop>
   <tabstop>middleRight</tabstop>
   <tabstop>bottomLeft</tabstop>
   <tabstop>bottomCenter</tabstop>
   <tabstop>bottomRight</tabstop>
  </tabstops>
  <resources/>
  <connections/>
 </ui>
diff --git a/plugins/extensions/imagesize/wdg_imagesize.ui b/plugins/extensions/imagesize/wdg_imagesize.ui
index 8a45fdf251..6edf3cafaf 100644
--- a/plugins/extensions/imagesize/wdg_imagesize.ui
+++ b/plugins/extensions/imagesize/wdg_imagesize.ui
@@ -1,447 +1,413 @@
 <?xml version="1.0" encoding="UTF-8"?>
 <ui version="4.0">
  <class>WdgImageSize</class>
  <widget class="QWidget" name="WdgImageSize">
   <property name="geometry">
    <rect>
     <x>0</x>
     <y>0</y>
     <width>391</width>
     <height>386</height>
    </rect>
   </property>
   <property name="windowTitle">
    <string>Scale To New Size</string>
   </property>
   <layout class="QVBoxLayout" name="verticalLayout">
    <item>
     <widget class="QGroupBox" name="groupImageSize">
      <property name="title">
       <string>Pixel Dimensions</string>
      </property>
      <property name="flat">
       <bool>true</bool>
      </property>
      <layout class="QGridLayout" name="gridLayout_3">
       <item row="1" column="2">
-       <widget class="KisDoubleParseSpinBox" name="pixelHeightDouble">
+       <widget class="KisDoubleParseUnitSpinBox" name="pixelHeightDouble">
         <property name="minimumSize">
          <size>
           <width>80</width>
           <height>0</height>
          </size>
         </property>
         <property name="decimals">
          <number>4</number>
         </property>
         <property name="minimum">
          <double>0.000100000000000</double>
         </property>
         <property name="maximum">
          <double>10000.000000000000000</double>
         </property>
         <property name="singleStep">
          <double>0.100000000000000</double>
         </property>
        </widget>
       </item>
-      <item row="1" column="2">
-       <widget class="KisIntParseSpinBox" name="pixelHeight">
-        <property name="minimumSize">
-         <size>
-          <width>80</width>
-          <height>0</height>
-         </size>
-        </property>
-        <property name="minimum">
-         <number>1</number>
-        </property>
-        <property name="maximum">
-         <number>100000</number>
-        </property>
-       </widget>
-      </item>
       <item row="0" column="3">
        <widget class="QComboBox" name="pixelWidthUnit"/>
       </item>
       <item row="0" column="0">
        <spacer name="horizontalSpacer_2">
         <property name="orientation">
          <enum>Qt::Horizontal</enum>
         </property>
         <property name="sizeType">
          <enum>QSizePolicy::Fixed</enum>
         </property>
         <property name="sizeHint" stdset="0">
          <size>
           <width>25</width>
           <height>20</height>
          </size>
         </property>
        </spacer>
       </item>
       <item row="0" column="1">
        <widget class="QLabel" name="lblPixelWidth">
         <property name="text">
-         <string>W&amp;idth:</string>
+         <string>Width:</string>
         </property>
         <property name="alignment">
          <set>Qt::AlignRight|Qt::AlignTrailing|Qt::AlignVCenter</set>
         </property>
-        <property name="buddy">
-         <cstring>pixelWidth</cstring>
-        </property>
        </widget>
       </item>
       <item row="2" column="1">
        <widget class="QLabel" name="lblPixelFilter">
         <property name="text">
          <string>&amp;Filter:</string>
         </property>
         <property name="alignment">
          <set>Qt::AlignRight|Qt::AlignTrailing|Qt::AlignVCenter</set>
         </property>
         <property name="buddy">
          <cstring>printWidth</cstring>
         </property>
        </widget>
       </item>
       <item row="0" column="4" rowspan="2">
        <widget class="KoAspectButton" name="pixelAspectRatioBtn" native="true">
         <property name="text" stdset="0">
          <string/>
         </property>
        </widget>
       </item>
       <item row="1" column="3">
        <widget class="QComboBox" name="pixelHeightUnit"/>
       </item>
       <item row="1" column="1">
        <widget class="QLabel" name="lblPixelHeight">
         <property name="text">
-         <string>&amp;Height:</string>
+         <string>Height:</string>
         </property>
         <property name="alignment">
          <set>Qt::AlignRight|Qt::AlignTrailing|Qt::AlignVCenter</set>
         </property>
-        <property name="buddy">
-         <cstring>pixelHeight</cstring>
-        </property>
        </widget>
       </item>
       <item row="0" column="2">
-       <widget class="KisDoubleParseSpinBox" name="pixelWidthDouble">
+       <widget class="KisDoubleParseUnitSpinBox" name="pixelWidthDouble">
         <property name="minimumSize">
          <size>
           <width>80</width>
           <height>0</height>
          </size>
         </property>
         <property name="decimals">
          <number>4</number>
         </property>
         <property name="minimum">
          <double>0.000100000000000</double>
         </property>
         <property name="maximum">
          <double>10000.000000000000000</double>
         </property>
         <property name="singleStep">
          <double>0.100000000000000</double>
         </property>
        </widget>
       </item>
-      <item row="0" column="2">
-       <widget class="KisIntParseSpinBox" name="pixelWidth">
-        <property name="minimum">
-         <number>1</number>
-        </property>
-        <property name="maximum">
-         <number>100000</number>
-        </property>
-       </widget>
-      </item>
       <item row="1" column="5">
        <spacer name="horizontalSpacer_5">
         <property name="orientation">
          <enum>Qt::Horizontal</enum>
         </property>
         <property name="sizeType">
          <enum>QSizePolicy::MinimumExpanding</enum>
         </property>
         <property name="sizeHint" stdset="0">
          <size>
           <width>40</width>
           <height>20</height>
          </size>
         </property>
        </spacer>
       </item>
       <item row="2" column="2" colspan="2">
        <widget class="KisCmbIDList" name="pixelFilterCmb" native="true"/>
       </item>
      </layout>
     </widget>
    </item>
    <item>
     <widget class="QGroupBox" name="groupPrintSize">
      <property name="title">
       <string>Print Size</string>
      </property>
      <property name="flat">
       <bool>true</bool>
      </property>
      <layout class="QGridLayout" name="gridLayout">
       <item row="1" column="1">
        <widget class="QLabel" name="lblPrintHeight">
         <property name="text">
          <string>Hei&amp;ght:</string>
         </property>
         <property name="alignment">
          <set>Qt::AlignRight|Qt::AlignTrailing|Qt::AlignVCenter</set>
         </property>
         <property name="buddy">
          <cstring>printHeight</cstring>
         </property>
        </widget>
       </item>
       <item row="1" column="3">
        <widget class="QComboBox" name="printHeightUnit"/>
       </item>
       <item row="0" column="2">
-       <widget class="KisDoubleParseSpinBox" name="printWidth">
+       <widget class="KisDoubleParseUnitSpinBox" name="printWidth">
         <property name="minimumSize">
          <size>
           <width>80</width>
           <height>0</height>
          </size>
         </property>
         <property name="decimals">
          <number>4</number>
         </property>
         <property name="minimum">
          <double>0.000100000000000</double>
         </property>
         <property name="maximum">
          <double>10000.000000000000000</double>
         </property>
         <property name="singleStep">
          <double>0.100000000000000</double>
         </property>
        </widget>
       </item>
       <item row="0" column="1">
        <widget class="QLabel" name="lblPrintWidth">
         <property name="text">
          <string>Wid&amp;th:</string>
         </property>
         <property name="alignment">
          <set>Qt::AlignRight|Qt::AlignTrailing|Qt::AlignVCenter</set>
         </property>
         <property name="buddy">
          <cstring>printWidth</cstring>
         </property>
        </widget>
       </item>
       <item row="1" column="2">
-       <widget class="KisDoubleParseSpinBox" name="printHeight">
+       <widget class="KisDoubleParseUnitSpinBox" name="printHeight">
         <property name="minimumSize">
          <size>
           <width>80</width>
           <height>0</height>
          </size>
         </property>
         <property name="decimals">
          <number>4</number>
         </property>
         <property name="minimum">
          <double>0.000100000000000</double>
         </property>
         <property name="maximum">
          <double>10000.000000000000000</double>
         </property>
         <property name="singleStep">
          <double>0.100000000000000</double>
         </property>
        </widget>
       </item>
       <item row="0" column="4" rowspan="2">
        <widget class="KoAspectButton" name="printAspectRatioBtn" native="true">
         <property name="text" stdset="0">
          <string/>
         </property>
        </widget>
       </item>
       <item row="0" column="3">
        <widget class="QComboBox" name="printWidthUnit"/>
       </item>
       <item row="2" column="1">
        <widget class="QLabel" name="lblResolution">
         <property name="text">
          <string>Resolution:</string>
         </property>
        </widget>
       </item>
       <item row="2" column="2">
        <widget class="KisDoubleParseSpinBox" name="printResolution">
         <property name="sizePolicy">
          <sizepolicy hsizetype="Minimum" vsizetype="Fixed">
           <horstretch>0</horstretch>
           <verstretch>0</verstretch>
          </sizepolicy>
         </property>
         <property name="minimumSize">
          <size>
           <width>70</width>
           <height>0</height>
          </size>
         </property>
         <property name="decimals">
          <number>4</number>
         </property>
         <property name="minimum">
          <double>0.000100000000000</double>
         </property>
         <property name="maximum">
          <double>10000.000000000000000</double>
         </property>
         <property name="singleStep">
          <double>0.100000000000000</double>
         </property>
        </widget>
       </item>
       <item row="2" column="3">
        <widget class="QComboBox" name="printResolutionUnit"/>
       </item>
       <item row="1" column="0">
        <spacer name="horizontalSpacer">
         <property name="orientation">
          <enum>Qt::Horizontal</enum>
         </property>
         <property name="sizeType">
          <enum>QSizePolicy::Fixed</enum>
         </property>
         <property name="sizeHint" stdset="0">
          <size>
           <width>25</width>
           <height>20</height>
          </size>
         </property>
        </spacer>
       </item>
       <item row="0" column="5">
        <spacer name="horizontalSpacer_3">
         <property name="orientation">
          <enum>Qt::Horizontal</enum>
         </property>
         <property name="sizeType">
          <enum>QSizePolicy::MinimumExpanding</enum>
         </property>
         <property name="sizeHint" stdset="0">
          <size>
           <width>40</width>
           <height>20</height>
          </size>
         </property>
        </spacer>
       </item>
      </layout>
     </widget>
    </item>
    <item>
     <spacer name="verticalSpacer_2">
      <property name="orientation">
       <enum>Qt::Vertical</enum>
      </property>
      <property name="sizeType">
       <enum>QSizePolicy::Fixed</enum>
      </property>
      <property name="sizeHint" stdset="0">
       <size>
        <width>20</width>
        <height>16</height>
       </size>
      </property>
     </spacer>
    </item>
    <item>
     <widget class="QCheckBox" name="constrainProportionsCkb">
      <property name="toolTip">
       <string>Constrain aspect ratio</string>
      </property>
      <property name="text">
       <string>Constrain proportions</string>
      </property>
      <property name="checked">
       <bool>true</bool>
      </property>
     </widget>
    </item>
    <item>
     <widget class="QCheckBox" name="adjustPrintSizeSeparatelyCkb">
      <property name="text">
       <string>Adjust print size separately</string>
      </property>
     </widget>
    </item>
    <item>
     <spacer name="verticalSpacer">
      <property name="orientation">
       <enum>Qt::Vertical</enum>
      </property>
      <property name="sizeType">
       <enum>QSizePolicy::MinimumExpanding</enum>
      </property>
      <property name="sizeHint" stdset="0">
       <size>
        <width>20</width>
        <height>30</height>
       </size>
      </property>
     </spacer>
    </item>
   </layout>
  </widget>
  <customwidgets>
   <customwidget>
    <class>KisCmbIDList</class>
    <extends></extends>
    <header>widgets/kis_cmb_idlist.h</header>
   </customwidget>
   <customwidget>
    <class>KoAspectButton</class>
    <extends>QWidget</extends>
    <header>KoAspectButton.h</header>
    <container>1</container>
   </customwidget>
-  <customwidget>
-   <class>KisIntParseSpinBox</class>
-   <extends>QSpinBox</extends>
-   <header>kis_int_parse_spin_box.h</header>
-  </customwidget>
   <customwidget>
    <class>KisDoubleParseSpinBox</class>
    <extends>QDoubleSpinBox</extends>
    <header>kis_double_parse_spin_box.h</header>
   </customwidget>
+  <customwidget>
+   <class>KisDoubleParseUnitSpinBox</class>
+   <extends>QDoubleSpinBox</extends>
+   <header>kis_double_parse_unit_spin_box.h</header>
+  </customwidget>
  </customwidgets>
  <tabstops>
-  <tabstop>pixelWidth</tabstop>
   <tabstop>pixelWidthDouble</tabstop>
   <tabstop>pixelWidthUnit</tabstop>
-  <tabstop>pixelHeight</tabstop>
   <tabstop>pixelHeightDouble</tabstop>
   <tabstop>pixelHeightUnit</tabstop>
   <tabstop>pixelFilterCmb</tabstop>
   <tabstop>printWidth</tabstop>
   <tabstop>printWidthUnit</tabstop>
   <tabstop>printHeight</tabstop>
   <tabstop>printHeightUnit</tabstop>
   <tabstop>printResolution</tabstop>
   <tabstop>printResolutionUnit</tabstop>
   <tabstop>constrainProportionsCkb</tabstop>
   <tabstop>adjustPrintSizeSeparatelyCkb</tabstop>
  </tabstops>
  <resources/>
  <connections/>
 </ui>
diff --git a/plugins/extensions/imagesize/wdg_layersize.ui b/plugins/extensions/imagesize/wdg_layersize.ui
index 58170c58ad..6a07d00756 100644
--- a/plugins/extensions/imagesize/wdg_layersize.ui
+++ b/plugins/extensions/imagesize/wdg_layersize.ui
@@ -1,248 +1,209 @@
 <?xml version="1.0" encoding="UTF-8"?>
 <ui version="4.0">
  <class>WdgLayerSize</class>
  <widget class="QWidget" name="WdgLayerSize">
   <property name="geometry">
    <rect>
     <x>0</x>
     <y>0</y>
-    <width>366</width>
+    <width>374</width>
     <height>201</height>
    </rect>
   </property>
   <property name="windowTitle">
    <string>Layer Size</string>
   </property>
   <layout class="QVBoxLayout" name="verticalLayout">
    <item>
     <widget class="QGroupBox" name="groupNewSize">
      <property name="title">
       <string>New Size</string>
      </property>
      <property name="flat">
       <bool>true</bool>
      </property>
      <layout class="QGridLayout" name="gridLayout_3">
       <item row="0" column="4" rowspan="2">
        <widget class="KoAspectButton" name="aspectRatioBtn" native="true">
         <property name="text" stdset="0">
          <string/>
         </property>
        </widget>
       </item>
       <item row="1" column="5">
        <spacer name="horizontalSpacer_5">
         <property name="orientation">
          <enum>Qt::Horizontal</enum>
         </property>
         <property name="sizeType">
          <enum>QSizePolicy::MinimumExpanding</enum>
         </property>
         <property name="sizeHint" stdset="0">
          <size>
           <width>40</width>
           <height>20</height>
          </size>
         </property>
        </spacer>
       </item>
       <item row="0" column="3">
        <widget class="QComboBox" name="newWidthUnit"/>
       </item>
       <item row="1" column="3">
        <widget class="QComboBox" name="newHeightUnit"/>
       </item>
       <item row="0" column="1">
        <widget class="QLabel" name="lblNewWidth">
         <property name="text">
-         <string>W&amp;idth:</string>
+         <string>Width:</string>
         </property>
         <property name="alignment">
          <set>Qt::AlignRight|Qt::AlignTrailing|Qt::AlignVCenter</set>
         </property>
-        <property name="buddy">
-         <cstring>newWidth</cstring>
-        </property>
        </widget>
       </item>
       <item row="0" column="2">
-       <widget class="KisDoubleParseSpinBox" name="newWidthDouble">
+       <widget class="KisDoubleParseUnitSpinBox" name="newWidthDouble">
         <property name="minimumSize">
          <size>
           <width>80</width>
           <height>0</height>
          </size>
         </property>
         <property name="decimals">
          <number>4</number>
         </property>
         <property name="minimum">
          <double>0.000100000000000</double>
         </property>
         <property name="maximum">
          <double>10000.000000000000000</double>
         </property>
         <property name="singleStep">
          <double>0.100000000000000</double>
         </property>
        </widget>
       </item>
       <item row="1" column="2">
-       <widget class="KisDoubleParseSpinBox" name="newHeightDouble">
+       <widget class="KisDoubleParseUnitSpinBox" name="newHeightDouble">
         <property name="minimumSize">
          <size>
           <width>80</width>
           <height>0</height>
          </size>
         </property>
         <property name="decimals">
          <number>4</number>
         </property>
         <property name="minimum">
          <double>0.000100000000000</double>
         </property>
         <property name="maximum">
          <double>10000.000000000000000</double>
         </property>
         <property name="singleStep">
          <double>0.100000000000000</double>
         </property>
        </widget>
       </item>
-      <item row="1" column="2">
-       <widget class="KisIntParseSpinBox" name="newHeight">
-        <property name="minimumSize">
-         <size>
-          <width>80</width>
-          <height>0</height>
-         </size>
-        </property>
-        <property name="minimum">
-         <number>1</number>
-        </property>
-        <property name="maximum">
-         <number>100000</number>
-        </property>
-       </widget>
-      </item>
-      <item row="0" column="2">
-       <widget class="KisIntParseSpinBox" name="newWidth">
-        <property name="minimum">
-         <number>1</number>
-        </property>
-        <property name="maximum">
-         <number>100000</number>
-        </property>
-       </widget>
-      </item>
       <item row="2" column="2" colspan="2">
        <widget class="KisCmbIDList" name="filterCmb" native="true"/>
       </item>
       <item row="2" column="1">
        <widget class="QLabel" name="lblFilter">
         <property name="text">
          <string>Filter:</string>
         </property>
         <property name="alignment">
          <set>Qt::AlignRight|Qt::AlignTrailing|Qt::AlignVCenter</set>
         </property>
        </widget>
       </item>
       <item row="1" column="1">
        <widget class="QLabel" name="lblNewHeight">
         <property name="text">
-         <string>&amp;Height:</string>
+         <string>Height:</string>
         </property>
         <property name="alignment">
          <set>Qt::AlignRight|Qt::AlignTrailing|Qt::AlignVCenter</set>
         </property>
-        <property name="buddy">
-         <cstring>newHeight</cstring>
-        </property>
        </widget>
       </item>
       <item row="3" column="2" colspan="4">
        <widget class="QCheckBox" name="constrainProportionsCkb">
         <property name="toolTip">
          <string>Constrain aspect ratio</string>
         </property>
         <property name="text">
          <string>Constrain proportions</string>
         </property>
         <property name="checked">
          <bool>true</bool>
         </property>
        </widget>
       </item>
       <item row="0" column="0">
        <spacer name="horizontalSpacer_2">
         <property name="orientation">
          <enum>Qt::Horizontal</enum>
         </property>
         <property name="sizeType">
          <enum>QSizePolicy::Fixed</enum>
         </property>
         <property name="sizeHint" stdset="0">
          <size>
           <width>25</width>
           <height>20</height>
          </size>
         </property>
        </spacer>
       </item>
      </layout>
     </widget>
    </item>
    <item>
     <spacer name="verticalSpacer">
      <property name="orientation">
       <enum>Qt::Vertical</enum>
      </property>
      <property name="sizeType">
       <enum>QSizePolicy::MinimumExpanding</enum>
      </property>
      <property name="sizeHint" stdset="0">
       <size>
        <width>20</width>
        <height>30</height>
       </size>
      </property>
     </spacer>
    </item>
   </layout>
  </widget>
  <customwidgets>
-  <customwidget>
-   <class>KisCmbIDList</class>
-   <extends></extends>
-   <header>widgets/kis_cmb_idlist.h</header>
-  </customwidget>
   <customwidget>
    <class>KoAspectButton</class>
    <extends>QWidget</extends>
    <header>KoAspectButton.h</header>
    <container>1</container>
   </customwidget>
   <customwidget>
-   <class>KisIntParseSpinBox</class>
-   <extends>QSpinBox</extends>
-   <header>kis_int_parse_spin_box.h</header>
+   <class>KisDoubleParseUnitSpinBox</class>
+   <extends>QDoubleSpinBox</extends>
+   <header>kis_double_parse_unit_spin_box.h</header>
   </customwidget>
   <customwidget>
-   <class>KisDoubleParseSpinBox</class>
-   <extends>QDoubleSpinBox</extends>
-   <header>kis_double_parse_spin_box.h</header>
+   <class>KisCmbIDList</class>
+   <extends></extends>
+   <header>widgets/kis_cmb_idlist.h</header>
   </customwidget>
  </customwidgets>
  <tabstops>
-  <tabstop>newWidth</tabstop>
   <tabstop>newWidthDouble</tabstop>
   <tabstop>newWidthUnit</tabstop>
-  <tabstop>newHeight</tabstop>
   <tabstop>newHeightDouble</tabstop>
   <tabstop>newHeightUnit</tabstop>
   <tabstop>filterCmb</tabstop>
  </tabstops>
  <resources/>
  <connections/>
 </ui>
diff --git a/plugins/extensions/offsetimage/dlg_offsetimage.cpp b/plugins/extensions/offsetimage/dlg_offsetimage.cpp
index 5c4094921c..481fd36d36 100644
--- a/plugins/extensions/offsetimage/dlg_offsetimage.cpp
+++ b/plugins/extensions/offsetimage/dlg_offsetimage.cpp
@@ -1,79 +1,109 @@
 /*
  * Copyright (c) 2013 Lukáš Tvrdý <lukast.dev@gmail.com>
  *
  *  This program is free software; you can redistribute it and/or modify
  *  it under the terms of the GNU General Public License as published by
  *  the Free Software Foundation; either version 2 of the License, or
  *  (at your option) any later version.
  *
  *  This program is distributed in the hope that it will be useful,
  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  *  GNU General Public License for more details.
  *
  *  You should have received a copy of the GNU General Public License
  *  along with this program; if not, write to the Free Software
  *  Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
  */
 
 #include "dlg_offsetimage.h"
 
 #include <klocalizedstring.h>
 #include <kis_debug.h>
 
+#include "kis_document_aware_spin_box_unit_manager.h"
+
 DlgOffsetImage::DlgOffsetImage(QWidget *  parent, const char * name, QSize imageSize)
-        :   KoDialog(parent),
-            m_offsetSize(imageSize)
+    :   KoDialog(parent),
+      m_offsetSize(imageSize)
 {
     setCaption("BUG: No sane caption is set");
     setButtons(Ok | Cancel);
     setDefaultButton(Ok);
     setObjectName(name);
 
 
     m_lock = false;
 
     m_page = new WdgOffsetImage(this);
     Q_CHECK_PTR(m_page);
     m_page->setObjectName("offset_image");
 
     setMainWidget(m_page);
     resize(m_page->sizeHint());
 
+    _widthUnitManager = new KisDocumentAwareSpinBoxUnitManager(this);
+    _heightUnitManager = new KisDocumentAwareSpinBoxUnitManager(this, KisDocumentAwareSpinBoxUnitManager::PIX_DIR_Y);
+
+    _widthUnitManager->setApparentUnitFromSymbol("px");
+    _heightUnitManager->setApparentUnitFromSymbol("px");
+
+    m_page->offsetXdoubleSpinBox->setUnitManager(_widthUnitManager);
+    m_page->offsetYdoubleSpinBox->setUnitManager(_heightUnitManager);
+    m_page->offsetXdoubleSpinBox->setDecimals(2);
+    m_page->offsetYdoubleSpinBox->setDecimals(2);
+    m_page->offsetXdoubleSpinBox->setDisplayUnit(false);
+    m_page->offsetYdoubleSpinBox->setDisplayUnit(false);
+
+    m_page->offsetXdoubleSpinBox->setReturnUnit("px");
+    m_page->offsetYdoubleSpinBox->setReturnUnit("px");
+
+    m_page->unitXComboBox->setModel(_widthUnitManager);
+    m_page->unitYComboBox->setModel(_heightUnitManager);
+
+    const int pixelUnitIndex = _widthUnitManager->getsUnitSymbolList().indexOf("px"); //TODO: have a better way to identify units.
+    m_page->unitXComboBox->setCurrentIndex(pixelUnitIndex);
+    m_page->unitYComboBox->setCurrentIndex(pixelUnitIndex);
+
     connect(this, SIGNAL(okClicked()),this, SLOT(okClicked()));
     connect(m_page->middleOffsetBtn, SIGNAL(clicked()), this, SLOT(slotMiddleOffset()));
-    connect(m_page->offsetXspinBox, SIGNAL(valueChanged(int)), this, SLOT(slotOffsetXChanged(int)));
-    connect(m_page->offsetYspinBox, SIGNAL(valueChanged(int)), this, SLOT(slotOffsetYChanged(int)));
+    connect(m_page->offsetXdoubleSpinBox, SIGNAL(valueChangedPt(double)), this, SLOT(slotOffsetXChanged(double)));
+    connect(m_page->offsetYdoubleSpinBox, SIGNAL(valueChangedPt(double)), this, SLOT(slotOffsetYChanged(double)));
+
+    connect(m_page->unitXComboBox, SIGNAL(currentIndexChanged(int)), _widthUnitManager, SLOT(selectApparentUnitFromIndex(int)));
+    connect(m_page->unitYComboBox, SIGNAL(currentIndexChanged(int)), _heightUnitManager, SLOT(selectApparentUnitFromIndex(int)));
+    connect(_widthUnitManager, SIGNAL(unitChanged(int)), m_page->unitXComboBox, SLOT(setCurrentIndex(int)));
+    connect(_heightUnitManager, SIGNAL(unitChanged(int)), m_page->unitYComboBox, SLOT(setCurrentIndex(int)));
 
     slotMiddleOffset();
 }
 
 DlgOffsetImage::~DlgOffsetImage()
 {
     delete m_page;
 }
 
-void DlgOffsetImage::slotOffsetXChanged(int newOffsetX)
+void DlgOffsetImage::slotOffsetXChanged(double newOffsetX)
 {
     m_offsetX = newOffsetX;
 }
 
-void DlgOffsetImage::slotOffsetYChanged(int newOffsetY)
+void DlgOffsetImage::slotOffsetYChanged(double newOffsetY)
 {
     m_offsetY = newOffsetY;
 }
 
 void DlgOffsetImage::slotMiddleOffset()
 {
     int offsetX = m_offsetSize.width() / 2;
     int offsetY = m_offsetSize.height() / 2;
-    m_page->offsetXspinBox->setValue(offsetX);
-    m_page->offsetYspinBox->setValue(offsetY);
+    m_page->offsetXdoubleSpinBox->changeValue(offsetX);
+    m_page->offsetYdoubleSpinBox->changeValue(offsetY);
 }
 
 void DlgOffsetImage::okClicked()
 {
     accept();
 }
 
 
diff --git a/plugins/extensions/offsetimage/dlg_offsetimage.h b/plugins/extensions/offsetimage/dlg_offsetimage.h
index 785d8bd2a3..5488fa6517 100644
--- a/plugins/extensions/offsetimage/dlg_offsetimage.h
+++ b/plugins/extensions/offsetimage/dlg_offsetimage.h
@@ -1,66 +1,70 @@
 /*
  * Copyright (c) 2013 Lukáš Tvrdý <lukast.dev@gmail.com>
  *
  *  This program is free software; you can redistribute it and/or modify
  *  it under the terms of the GNU General Public License as published by
  *  the Free Software Foundation; either version 2 of the License, or
  *  (at your option) any later version.
  *
  *  This program is distributed in the hope that it will be useful,
  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  *  GNU General Public License for more details.
  *
  *  You should have received a copy of the GNU General Public License
  *  along with this program; if not, write to the Free Software
  *  Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
  */
 
 #ifndef DLG_OFFSETIMAGE
 #define DLG_OFFSETIMAGE
 
 #include <KoDialog.h>
 #include <kis_global.h>
 
 #include "ui_wdg_offsetimage.h"
 
+class KisDocumentAwareSpinBoxUnitManager;
 
 class WdgOffsetImage : public QWidget, public Ui::WdgOffsetImage
 {
     Q_OBJECT
 
 public:
     WdgOffsetImage(QWidget *parent) : QWidget(parent) {
         setupUi(this);
     }
 };
 
 class DlgOffsetImage: public KoDialog
 {
 
     Q_OBJECT
 
 public:
     DlgOffsetImage(QWidget * parent = 0, const char* name = 0, QSize imageSize = QSize());
     ~DlgOffsetImage();
 
     int offsetX() const { return m_offsetX;}
     int offsetY() const { return m_offsetY;}
 
 
 private Q_SLOTS:
     void okClicked();
-    void slotOffsetXChanged(int);
-    void slotOffsetYChanged(int);
+    void slotOffsetXChanged(double);
+    void slotOffsetYChanged(double);
     void slotMiddleOffset();
 
 private:
     WdgOffsetImage * m_page;
     int m_offsetX;
     int m_offsetY;
     bool m_lock;
     QSize m_offsetSize;
 
+    KisDocumentAwareSpinBoxUnitManager* _widthUnitManager;
+    KisDocumentAwareSpinBoxUnitManager* _heightUnitManager;
+
 };
 
 #endif // DLG_OFFSETIMAGE
diff --git a/plugins/extensions/offsetimage/wdg_offsetimage.ui b/plugins/extensions/offsetimage/wdg_offsetimage.ui
index dbcf84b6bd..8a1eedac33 100644
--- a/plugins/extensions/offsetimage/wdg_offsetimage.ui
+++ b/plugins/extensions/offsetimage/wdg_offsetimage.ui
@@ -1,126 +1,132 @@
 <?xml version="1.0" encoding="UTF-8"?>
 <ui version="4.0">
  <class>WdgOffsetImage</class>
  <widget class="QWidget" name="WdgOffsetImage">
   <property name="geometry">
    <rect>
     <x>0</x>
     <y>0</y>
-    <width>203</width>
+    <width>214</width>
     <height>157</height>
    </rect>
   </property>
   <property name="windowTitle">
    <string>Rotate Image</string>
   </property>
   <layout class="QGridLayout" name="gridLayout">
    <item row="0" column="0">
     <widget class="QGroupBox" name="grpAngle">
      <property name="title">
       <string>Offset</string>
      </property>
      <layout class="QVBoxLayout">
       <item>
-       <layout class="QHBoxLayout" name="offsetRowX" stretch="0,1">
+       <layout class="QHBoxLayout" name="offsetRowX" stretch="0,0,0">
         <property name="leftMargin">
          <number>0</number>
         </property>
         <property name="topMargin">
          <number>0</number>
         </property>
         <property name="rightMargin">
          <number>0</number>
         </property>
         <property name="bottomMargin">
          <number>0</number>
         </property>
         <item>
          <widget class="QLabel" name="xLabel">
           <property name="text">
            <string>X:</string>
           </property>
           <property name="alignment">
            <set>Qt::AlignRight|Qt::AlignTrailing|Qt::AlignVCenter</set>
           </property>
          </widget>
         </item>
         <item>
-         <widget class="KisIntParseSpinBox" name="offsetXspinBox">
-          <property name="suffix">
-           <string> px</string>
-          </property>
-          <property name="maximum">
-           <number>999999999</number>
+         <widget class="KisDoubleParseUnitSpinBox" name="offsetXdoubleSpinBox">
+          <property name="sizePolicy">
+           <sizepolicy hsizetype="Expanding" vsizetype="Fixed">
+            <horstretch>0</horstretch>
+            <verstretch>0</verstretch>
+           </sizepolicy>
           </property>
          </widget>
         </item>
+        <item>
+         <widget class="QComboBox" name="unitXComboBox"/>
+        </item>
        </layout>
       </item>
       <item>
-       <layout class="QHBoxLayout" name="offsetRowY" stretch="0,1">
+       <layout class="QHBoxLayout" name="offsetRowY" stretch="0,0,0">
         <item>
          <widget class="QLabel" name="yLabel">
           <property name="text">
            <string>Y:</string>
           </property>
           <property name="alignment">
            <set>Qt::AlignRight|Qt::AlignTrailing|Qt::AlignVCenter</set>
           </property>
          </widget>
         </item>
         <item>
-         <widget class="KisIntParseSpinBox" name="offsetYspinBox">
-          <property name="suffix">
-           <string> px</string>
-          </property>
-          <property name="maximum">
-           <number>999999999</number>
+         <widget class="KisDoubleParseUnitSpinBox" name="offsetYdoubleSpinBox">
+          <property name="sizePolicy">
+           <sizepolicy hsizetype="Expanding" vsizetype="Fixed">
+            <horstretch>0</horstretch>
+            <verstretch>0</verstretch>
+           </sizepolicy>
           </property>
          </widget>
         </item>
+        <item>
+         <widget class="QComboBox" name="unitYComboBox"/>
+        </item>
        </layout>
       </item>
      </layout>
     </widget>
    </item>
    <item row="1" column="0">
     <widget class="QPushButton" name="middleOffsetBtn">
      <property name="sizePolicy">
       <sizepolicy hsizetype="Preferred" vsizetype="Fixed">
        <horstretch>0</horstretch>
        <verstretch>0</verstretch>
       </sizepolicy>
      </property>
      <property name="text">
       <string>Offset by x/2, y/2</string>
      </property>
     </widget>
    </item>
    <item row="2" column="0">
     <spacer name="spacer4">
      <property name="orientation">
       <enum>Qt::Vertical</enum>
      </property>
      <property name="sizeType">
       <enum>QSizePolicy::Minimum</enum>
      </property>
      <property name="sizeHint" stdset="0">
       <size>
        <width>0</width>
        <height>0</height>
       </size>
      </property>
     </spacer>
    </item>
   </layout>
  </widget>
  <customwidgets>
   <customwidget>
-   <class>KisIntParseSpinBox</class>
-   <extends>QSpinBox</extends>
-   <header>kis_int_parse_spin_box.h</header>
+   <class>KisDoubleParseUnitSpinBox</class>
+   <extends>QDoubleSpinBox</extends>
+   <header>kis_double_parse_unit_spin_box.h</header>
   </customwidget>
  </customwidgets>
  <resources/>
  <connections/>
 </ui>
diff --git a/plugins/flake/pathshapes/rectangle/RectangleShapeConfigWidget.cpp b/plugins/flake/pathshapes/rectangle/RectangleShapeConfigWidget.cpp
index 927cd9421d..bc6b809651 100644
--- a/plugins/flake/pathshapes/rectangle/RectangleShapeConfigWidget.cpp
+++ b/plugins/flake/pathshapes/rectangle/RectangleShapeConfigWidget.cpp
@@ -1,82 +1,84 @@
 /* This file is part of the KDE project
  * Copyright (C) 2007 Jan Hambrecht <jaham@gmx.net>
  *
  * This library is free software; you can redistribute it and/or
  * modify it under the terms of the GNU Library General Public
  * License as published by the Free Software Foundation; either
  * version 2 of the License, or (at your option) any later version.
  *
  * This library is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  * Library General Public License for more details.
  *
  * You should have received a copy of the GNU Library General Public License
  * along with this library; see the file COPYING.LIB.  If not, write to
  * the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
  * Boston, MA 02110-1301, USA.
  */
 
 #include "RectangleShapeConfigWidget.h"
 #include "RectangleShape.h"
 #include "RectangleShapeConfigCommand.h"
 
+#include "kis_document_aware_spin_box_unit_manager.h"
+
 RectangleShapeConfigWidget::RectangleShapeConfigWidget()
 {
     widget.setupUi(this);
 
     connect(widget.cornerRadiusX, SIGNAL(editingFinished()), this, SIGNAL(propertyChanged()));
     connect(widget.cornerRadiusY, SIGNAL(editingFinished()), this, SIGNAL(propertyChanged()));
 }
 
 void RectangleShapeConfigWidget::setUnit(const KoUnit &unit)
 {
     widget.cornerRadiusX->setUnit(unit);
     widget.cornerRadiusY->setUnit(unit);
 }
 
 void RectangleShapeConfigWidget::open(KoShape *shape)
 {
     m_rectangle = dynamic_cast<RectangleShape *>(shape);
     if (!m_rectangle) {
         return;
     }
 
     widget.cornerRadiusX->blockSignals(true);
     widget.cornerRadiusY->blockSignals(true);
 
     QSizeF size = m_rectangle->size();
 
     widget.cornerRadiusX->setMaximum(0.5 * size.width());
     widget.cornerRadiusX->changeValue(0.01 * m_rectangle->cornerRadiusX() * 0.5 * size.width());
     widget.cornerRadiusY->setMaximum(0.5 * size.height());
     widget.cornerRadiusY->changeValue(0.01 * m_rectangle->cornerRadiusY() * 0.5 * size.height());
 
     widget.cornerRadiusX->blockSignals(false);
     widget.cornerRadiusY->blockSignals(false);
 }
 
 void RectangleShapeConfigWidget::save()
 {
     if (!m_rectangle) {
         return;
     }
 
     QSizeF size = m_rectangle->size();
 
     m_rectangle->setCornerRadiusX(100.0 * widget.cornerRadiusX->value() / (0.5 * size.width()));
     m_rectangle->setCornerRadiusY(100.0 * widget.cornerRadiusY->value() / (0.5 * size.height()));
 }
 
 KUndo2Command *RectangleShapeConfigWidget::createCommand()
 {
     if (!m_rectangle) {
         return 0;
     }
     QSizeF size = m_rectangle->size();
 
     qreal cornerRadiusX = 100.0 * widget.cornerRadiusX->value() / (0.5 * size.width());
     qreal cornerRadiusY = 100.0 * widget.cornerRadiusY->value() / (0.5 * size.height());
 
     return new RectangleShapeConfigCommand(m_rectangle, cornerRadiusX, cornerRadiusY);
 }
diff --git a/plugins/flake/pathshapes/star/StarShapeConfigWidget.cpp b/plugins/flake/pathshapes/star/StarShapeConfigWidget.cpp
index 502f1511cd..0d203d231b 100644
--- a/plugins/flake/pathshapes/star/StarShapeConfigWidget.cpp
+++ b/plugins/flake/pathshapes/star/StarShapeConfigWidget.cpp
@@ -1,93 +1,95 @@
 /* This file is part of the KDE project
  * Copyright (C) 2007 Jan Hambrecht <jaham@gmx.net>
  *
  * This library is free software; you can redistribute it and/or
  * modify it under the terms of the GNU Library General Public
  * License as published by the Free Software Foundation; either
  * version 2 of the License, or (at your option) any later version.
  *
  * This library is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  * Library General Public License for more details.
  *
  * You should have received a copy of the GNU Library General Public License
  * along with this library; see the file COPYING.LIB.  If not, write to
  * the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
  * Boston, MA 02110-1301, USA.
  */
 
 #include "StarShapeConfigWidget.h"
 #include "StarShape.h"
 #include "StarShapeConfigCommand.h"
 
+#include "kis_document_aware_spin_box_unit_manager.h"
+
 StarShapeConfigWidget::StarShapeConfigWidget()
 {
     widget.setupUi(this);
 
     connect(widget.corners, SIGNAL(valueChanged(int)), this, SIGNAL(propertyChanged()));
     connect(widget.innerRadius, SIGNAL(editingFinished()), this, SIGNAL(propertyChanged()));
     connect(widget.outerRadius, SIGNAL(editingFinished()), this, SIGNAL(propertyChanged()));
     connect(widget.convex, SIGNAL(stateChanged(int)), this, SIGNAL(propertyChanged()));
     connect(widget.convex, SIGNAL(clicked()), this, SLOT(typeChanged()));
 }
 
 void StarShapeConfigWidget::setUnit(const KoUnit &unit)
 {
     widget.innerRadius->setUnit(unit);
     widget.outerRadius->setUnit(unit);
 }
 
 void StarShapeConfigWidget::open(KoShape *shape)
 {
     m_star = dynamic_cast<StarShape *>(shape);
     if (!m_star) {
         return;
     }
 
     widget.corners->blockSignals(true);
     widget.innerRadius->blockSignals(true);
     widget.outerRadius->blockSignals(true);
     widget.convex->blockSignals(true);
 
     widget.corners->setValue(m_star->cornerCount());
     widget.innerRadius->changeValue(m_star->baseRadius());
     widget.outerRadius->changeValue(m_star->tipRadius());
     widget.convex->setCheckState(m_star->convex() ? Qt::Checked : Qt::Unchecked);
     typeChanged();
 
     widget.corners->blockSignals(false);
     widget.innerRadius->blockSignals(false);
     widget.outerRadius->blockSignals(false);
     widget.convex->blockSignals(false);
 }
 
 void StarShapeConfigWidget::save()
 {
     if (!m_star) {
         return;
     }
 
     m_star->setCornerCount(widget.corners->value());
     m_star->setBaseRadius(widget.innerRadius->value());
     m_star->setTipRadius(widget.outerRadius->value());
     m_star->setConvex(widget.convex->checkState() == Qt::Checked);
 }
 
 KUndo2Command *StarShapeConfigWidget::createCommand()
 {
     if (!m_star) {
         return 0;
     } else
         return new StarShapeConfigCommand(m_star, widget.corners->value(), widget.innerRadius->value(),
                                           widget.outerRadius->value(), widget.convex->checkState() == Qt::Checked);
 }
 
 void StarShapeConfigWidget::typeChanged()
 {
     if (widget.convex->checkState() == Qt::Checked) {
         widget.innerRadius->setEnabled(false);
     } else {
         widget.innerRadius->setEnabled(true);
     }
 }
diff --git a/plugins/impex/brush/kis_brush_export.h b/plugins/impex/brush/kis_brush_export.h
index 2e3d262cbc..e901009b46 100644
--- a/plugins/impex/brush/kis_brush_export.h
+++ b/plugins/impex/brush/kis_brush_export.h
@@ -1,61 +1,61 @@
 /*
  *  Copyright (c) 2016 Boudewijn Rempt <boud@valdyas.org>
  *
  *  This program is free software; you can redistribute it and/or modify
  *  it under the terms of the GNU General Public License as published by
  *  the Free Software Foundation; either version 2 of the License, or
  *  (at your option) any later version.
  *
  *  This program is distributed in the hope that it will be useful,
  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  *  GNU General Public License for more details.
  *
  *  You should have received a copy of the GNU General Public License
  *  along with this program; if not, write to the Free Software
  *  Foundation, Inc., 51 Franklin Street, Fifth Floor,
  * Boston, MA 02110-1301, USA.
  */
 
 #ifndef _KIS_Brush_EXPORT_H_
 #define _KIS_Brush_EXPORT_H_
 
 #include <QVariant>
 
 #include <KisImportExportFilter.h>
 #include <ui_wdg_export_gih.h>
 #include <kis_config_widget.h>
 #include <kis_properties_configuration.h>
 
 class KisWdgOptionsBrush : public KisConfigWidget, public Ui::WdgExportGih
 {
     Q_OBJECT
 
 public:
     KisWdgOptionsBrush(QWidget *parent)
         : KisConfigWidget(parent)
     {
         setupUi(this);
     }
 
     void setConfiguration(const KisPropertiesConfigurationSP  cfg);
     KisPropertiesConfigurationSP configuration() const;
 };
 
 
 class KisBrushExport : public KisImportExportFilter
 {
     Q_OBJECT
 public:
     KisBrushExport(QObject *parent, const QVariantList &);
     virtual ~KisBrushExport();
-public:
+    virtual bool supportsIO() const { return false; }
     virtual KisImportExportFilter::ConversionStatus convert(KisDocument *document, QIODevice *io,  KisPropertiesConfigurationSP configuration = 0);
     KisPropertiesConfigurationSP defaultConfiguration(const QByteArray& from = "", const QByteArray& to = "") const;
     KisPropertiesConfigurationSP lastSavedConfiguration(const QByteArray &from = "", const QByteArray &to = "") const;
     KisConfigWidget *createConfigurationWidget(QWidget *parent, const QByteArray& from = "", const QByteArray& to = "") const;
 
     void initializeCapabilities();
 };
 
 #endif
diff --git a/plugins/impex/exr/exr_export.h b/plugins/impex/exr/exr_export.h
index a1950b9a9a..23cd869859 100644
--- a/plugins/impex/exr/exr_export.h
+++ b/plugins/impex/exr/exr_export.h
@@ -1,59 +1,60 @@
 /*
  *  Copyright (c) 2010 Cyrille Berger <cberger@cberger.net>
  *
  *  This program is free software; you can redistribute it and/or modify
  *  it under the terms of the GNU General Public License as published by
  *  the Free Software Foundation; either version 2 of the License, or
  *  (at your option) any later version.
  *
  *  This program is distributed in the hope that it will be useful,
  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  *  GNU General Public License for more details.
  *
  *  You should have received a copy of the GNU General Public License
  *  along with this program; if not, write to the Free Software
  *  Foundation, Inc., 51 Franklin Street, Fifth Floor,
  * Boston, MA 02110-1301, USA.
  */
 
 #ifndef _EXR_EXPORT_H_
 #define _EXR_EXPORT_H_
 
 #include <QVariant>
 
 #include <KisImportExportFilter.h>
 #include <kis_config_widget.h>
 #include "ui_exr_export_widget.h"
 
 class KisWdgOptionsExr : public KisConfigWidget, public Ui::ExrExportWidget
 {
     Q_OBJECT
 
 public:
     KisWdgOptionsExr(QWidget *parent)
         : KisConfigWidget(parent)
     {
         setupUi(this);
     }
 
     void setConfiguration(const KisPropertiesConfigurationSP  cfg);
     KisPropertiesConfigurationSP configuration() const;
 };
 
 
 class EXRExport : public KisImportExportFilter
 {
     Q_OBJECT
 public:
     EXRExport(QObject *parent, const QVariantList &);
     virtual ~EXRExport();
+    virtual bool supportsIO() const { return false; }
     virtual KisImportExportFilter::ConversionStatus convert(KisDocument *document, QIODevice *io,  KisPropertiesConfigurationSP configuration = 0);
     KisPropertiesConfigurationSP defaultConfiguration(const QByteArray& from = "", const QByteArray& to = "") const;
     KisPropertiesConfigurationSP lastSavedConfiguration(const QByteArray &from = "", const QByteArray &to = "") const;
     KisConfigWidget *createConfigurationWidget(QWidget *parent, const QByteArray& from = "", const QByteArray& to = "") const;
     void initializeCapabilities();
 
 };
 
 #endif
diff --git a/plugins/impex/exr/exr_import.h b/plugins/impex/exr/exr_import.h
index eb6ed2cb5f..52adab72b7 100644
--- a/plugins/impex/exr/exr_import.h
+++ b/plugins/impex/exr/exr_import.h
@@ -1,37 +1,37 @@
 /*
  *  Copyright (c) 2010 Cyrille Berger <cberger@cberger.net>
  *
  *  This program is free software; you can redistribute it and/or modify
  *  it under the terms of the GNU General Public License as published by
  *  the Free Software Foundation; either version 2 of the License, or
  *  (at your option) any later version.
  *
  *  This program is distributed in the hope that it will be useful,
  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  *  GNU General Public License for more details.
  *
  *  You should have received a copy of the GNU General Public License
  *  along with this program; if not, write to the Free Software
  *  Foundation, Inc., 51 Franklin Street, Fifth Floor,
  * Boston, MA 02110-1301, USA.
  */
 
 #ifndef EXR_IMPORT_H_
 #define EXR_IMPORT_H_
 
 #include <QVariant>
 
 #include <KisImportExportFilter.h>
 
 class exrImport : public KisImportExportFilter
 {
     Q_OBJECT
 public:
     exrImport(QObject *parent, const QVariantList &);
     virtual ~exrImport();
-public:
+    virtual bool supportsIO() const { return false; }
     virtual KisImportExportFilter::ConversionStatus convert(KisDocument *document, QIODevice *io,  KisPropertiesConfigurationSP configuration = 0);
 };
 
 #endif
diff --git a/plugins/impex/spriter/kis_spriter_export.h b/plugins/impex/spriter/kis_spriter_export.h
index d620f17493..04f9632a7d 100644
--- a/plugins/impex/spriter/kis_spriter_export.h
+++ b/plugins/impex/spriter/kis_spriter_export.h
@@ -1,135 +1,135 @@
 /*
  *  Copyright (c) 2016 Boudewijn Rempt <boud@valdyas.org>
  *
  *  This program is free software; you can redistribute it and/or modify
  *  it under the terms of the GNU General Public License as published by
  *  the Free Software Foundation; either version 2 of the License, or
  *  (at your option) any later version.
  *
  *  This program is distributed in the hope that it will be useful,
  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  *  GNU General Public License for more details.
  *
  *  You should have received a copy of the GNU General Public License
  *  along with this program; if not, write to the Free Software
  *  Foundation, Inc., 51 Franklin Street, Fifth Floor,
  * Boston, MA 02110-1301, USA.
  */
 
 #ifndef _KIS_SPRITER_EXPORT_H_
 #define _KIS_SPRITER_EXPORT_H_
 
 #include <QVariant>
 #include <QDomDocument>
 #include <QList>
 
 #include <KisImportExportFilter.h>
 #include <kis_types.h>
 
 struct SpriterFile {
     qreal id;
     QString name;
     QString pathName;
     QString baseName;
     QString layerName;
     qreal width;
     qreal height;
     qreal x;
     qreal y;
 };
 
 struct Folder {
     qreal id;
     QString name;
     QString pathName;
     QString baseName;
     QString groupName;
     QList<SpriterFile> files;
 };
 
 struct Bone {
     qreal id;
     const Bone *parentBone;
     QString name;
     qreal x;
     qreal y;
     qreal width;
     qreal height;
     qreal localX;
     qreal localY;
     qreal localAngle;
     qreal localScaleX;
     qreal localScaleY;
     qreal fixLocalX;
     qreal fixLocalY;
     qreal fixLocalAngle;
     qreal fixLocalScaleX;
     qreal fixLocalScaleY;
     QList<Bone*> bones;
 
     ~Bone() {
         qDeleteAll(bones);
         bones.clear();;
     }
 };
 
 struct SpriterSlot {
     QString name;
     bool defaultAttachmentFlag;
 };
 
 struct SpriterObject {
     qreal id;
     qreal folderId;
     qreal fileId;
     Bone *bone;
     SpriterSlot *slot;
     qreal x;
     qreal y;
     qreal localX;
     qreal localY;
     qreal localAngle;
     qreal localScaleX;
     qreal localScaleY;
     qreal fixLocalX;
     qreal fixLocalY;
     qreal fixLocalAngle;
     qreal fixLocalScaleX;
     qreal fixLocalScaleY;
 
     ~SpriterObject() {
         delete slot;
     }
 };
 
 class KisSpriterExport : public KisImportExportFilter
 {
     Q_OBJECT
 public:
     KisSpriterExport(QObject *parent, const QVariantList &);
     virtual ~KisSpriterExport();
-public:
+    virtual bool supportsIO() const { return false; }
     virtual KisImportExportFilter::ConversionStatus convert(KisDocument *document, QIODevice *io,  KisPropertiesConfigurationSP configuration = 0);
     void initializeCapabilities();
 private:
 
     bool savePaintDevice(KisPaintDeviceSP dev, const QString &fileName);
     void parseFolder(KisGroupLayerSP parentGroup, const QString &folderName, const QString &basePath, int *folderId = 0);
     Bone *parseBone(const Bone *parent, KisGroupLayerSP groupLayer);
     void fixBone(Bone *bone);
     void fillScml(QDomDocument &scml, const QString &entityName);
     void writeBoneRef(const Bone *bone, QDomElement &mainline, QDomDocument &scml);
     void writeBone(const Bone *bone, QDomElement &timeline, QDomDocument &scml);
 
     KisImageSP m_image;
     qreal m_timelineid;
     QList<Folder> m_folders;
     Bone *m_rootBone;
     QList<SpriterObject> m_objects;
     KisGroupLayerSP m_rootLayer; // Not the image's root later, but the one that is named "root"
     KisLayerSP m_boneLayer;
 
 };
 
 #endif
diff --git a/plugins/impex/tiff/kis_tiff_export.h b/plugins/impex/tiff/kis_tiff_export.h
index 4bd4517bbd..6def27cfac 100644
--- a/plugins/impex/tiff/kis_tiff_export.h
+++ b/plugins/impex/tiff/kis_tiff_export.h
@@ -1,42 +1,42 @@
 /*
  *  Copyright (c) 2005 Cyrille Berger <cberger@cberger.net>
  *
  *  This program is free software; you can redistribute it and/or modify
  *  it under the terms of the GNU General Public License as published by
  *  the Free Software Foundation; either version 2 of the License, or
  *  (at your option) any later version.
  *
  *  This program is distributed in the hope that it will be useful,
  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  *  GNU General Public License for more details.
  *
  *  You should have received a copy of the GNU General Public License
  *  along with this program; if not, write to the Free Software
  *  Foundation, Inc., 51 Franklin Street, Fifth Floor,
  * Boston, MA 02110-1301, USA.
  */
 
 #ifndef _KIS_TIFF_EXPORT_H_
 #define _KIS_TIFF_EXPORT_H_
 
 #include <QVariant>
 
 #include <KisImportExportFilter.h>
 #include <kis_config_widget.h>
 
 class KisTIFFExport : public KisImportExportFilter
 {
     Q_OBJECT
 public:
     KisTIFFExport(QObject *parent, const QVariantList &);
     virtual ~KisTIFFExport();
-public:
+    virtual bool supportsIO() const { return false; }
     virtual KisImportExportFilter::ConversionStatus convert(KisDocument *document, QIODevice *io,  KisPropertiesConfigurationSP configuration = 0);
     KisPropertiesConfigurationSP defaultConfiguration(const QByteArray& from = "", const QByteArray& to = "") const;
     KisPropertiesConfigurationSP lastSavedConfiguration(const QByteArray &from = "", const QByteArray &to = "") const;
     KisConfigWidget *createConfigurationWidget(QWidget *parent, const QByteArray& from = "", const QByteArray& to = "") const;
     void initializeCapabilities();
 };
 
 #endif
diff --git a/plugins/impex/tiff/kis_tiff_import.h b/plugins/impex/tiff/kis_tiff_import.h
index 99e04c4a38..78b85bd6ef 100644
--- a/plugins/impex/tiff/kis_tiff_import.h
+++ b/plugins/impex/tiff/kis_tiff_import.h
@@ -1,36 +1,37 @@
 /*
  *  Copyright (c) 2005 Cyrille Berger <cberger@cberger.net>
  *
  *  This program is free software; you can redistribute it and/or modify
  *  it under the terms of the GNU General Public License as published by
  *  the Free Software Foundation; either version 2 of the License, or
  *  (at your option) any later version.
  *
  *  This program is distributed in the hope that it will be useful,
  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  *  GNU General Public License for more details.
  *
  *  You should have received a copy of the GNU General Public License
  *  along with this program; if not, write to the Free Software
  *  Foundation, Inc., 51 Franklin Street, Fifth Floor,
  * Boston, MA 02110-1301, USA.
  */
 #ifndef _KIS_TIFF_IMPORT_H_
 #define _KIS_TIFF_IMPORT_H_
 
 #include <QVariant>
 
 #include <KisImportExportFilter.h>
 
 class KisTIFFImport : public KisImportExportFilter
 {
     Q_OBJECT
 public:
     KisTIFFImport(QObject *parent, const QVariantList &);
     virtual ~KisTIFFImport();
+    virtual bool supportsIO() const { return false; }
 public:
     virtual KisImportExportFilter::ConversionStatus convert(KisDocument *document, QIODevice *io,  KisPropertiesConfigurationSP configuration = 0);
 };
 
 #endif
diff --git a/plugins/impex/video/kis_video_export.h b/plugins/impex/video/kis_video_export.h
index 4c1edf0c4a..6daadd5d97 100644
--- a/plugins/impex/video/kis_video_export.h
+++ b/plugins/impex/video/kis_video_export.h
@@ -1,42 +1,43 @@
 /*
  *  Copyright (c) 2016 Dmitry Kazakov <dimula73@gmail.com>
  *
  *  This program is free software; you can redistribute it and/or modify
  *  it under the terms of the GNU General Public License as published by
  *  the Free Software Foundation; either version 2 of the License, or
  *  (at your option) any later version.
  *
  *  This program is distributed in the hope that it will be useful,
  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  *  GNU General Public License for more details.
  *
  *  You should have received a copy of the GNU General Public License
  *  along with this program; if not, write to the Free Software
  *  Foundation, Inc., 51 Franklin Street, Fifth Floor,
  * Boston, MA 02110-1301, USA.
  */
 
 #ifndef _KIS_VIDEO_EXPORT_H_
 #define _KIS_VIDEO_EXPORT_H_
 
 #include <QVariant>
 
 #include <KisImportExportFilter.h>
 
 class KisVideoExport : public KisImportExportFilter
 {
     Q_OBJECT
 public:
     KisVideoExport(QObject *parent, const QVariantList &);
     virtual ~KisVideoExport();
 public:
+    virtual bool supportsIO() const { return false; }
     virtual KisImportExportFilter::ConversionStatus convert(KisDocument *document, QIODevice *io,  KisPropertiesConfigurationSP configuration = 0);
 
     KisPropertiesConfigurationSP defaultConfiguration(const QByteArray& from, const QByteArray& to) const;
     KisPropertiesConfigurationSP lastSavedConfiguration(const QByteArray &from, const QByteArray &to) const;
     KisConfigWidget *createConfigurationWidget(QWidget *parent, const QByteArray& from = "", const QByteArray& to = "") const;
 
 };
 
 #endif
diff --git a/plugins/paintops/libpaintop/kis_brush_based_paintop_settings.cpp b/plugins/paintops/libpaintop/kis_brush_based_paintop_settings.cpp
index 2d378181f5..fb4e3c612e 100644
--- a/plugins/paintops/libpaintop/kis_brush_based_paintop_settings.cpp
+++ b/plugins/paintops/libpaintop/kis_brush_based_paintop_settings.cpp
@@ -1,340 +1,342 @@
 /*
  *  Copyright (c) 2010 Sven Langkamp <sven.langkamp@gmail.com>
  *
  *  This program is free software; you can redistribute it and/or modify
  *  it under the terms of the GNU General Public License as published by
  *  the Free Software Foundation; either version 2 of the License, or
  *  (at your option) any later version.
  *
  *  This program is distributed in the hope that it will be useful,
  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  *  GNU General Public License for more details.
  *
  *  You should have received a copy of the GNU General Public License
  *  along with this program; if not, write to the Free Software
  *  Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
  */
 
 #include "kis_brush_based_paintop_settings.h"
 
 #include <kis_paint_action_type_option.h>
 #include <kis_airbrush_option.h>
 #include "kis_brush_based_paintop_options_widget.h"
 #include <kis_boundary.h>
 #include "kis_brush_server.h"
 #include <QLineF>
 #include "kis_signals_blocker.h"
 #include "kis_brush_option.h"
 
 struct BrushReader {
     BrushReader(const KisBrushBasedPaintOpSettings *parent)
         : m_parent(parent)
     {
         m_option.readOptionSetting(m_parent);
     }
 
     KisBrushSP brush() {
         return m_option.brush();
     }
 
     const KisBrushBasedPaintOpSettings *m_parent;
     KisBrushOption m_option;
 };
 
 struct BrushWriter {
     BrushWriter(KisBrushBasedPaintOpSettings *parent)
         : m_parent(parent)
     {
         m_option.readOptionSetting(m_parent);
     }
 
     ~BrushWriter() {
         m_option.writeOptionSetting(m_parent);
     }
 
     KisBrushSP brush() {
         return m_option.brush();
     }
 
     KisBrushBasedPaintOpSettings *m_parent;
     KisBrushOption m_option;
 };
 
 
 KisBrushBasedPaintOpSettings::KisBrushBasedPaintOpSettings()
     : KisOutlineGenerationPolicy<KisPaintOpSettings>(KisCurrentOutlineFetcher::SIZE_OPTION |
             KisCurrentOutlineFetcher::ROTATION_OPTION |
             KisCurrentOutlineFetcher::MIRROR_OPTION)
 {
 }
 
 bool KisBrushBasedPaintOpSettings::paintIncremental()
 {
     if (hasProperty("PaintOpAction")) {
         return (enumPaintActionType)getInt("PaintOpAction", WASH) == BUILDUP;
     }
     return true;
 }
 
 bool KisBrushBasedPaintOpSettings::isAirbrushing() const
 {
     return getBool(AIRBRUSH_ENABLED);
 }
 
 
 int KisBrushBasedPaintOpSettings::rate() const
 {
     return getInt(AIRBRUSH_RATE);
 }
 
 KisPaintOpSettingsSP KisBrushBasedPaintOpSettings::clone() const
 {
     KisPaintOpSettingsSP _settings = KisOutlineGenerationPolicy<KisPaintOpSettings>::clone();
     KisBrushBasedPaintOpSettingsSP settings = dynamic_cast<KisBrushBasedPaintOpSettings*>(_settings.data());
     settings->m_savedBrush = this->brush();
     return settings;
 }
 
 KisBrushSP KisBrushBasedPaintOpSettings::brush() const
 {
     KisBrushSP brush = m_savedBrush;
 
     if (!brush) {
         BrushReader w(this);
         brush = w.brush();
         m_savedBrush = brush;
     }
 
     return brush;
 }
 
 QPainterPath KisBrushBasedPaintOpSettings::brushOutlineImpl(const KisPaintInformation &info,
                                                             OutlineMode mode,
                                                             qreal additionalScale,
                                                             bool forceOutline)
 {
     QPainterPath path;
 
     if (forceOutline || mode == CursorIsOutline || mode == CursorIsCircleOutline || mode == CursorTiltOutline) {
         KisBrushSP brush = this->brush();
         if (!brush) return path;
         qreal finalScale = brush->scale() * additionalScale;
 
         QPainterPath realOutline = brush->outline();
 
         if (mode == CursorIsCircleOutline || mode == CursorTiltOutline ||
             (forceOutline && mode == CursorNoOutline)) {
 
             QPainterPath ellipse;
             ellipse.addEllipse(realOutline.boundingRect());
             realOutline = ellipse;
         }
 
         path = outlineFetcher()->fetchOutline(info, this, realOutline, finalScale, brush->angle());
 
         if (mode == CursorTiltOutline) {
             QPainterPath tiltLine = makeTiltIndicator(info,
                 realOutline.boundingRect().center(),
                 realOutline.boundingRect().width() * 0.5,
                 3.0);
             path.addPath(outlineFetcher()->fetchOutline(info, this, tiltLine, finalScale, 0.0, true, realOutline.boundingRect().center().x(), realOutline.boundingRect().center().y()));
         }
     }
 
     return path;
 }
 
 QPainterPath KisBrushBasedPaintOpSettings::brushOutline(const KisPaintInformation &info, OutlineMode mode)
 {
     return brushOutlineImpl(info, mode, 1.0);
 }
 
 bool KisBrushBasedPaintOpSettings::isValid() const
 {
     QString filename = getString("requiredBrushFile", QString());
     if (!filename.isEmpty()) {
         KisBrushSP brush = KisBrushServer::instance()->brushServer()->resourceByFilename(filename);
         if (!brush) {
             return false;
         }
     }
     return true;
 }
 
 bool KisBrushBasedPaintOpSettings::isLoadable()
 {
     return (KisBrushServer::instance()->brushServer()->resources().count() > 0);
 }
 
 void KisBrushBasedPaintOpSettings::setAngle(qreal value)
 {
     BrushWriter w(this);
     if (!w.brush()) return;
     w.brush()->setAngle(value);
 }
 
 qreal KisBrushBasedPaintOpSettings::angle()
 {
     return this->brush()->angle();
 }
 
 void KisBrushBasedPaintOpSettings::setSpacing(qreal value)
 {
     BrushWriter w(this);
     if (!w.brush()) return;
     w.brush()->setSpacing(value);
 }
 
 qreal KisBrushBasedPaintOpSettings::spacing()
 {
     return this->brush()->spacing();
 }
 
 void KisBrushBasedPaintOpSettings::setAutoSpacing(bool active, qreal coeff)
 {
     BrushWriter w(this);
     if (!w.brush()) return;
     w.brush()->setAutoSpacing(active, coeff);
 }
 
 
 bool KisBrushBasedPaintOpSettings::autoSpacingActive()
 {
     return this->brush()->autoSpacingActive();
 }
 
 qreal KisBrushBasedPaintOpSettings::autoSpacingCoeff()
 {
     return this->brush()->autoSpacingCoeff();
 }
 
 void KisBrushBasedPaintOpSettings::setPaintOpSize(qreal value)
 {
     BrushWriter w(this);
     if (!w.brush()) return;
 
     w.brush()->setUserEffectiveSize(value);
 }
 
 qreal KisBrushBasedPaintOpSettings::paintOpSize() const
 {
     return this->brush()->userEffectiveSize();
 }
 
 
 
 #include <brushengine/kis_slider_based_paintop_property.h>
 #include "kis_paintop_preset.h"
 #include "kis_paintop_settings_update_proxy.h"
 
 QList<KisUniformPaintOpPropertySP> KisBrushBasedPaintOpSettings::uniformProperties(KisPaintOpSettingsSP settings)
 {
     QList<KisUniformPaintOpPropertySP> props =
         listWeakToStrong(m_uniformProperties);
 
     if (props.isEmpty()) {
         {
             KisIntSliderBasedPaintOpPropertyCallback *prop =
                 new KisIntSliderBasedPaintOpPropertyCallback(
                     KisIntSliderBasedPaintOpPropertyCallback::Int,
                     "angle",
                     "Angle",
                     settings, 0);
 
             prop->setRange(0, 360);
 
             prop->setReadCallback(
                 [](KisUniformPaintOpProperty *prop) {
                     KisBrushBasedPaintOpSettings *s =
                         dynamic_cast<KisBrushBasedPaintOpSettings*>(prop->settings().data());
 
                     const qreal angleResult = kisRadiansToDegrees(s->angle());
                     prop->setValue(angleResult);
                 });
             prop->setWriteCallback(
                 [](KisUniformPaintOpProperty *prop) {
                     KisBrushBasedPaintOpSettings *s =
                         dynamic_cast<KisBrushBasedPaintOpSettings*>(prop->settings().data());
 
                     s->setAngle(kisDegreesToRadians(prop->value().toReal()));
                 });
 
             QObject::connect(preset()->updateProxy(), SIGNAL(sigSettingsChanged()), prop, SLOT(requestReadValue()));
             prop->requestReadValue();
             props << toQShared(prop);
         }
         {
             KisUniformPaintOpPropertyCallback *prop =
                 new KisUniformPaintOpPropertyCallback(
                     KisUniformPaintOpPropertyCallback::Bool,
                     "auto_spacing",
                     "Auto Spacing",
                     settings, 0);
 
             prop->setReadCallback(
                 [](KisUniformPaintOpProperty *prop) {
                     KisBrushBasedPaintOpSettings *s =
                         dynamic_cast<KisBrushBasedPaintOpSettings*>(prop->settings().data());
 
                     prop->setValue(s->autoSpacingActive());
                 });
             prop->setWriteCallback(
                 [](KisUniformPaintOpProperty *prop) {
                     KisBrushBasedPaintOpSettings *s =
                         dynamic_cast<KisBrushBasedPaintOpSettings*>(prop->settings().data());
 
                     s->setAutoSpacing(prop->value().toBool(), s->autoSpacingCoeff());
                 });
 
             QObject::connect(preset()->updateProxy(), SIGNAL(sigSettingsChanged()), prop, SLOT(requestReadValue()));
             prop->requestReadValue();
             props << toQShared(prop);
         }
 
         {
             KisDoubleSliderBasedPaintOpPropertyCallback *prop =
                 new KisDoubleSliderBasedPaintOpPropertyCallback(
                     KisDoubleSliderBasedPaintOpPropertyCallback::Double,
                     "spacing",
                     "Spacing",
                     settings, 0);
 
             prop->setRange(0.01, 10);
             prop->setSingleStep(0.01);
+            prop->setExponentRatio(3.0);
+
 
             prop->setReadCallback(
                 [](KisUniformPaintOpProperty *prop) {
                     KisBrushBasedPaintOpSettings *s =
                         dynamic_cast<KisBrushBasedPaintOpSettings*>(prop->settings().data());
 
                     const qreal value = s->autoSpacingActive() ?
                         s->autoSpacingCoeff() : s->spacing();
                     prop->setValue(value);
                 });
             prop->setWriteCallback(
                 [](KisUniformPaintOpProperty *prop) {
                     KisBrushBasedPaintOpSettings *s =
                         dynamic_cast<KisBrushBasedPaintOpSettings*>(prop->settings().data());
 
                     if (s->autoSpacingActive()) {
                         s->setAutoSpacing(true, prop->value().toReal());
                     } else {
                         s->setSpacing(prop->value().toReal());
                     }
                 });
 
             QObject::connect(preset()->updateProxy(), SIGNAL(sigSettingsChanged()), prop, SLOT(requestReadValue()));
             prop->requestReadValue();
             props << toQShared(prop);
         }
     }
 
     return KisPaintOpSettings::uniformProperties(settings) + props;
 }
 
 void KisBrushBasedPaintOpSettings::onPropertyChanged()
 {
     m_savedBrush.clear();
     KisOutlineGenerationPolicy<KisPaintOpSettings>::onPropertyChanged();
 }
diff --git a/plugins/paintops/libpaintop/kis_spacing_selection_widget.cpp b/plugins/paintops/libpaintop/kis_spacing_selection_widget.cpp
index 3d486c6cf7..4723ea69aa 100644
--- a/plugins/paintops/libpaintop/kis_spacing_selection_widget.cpp
+++ b/plugins/paintops/libpaintop/kis_spacing_selection_widget.cpp
@@ -1,129 +1,130 @@
 /*
  *  Copyright (c) 2014 Dmitry Kazakov <dimula73@gmail.com>
  *
  *  This program is free software; you can redistribute it and/or modify
  *  it under the terms of the GNU General Public License as published by
  *  the Free Software Foundation; either version 2 of the License, or
  *  (at your option) any later version.
  *
  *  This program is distributed in the hope that it will be useful,
  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  *  GNU General Public License for more details.
  *
  *  You should have received a copy of the GNU General Public License
  *  along with this program; if not, write to the Free Software
  *  Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
  */
 
 #include "kis_spacing_selection_widget.h"
 
 #include <QCheckBox>
 #include <QHBoxLayout>
 
 #include "klocalizedstring.h"
 
 #include "kis_signals_blocker.h"
 #include "kis_slider_spin_box.h"
 
 
 
 struct KisSpacingSelectionWidget::Private
 {
     Private(KisSpacingSelectionWidget *_q)
         : q(_q), oldSliderValue(0.1)
     {
     }
 
     KisSpacingSelectionWidget *q;
 
     KisDoubleSliderSpinBox *slider;
     QCheckBox *autoButton;
 
     qreal oldSliderValue;
 
     void slotSpacingChanged(qreal value);
     void slotAutoSpacing(bool value);
 };
 
 
 KisSpacingSelectionWidget::KisSpacingSelectionWidget(QWidget *parent)
     : QWidget(parent),
       m_d(new Private(this))
 {
     m_d->slider = new KisDoubleSliderSpinBox(this);
-    m_d->slider->setRange(0.0, 10.0, 2);
+    m_d->slider->setRange(0.01, 10.0, 2);
+    m_d->slider->setExponentRatio(3);
     m_d->slider->setSingleStep(0.01);
     m_d->slider->setValue(0.1);
     m_d->slider->setSizePolicy(QSizePolicy(QSizePolicy::MinimumExpanding, QSizePolicy::Fixed));
 
 
     m_d->autoButton = new QCheckBox(this);
     m_d->autoButton->setText(i18nc("@action:button", "Auto"));
     m_d->autoButton->setToolTip(i18nc("@info:tooltip", "In auto mode the spacing of the brush will be calculated automatically depending on its size"));
     m_d->autoButton->setCheckable(true);
     m_d->autoButton->setSizePolicy(QSizePolicy(QSizePolicy::Minimum, QSizePolicy::Fixed));
 
     QHBoxLayout *layout = new QHBoxLayout(this);
     layout->addWidget(m_d->autoButton);
     layout->addWidget(m_d->slider);
     layout->setMargin(0);
 
     connect(m_d->slider, SIGNAL(valueChanged(qreal)), SLOT(slotSpacingChanged(qreal)));
     connect(m_d->autoButton, SIGNAL(toggled(bool)), SLOT(slotAutoSpacing(bool)));
 }
 
 KisSpacingSelectionWidget::~KisSpacingSelectionWidget()
 {
 }
 
 qreal KisSpacingSelectionWidget::spacing() const
 {
     return autoSpacingActive() ? 0.1 : m_d->slider->value();
 }
 
 bool KisSpacingSelectionWidget::autoSpacingActive() const
 {
     return m_d->autoButton->isChecked();
 }
 
 qreal KisSpacingSelectionWidget::autoSpacingCoeff() const
 {
     return autoSpacingActive() ? m_d->slider->value() : 1.0;
 }
 
 void KisSpacingSelectionWidget::setSpacing(bool isAuto, qreal spacing)
 {
     KisSignalsBlocker b1(m_d->autoButton);
     KisSignalsBlocker b2(m_d->slider);
 
     m_d->autoButton->setChecked(isAuto);
     m_d->slider->setValue(spacing);
 }
 
 void KisSpacingSelectionWidget::Private::slotSpacingChanged(qreal value)
 {
     Q_UNUSED(value);
     emit q->sigSpacingChanged();
 }
 
 void KisSpacingSelectionWidget::Private::slotAutoSpacing(bool value)
 {
     qreal newSliderValue = 0.0;
 
     if (value) {
         newSliderValue = 1.0;
         oldSliderValue = slider->value();
     } else {
         newSliderValue = oldSliderValue;
     }
 
     {
         KisSignalsBlocker b(slider);
         slider->setValue(newSliderValue);
     }
 
     emit q->sigSpacingChanged();
 }
 
 #include "moc_kis_spacing_selection_widget.moc"
diff --git a/plugins/paintops/spray/kis_spray_paintop_settings.cpp b/plugins/paintops/spray/kis_spray_paintop_settings.cpp
index 6138ede053..154562824b 100644
--- a/plugins/paintops/spray/kis_spray_paintop_settings.cpp
+++ b/plugins/paintops/spray/kis_spray_paintop_settings.cpp
@@ -1,238 +1,239 @@
 /*
  *  Copyright (c) 2008,2009,2010 Lukáš Tvrdý <lukast.dev@gmail.com>
  *
  *  This program is free software; you can redistribute it and/or modify
  *  it under the terms of the GNU General Public License as published by
  *  the Free Software Foundation; either version 2 of the License, or
  *  (at your option) any later version.
  *
  *  This program is distributed in the hope that it will be useful,
  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  *  GNU General Public License for more details.
  *
  *  You should have received a copy of the GNU General Public License
  *  along with this program; if not, write to the Free Software
  *  Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
  */
 
 #include <cmath>
 
 #include <kis_paint_action_type_option.h>
 #include <kis_color_option.h>
 
 #include "kis_spray_paintop_settings.h"
 #include "kis_sprayop_option.h"
 #include "kis_spray_shape_option.h"
 #include <kis_airbrush_option.h>
 
 struct KisSprayPaintOpSettings::Private
 {
     QList<KisUniformPaintOpPropertyWSP> uniformProperties;
 };
 
 
 KisSprayPaintOpSettings::KisSprayPaintOpSettings()
     : KisOutlineGenerationPolicy<KisPaintOpSettings>(KisCurrentOutlineFetcher::SIZE_OPTION |
                                                      KisCurrentOutlineFetcher::ROTATION_OPTION),
     m_d(new Private)
 {
 }
 
 KisSprayPaintOpSettings::~KisSprayPaintOpSettings()
 {
 }
 
 void KisSprayPaintOpSettings::setPaintOpSize(qreal value)
 {
     KisSprayProperties option;
     option.readOptionSetting(this);
     option.diameter = value;
     option.writeOptionSetting(this);
 }
 
 qreal KisSprayPaintOpSettings::paintOpSize() const
 {
 
     KisSprayProperties option;
     option.readOptionSetting(this);
 
     return option.diameter;
 }
 
 bool KisSprayPaintOpSettings::paintIncremental()
 {
     return (enumPaintActionType)getInt("PaintOpAction", WASH) == BUILDUP;
 }
 
 bool KisSprayPaintOpSettings::isAirbrushing() const
 {
     return getBool(AIRBRUSH_ENABLED);
 }
 
 int KisSprayPaintOpSettings::rate() const
 {
     return getInt(AIRBRUSH_RATE);
 }
 
 
 QPainterPath KisSprayPaintOpSettings::brushOutline(const KisPaintInformation &info, OutlineMode mode)
 {
     QPainterPath path;
     if (mode == CursorIsOutline || mode == CursorIsCircleOutline || mode == CursorTiltOutline) {
         qreal width = getInt(SPRAY_DIAMETER);
         qreal height = getInt(SPRAY_DIAMETER) * getDouble(SPRAY_ASPECT);
         path = ellipseOutline(width, height, getDouble(SPRAY_SCALE), getDouble(SPRAY_ROTATION));
 
         QPainterPath tiltLine;
         QLineF tiltAngle(QPointF(0.0,0.0), QPointF(0.0,width));
         tiltAngle.setLength(qMax(width*0.5, 50.0) * (1 - info.tiltElevation(info, 60.0, 60.0, true)));
         tiltAngle.setAngle((360.0 - fmod(KisPaintInformation::tiltDirection(info, true) * 360.0 + 270.0, 360.0))-3.0);
         tiltLine.moveTo(tiltAngle.p1());
         tiltLine.lineTo(tiltAngle.p2());
         tiltAngle.setAngle((360.0 - fmod(KisPaintInformation::tiltDirection(info, true) * 360.0 + 270.0, 360.0))+3.0);
         tiltLine.lineTo(tiltAngle.p2());
         tiltLine.lineTo(tiltAngle.p1());
 
         path = outlineFetcher()->fetchOutline(info, this, path);
 
         if (mode == CursorTiltOutline) {
             QPainterPath tiltLine =
                 makeTiltIndicator(info, QPointF(0.0, 0.0), width * 0.5, 3.0);
             path.addPath(outlineFetcher()->fetchOutline(info, this, tiltLine, 1.0, 0.0, true, 0, 0));
         }
     }
     return path;
 }
 
 #include <brushengine/kis_slider_based_paintop_property.h>
 #include "kis_paintop_preset.h"
 #include "kis_paintop_settings_update_proxy.h"
 #include "kis_standard_uniform_properties_factory.h"
 
 
 QList<KisUniformPaintOpPropertySP> KisSprayPaintOpSettings::uniformProperties(KisPaintOpSettingsSP settings)
 {
     QList<KisUniformPaintOpPropertySP> props =
         listWeakToStrong(m_d->uniformProperties);
 
     if (props.isEmpty()) {
         {
             KisDoubleSliderBasedPaintOpPropertyCallback *prop =
                 new KisDoubleSliderBasedPaintOpPropertyCallback(
                     KisDoubleSliderBasedPaintOpPropertyCallback::Double,
                     "spacing",
                     i18n("Spacing"),
                     settings, 0);
 
             prop->setRange(0.01, 10);
             prop->setSingleStep(0.01);
+            prop->setExponentRatio(3.0);
 
             prop->setReadCallback(
                 [](KisUniformPaintOpProperty *prop) {
                     KisSprayProperties option;
                     option.readOptionSetting(prop->settings().data());
 
                     prop->setValue(option.spacing);
                 });
             prop->setWriteCallback(
                 [](KisUniformPaintOpProperty *prop) {
                     KisSprayProperties option;
                     option.readOptionSetting(prop->settings().data());
                     option.spacing = prop->value().toReal();
                     option.writeOptionSetting(prop->settings().data());
                 });
 
             QObject::connect(preset()->updateProxy(), SIGNAL(sigSettingsChanged()), prop, SLOT(requestReadValue()));
             prop->requestReadValue();
             props << toQShared(prop);
         }
         {
             KisIntSliderBasedPaintOpPropertyCallback *prop =
                 new KisIntSliderBasedPaintOpPropertyCallback(
                     KisIntSliderBasedPaintOpPropertyCallback::Int,
                     "spray_particlecount",
                     i18n("Particle Count"),
                     settings, 0);
 
             prop->setRange(0, 1000);
             prop->setExponentRatio(3);
 
             prop->setReadCallback(
                 [](KisUniformPaintOpProperty *prop) {
                     KisSprayProperties option;
                     option.readOptionSetting(prop->settings().data());
 
                     prop->setValue(int(option.particleCount));
                 });
             prop->setWriteCallback(
                 [](KisUniformPaintOpProperty *prop) {
                     KisSprayProperties option;
                     option.readOptionSetting(prop->settings().data());
                     option.particleCount = prop->value().toInt();
                     option.writeOptionSetting(prop->settings().data());
                 });
             prop->setIsVisibleCallback(
                 [](const KisUniformPaintOpProperty *prop) {
                     KisSprayProperties option;
                     option.readOptionSetting(prop->settings().data());
                     return !option.useDensity;
                 });
 
             QObject::connect(preset()->updateProxy(), SIGNAL(sigSettingsChanged()), prop, SLOT(requestReadValue()));
             prop->requestReadValue();
             props << toQShared(prop);
         }
         {
             KisDoubleSliderBasedPaintOpPropertyCallback *prop =
                 new KisDoubleSliderBasedPaintOpPropertyCallback(
                     KisDoubleSliderBasedPaintOpPropertyCallback::Double,
                     "spray_density",
                     i18n("Density"),
                     settings, 0);
 
             prop->setRange(0.1, 100);
             prop->setSingleStep(0.01);
             prop->setDecimals(2);
             prop->setExponentRatio(3);
             prop->setSuffix(i18n("%"));
 
             prop->setReadCallback(
                 [](KisUniformPaintOpProperty *prop) {
                     KisSprayProperties option;
                     option.readOptionSetting(prop->settings().data());
                     prop->setValue(option.coverage);
                 });
             prop->setWriteCallback(
                 [](KisUniformPaintOpProperty *prop) {
                     KisSprayProperties option;
                     option.readOptionSetting(prop->settings().data());
                     option.coverage = prop->value().toReal();
                     option.writeOptionSetting(prop->settings().data());
                 });
             prop->setIsVisibleCallback(
                 [](const KisUniformPaintOpProperty *prop) {
                     KisSprayProperties option;
                     option.readOptionSetting(prop->settings().data());
                     return option.useDensity;
                 });
 
             QObject::connect(preset()->updateProxy(), SIGNAL(sigSettingsChanged()), prop, SLOT(requestReadValue()));
             prop->requestReadValue();
             props << toQShared(prop);
         }
     }
     {
         using namespace KisStandardUniformPropertiesFactory;
 
         Q_FOREACH (KisUniformPaintOpPropertySP prop, KisPaintOpSettings::uniformProperties(settings)) {
             if (prop->id() == opacity.id() ||
                 prop->id() == size.id()) {
 
                 props.prepend(prop);
             }
         }
     }
 
     return props;
 }
diff --git a/plugins/tools/basictools/kis_tool_pencil.cc b/plugins/tools/basictools/kis_tool_pencil.cc
index 7b7516af63..50b8858024 100644
--- a/plugins/tools/basictools/kis_tool_pencil.cc
+++ b/plugins/tools/basictools/kis_tool_pencil.cc
@@ -1,68 +1,82 @@
 /*
  *  Copyright (c) 2012 Sven Langkamp <sven.langkamp@gmail.com>
  *  Copyright (c) 2010 Cyrille Berger <cberger@cberger.net>
  *
  *  This program is free software; you can redistribute it and/or modify
  *  it under the terms of the GNU General Public License as published by
  *  the Free Software Foundation; either version 2 of the License, or
  *  (at your option) any later version.
  *
  *  This program is distributed in the hope that it will be useful,
  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  *  GNU General Public License for more details.
  *
  *  You should have received a copy of the GNU General Public License
  *  along with this program; if not, write to the Free Software
  *  Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
  */
 
 #include "kis_tool_pencil.h"
 #include <KoPathShape.h>
 #include <KoCanvasBase.h>
 #include <KoPointerEvent.h>
 #include <KoShapeStroke.h>
 
 #include <kis_cursor.h>
 
 KisToolPencil::KisToolPencil(KoCanvasBase * canvas)
     : DelegatedPencilTool(canvas, Qt::ArrowCursor,
                           new __KisToolPencilLocalTool(canvas, this))
 {
 }
 
 void KisToolPencil::resetCursorStyle()
 {
     DelegatedPencilTool::resetCursorStyle();
     overrideCursorIfNotEditable();
 }
 
 void KisToolPencil::mousePressEvent(KoPointerEvent *event)
 {
     if (!nodeEditable()) return;
     DelegatedPencilTool::mousePressEvent(event);
 }
 
+QList<QPointer<QWidget> > KisToolPencil::createOptionWidgets()
+{
+    QList<QPointer<QWidget> > widgetsList =
+            DelegatedPencilTool::createOptionWidgets();
+
+    QList<QPointer<QWidget> > filteredWidgets;
+    Q_FOREACH (QWidget* widget, widgetsList) {
+        if (widget->objectName() != "Stroke widget") {
+            filteredWidgets.push_back(widget);
+        }
+    }
+    return filteredWidgets;
+}
 
 __KisToolPencilLocalTool::__KisToolPencilLocalTool(KoCanvasBase * canvas, KisToolPencil* parentTool)
     : KoPencilTool(canvas), m_parentTool(parentTool) {}
 
 void __KisToolPencilLocalTool::paintPath(KoPathShape &pathShape, QPainter &painter, const KoViewConverter &converter)
 {
     Q_UNUSED(converter);
 
     QTransform matrix;
     matrix.scale(m_parentTool->image()->xRes(), m_parentTool->image()->yRes());
     matrix.translate(pathShape.position().x(), pathShape.position().y());
     m_parentTool->paintToolOutline(&painter, m_parentTool->pixelToView(matrix.map(pathShape.outline())));
 }
 
 void __KisToolPencilLocalTool::addPathShape(KoPathShape* pathShape, bool closePath)
 {
     if (closePath) {
         pathShape->close();
         pathShape->normalize();
     }
 
     m_parentTool->addPathShape(pathShape, kundo2_i18n("Draw Freehand Path"));
 }
+
diff --git a/plugins/tools/basictools/kis_tool_pencil.h b/plugins/tools/basictools/kis_tool_pencil.h
index 3b3aed4a42..3781e64a66 100644
--- a/plugins/tools/basictools/kis_tool_pencil.h
+++ b/plugins/tools/basictools/kis_tool_pencil.h
@@ -1,88 +1,90 @@
 /*
  *  Copyright (c) 2012 Sven Langkamp <sven.langkamp@gmail.com>
  *
  *  This program is free software; you can redistribute it and/or modify
  *  it under the terms of the GNU General Public License as published by
  *  the Free Software Foundation; either version 2 of the License, or
  *  (at your option) any later version.
  *
  *  This program is distributed in the hope that it will be useful,
  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  *  GNU General Public License for more details.
  *
  *  You should have received a copy of the GNU General Public License
  *  along with this program; if not, write to the Free Software
  *  Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
  */
 
 #ifndef KIS_TOOL_PENCIL_H_
 #define KIS_TOOL_PENCIL_H_
 
 #include <KoPencilTool.h>
 #include <KoToolFactoryBase.h>
 
 #include "flake/kis_node_shape.h"
 #include "kis_tool_shape.h"
 #include "kis_delegated_tool.h"
 #include <kis_icon.h>
 
 class KoCanvasBase;
 class KisToolPencil;
 
 
 class __KisToolPencilLocalTool : public KoPencilTool {
 public:
     __KisToolPencilLocalTool(KoCanvasBase * canvas, KisToolPencil* parentTool);
     virtual void paintPath(KoPathShape &path, QPainter &painter, const KoViewConverter &converter);
     virtual void addPathShape(KoPathShape* pathShape, bool closePath);
 
     using KoPencilTool::createOptionWidgets;
 
 private:
     KisToolPencil* const m_parentTool;
 };
 
 typedef KisDelegatedTool<KisToolShape,
-                         __KisToolPencilLocalTool,
-                         DeselectShapesActivationPolicy> DelegatedPencilTool;
+__KisToolPencilLocalTool,
+DeselectShapesActivationPolicy> DelegatedPencilTool;
 
 class KisToolPencil : public DelegatedPencilTool
 {
     Q_OBJECT
 
 public:
     KisToolPencil(KoCanvasBase * canvas);
     void mousePressEvent(KoPointerEvent *event);
 
+    virtual QList<QPointer<QWidget> > createOptionWidgets();
+
 protected Q_SLOTS:
     virtual void resetCursorStyle();
 
 private:
     friend class __KisToolPencilLocalTool;
 };
 
 class KisToolPencilFactory : public KoToolFactoryBase
 {
 
 public:
     KisToolPencilFactory()
-            : KoToolFactoryBase("KisToolPencil") {
+        : KoToolFactoryBase("KisToolPencil") {
         setToolTip(i18n("Freehand Path Tool"));
         setSection(TOOL_TYPE_SHAPE);
         setActivationShapeId(KRITA_TOOL_ACTIVATION_ID);
         setIconName(koIconNameCStr("krita_tool_freehandvector"));
         setPriority(9);
     }
 
     virtual ~KisToolPencilFactory() {}
 
     virtual KoToolBase * createTool(KoCanvasBase *canvas) {
         return new KisToolPencil(canvas);
     }
 };
 
 
 
 #endif // KIS_TOOL_PENCIL_H_
 
diff --git a/plugins/tools/defaulttool/connectionTool/ConnectionTool.cpp b/plugins/tools/defaulttool/connectionTool/ConnectionTool.cpp
index 5260c43996..23098b2673 100644
--- a/plugins/tools/defaulttool/connectionTool/ConnectionTool.cpp
+++ b/plugins/tools/defaulttool/connectionTool/ConnectionTool.cpp
@@ -1,979 +1,986 @@
 /* This file is part of the KDE project
  *
  * Copyright (C) 2009 Thorsten Zachmann <zachmann@kde.org>
  * Copyright (C) 2009 Jean-Nicolas Artaud <jeannicolasartaud@gmail.com>
  * Copyright (C) 2011 Jan Hambrecht <jaham@gmx.net>
  *
  * This library is free software; you can redistribute it and/or
  * modify it under the terms of the GNU Library General Public
  * License as published by the Free Software Foundation; either
  * version 2 of the License, or (at your option) any later version.
  *
  * This library is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  * Library General Public License for more details.
  *
  * You should have received a copy of the GNU Library General Public License
  * along with this library; see the file COPYING.LIB.  If not, write to
  * the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
  * Boston, MA 02110-1301, USA.
  */
 
 #include "ConnectionTool.h"
 
 #include <QPointF>
 #include <QKeyEvent>
 #include <QPainter>
 
 #include "AddConnectionPointCommand.h"
 #include "RemoveConnectionPointCommand.h"
 #include "ChangeConnectionPointCommand.h"
 #include "MoveConnectionPointStrategy.h"
 #include "ConnectionPointWidget.h"
 
 #define TextShape_SHAPEID "TextShapeID"
 
 #include <KoCanvasBase.h>
 #include <KoPointerEvent.h>
 #include <KoShapeManager.h>
 #include <KoShapeFactoryBase.h>
 #include <KoShape.h>
 #include <KoShapeGroup.h>
 #include <KoShapeController.h>
 #include <KoShapeLayer.h>
 #include <KoShapeRegistry.h>
 #include <KoSelection.h>
 #include <KoPathSegment.h>
 #include <KoDocumentResourceManager.h>
 #include <KoInteractionStrategy.h>
 #include <KoShapeConfigWidgetBase.h>
 #include <KoConnectionShapeConfigWidget.h>
 #include <KoPathConnectionPointStrategy.h>
 #include <KoStrokeConfigWidget.h>
 
+#include "kis_document_aware_spin_box_unit_manager.h"
+
 #include <KoIcon.h>
 #include "kis_action_registry.h"
 
 #include <QAction>
 #include <klocalizedstring.h>
 #include <QDebug>
 #include <KoResourcePaths.h>
 #include <kundo2command.h>
 
 #include <math.h>
 
 ConnectionTool::ConnectionTool(KoCanvasBase *canvas)
     : KoToolBase(canvas)
     , m_editMode(Idle)
     , m_connectionType(KoConnectionShape::Standard)
     , m_currentShape(0)
     , m_activeHandle(-1)
     , m_currentStrategy(0)
     , m_oldSnapStrategies(0)
     , m_resetPaint(true)
 {
     QPixmap connectPixmap;
     connectPixmap.load(":/cursor_connect.png");
     m_connectCursor = QCursor(connectPixmap, 4, 1);
 
     KisActionRegistry *actionRegistry = KisActionRegistry::instance();
     m_editConnectionPoint = actionRegistry->makeQAction("toggle-edit-mode", this);
     m_editConnectionPoint->setCheckable(true);
     addAction("toggle-edit-mode", m_editConnectionPoint);
 
     m_alignPercent = actionRegistry->makeQAction("align-relative", this);
     m_alignPercent->setCheckable(true);
     addAction("align-relative", m_alignPercent);
     m_alignLeft = actionRegistry->makeQAction("align-left", this);
     m_alignLeft->setCheckable(true);
     addAction("align-left", m_alignLeft);
     m_alignCenterH = actionRegistry->makeQAction("align-centerh", this);
     m_alignCenterH->setCheckable(true);
     addAction("align-centerh", m_alignCenterH);
     m_alignRight = actionRegistry->makeQAction("align-right", this);
     m_alignRight->setCheckable(true);
     addAction("align-right", m_alignRight);
     m_alignTop = actionRegistry->makeQAction("align-top", this);
     m_alignTop->setCheckable(true);
     addAction("align-top", m_alignTop);
     m_alignCenterV = actionRegistry->makeQAction("align-centerv", this);
     m_alignCenterV->setCheckable(true);
     addAction("align-centerv", m_alignCenterV);
     m_alignBottom = actionRegistry->makeQAction("align-bottom", this);
     m_alignBottom->setCheckable(true);
     addAction("align-bottom", m_alignBottom);
 
     m_escapeAll = actionRegistry->makeQAction("escape-all", this);
     m_escapeAll->setCheckable(true);
     addAction("escape-all", m_escapeAll);
     m_escapeHorizontal = actionRegistry->makeQAction("escape-horizontal", this);
     m_escapeHorizontal->setCheckable(true);
     addAction("escape-horizontal", m_escapeHorizontal);
     m_escapeVertical = actionRegistry->makeQAction("escape-vertical", this);
     m_escapeVertical->setCheckable(true);
     addAction("escape-vertical", m_escapeVertical);
     m_escapeLeft = actionRegistry->makeQAction("escape-left", this);
     m_escapeLeft->setCheckable(true);
     addAction("escape-left", m_escapeLeft);
     m_escapeRight = actionRegistry->makeQAction("escape-right", this);
     m_escapeRight->setCheckable(true);
     addAction("escape-right", m_escapeRight);
     m_escapeUp = actionRegistry->makeQAction("escape-up", this);
     m_escapeUp->setCheckable(true);
     addAction("escape-up", m_escapeUp);
     m_escapeDown = actionRegistry->makeQAction("escape-down", this);
     m_escapeDown->setCheckable(true);
     addAction("escape-down", m_escapeDown);
 
     m_alignHorizontal = new QActionGroup(this);
     m_alignHorizontal->setExclusive(true);
     m_alignHorizontal->addAction(m_alignLeft);
     m_alignHorizontal->addAction(m_alignCenterH);
     m_alignHorizontal->addAction(m_alignRight);
     connect(m_alignHorizontal, SIGNAL(triggered(QAction*)), this, SLOT(horizontalAlignChanged()));
 
     m_alignVertical = new QActionGroup(this);
     m_alignVertical->setExclusive(true);
     m_alignVertical->addAction(m_alignTop);
     m_alignVertical->addAction(m_alignCenterV);
     m_alignVertical->addAction(m_alignBottom);
     connect(m_alignVertical, SIGNAL(triggered(QAction*)), this, SLOT(verticalAlignChanged()));
 
     m_alignRelative = new QActionGroup(this);
     m_alignRelative->setExclusive(true);
     m_alignRelative->addAction(m_alignPercent);
     connect(m_alignRelative, SIGNAL(triggered(QAction*)), this, SLOT(relativeAlignChanged()));
 
     m_escapeDirections = new QActionGroup(this);
     m_escapeDirections->setExclusive(true);
     m_escapeDirections->addAction(m_escapeAll);
     m_escapeDirections->addAction(m_escapeHorizontal);
     m_escapeDirections->addAction(m_escapeVertical);
     m_escapeDirections->addAction(m_escapeLeft);
     m_escapeDirections->addAction(m_escapeRight);
     m_escapeDirections->addAction(m_escapeUp);
     m_escapeDirections->addAction(m_escapeDown);
     connect(m_escapeDirections, SIGNAL(triggered(QAction*)), this, SLOT(escapeDirectionChanged()));
 
     connect(this, SIGNAL(connectionPointEnabled(bool)), m_alignHorizontal, SLOT(setEnabled(bool)));
     connect(this, SIGNAL(connectionPointEnabled(bool)), m_alignVertical, SLOT(setEnabled(bool)));
     connect(this, SIGNAL(connectionPointEnabled(bool)), m_alignRelative, SLOT(setEnabled(bool)));
     connect(this, SIGNAL(connectionPointEnabled(bool)), m_escapeDirections, SLOT(setEnabled(bool)));
 
     resetEditMode();
 }
 
 ConnectionTool::~ConnectionTool()
 {
 }
 
 void ConnectionTool::paint(QPainter &painter, const KoViewConverter &converter)
 {
     // get the correctly sized rect for painting handles
     QRectF handleRect = handlePaintRect(QPointF());
 
     painter.setRenderHint(QPainter::Antialiasing, true);
 
     if (m_currentStrategy) {
         painter.save();
         m_currentStrategy->paint(painter, converter);
         painter.restore();
     }
 
     QList<KoShape *> shapes = canvas()->shapeManager()->shapes();
     for (QList<KoShape *>::const_iterator end = shapes.constBegin(); end !=  shapes.constEnd(); ++end) {
         KoShape *shape = *end;
         if (!dynamic_cast<KoConnectionShape *>(shape)) {
             // only paint connection points of textShapes not inside a tos container and other shapes
             if (shape->shapeId() == TextShape_SHAPEID && dynamic_cast<KoTosContainer *>(shape->parent())) {
                 continue;
             }
 
             painter.save();
             painter.setPen(Qt::black);
             QTransform transform = shape->absoluteTransformation(0);
             KoShape::applyConversion(painter, converter);
             // Draw all the connection points of the shape
             KoConnectionPoints connectionPoints = shape->connectionPoints();
             KoConnectionPoints::const_iterator cp = connectionPoints.constBegin();
             KoConnectionPoints::const_iterator lastCp = connectionPoints.constEnd();
             for (; cp != lastCp; ++cp) {
                 if (shape == findNonConnectionShapeAtPosition(transform.map(cp.value().position))) {
                     handleRect.moveCenter(transform.map(cp.value().position));
                     painter.setBrush(cp.key() == m_activeHandle && shape == m_currentShape ?
-                                     Qt::red : Qt::white);
+                                         Qt::red : Qt::white);
                     painter.drawRect(handleRect);
                 }
             }
             painter.restore();
         }
     }
     // paint connection points or connection handles depending
     // on the shape the mouse is currently
     if (m_currentShape && m_editMode == EditConnection) {
         KoConnectionShape *connectionShape = dynamic_cast<KoConnectionShape *>(m_currentShape);
         if (connectionShape) {
             int radius = handleRadius() + 1;
             int handleCount = connectionShape->handleCount();
             for (int i = 0; i < handleCount; ++i) {
                 painter.save();
                 painter.setPen(Qt::blue);
                 painter.setBrush(i == m_activeHandle ? Qt::red : Qt::white);
                 painter.setTransform(connectionShape->absoluteTransformation(&converter) * painter.transform());
                 connectionShape->paintHandle(painter, converter, i, radius);
                 painter.restore();
             }
         }
     }
 }
 
 void ConnectionTool::repaintDecorations()
 {
     const qreal radius = handleRadius();
     QRectF repaintRect;
 
     if (m_currentShape) {
         repaintRect = m_currentShape->boundingRect();
         canvas()->updateCanvas(repaintRect.adjusted(-radius, -radius, radius, radius));
         KoConnectionShape *connectionShape = dynamic_cast<KoConnectionShape *>(m_currentShape);
         if (!m_resetPaint && m_currentShape->isVisible(true) && !connectionShape) {
             // only paint connection points of textShapes not inside a tos container and other shapes
             if (!(m_currentShape->shapeId() == TextShape_SHAPEID &&
-                    dynamic_cast<KoTosContainer *>(m_currentShape->parent()))) {
+                  dynamic_cast<KoTosContainer *>(m_currentShape->parent()))) {
                 KoConnectionPoints connectionPoints = m_currentShape->connectionPoints();
                 KoConnectionPoints::const_iterator cp = connectionPoints.constBegin();
                 KoConnectionPoints::const_iterator lastCp = connectionPoints.constEnd();
                 for (; cp != lastCp; ++cp) {
                     repaintRect = handleGrabRect(m_currentShape->shapeToDocument(cp.value().position));
                     canvas()->updateCanvas(repaintRect.adjusted(-radius, -radius, radius, radius));
                 }
             }
         }
         if (m_editMode == EditConnection) {
             if (connectionShape) {
                 QPointF handlePos = connectionShape->handlePosition(m_activeHandle);
                 handlePos = connectionShape->shapeToDocument(handlePos);
                 repaintRect = handlePaintRect(handlePos);
                 canvas()->updateCanvas(repaintRect.adjusted(-radius, -radius, radius, radius));
             }
         }
     }
     if (m_resetPaint) {
         QList<KoShape *> shapes = canvas()->shapeManager()->shapes();
         for (QList<KoShape *>::const_iterator end = shapes.constBegin(); end !=  shapes.constEnd(); ++end) {
             KoShape *shape = *end;
             if (!dynamic_cast<KoConnectionShape *>(shape)) {
                 // only paint connection points of textShapes not inside a tos container and other shapes
                 if (shape->shapeId() == TextShape_SHAPEID && dynamic_cast<KoTosContainer *>(shape->parent())) {
                     continue;
                 }
 
                 KoConnectionPoints connectionPoints = shape->connectionPoints();
                 KoConnectionPoints::const_iterator cp = connectionPoints.constBegin();
                 KoConnectionPoints::const_iterator lastCp = connectionPoints.constEnd();
                 for (; cp != lastCp; ++cp) {
                     repaintRect = handleGrabRect(shape->shapeToDocument(cp.value().position));
                     canvas()->updateCanvas(repaintRect.adjusted(-radius, -radius, radius, radius));
                 }
             }
         }
     }
     m_resetPaint = false;
 }
 
 void ConnectionTool::mousePressEvent(KoPointerEvent *event)
 {
 
     if (!m_currentShape) {
         return;
     }
 
     KoShape *hitShape = findShapeAtPosition(event->point);
     int hitHandle = handleAtPoint(m_currentShape, event->point);
 
     if (m_editMode == EditConnection && hitHandle >= 0) {
         // create connection handle change strategy
         m_currentStrategy = new KoPathConnectionPointStrategy(this, dynamic_cast<KoConnectionShape *>(m_currentShape), hitHandle);
     } else if (m_editMode == EditConnectionPoint) {
         if (hitHandle >= KoConnectionPoint::FirstCustomConnectionPoint) {
             // start moving custom connection point
             m_currentStrategy = new MoveConnectionPointStrategy(m_currentShape, hitHandle, this);
         }
     } else if (m_editMode == CreateConnection) {
         // create new connection shape, connect it to the active connection point
         // and start editing the new connection
         // create the new connection shape
         KoShapeFactoryBase *factory = KoShapeRegistry::instance()->value("KoConnectionShape");
         KoShape *shape = factory->createDefaultShape(canvas()->shapeController()->resourceManager());
         KoConnectionShape *connectionShape = dynamic_cast<KoConnectionShape *>(shape);
         if (!connectionShape) {
             delete shape;
             resetEditMode();
             return;
         }
         //set connection type
         connectionShape->setType(m_connectionType);
         // get the position of the connection point we start our connection from
         QPointF cp = m_currentShape->shapeToDocument(m_currentShape->connectionPoint(m_activeHandle).position);
         // move both handles to that point
         connectionShape->moveHandle(0, cp);
         connectionShape->moveHandle(1, cp);
         // connect the first handle of the connection shape to our connection point
         if (!connectionShape->connectFirst(m_currentShape, m_activeHandle)) {
             delete shape;
             resetEditMode();
             return;
         }
         //add connector label
         connectionShape->createTextShape(canvas()->shapeController()->resourceManager());
         connectionShape->setPlainText(QString());
         // create the connection edit strategy from the path tool
         m_currentStrategy = new KoPathConnectionPointStrategy(this, connectionShape, 1);
         if (!m_currentStrategy) {
             delete shape;
             resetEditMode();
             return;
         }
         // update our handle data
         setEditMode(m_editMode, shape, 1);
         // add connection shape to the shape manager so it gets painted
         canvas()->shapeManager()->addShape(connectionShape);
     } else {
         // pressing on a shape in idle mode switches to corresponding edit mode
         if (hitShape) {
             if (dynamic_cast<KoConnectionShape *>(hitShape)) {
                 int hitHandle = handleAtPoint(hitShape, event->point);
                 setEditMode(EditConnection, hitShape, hitHandle);
                 if (hitHandle >= 0) {
                     // start editing connection shape
                     m_currentStrategy = new KoPathConnectionPointStrategy(this, dynamic_cast<KoConnectionShape *>(m_currentShape), m_activeHandle);
                 }
             }
         } else {
             resetEditMode();
         }
     }
 }
 
 void ConnectionTool::mouseMoveEvent(KoPointerEvent *event)
 {
     if (m_currentStrategy) {
         repaintDecorations();
         if (m_editMode != EditConnection && m_editMode != CreateConnection) {
             QPointF snappedPos = canvas()->snapGuide()->snap(event->point, event->modifiers());
             m_currentStrategy->handleMouseMove(snappedPos, event->modifiers());
         } else {
             m_currentStrategy->handleMouseMove(event->point, event->modifiers());
         }
         repaintDecorations();
     } else if (m_editMode == EditConnectionPoint) {
         KoShape *hoverShape = findNonConnectionShapeAtPosition(event->point);//TODO exclude connectors, need snap guide maybe?
         if (hoverShape) {
             m_currentShape = hoverShape;
             Q_ASSERT(m_currentShape);
             // check if we should highlight another connection point
             int handle = handleAtPoint(m_currentShape, event->point);
             if (handle >= 0) {
                 setEditMode(m_editMode, m_currentShape, handle);
                 useCursor(handle >= KoConnectionPoint::FirstCustomConnectionPoint ? Qt::SizeAllCursor : Qt::ArrowCursor);
             } else {
                 updateStatusText();
                 useCursor(Qt::CrossCursor);
             }
         } else {
             m_currentShape = 0;
             useCursor(Qt::ArrowCursor);
         }
     } else if (m_editMode == EditConnection) {
         Q_ASSERT(m_currentShape);
         KoShape *hoverShape = findShapeAtPosition(event->point);
         // check if we should highlight another connection handle
         int handle = handleAtPoint(m_currentShape, event->point);
         setEditMode(m_editMode, m_currentShape, handle);
         if (m_activeHandle == KoConnectionShape::StartHandle ||
                 m_activeHandle == KoConnectionShape::EndHandle) {
             useCursor(Qt::SizeAllCursor);
         } else if (m_activeHandle >= KoConnectionShape::ControlHandle_1) {
 
         } else if (hoverShape && hoverShape != m_currentShape) {
             useCursor(Qt::PointingHandCursor);
         } else {
             useCursor(Qt::ArrowCursor);
         }
     } else {// Idle and no current strategy
         KoShape *hoverShape = findShapeAtPosition(event->point);
         int hoverHandle = -1;
         if (hoverShape) {
             KoConnectionShape *connectionShape = dynamic_cast<KoConnectionShape *>(hoverShape);
             if (!connectionShape) {
                 QPointF snappedPos = canvas()->snapGuide()->snap(event->point, event->modifiers());
                 hoverHandle = handleAtPoint(hoverShape, snappedPos);
                 setEditMode(hoverHandle >= 0 ? CreateConnection : Idle, hoverShape, hoverHandle);
             }
             useCursor(hoverHandle >= 0 ? m_connectCursor : Qt::PointingHandCursor);
         } else {
             useCursor(Qt::ArrowCursor);
         }
     }
 }
 
 void ConnectionTool::mouseReleaseEvent(KoPointerEvent *event)
 {
     if (m_currentStrategy) {
         if (m_editMode == CreateConnection) {
             // check if connection handles have a minimal distance
             KoConnectionShape *connectionShape = dynamic_cast<KoConnectionShape *>(m_currentShape);
             Q_ASSERT(connectionShape);
             // get both handle positions in document coordinates
             QPointF p1 = connectionShape->shapeToDocument(connectionShape->handlePosition(0));
             QPointF p2 = connectionShape->shapeToDocument(connectionShape->handlePosition(1));
             int grabDistance = grabSensitivity();
             // use grabbing sensitivity as minimal distance threshold
             if (squareDistance(p1, p2) < grabDistance * grabDistance) {
                 // minimal distance was not reached, so we have to undo the started work:
                 // - cleanup and delete the strategy
                 // - remove connection shape from shape manager and delete it
                 // - reset edit mode to last state
                 delete m_currentStrategy;
                 m_currentStrategy = 0;
                 repaintDecorations();
                 canvas()->shapeManager()->remove(m_currentShape);
                 setEditMode(m_editMode, connectionShape->firstShape(), connectionShape->firstConnectionId());
                 repaintDecorations();
                 delete connectionShape;
                 return;
             } else {
                 // finalize adding the new connection shape with an undo command
                 KUndo2Command *cmd = canvas()->shapeController()->addShape(m_currentShape);
                 canvas()->addCommand(cmd);
                 setEditMode(EditConnection, m_currentShape, KoConnectionShape::StartHandle);
             }
         }
         m_currentStrategy->finishInteraction(event->modifiers());
         // TODO: Add parent command to KoInteractionStrategy::createCommand
         // so that we can have a single command to undo for the user
         KUndo2Command *command = m_currentStrategy->createCommand();
         if (command) {
             canvas()->addCommand(command);
         }
         delete m_currentStrategy;
         m_currentStrategy = 0;
     }
     updateStatusText();
 }
 
 void ConnectionTool::mouseDoubleClickEvent(KoPointerEvent *event)
 {
     if (m_editMode == EditConnectionPoint) {
         repaintDecorations();
 
         //quit EditConnectionPoint mode when double click blank region on canvas
         if (!m_currentShape) {
             resetEditMode();
             return;
         }
 
         //add connection point when double click a shape
         //remove connection point when double click a existed connection point
         int handleId = handleAtPoint(m_currentShape, event->point);
         if (handleId < 0) {
             QPointF mousePos = canvas()->snapGuide()->snap(event->point, event->modifiers());
             QPointF point = m_currentShape->documentToShape(mousePos);
             canvas()->addCommand(new AddConnectionPointCommand(m_currentShape, point));
         } else {
             canvas()->addCommand(new RemoveConnectionPointCommand(m_currentShape, handleId));
         }
         setEditMode(m_editMode, m_currentShape, -1);
     } else {
         //deactivate connection tool when double click blank region on canvas
         KoShape *hitShape = findShapeAtPosition(event->point);
         if (!hitShape) {
             deactivate();
             emit done();
         } else if (dynamic_cast<KoConnectionShape *>(hitShape)) {
             repaintDecorations();
             setEditMode(EditConnection, m_currentShape, -1);
             //TODO: temporarily activate text tool to edit connection path
         }
     }
 }
 
 void ConnectionTool::keyPressEvent(QKeyEvent *event)
 {
     if (event->key() == Qt::Key_Escape) {
         deactivate();
         emit done();
     } else if (event->key() == Qt::Key_Backspace) {
         deleteSelection();
         event->accept();
     }
 }
 
 void ConnectionTool::activate(ToolActivation, const QSet<KoShape *> &)
 {
     // save old enabled snap strategies, set bounding box snap strategy
     m_oldSnapStrategies = canvas()->snapGuide()->enabledSnapStrategies();
     canvas()->snapGuide()->enableSnapStrategies(KoSnapGuide::BoundingBoxSnapping);
     canvas()->snapGuide()->reset();
     m_resetPaint = true;
     repaintDecorations();
 }
 
 void ConnectionTool::deactivate()
 {
     // Put everything to 0 to be able to begin a new shape properly
     delete m_currentStrategy;
     m_currentStrategy = 0;
     resetEditMode();
     m_resetPaint = true;
     repaintDecorations();
     // restore previously set snap strategies
     canvas()->snapGuide()->enableSnapStrategies(m_oldSnapStrategies);
     canvas()->snapGuide()->reset();
 }
 
 qreal ConnectionTool::squareDistance(const QPointF &p1, const QPointF &p2) const
 {
     // Square of the distance
     const qreal dx = p2.x() - p1.x();
     const qreal dy = p2.y() - p1.y();
     return dx * dx + dy * dy;
 }
 
 KoShape *ConnectionTool::findShapeAtPosition(const QPointF &position) const
 {
     QList<KoShape *> shapes = canvas()->shapeManager()->shapesAt(handleGrabRect(position));
     if (!shapes.isEmpty()) {
         qSort(shapes.begin(), shapes.end(), KoShape::compareShapeZIndex);
         // we want to priorize connection shape handles, even if the connection shape
         // is not at the top of the shape stack at the mouse position
         KoConnectionShape *connectionShape = nearestConnectionShape(shapes, position);
         // use best connection shape or first shape from stack (last in the list) if not found
         if (connectionShape) {
             return connectionShape;
         } else {
             for (QList<KoShape *>::const_iterator end = shapes.constEnd() - 1; end >= shapes.constBegin(); --end) {
                 KoShape *shape = *end;
                 if (!dynamic_cast<KoConnectionShape *>(shape) && shape->shapeId() != TextShape_SHAPEID) {
                     return shape;
                 }
             }
         }
     }
 
     return 0;
 }
 
 KoShape *ConnectionTool::findNonConnectionShapeAtPosition(const QPointF &position) const
 {
     QList<KoShape *> shapes = canvas()->shapeManager()->shapesAt(handleGrabRect(position));
     if (!shapes.isEmpty()) {
         qSort(shapes.begin(), shapes.end(), KoShape::compareShapeZIndex);
         for (QList<KoShape *>::const_iterator end = shapes.constEnd() - 1; end >= shapes.constBegin(); --end) {
             KoShape *shape = *end;
             if (!dynamic_cast<KoConnectionShape *>(shape) && shape->shapeId() != TextShape_SHAPEID) {
                 return shape;
             }
         }
     }
 
     return 0;
 }
 
 int ConnectionTool::handleAtPoint(KoShape *shape, const QPointF &mousePoint) const
 {
     if (!shape) {
         return -1;
     }
 
     const QPointF shapePoint = shape->documentToShape(mousePoint);
 
     KoConnectionShape *connectionShape = dynamic_cast<KoConnectionShape *>(shape);
     if (connectionShape) {
         // check connection shape handles
         return connectionShape->handleIdAt(handleGrabRect(shapePoint));
     } else {
         // check connection points
         int grabDistance = grabSensitivity();
         qreal minDistance = HUGE_VAL;
         int handleId = -1;
         KoConnectionPoints connectionPoints = shape->connectionPoints();
         KoConnectionPoints::const_iterator cp = connectionPoints.constBegin();
         KoConnectionPoints::const_iterator lastCp = connectionPoints.constEnd();
         for (; cp != lastCp; ++cp) {
             qreal d = squareDistance(shapePoint, cp.value().position);
             if (d <= grabDistance && d < minDistance) {
                 handleId = cp.key();
                 minDistance = d;
             }
         }
         return handleId;
     }
 }
 
 KoConnectionShape *ConnectionTool::nearestConnectionShape(const QList<KoShape *> &shapes, const QPointF &mousePos) const
 {
     int grabDistance = grabSensitivity();
 
     KoConnectionShape *nearestConnectionShape = 0;
     qreal minSquaredDistance = HUGE_VAL;
     const qreal maxSquaredDistance = grabDistance * grabDistance;
 
     Q_FOREACH (KoShape *shape, shapes) {
         KoConnectionShape *connectionShape = dynamic_cast<KoConnectionShape *>(shape);
         if (!connectionShape || !connectionShape->isParametricShape()) {
             continue;
         }
 
         // convert document point to shape coordinates
         QPointF p = connectionShape->documentToShape(mousePos);
         // our region of interest, i.e. a region around our mouse position
         QRectF roi = handleGrabRect(p);
 
         // check all segments of this shape which intersect the region of interest
         QList<KoPathSegment> segments = connectionShape->segmentsAt(roi);
         foreach (const KoPathSegment &s, segments) {
             qreal nearestPointParam = s.nearestPoint(p);
             QPointF nearestPoint = s.pointAt(nearestPointParam);
             QPointF diff = p - nearestPoint;
             qreal squaredDistance = diff.x() * diff.x() + diff.y() * diff.y();
             // are we within the allowed distance ?
             if (squaredDistance > maxSquaredDistance) {
                 continue;
             }
             // are we closer to the last closest point ?
             if (squaredDistance < minSquaredDistance) {
                 nearestConnectionShape = connectionShape;
                 minSquaredDistance = squaredDistance;
             }
         }
     }
 
     return nearestConnectionShape;
 }
 
 void ConnectionTool::setEditMode(EditMode mode, KoShape *currentShape, int handle)
 {
     repaintDecorations();
     m_editMode = mode;
     if (m_currentShape != currentShape) {
         KoConnectionShape *connectionShape = dynamic_cast<KoConnectionShape *>(currentShape);
         foreach (KoShapeConfigWidgetBase *cw, m_connectionShapeWidgets) {
             if (connectionShape) {
                 cw->open(currentShape);
             }
         }
     }
     if (mode == Idle) {
         emit sendConnectionType(m_connectionType);
     }
     m_currentShape = currentShape;
     m_activeHandle = handle;
     repaintDecorations();
     updateActions();
     updateStatusText();
 }
 
 void ConnectionTool::resetEditMode()
 {
     m_connectionType = KoConnectionShape::Standard;
     setEditMode(Idle, 0, -1);
     emit sendConnectionPointEditState(false);
 }
 
 void ConnectionTool::updateActions()
 {
     const bool connectionPointSelected = m_editMode == EditConnectionPoint && m_activeHandle >= 0;
     if (connectionPointSelected) {
         KoConnectionPoint cp = m_currentShape->connectionPoint(m_activeHandle);
 
         m_alignPercent->setChecked(false);
         Q_FOREACH (QAction *action, m_alignHorizontal->actions()) {
             action->setChecked(false);
         }
         Q_FOREACH (QAction *action, m_alignVertical->actions()) {
             action->setChecked(false);
         }
         switch (cp.alignment) {
         case KoConnectionPoint::AlignNone:
             m_alignPercent->setChecked(true);
             break;
         case KoConnectionPoint::AlignTopLeft:
             m_alignLeft->setChecked(true);
             m_alignTop->setChecked(true);
             break;
         case KoConnectionPoint::AlignTop:
             m_alignCenterH->setChecked(true);
             m_alignTop->setChecked(true);
             break;
         case KoConnectionPoint::AlignTopRight:
             m_alignRight->setChecked(true);
             m_alignTop->setChecked(true);
             break;
         case KoConnectionPoint::AlignLeft:
             m_alignLeft->setChecked(true);
             m_alignCenterV->setChecked(true);
             break;
         case KoConnectionPoint::AlignCenter:
             m_alignCenterH->setChecked(true);
             m_alignCenterV->setChecked(true);
             break;
         case KoConnectionPoint::AlignRight:
             m_alignRight->setChecked(true);
             m_alignCenterV->setChecked(true);
             break;
         case KoConnectionPoint::AlignBottomLeft:
             m_alignLeft->setChecked(true);
             m_alignBottom->setChecked(true);
             break;
         case KoConnectionPoint::AlignBottom:
             m_alignCenterH->setChecked(true);
             m_alignBottom->setChecked(true);
             break;
         case KoConnectionPoint::AlignBottomRight:
             m_alignRight->setChecked(true);
             m_alignBottom->setChecked(true);
             break;
         }
         Q_FOREACH (QAction *action, m_escapeDirections->actions()) {
             action->setChecked(false);
         }
         switch (cp.escapeDirection) {
         case KoConnectionPoint::AllDirections:
             m_escapeAll->setChecked(true);
             break;
         case KoConnectionPoint::HorizontalDirections:
             m_escapeHorizontal->setChecked(true);
             break;
         case KoConnectionPoint::VerticalDirections:
             m_escapeVertical->setChecked(true);
             break;
         case KoConnectionPoint::LeftDirection:
             m_escapeLeft->setChecked(true);
             break;
         case KoConnectionPoint::RightDirection:
             m_escapeRight->setChecked(true);
             break;
         case KoConnectionPoint::UpDirection:
             m_escapeUp->setChecked(true);
             break;
         case KoConnectionPoint::DownDirection:
             m_escapeDown->setChecked(true);
             break;
         }
     }
     emit connectionPointEnabled(connectionPointSelected);
 }
 
 void ConnectionTool::updateStatusText()
 {
     switch (m_editMode) {
     case Idle:
         if (m_currentShape) {
             if (dynamic_cast<KoConnectionShape *>(m_currentShape)) {
                 if (m_activeHandle >= 0) {
                     emit statusTextChanged(i18n("Drag to edit connection."));
                 } else {
                     emit statusTextChanged(i18n("Double click connection or press delete to remove it."));
                 }
             } else if (m_activeHandle < 0) {
                 emit statusTextChanged(i18n("Click to edit connection points."));
             }
         } else {
             emit statusTextChanged(QString());
         }
         break;
     case EditConnection:
         if (m_activeHandle >= 0) {
             emit statusTextChanged(i18n("Drag to edit connection."));
         } else {
             emit statusTextChanged(i18n("Double click connection or press delete to remove it."));
         }
         break;
     case EditConnectionPoint:
         if (m_activeHandle >= KoConnectionPoint::FirstCustomConnectionPoint) {
             emit statusTextChanged(i18n("Drag to move connection point. Double click connection or press delete to remove it."));
         } else if (m_activeHandle >= 0) {
             emit statusTextChanged(i18n("Double click connection point or press delete to remove it."));
         } else {
             emit statusTextChanged(i18n("Double click to add connection point."));
         }
         break;
     case CreateConnection:
         emit statusTextChanged(i18n("Drag to create new connection."));
         break;
     default:
         emit statusTextChanged(QString());
     }
 }
 
 QList<QPointer<QWidget> > ConnectionTool::createOptionWidgets()
 {
     QList<QPointer<QWidget> > list;
 
     m_connectionShapeWidgets.clear();
 
     KoShapeFactoryBase *factory = KoShapeRegistry::instance()->get(KOCONNECTIONSHAPEID);
     if (factory) {
         QList<KoShapeConfigWidgetBase *> widgets = factory->createShapeOptionPanels();
         Q_FOREACH (KoShapeConfigWidgetBase *cw, widgets) {
             if (cw->showOnShapeCreate() || !cw->showOnShapeSelect()) {
                 delete cw;
                 continue;
             }
             connect(cw, SIGNAL(propertyChanged()), this, SLOT(connectionChanged()));
             KoConnectionShapeConfigWidget *cw2 = (KoConnectionShapeConfigWidget *)cw;
             if (cw2) {
                 connect(cw2, SIGNAL(connectionTypeChanged(int)), this, SLOT(getConnectionType(int)));
                 connect(this, SIGNAL(sendConnectionType(int)), cw2, SLOT(setConnectionType(int)));
             }
             m_connectionShapeWidgets.append(cw);
             cw->setWindowTitle(i18n("Connection"));
             list.append(cw);
         }
     }
     KoStrokeConfigWidget *strokeWidget = new KoStrokeConfigWidget(0);
+    KisDocumentAwareSpinBoxUnitManager* managerLineWidth = new KisDocumentAwareSpinBoxUnitManager(strokeWidget);
+    KisDocumentAwareSpinBoxUnitManager* managerMitterLimit = new KisDocumentAwareSpinBoxUnitManager(strokeWidget);
+    managerLineWidth->setApparentUnitFromSymbol("px");
+    managerMitterLimit->setApparentUnitFromSymbol("px");
+    strokeWidget->setUnitManagers(managerLineWidth, managerMitterLimit);
     strokeWidget->setWindowTitle(i18n("Line"));
     strokeWidget->setCanvas(canvas());
     list.append(strokeWidget);
 
     ConnectionPointWidget *connectPoint = new ConnectionPointWidget(this);
     connectPoint->setWindowTitle(i18n("Connection Point"));
     list.append(connectPoint);
 
     return list;
 }
 
 void ConnectionTool::horizontalAlignChanged()
 {
     if (m_alignPercent->isChecked()) {
         m_alignPercent->setChecked(false);
         m_alignTop->setChecked(true);
     }
     updateConnectionPoint();
 }
 
 void ConnectionTool::verticalAlignChanged()
 {
     if (m_alignPercent->isChecked()) {
         m_alignPercent->setChecked(false);
         m_alignLeft->setChecked(true);
     }
     updateConnectionPoint();
 }
 
 void ConnectionTool::relativeAlignChanged()
 {
     Q_FOREACH (QAction *action, m_alignHorizontal->actions()) {
         action->setChecked(false);
     }
     Q_FOREACH (QAction *action, m_alignVertical->actions()) {
         action->setChecked(false);
     }
     m_alignPercent->setChecked(true);
 
     updateConnectionPoint();
 }
 
 void ConnectionTool::updateConnectionPoint()
 {
     if (m_editMode == EditConnectionPoint && m_currentShape && m_activeHandle >= 0) {
         KoConnectionPoint oldPoint = m_currentShape->connectionPoint(m_activeHandle);
         KoConnectionPoint newPoint = oldPoint;
         if (m_alignPercent->isChecked()) {
             newPoint.alignment = KoConnectionPoint::AlignNone;
         } else if (m_alignLeft->isChecked() && m_alignTop->isChecked()) {
             newPoint.alignment = KoConnectionPoint::AlignTopLeft;
         } else if (m_alignCenterH->isChecked() && m_alignTop->isChecked()) {
             newPoint.alignment = KoConnectionPoint::AlignTop;
         } else if (m_alignRight->isChecked() && m_alignTop->isChecked()) {
             newPoint.alignment = KoConnectionPoint::AlignTopRight;
         } else if (m_alignLeft->isChecked() && m_alignCenterV->isChecked()) {
             newPoint.alignment = KoConnectionPoint::AlignLeft;
         } else if (m_alignCenterH->isChecked() && m_alignCenterV->isChecked()) {
             newPoint.alignment = KoConnectionPoint::AlignCenter;
         } else if (m_alignRight->isChecked() && m_alignCenterV->isChecked()) {
             newPoint.alignment = KoConnectionPoint::AlignRight;
         } else if (m_alignLeft->isChecked() && m_alignBottom->isChecked()) {
             newPoint.alignment = KoConnectionPoint::AlignBottomLeft;
         } else if (m_alignCenterH->isChecked() && m_alignBottom->isChecked()) {
             newPoint.alignment = KoConnectionPoint::AlignBottom;
         } else if (m_alignRight->isChecked() && m_alignBottom->isChecked()) {
             newPoint.alignment = KoConnectionPoint::AlignBottomRight;
         }
 
         canvas()->addCommand(new ChangeConnectionPointCommand(m_currentShape, m_activeHandle, oldPoint, newPoint));
     }
 }
 
 void ConnectionTool::escapeDirectionChanged()
 {
     if (m_editMode == EditConnectionPoint && m_currentShape && m_activeHandle >= 0) {
         KoConnectionPoint oldPoint = m_currentShape->connectionPoint(m_activeHandle);
         KoConnectionPoint newPoint = oldPoint;
         QAction *checkedAction = m_escapeDirections->checkedAction();
         if (checkedAction == m_escapeAll) {
             newPoint.escapeDirection = KoConnectionPoint::AllDirections;
         } else if (checkedAction == m_escapeHorizontal) {
             newPoint.escapeDirection = KoConnectionPoint::HorizontalDirections;
         } else if (checkedAction == m_escapeVertical) {
             newPoint.escapeDirection = KoConnectionPoint::VerticalDirections;
         } else if (checkedAction == m_escapeLeft) {
             newPoint.escapeDirection = KoConnectionPoint::LeftDirection;
         } else if (checkedAction == m_escapeRight) {
             newPoint.escapeDirection = KoConnectionPoint::RightDirection;
         } else if (checkedAction == m_escapeUp) {
             newPoint.escapeDirection = KoConnectionPoint::UpDirection;
         } else if (checkedAction == m_escapeDown) {
             newPoint.escapeDirection = KoConnectionPoint::DownDirection;
         }
         canvas()->addCommand(new ChangeConnectionPointCommand(m_currentShape, m_activeHandle, oldPoint, newPoint));
     }
 }
 
 void ConnectionTool::connectionChanged()
 {
     if (m_editMode != EditConnection) {
         return;
     }
     KoConnectionShape *connectionShape = dynamic_cast<KoConnectionShape *>(m_currentShape);
     if (!connectionShape) {
         return;
     }
 
     Q_FOREACH (KoShapeConfigWidgetBase *cw, m_connectionShapeWidgets) {
         canvas()->addCommand(cw->createCommand());
     }
 }
 
 void ConnectionTool::deleteSelection()
 {
     if (m_editMode == EditConnectionPoint && m_currentShape && m_activeHandle >= 0) {
         repaintDecorations();
         canvas()->addCommand(new RemoveConnectionPointCommand(m_currentShape, m_activeHandle));
         setEditMode(m_editMode, m_currentShape, -1);
     } else if (m_editMode == EditConnection && m_currentShape) {
         repaintDecorations();
         canvas()->addCommand(canvas()->shapeController()->removeShape(m_currentShape));
         resetEditMode();
     }
 }
 
 void ConnectionTool::getConnectionType(int type)
 {
     if (m_editMode == Idle) {
         m_connectionType = (KoConnectionShape::Type)type;
     }
 }
 
 void ConnectionTool::toggleConnectionPointEditMode(int state)
 {
     if (state == Qt::Checked) {
         setEditMode(EditConnectionPoint, 0, -1);
     } else if (state == Qt::Unchecked) {
         setEditMode(Idle, 0, -1);
     } else {
         return;
     }
 }
diff --git a/plugins/tools/defaulttool/defaulttool/DefaultTool.cpp b/plugins/tools/defaulttool/defaulttool/DefaultTool.cpp
index 02e5e2f2cf..97681020b8 100644
--- a/plugins/tools/defaulttool/defaulttool/DefaultTool.cpp
+++ b/plugins/tools/defaulttool/defaulttool/DefaultTool.cpp
@@ -1,1242 +1,1253 @@
 /* This file is part of the KDE project
 
    Copyright (C) 2006-2008 Thorsten Zachmann <zachmann@kde.org>
    Copyright (C) 2006-2010 Thomas Zander <zander@kde.org>
    Copyright (C) 2008-2009 Jan Hambrecht <jaham@gmx.net>
    Copyright (C) 2008 C. Boemann <cbo@boemann.dk>
 
    This library is free software; you can redistribute it and/or
    modify it under the terms of the GNU Library General Public
    License as published by the Free Software Foundation; either
    version 2 of the License, or (at your option) any later version.
 
    This library is distributed in the hope that it will be useful,
    but WITHOUT ANY WARRANTY; without even the implied warranty of
    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
    Library General Public License for more details.
 
    You should have received a copy of the GNU Library General Public License
    along with this library; see the file COPYING.LIB.  If not, write to
    the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
  * Boston, MA 02110-1301, USA.
 */
 
 #include "DefaultTool.h"
 #include "DefaultToolWidget.h"
 #include "DefaultToolArrangeWidget.h"
 #include "SelectionDecorator.h"
 #include "ShapeMoveStrategy.h"
 #include "ShapeRotateStrategy.h"
 #include "ShapeShearStrategy.h"
 #include "ShapeResizeStrategy.h"
 
 #include <KoPointerEvent.h>
 #include <KoToolSelection.h>
 #include <KoToolManager.h>
 #include <KoSelection.h>
 #include <KoShapeController.h>
 #include <KoShapeManager.h>
 #include <KoShapeGroup.h>
 #include <KoShapeLayer.h>
 #include <KoShapePaste.h>
 #include <KoShapeOdfSaveHelper.h>
 #include <KoDrag.h>
 #include <KoCanvasBase.h>
 #include <KoCanvasResourceManager.h>
 #include <KoShapeRubberSelectStrategy.h>
 #include <commands/KoShapeMoveCommand.h>
 #include <commands/KoShapeDeleteCommand.h>
 #include <commands/KoShapeCreateCommand.h>
 #include <commands/KoShapeGroupCommand.h>
 #include <commands/KoShapeUngroupCommand.h>
 #include <KoSnapGuide.h>
 #include <KoStrokeConfigWidget.h>
 #include <KoFillConfigWidget.h>
 #include <KoShadowConfigWidget.h>
 #include "kis_action_registry.h"
 
+#include "kis_document_aware_spin_box_unit_manager.h"
+
 #include <KoIcon.h>
 
 #include <QPointer>
 #include <QAction>
 #include <QKeyEvent>
 #include <QClipboard>
 #include <KoResourcePaths.h>
 
 #include <math.h>
 
 #include <QVector2D>
 
 #define HANDLE_DISTANCE 10
 
 class NopInteractionStrategy : public KoInteractionStrategy
 {
 public:
     explicit NopInteractionStrategy(KoToolBase *parent)
         : KoInteractionStrategy(parent)
     {
     }
 
     KUndo2Command *createCommand() override
     {
         return 0;
     }
 
     void handleMouseMove(const QPointF & /*mouseLocation*/, Qt::KeyboardModifiers /*modifiers*/) override {}
     void finishInteraction(Qt::KeyboardModifiers /*modifiers*/) override {}
 };
 
 class SelectionHandler : public KoToolSelection
 {
 public:
     SelectionHandler(DefaultTool *parent)
         : KoToolSelection(parent)
         , m_selection(parent->koSelection())
     {
     }
 
     bool hasSelection() override
     {
         if (m_selection) {
             return m_selection->count();
         }
         return false;
     }
 
 private:
     QPointer<KoSelection> m_selection;
 };
 
 DefaultTool::DefaultTool(KoCanvasBase *canvas)
     : KoInteractionTool(canvas)
     , m_lastHandle(KoFlake::NoHandle)
     , m_hotPosition(KoFlake::TopLeftCorner)
     , m_mouseWasInsideHandles(false)
     , m_moveCommand(0)
     , m_selectionHandler(new SelectionHandler(this))
     , m_customEventStrategy(0)
 {
     setupActions();
 
     QPixmap rotatePixmap, shearPixmap;
     rotatePixmap.load(":/cursor_rotate.png");
     Q_ASSERT(!rotatePixmap.isNull());
     shearPixmap.load(":/cursor_shear.png");
     Q_ASSERT(!shearPixmap.isNull());
 
     m_rotateCursors[0] = QCursor(rotatePixmap.transformed(QTransform().rotate(45)));
     m_rotateCursors[1] = QCursor(rotatePixmap.transformed(QTransform().rotate(90)));
     m_rotateCursors[2] = QCursor(rotatePixmap.transformed(QTransform().rotate(135)));
     m_rotateCursors[3] = QCursor(rotatePixmap.transformed(QTransform().rotate(180)));
     m_rotateCursors[4] = QCursor(rotatePixmap.transformed(QTransform().rotate(225)));
     m_rotateCursors[5] = QCursor(rotatePixmap.transformed(QTransform().rotate(270)));
     m_rotateCursors[6] = QCursor(rotatePixmap.transformed(QTransform().rotate(315)));
     m_rotateCursors[7] = QCursor(rotatePixmap);
     /*
         m_rotateCursors[0] = QCursor(Qt::RotateNCursor);
         m_rotateCursors[1] = QCursor(Qt::RotateNECursor);
         m_rotateCursors[2] = QCursor(Qt::RotateECursor);
         m_rotateCursors[3] = QCursor(Qt::RotateSECursor);
         m_rotateCursors[4] = QCursor(Qt::RotateSCursor);
         m_rotateCursors[5] = QCursor(Qt::RotateSWCursor);
         m_rotateCursors[6] = QCursor(Qt::RotateWCursor);
         m_rotateCursors[7] = QCursor(Qt::RotateNWCursor);
     */
     m_shearCursors[0] = QCursor(shearPixmap);
     m_shearCursors[1] = QCursor(shearPixmap.transformed(QTransform().rotate(45)));
     m_shearCursors[2] = QCursor(shearPixmap.transformed(QTransform().rotate(90)));
     m_shearCursors[3] = QCursor(shearPixmap.transformed(QTransform().rotate(135)));
     m_shearCursors[4] = QCursor(shearPixmap.transformed(QTransform().rotate(180)));
     m_shearCursors[5] = QCursor(shearPixmap.transformed(QTransform().rotate(225)));
     m_shearCursors[6] = QCursor(shearPixmap.transformed(QTransform().rotate(270)));
     m_shearCursors[7] = QCursor(shearPixmap.transformed(QTransform().rotate(315)));
     m_sizeCursors[0] = Qt::SizeVerCursor;
     m_sizeCursors[1] = Qt::SizeBDiagCursor;
     m_sizeCursors[2] = Qt::SizeHorCursor;
     m_sizeCursors[3] = Qt::SizeFDiagCursor;
     m_sizeCursors[4] = Qt::SizeVerCursor;
     m_sizeCursors[5] = Qt::SizeBDiagCursor;
     m_sizeCursors[6] = Qt::SizeHorCursor;
     m_sizeCursors[7] = Qt::SizeFDiagCursor;
 
     KoShapeManager *manager = canvas->shapeManager();
     connect(manager, SIGNAL(selectionChanged()), this, SLOT(updateActions()));
 }
 
 DefaultTool::~DefaultTool()
 {
 }
 
 bool DefaultTool::wantsAutoScroll() const
 {
     return true;
 }
 
 void DefaultTool::setupActions()
 {
     KisActionRegistry *actionRegistry = KisActionRegistry::instance();
 
     QAction *actionBringToFront = actionRegistry->makeQAction("object_order_front", this);
     addAction("object_order_front", actionBringToFront);
     connect(actionBringToFront, SIGNAL(triggered()), this, SLOT(selectionBringToFront()));
 
     QAction *actionRaise = actionRegistry->makeQAction("object_order_raise", this);
     addAction("object_order_raise", actionRaise);
     connect(actionRaise, SIGNAL(triggered()), this, SLOT(selectionMoveUp()));
 
     QAction *actionLower = actionRegistry->makeQAction("object_order_lower", this);
     addAction("object_order_lower", actionLower);
     connect(actionLower, SIGNAL(triggered()), this, SLOT(selectionMoveDown()));
 
     QAction *actionSendToBack = actionRegistry->makeQAction("object_order_back", this);
     addAction("object_order_back", actionSendToBack);
     connect(actionSendToBack, SIGNAL(triggered()), this, SLOT(selectionSendToBack()));
 
     QAction *actionAlignLeft = actionRegistry->makeQAction("object_align_horizontal_left", this);
     addAction("object_align_horizontal_left", actionAlignLeft);
     connect(actionAlignLeft, SIGNAL(triggered()), this, SLOT(selectionAlignHorizontalLeft()));
 
     QAction *actionAlignCenter = actionRegistry->makeQAction("object_align_horizontal_center", this);
     addAction("object_align_horizontal_center", actionAlignCenter);
     connect(actionAlignCenter, SIGNAL(triggered()), this, SLOT(selectionAlignHorizontalCenter()));
 
     QAction *actionAlignRight = actionRegistry->makeQAction("object_align_horizontal_right", this);
     addAction("object_align_horizontal_right", actionAlignRight);
     connect(actionAlignRight, SIGNAL(triggered()), this, SLOT(selectionAlignHorizontalRight()));
 
     QAction *actionAlignTop = actionRegistry->makeQAction("object_align_vertical_top", this);
     addAction("object_align_vertical_top", actionAlignTop);
     connect(actionAlignTop, SIGNAL(triggered()), this, SLOT(selectionAlignVerticalTop()));
 
     QAction *actionAlignMiddle = actionRegistry->makeQAction("object_align_vertical_center", this);
     addAction("object_align_vertical_center", actionAlignMiddle);
     connect(actionAlignMiddle, SIGNAL(triggered()), this, SLOT(selectionAlignVerticalCenter()));
 
     QAction *actionAlignBottom = actionRegistry->makeQAction("object_align_vertical_bottom", this);
     addAction("object_align_vertical_bottom", actionAlignBottom);
     connect(actionAlignBottom, SIGNAL(triggered()), this, SLOT(selectionAlignVerticalBottom()));
 
     QAction *actionGroupBottom = actionRegistry->makeQAction("object_group", this);
     addAction("object_group", actionGroupBottom);
     connect(actionGroupBottom, SIGNAL(triggered()), this, SLOT(selectionGroup()));
 
     QAction *actionUngroupBottom = actionRegistry->makeQAction("object_ungroup", this);
     addAction("object_ungroup", actionUngroupBottom);
     connect(actionUngroupBottom, SIGNAL(triggered()), this, SLOT(selectionUngroup()));
 }
 
 qreal DefaultTool::rotationOfHandle(KoFlake::SelectionHandle handle, bool useEdgeRotation)
 {
     QPointF selectionCenter = koSelection()->absolutePosition();
     QPointF direction;
 
     switch (handle) {
     case KoFlake::TopMiddleHandle:
         if (useEdgeRotation) {
             direction = koSelection()->absolutePosition(KoFlake::TopRightCorner)
-                        - koSelection()->absolutePosition(KoFlake::TopLeftCorner);
+                    - koSelection()->absolutePosition(KoFlake::TopLeftCorner);
         } else {
             QPointF handlePosition = koSelection()->absolutePosition(KoFlake::TopLeftCorner);
             handlePosition += 0.5 * (koSelection()->absolutePosition(KoFlake::TopRightCorner) - handlePosition);
             direction = handlePosition - selectionCenter;
         }
         break;
     case KoFlake::TopRightHandle:
         direction = (QVector2D(koSelection()->absolutePosition(KoFlake::TopRightCorner) - koSelection()->absolutePosition(KoFlake::TopLeftCorner)).normalized() + QVector2D(koSelection()->absolutePosition(KoFlake::TopRightCorner) - koSelection()->absolutePosition(KoFlake::BottomRightCorner)).normalized()).toPointF();
         break;
     case KoFlake::RightMiddleHandle:
         if (useEdgeRotation) {
             direction = koSelection()->absolutePosition(KoFlake::BottomRightCorner)
-                        - koSelection()->absolutePosition(KoFlake::TopRightCorner);
+                    - koSelection()->absolutePosition(KoFlake::TopRightCorner);
         } else {
             QPointF handlePosition = koSelection()->absolutePosition(KoFlake::TopRightCorner);
             handlePosition += 0.5 * (koSelection()->absolutePosition(KoFlake::BottomRightCorner) - handlePosition);
             direction = handlePosition - selectionCenter;
         }
         break;
     case KoFlake::BottomRightHandle:
         direction = (QVector2D(koSelection()->absolutePosition(KoFlake::BottomRightCorner) - koSelection()->absolutePosition(KoFlake::BottomLeftCorner)).normalized() + QVector2D(koSelection()->absolutePosition(KoFlake::BottomRightCorner) - koSelection()->absolutePosition(KoFlake::TopRightCorner)).normalized()).toPointF();
         break;
     case KoFlake::BottomMiddleHandle:
         if (useEdgeRotation) {
             direction = koSelection()->absolutePosition(KoFlake::BottomLeftCorner)
-                        - koSelection()->absolutePosition(KoFlake::BottomRightCorner);
+                    - koSelection()->absolutePosition(KoFlake::BottomRightCorner);
         } else {
             QPointF handlePosition = koSelection()->absolutePosition(KoFlake::BottomLeftCorner);
             handlePosition += 0.5 * (koSelection()->absolutePosition(KoFlake::BottomRightCorner) - handlePosition);
             direction = handlePosition - selectionCenter;
         }
         break;
     case KoFlake::BottomLeftHandle:
         direction = koSelection()->absolutePosition(KoFlake::BottomLeftCorner) - selectionCenter;
         direction = (QVector2D(koSelection()->absolutePosition(KoFlake::BottomLeftCorner) - koSelection()->absolutePosition(KoFlake::BottomRightCorner)).normalized() + QVector2D(koSelection()->absolutePosition(KoFlake::BottomLeftCorner) - koSelection()->absolutePosition(KoFlake::TopLeftCorner)).normalized()).toPointF();
         break;
     case KoFlake::LeftMiddleHandle:
         if (useEdgeRotation) {
             direction = koSelection()->absolutePosition(KoFlake::TopLeftCorner)
-                        - koSelection()->absolutePosition(KoFlake::BottomLeftCorner);
+                    - koSelection()->absolutePosition(KoFlake::BottomLeftCorner);
         } else {
             QPointF handlePosition = koSelection()->absolutePosition(KoFlake::TopLeftCorner);
             handlePosition += 0.5 * (koSelection()->absolutePosition(KoFlake::BottomLeftCorner) - handlePosition);
             direction = handlePosition - selectionCenter;
         }
         break;
     case KoFlake::TopLeftHandle:
         direction = koSelection()->absolutePosition(KoFlake::TopLeftCorner) - selectionCenter;
         direction = (QVector2D(koSelection()->absolutePosition(KoFlake::TopLeftCorner) - koSelection()->absolutePosition(KoFlake::TopRightCorner)).normalized() + QVector2D(koSelection()->absolutePosition(KoFlake::TopLeftCorner) - koSelection()->absolutePosition(KoFlake::BottomLeftCorner)).normalized()).toPointF();
         break;
     case KoFlake::NoHandle:
         return 0.0;
         break;
     }
 
     qreal rotation = atan2(direction.y(), direction.x()) * 180.0 / M_PI;
 
     switch (handle) {
     case KoFlake::TopMiddleHandle:
         if (useEdgeRotation) {
             rotation -= 0.0;
         } else {
             rotation -= 270.0;
         }
         break;
     case KoFlake::TopRightHandle:
         rotation -= 315.0;
         break;
     case KoFlake::RightMiddleHandle:
         if (useEdgeRotation) {
             rotation -= 90.0;
         } else {
             rotation -= 0.0;
         }
         break;
     case KoFlake::BottomRightHandle:
         rotation -= 45.0;
         break;
     case KoFlake::BottomMiddleHandle:
         if (useEdgeRotation) {
             rotation -= 180.0;
         } else {
             rotation -= 90.0;
         }
         break;
     case KoFlake::BottomLeftHandle:
         rotation -= 135.0;
         break;
     case KoFlake::LeftMiddleHandle:
         if (useEdgeRotation) {
             rotation -= 270.0;
         } else {
             rotation -= 180.0;
         }
         break;
     case KoFlake::TopLeftHandle:
         rotation -= 225.0;
         break;
     case KoFlake::NoHandle:
         break;
     }
 
     if (rotation < 0.0) {
         rotation += 360.0;
     }
 
     return rotation;
 }
 
 void DefaultTool::updateCursor()
 {
     QCursor cursor = Qt::ArrowCursor;
 
     QString statusText;
     KoSelection * selection = koSelection();
     if (selection && selection->count() > 0) { // has a selection
         bool editable = editableShapesCount(koSelection()->selectedShapes(KoFlake::StrippedSelection));
 
         if (!m_mouseWasInsideHandles) {
             m_angle = rotationOfHandle(m_lastHandle, true);
             int rotOctant = 8 + int(8.5 + m_angle / 45);
 
             bool rotateHandle = false;
             bool shearHandle = false;
             switch (m_lastHandle) {
             case KoFlake::TopMiddleHandle:
                 cursor = m_shearCursors[(0 + rotOctant) % 8];
                 shearHandle = true;
                 break;
             case KoFlake::TopRightHandle:
                 cursor = m_rotateCursors[(1 + rotOctant) % 8];
                 rotateHandle = true;
                 break;
             case KoFlake::RightMiddleHandle:
                 cursor = m_shearCursors[(2 + rotOctant) % 8];
                 shearHandle = true;
                 break;
             case KoFlake::BottomRightHandle:
                 cursor = m_rotateCursors[(3 + rotOctant) % 8];
                 rotateHandle = true;
                 break;
             case KoFlake::BottomMiddleHandle:
                 cursor = m_shearCursors[(4 + rotOctant) % 8];
                 shearHandle = true;
                 break;
             case KoFlake::BottomLeftHandle:
                 cursor = m_rotateCursors[(5 + rotOctant) % 8];
                 rotateHandle = true;
                 break;
             case KoFlake::LeftMiddleHandle:
                 cursor = m_shearCursors[(6 + rotOctant) % 8];
                 shearHandle = true;
                 break;
             case KoFlake::TopLeftHandle:
                 cursor = m_rotateCursors[(7 + rotOctant) % 8];
                 rotateHandle = true;
                 break;
             case KoFlake::NoHandle:
                 cursor = Qt::ArrowCursor;
                 break;
             }
             if (rotateHandle) {
                 statusText = i18n("Left click rotates around center, right click around highlighted position.");
             }
             if (shearHandle) {
                 statusText = i18n("Click and drag to shear selection.");
             }
         } else {
             statusText = i18n("Click and drag to resize selection.");
             m_angle = rotationOfHandle(m_lastHandle, false);
             int rotOctant = 8 + int(8.5 + m_angle / 45);
             bool cornerHandle = false;
             switch (m_lastHandle) {
             case KoFlake::TopMiddleHandle:
                 cursor = m_sizeCursors[(0 + rotOctant) % 8];
                 break;
             case KoFlake::TopRightHandle:
                 cursor = m_sizeCursors[(1 + rotOctant) % 8];
                 cornerHandle = true;
                 break;
             case KoFlake::RightMiddleHandle:
                 cursor = m_sizeCursors[(2 + rotOctant) % 8];
                 break;
             case KoFlake::BottomRightHandle:
                 cursor = m_sizeCursors[(3 + rotOctant) % 8];
                 cornerHandle = true;
                 break;
             case KoFlake::BottomMiddleHandle:
                 cursor = m_sizeCursors[(4 + rotOctant) % 8];
                 break;
             case KoFlake::BottomLeftHandle:
                 cursor = m_sizeCursors[(5 + rotOctant) % 8];
                 cornerHandle = true;
                 break;
             case KoFlake::LeftMiddleHandle:
                 cursor = m_sizeCursors[(6 + rotOctant) % 8];
                 break;
             case KoFlake::TopLeftHandle:
                 cursor = m_sizeCursors[(7 + rotOctant) % 8];
                 cornerHandle = true;
                 break;
             case KoFlake::NoHandle:
                 cursor = Qt::SizeAllCursor;
                 statusText = i18n("Click and drag to move selection.");
                 break;
             }
             if (cornerHandle) {
                 statusText = i18n("Click and drag to resize selection. Middle click to set highlighted position.");
             }
         }
         if (!editable) {
             cursor = Qt::ArrowCursor;
         }
     } else {
         // there used to be guides... :'''(
     }
     useCursor(cursor);
     if (currentStrategy() == 0) {
         emit statusTextChanged(statusText);
     }
 }
 
 void DefaultTool::paint(QPainter &painter, const KoViewConverter &converter)
 {
     KoInteractionTool::paint(painter, converter);
     if (currentStrategy() == 0 && koSelection() && koSelection()->count() > 0) {
         SelectionDecorator decorator(m_mouseWasInsideHandles ? m_lastHandle : KoFlake::NoHandle,
                                      true, true);
         decorator.setSelection(koSelection());
         decorator.setHandleRadius(handleRadius());
         decorator.setHotPosition(m_hotPosition);
         decorator.paint(painter, converter);
     }
     painter.save();
     KoShape::applyConversion(painter, converter);
     canvas()->snapGuide()->paint(painter, converter);
     painter.restore();
 }
 
 void DefaultTool::mousePressEvent(KoPointerEvent *event)
 {
     KoInteractionTool::mousePressEvent(event);
     updateCursor();
 }
 
 void DefaultTool::mouseMoveEvent(KoPointerEvent *event)
 {
     KoInteractionTool::mouseMoveEvent(event);
     if (currentStrategy() == 0 && koSelection() && koSelection()->count() > 0) {
         QRectF bound = handlesSize();
         if (bound.contains(event->point)) {
             bool inside;
             KoFlake::SelectionHandle newDirection = handleAt(event->point, &inside);
             if (inside != m_mouseWasInsideHandles || m_lastHandle != newDirection) {
                 m_lastHandle = newDirection;
                 m_mouseWasInsideHandles = inside;
                 //repaintDecorations();
             }
         } else {
             /*if (m_lastHandle != KoFlake::NoHandle)
                 repaintDecorations(); */
             m_lastHandle = KoFlake::NoHandle;
             m_mouseWasInsideHandles = false;
 
             // there used to be guides... :'''(
         }
     } else {
         // there used to be guides... :'''(
     }
 
     updateCursor();
 }
 
 QRectF DefaultTool::handlesSize()
 {
     QRectF bound = koSelection()->boundingRect();
     // expansion Border
     if (!canvas() || !canvas()->viewConverter()) {
         return bound;
     }
 
     QPointF border = canvas()->viewConverter()->viewToDocument(QPointF(HANDLE_DISTANCE, HANDLE_DISTANCE));
     bound.adjust(-border.x(), -border.y(), border.x(), border.y());
     return bound;
 }
 
 void DefaultTool::mouseReleaseEvent(KoPointerEvent *event)
 {
     KoInteractionTool::mouseReleaseEvent(event);
     updateCursor();
 }
 
 void DefaultTool::mouseDoubleClickEvent(KoPointerEvent *event)
 {
     QList<KoShape *> shapes;
     Q_FOREACH (KoShape *shape, koSelection()->selectedShapes()) {
         if (shape->boundingRect().contains(event->point) && // first 'cheap' check
                 shape->outline().contains(event->point)) { // this is more expensive but weeds out the almost hits
             shapes.append(shape);
         }
     }
     if (shapes.count() == 0) { // nothing in the selection was clicked on.
         KoShape *shape = canvas()->shapeManager()->shapeAt(event->point, KoFlake::ShapeOnTop);
         if (shape) {
             shapes.append(shape);
         } // there used to be guides... :'''(
     }
 
     QList<KoShape *> shapes2;
     foreach (KoShape *shape, shapes) {
         QSet<KoShape *> delegates = shape->toolDelegates();
         if (delegates.isEmpty()) {
             shapes2.append(shape);
         } else {
             foreach (KoShape *delegatedShape, delegates) {
                 shapes2.append(delegatedShape);
             }
         }
     }
 
     KoToolManager::instance()->switchToolRequested(
-        KoToolManager::instance()->preferredToolForSelection(shapes2));
+                KoToolManager::instance()->preferredToolForSelection(shapes2));
 }
 
 bool DefaultTool::moveSelection(int direction, Qt::KeyboardModifiers modifiers)
 {
     qreal x = 0.0, y = 0.0;
     if (direction == Qt::Key_Left) {
         x = -5;
     } else if (direction == Qt::Key_Right) {
         x = 5;
     } else if (direction == Qt::Key_Up) {
         y = -5;
     } else if (direction == Qt::Key_Down) {
         y = 5;
     }
 
     if (x != 0.0 || y != 0.0) { // actually move
         if ((modifiers & Qt::ShiftModifier) != 0) {
             x *= 10;
             y *= 10;
         } else if ((modifiers & Qt::AltModifier) != 0) { // more precise
             x /= 5;
             y /= 5;
         }
 
         QList<QPointF> prevPos;
         QList<QPointF> newPos;
         QList<KoShape *> shapes;
         Q_FOREACH (KoShape *shape, koSelection()->selectedShapes(KoFlake::TopLevelSelection)) {
             if (shape->isGeometryProtected()) {
                 continue;
             }
             shapes.append(shape);
             QPointF p = shape->position();
             prevPos.append(p);
             p.setX(p.x() + x);
             p.setY(p.y() + y);
             newPos.append(p);
         }
         if (shapes.count() > 0) {
             // use a timeout to make sure we don't reuse a command possibly deleted by the commandHistory
             if (m_lastUsedMoveCommand.msecsTo(QTime::currentTime()) > 5000) {
                 m_moveCommand = 0;
             }
             if (m_moveCommand) { // alter previous instead of creating new one.
                 m_moveCommand->setNewPositions(newPos);
                 m_moveCommand->redo();
             } else {
                 m_moveCommand = new KoShapeMoveCommand(shapes, prevPos, newPos);
                 canvas()->addCommand(m_moveCommand);
             }
             m_lastUsedMoveCommand = QTime::currentTime();
             return true;
         }
     }
     return false;
 }
 
 void DefaultTool::keyPressEvent(QKeyEvent *event)
 {
     KoInteractionTool::keyPressEvent(event);
     if (currentStrategy() == 0) {
         switch (event->key()) {
         case Qt::Key_Left:
         case Qt::Key_Right:
         case Qt::Key_Up:
         case Qt::Key_Down:
             if (moveSelection(event->key(), event->modifiers())) {
                 event->accept();
             }
             break;
         case Qt::Key_1:
         case Qt::Key_2:
         case Qt::Key_3:
         case Qt::Key_4:
         case Qt::Key_5:
             canvas()->resourceManager()->setResource(HotPosition, event->key() - Qt::Key_1);
             event->accept();
             break;
         default:
             return;
         }
     }
 }
 
 void DefaultTool::customMoveEvent(KoPointerEvent *event)
 {
     if (koSelection() && koSelection()->count() <= 0) {
         event->ignore();
         return;
     }
 
     int move = qMax(qAbs(event->x()), qAbs(event->y()));
     int zoom = qAbs(event->z());
     int rotate = qAbs(event->rotationZ());
     const int threshold = 2;
 
     if (move < threshold && zoom < threshold && rotate < threshold) {
         if (m_customEventStrategy) {
             m_customEventStrategy->finishInteraction(event->modifiers());
             KUndo2Command *command = m_customEventStrategy->createCommand();
             if (command) {
                 canvas()->addCommand(command);
             }
             delete m_customEventStrategy;
             m_customEventStrategy = 0;
             repaintDecorations();
         }
         event->accept();
         return;
     }
 
     // check if the z-movement is dominant
     if (zoom > move && zoom > rotate) {
         // zoom
         if (!m_customEventStrategy) {
             m_customEventStrategy = new ShapeResizeStrategy(this, event->point, KoFlake::TopLeftHandle);
         }
     } else if (move > zoom && move > rotate) { // check if x-/y-movement is dominant
         // move
         if (!m_customEventStrategy) {
             m_customEventStrategy = new ShapeMoveStrategy(this, event->point);
         }
     } else if (rotate > zoom && rotate > move) { // rotation is dominant
         // rotate
         if (!m_customEventStrategy) {
             m_customEventStrategy = new ShapeRotateStrategy(this, event->point, event->buttons());
         }
     }
 
     if (m_customEventStrategy) {
         m_customEventStrategy->handleCustomEvent(event);
     }
 
     event->accept();
 }
 
 void DefaultTool::repaintDecorations()
 {
     if (koSelection() && koSelection()->count() > 0) {
         canvas()->updateCanvas(handlesSize());
     }
 }
 
 void DefaultTool::copy() const
 {
     QList<KoShape *> shapes = canvas()->shapeManager()->selection()->selectedShapes(KoFlake::TopLevelSelection);
     if (!shapes.empty()) {
         KoShapeOdfSaveHelper saveHelper(shapes);
         KoDrag drag;
         drag.setOdf(KoOdf::mimeType(KoOdf::Text), saveHelper);
         drag.addToClipboard();
     }
 }
 
 void DefaultTool::deleteSelection()
 {
     QList<KoShape *> shapes;
     foreach (KoShape *s, canvas()->shapeManager()->selection()->selectedShapes(KoFlake::TopLevelSelection)) {
         if (s->isGeometryProtected()) {
             continue;
         }
         shapes << s;
     }
     if (!shapes.empty()) {
         canvas()->addCommand(canvas()->shapeController()->removeShapes(shapes));
     }
 }
 
 bool DefaultTool::paste()
 {
     // we no longer have to do anything as tool Proxy will do it for us
     return false;
 }
 
 QStringList DefaultTool::supportedPasteMimeTypes() const
 {
     QStringList list;
     list << KoOdf::mimeType(KoOdf::Text);
     return list;
 }
 
 KoSelection *DefaultTool::koSelection()
 {
     Q_ASSERT(canvas());
     Q_ASSERT(canvas()->shapeManager());
     return canvas()->shapeManager()->selection();
 }
 
 KoFlake::SelectionHandle DefaultTool::handleAt(const QPointF &point, bool *innerHandleMeaning)
 {
     // check for handles in this order; meaning that when handles overlap the one on top is chosen
     static const KoFlake::SelectionHandle handleOrder[] = {
         KoFlake::BottomRightHandle,
         KoFlake::TopLeftHandle,
         KoFlake::BottomLeftHandle,
         KoFlake::TopRightHandle,
         KoFlake::BottomMiddleHandle,
         KoFlake::RightMiddleHandle,
         KoFlake::LeftMiddleHandle,
         KoFlake::TopMiddleHandle,
         KoFlake::NoHandle
     };
 
     if (koSelection() && koSelection()->count() == 0) {
         return KoFlake::NoHandle;
     }
 
     recalcSelectionBox();
     const KoViewConverter *converter = canvas()->viewConverter();
     if (!converter) {
         return KoFlake::NoHandle;
     }
 
     if (innerHandleMeaning != 0) {
         QPainterPath path;
         path.addPolygon(m_selectionOutline);
         *innerHandleMeaning = path.contains(point) || path.intersects(handlePaintRect(point));
     }
     for (int i = 0; i < KoFlake::NoHandle; ++i) {
         KoFlake::SelectionHandle handle = handleOrder[i];
         QPointF pt = converter->documentToView(point) - converter->documentToView(m_selectionBox[handle]);
 
         // if just inside the outline
         if (qAbs(pt.x()) < HANDLE_DISTANCE &&
                 qAbs(pt.y()) < HANDLE_DISTANCE) {
             if (innerHandleMeaning != 0) {
                 if (qAbs(pt.x()) < 4 && qAbs(pt.y()) < 4) {
                     *innerHandleMeaning = true;
                 }
             }
             return handle;
         }
     }
     return KoFlake::NoHandle;
 }
 
 void DefaultTool::recalcSelectionBox()
 {
     if (!koSelection()) {
         return;
     }
 
     if (koSelection()->count() == 0) {
         return;
     }
 
     if (koSelection()->count() > 1) {
         QTransform matrix = koSelection()->absoluteTransformation(0);
         m_selectionOutline = matrix.map(QPolygonF(QRectF(QPointF(0, 0), koSelection()->size())));
         m_angle = 0.0; //koSelection()->rotation();
     } else {
         QTransform matrix = koSelection()->firstSelectedShape()->absoluteTransformation(0);
         m_selectionOutline = matrix.map(QPolygonF(QRectF(QPointF(0, 0), koSelection()->firstSelectedShape()->size())));
         m_angle = 0.0; //koSelection()->firstSelectedShape()->rotation();
     }
     QPolygonF outline = m_selectionOutline; //shorter name in the following :)
     m_selectionBox[KoFlake::TopMiddleHandle] = (outline.value(0) + outline.value(1)) / 2;
     m_selectionBox[KoFlake::TopRightHandle] = outline.value(1);
     m_selectionBox[KoFlake::RightMiddleHandle] = (outline.value(1) + outline.value(2)) / 2;
     m_selectionBox[KoFlake::BottomRightHandle] = outline.value(2);
     m_selectionBox[KoFlake::BottomMiddleHandle] = (outline.value(2) + outline.value(3)) / 2;
     m_selectionBox[KoFlake::BottomLeftHandle] = outline.value(3);
     m_selectionBox[KoFlake::LeftMiddleHandle] = (outline.value(3) + outline.value(0)) / 2;
     m_selectionBox[KoFlake::TopLeftHandle] = outline.value(0);
     if (koSelection()->count() == 1) {
 #if 0        // TODO detect mirroring
         KoShape *s = koSelection()->firstSelectedShape();
 
         if (s->scaleX() < 0) { // vertically mirrored: swap left / right
             qSwap(m_selectionBox[KoFlake::TopLeftHandle], m_selectionBox[KoFlake::TopRightHandle]);
             qSwap(m_selectionBox[KoFlake::LeftMiddleHandle], m_selectionBox[KoFlake::RightMiddleHandle]);
             qSwap(m_selectionBox[KoFlake::BottomLeftHandle], m_selectionBox[KoFlake::BottomRightHandle]);
         }
         if (s->scaleY() < 0) { // vertically mirrored: swap top / bottom
             qSwap(m_selectionBox[KoFlake::TopLeftHandle], m_selectionBox[KoFlake::BottomLeftHandle]);
             qSwap(m_selectionBox[KoFlake::TopMiddleHandle], m_selectionBox[KoFlake::BottomMiddleHandle]);
             qSwap(m_selectionBox[KoFlake::TopRightHandle], m_selectionBox[KoFlake::BottomRightHandle]);
         }
 #endif
     }
 }
 
 void DefaultTool::activate(ToolActivation, const QSet<KoShape *> &)
 {
     m_mouseWasInsideHandles = false;
     m_lastHandle = KoFlake::NoHandle;
     useCursor(Qt::ArrowCursor);
     repaintDecorations();
     updateActions();
 }
 
 void DefaultTool::selectionAlignHorizontalLeft()
 {
     selectionAlign(KoShapeAlignCommand::HorizontalLeftAlignment);
 }
 
 void DefaultTool::selectionAlignHorizontalCenter()
 {
     selectionAlign(KoShapeAlignCommand::HorizontalCenterAlignment);
 }
 
 void DefaultTool::selectionAlignHorizontalRight()
 {
     selectionAlign(KoShapeAlignCommand::HorizontalRightAlignment);
 }
 
 void DefaultTool::selectionAlignVerticalTop()
 {
     selectionAlign(KoShapeAlignCommand::VerticalTopAlignment);
 }
 
 void DefaultTool::selectionAlignVerticalCenter()
 {
     selectionAlign(KoShapeAlignCommand::VerticalCenterAlignment);
 }
 
 void DefaultTool::selectionAlignVerticalBottom()
 {
     selectionAlign(KoShapeAlignCommand::VerticalBottomAlignment);
 }
 
 void DefaultTool::selectionGroup()
 {
     KoSelection *selection = koSelection();
     if (!selection) {
         return;
     }
 
     QList<KoShape *> selectedShapes = selection->selectedShapes(KoFlake::TopLevelSelection);
     QList<KoShape *> groupedShapes;
 
     // only group shapes with an unselected parent
     foreach (KoShape *shape, selectedShapes) {
         if (!selectedShapes.contains(shape->parent()) && shape->isEditable()) {
             groupedShapes << shape;
         }
     }
     KoShapeGroup *group = new KoShapeGroup();
     // TODO what if only one shape is left?
     KUndo2Command *cmd = new KUndo2Command(kundo2_i18n("Group shapes"));
     canvas()->shapeController()->addShapeDirect(group, cmd);
     KoShapeGroupCommand::createCommand(group, groupedShapes, cmd);
     canvas()->addCommand(cmd);
 
     // update selection so we can ungroup immediately again
     selection->deselectAll();
     selection->select(group);
 }
 
 void DefaultTool::selectionUngroup()
 {
     KoSelection *selection = canvas()->shapeManager()->selection();
     if (!selection) {
         return;
     }
 
     QList<KoShape *> selectedShapes = selection->selectedShapes(KoFlake::TopLevelSelection);
     QList<KoShape *> containerSet;
 
     // only ungroup shape groups with an unselected parent
     foreach (KoShape *shape, selectedShapes) {
         if (!selectedShapes.contains(shape->parent()) && shape->isEditable()) {
             containerSet << shape;
         }
     }
 
     KUndo2Command *cmd = 0;
 
     // add a ungroup command for each found shape container to the macro command
     Q_FOREACH (KoShape *shape, containerSet) {
         KoShapeGroup *group = dynamic_cast<KoShapeGroup *>(shape);
         if (group) {
             cmd = cmd ? cmd : new KUndo2Command(kundo2_i18n("Ungroup shapes"));
             new KoShapeUngroupCommand(group, group->shapes(),
                                       group->parent() ? QList<KoShape *>() : canvas()->shapeManager()->topLevelShapes(),
                                       cmd);
             canvas()->shapeController()->removeShape(group, cmd);
         }
     }
     if (cmd) {
         canvas()->addCommand(cmd);
     }
 }
 
 void DefaultTool::selectionAlign(KoShapeAlignCommand::Align align)
 {
     KoSelection *selection = canvas()->shapeManager()->selection();
     if (!selection) {
         return;
     }
 
     QList<KoShape *> selectedShapes = selection->selectedShapes(KoFlake::TopLevelSelection);
     if (selectedShapes.count() < 1) {
         return;
     }
 
     QList<KoShape *> editableShapes = filterEditableShapes(selectedShapes);
 
     // TODO add an option to the widget so that one can align to the page
     // with multiple selected shapes too
 
     QRectF bb;
 
     // single selected shape is automatically aligned to document rect
     if (editableShapes.count() == 1) {
         if (!canvas()->resourceManager()->hasResource(KoCanvasResourceManager::PageSize)) {
             return;
         }
         bb = QRectF(QPointF(0, 0), canvas()->resourceManager()->sizeResource(KoCanvasResourceManager::PageSize));
     } else {
         Q_FOREACH (KoShape *shape, editableShapes) {
             bb |= shape->boundingRect();
         }
     }
 
     KoShapeAlignCommand *cmd = new KoShapeAlignCommand(editableShapes, align, bb);
 
     canvas()->addCommand(cmd);
     selection->updateSizeAndPosition();
 }
 
 void DefaultTool::selectionBringToFront()
 {
     selectionReorder(KoShapeReorderCommand::BringToFront);
 }
 
 void DefaultTool::selectionMoveUp()
 {
     selectionReorder(KoShapeReorderCommand::RaiseShape);
 }
 
 void DefaultTool::selectionMoveDown()
 {
     selectionReorder(KoShapeReorderCommand::LowerShape);
 }
 
 void DefaultTool::selectionSendToBack()
 {
     selectionReorder(KoShapeReorderCommand::SendToBack);
 }
 
 void DefaultTool::selectionReorder(KoShapeReorderCommand::MoveShapeType order)
 {
     KoSelection *selection = canvas()->shapeManager()->selection();
     if (!selection) {
         return;
     }
 
     QList<KoShape *> selectedShapes = selection->selectedShapes(KoFlake::TopLevelSelection);
     if (selectedShapes.count() < 1) {
         return;
     }
 
     QList<KoShape *> editableShapes = filterEditableShapes(selectedShapes);
     if (editableShapes.count() < 1) {
         return;
     }
 
     KUndo2Command *cmd = KoShapeReorderCommand::createCommand(editableShapes, canvas()->shapeManager(), order);
     if (cmd) {
         canvas()->addCommand(cmd);
     }
 }
 
 QList<QPointer<QWidget> > DefaultTool::createOptionWidgets()
 {
     QList<QPointer<QWidget> > widgets;
     DefaultToolArrangeWidget *defaultArrange = new DefaultToolArrangeWidget(this);
     defaultArrange->setWindowTitle(i18n("Arrange"));
     widgets.append(defaultArrange);
     DefaultToolWidget *defaultTool = new DefaultToolWidget(this);
     defaultTool->setWindowTitle(i18n("Geometry"));
     widgets.append(defaultTool);
+
     KoStrokeConfigWidget *strokeWidget = new KoStrokeConfigWidget(0);
+    KisDocumentAwareSpinBoxUnitManager* managerLineWidth = new KisDocumentAwareSpinBoxUnitManager(strokeWidget);
+    KisDocumentAwareSpinBoxUnitManager* managerMitterLimit = new KisDocumentAwareSpinBoxUnitManager(strokeWidget);
+    managerLineWidth->setApparentUnitFromSymbol("px");
+    managerMitterLimit->setApparentUnitFromSymbol("px"); //set unit to px by default
+    strokeWidget->setUnitManagers(managerLineWidth, managerMitterLimit);
     strokeWidget->setWindowTitle(i18n("Line"));
     strokeWidget->setCanvas(canvas());
     widgets.append(strokeWidget);
 
     KoFillConfigWidget *fillWidget = new KoFillConfigWidget(0);
     fillWidget->setWindowTitle(i18n("Fill"));
     fillWidget->setCanvas(canvas());
     widgets.append(fillWidget);
 
     KoShadowConfigWidget *shadowWidget = new KoShadowConfigWidget(0);
+    KisDocumentAwareSpinBoxUnitManager* managerBlur = new KisDocumentAwareSpinBoxUnitManager(shadowWidget); //let the shadow widget be aware of document relative units.
+    KisDocumentAwareSpinBoxUnitManager* managerOffset = new KisDocumentAwareSpinBoxUnitManager(shadowWidget); //let the shadow widget be aware of document relative units.
+    shadowWidget->setUnitManagers(managerBlur, managerOffset);
     shadowWidget->setWindowTitle(i18n("Shadow"));
     shadowWidget->setCanvas(canvas());
     widgets.append(shadowWidget);
 
     return widgets;
 }
 
 void DefaultTool::canvasResourceChanged(int key, const QVariant &res)
 {
     if (key == HotPosition) {
         m_hotPosition = static_cast<KoFlake::Position>(res.toInt());
         repaintDecorations();
     }
 }
 
 KoInteractionStrategy *DefaultTool::createStrategy(KoPointerEvent *event)
 {
     // reset the move by keys when a new strategy is created otherwise we might change the
     // command after a new command was added. This happend when you where faster than the timer.
     m_moveCommand = 0;
 
     KoShapeManager *shapeManager = canvas()->shapeManager();
     KoSelection *select = shapeManager->selection();
     bool insideSelection;
     KoFlake::SelectionHandle handle = handleAt(event->point, &insideSelection);
 
     bool editableShape = editableShapesCount(select->selectedShapes());
 
     if (event->buttons() & Qt::MidButton) {
         // change the hot selection position when middle clicking on a handle
         KoFlake::Position newHotPosition = m_hotPosition;
         switch (handle) {
         case KoFlake::TopLeftHandle:
             newHotPosition = KoFlake::TopLeftCorner;
             break;
         case KoFlake::TopRightHandle:
             newHotPosition = KoFlake::TopRightCorner;
             break;
         case KoFlake::BottomLeftHandle:
             newHotPosition = KoFlake::BottomLeftCorner;
             break;
         case KoFlake::BottomRightHandle:
             newHotPosition = KoFlake::BottomRightCorner;
             break;
         default: {
             // check if we had hit the center point
             const KoViewConverter *converter = canvas()->viewConverter();
             QPointF pt = converter->documentToView(event->point - select->absolutePosition());
             if (qAbs(pt.x()) < HANDLE_DISTANCE && qAbs(pt.y()) < HANDLE_DISTANCE) {
                 newHotPosition = KoFlake::CenteredPosition;
             }
             break;
         }
         }
         if (m_hotPosition != newHotPosition) {
             canvas()->resourceManager()->setResource(HotPosition, newHotPosition);
         }
         return 0;
     }
 
     bool selectMultiple = event->modifiers() & Qt::ControlModifier;
     bool selectNextInStack = event->modifiers() & Qt::ShiftModifier;
 
     if (editableShape) {
         // manipulation of selected shapes goes first
         if (handle != KoFlake::NoHandle) {
             if (event->buttons() == Qt::LeftButton) {
                 // resizing or shearing only with left mouse button
                 if (insideSelection) {
                     return new ShapeResizeStrategy(this, event->point, handle);
                 }
                 if (handle == KoFlake::TopMiddleHandle || handle == KoFlake::RightMiddleHandle ||
                         handle == KoFlake::BottomMiddleHandle || handle == KoFlake::LeftMiddleHandle) {
                     return new ShapeShearStrategy(this, event->point, handle);
                 }
             }
             // rotating is allowed for rigth mouse button too
             if (handle == KoFlake::TopLeftHandle || handle == KoFlake::TopRightHandle ||
                     handle == KoFlake::BottomLeftHandle || handle == KoFlake::BottomRightHandle) {
                 return new ShapeRotateStrategy(this, event->point, event->buttons());
             }
         }
         if (!(selectMultiple || selectNextInStack) && event->buttons() == Qt::LeftButton) {
             const QPainterPath outlinePath = select->transformation().map(select->outline());
             if (outlinePath.contains(event->point) || outlinePath.intersects(handlePaintRect(event->point))) {
                 return new ShapeMoveStrategy(this, event->point);
             }
         }
     }
 
     if ((event->buttons() & Qt::LeftButton) == 0) {
         return 0;    // Nothing to do for middle/right mouse button
     }
 
     KoShape *shape = shapeManager->shapeAt(event->point, selectNextInStack ? KoFlake::NextUnselected : KoFlake::ShapeOnTop);
 
     if (!shape && handle == KoFlake::NoHandle) {
         if (!selectMultiple) {
             repaintDecorations();
             select->deselectAll();
         }
         return new KoShapeRubberSelectStrategy(this, event->point);
     }
 
     if (select->isSelected(shape)) {
         if (selectMultiple) {
             repaintDecorations();
             select->deselect(shape);
         }
     } else if (handle == KoFlake::NoHandle) { // clicked on shape which is not selected
         repaintDecorations();
         if (!selectMultiple) {
             shapeManager->selection()->deselectAll();
         }
         select->select(shape, selectNextInStack ? false : true);
         repaintDecorations();
         // tablet selection isn't precise and may lead to a move, preventing that
         if (event->isTabletEvent()) {
             return new NopInteractionStrategy(this);
         }
         return new ShapeMoveStrategy(this, event->point);
     }
     return 0;
 }
 
 void DefaultTool::updateActions()
 {
     KoSelection *selection(koSelection());
     if (!selection) {
         action("object_order_front")->setEnabled(false);
         action("object_order_raise")->setEnabled(false);
         action("object_order_lower")->setEnabled(false);
         action("object_order_back")->setEnabled(false);
         action("object_align_horizontal_left")->setEnabled(false);
         action("object_align_horizontal_center")->setEnabled(false);
         action("object_align_horizontal_right")->setEnabled(false);
         action("object_align_vertical_top")->setEnabled(false);
         action("object_align_vertical_center")->setEnabled(false);
         action("object_align_vertical_bottom")->setEnabled(false);
         action("object_group")->setEnabled(false);
         action("object_ungroup")->setEnabled(false);
         return;
     }
 
     QList<KoShape *> editableShapes = filterEditableShapes(selection->selectedShapes(KoFlake::TopLevelSelection));
     bool enable = editableShapes.count() > 0;
     action("object_order_front")->setEnabled(enable);
     action("object_order_raise")->setEnabled(enable);
     action("object_order_lower")->setEnabled(enable);
     action("object_order_back")->setEnabled(enable);
     enable = (editableShapes.count() > 1) || (enable && canvas()->resourceManager()->hasResource(KoCanvasResourceManager::PageSize));
     action("object_align_horizontal_left")->setEnabled(enable);
     action("object_align_horizontal_center")->setEnabled(enable);
     action("object_align_horizontal_right")->setEnabled(enable);
     action("object_align_vertical_top")->setEnabled(enable);
     action("object_align_vertical_center")->setEnabled(enable);
     action("object_align_vertical_bottom")->setEnabled(enable);
 
     action("object_group")->setEnabled(editableShapes.count() > 1);
     bool groupShape = false;
     foreach (KoShape *shape, editableShapes) {
         if (dynamic_cast<KoShapeGroup *>(shape)) {
             groupShape = true;
             break;
         }
     }
     action("object_ungroup")->setEnabled(groupShape);
 
     emit selectionChanged(selection->count());
 }
 
 KoToolSelection *DefaultTool::selection()
 {
     return m_selectionHandler;
 }
 
 QList<KoShape *> DefaultTool::filterEditableShapes(const QList<KoShape *> &shapes)
 {
     QList<KoShape *> editableShapes;
     Q_FOREACH (KoShape *shape, shapes) {
         if (shape->isEditable()) {
             editableShapes.append(shape);
         }
     }
 
     return editableShapes;
 }
 
 uint DefaultTool::editableShapesCount(const QList<KoShape *> &shapes)
 {
     uint count = 0;
     Q_FOREACH (KoShape *shape, shapes) {
         if (shape->isEditable()) {
             count++;
         }
     }
 
     return count;
 }
diff --git a/plugins/tools/defaulttool/defaulttool/DefaultToolTransformWidget.cpp b/plugins/tools/defaulttool/defaulttool/DefaultToolTransformWidget.cpp
index 93b5c7db6f..37461e944e 100644
--- a/plugins/tools/defaulttool/defaulttool/DefaultToolTransformWidget.cpp
+++ b/plugins/tools/defaulttool/defaulttool/DefaultToolTransformWidget.cpp
@@ -1,284 +1,286 @@
 /* This file is part of the KDE project
  * Copyright (C) 2007 Martin Pfeiffer <hubipete@gmx.net>
  * Copyright (C) 2007 Jan Hambrecht <jaham@gmx.net>
  * Copyright (C) 2008 Thorsten Zachmann <zachmann@kde.org>
  * Copyright (C) 2008 C. Boemann <cbo@boemann.dk>
  *
  * This library is free software; you can redistribute it and/or
  * modify it under the terms of the GNU Library General Public
  * License as published by the Free Software Foundation; either
  * version 2 of the License, or (at your option) any later version.
  *
  * This library is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  * Library General Public License for more details.
  *
  * You should have received a copy of the GNU Library General Public License
  * along with this library; see the file COPYING.LIB.  If not, write to
  * the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
  * Boston, MA 02110-1301, USA.
  */
 
 #include "DefaultToolTransformWidget.h"
 
 #include <KoInteractionTool.h>
 #include <KoCanvasBase.h>
 #include <KoCanvasResourceManager.h>
 #include <KoShapeManager.h>
 #include <KoSelection.h>
 #include <KoUnit.h>
 #include <commands/KoShapeMoveCommand.h>
 #include <commands/KoShapeSizeCommand.h>
 #include <commands/KoShapeTransformCommand.h>
 #include "SelectionDecorator.h"
 
 #include <QSize>
 #include <QRadioButton>
 #include <QLabel>
 #include <QCheckBox>
 #include <QDoubleSpinBox>
 #include <QList>
 #include <QTransform>
 
+#include "kis_document_aware_spin_box_unit_manager.h"
+
 DefaultToolTransformWidget::DefaultToolTransformWidget(KoInteractionTool *tool, QWidget *parent)
     : QMenu(parent)
 {
     m_tool = tool;
 
     setupUi(this);
 
     setUnit(m_tool->canvas()->unit());
 
     connect(m_tool->canvas()->resourceManager(), SIGNAL(canvasResourceChanged(int,QVariant)),
             this, SLOT(resourceChanged(int,QVariant)));
 
     connect(rotateButton, SIGNAL(clicked()), this, SLOT(rotationChanged()));
     connect(shearXButton, SIGNAL(clicked()), this, SLOT(shearXChanged()));
     connect(shearYButton, SIGNAL(clicked()), this, SLOT(shearYChanged()));
     connect(scaleXButton, SIGNAL(clicked()), this, SLOT(scaleXChanged()));
     connect(scaleYButton, SIGNAL(clicked()), this, SLOT(scaleYChanged()));
     connect(scaleAspectCheckBox, SIGNAL(toggled(bool)), scaleYSpinBox, SLOT(setDisabled(bool)));
     connect(scaleAspectCheckBox, SIGNAL(toggled(bool)), scaleYButton, SLOT(setDisabled(bool)));
     connect(resetButton, SIGNAL(clicked()), this, SLOT(resetTransformations()));
 }
 
 void DefaultToolTransformWidget::setUnit(const KoUnit &unit)
 {
     shearXSpinBox->setUnit(unit);
     shearYSpinBox->setUnit(unit);
 }
 
 void DefaultToolTransformWidget::resourceChanged(int key, const QVariant &res)
 {
     if (key == KoCanvasResourceManager::Unit) {
         setUnit(res.value<KoUnit>());
     }
 }
 
 void DefaultToolTransformWidget::rotationChanged()
 {
     QList<KoShape *> selectedShapes = m_tool->canvas()->shapeManager()->selection()->selectedShapes(KoFlake::TopLevelSelection);
     QList<QTransform> oldTransforms;
 
     Q_FOREACH (KoShape *shape, selectedShapes) {
         oldTransforms << shape->transformation();
     }
 
     qreal angle = rotateSpinBox->value();
     QPointF rotationCenter = m_tool->canvas()->shapeManager()->selection()->absolutePosition(SelectionDecorator::hotPosition());
     QTransform matrix;
     matrix.translate(rotationCenter.x(), rotationCenter.y());
     matrix.rotate(angle);
     matrix.translate(-rotationCenter.x(), -rotationCenter.y());
 
     Q_FOREACH (KoShape *shape, selectedShapes) {
         shape->update();
         shape->applyAbsoluteTransformation(matrix);
         shape->update();
     }
 
     m_tool->canvas()->shapeManager()->selection()->applyAbsoluteTransformation(matrix);
     QList<QTransform> newTransforms;
 
     Q_FOREACH (KoShape *shape, selectedShapes) {
         newTransforms << shape->transformation();
     }
 
     KoShapeTransformCommand *cmd = new KoShapeTransformCommand(selectedShapes, oldTransforms, newTransforms);
     cmd->setText(kundo2_i18n("Rotate"));
     m_tool->canvas()->addCommand(cmd);
 }
 
 void DefaultToolTransformWidget::shearXChanged()
 {
     KoSelection *selection = m_tool->canvas()->shapeManager()->selection();
     QList<KoShape *> selectedShapes = selection->selectedShapes(KoFlake::TopLevelSelection);
     QList<QTransform> oldTransforms;
 
     Q_FOREACH (KoShape *shape, selectedShapes) {
         oldTransforms << shape->transformation();
     }
 
     qreal shearX = shearXSpinBox->value() / selection->size().height();
     QPointF basePoint = selection->absolutePosition(SelectionDecorator::hotPosition());
     QTransform matrix;
     matrix.translate(basePoint.x(), basePoint.y());
     matrix.shear(shearX, 0.0);
     matrix.translate(-basePoint.x(), -basePoint.y());
 
     Q_FOREACH (KoShape *shape, selectedShapes) {
         shape->update();
         shape->applyAbsoluteTransformation(matrix);
         shape->update();
     }
 
     selection->applyAbsoluteTransformation(matrix);
     QList<QTransform> newTransforms;
 
     Q_FOREACH (KoShape *shape, selectedShapes) {
         newTransforms << shape->transformation();
     }
 
     KoShapeTransformCommand *cmd = new KoShapeTransformCommand(selectedShapes, oldTransforms, newTransforms);
     cmd->setText(kundo2_i18n("Shear X"));
     m_tool->canvas()->addCommand(cmd);
 }
 
 void DefaultToolTransformWidget::shearYChanged()
 {
     KoSelection *selection = m_tool->canvas()->shapeManager()->selection();
     QList<KoShape *> selectedShapes = selection->selectedShapes(KoFlake::TopLevelSelection);
     QList<QTransform> oldTransforms;
 
     Q_FOREACH (KoShape *shape, selectedShapes) {
         oldTransforms << shape->transformation();
     }
 
     qreal shearY = shearYSpinBox->value() / selection->size().width();
     QPointF basePoint = selection->absolutePosition(SelectionDecorator::hotPosition());
     QTransform matrix;
     matrix.translate(basePoint.x(), basePoint.y());
     matrix.shear(0.0, shearY);
     matrix.translate(-basePoint.x(), -basePoint.y());
 
     Q_FOREACH (KoShape *shape, selectedShapes) {
         shape->update();
         shape->applyAbsoluteTransformation(matrix);
         shape->update();
     }
 
     selection->applyAbsoluteTransformation(matrix);
     QList<QTransform> newTransforms;
 
     Q_FOREACH (KoShape *shape, selectedShapes) {
         newTransforms << shape->transformation();
     }
 
     KoShapeTransformCommand *cmd = new KoShapeTransformCommand(selectedShapes, oldTransforms, newTransforms);
     cmd->setText(kundo2_i18n("Shear Y"));
     m_tool->canvas()->addCommand(cmd);
 }
 
 void DefaultToolTransformWidget::scaleXChanged()
 {
     QList<KoShape *> selectedShapes = m_tool->canvas()->shapeManager()->selection()->selectedShapes(KoFlake::TopLevelSelection);
     QList<QTransform> oldTransforms;
 
     Q_FOREACH (KoShape *shape, selectedShapes) {
         oldTransforms << shape->transformation();
     }
 
     qreal scale = scaleXSpinBox->value() * 0.01; // Input is in per cent
     QPointF basePoint = m_tool->canvas()->shapeManager()->selection()->absolutePosition(SelectionDecorator::hotPosition());
     QTransform matrix;
     matrix.translate(basePoint.x(), basePoint.y());
 
     if (scaleAspectCheckBox->isChecked()) {
         matrix.scale(scale, scale);
     } else {
         matrix.scale(scale, 1.0);
     }
 
     matrix.translate(-basePoint.x(), -basePoint.y());
 
     Q_FOREACH (KoShape *shape, selectedShapes) {
         shape->update();
         shape->applyAbsoluteTransformation(matrix);
         shape->update();
     }
 
     m_tool->canvas()->shapeManager()->selection()->applyAbsoluteTransformation(matrix);
     QList<QTransform> newTransforms;
 
     Q_FOREACH (KoShape *shape, selectedShapes) {
         newTransforms << shape->transformation();
     }
 
     KoShapeTransformCommand *cmd = new KoShapeTransformCommand(selectedShapes, oldTransforms, newTransforms);
     cmd->setText(kundo2_i18n("Scale"));
     m_tool->canvas()->addCommand(cmd);
 }
 
 void DefaultToolTransformWidget::scaleYChanged()
 {
     QList<KoShape *> selectedShapes = m_tool->canvas()->shapeManager()->selection()->selectedShapes(KoFlake::TopLevelSelection);
     QList<QTransform> oldTransforms;
 
     Q_FOREACH (KoShape *shape, selectedShapes) {
         oldTransforms << shape->transformation();
     }
 
     qreal scale = scaleYSpinBox->value() * 0.01; // Input is in per cent
     QPointF basePoint = m_tool->canvas()->shapeManager()->selection()->absolutePosition(SelectionDecorator::hotPosition());
     QTransform matrix;
     matrix.translate(basePoint.x(), basePoint.y());
     matrix.scale(1.0, scale);
     matrix.translate(-basePoint.x(), -basePoint.y());
 
     Q_FOREACH (KoShape *shape, selectedShapes) {
         shape->update();
         shape->applyAbsoluteTransformation(matrix);
         shape->update();
     }
 
     m_tool->canvas()->shapeManager()->selection()->applyAbsoluteTransformation(matrix);
     QList<QTransform> newTransforms;
 
     Q_FOREACH (KoShape *shape, selectedShapes) {
         newTransforms << shape->transformation();
     }
 
     KoShapeTransformCommand *cmd = new KoShapeTransformCommand(selectedShapes, oldTransforms, newTransforms);
     cmd->setText(kundo2_i18n("Scale"));
     m_tool->canvas()->addCommand(cmd);
 }
 
 void DefaultToolTransformWidget::resetTransformations()
 {
     QList<KoShape *> selectedShapes = m_tool->canvas()->shapeManager()->selection()->selectedShapes(KoFlake::TopLevelSelection);
     QList<QTransform> oldTransforms;
 
     Q_FOREACH (KoShape *shape, selectedShapes) {
         oldTransforms << shape->transformation();
     }
 
     QTransform matrix;
 
     Q_FOREACH (KoShape *shape, selectedShapes) {
         shape->update();
         shape->setTransformation(matrix);
         shape->update();
     }
 
     m_tool->canvas()->shapeManager()->selection()->applyAbsoluteTransformation(matrix);
     QList<QTransform> newTransforms;
 
     Q_FOREACH (KoShape *shape, selectedShapes) {
         newTransforms << shape->transformation();
     }
 
     KoShapeTransformCommand *cmd = new KoShapeTransformCommand(selectedShapes, oldTransforms, newTransforms);
     cmd->setText(kundo2_i18n("Reset Transformations"));
     m_tool->canvas()->addCommand(cmd);
 }
diff --git a/plugins/tools/defaulttool/defaulttool/DefaultToolWidget.cpp b/plugins/tools/defaulttool/defaulttool/DefaultToolWidget.cpp
index 5c5b0e7b91..408daa2358 100644
--- a/plugins/tools/defaulttool/defaulttool/DefaultToolWidget.cpp
+++ b/plugins/tools/defaulttool/defaulttool/DefaultToolWidget.cpp
@@ -1,280 +1,282 @@
 /* This file is part of the KDE project
  * Copyright (C) 2007 Martin Pfeiffer <hubipete@gmx.net>
  * Copyright (C) 2007 Jan Hambrecht <jaham@gmx.net>
    Copyright (C) 2008 Thorsten Zachmann <zachmann@kde.org>
  * Copyright (C) 2010 Thomas Zander <zander@kde.org>
  *
  * This library is free software; you can redistribute it and/or
  * modify it under the terms of the GNU Library General Public
  * License as published by the Free Software Foundation; either
  * version 2 of the License, or (at your option) any later version.
  *
  * This library is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  * Library General Public License for more details.
  *
  * You should have received a copy of the GNU Library General Public License
  * along with this library; see the file COPYING.LIB.  If not, write to
  * the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
  * Boston, MA 02110-1301, USA.
  */
 
 #include "DefaultToolWidget.h"
 #include "DefaultTool.h"
 
 #include <KoInteractionTool.h>
 #include <KoCanvasBase.h>
 #include <KoCanvasResourceManager.h>
 #include <KoShapeManager.h>
 #include <KoSelection.h>
 #include <KoUnit.h>
 #include <commands/KoShapeMoveCommand.h>
 #include <commands/KoShapeSizeCommand.h>
 #include <commands/KoShapeTransformCommand.h>
 #include <KoPositionSelector.h>
 #include "SelectionDecorator.h"
 #include "DefaultToolTransformWidget.h"
 
 #include <QAction>
 #include <QSize>
 #include <QRadioButton>
 #include <QLabel>
 #include <QCheckBox>
 #include <QDoubleSpinBox>
 #include <QList>
 #include <QTransform>
 
+#include "kis_document_aware_spin_box_unit_manager.h"
+
 DefaultToolWidget::DefaultToolWidget(KoInteractionTool *tool, QWidget *parent)
     : QWidget(parent)
     , m_tool(tool)
     , m_blockSignals(false)
 {
     setupUi(this);
 
     setUnit(m_tool->canvas()->unit());
 
     aspectButton->setKeepAspectRatio(false);
     updatePosition();
     updateSize();
 
     connect(positionSelector, SIGNAL(positionSelected(KoFlake::Position)),
             this, SLOT(positionSelected(KoFlake::Position)));
 
     connect(positionXSpinBox, SIGNAL(editingFinished()), this, SLOT(positionHasChanged()));
     connect(positionYSpinBox, SIGNAL(editingFinished()), this, SLOT(positionHasChanged()));
 
     connect(widthSpinBox, SIGNAL(editingFinished()), this, SLOT(sizeHasChanged()));
     connect(heightSpinBox, SIGNAL(editingFinished()), this, SLOT(sizeHasChanged()));
 
     KoSelection *selection = m_tool->canvas()->shapeManager()->selection();
     connect(selection, SIGNAL(selectionChanged()), this, SLOT(updatePosition()));
     connect(selection, SIGNAL(selectionChanged()), this, SLOT(updateSize()));
     KoShapeManager *manager = m_tool->canvas()->shapeManager();
     connect(manager, SIGNAL(selectionContentChanged()), this, SLOT(updatePosition()));
     connect(manager, SIGNAL(selectionContentChanged()), this, SLOT(updateSize()));
 
     connect(m_tool->canvas()->resourceManager(), SIGNAL(canvasResourceChanged(int,QVariant)),
             this, SLOT(resourceChanged(int,QVariant)));
 
     connect(aspectButton, SIGNAL(keepAspectRatioChanged(bool)),
             this, SLOT(aspectButtonToggled(bool)));
 }
 
 void DefaultToolWidget::positionSelected(KoFlake::Position position)
 {
     m_tool->canvas()->resourceManager()->setResource(DefaultTool::HotPosition, QVariant(position));
     updatePosition();
 }
 
 void DefaultToolWidget::updatePosition()
 {
     QPointF selPosition(0, 0);
     KoFlake::Position position = positionSelector->position();
 
     KoSelection *selection = m_tool->canvas()->shapeManager()->selection();
     if (selection && selection->count()) {
         selPosition = selection->absolutePosition(position);
     }
 
     positionXSpinBox->setEnabled(selection && selection->count());
     positionYSpinBox->setEnabled(selection && selection->count());
 
     if (m_blockSignals) {
         return;
     }
     m_blockSignals = true;
     positionXSpinBox->changeValue(selPosition.x());
     positionYSpinBox->changeValue(selPosition.y());
 
     QList<KoShape *> selectedShapes = selection->selectedShapes(KoFlake::TopLevelSelection);
     bool aspectLocked = false;
     foreach (KoShape *shape, selectedShapes) {
         aspectLocked = aspectLocked | shape->keepAspectRatio();
     }
     aspectButton->setKeepAspectRatio(aspectLocked);
     m_blockSignals = false;
 }
 
 void DefaultToolWidget::positionHasChanged()
 {
     KoSelection *selection = m_tool->canvas()->shapeManager()->selection();
     if (!selection || selection->count() <= 0) {
         return;
     }
 
     KoFlake::Position position = positionSelector->position();
     QPointF newPos(positionXSpinBox->value(), positionYSpinBox->value());
     QPointF oldPos = selection->absolutePosition(position);
     if (oldPos == newPos) {
         return;
     }
 
     QList<KoShape *> selectedShapes = selection->selectedShapes(KoFlake::TopLevelSelection);
     QPointF moveBy = newPos - oldPos;
     QList<QPointF> oldPositions;
     QList<QPointF> newPositions;
     Q_FOREACH (KoShape *shape, selectedShapes) {
         oldPositions.append(shape->position());
         newPositions.append(shape->position() + moveBy);
     }
     selection->setPosition(selection->position() + moveBy);
     m_tool->canvas()->addCommand(new KoShapeMoveCommand(selectedShapes, oldPositions, newPositions));
     updatePosition();
 }
 
 void DefaultToolWidget::updateSize()
 {
     QSizeF selSize(0, 0);
     KoSelection *selection = m_tool->canvas()->shapeManager()->selection();
     uint selectionCount = 0;
     if (selection && selection->count()) {
         selectionCount = selection->count();
     }
     if (selectionCount) {
         selSize = selection->boundingRect().size();
     }
 
     widthSpinBox->setEnabled(selectionCount);
     heightSpinBox->setEnabled(selectionCount);
 
     if (m_blockSignals) {
         return;
     }
     m_blockSignals = true;
     widthSpinBox->changeValue(selSize.width());
     heightSpinBox->changeValue(selSize.height());
     m_blockSignals = false;
 }
 
 void DefaultToolWidget::sizeHasChanged()
 {
     if (aspectButton->hasFocus()) {
         return;
     }
     if (m_blockSignals) {
         return;
     }
 
     QSizeF newSize(widthSpinBox->value(), heightSpinBox->value());
 
     KoSelection *selection = m_tool->canvas()->shapeManager()->selection();
     QRectF rect = selection->boundingRect();
 
     if (aspectButton->keepAspectRatio()) {
         qreal aspect = rect.width() / rect.height();
         if (rect.width() != newSize.width()) {
             newSize.setHeight(newSize.width() / aspect);
         } else if (rect.height() != newSize.height()) {
             newSize.setWidth(newSize.height() * aspect);
         }
     }
 
     if (rect.width() != newSize.width() || rect.height() != newSize.height()) {
         // get the scale/resize center from the position selector
         QPointF scaleCenter = selection->absolutePosition(positionSelector->position());
 
         QTransform resizeMatrix;
         resizeMatrix.translate(scaleCenter.x(), scaleCenter.y());
         // make sure not to divide by 0 in case the selection is a line and has no width. In this case just scale by 1.
         resizeMatrix.scale(rect.width() ? newSize.width() / rect.width() : 1, rect.height() ? newSize.height() / rect.height() : 1);
         resizeMatrix.translate(-scaleCenter.x(), -scaleCenter.y());
 
         QList<KoShape *> selectedShapes = selection->selectedShapes(KoFlake::StrippedSelection);
         QList<QSizeF> oldSizes, newSizes;
         QList<QTransform> oldState;
         QList<QTransform> newState;
 
         Q_FOREACH (KoShape *shape, selectedShapes) {
             shape->update();
             QSizeF oldSize = shape->size();
             oldState << shape->transformation();
             QTransform shapeMatrix = shape->absoluteTransformation(0);
 
             // calculate the matrix we would apply to the local shape matrix
             // that tells us the effective scale values we have to use for the resizing
             QTransform localMatrix = shapeMatrix * resizeMatrix * shapeMatrix.inverted();
             // save the effective scale values, without any mirroring portion
             const qreal scaleX = qAbs(localMatrix.m11());
             const qreal scaleY = qAbs(localMatrix.m22());
 
             // calculate the scale matrix which is equivalent to our resizing above
             QTransform scaleMatrix = (QTransform().scale(scaleX, scaleY));
             scaleMatrix =  shapeMatrix.inverted() * scaleMatrix * shapeMatrix;
 
             // calculate the new size of the shape, using the effective scale values
             oldSizes << oldSize;
             QSizeF newSize = QSizeF(scaleX * oldSize.width(), scaleY * oldSize.height());
             newSizes << newSize;
             shape->setSize(newSize);
 
             // apply the rest of the transformation without the resizing part
             shape->applyAbsoluteTransformation(scaleMatrix.inverted() * resizeMatrix);
             newState << shape->transformation();
         }
         m_tool->repaintDecorations();
         selection->applyAbsoluteTransformation(resizeMatrix);
         KUndo2Command *cmd = new KUndo2Command(kundo2_i18n("Resize"));
         new KoShapeSizeCommand(selectedShapes, oldSizes, newSizes, cmd);
         new KoShapeTransformCommand(selectedShapes, oldState, newState, cmd);
         m_tool->canvas()->addCommand(cmd);
         updateSize();
         updatePosition();
     }
 }
 
 void DefaultToolWidget::setUnit(const KoUnit &unit)
 {
     m_blockSignals = true;
     positionXSpinBox->setUnit(unit);
     positionYSpinBox->setUnit(unit);
     widthSpinBox->setUnit(unit);
     heightSpinBox->setUnit(unit);
     m_blockSignals = false;
 
     updatePosition();
     updateSize();
 }
 
 void DefaultToolWidget::resourceChanged(int key, const QVariant &res)
 {
     if (key == KoCanvasResourceManager::Unit) {
         setUnit(res.value<KoUnit>());
     } else if (key == DefaultTool::HotPosition) {
         if (res.toInt() != positionSelector->position()) {
             positionSelector->setPosition(static_cast<KoFlake::Position>(res.toInt()));
             updatePosition();
         }
     }
 }
 
 void DefaultToolWidget::aspectButtonToggled(bool keepAspect)
 {
     if (m_blockSignals) {
         return;
     }
     KoSelection *selection = m_tool->canvas()->shapeManager()->selection();
     foreach (KoShape *shape, selection->selectedShapes(KoFlake::TopLevelSelection)) {
         shape->setKeepAspectRatio(keepAspect);
     }
 }
diff --git a/plugins/tools/selectiontools/kis_tool_select_path.cc b/plugins/tools/selectiontools/kis_tool_select_path.cc
index 23ecc10b51..fa0dd2d5af 100644
--- a/plugins/tools/selectiontools/kis_tool_select_path.cc
+++ b/plugins/tools/selectiontools/kis_tool_select_path.cc
@@ -1,167 +1,173 @@
 /*
  *  Copyright (c) 2007 Sven Langkamp <sven.langkamp@gmail.com>
  *
  *  This program is free software; you can redistribute it and/or modify
  *  it under the terms of the GNU General Public License as published by
  *  the Free Software Foundation; either version 2 of the License, or
  *  (at your option) any later version.
  *
  *  This program is distributed in the hope that it will be useful,
  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  *  GNU General Public License for more details.
  *
  *  You should have received a copy of the GNU General Public License
  *  along with this program; if not, write to the Free Software
  *  Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
  */
 
 #include "kis_tool_select_path.h"
 
 #include <KoPathShape.h>
 
 #include "kis_cursor.h"
 #include "kis_image.h"
 #include "kis_painter.h"
 #include "kis_selection_options.h"
 #include "kis_canvas_resource_provider.h"
 #include "kis_canvas2.h"
 #include "kis_pixel_selection.h"
 #include "kis_selection_tool_helper.h"
 #include <KisView.h>
 
 
 KisToolSelectPath::KisToolSelectPath(KoCanvasBase * canvas)
     : KisToolSelectBase<KisDelegatedSelectPathWrapper>(canvas,
                                                        KisCursor::load("tool_polygonal_selection_cursor.png", 6, 6),
                                                        i18n("Select path"),
                                                        (KisTool*) (new __KisToolSelectPathLocalTool(canvas, this)))
 {
 }
 
 void KisToolSelectPath::requestStrokeEnd()
 {
     localTool()->endPathWithoutLastPoint();
 }
 
 void KisToolSelectPath::requestStrokeCancellation()
 {
     localTool()->cancelPath();
 }
 
 void KisToolSelectPath::mousePressEvent(KoPointerEvent* event)
 {
     if (!selectionEditable()) return;
     DelegatedSelectPathTool::mousePressEvent(event);
 }
 
 // Install an event filter to catch right-click events.
 // This code is duplicated in kis_tool_path.cc
 bool KisToolSelectPath::eventFilter(QObject *obj, QEvent *event)
 {
     Q_UNUSED(obj);
     if (event->type() == QEvent::MouseButtonPress ||
-        event->type() == QEvent::MouseButtonDblClick) {
+            event->type() == QEvent::MouseButtonDblClick) {
         QMouseEvent *mouseEvent = static_cast<QMouseEvent*>(event);
         if (mouseEvent->button() == Qt::RightButton) {
             localTool()->removeLastPoint();
             return true;
         }
     } else if (event->type() == QEvent::TabletPress) {
         QTabletEvent *tabletEvent = static_cast<QTabletEvent*>(event);
         if (tabletEvent->button() == Qt::RightButton) {
             localTool()->removeLastPoint();
             return true;
         }
     }
     return false;
 }
 
 QList<QPointer<QWidget> > KisToolSelectPath::createOptionWidgets()
 {
     QList<QPointer<QWidget> > widgetsList =
             DelegatedSelectPathTool::createOptionWidgets();
-    return widgetsList;
+    QList<QPointer<QWidget> > filteredWidgets;
+    Q_FOREACH (QWidget* widget, widgetsList) {
+        if (widget->objectName() != "Stroke widget") {
+            filteredWidgets.push_back(widget);
+        }
+    }
+    return filteredWidgets;
 }
 
 void KisToolSelectPath::setAlternateSelectionAction(SelectionAction action)
 {
     // We will turn off the ability to change the selection in the middle of drawing a path.
     if (!m_localTool->listeningToModifiers()) {
         KisToolSelectBase<KisDelegatedSelectPathWrapper>::setAlternateSelectionAction(action);
     }
 }
 
 
 bool KisDelegatedSelectPathWrapper::listeningToModifiers() {
     return m_localTool->listeningToModifiers();
 }
 
 void KisDelegatedSelectPathWrapper::beginPrimaryAction(KoPointerEvent *event) {
     mousePressEvent(event);
 }
 
 void KisDelegatedSelectPathWrapper::continuePrimaryAction(KoPointerEvent *event){
     mouseMoveEvent(event);
 }
 
 void KisDelegatedSelectPathWrapper::endPrimaryAction(KoPointerEvent *event) {
     mouseReleaseEvent(event);
 }
 
 __KisToolSelectPathLocalTool::__KisToolSelectPathLocalTool(KoCanvasBase * canvas, KisToolSelectPath* parentTool)
     : KoCreatePathTool(canvas), m_selectionTool(parentTool)
 {
 }
 
 void __KisToolSelectPathLocalTool::paintPath(KoPathShape &pathShape, QPainter &painter, const KoViewConverter &converter)
 {
     Q_UNUSED(converter);
     KisCanvas2 * kisCanvas = dynamic_cast<KisCanvas2*>(canvas());
     if (!kisCanvas)
         return;
 
     QTransform matrix;
     matrix.scale(kisCanvas->image()->xRes(), kisCanvas->image()->yRes());
     matrix.translate(pathShape.position().x(), pathShape.position().y());
     m_selectionTool->paintToolOutline(&painter, m_selectionTool->pixelToView(matrix.map(pathShape.outline())));
 }
 
 void __KisToolSelectPathLocalTool::addPathShape(KoPathShape* pathShape)
 {
     pathShape->normalize();
     pathShape->close();
 
     KisCanvas2 * kisCanvas = dynamic_cast<KisCanvas2*>(canvas());
     if (!kisCanvas)
         return;
 
     KisImageWSP image = kisCanvas->image();
 
     KisSelectionToolHelper helper(kisCanvas, kundo2_i18n("Select by Bezier Curve"));
 
     if (m_selectionTool->selectionMode() == PIXEL_SELECTION) {
 
         KisPixelSelectionSP tmpSel = KisPixelSelectionSP(new KisPixelSelection());
 
         KisPainter painter(tmpSel);
         painter.setPaintColor(KoColor(Qt::black, tmpSel->colorSpace()));
         painter.setFillStyle(KisPainter::FillStyleForegroundColor);
         painter.setAntiAliasPolygonFill(m_selectionTool->antiAliasSelection());
         painter.setStrokeStyle(KisPainter::StrokeStyleNone);
 
         QTransform matrix;
         matrix.scale(image->xRes(), image->yRes());
         matrix.translate(pathShape->position().x(), pathShape->position().y());
 
         QPainterPath path = matrix.map(pathShape->outline());
         painter.fillPainterPath(path);
         tmpSel->setOutlineCache(path);
 
         helper.selectPixelSelection(tmpSel, m_selectionTool->selectionAction());
 
         delete pathShape;
     } else {
         helper.addSelectionShape(pathShape);
     }
 }
diff --git a/plugins/tools/selectiontools/kis_tool_select_path.h b/plugins/tools/selectiontools/kis_tool_select_path.h
index f321c52cf1..261fbed4ba 100644
--- a/plugins/tools/selectiontools/kis_tool_select_path.h
+++ b/plugins/tools/selectiontools/kis_tool_select_path.h
@@ -1,107 +1,107 @@
 /*
  *  Copyright (c) 2007 Sven Langkamp <sven.langkamp@gmail.com>
  *  Copyright (c) 2015 Michael Abrahams <miabraha@gmail.com>
  *
  *  This program is free software; you can redistribute it and/or modify
  *  it under the terms of the GNU General Public License as published by
  *  the Free Software Foundation; either version 2 of the License, or
  *  (at your option) any later version.
  *
  *  This program is distributed in the hope that it will be useful,
  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  *  GNU General Public License for more details.
  *
  *  You should have received a copy of the GNU General Public License
  *  along with this program; if not, write to the Free Software
  *  Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
  */
 
 #ifndef KIS_TOOL_SELECT_PATH_H_
 #define KIS_TOOL_SELECT_PATH_H_
 
 #include <KoCreatePathTool.h>
 #include <KoToolFactoryBase.h>
 #include "kis_tool_select_base.h"
 #include "kis_delegated_tool.h"
 
 #include <kis_icon.h>
 
 class KoCanvasBase;
 class KisToolSelectPath;
 
 
 class __KisToolSelectPathLocalTool : public KoCreatePathTool {
 public:
     __KisToolSelectPathLocalTool(KoCanvasBase * canvas, KisToolSelectPath* parentTool);
     virtual void paintPath(KoPathShape &path, QPainter &painter, const KoViewConverter &converter);
     virtual void addPathShape(KoPathShape* pathShape);
 
     using KoCreatePathTool::createOptionWidgets;
     using KoCreatePathTool::endPathWithoutLastPoint;
     using KoCreatePathTool::endPath;
     using KoCreatePathTool::cancelPath;
     using KoCreatePathTool::removeLastPoint;
 
 private:
     KisToolSelectPath* const m_selectionTool;
 };
 
 typedef KisDelegatedTool<KisTool, __KisToolSelectPathLocalTool,
-                         DeselectShapesActivationPolicy> DelegatedSelectPathTool;
+DeselectShapesActivationPolicy> DelegatedSelectPathTool;
 
 struct KisDelegatedSelectPathWrapper : public DelegatedSelectPathTool {
     KisDelegatedSelectPathWrapper(KoCanvasBase *canvas,
                                   const QCursor &cursor,
                                   KisTool* delegateTool)
         : DelegatedSelectPathTool(canvas, cursor, (__KisToolSelectPathLocalTool*) delegateTool)
     {
     }
     bool listeningToModifiers();
 
     // If an event is explicitly forwarded only as an action (e.g. shift-click is captured by "change size")
     // we will receive a primary action but no mousePressEvent.  Thus these events must be explicitly forwarded.
     void beginPrimaryAction(KoPointerEvent *event);
     void continuePrimaryAction(KoPointerEvent *event);
     void endPrimaryAction(KoPointerEvent *event);
 };
 
 
 class KisToolSelectPath : public KisToolSelectBase<KisDelegatedSelectPathWrapper>
 {
     Q_OBJECT
 public:
     KisToolSelectPath(KoCanvasBase * canvas);
     void mousePressEvent(KoPointerEvent* event);
     bool eventFilter(QObject *obj, QEvent *event);
 
 protected:
     void requestStrokeCancellation();
     void requestStrokeEnd();
     void setAlternateSelectionAction(SelectionAction action);
     friend class __KisToolSelectPathLocalTool;
     QList<QPointer<QWidget> > createOptionWidgets();
 };
 
 class KisToolSelectPathFactory : public KoToolFactoryBase
 {
 public:
     KisToolSelectPathFactory()
         : KoToolFactoryBase("KisToolSelectPath") {
         setToolTip(i18n("Bezier Curve Selection Tool"));
         setSection(TOOL_TYPE_SELECTION);
         setActivationShapeId(KRITA_TOOL_ACTIVATION_ID);
         setIconName(koIconNameCStr("tool_path_selection"));
         setPriority(6);
     }
 
     virtual ~KisToolSelectPathFactory() {}
 
     virtual KoToolBase * createTool(KoCanvasBase *canvas) {
         return new KisToolSelectPath(canvas);
     }
 };
 
 
 
 #endif // KIS_TOOL_SELECT_PATH_H_