diff --git a/libs/ui/CMakeLists.txt b/libs/ui/CMakeLists.txt
index 3b6c778cc9..b55f9c9d00 100644
--- a/libs/ui/CMakeLists.txt
+++ b/libs/ui/CMakeLists.txt
@@ -1,592 +1,592 @@
 include_directories(
     ${CMAKE_CURRENT_SOURCE_DIR}/qtlockedfile
     ${EXIV2_INCLUDE_DIR}
 )
 
 include_directories(SYSTEM
     ${EIGEN3_INCLUDE_DIR}
     ${OCIO_INCLUDE_DIR}
 )
 
 add_subdirectory( tests )
 
 if (APPLE)
     find_library(FOUNDATION_LIBRARY Foundation)
     find_library(APPKIT_LIBRARY AppKit)
 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
     canvas/KisSnapPointStrategy.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/KisSessionManagerDialog.cpp
     dialogs/KisNewWindowLayoutDialog.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
     KisPaintopPropertiesBase.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_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_change_file_layer_command.h
     kis_safe_document_loader.cpp
     kis_splash_screen.cpp
     kis_filter_manager.cc
     kis_filters_model.cc
     kis_histogram_view.cc
     KisImageBarrierLockerWithFeedback.cpp
     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
     KisNodeDisplayModeAdapter.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
     KisDecorationsManager.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
     KisResourceServerProvider.cpp
     KisResourceBundleServerProvider.cpp
     KisSelectedShapesProxy.cpp
     kis_selection_decoration.cc
     kis_selection_manager.cc
     KisSelectionActionsAdapter.cpp
     kis_statusbar.cc
     kis_zoom_manager.cc
     kis_favorite_resource_manager.cpp
     kis_workspace_resource.cpp
     kis_action.cpp
     kis_action_manager.cpp
     KisActionPlugin.cpp
     kis_canvas_controls_manager.cpp
     kis_tooltip_manager.cpp
     kis_multinode_property.cpp
     kis_stopgradient_editor.cpp
     KisWelcomePageWidget.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
     opengl/kis_texture_tile_info_pool.cpp
     opengl/KisOpenGLUpdateInfoBuilder.cpp
     kis_fps_decoration.cpp
     tool/KisToolChangesTracker.cpp
     tool/KisToolChangesTrackerData.cpp
     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_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/KisStrokeSpeedMonitor.cpp
     tool/strokes/freehand_stroke.cpp
     tool/strokes/KisStrokeEfficiencyMeasurer.cpp
     tool/strokes/kis_painter_based_stroke_strategy.cpp
     tool/strokes/kis_filter_stroke_strategy.cpp
     tool/strokes/kis_color_picker_stroke_strategy.cpp
     tool/strokes/KisFreehandStrokeInfo.cpp
     tool/strokes/KisMaskedFreehandStrokePainter.cpp
     tool/strokes/KisMaskingBrushRenderer.cpp
     tool/strokes/KisMaskingBrushCompositeOpFactory.cpp
     tool/strokes/move_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_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_paintop_presets_save.cpp
     widgets/kis_paintop_preset_icon_library.cpp
     widgets/kis_pattern_chooser.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/KisSelectionPropertySlider.cpp
     widgets/kis_size_group.cpp
     widgets/kis_size_group_p.cpp
     widgets/kis_wdg_generator.cpp
     widgets/kis_workspace_chooser.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_preset_live_preview_view.cpp
     widgets/KisScreenColorPicker.cpp
     widgets/KoDualColorButton.cpp
     widgets/KoStrokeConfigWidget.cpp
     widgets/KoFillConfigWidget.cpp
     
     KisPaletteEditor.cpp
     dialogs/KisDlgPaletteEditor.cpp
 
     widgets/KisNewsWidget.cpp
-	widgets/KisGamutMaskToolbar.cpp
+    widgets/KisGamutMaskToolbar.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_native_gesture_shortcut.cpp
     input/kis_single_action_shortcut.cpp
     input/kis_stroke_shortcut.cpp
     input/kis_shortcut_matcher.cpp
     input/kis_select_layer_action.cpp
     input/KisQtWidgetsTweaker.cpp
     input/KisInputActionGroup.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
     actions/KisPasteActionFactory.cpp
     actions/KisTransformToolActivationCommand.cpp
     input/kis_touch_shortcut.cpp
     kis_document_undo_store.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
     KisCloneDocumentStroke.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
     KisImportExportUtils.cpp
     kis_async_action_feedback.cpp
     KisMainWindow.cpp
     KisOpenPane.cpp
     KisPart.cpp
     KisPrintJob.cpp
     KisTemplate.cpp
     KisTemplateCreateDia.cpp
     KisTemplateGroup.cpp
     KisTemplates.cpp
     KisTemplatesPane.cpp
     KisTemplateTree.cpp
     KisUndoActionsUpdateManager.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
 
     KisSaveGroupVisitor.cpp
     KisWindowLayoutResource.cpp
     KisWindowLayoutManager.cpp
     KisSessionResource.cpp
 
     KisReferenceImagesDecoration.cpp
     KisReferenceImage.cpp
     flake/KisReferenceImagesLayer.cpp
     flake/KisReferenceImagesLayer.h
 
 )
 
 if(WIN32)
     set(kritaui_LIB_SRCS
         ${kritaui_LIB_SRCS}
         input/wintab/kis_tablet_support_win.cpp
         input/wintab/kis_screen_size_choice_dialog.cpp
         qtlockedfile/qtlockedfile_win.cpp
         input/wintab/kis_tablet_support_win8.cpp
         opengl/kis_opengl_win.cpp
         )
 endif()
 
     set(kritaui_LIB_SRCS
         ${kritaui_LIB_SRCS}
         kis_animation_frame_cache.cpp
         kis_animation_cache_populator.cpp
         KisAsyncAnimationRendererBase.cpp
         KisAsyncAnimationCacheRenderer.cpp
         KisAsyncAnimationFramesSavingRenderer.cpp
         dialogs/KisAsyncAnimationRenderDialogBase.cpp
         dialogs/KisAsyncAnimationCacheRenderDialog.cpp
         dialogs/KisAsyncAnimationFramesSaveDialog.cpp
         canvas/kis_animation_player.cpp
         kis_animation_importer.cpp
         KisSyncedAudioPlayback.cpp
         KisFrameDataSerializer.cpp
         KisFrameCacheStore.cpp
         KisFrameCacheSwapper.cpp
         KisAbstractFrameCacheSwapper.cpp
         KisInMemoryFrameCacheSwapper.cpp
 
         input/wintab/drawpile_tablettester/tablettester.cpp
         input/wintab/drawpile_tablettester/tablettest.cpp
     )
 
 if (UNIX)
     set(kritaui_LIB_SRCS
         ${kritaui_LIB_SRCS}
         qtlockedfile/qtlockedfile_unix.cpp
         )
     if(NOT USE_QT_XCB)
     set(kritaui_LIB_SRCS
         ${kritaui_LIB_SRCS}
         input/wintab/kis_tablet_support.cpp
     )
     endif()
     if(NOT APPLE AND NOT USE_QT_XCB)
         set(kritaui_LIB_SRCS
             ${kritaui_LIB_SRCS}
             input/wintab/qxcbconnection_xi2.cpp
             input/wintab/qxcbconnection.cpp
             input/wintab/kis_xi2_event_filter.cpp
             )
     endif()
 endif()
 
 if(APPLE)
     set(kritaui_LIB_SRCS
         ${kritaui_LIB_SRCS}
         osx.mm
     )
 endif()
 
 ki18n_wrap_ui(kritaui_LIB_SRCS
     widgets/KoFillConfigWidget.ui
     widgets/KoStrokeConfigWidget.ui
     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/wdgmultipliersdoublesliderspinbox.ui
     forms/wdgnodequerypatheditor.ui
     forms/wdgpresetselectorstrip.ui
     forms/wdgsavebrushpreset.ui
     forms/wdgpreseticonlibrary.ui
     forms/wdgdlgblacklistcleanup.ui
     forms/wdgrectangleconstraints.ui
     forms/wdgimportimagesequence.ui
     forms/wdgstrokeselectionproperties.ui
     forms/KisDetailsPaneBase.ui
     forms/KisOpenPaneBase.ui
     forms/wdgstopgradienteditor.ui
     forms/wdgsessionmanager.ui
     forms/wdgnewwindowlayout.ui
     forms/KisWelcomePage.ui
     forms/WdgDlgPaletteEditor.ui
     forms/KisNewsPage.ui
-	forms/wdgGamutMaskToolbar.ui
+    forms/wdgGamutMaskToolbar.ui
 
     brushhud/kis_dlg_brush_hud_config.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
     input/wintab/drawpile_tablettester/tablettest.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 (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})
     target_link_libraries(kritaui ${APPKIT_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/widgets/KisScreenColorPicker.cpp b/libs/ui/widgets/KisScreenColorPicker.cpp
index 70f543aacc..1bdc75549f 100644
--- a/libs/ui/widgets/KisScreenColorPicker.cpp
+++ b/libs/ui/widgets/KisScreenColorPicker.cpp
@@ -1,284 +1,288 @@
 /*
  * Copyright (C) Wolthera van Hovell tot Westerflier <griffinvalley@gmail.com>, (C) 2016
  *
  *  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 <QDesktopWidget>
 #include <QGuiApplication>
 #include <QApplication>
 #include <QScreen>
 #include <QColor>
 #include <QVBoxLayout>
 #include <QLabel>
 #include <QPushButton>
 #include <QWindow>
 #include <QTimer>
 
 #include <kis_canvas2.h>
 
 #include "kis_shared_ptr.h"
 #include "kis_icon.h"
 #include "kis_image.h"
 #include "kis_wrapped_rect.h"
 #include "KisPart.h"
 #include "KisScreenColorPicker.h"
 #include "KisDlgInternalColorSelector.h"
 
 struct KisScreenColorPicker::Private
 {
-
     QPushButton *screenColorPickerButton = 0;
     QLabel *lblScreenColorInfo = 0;
 
     KoColor currentColor = KoColor();
     KoColor beforeScreenColorPicking = KoColor();
 
     KisScreenColorPickingEventFilter *colorPickingEventFilter = 0;
 
 #ifdef Q_OS_WIN32
     QTimer *updateTimer = 0;
     QWindow dummyTransparentWindow;
 #endif
 };
 
-KisScreenColorPicker::KisScreenColorPicker(QWidget *parent) : KisScreenColorPickerBase(parent), m_d(new Private)
+KisScreenColorPicker::KisScreenColorPicker(bool showInfoLabel, QWidget *parent) : KisScreenColorPickerBase(parent), m_d(new Private)
 {
     QVBoxLayout *layout = new QVBoxLayout();
     this->setLayout(layout);
     m_d->screenColorPickerButton = new QPushButton();
 
     m_d->screenColorPickerButton->setMinimumHeight(25);
     this->layout()->addWidget(m_d->screenColorPickerButton);
-    m_d->lblScreenColorInfo = new QLabel(QLatin1String("\n"));
-    this->layout()->addWidget(m_d->lblScreenColorInfo);
+
+    if (showInfoLabel) {
+        m_d->lblScreenColorInfo = new QLabel(QLatin1String("\n"));
+        this->layout()->addWidget(m_d->lblScreenColorInfo);
+    }
+
     connect(m_d->screenColorPickerButton, SIGNAL(clicked()), SLOT(pickScreenColor()));
 
     updateIcons();
 
 #ifdef Q_OS_WIN32
     m_d->updateTimer = new QTimer(this);
     m_d->dummyTransparentWindow.resize(1, 1);
     m_d->dummyTransparentWindow.setFlags(Qt::Tool | Qt::FramelessWindowHint);
     connect(m_d->updateTimer, SIGNAL(timeout()), SLOT(updateColorPicking()));
 #endif
 }
 
 KisScreenColorPicker::~KisScreenColorPicker()
 {
 }
 
 void KisScreenColorPicker::updateIcons()
 {
     m_d->screenColorPickerButton->setIcon(kisIcon("krita_tool_color_picker"));
 }
 
 KoColor KisScreenColorPicker::currentColor()
 {
     return m_d->currentColor;
 }
 
 void KisScreenColorPicker::pickScreenColor()
 {
     if (!m_d->colorPickingEventFilter)
         m_d->colorPickingEventFilter = new KisScreenColorPickingEventFilter(this);
     this->installEventFilter(m_d->colorPickingEventFilter);
     // If user pushes Escape, the last color before picking will be restored.
     m_d->beforeScreenColorPicking = currentColor();
     grabMouse(Qt::CrossCursor);
 
 #ifdef Q_OS_WIN32 // excludes WinCE and WinRT
     // On Windows mouse tracking doesn't work over other processes's windows
     m_d->updateTimer->start(30);
 
     // HACK: Because mouse grabbing doesn't work across processes, we have to have a dummy,
     // invisible window to catch the mouse click, otherwise we will click whatever we clicked
     // and loose focus.
     m_d->dummyTransparentWindow.show();
 #endif
     grabKeyboard();
     /* With setMouseTracking(true) the desired color can be more precisely picked up,
      * and continuously pushing the mouse button is not necessary.
      */
     setMouseTracking(true);
 
-    //emit to the rest of the dialog to disable.
-    Q_EMIT sigPleaseDisableEverything(true);
     m_d->screenColorPickerButton->setDisabled(true);
 
     const QPoint globalPos = QCursor::pos();
     setCurrentColor(grabScreenColor(globalPos));
     updateColorLabelText(globalPos);
 }
 
 void KisScreenColorPicker::setCurrentColor(KoColor c)
 {
     m_d->currentColor = c;
 }
 
 KoColor KisScreenColorPicker::grabScreenColor(const QPoint &p)
 {
     // First check whether we're clicking on a Krita window for some real color picking
     Q_FOREACH(KisView *view, KisPart::instance()->views()) {
         QWidget *canvasWidget = view->canvasBase()->canvasWidget();
         QPoint widgetPoint = canvasWidget->mapFromGlobal(p);
 
         if (canvasWidget->rect().contains(widgetPoint)) {
             QPointF imagePoint = view->canvasBase()->coordinatesConverter()->widgetToImage(widgetPoint);
             KisImageWSP image = view->image();
 
             if (image) {
                 if (image->wrapAroundModePermitted()) {
                     imagePoint = KisWrappedRect::ptToWrappedPt(imagePoint.toPoint(), image->bounds());
                 }
                 KoColor pickedColor = KoColor();
                 image->projection()->pixel(imagePoint.x(), imagePoint.y(), &pickedColor);
                 return pickedColor;
             }
         }
     }
 
     // And otherwise, we'll check the desktop
     const QDesktopWidget *desktop = QApplication::desktop();
     const QPixmap pixmap = QGuiApplication::screens().at(desktop->screenNumber())->grabWindow(desktop->winId(),
                                                                                               p.x(), p.y(), 1, 1);
     QImage i = pixmap.toImage();
     KoColor col = KoColor();
     col.fromQColor(QColor::fromRgb(i.pixel(0, 0)));
     return col;
 }
 
 void KisScreenColorPicker::updateColorLabelText(const QPoint &globalPos)
 {
-    KoColor col = grabScreenColor(globalPos);
-    QString colname = KoColor::toQString(col);
-    QString location = QString::number(globalPos.x())+QString(", ")+QString::number(globalPos.y());
-    m_d->lblScreenColorInfo->setWordWrap(true);
-    m_d->lblScreenColorInfo->setText(location+QString(": ")+colname);
+    if (m_d->lblScreenColorInfo) {
+        KoColor col = grabScreenColor(globalPos);
+        QString colname = KoColor::toQString(col);
+        QString location = QString::number(globalPos.x())+QString(", ")+QString::number(globalPos.y());
+        m_d->lblScreenColorInfo->setWordWrap(true);
+        m_d->lblScreenColorInfo->setText(location+QString(": ")+colname);
+    }
 }
 
 bool KisScreenColorPicker::handleColorPickingMouseMove(QMouseEvent *e)
 {
     // If the cross is visible the grabbed color will be black most of the times
     //cp->setCrossVisible(!cp->geometry().contains(e->pos()));
 
     continueUpdateColorPicking(e->globalPos());
     return true;
 }
 
 bool KisScreenColorPicker::handleColorPickingMouseButtonRelease(QMouseEvent *e)
 {
     setCurrentColor(grabScreenColor(e->globalPos()));
     Q_EMIT sigNewColorPicked(currentColor());
     releaseColorPicking();
     return true;
 }
 
 bool KisScreenColorPicker::handleColorPickingKeyPress(QKeyEvent *e)
 {
 #if QT_VERSION >= 0x050600
     if (e->matches(QKeySequence::Cancel)) {
 #else
     if (e->key() == Qt::Key_Escape) {
 #endif
         releaseColorPicking();
         setCurrentColor(m_d->beforeScreenColorPicking);
     } else if (e->key() == Qt::Key_Return || e->key() == Qt::Key_Enter) {
         setCurrentColor(grabScreenColor(QCursor::pos()));
         releaseColorPicking();
     }
     e->accept();
     return true;
 }
 
 void KisScreenColorPicker::releaseColorPicking()
 {
 
     removeEventFilter(m_d->colorPickingEventFilter);
     releaseMouse();
 #ifdef Q_OS_WIN32
     m_d->updateTimer->stop();
     m_d->dummyTransparentWindow.setVisible(false);
 #endif
     releaseKeyboard();
     setMouseTracking(false);
-    m_d->lblScreenColorInfo->setText(QLatin1String("\n"));
-    //emit enable signal
-    Q_EMIT sigPleaseDisableEverything(false);
+
+    if (m_d->lblScreenColorInfo) {
+        m_d->lblScreenColorInfo->setText(QLatin1String("\n"));
+    }
+
     m_d->screenColorPickerButton->setDisabled(false);
 }
 
 void KisScreenColorPicker::changeEvent(QEvent *e)
 {
     QWidget::changeEvent(e);
 }
 
 void KisScreenColorPicker::updateColorPicking()
 {
     static QPoint lastGlobalPos;
     QPoint newGlobalPos = QCursor::pos();
     if (lastGlobalPos == newGlobalPos)
         return;
     lastGlobalPos = newGlobalPos;
 
     if (!rect().contains(mapFromGlobal(newGlobalPos))) { // Inside the dialog mouse tracking works, handleColorPickingMouseMove will be called
         continueUpdateColorPicking(newGlobalPos);
 #ifdef Q_OS_WIN32
         m_d->dummyTransparentWindow.setPosition(newGlobalPos);
 #endif
     }
 }
 
 void KisScreenColorPicker::continueUpdateColorPicking(const QPoint &globalPos)
 {
     const KoColor color = grabScreenColor(globalPos);
     // QTBUG-39792, do not change standard, custom color selectors while moving as
     // otherwise it is not possible to pre-select a custom cell for assignment.
     setCurrentColor(color);
     updateColorLabelText(globalPos);
-
 }
 
 // Event filter to be installed on the dialog while in color-picking mode.
 KisScreenColorPickingEventFilter::KisScreenColorPickingEventFilter(KisScreenColorPicker *w, QObject *parent)
     : QObject(parent)
     , m_w(w)
 {}
 
 bool KisScreenColorPickingEventFilter::eventFilter(QObject *, QEvent *event)
 {
     switch (event->type()) {
     case QEvent::MouseMove:
         return m_w->handleColorPickingMouseMove(static_cast<QMouseEvent *>(event));
     case QEvent::MouseButtonRelease:
         return m_w->handleColorPickingMouseButtonRelease(static_cast<QMouseEvent *>(event));
     case QEvent::KeyPress:
         return m_w->handleColorPickingKeyPress(static_cast<QKeyEvent *>(event));
     default:
         break;
     }
     return false;
 }
 
 // Register the color picker factory with the internal color selector
 struct ColorPickerRegistrar {
     ColorPickerRegistrar()
     {
         KisDlgInternalColorSelector::setScreenColorPickerFactory(KisScreenColorPicker::createScreenColorPicker);
     }
 };
 
 static ColorPickerRegistrar s_colorPickerRegistrar;
 
diff --git a/libs/ui/widgets/KisScreenColorPicker.h b/libs/ui/widgets/KisScreenColorPicker.h
index 79c327e6db..6a8d07e6f6 100644
--- a/libs/ui/widgets/KisScreenColorPicker.h
+++ b/libs/ui/widgets/KisScreenColorPicker.h
@@ -1,84 +1,83 @@
 /*
  * Copyright (C) Wolthera van Hovell tot Westerflier <griffinvalley@gmail.com>, (C) 2016
  *
  *  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 KISSCREENCOLORPICKER_H
 #define KISSCREENCOLORPICKER_H
 
 #include <QScopedPointer>
 #include <QEvent>
 #include <QMouseEvent>
 
 #include "KoColor.h"
 #include <KisScreenColorPickerBase.h>
 
 #include "kritaui_export.h"
 
 /**
  * @brief The KisScreenColorPicker class
  * Based on the original QColorDialog's screen color picker, this class provides a button
  * that can be used to activate a colorpicker that can pick from anywhere on the screen.
  */
 class KRITAUI_EXPORT KisScreenColorPicker : public KisScreenColorPickerBase
 {
     Q_OBJECT
 public:
-    explicit KisScreenColorPicker(QWidget *parent = 0);
+    explicit KisScreenColorPicker(bool showInfoLabel = false, QWidget *parent = 0);
     ~KisScreenColorPicker() override;
 
     KoColor currentColor();
 
     bool handleColorPickingMouseMove(QMouseEvent *e);
     bool handleColorPickingMouseButtonRelease(QMouseEvent *e);
     bool handleColorPickingKeyPress(QKeyEvent *e);
 
     /// reloads icon(s) when theme is updated
     void updateIcons() override;
 
     static KisScreenColorPicker *createScreenColorPicker(QWidget *parent = 0) {return new KisScreenColorPicker(parent);}
 
 Q_SIGNALS:
     void sigNewColorPicked(KoColor c);
-    void sigPleaseDisableEverything(bool disable);
 
 public Q_SLOTS:
     void pickScreenColor();
 
 private Q_SLOTS:
     void updateColorPicking();
 protected:
     void changeEvent(QEvent *event) override;
 private:
     struct Private; //The private struct
     const QScopedPointer<Private> m_d; //the private pointer
 
     void setCurrentColor(KoColor c);
     KoColor grabScreenColor(const QPoint &p);
     void updateColorLabelText(const QPoint &globalPos);
     void releaseColorPicking();
     void continueUpdateColorPicking(const QPoint &globalPos);
 };
 
 class KisScreenColorPickingEventFilter : public QObject {
 public:
     explicit KisScreenColorPickingEventFilter(KisScreenColorPicker *w, QObject *parent = 0);
 
     bool eventFilter(QObject *, QEvent *event) override;
 private:
     KisScreenColorPicker *m_w;
 };
 
 #endif // KISSCREENCOLORPICKER_H
diff --git a/libs/widgets/KisDlgInternalColorSelector.cpp b/libs/widgets/KisDlgInternalColorSelector.cpp
index 83d7a7488a..d7a5480311 100644
--- a/libs/widgets/KisDlgInternalColorSelector.cpp
+++ b/libs/widgets/KisDlgInternalColorSelector.cpp
@@ -1,344 +1,344 @@
 /*
  * Copyright (C) Wolthera van Hovell tot Westerflier <griffinvalley@gmail.com>, (C) 2016
  *
  *  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 <QList>
 #include <QAbstractSpinBox>
 #include <QSpinBox>
 #include <QDoubleSpinBox>
 #include <QPointer>
 #include <QCompleter>
 
 #include <functional>
 
 #include <KConfigGroup>
 
 #include "KoColorSpaceRegistry.h"
 #include <KoColorSet.h>
 #include <KisPaletteModel.h>
 #include <KisPaletteListWidget.h>
 #include <kis_palette_view.h>
 #include <KoResourceServerProvider.h>
 #include <KoResourceServer.h>
 
 #include "kis_signal_compressor.h"
 #include "KoColorDisplayRendererInterface.h"
 
 #include "kis_spinbox_color_selector.h"
 
 #include "KisDlgInternalColorSelector.h"
 #include "ui_WdgDlgInternalColorSelector.h"
 #include "kis_config_notifier.h"
 #include "kis_color_input.h"
 #include "kis_icon_utils.h"
 #include "squeezedcombobox.h"
 
 std::function<KisScreenColorPickerBase *(QWidget *)> KisDlgInternalColorSelector::s_screenColorPickerFactory = 0;
 
 struct KisDlgInternalColorSelector::Private
 {
     bool allowUpdates = true;
     KoColor currentColor;
     KoColor previousColor;
     KoColor sRGB = KoColor(KoColorSpaceRegistry::instance()->rgb8());
     const KoColorSpace *currentColorSpace;
     bool lockUsedCS = false;
     bool chooseAlpha = false;
     KisSignalCompressor *compressColorChanges;
     const KoColorDisplayRendererInterface *displayRenderer;
     KisHexColorInput *hexColorInput = 0;
     KisPaletteModel *paletteModel = 0;
     KisPaletteListWidget *paletteChooser = 0;
     KisScreenColorPickerBase *screenColorPicker = 0;
 };
 
 KisDlgInternalColorSelector::KisDlgInternalColorSelector(QWidget *parent, KoColor color, Config config, const QString &caption, const KoColorDisplayRendererInterface *displayRenderer)
     : QDialog(parent)
     , m_d(new Private)
 {
     setModal(config.modal);
     setFocusPolicy(Qt::ClickFocus);
     m_ui = new Ui_WdgDlgInternalColorSelector();
     m_ui->setupUi(this);
 
     setWindowTitle(caption);
 
     m_d->currentColor = color;
     m_d->currentColorSpace = m_d->currentColor.colorSpace();
     m_d->displayRenderer = displayRenderer;
 
     m_ui->spinboxselector->slotSetColor(color);
     connect(m_ui->spinboxselector, SIGNAL(sigNewColor(KoColor)), this, SLOT(slotColorUpdated(KoColor)));
 
     m_ui->visualSelector->slotSetColor(color);
     m_ui->visualSelector->setDisplayRenderer(displayRenderer);
     m_ui->visualSelector->setConfig(false, config.modal);
     if (config.visualColorSelector) {
         connect(m_ui->visualSelector, SIGNAL(sigNewColor(KoColor)), this, SLOT(slotColorUpdated(KoColor)));
         connect(KisConfigNotifier::instance(), SIGNAL(configChanged()), m_ui->visualSelector, SLOT(configurationChanged()));
     } else {
         m_ui->visualSelector->hide();
     }
 
     m_d->paletteChooser = new KisPaletteListWidget(this);
     m_d->paletteModel = new KisPaletteModel(this);
     m_ui->bnPaletteChooser->setIcon(KisIconUtils::loadIcon("hi16-palette_library"));
     m_ui->paletteBox->setPaletteModel(m_d->paletteModel);
     m_ui->paletteBox->setDisplayRenderer(displayRenderer);
     m_ui->cmbNameList->setCompanionView(m_ui->paletteBox);
     connect(m_d->paletteChooser, SIGNAL(sigPaletteSelected(KoColorSet*)), this, SLOT(slotChangePalette(KoColorSet*)));
     connect(m_ui->cmbNameList, SIGNAL(sigColorSelected(KoColor)), SLOT(slotColorUpdated(KoColor)));
 
     // For some bizare reason, the modal dialog doesn't like having the colorset set, so let's not.
     if (config.paletteBox) {
         //TODO: Add disable signal as well. Might be not necessary...?
         KConfigGroup cfg(KSharedConfig::openConfig()->group(""));
         QString paletteName = cfg.readEntry("internal_selector_active_color_set", QString());
         KoResourceServer<KoColorSet>* rServer = KoResourceServerProvider::instance()->paletteServer();
         KoColorSet *savedPal = rServer->resourceByName(paletteName);
         if (savedPal) {
             this->slotChangePalette(savedPal);
         } else {
             if (rServer->resources().count()) {
                 savedPal = rServer->resources().first();
                 if (savedPal) {
                     this->slotChangePalette(savedPal);
                 }
             }
         }
 
         connect(m_ui->paletteBox, SIGNAL(sigColorSelected(KoColor)), this,
                 SLOT(slotColorUpdated(KoColor)));
         m_ui->bnPaletteChooser->setPopupWidget(m_d->paletteChooser);
     } else {
         m_ui->paletteBox->setEnabled(false);
         m_ui->cmbNameList->setEnabled(false);
         m_ui->bnPaletteChooser->setEnabled(false);
     }
 
     if (config.prevNextButtons) {
         m_ui->currentColor->setColor(m_d->currentColor);
         m_ui->currentColor->setDisplayRenderer(displayRenderer);
         m_ui->previousColor->setColor(m_d->currentColor);
         m_ui->previousColor->setDisplayRenderer(displayRenderer);
         connect(m_ui->previousColor, SIGNAL(triggered(KoColorPatch*)), SLOT(slotSetColorFromPatch(KoColorPatch*)));
     } else {
         m_ui->currentColor->hide();
         m_ui->previousColor->hide();
     }
 
     if (config.hexInput) {
         m_d->sRGB.fromKoColor(m_d->currentColor);
         m_d->hexColorInput = new KisHexColorInput(this, &m_d->sRGB);
         m_d->hexColorInput->update();
         connect(m_d->hexColorInput, SIGNAL(updated()), SLOT(slotSetColorFromHex()));
         m_ui->rightPane->addWidget(m_d->hexColorInput);
         m_d->hexColorInput->setToolTip(i18n("This is a hexcode input, for webcolors. It can only get colors in the sRGB space."));
     }
 
-    // screen color picker is in kritaui, so a dependency inversion is used to get it
+    // KisScreenColorPicker is in the kritaui module, so dependency inversion is used to access it.
     m_ui->screenColorPickerWidget->setLayout(new QHBoxLayout(m_ui->screenColorPickerWidget));
     if (s_screenColorPickerFactory) {
         m_d->screenColorPicker = s_screenColorPickerFactory(m_ui->screenColorPickerWidget);
         m_ui->screenColorPickerWidget->layout()->addWidget(m_d->screenColorPicker);
         if (config.screenColorPicker) {
             connect(m_d->screenColorPicker, SIGNAL(sigNewColorPicked(KoColor)),this, SLOT(slotColorUpdated(KoColor)));
         } else {
             m_d->screenColorPicker->hide();
         }
     }
 
     connect(this, SIGNAL(signalForegroundColorChosen(KoColor)), this, SLOT(slotLockSelector()));
     m_d->compressColorChanges = new KisSignalCompressor(100 /* ms */, KisSignalCompressor::POSTPONE, this);
     connect(m_d->compressColorChanges, SIGNAL(timeout()), this, SLOT(endUpdateWithNewColor()));
 
     connect(m_ui->buttonBox, SIGNAL(accepted()), this, SLOT(accept()));
     connect(m_ui->buttonBox, SIGNAL(rejected()), this, SLOT(reject()));
 
     connect(this, SIGNAL(finished(int)), SLOT(slotFinishUp()));
 }
 
 KisDlgInternalColorSelector::~KisDlgInternalColorSelector()
 {
     delete m_ui;
 }
 
 void KisDlgInternalColorSelector::slotColorUpdated(KoColor newColor)
 {
     //if the update did not come from this selector...
     if (m_d->allowUpdates || QObject::sender() == this->parent()) {
         if (m_d->lockUsedCS){
             newColor.convertTo(m_d->currentColorSpace);
             m_d->currentColor = newColor;
         } else {
             m_d->currentColor = newColor;
         }
         updateAllElements(QObject::sender());
     }
 }
 
 void KisDlgInternalColorSelector::slotSetColorFromPatch(KoColorPatch *patch)
 {
     slotColorUpdated(patch->color());
 }
 
 void KisDlgInternalColorSelector::colorSpaceChanged(const KoColorSpace *cs)
 {
     if (cs == m_d->currentColorSpace) {
         return;
     }
 
     m_d->currentColorSpace = KoColorSpaceRegistry::instance()->colorSpace(cs->colorModelId().id(), cs->colorDepthId().id(), cs->profile());
     m_ui->spinboxselector->slotSetColorSpace(m_d->currentColorSpace);
     m_ui->visualSelector->slotsetColorSpace(m_d->currentColorSpace);
 
 }
 
 void KisDlgInternalColorSelector::lockUsedColorSpace(const KoColorSpace *cs)
 {
     colorSpaceChanged(cs);
     m_d->lockUsedCS = true;
 }
 
 void KisDlgInternalColorSelector::setDisplayRenderer(const KoColorDisplayRendererInterface *displayRenderer)
 {
     if (displayRenderer) {
         m_d->displayRenderer = displayRenderer;
         m_ui->visualSelector->setDisplayRenderer(displayRenderer);
         m_ui->currentColor->setDisplayRenderer(displayRenderer);
         m_ui->previousColor->setDisplayRenderer(displayRenderer);
         m_ui->paletteBox->setDisplayRenderer(displayRenderer);
     } else {
         m_d->displayRenderer = KoDumbColorDisplayRenderer::instance();
     }
 }
 
 KoColor KisDlgInternalColorSelector::getModalColorDialog(const KoColor color, QWidget* parent, QString caption)
 {
     Config config = Config();
     KisDlgInternalColorSelector dialog(parent, color, config, caption);
     dialog.setPreviousColor(color);
     dialog.exec();
     return dialog.getCurrentColor();
 }
 
 KoColor KisDlgInternalColorSelector::getCurrentColor()
 {
     return m_d->currentColor;
 }
 
 void KisDlgInternalColorSelector::chooseAlpha(bool chooseAlpha)
 {
     m_d->chooseAlpha = chooseAlpha;
 }
 
 void KisDlgInternalColorSelector::slotConfigurationChanged()
 {
     //m_d->canvas->displayColorConverter()->
     //slotColorSpaceChanged(m_d->canvas->image()->colorSpace());
 }
 
 void KisDlgInternalColorSelector::slotLockSelector()
 {
     m_d->allowUpdates = false;
 }
 
 void KisDlgInternalColorSelector::setPreviousColor(KoColor c)
 {
     m_d->previousColor = c;
 }
 
 void KisDlgInternalColorSelector::reject()
 {
     slotColorUpdated(m_d->previousColor);
     QDialog::reject();
 }
 
 void KisDlgInternalColorSelector::updateAllElements(QObject *source)
 {
     //update everything!!!
     if (source != m_ui->spinboxselector) {
         m_ui->spinboxselector->slotSetColor(m_d->currentColor);
     }
     if (source != m_ui->visualSelector) {
         m_ui->visualSelector->slotSetColor(m_d->currentColor);
     }
 
     if (source != m_d->hexColorInput) {
         m_d->sRGB.fromKoColor(m_d->currentColor);
         m_d->hexColorInput->update();
     }
 
     if (source != m_ui->paletteBox) {
         m_ui->paletteBox->selectClosestColor(m_d->currentColor);
     }
 
     m_ui->previousColor->setColor(m_d->previousColor);
 
     m_ui->currentColor->setColor(m_d->currentColor);
 
     if (source != this->parent()) {
         emit(signalForegroundColorChosen(m_d->currentColor));
         m_d->compressColorChanges->start();
     }
 
     if (m_d->screenColorPicker) {
         m_d->screenColorPicker->updateIcons();
     }
 }
 
 
 void KisDlgInternalColorSelector::endUpdateWithNewColor()
 {
     m_d->allowUpdates = true;
 }
 
 void KisDlgInternalColorSelector::focusInEvent(QFocusEvent *)
 {
     //setPreviousColor();
 }
 
 void KisDlgInternalColorSelector::slotFinishUp()
 {
     setPreviousColor(m_d->currentColor);
     KConfigGroup cfg(KSharedConfig::openConfig()->group(""));
     if (m_d->paletteModel) {
         if (m_d->paletteModel->colorSet()) {
             cfg.writeEntry("internal_selector_active_color_set", m_d->paletteModel->colorSet()->name());
         }
     }
 }
 
 void KisDlgInternalColorSelector::slotSetColorFromHex()
 {
     slotColorUpdated(m_d->sRGB);
 }
 
 void KisDlgInternalColorSelector::slotChangePalette(KoColorSet *set)
 {
     if (!set) {
         return;
     }
     m_d->paletteModel->setPalette(set);
 }
 
 void KisDlgInternalColorSelector::showEvent(QShowEvent *event)
 {
     updateAllElements(0);
     QDialog::showEvent(event);
 }
 
diff --git a/libs/widgets/KisDlgInternalColorSelector.h b/libs/widgets/KisDlgInternalColorSelector.h
index 45b85df236..f703182557 100644
--- a/libs/widgets/KisDlgInternalColorSelector.h
+++ b/libs/widgets/KisDlgInternalColorSelector.h
@@ -1,195 +1,194 @@
 /*
  * Copyright (C) Wolthera van Hovell tot Westerflier <griffinvalley@gmail.com>, (C) 2016
  *
  *  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 KISDLGINTERNALCOLORSELECTOR_H
 #define KISDLGINTERNALCOLORSELECTOR_H
 
 #include "kritawidgets_export.h"
 #include "KoColor.h"
 #include "KoColorSpace.h"
 #include "KoColorDisplayRendererInterface.h"
 #include "KoColorSet.h"
 
 #include <QScopedPointer>
 
 #include "KisScreenColorPickerBase.h"
 #include "ui_WdgDlgInternalColorSelector.h"
 
 /**
  * @brief The KisInternalColorSelector class
  *
  * A non-modal color selector dialog that is not a plugin and can thus be used for filters.
  */
 class KRITAWIDGETS_EXPORT KisDlgInternalColorSelector : public QDialog
 {
     Q_OBJECT
 
-
     static std::function<KisScreenColorPickerBase *(QWidget *)> s_screenColorPickerFactory;
 
 public:
 
     static void setScreenColorPickerFactory(std::function<KisScreenColorPickerBase *(QWidget *)> f) {
         s_screenColorPickerFactory = f;
     }
 
     struct Config
     {
         Config() :
             modal(true),
             visualColorSelector(true),
             paletteBox(true),
             screenColorPicker(true),
             prevNextButtons(true),
             hexInput(true),
             useAlpha(false){}
         bool modal;
         bool visualColorSelector;
         bool paletteBox;
         bool screenColorPicker;
         bool prevNextButtons;
         bool hexInput;
         bool useAlpha;
     };
 
     KisDlgInternalColorSelector(QWidget* parent, KoColor color, Config config, const QString &caption, const KoColorDisplayRendererInterface *displayRenderer = KoDumbColorDisplayRenderer::instance());
     ~KisDlgInternalColorSelector() override;
 
     /**
      * @brief slotColorSpaceChanged
      * Color space has changed, use this dialog to change the colorspace.
      */
     void colorSpaceChanged(const KoColorSpace *cs);
 
     /**
      * @brief lockUsedColorSpace
      * Lock the used colorspace of this selector.
      * @param cs
      */
     void lockUsedColorSpace(const KoColorSpace *cs);
 
     /**
      * @brief setDisplayRenderer
      * Set the display renderer. This is necessary for HDR color manage support.
      * @param displayRenderer
      */
     void setDisplayRenderer(const KoColorDisplayRendererInterface *displayRenderer);
 
     /**
      * @brief getModalColorDialog
      * Execute this dialog modally. The function returns
      * the KoColor you want.
      * @param color - The current color. Make sure this is in the color space you want your
      * end color to be in.
      * @param chooseAlpha - Whether or not the alpha-choosing functionality should be used.
      */
     static KoColor getModalColorDialog(const KoColor color, QWidget* parent = Q_NULLPTR, QString caption = QString());
 
     /**
      * @brief getCurrentColor
      * @return gives currently active color;
      */
     KoColor getCurrentColor();
 
     void chooseAlpha(bool chooseAlpha);
 
 Q_SIGNALS:
     /**
      * @brief signalForegroundColorChosen
      * The most important signal. This will sent out when a color has been picked from the selector.
      * There will be a small delay to make sure that the selector causes too many updates.
      *
      * Do not connect this to slotColorUpdated.
      * @param color The new color chosen
      */
 
     void signalForegroundColorChosen(KoColor color);
+
 public Q_SLOTS:
     /**
      * @brief slotColorUpdated
      * Very important slot. Is connected to krita's resources to make sure it has
      * the currently active color. It's very important that this function is able to understand
      * when the signal came from itself.
      * @param newColor This is the new color.
      */
     void slotColorUpdated(KoColor newColor);
 
     /**
     * @brief slotSetColorFromPatch
     * update current color from kocolorpatch.
     * @param patch
     */
     void slotSetColorFromPatch(KoColorPatch* patch);
 
     /**
      * @brief setPreviousColor
      * set the previous color.
      */
     void setPreviousColor(KoColor c);
 
     void reject() override;
 
 private Q_SLOTS:
-
     /**
      * @brief slotLockSelector
      * This slot will prevent the color from being updated.
      */
     void slotLockSelector();
 
     /**
      * @brief slotConfigurationChanged
      * Wrapper slot for changes to the colorspace.
      */
     void slotConfigurationChanged();
 
     void endUpdateWithNewColor();
 
     /**
      * @brief slotFinishUp
      * This is called when the selector is closed, for saving the current palette.
      */
     void slotFinishUp();
 
     /**
      * @brief slotSetColorFromHex
      * Update from the hex color input.
      */
     void slotSetColorFromHex();
 
     void slotChangePalette(KoColorSet *set);
 
 protected:
     void showEvent(QShowEvent *event) override;
 
 private:
     void focusInEvent(QFocusEvent *) override;
     /**
      * @brief updateAllElements
      * Updates each widget with the new element, and if it's responsible for the update sents
      * a signal out that there's a new color.
      */
     void updateAllElements(QObject *source);
 
 private:
     Ui_WdgDlgInternalColorSelector *m_ui;
     struct Private; //The private struct
     const QScopedPointer<Private> m_d; //the private pointer
 };
 
 #endif // KISDLGINTERNALCOLORSELECTOR_H
diff --git a/plugins/tools/svgtexttool/SvgTextEditor.cpp b/plugins/tools/svgtexttool/SvgTextEditor.cpp
index 1f723f6a10..9c570a4a4a 100644
--- a/plugins/tools/svgtexttool/SvgTextEditor.cpp
+++ b/plugins/tools/svgtexttool/SvgTextEditor.cpp
@@ -1,1107 +1,1115 @@
 /* This file is part of the KDE project
  *
  * Copyright 2017 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 "SvgTextEditor.h"
 
 #include <QAction>
 #include <QApplication>
 #include <QBuffer>
 #include <QComboBox>
 #include <QDialogButtonBox>
 #include <QDoubleSpinBox>
 #include <QFontComboBox>
 #include <QFontDatabase>
 #include <QFormLayout>
 #include <QLineEdit>
 #include <QListView>
 #include <QMenu>
 #include <QMessageBox>
 #include <QPainter>
 #include <QPalette>
 #include <QPushButton>
 #include <QStandardItem>
 #include <QStandardItemModel>
 #include <QSvgGenerator>
 #include <QTabWidget>
 #include <QTextEdit>
 #include <QUrl>
 #include <QVBoxLayout>
 #include <QWidgetAction>
 
 #include <kcharselect.h>
 #include <klocalizedstring.h>
 #include <ksharedconfig.h>
 #include <kconfiggroup.h>
 #include <kactioncollection.h>
 #include <kxmlguifactory.h>
 #include <ktoolbar.h>
 #include <ktoggleaction.h>
 #include <kguiitem.h>
 
 #include <KoDialog.h>
 #include <KoResourcePaths.h>
 #include <KoSvgTextShape.h>
 #include <KoSvgTextShapeMarkupConverter.h>
 #include <KoColorSpaceRegistry.h>
 #include <KoColorPopupAction.h>
 #include <svg/SvgUtil.h>
 
+#include <KisScreenColorPicker.h>
 #include <kis_icon.h>
 #include <kis_config.h>
 #include <kis_file_name_requester.h>
 #include <kis_action_registry.h>
 
 #include "kis_font_family_combo_box.h"
 #include "FontSizeAction.h"
 #include "kis_signals_blocker.h"
 
 SvgTextEditor::SvgTextEditor(QWidget *parent, Qt::WindowFlags flags)
     : KXmlGuiWindow(parent, flags)
     , m_page(new QWidget(this))
 #ifndef Q_OS_WIN
     , m_charSelectDialog(new KoDialog(this))
 #endif
 {
     m_textEditorWidget.setupUi(m_page);
     setCentralWidget(m_page);
 
     m_textEditorWidget.chkVertical->setVisible(false);
 #ifndef Q_OS_WIN
     KCharSelect *charSelector = new KCharSelect(m_charSelectDialog, 0, KCharSelect::AllGuiElements);
     m_charSelectDialog->setMainWidget(charSelector);
     connect(charSelector, SIGNAL(currentCharChanged(QChar)), SLOT(insertCharacter(QChar)));
     m_charSelectDialog->hide();
     m_charSelectDialog->setButtons(KoDialog::Close);
 #endif
     connect(m_textEditorWidget.buttons, SIGNAL(accepted()), this, SLOT(save()));
     connect(m_textEditorWidget.buttons, SIGNAL(rejected()), this, SLOT(slotCloseEditor()));
     connect(m_textEditorWidget.buttons, SIGNAL(clicked(QAbstractButton*)), this, SLOT(dialogButtonClicked(QAbstractButton*)));
 
     KConfigGroup cg(KSharedConfig::openConfig(), "SvgTextTool");
     actionCollection()->setConfigGroup("SvgTextTool");
     actionCollection()->setComponentName("svgtexttool");
     actionCollection()->setComponentDisplayName(i18n("Text Tool"));
 
     QByteArray state;
     if (cg.hasKey("WindowState")) {
         state = cg.readEntry("State", state);
         state = QByteArray::fromBase64(state);
         // One day will need to load the version number, but for now, assume 0
         restoreState(state);
     }
 
     setAcceptDrops(true);
     //setStandardToolBarMenuEnabled(true);
 #ifdef Q_OS_OSX
     setUnifiedTitleAndToolBarOnMac(true);
 #endif
     setTabPosition(Qt::AllDockWidgetAreas, QTabWidget::North);
 
     m_syntaxHighlighter = new BasicXMLSyntaxHighlighter(m_textEditorWidget.svgTextEdit);
     m_textEditorWidget.svgTextEdit->setFont(QFontDatabase().systemFont(QFontDatabase::FixedFont));
 
     createActions();
     // If we have customized the toolbars, load that first
     setLocalXMLFile(KoResourcePaths::locateLocal("data", "svgtexttool.xmlgui"));
     setXMLFile(":/kxmlgui5/svgtexttool.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) {
             toolBar->setToolButtonStyle(Qt::ToolButtonIconOnly);
             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);
         }
     }
     plugActionList("toolbarlist", toolbarList);
     connect(m_textEditorWidget.textTab, SIGNAL(currentChanged(int)), this, SLOT(switchTextEditorTab()));
     switchTextEditorTab();
 
     m_textEditorWidget.richTextEdit->document()->setDefaultStyleSheet("p {margin:0px;}");
 
     applySettings();
-
 }
 
 SvgTextEditor::~SvgTextEditor()
 {
     KConfigGroup g(KSharedConfig::openConfig(), "SvgTextTool");
     QByteArray ba = saveState();
     g.writeEntry("windowState", ba.toBase64());
 }
 
 
 void SvgTextEditor::setShape(KoSvgTextShape *shape)
 {
     m_shape = shape;
     if (m_shape) {
         KoSvgTextShapeMarkupConverter converter(m_shape);
 
         QString svg;
         QString styles;
         QTextDocument *doc = m_textEditorWidget.richTextEdit->document();
 
         if (converter.convertToSvg(&svg, &styles)) {
             m_textEditorWidget.svgTextEdit->setPlainText(svg);
             m_textEditorWidget.svgStylesEdit->setPlainText(styles);
             m_textEditorWidget.svgTextEdit->document()->setModified(false);
 
             if (shape->isRichTextPreferred() &&
                 converter.convertSvgToDocument(svg, doc)) {
 
                 m_textEditorWidget.richTextEdit->setDocument(doc);
                 KisSignalsBlocker b(m_textEditorWidget.textTab);
                 m_textEditorWidget.textTab->setCurrentIndex(Richtext);
                 switchTextEditorTab(false);
             } else {
                 KisSignalsBlocker b(m_textEditorWidget.textTab);
                 m_textEditorWidget.textTab->setCurrentIndex(SvgSource);
                 switchTextEditorTab(false);
             }
         }
         else {
             QMessageBox::warning(this, i18n("Conversion failed"), "Could not get svg text from the shape:\n" + converter.errors().join('\n') + "\n" + converter.warnings().join('\n'));
         }
     }
 
 }
 
 void SvgTextEditor::save()
 {
     if (m_shape) {
         if (m_textEditorWidget.textTab->currentIndex() == Richtext) {
 
             QString svg;
             QString styles = m_textEditorWidget.svgStylesEdit->document()->toPlainText();
             KoSvgTextShapeMarkupConverter converter(m_shape);
 
             if (!converter.convertDocumentToSvg(m_textEditorWidget.richTextEdit->document(), &svg)) {
                     qWarning()<<"new converter doesn't work!";
             }
             m_textEditorWidget.richTextEdit->document()->setModified(false);
             emit textUpdated(m_shape, svg, styles, true);
         }
         else {
             emit textUpdated(m_shape, m_textEditorWidget.svgTextEdit->document()->toPlainText(), m_textEditorWidget.svgStylesEdit->document()->toPlainText(), false);
             m_textEditorWidget.svgTextEdit->document()->setModified(false);
         }
     }
 
 }
 
 void SvgTextEditor::switchTextEditorTab(bool convertData)
 {
     KoSvgTextShape shape;
     KoSvgTextShapeMarkupConverter converter(&shape);
 
     if (m_currentEditor) {
         disconnect(m_currentEditor->document(), SIGNAL(modificationChanged(bool)), this, SLOT(setModified(bool)));
     }
 
     if (m_textEditorWidget.textTab->currentIndex() == Richtext) {
         //first, make buttons checkable
         enableRichTextActions(true);
         enableSvgTextActions(false);
 
         //then connect the cursor change to the checkformat();
         connect(m_textEditorWidget.richTextEdit, SIGNAL(cursorPositionChanged()), this, SLOT(checkFormat()));
 
 
         if (m_shape && convertData) {
             QTextDocument *doc = m_textEditorWidget.richTextEdit->document();
             if (!converter.convertSvgToDocument(m_textEditorWidget.svgTextEdit->document()->toPlainText(), doc)) {
                 qWarning()<<"new converter svgToDoc doesn't work!";
             }
             m_textEditorWidget.richTextEdit->setDocument(doc);
         }
         m_currentEditor = m_textEditorWidget.richTextEdit;
     }
     else {
         //first, make buttons uncheckable
         enableRichTextActions(false);
         enableSvgTextActions(true);
         disconnect(m_textEditorWidget.richTextEdit, SIGNAL(cursorPositionChanged()), this, SLOT(checkFormat()));
 
         // Convert the rich text to svg and styles strings
         if (m_shape && convertData) {
             QString svg;
             QString styles;
 
             if (!converter.convertDocumentToSvg(m_textEditorWidget.richTextEdit->document(), &svg)) {
                     qWarning()<<"new converter docToSVG doesn't work!";
             }
             m_textEditorWidget.svgTextEdit->setPlainText(svg);
         }
         m_currentEditor = m_textEditorWidget.svgTextEdit;
     }
 
     connect(m_currentEditor->document(), SIGNAL(modificationChanged(bool)), SLOT(setModified(bool)));
 }
 
 void SvgTextEditor::checkFormat()
 {
     QTextCharFormat format = m_textEditorWidget.richTextEdit->textCursor().charFormat();
     QTextBlockFormat blockFormat = m_textEditorWidget.richTextEdit->textCursor().blockFormat();
 
     // checkboxes do not emit signals on manual switching, so we
     // can avoid blocking them
 
     if (format.fontWeight() > QFont::Normal) {
         actionCollection()->action("svg_weight_bold")->setChecked(true);
     } else {
         actionCollection()->action("svg_weight_bold")->setChecked(false);
     }
     actionCollection()->action("svg_format_italic")->setChecked(format.fontItalic());
     actionCollection()->action("svg_format_underline")->setChecked(format.fontUnderline());
     actionCollection()->action("svg_format_strike_through")->setChecked(format.fontStrikeOut());
 
     {
         FontSizeAction *fontSizeAction = qobject_cast<FontSizeAction*>(actionCollection()->action("svg_font_size"));
         KisSignalsBlocker b(fontSizeAction);
         fontSizeAction->setFontSize(format.font().pointSize());
     }
 
 
     {
         KoColor fg(format.foreground().color(), KoColorSpaceRegistry::instance()->rgb8());
         KoColorPopupAction *fgColorPopup = qobject_cast<KoColorPopupAction*>(actionCollection()->action("svg_format_textcolor"));
         KisSignalsBlocker b(fgColorPopup);
         fgColorPopup->setCurrentColor(fg);
     }
 
     {
         KoColor bg(format.foreground().color(), KoColorSpaceRegistry::instance()->rgb8());
         KoColorPopupAction *bgColorPopup = qobject_cast<KoColorPopupAction*>(actionCollection()->action("svg_background_color"));
         KisSignalsBlocker b(bgColorPopup);
         bgColorPopup->setCurrentColor(bg);
     }
 
     {
         KisFontComboBoxes* fontComboBox = qobject_cast<KisFontComboBoxes*>(qobject_cast<QWidgetAction*>(actionCollection()->action("svg_font"))->defaultWidget());
         KisSignalsBlocker b(fontComboBox);
         fontComboBox->setCurrentFont(format.font());
     }
 
     {
         QDoubleSpinBox *spnLineHeight = qobject_cast<QDoubleSpinBox*>(qobject_cast<QWidgetAction*>(actionCollection()->action("svg_line_height"))->defaultWidget());
         KisSignalsBlocker b(spnLineHeight);
 
         if (blockFormat.lineHeightType() == QTextBlockFormat::SingleHeight) {
             spnLineHeight->setValue(100.0);
         } else if(blockFormat.lineHeightType() == QTextBlockFormat::ProportionalHeight) {
             spnLineHeight->setValue(double(blockFormat.lineHeight()));
         }
     }
 }
 
 void SvgTextEditor::undo()
 {
     m_currentEditor->undo();
 }
 
 void SvgTextEditor::redo()
 {
     m_currentEditor->redo();
 }
 
 void SvgTextEditor::cut()
 {
     m_currentEditor->cut();
 }
 
 void SvgTextEditor::copy()
 {
     m_currentEditor->copy();
 }
 
 void SvgTextEditor::paste()
 {
     m_currentEditor->paste();
 }
 
 void SvgTextEditor::selectAll()
 {
     m_currentEditor->selectAll();
 }
 
 void SvgTextEditor::deselect()
 {
     QTextCursor cursor(m_currentEditor->textCursor());
     cursor.clearSelection();
     m_currentEditor->setTextCursor(cursor);
 }
 
 void SvgTextEditor::find()
 {
     QDialog *findDialog = new QDialog(this);
     findDialog->setWindowTitle(i18n("Find Text"));
     QFormLayout *layout = new QFormLayout();
     findDialog->setLayout(layout);
     QLineEdit *lnSearchKey = new QLineEdit();
     layout->addRow(i18n("Find:"), lnSearchKey);
     QDialogButtonBox *buttons = new QDialogButtonBox(QDialogButtonBox::Ok|QDialogButtonBox::Cancel);
     findDialog->layout()->addWidget(buttons);
     connect(buttons, SIGNAL(accepted()), findDialog, SLOT(accept()));
     connect(buttons, SIGNAL(rejected()), findDialog, SLOT(reject()));
 
 
     if (findDialog->exec()==QDialog::Accepted) {
         m_searchKey = lnSearchKey->text();
         m_currentEditor->find(m_searchKey);
     }
 }
 
 void SvgTextEditor::findNext()
 {
     if (!m_currentEditor->find(m_searchKey)) {
         QTextCursor cursor(m_currentEditor->textCursor());
         cursor.movePosition(QTextCursor::Start);
         m_currentEditor->setTextCursor(cursor);
         m_currentEditor->find(m_searchKey);
     }
 }
 
 void SvgTextEditor::findPrev()
 {
     if (!m_currentEditor->find(m_searchKey,QTextDocument::FindBackward)) {
         QTextCursor cursor(m_currentEditor->textCursor());
         cursor.movePosition(QTextCursor::End);
         m_currentEditor->setTextCursor(cursor);
         m_currentEditor->find(m_searchKey,QTextDocument::FindBackward);
     }
 }
 
 void SvgTextEditor::replace()
 {
     QDialog *findDialog = new QDialog(this);
     findDialog->setWindowTitle(i18n("Find and Replace all"));
     QFormLayout *layout = new QFormLayout();
     findDialog->setLayout(layout);
     QLineEdit *lnSearchKey = new QLineEdit();
     QLineEdit *lnReplaceKey = new QLineEdit();
     layout->addRow(i18n("Find:"), lnSearchKey);
     QDialogButtonBox *buttons = new QDialogButtonBox(QDialogButtonBox::Ok|QDialogButtonBox::Cancel);
     layout->addRow(i18n("Replace:"), lnReplaceKey);
     findDialog->layout()->addWidget(buttons);
     connect(buttons, SIGNAL(accepted()), findDialog, SLOT(accept()));
     connect(buttons, SIGNAL(rejected()), findDialog, SLOT(reject()));
 
 
     if (findDialog->exec()==QDialog::Accepted) {
         QString search = lnSearchKey->text();
         QString replace = lnReplaceKey->text();
         QTextCursor cursor(m_currentEditor->textCursor());
         cursor.movePosition(QTextCursor::Start);
         m_currentEditor->setTextCursor(cursor);
         while(m_currentEditor->find(search)) {
             m_currentEditor->textCursor().removeSelectedText();
             m_currentEditor->textCursor().insertText(replace);
         }
 
     }
 }
 
 
 void SvgTextEditor::zoomOut()
 {
     m_currentEditor->zoomOut();
 }
 
 void SvgTextEditor::zoomIn()
 {
     m_currentEditor->zoomIn();
 }
 
 #ifndef Q_OS_WIN
 void SvgTextEditor::showInsertSpecialCharacterDialog()
 {
     m_charSelectDialog->setVisible(!m_charSelectDialog->isVisible());
 }
 
 void SvgTextEditor::insertCharacter(const QChar &c)
 {
     m_currentEditor->textCursor().insertText(QString(c));
 }
 #endif
 
 void SvgTextEditor::setTextBold(QFont::Weight weight)
 {
     if (m_textEditorWidget.textTab->currentIndex() == Richtext) {
         QTextCharFormat format;
         if (m_textEditorWidget.richTextEdit->textCursor().charFormat().fontWeight() > QFont::Normal && weight==QFont::Bold) {
             format.setFontWeight(QFont::Normal);
         } else {
             format.setFontWeight(weight);
         }
         m_textEditorWidget.richTextEdit->mergeCurrentCharFormat(format);
     } else {
         QTextCursor cursor = m_textEditorWidget.svgTextEdit->textCursor();
         if (cursor.hasSelection()) {
             QString selectionModified = "<tspan style=\"font-weight:700;\">" + cursor.selectedText() + "</tspan>";
             cursor.removeSelectedText();
             cursor.insertText(selectionModified);
         }
     }
 }
 
 void SvgTextEditor::setTextWeightLight()
 {
     if (m_textEditorWidget.richTextEdit->textCursor().charFormat().fontWeight() < QFont::Normal) {
         setTextBold(QFont::Normal);
     } else {
         setTextBold(QFont::Light);
     }
 }
 
 void SvgTextEditor::setTextWeightNormal()
 {
     setTextBold(QFont::Normal);
 }
 
 void SvgTextEditor::setTextWeightDemi()
 {
     if (m_textEditorWidget.richTextEdit->textCursor().charFormat().fontWeight() != QFont::Normal) {
         setTextBold(QFont::Normal);
     } else {
         setTextBold(QFont::DemiBold);
     }
 }
 
 void SvgTextEditor::setTextWeightBlack()
 {
     if (m_textEditorWidget.richTextEdit->textCursor().charFormat().fontWeight()>QFont::Normal) {
         setTextBold(QFont::Normal);
     } else {
         setTextBold(QFont::Black);
     }
 }
 
 void SvgTextEditor::setTextItalic(QFont::Style style)
 {
     QTextCursor cursor = m_textEditorWidget.svgTextEdit->textCursor();
     QString fontStyle = "inherit";
 
     if (style == QFont::StyleItalic) {
         fontStyle = "italic";
     } else if(style == QFont::StyleOblique) {
         fontStyle = "oblique";
     }
 
     if (m_textEditorWidget.textTab->currentIndex() == Richtext) {
         QTextCharFormat format;
         format.setFontItalic(!m_textEditorWidget.richTextEdit->textCursor().charFormat().fontItalic());
         m_textEditorWidget.richTextEdit->mergeCurrentCharFormat(format);
     }
     else {
         if (cursor.hasSelection()) {
             QString selectionModified = "<tspan style=\"font-style:"+fontStyle+";\">" + cursor.selectedText() + "</tspan>";
             cursor.removeSelectedText();
             cursor.insertText(selectionModified);
         }
     }
 }
 
 void SvgTextEditor::setTextDecoration(KoSvgText::TextDecoration decor)
 {
     QTextCursor cursor = m_textEditorWidget.svgTextEdit->textCursor();
     QTextCharFormat currentFormat = m_textEditorWidget.richTextEdit->textCursor().charFormat();
     QTextCharFormat format;
     QString textDecoration = "inherit";
 
     if (decor == KoSvgText::DecorationUnderline) {
         textDecoration = "underline";
         if (currentFormat.fontUnderline()) {
             format.setFontUnderline(false);
         }
         else {
             format.setFontUnderline(true);
         }
         format.setFontOverline(false);
         format.setFontStrikeOut(false);
     }
     else if (decor == KoSvgText::DecorationLineThrough) {
         textDecoration = "line-through";
         format.setFontUnderline(false);
         format.setFontOverline(false);
         if (currentFormat.fontStrikeOut()) {
             format.setFontStrikeOut(false);
         }
         else {
             format.setFontStrikeOut(true);
         }
     }
     else if (decor == KoSvgText::DecorationOverline) {
         textDecoration = "overline";
         format.setFontUnderline(false);
         if (currentFormat.fontOverline()) {
             format.setFontOverline(false);
         }
         else {
             format.setFontOverline(true);
         }
         format.setFontStrikeOut(false);
     }
 
     if (m_textEditorWidget.textTab->currentIndex() == Richtext) {
         m_textEditorWidget.richTextEdit->mergeCurrentCharFormat(format);
     }
     else {
         if (cursor.hasSelection()) {
             QString selectionModified = "<tspan style=\"text-decoration:" + textDecoration + ";\">" + cursor.selectedText() + "</tspan>";
             cursor.removeSelectedText();
             cursor.insertText(selectionModified);
         }
     }
 }
 
 void SvgTextEditor::setTextUnderline()
 {
     setTextDecoration(KoSvgText::DecorationUnderline);
 }
 
 void SvgTextEditor::setTextOverline()
 {
     setTextDecoration(KoSvgText::DecorationOverline);
 }
 
 void SvgTextEditor::setTextStrikethrough()
 {
     setTextDecoration(KoSvgText::DecorationLineThrough);
 }
 
 void SvgTextEditor::setTextSubscript()
 {
     QTextCharFormat format = m_textEditorWidget.richTextEdit->textCursor().charFormat();
     if (format.verticalAlignment()==QTextCharFormat::AlignSubScript) {
         format.setVerticalAlignment(QTextCharFormat::AlignNormal);
     } else {
         format.setVerticalAlignment(QTextCharFormat::AlignSubScript);
     }
     m_textEditorWidget.richTextEdit->mergeCurrentCharFormat(format);
 }
 
 void SvgTextEditor::setTextSuperScript()
 {
     QTextCharFormat format = m_textEditorWidget.richTextEdit->textCursor().charFormat();
     if (format.verticalAlignment()==QTextCharFormat::AlignSuperScript) {
         format.setVerticalAlignment(QTextCharFormat::AlignNormal);
     } else {
         format.setVerticalAlignment(QTextCharFormat::AlignSuperScript);
     }
     m_textEditorWidget.richTextEdit->mergeCurrentCharFormat(format);
 }
 
 void SvgTextEditor::increaseTextSize()
 {
     QTextCharFormat format;
     int pointSize = m_textEditorWidget.richTextEdit->textCursor().charFormat().font().pointSize();
     if (pointSize<0) {
         pointSize = m_textEditorWidget.richTextEdit->textCursor().charFormat().font().pixelSize();
     }
     format.setFontPointSize(pointSize+1.0);
     m_textEditorWidget.richTextEdit->mergeCurrentCharFormat(format);
 }
 
 void SvgTextEditor::decreaseTextSize()
 {
     QTextCharFormat format;
     int pointSize = m_textEditorWidget.richTextEdit->textCursor().charFormat().font().pointSize();
     if (pointSize<1) {
         pointSize = m_textEditorWidget.richTextEdit->textCursor().charFormat().font().pixelSize();
     }
     format.setFontPointSize(qMax(pointSize-1.0, 1.0));
     m_textEditorWidget.richTextEdit->mergeCurrentCharFormat(format);
 }
 
 void SvgTextEditor::setLineHeight(double lineHeightPercentage)
 {
     QTextBlockFormat format = m_textEditorWidget.richTextEdit->textCursor().blockFormat();
     format.setLineHeight(lineHeightPercentage, QTextBlockFormat::ProportionalHeight);
      m_textEditorWidget.richTextEdit->textCursor().mergeBlockFormat(format);
 }
 
 
 void SvgTextEditor::alignLeft()
 {
     QTextBlockFormat format = m_textEditorWidget.richTextEdit->textCursor().blockFormat();
     format.setAlignment(Qt::AlignLeft);
     m_textEditorWidget.richTextEdit->textCursor().mergeBlockFormat(format);
 }
 
 void SvgTextEditor::alignRight()
 {
     QTextBlockFormat format = m_textEditorWidget.richTextEdit->textCursor().blockFormat();
     format.setAlignment(Qt::AlignRight);
     m_textEditorWidget.richTextEdit->textCursor().mergeBlockFormat(format);
 }
 
 void SvgTextEditor::alignCenter()
 {
     QTextBlockFormat format = m_textEditorWidget.richTextEdit->textCursor().blockFormat();
     format.setAlignment(Qt::AlignCenter);
     m_textEditorWidget.richTextEdit->textCursor().mergeBlockFormat(format);
 }
 
 void SvgTextEditor::alignJustified()
 {
     QTextBlockFormat format = m_textEditorWidget.richTextEdit->textCursor().blockFormat();
     format.setAlignment(Qt::AlignJustify);
     m_textEditorWidget.richTextEdit->textCursor().mergeBlockFormat(format);
 }
 
 void SvgTextEditor::setSettings()
 {
     KoDialog settingsDialog(this);
     Ui_WdgSvgTextSettings textSettings;
     QWidget *settingsPage = new QWidget(&settingsDialog, 0);
     settingsDialog.setMainWidget(settingsPage);
     textSettings.setupUi(settingsPage);
 
     // get the settings and initialize the dialog
     KConfigGroup cfg(KSharedConfig::openConfig(), "SvgTextTool");
 
     QStringList selectedWritingSystems = cfg.readEntry("selectedWritingSystems", "").split(",");
 
     QList<QFontDatabase::WritingSystem> scripts = QFontDatabase().writingSystems();
     QStandardItemModel *writingSystemsModel = new QStandardItemModel(&settingsDialog);
     for (int s = 0; s < scripts.size(); s ++) {
         QString writingSystem = QFontDatabase().writingSystemName(scripts.at(s));
         QStandardItem *script = new QStandardItem(writingSystem);
         script->setCheckable(true);
         script->setCheckState(selectedWritingSystems.contains(QString::number(scripts.at(s))) ? Qt::Checked : Qt::Unchecked);
         script->setData((int)scripts.at(s));
         writingSystemsModel->appendRow(script);
     }
     textSettings.lwScripts->setModel(writingSystemsModel);
 
     EditorMode mode = (EditorMode)cfg.readEntry("EditorMode", (int)Both);
     switch(mode) {
     case(RichText):
         textSettings.radioRichText->setChecked(true);
         break;
     case(SvgSource):
         textSettings.radioSvgSource->setChecked(true);
         break;
     case(Both):
         textSettings.radioBoth->setChecked(true);
     }
 
     QColor background = cfg.readEntry("colorEditorBackground", qApp->palette().background().color());
     textSettings.colorEditorBackground->setColor(background);
     textSettings.colorEditorForeground->setColor(cfg.readEntry("colorEditorForeground", qApp->palette().text().color()));
 
     textSettings.colorKeyword->setColor(cfg.readEntry("colorKeyword", QColor(background.value() < 100 ? Qt::cyan : Qt::blue)));
     textSettings.chkBoldKeyword->setChecked(cfg.readEntry("BoldKeyword", true));
     textSettings.chkItalicKeyword->setChecked(cfg.readEntry("ItalicKeyword", false));
 
     textSettings.colorElement->setColor(cfg.readEntry("colorElement", QColor(background.value() < 100 ? Qt::magenta : Qt::darkMagenta)));
     textSettings.chkBoldElement->setChecked(cfg.readEntry("BoldElement", true));
     textSettings.chkItalicElement->setChecked(cfg.readEntry("ItalicElement", false));
 
     textSettings.colorAttribute->setColor(cfg.readEntry("colorAttribute", QColor(background.value() < 100 ? Qt::green : Qt::darkGreen)));
     textSettings.chkBoldAttribute->setChecked(cfg.readEntry("BoldAttribute", true));
     textSettings.chkItalicAttribute->setChecked(cfg.readEntry("ItalicAttribute", true));
 
     textSettings.colorValue->setColor(cfg.readEntry("colorValue", QColor(background.value() < 100 ? Qt::red: Qt::darkRed)));
     textSettings.chkBoldValue->setChecked(cfg.readEntry("BoldValue", true));
     textSettings.chkItalicValue->setChecked(cfg.readEntry("ItalicValue", false));
 
     textSettings.colorComment->setColor(cfg.readEntry("colorComment", QColor(background.value() < 100 ? Qt::lightGray : Qt::gray)));
     textSettings.chkBoldComment->setChecked(cfg.readEntry("BoldComment", false));
     textSettings.chkItalicComment->setChecked(cfg.readEntry("ItalicComment", false));
 
     settingsDialog.setButtons(KoDialog::Ok | KoDialog::Cancel);
     if (settingsDialog.exec() == QDialog::Accepted) {
         // save  and set the settings
         QStringList writingSystems;
         for (int i = 0; i < writingSystemsModel->rowCount(); i++) {
             QStandardItem *item = writingSystemsModel->item(i);
             if (item->checkState() == Qt::Checked) {
                 writingSystems.append(QString::number(item->data().toInt()));
             }
         }
         if (!writingSystems.isEmpty()) {
             cfg.writeEntry("selectedWritingSystems", writingSystems.join(','));
         }
 
         if (textSettings.radioRichText->isChecked()) {
             cfg.writeEntry("EditorMode", (int)Richtext);
         }
         else if (textSettings.radioSvgSource->isChecked()) {
             cfg.writeEntry("EditorMode", (int)SvgSource);
         }
         else  if (textSettings.radioBoth->isChecked()) {
             cfg.writeEntry("EditorMode", (int)Both);
         }
 
         cfg.writeEntry("colorEditorBackground", textSettings.colorEditorBackground->color());
         cfg.writeEntry("colorEditorForeground", textSettings.colorEditorForeground->color());
 
         cfg.writeEntry("colorKeyword", textSettings.colorKeyword->color());
         cfg.writeEntry("BoldKeyword", textSettings.chkBoldKeyword->isChecked());
         cfg.writeEntry("ItalicKeyWord", textSettings.chkItalicKeyword->isChecked());
 
         cfg.writeEntry("colorElement", textSettings.colorElement->color());
         cfg.writeEntry("BoldElement", textSettings.chkBoldElement->isChecked());
         cfg.writeEntry("ItalicElement", textSettings.chkItalicElement->isChecked());
 
         cfg.writeEntry("colorAttribute", textSettings.colorAttribute->color());
         cfg.writeEntry("BoldAttribute", textSettings.chkBoldAttribute->isChecked());
         cfg.writeEntry("ItalicAttribute", textSettings.chkItalicAttribute->isChecked());
 
         cfg.writeEntry("colorValue", textSettings.colorValue->color());
         cfg.writeEntry("BoldValue", textSettings.chkBoldValue->isChecked());
         cfg.writeEntry("ItalicValue", textSettings.chkItalicValue->isChecked());
 
         cfg.writeEntry("colorComment", textSettings.colorComment->color());
         cfg.writeEntry("BoldComment", textSettings.chkBoldComment->isChecked());
         cfg.writeEntry("ItalicComment", textSettings.chkItalicComment->isChecked());
 
         applySettings();
     }
 }
 
 void SvgTextEditor::slotToolbarToggled(bool)
 {
-
 }
 
-
 void SvgTextEditor::setFontColor(const KoColor &c)
 {
     QColor color = c.toQColor();
     if (m_textEditorWidget.textTab->currentIndex() == Richtext) {
         QTextCharFormat format;
         format.setForeground(QBrush(color));
         m_textEditorWidget.richTextEdit->mergeCurrentCharFormat(format);
     }
     else {
         QTextCursor cursor = m_textEditorWidget.svgTextEdit->textCursor();
         if (cursor.hasSelection()) {
             QString selectionModified = "<tspan fill=\""+color.name()+"\">" + cursor.selectedText() + "</tspan>";
             cursor.removeSelectedText();
             cursor.insertText(selectionModified);
         }
     }
 }
 
 void SvgTextEditor::setBackgroundColor(const KoColor &c)
 {
     QColor color = c.toQColor();
     QTextCursor cursor = m_textEditorWidget.svgTextEdit->textCursor();
     if (cursor.hasSelection()) {
         QString selectionModified = "<tspan stroke=\""+color.name()+"\">" + cursor.selectedText() + "</tspan>";
         cursor.removeSelectedText();
         cursor.insertText(selectionModified);
     }
 }
 
 void SvgTextEditor::setModified(bool modified)
 {
     if (modified) {
         m_textEditorWidget.buttons->setStandardButtons(QDialogButtonBox::Save | QDialogButtonBox::Discard);
     }
     else {
         m_textEditorWidget.buttons->setStandardButtons(QDialogButtonBox::Save | QDialogButtonBox::Close);
     }
 }
 
 void SvgTextEditor::dialogButtonClicked(QAbstractButton *button)
 {
     if (m_textEditorWidget.buttons->standardButton(button) == QDialogButtonBox::Discard) {
         if (QMessageBox::warning(this, i18nc("@title:window", "Krita"), i18n("You have modified the text. Discard changes?"), QMessageBox::Yes | QMessageBox::No) == QMessageBox::Yes) {
             close();
         }
     }
 }
 
 void SvgTextEditor::setFont(const QString &fontName)
 {
     QFont font;
     font.fromString(fontName);
     QTextCharFormat curFormat = m_textEditorWidget.richTextEdit->textCursor().charFormat();
     font.setPointSize(curFormat.font().pointSize());
 
     QTextCharFormat format;
     //This disables the style being set from the font-comboboxes too, so we need to rethink how we use that.
     format.setFontFamily(font.family());
     if (m_textEditorWidget.textTab->currentIndex() == Richtext) {
         m_textEditorWidget.richTextEdit->mergeCurrentCharFormat(format);
     } else {
         QTextCursor cursor = m_textEditorWidget.svgTextEdit->textCursor();
         if (cursor.hasSelection()) {
             QString selectionModified = "<tspan style=\"font-family:"+font.family()+" "+font.styleName()+";\">" + cursor.selectedText() + "</tspan>";
             cursor.removeSelectedText();
             cursor.insertText(selectionModified);
         }
     }
 }
 
 void SvgTextEditor::setFontSize(qreal fontSize)
 {
     if (m_textEditorWidget.textTab->currentIndex() == Richtext) {
         QTextCharFormat format;
         format.setFontPointSize(fontSize);
         m_textEditorWidget.richTextEdit->mergeCurrentCharFormat(format);
     } else {
         QTextCursor cursor = m_textEditorWidget.svgTextEdit->textCursor();
         if (cursor.hasSelection()) {
             QString selectionModified = "<tspan style=\"font-size:" + QString::number(fontSize) + ";\">" + cursor.selectedText() + "</tspan>";
             cursor.removeSelectedText();
             cursor.insertText(selectionModified);
         }
     }
 }
 
 void SvgTextEditor::setBaseline(KoSvgText::BaselineShiftMode)
 {
 
     QTextCursor cursor = m_textEditorWidget.svgTextEdit->textCursor();
     if (cursor.hasSelection()) {
         QString selectionModified = "<tspan style=\"font-size:50%;baseline-shift:super;\">" + cursor.selectedText() + "</tspan>";
         cursor.removeSelectedText();
         cursor.insertText(selectionModified);
     }
 }
 
 void SvgTextEditor::wheelEvent(QWheelEvent *event)
 {
     if (event->modifiers() & Qt::ControlModifier) {
         int numDegrees = event->delta() / 8;
         int numSteps = numDegrees / 7;
         m_textEditorWidget.svgTextEdit->zoomOut(numSteps);
         event->accept();
     }
 }
 
 void SvgTextEditor::applySettings()
 {
     KConfigGroup cfg(KSharedConfig::openConfig(), "SvgTextTool");
 
     EditorMode mode = (EditorMode)cfg.readEntry("EditorMode", (int)Both);
 
     QWidget *richTab = m_textEditorWidget.richTab;
     QWidget *svgTab = m_textEditorWidget.svgTab;
 
     m_page->setUpdatesEnabled(false);
     m_textEditorWidget.textTab->clear();
 
     switch(mode) {
     case(RichText):
         m_textEditorWidget.textTab->addTab(richTab, i18n("Rich text"));
         break;
     case(SvgSource):
         m_textEditorWidget.textTab->addTab(svgTab, i18n("SVG Source"));
         break;
     case(Both):
         m_textEditorWidget.textTab->addTab(richTab, i18n("Rich text"));
         m_textEditorWidget.textTab->addTab(svgTab, i18n("SVG Source"));
     }
 
     m_syntaxHighlighter->setFormats();
 
     QPalette palette = m_textEditorWidget.svgTextEdit->palette();
 
     QColor background = cfg.readEntry("colorEditorBackground", qApp->palette().background().color());
     palette.setBrush(QPalette::Active, QPalette::Background, QBrush(background));
     QColor foreground = cfg.readEntry("colorEditorForeground", qApp->palette().text().color());
     palette.setBrush(QPalette::Active, QPalette::Text, QBrush(foreground));
 
     QStringList selectedWritingSystems = cfg.readEntry("selectedWritingSystems", "").split(",");
 
     QVector<QFontDatabase::WritingSystem> writingSystems;
     for (int i=0; i<selectedWritingSystems.size(); i++) {
         writingSystems.append((QFontDatabase::WritingSystem)QString(selectedWritingSystems.at(i)).toInt());
     }
     qobject_cast<KisFontComboBoxes*>(qobject_cast<QWidgetAction*>(actionCollection()->action("svg_font"))->defaultWidget())->refillComboBox(writingSystems);
 
     m_page->setUpdatesEnabled(true);
 }
 
 QAction *SvgTextEditor::createAction(const QString &name, const char *member)
 {
     QAction *action = new QAction(this);
     KisActionRegistry *actionRegistry = KisActionRegistry::instance();
     actionRegistry->propertizeAction(name, action);
 
     actionCollection()->addAction(name, action);
     QObject::connect(action, SIGNAL(triggered(bool)), this, member);
     return action;
 }
 
 
 void SvgTextEditor::createActions()
 {
     KisActionRegistry *actionRegistry = KisActionRegistry::instance();
 
 
     // File: new, open, save, save as, close
     KStandardAction::save(this, SLOT(save()), actionCollection());
     KStandardAction::close(this, SLOT(slotCloseEditor()), actionCollection());
 
     // Edit
     KStandardAction::undo(this, SLOT(undo()), actionCollection());
     KStandardAction::redo(this, SLOT(redo()), actionCollection());
     KStandardAction::cut(this, SLOT(cut()), actionCollection());
     KStandardAction::copy(this, SLOT(copy()), actionCollection());
     KStandardAction::paste(this, SLOT(paste()), actionCollection());
     KStandardAction::selectAll(this, SLOT(selectAll()), actionCollection());
     KStandardAction::deselect(this, SLOT(deselect()), actionCollection());
     KStandardAction::find(this, SLOT(find()), actionCollection());
     KStandardAction::findNext(this, SLOT(findNext()), actionCollection());
     KStandardAction::findPrev(this, SLOT(findPrev()), actionCollection());
     KStandardAction::replace(this, SLOT(replace()), actionCollection());
 
     // View
     // WISH: we cannot zoom-in/out in rech-text mode
     m_svgTextActions << KStandardAction::zoomOut(this, SLOT(zoomOut()), actionCollection());
     m_svgTextActions << KStandardAction::zoomIn(this, SLOT(zoomIn()), actionCollection());
 #ifndef Q_OS_WIN
     // Insert:
     QAction * insertAction = createAction("svg_insert_special_character",
                                           SLOT(showInsertSpecialCharacterDialog()));
     insertAction->setCheckable(true);
     insertAction->setChecked(false);
 #endif
     // Format:
     m_richTextActions << createAction("svg_weight_bold",
                                       SLOT(setTextBold()));
 
     m_richTextActions << createAction("svg_format_italic",
                                       SLOT(setTextItalic()));
 
     m_richTextActions << createAction("svg_format_underline",
                                       SLOT(setTextUnderline()));
 
     m_richTextActions << createAction("svg_format_strike_through",
                                       SLOT(setTextStrikethrough()));
 
     m_richTextActions << createAction("svg_format_superscript",
                                       SLOT(setTextSuperScript()));
 
     m_richTextActions << createAction("svg_format_subscript",
                                       SLOT(setTextSubscript()));
 
     m_richTextActions << createAction("svg_weight_light",
                                       SLOT(setTextWeightLight()));
 
     m_richTextActions << createAction("svg_weight_normal",
                                       SLOT(setTextWeightNormal()));
 
     m_richTextActions << createAction("svg_weight_demi",
                                       SLOT(setTextWeightDemi()));
 
     m_richTextActions << createAction("svg_weight_black",
                                       SLOT(setTextWeightBlack()));
 
     m_richTextActions << createAction("svg_increase_font_size",
                                       SLOT(increaseTextSize()));
 
     m_richTextActions << createAction("svg_decrease_font_size",
                                       SLOT(decreaseTextSize()));
 
     m_richTextActions << createAction("svg_align_left",
                                       SLOT(alignLeft()));
 
     m_richTextActions << createAction("svg_align_right",
                                       SLOT(alignRight()));
 
     m_richTextActions << createAction("svg_align_center",
                                       SLOT(alignCenter()));
 
 //    m_richTextActions << createAction("svg_align_justified",
 //                                      SLOT(alignJustified()));
 
     // Settings
     m_richTextActions << createAction("svg_settings",
                                       SLOT(setSettings()));
 
     QWidgetAction *fontComboAction = new QWidgetAction(this);
     fontComboAction->setToolTip(i18n("Font"));
     KisFontComboBoxes *fontCombo = new KisFontComboBoxes();
     connect(fontCombo, SIGNAL(fontChanged(QString)), SLOT(setFont(QString)));
     fontComboAction->setDefaultWidget(fontCombo);
     actionCollection()->addAction("svg_font", fontComboAction);
     m_richTextActions << fontComboAction;
     actionRegistry->propertizeAction("svg_font", fontComboAction);
 
     QWidgetAction *fontSizeAction = new FontSizeAction(this);
     fontSizeAction->setToolTip(i18n("Size"));
     connect(fontSizeAction, SIGNAL(fontSizeChanged(qreal)), this, SLOT(setFontSize(qreal)));
     actionCollection()->addAction("svg_font_size", fontSizeAction);
     m_richTextActions << fontSizeAction;
     actionRegistry->propertizeAction("svg_font_size", fontSizeAction);
 
     KoColorPopupAction *fgColor = new KoColorPopupAction(this);
     fgColor->setCurrentColor(QColor(Qt::black));
     fgColor->setToolTip(i18n("Text Color"));
     connect(fgColor, SIGNAL(colorChanged(KoColor)), SLOT(setFontColor(KoColor)));
     actionCollection()->addAction("svg_format_textcolor", fgColor);
     m_richTextActions << fgColor;
     actionRegistry->propertizeAction("svg_format_textcolor", fgColor);
 
     KoColorPopupAction *bgColor = new KoColorPopupAction(this);
     bgColor->setCurrentColor(QColor(Qt::white));
     bgColor->setToolTip(i18n("Background Color"));
     connect(bgColor, SIGNAL(colorChanged(KoColor)), SLOT(setBackgroundColor(KoColor)));
     actionCollection()->addAction("svg_background_color", bgColor);
     actionRegistry->propertizeAction("svg_background_color", bgColor);
     m_richTextActions << bgColor;
 
+    QWidgetAction *colorPickerAction = new QWidgetAction(this);
+    colorPickerAction->setToolTip(i18n("Pick a Color"));
+    KisScreenColorPicker *colorPicker = new KisScreenColorPicker(false);
+    connect(colorPicker, SIGNAL(sigNewColorPicked(KoColor)), fgColor, SLOT(setCurrentColor(KoColor)));
+    connect(colorPicker, SIGNAL(sigNewColorPicked(KoColor)), SLOT(setFontColor(KoColor)));
+    colorPickerAction->setDefaultWidget(colorPicker);
+    actionCollection()->addAction("svg_pick_color", colorPickerAction);
+    m_richTextActions << colorPickerAction;
+    actionRegistry->propertizeAction("svg_pick_color", colorPickerAction);
+
     QWidgetAction *lineHeight = new QWidgetAction(this);
     lineHeight->setToolTip(i18n("Line height"));
     QDoubleSpinBox *spnLineHeight = new QDoubleSpinBox();
     spnLineHeight->setRange(0.0, 1000.0);
     spnLineHeight->setSingleStep(10.0);
     spnLineHeight->setSuffix("%");
     connect(spnLineHeight, SIGNAL(valueChanged(double)), SLOT(setLineHeight(double)));
     lineHeight->setDefaultWidget(spnLineHeight);
     actionCollection()->addAction("svg_line_height", lineHeight);
     m_richTextActions << lineHeight;
     actionRegistry->propertizeAction("svg_line_height", lineHeight);
 }
 
 void SvgTextEditor::enableRichTextActions(bool enable)
 {
     Q_FOREACH(QAction *action, m_richTextActions) {
         action->setEnabled(enable);
     }
 }
 
 void SvgTextEditor::enableSvgTextActions(bool enable)
 {
     Q_FOREACH(QAction *action, m_svgTextActions) {
         action->setEnabled(enable);
     }
 }
 
 void SvgTextEditor::slotCloseEditor()
 {
     close();
     emit textEditorClosed();
 }
diff --git a/plugins/tools/svgtexttool/SvgTextEditor.h b/plugins/tools/svgtexttool/SvgTextEditor.h
index 7bcad97be0..e898a757d3 100644
--- a/plugins/tools/svgtexttool/SvgTextEditor.h
+++ b/plugins/tools/svgtexttool/SvgTextEditor.h
@@ -1,166 +1,163 @@
 /* This file is part of the KDE project
  *
  * Copyright 2017 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.
  */
 
 #ifndef TEXTNGSHAPECONFIGWIDGET_H
 #define TEXTNGSHAPECONFIGWIDGET_H
 
 #include <QWidget>
 #include <QTextEdit>
 
 #include <kxmlguiwindow.h>
 #include <KoColor.h>
 #include <KoSvgText.h>//for the enums
 
 #include <BasicXMLSyntaxHighlighter.h>
 
 #include "ui_WdgSvgTextEditor.h"
 #include "ui_WdgSvgTextSettings.h"
 
 class KoSvgTextShape;
 class KoDialog;
 
 class SvgTextEditor : public KXmlGuiWindow
 {
     Q_OBJECT
 public:
     SvgTextEditor(QWidget *parent = 0, Qt::WindowFlags flags = 0);
     ~SvgTextEditor();
 
     //tiny enum to keep track of the tab on which editor something happens while keeping the code readable.
     enum Editor {
         Richtext, // 0
         SVGsource // 1
     };
 
     // enum to store which tabs are visible in the configuration
     enum EditorMode {
         RichText,
         SvgSource,
         Both
     };
 
     void setShape(KoSvgTextShape *shape);
 
 private Q_SLOTS:
-
     /**
      * switch the text editor tab.
      */
     void switchTextEditorTab(bool convertData = true);
 
     void slotCloseEditor();
 
     /**
      * in rich text, check the current format, and toggle the given buttons.
      */
     void checkFormat();
 
     void save();
 
     void undo();
     void redo();
+
     void cut();
     void copy();
     void paste();
+
     void selectAll();
     void deselect();
+
     void find();
     void findNext();
     void findPrev();
     void replace();
 
     void zoomOut();
     void zoomIn();
 #ifndef Q_OS_WIN
     void showInsertSpecialCharacterDialog();
     void insertCharacter(const QChar &c);
 #endif
     void setTextBold(QFont::Weight weight = QFont::Bold);
     void setTextWeightLight();
     void setTextWeightNormal();
     void setTextWeightDemi();
     void setTextWeightBlack();
 
     void setTextItalic(QFont::Style style = QFont::StyleOblique);
     void setTextDecoration(KoSvgText::TextDecoration decor);
     void setTextUnderline();
     void setTextOverline();
     void setTextStrikethrough();
     void setTextSubscript();
     void setTextSuperScript();
     void increaseTextSize();
     void decreaseTextSize();
 
     void setLineHeight(double lineHeightPercentage);
     void alignLeft();
     void alignRight();
     void alignCenter();
     void alignJustified();
 
     void setFont(const QString &fontName);
     void setFontSize(qreal size);
     void setBaseline(KoSvgText::BaselineShiftMode baseline);
 
     void setSettings();
     void slotToolbarToggled(bool);
 
     void setFontColor(const KoColor &c);
     void setBackgroundColor(const KoColor &c);
 
     void setModified(bool modified);
     void dialogButtonClicked(QAbstractButton *button);
 
 Q_SIGNALS:
-
     void textUpdated(KoSvgTextShape *shape, const QString &svg, const QString &defs, bool richTextPreferred);
     void textEditorClosed();
 
 protected:
-
     void wheelEvent(QWheelEvent *event) override;
 
 private:
-
     void applySettings();
 
     QAction *createAction(const QString &name,
                           const char *member);
     void createActions();
     void enableRichTextActions(bool enable);
     void enableSvgTextActions(bool enable);
 
-
-
     Ui_WdgSvgTextEditor m_textEditorWidget;
     QTextEdit *m_currentEditor {0};
     QWidget *m_page {0};
     QList<QAction*> m_richTextActions;
     QList<QAction*> m_svgTextActions;
 
     KoSvgTextShape *m_shape {0};
 #ifndef Q_OS_WIN
     KoDialog *m_charSelectDialog {0};
 #endif
     BasicXMLSyntaxHighlighter *m_syntaxHighlighter;
 
     QString m_searchKey;
 };
 
 #endif //TEXTNGSHAPECONFIGWIDGET_H
diff --git a/plugins/tools/svgtexttool/SvgTextTool.action b/plugins/tools/svgtexttool/SvgTextTool.action
index 8f3dac9ea0..2e2466dcee 100644
--- a/plugins/tools/svgtexttool/SvgTextTool.action
+++ b/plugins/tools/svgtexttool/SvgTextTool.action
@@ -1,235 +1,245 @@
 <?xml version="1.0" encoding="UTF-8"?>
 <ActionCollection version="2" name="svg_Tools">
   <Actions category="Text Tool">
     <text>SVG Text Tool</text>
     <Action name="svg_format_textcolor">
       <iconText>Text Color</iconText>
       <shortcut/>
       <toolTip>Text Color...</toolTip>
       <icon>format-text-color</icon>
       <whatsThis/>
       <statusTip/>
       <isCheckable>false</isCheckable>
       <text>Text Color</text>
     </Action>
     <Action name="svg_background_color">
       <iconText>Background</iconText>
       <shortcut/>
       <toolTip>Background Color...</toolTip>
       <icon>format-fill-color</icon>
       <whatsThis/>
       <statusTip/>
       <isCheckable>false</isCheckable>
       <text>Background</text>
     </Action>
     <Action name="svg_font_size">
       <iconText>Font Size</iconText>
       <shortcut/>
       <toolTip>Font Size</toolTip>
       <icon/>
       <whatsThis/>
       <statusTip/>
       <isCheckable>false</isCheckable>
       <text>Font Size</text>
     </Action>
     <Action name="svg_font">
       <iconText>Font</iconText>
       <shortcut>Ctrl+Alt+F</shortcut>
       <toolTip>Change character size, font, boldface, italics etc.</toolTip>
       <icon/>
       <whatsThis>Change the attributes of the currently selected characters.</whatsThis>
       <statusTip/>
       <isCheckable>false</isCheckable>
       <text>Font...</text>
     </Action>
     <Action name="svg_insert_special_character">
       <iconText>Special Character</iconText>
       <shortcut>Alt+Shift+C</shortcut>
       <toolTip>Insert one or more symbols or characters not found on the keyboard</toolTip>
       <icon>character-set</icon>
       <whatsThis>Insert one or more symbols or characters not found on the keyboard.</whatsThis>
       <statusTip/>
       <isCheckable>false</isCheckable>
       <text>Special Character...</text>
     </Action>
     <Action name="svg_align_right">
       <iconText>Align Right</iconText>
       <shortcut>Ctrl+Alt+R</shortcut>
       <toolTip>Align Right</toolTip>
       <icon>format-justify-right</icon>
       <whatsThis/>
       <statusTip/>
       <isCheckable>false</isCheckable>
       <text>Align Right</text>
     </Action>
     <Action name="svg_align_left">
       <iconText>Align Left</iconText>
       <shortcut/>
       <toolTip>Align Left</toolTip>
       <icon>format-justify-left</icon>
       <whatsThis/>
       <statusTip/>
       <isCheckable>false</isCheckable>
       <text>Align Left</text>
     </Action>
     <Action name="svg_align_justified">
       <iconText>Align Block</iconText>
       <shortcut>Ctrl+Alt+R</shortcut>
       <toolTip>Align Block</toolTip>
       <icon>format-justify-fill</icon>
       <whatsThis/>
       <statusTip/>
       <isCheckable>false</isCheckable>
       <text>Align Block</text>
     </Action>
     <Action name="svg_align_center">
       <iconText>Align Center</iconText>
       <shortcut>Ctrl+Alt+C</shortcut>
       <toolTip>Align Center</toolTip>
       <icon>format-justify-center</icon>
       <whatsThis/>
       <statusTip/>
       <isCheckable>false</isCheckable>
       <text>Align Center</text>
     </Action>
     <Action name="svg_decrease_font_size">
       <iconText>Decrease Font Size</iconText>
       <shortcut>Ctrl+&lt;</shortcut>
       <toolTip>Decrease Font Size</toolTip>
       <icon/>
       <whatsThis/>
       <statusTip/>
       <isCheckable>false</isCheckable>
       <text>Decrease Font Size</text>
     </Action>
     <Action name="svg_increase_font_size">
       <iconText>Increase Font Size</iconText>
       <shortcut>Ctrl+&gt;</shortcut>
       <toolTip>Increase Font Size</toolTip>
       <icon/>
       <whatsThis/>
       <statusTip/>
       <isCheckable>false</isCheckable>
       <text>Increase Font Size</text>
     </Action>
     <Action name="svg_format_subscript">
       <iconText>Subscript</iconText>
       <shortcut>Ctrl+Shift+B</shortcut>
       <toolTip>Subscript</toolTip>
       <icon>format-text-subscript</icon>
       <whatsThis/>
       <statusTip/>
       <isCheckable>false</isCheckable>
       <text>Subscript</text>
     </Action>
     <Action name="svg_format_superscript">
       <iconText>Superscript</iconText>
       <shortcut>Ctrl+Shift+P</shortcut>
       <toolTip>Superscript</toolTip>
       <icon>format-text-superscript</icon>
       <whatsThis/>
       <statusTip/>
       <isCheckable>false</isCheckable>
       <text>Superscript</text>
     </Action>
     <Action name="svg_format_underline">
       <iconText>Underline</iconText>
       <shortcut>Ctrl+U</shortcut>
       <toolTip>Underline</toolTip>
       <icon>format-text-underline</icon>
       <whatsThis/>
       <statusTip/>
       <isCheckable>false</isCheckable>
       <text>Underline</text>
     </Action>
     <Action name="svg_format_strike_through">
       <iconText>Strikethrough</iconText>
       <shortcut/>
       <toolTip>Strikethrough</toolTip>
       <icon>format-text-strikethrough</icon>
       <whatsThis/>
       <statusTip/>
       <isCheckable>false</isCheckable>
       <text>Strikethrough</text>
     </Action>
     <Action name="svg_weight_bold">
       <iconText>Bold</iconText>
       <shortcut>Ctrl+B</shortcut>
       <toolTip>Bold</toolTip>
       <icon>format-text-bold</icon>
       <whatsThis/>
       <statusTip/>
       <isCheckable>true</isCheckable>
       <text>Bold</text>
     </Action>
     <Action name="svg_format_italic">
       <iconText>Italic</iconText>
       <shortcut>Ctrl+I</shortcut>
       <toolTip>Italic</toolTip>
       <icon>format-text-italic</icon>
       <whatsThis/>
       <statusTip/>
       <isCheckable>true</isCheckable>
       <text>Italic</text>
     </Action>
     <Action name="svg_weight_normal">
       <iconText>Normal</iconText>
       <shortcut>Ctrl+N</shortcut>
       <toolTip>Normal</toolTip>
       <icon>format-text-normal</icon>
       <whatsThis/>
       <statusTip/>
       <isCheckable>false</isCheckable>
       <text>Normal</text>
     </Action>
     <Action name="svg_weight_demi">
       <iconText>Demi</iconText>
       <shortcut/>
       <toolTip>Demi</toolTip>
       <icon>format-text-demi</icon>
       <whatsThis/>
       <statusTip/>
       <isCheckable>false</isCheckable>
       <text>Demi</text>
     </Action>
     <Action name="svg_weight_black">
       <iconText>Black</iconText>
       <shortcut/>
       <toolTip>Black</toolTip>
       <icon>format-text-black</icon>
       <whatsThis/>
       <statusTip/>
       <isCheckable>false</isCheckable>
       <text>Black</text>
     </Action>
     <Action name="svg_weight_light">
       <iconText>Light</iconText>
       <shortcut>Ctrl+L</shortcut>
       <toolTip>Light</toolTip>
       <icon>format-text-light</icon>
       <whatsThis/>
       <statusTip/>
       <isCheckable>false</isCheckable>
       <text>Light</text>
     </Action>
     <Action name="svg_line_height">
       <iconText>Line Height</iconText>
       <shortcut>Ctrl+H</shortcut>
       <toolTip>Line Height in em</toolTip>
       <icon></icon>
       <whatsThis/>
       <statusTip/>
       <isCheckable>false</isCheckable>
       <text>Line Height</text>
     </Action>
     <Action name="svg_settings">
       <iconText>Settings</iconText>
       <shortcut></shortcut>
       <toolTip>Text Editor Settings</toolTip>
       <icon></icon>
       <whatsThis/>
       <statusTip/>
       <isCheckable>false</isCheckable>
       <text>Settings...</text>
     </Action></Actions>
+    <Action name="svg_pick_color">
+      <iconText>Colorpicker</iconText>
+      <shortcut></shortcut>
+      <toolTip>Pick a color from the screen</toolTip>
+      <icon></icon>
+      <whatsThis/>
+      <statusTip/>
+      <isCheckable>false</isCheckable>
+      <text>Color Picker</text>
+    </Action></Actions>
 </ActionCollection>
diff --git a/plugins/tools/svgtexttool/svgtexttool.xmlgui b/plugins/tools/svgtexttool/svgtexttool.xmlgui
index 03d8445756..026b8d0982 100644
--- a/plugins/tools/svgtexttool/svgtexttool.xmlgui
+++ b/plugins/tools/svgtexttool/svgtexttool.xmlgui
@@ -1,99 +1,100 @@
 <?xml version="1.0"?>
 <kpartgui xmlns="http://www.kde.org/standards/kxmlgui/1.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" name="svg_SvgTextTool" version="1" xsi:schemaLocation="http://www.kde.org/standards/kxmlgui/1.0  http://www.kde.org/standards/kxmlgui/1.0/kxmlgui.xsd">
   <MenuBar>
     <Menu name="file">
       <text>&amp;File</text>
       <Action name="file_save"/>
       <Separator/>
       <Action name="file_close"/>
     </Menu>
     <Menu name="edit">
       <text>&amp;Edit</text>
       <Action name="edit_undo"/>
       <Action name="edit_redo"/>
       <Separator/>
       <Action name="edit_cut"/>
       <Action name="edit_copy"/>
       <Action name="edit_paste"/>
       <Separator/>
       <Action name="edit_select_all"/>
       <Action name="edit_deselect"/>
       <Separator/>
       <Action name="edit_find"/>
       <Action name="edit_find_next"/>
       <Action name="edit_find_prev"/>
       <Action name="edit_replace"/>
     </Menu>
     <Menu name="view">
       <text>&amp;View</text>
       <Action name="view_zoom_out"/>
       <Action name="view_zoom_in"/>
     </Menu>
     <Menu name="insert">
       <text>&amp;Insert</text>
       <Action name="svg_insert_special_character"/>
     </Menu>
     <Menu name="format">
       <text>&amp;Format</text>
       <Action name="svg_weight_bold"/>
       <Action name="svg_format_italic"/>
       <Action name="svg_format_underline"/>
       <Action name="svg_format_strike_through"/>
       <Action name="svg_format_superscript"/>
       <Action name="svg_format_subscript"/>
       <Menu name="weight">
         <text>&amp;Weight</text>
         <Action name="svg_weight_light"/>
         <Action name="svg_weight_normal"/>
         <Action name="svg_weight_bold"/>
         <Action name="svg_weight_demi_bold"/>
         <Action name="svg_weight_black"/>
       </Menu>
       <Separator/>
       <Action name="svg_increase_text_size"/>
       <Action name="svg_decrease_text_size"/>
       <Separator/>
       <Action name="svg_align_left"/>
       <Action name="svg_align_center"/>
       <Action name="svg_align_right"/>
       <!--Action name="svg_align_justified"/-->
     </Menu>
     <Menu name="settings">
       <text>Setti&amp;ngs</text>
       <Action name="svg_settings"/>
       <Merge name="StandardToolBarMenuHandler"/>
       <Separator/>
     </Menu>
   </MenuBar>
   <ToolBar name="mainToolBar" fullWidth="false" noMerge="1">
     <Text>File</Text>
     <Action name="edit_undo"/>
     <Action name="edit_redo"/>
     <Separator/>
     <Action name="edit_cut"/>
     <Action name="edit_copy"/>
     <Action name="edit_paste"/>
   </ToolBar>
     
   <ToolBar name="fontSettings" newline="true" >
     <Text>Font Settings</Text>
     <Action name="svg_font"/>
     <Action name="svg_font_size"/>
     <Action name="svg_font_color"/>
     <Action name="svg_format_textcolor"/>
+    <Action name="svg_pick_color"/>
   </ToolBar>
   
   <ToolBar name="formatting" newline="true" >
     <Text>Formatting</Text>
     <Action name="svg_weight_bold"/>
     <Action name="svg_format_italic"/>
     <Action name="svg_format_underline"/>
     <Action name="svg_align_left"/>
     <Action name="svg_align_center"/>
     <Action name="svg_align_right"/>
     <Action name="svg_line_height">
     </Action>
   </ToolBar>
   
   
 </kpartgui>