diff --git a/libs/ui/CMakeLists.txt b/libs/ui/CMakeLists.txt
index 344805c564..7ca8b1bef2 100644
--- a/libs/ui/CMakeLists.txt
+++ b/libs/ui/CMakeLists.txt
@@ -1,590 +1,588 @@
 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/kis_dlg_internal_color_selector.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
     kis_base_option.cpp
     kis_canvas_resource_provider.cpp
     kis_derived_resources.cpp
     kis_categories_mapper.cpp
     kis_categorized_list_model.cpp
     kis_categorized_item_delegate.cpp
     kis_clipboard.cc
     kis_config.cc
     kis_config_notifier.cpp
     kis_control_frame.cpp
     kis_composite_ops_model.cc
     kis_paint_ops_model.cpp
     kis_cursor.cc
     kis_cursor_cache.cpp
     kis_custom_pattern.cc
     kis_file_layer.cpp
     kis_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
     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
     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
     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
     kis_fps_decoration.cpp
     recorder/kis_node_query_path_editor.cc
     recorder/kis_recorded_action_creator.cc
     recorder/kis_recorded_action_creator_factory.cc
     recorder/kis_recorded_action_creator_factory_registry.cc
     recorder/kis_recorded_action_editor_factory.cc
     recorder/kis_recorded_action_editor_factory_registry.cc
     recorder/kis_recorded_filter_action_editor.cc
     recorder/kis_recorded_filter_action_creator.cpp
     recorder/kis_recorded_paint_action_editor.cc
     tool/kis_selection_tool_helper.cpp
     tool/kis_selection_tool_config_widget_helper.cpp
     tool/kis_rectangle_constraint_widget.cpp
     tool/kis_shape_tool_helper.cpp
     tool/kis_tool.cc
     tool/kis_delegated_tool_policies.cpp
     tool/kis_tool_freehand.cc
     tool/kis_speed_smoother.cpp
     tool/kis_painting_information_builder.cpp
     tool/kis_stabilized_events_sampler.cpp
     tool/kis_tool_freehand_helper.cpp
     tool/kis_tool_multihand_helper.cpp
     tool/kis_figure_painting_tool_helper.cpp
     tool/kis_recording_adapter.cpp
     tool/kis_tool_paint.cc
     tool/kis_tool_shape.cc
     tool/kis_tool_ellipse_base.cpp
     tool/kis_tool_rectangle_base.cpp
     tool/kis_tool_polyline_base.cpp
     tool/kis_tool_utils.cpp
     tool/kis_resources_snapshot.cpp
     tool/kis_smoothing_options.cpp
     tool/KisStabilizerDelayedPaintHelper.cpp
     tool/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
 
     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_popup_button.cc
     widgets/kis_preset_chooser.cpp
     widgets/kis_progress_widget.cpp
     widgets/kis_selection_options.cc
     widgets/kis_scratch_pad.cpp
     widgets/kis_scratch_pad_event_filter.cpp
     widgets/kis_preset_selector_strip.cpp
     widgets/kis_slider_spin_box.cpp
     widgets/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_spinbox_color_selector.cpp
     widgets/kis_screen_color_picker.cpp
     widgets/kis_preset_live_preview_view.cpp
     widgets/KoDualColorButton.cpp
     widgets/kis_color_input.cpp
     widgets/kis_color_button.cpp
     widgets/KisVisualColorSelector.cpp
     widgets/KisVisualColorSelectorShape.cpp
     widgets/KisVisualEllipticalSelectorShape.cpp
     widgets/KisVisualRectangleSelectorShape.cpp
     widgets/KisVisualTriangleSelectorShape.cpp
     widgets/KoStrokeConfigWidget.cpp
     widgets/KoFillConfigWidget.cpp
 
-    widgets/KisLayoutSelector.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
     input/kis_touch_shortcut.cpp
     kis_document_undo_store.cpp
     kis_transaction_based_command.cpp
     kis_gui_context_command.cpp
     kis_gui_context_command_p.cpp
     input/kis_tablet_debugger.cpp
     input/kis_input_profile_manager.cpp
     input/kis_input_profile.cpp
     input/kis_shortcut_configuration.cpp
     input/config/kis_input_configuration_page.cpp
     input/config/kis_edit_profiles_dialog.cpp
     input/config/kis_input_profile_model.cpp
     input/config/kis_input_configuration_page_item.cpp
     input/config/kis_action_shortcuts_model.cpp
     input/config/kis_input_type_delegate.cpp
     input/config/kis_input_mode_delegate.cpp
     input/config/kis_input_button.cpp
     input/config/kis_input_editor_delegate.cpp
     input/config/kis_mouse_input_editor.cpp
     input/config/kis_wheel_input_editor.cpp
     input/config/kis_key_input_editor.cpp
     processing/fill_processing_visitor.cpp
     kis_asl_layer_style_serializer.cpp
     kis_psd_layer_style_resource.cpp
     canvas/kis_mirror_axis.cpp
 
     kis_abstract_perspective_grid.cpp
     
     KisApplication.cpp
     KisAutoSaveRecoveryDialog.cpp
     KisDetailsPane.cpp
     KisDocument.cpp
     KisNodeDelegate.cpp
     kis_node_view_visibility_delegate.cpp
     KisNodeToolTip.cpp
     KisNodeView.cpp
     kis_node_view_color_scheme.cpp
     KisImportExportFilter.cpp
     KisFilterEntry.cpp
     KisImportExportManager.cpp
     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
 
     KisPaletteModel.cpp
     kis_palette_delegate.cpp
     kis_palette_view.cpp
     KisColorsetChooser.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/kis_tablet_event.cpp
         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
     )
 
 if(UNIX)
     set(kritaui_LIB_SRCS
         ${kritaui_LIB_SRCS}
         input/kis_tablet_event.cpp
         input/wintab/kis_tablet_support.cpp
         qtlockedfile/qtlockedfile_unix.cpp
         )
     if(NOT APPLE)
         set(kritaui_LIB_SRCS
             ${kritaui_LIB_SRCS}
             input/wintab/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/wdgpaintactioneditor.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
     brushhud/kis_dlg_brush_hud_config.ui
     forms/wdgdlginternalcolorselector.ui
     dialogs/kis_delayed_save_dialog.ui
     input/config/kis_input_configuration_page.ui
     input/config/kis_edit_profiles_dialog.ui
     input/config/kis_input_configuration_page_item.ui
     input/config/kis_mouse_input_editor.ui
     input/config/kis_wheel_input_editor.ui
     input/config/kis_key_input_editor.ui
 
     layerstyles/wdgBevelAndEmboss.ui
     layerstyles/wdgblendingoptions.ui
     layerstyles/WdgColorOverlay.ui
     layerstyles/wdgContour.ui
     layerstyles/wdgdropshadow.ui
     layerstyles/WdgGradientOverlay.ui
     layerstyles/wdgInnerGlow.ui
     layerstyles/wdglayerstyles.ui
     layerstyles/WdgPatternOverlay.ui
     layerstyles/WdgSatin.ui
     layerstyles/WdgStroke.ui
     layerstyles/wdgstylesselector.ui
     layerstyles/wdgTexture.ui
 
     wdgsplash.ui
     input/wintab/kis_screen_size_choice_dialog.ui
 
 )
 
 
 QT5_WRAP_CPP(kritaui_HEADERS_MOC KisNodePropertyAction_p.h)
 
 add_library(kritaui SHARED ${kritaui_HEADERS_MOC} ${kritaui_LIB_SRCS} )
 generate_export_header(kritaui BASE_NAME kritaui)
 
 target_link_libraries(kritaui KF5::CoreAddons KF5::Completion KF5::I18n KF5::ItemViews Qt5::Network
                       kritaimpex kritacolor kritaimage kritalibbrush kritawidgets kritawidgetutils ${PNG_LIBRARIES} ${EXIV2_LIBRARIES}
 )
 
 if (HAVE_QT_MULTIMEDIA)
     target_link_libraries(kritaui Qt5::Multimedia)
 endif()
 
 if (HAVE_KIO)
     target_link_libraries(kritaui KF5::KIOCore)
 endif() 
 
 if (NOT WIN32 AND NOT APPLE)
   target_link_libraries(kritaui ${X11_X11_LIB}
                                 ${X11_Xinput_LIB}
                                 ${XCB_LIBRARIES})
 endif()
 
 if(APPLE)
     target_link_libraries(kritaui ${FOUNDATION_LIBRARY})
     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/KisWindowLayoutManager.cpp b/libs/ui/KisWindowLayoutManager.cpp
index d4a88c7d23..99465a0b51 100644
--- a/libs/ui/KisWindowLayoutManager.cpp
+++ b/libs/ui/KisWindowLayoutManager.cpp
@@ -1,252 +1,242 @@
 /*
  *  Copyright (c) 2018 Jouni Pentikäinen <joupent@gmail.com>
  *
  *  This program is free software; you can redistribute it and/or modify
  *  it under the terms of the GNU General Public License as published by
  *  the Free Software Foundation; either version 2 of the License, or
  *  (at your option) any later version.
  *
  *  This program is distributed in the hope that it will be useful,
  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  *  GNU General Public License for more details.
  *
  *  You should have received a copy of the GNU General Public License
  *  along with this program; if not, write to the Free Software
  *  Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
  */
 
 #include "KisWindowLayoutManager.h"
 
 #include <QWidget>
 #include <QDesktopWidget>
 #include <QScreen>
 
 #include <kconfiggroup.h>
 #include <ksharedconfig.h>
 
 #include <KisApplication.h>
 #include <KisMainWindow.h>
 #include <KisPart.h>
 #include <kis_dom_utils.h>
 #include <KisResourceServerProvider.h>
 #include <KisSessionResource.h>
 
 Q_GLOBAL_STATIC(KisWindowLayoutManager, s_instance)
 
 struct KisWindowLayoutManager::Private {
     bool showImageInAllWindows{false};
     bool primaryWorkspaceFollowsFocus{false};
     QUuid primaryWindow;
 
-    QString lastLayoutName;
-
     QVector<DisplayLayout*> displayLayouts;
 
     void loadDisplayLayouts() {
         KConfigGroup layoutsCfg(KSharedConfig::openConfig(), "DisplayLayouts");
         QStringList groups = layoutsCfg.groupList();
 
         Q_FOREACH(QString name, groups) {
             loadDisplayLayout(name, layoutsCfg.group(name));
         }
     }
 
     void loadDisplayLayout(const QString &name, KConfigGroup layoutCfg) {
         DisplayLayout *layout = new DisplayLayout();
         layout->name = name;
 
         int displayNumber = 1;
 
         while (true) {
             const QString displayDefinition = layoutCfg.readEntry(QString("Display%1").arg(displayNumber++), QString());
             if (displayDefinition.isEmpty()) break;
 
             // Just the resolution for now. Later we might want to split by a separator and include things like serial number, etc.
             const QString &resolutionStr = displayDefinition;
 
             QStringList dimensions = resolutionStr.split('x');
             if (dimensions.size() != 2) {
                 qWarning() << "Invalid display definition: " << displayDefinition;
                 break;
             }
 
             QSize resolution = QSize(
                 KisDomUtils::toInt(dimensions[0]),
                 KisDomUtils::toInt(dimensions[1])
             );
 
             layout->displays.append(Display{resolution});
         }
 
         layout->preferredWindowLayout = layoutCfg.readEntry("PreferredLayout", "");
 
         displayLayouts.append(layout);
     }
 
     void saveDisplayLayout(const DisplayLayout &layout) {
         KConfigGroup layoutsCfg(KSharedConfig::openConfig(), "DisplayLayouts");
         KConfigGroup layoutCfg = layoutsCfg.group(layout.name);
         layoutCfg.writeEntry("PreferredLayout", layout.preferredWindowLayout);
     }
 };
 
 bool KisWindowLayoutManager::Display::matches(QScreen* screen) const
 {
     return resolution == screen->geometry().size();
 }
 
 bool KisWindowLayoutManager::DisplayLayout::matches(QList<QScreen*> screens) const
 {
     if (screens.size() != displays.size()) return false;
 
     QVector<bool> matchedScreens(screens.size());
     Q_FOREACH(auto &expectedDisplay, displays) {
         int i;
         for (i = 0; i < screens.size(); i++) {
             if (matchedScreens[i]) continue;
 
             if (expectedDisplay.matches(screens[i])) {
                 matchedScreens[i] = true;
                 break;
             }
         }
 
         if (i == screens.size()) {
             return false;
         }
     }
 
     return true;
 }
 
 KisWindowLayoutManager * KisWindowLayoutManager::instance()
 {
     return s_instance;
 }
 
 KisWindowLayoutManager::KisWindowLayoutManager()
     : d(new Private)
 {
     d->loadDisplayLayouts();
 
     connect(qobject_cast<KisApplication*>(KisApplication::instance()), SIGNAL(slotFocusChanged(QWidget*, QWidget*)),
             this, SLOT(focusChanged(QWidget*, QWidget*)));
 
     connect(QApplication::desktop(), SIGNAL(resized(int)), this, SLOT(slotScreensChanged()));
     connect(QApplication::desktop(), SIGNAL(screenCountChanged(int)), this, SLOT(slotScreensChanged()));
 }
 
 KisWindowLayoutManager::~KisWindowLayoutManager() {
     Q_FOREACH(DisplayLayout *layout, d->displayLayouts) {
         delete layout;
     }
 }
 
 void KisWindowLayoutManager::setShowImageInAllWindowsEnabled(bool showInAll)
 {
     bool wasEnabled = d->showImageInAllWindows;
 
     d->showImageInAllWindows = showInAll;
 
     if (!wasEnabled && showInAll) {
         KisMainWindow *currentMainWindow = KisPart::instance()->currentMainwindow();
         if (currentMainWindow) {
             KisView *activeView = currentMainWindow->activeView();
             if (activeView) {
                 KisDocument *document = activeView->document();
                 if (document) {
                    activeDocumentChanged(document);
                 }
             }
         }
     }
 }
 
 bool KisWindowLayoutManager::isShowImageInAllWindowsEnabled() const
 {
     return d->showImageInAllWindows;
 }
 
 bool KisWindowLayoutManager::primaryWorkspaceFollowsFocus() const
 {
     return d->primaryWorkspaceFollowsFocus;
 }
 
 void KisWindowLayoutManager::setPrimaryWorkspaceFollowsFocus(bool enabled, QUuid primaryWindow)
 {
     d->primaryWorkspaceFollowsFocus = enabled;
     d->primaryWindow = primaryWindow;
 }
 
 QUuid KisWindowLayoutManager::primaryWindowId() const
 {
     return d->primaryWindow;
 }
 
 void KisWindowLayoutManager::activeDocumentChanged(KisDocument *document)
 {
     if (d->showImageInAllWindows) {
         Q_FOREACH(QPointer<KisMainWindow> window, KisPart::instance()->mainWindows()) {
             if (window->isHidden()) continue;
 
             const auto view = window->activeView();
             if (!view || view->document() != document) {
                 window->showDocument(document);
             }
         }
     }
 }
 
 void KisWindowLayoutManager::slotFocusChanged(QWidget *old, QWidget *now)
 {
     Q_UNUSED(old);
 
     if (!now) return;
     KisMainWindow *newMainWindow = qobject_cast<KisMainWindow*>(now->window());
     if (!newMainWindow) return;
 
     newMainWindow->windowFocused();
 }
 
-QString KisWindowLayoutManager::lastLayoutName()
-{
-    return d->lastLayoutName;
-}
-
 void KisWindowLayoutManager::setLastUsedLayout(const KisWindowLayoutResource *layout)
 {
-    // For layout selector, accept both window layouts and sessions
-    d->lastLayoutName = layout->name();
-
     // For automatic switching, only allow a window layout proper
     auto *session = dynamic_cast<const KisSessionResource*>(layout);
     if (session) return;
 
     QList<QScreen*> screens = QGuiApplication::screens();
     Q_FOREACH(DisplayLayout *displayLayout, d->displayLayouts) {
         if (displayLayout->matches(screens)) {
             displayLayout->preferredWindowLayout = layout->name();
             d->saveDisplayLayout(*displayLayout);
             break;
         }
     }
 }
 
 void KisWindowLayoutManager::slotScreensChanged()
 {
     QList<QScreen*> screens = QGuiApplication::screens();
 
     Q_FOREACH(const DisplayLayout *displayLayout, d->displayLayouts) {
         if (displayLayout->matches(screens)) {
             KoResourceServer<KisWindowLayoutResource> *windowLayoutServer = KisResourceServerProvider::instance()->windowLayoutServer();
             KisWindowLayoutResource *layout = windowLayoutServer->resourceByName(displayLayout->preferredWindowLayout);
 
             if (layout) {
                 setLastUsedLayout(layout);
                 layout->applyLayout();
                 return;
             }
         }
     }
 }
diff --git a/libs/ui/KisWindowLayoutManager.h b/libs/ui/KisWindowLayoutManager.h
index 3bdfee3cb3..eb7ae94029 100644
--- a/libs/ui/KisWindowLayoutManager.h
+++ b/libs/ui/KisWindowLayoutManager.h
@@ -1,90 +1,85 @@
 /*
  *  Copyright (c) 2018 Jouni Pentikäinen <joupent@gmail.com>
  *
  *  This program is free software; you can redistribute it and/or modify
  *  it under the terms of the GNU General Public License as published by
  *  the Free Software Foundation; either version 2 of the License, or
  *  (at your option) any later version.
  *
  *  This program is distributed in the hope that it will be useful,
  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  *  GNU General Public License for more details.
  *
  *  You should have received a copy of the GNU General Public License
  *  along with this program; if not, write to the Free Software
  *  Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
  */
 
 #ifndef KISWINDOWLAYOUTMANAGER_H
 #define KISWINDOWLAYOUTMANAGER_H
 
 #include <QObject>
 #include <QUuid>
 #include <QVector>
 #include <QSize>
 
 class QScreen;
 class KisWindowLayoutResource;
 class KisDocument;
 
 class KisWindowLayoutManager : public QObject
 {
     Q_OBJECT
 
 public:
     struct Display
     {
         QSize resolution;
 
         bool matches(QScreen* screen) const;
     };
 
     struct DisplayLayout
     {
         QString name;
 
         QVector<Display> displays;
         QString preferredWindowLayout;
 
         bool matches(QList<QScreen*> screens) const;
     };
 
     explicit KisWindowLayoutManager();
     ~KisWindowLayoutManager();
 
     static KisWindowLayoutManager *instance();
 
     /**
      * When enabled, a workspace dedicated as primary is used for any main window which receives focus.
      * Meanwhile, the workspace of that window is used for the window which originally had the primary workspace.
      */
     bool primaryWorkspaceFollowsFocus() const;
     void setPrimaryWorkspaceFollowsFocus(bool enabled, QUuid primaryWindow);
     QUuid primaryWindowId() const;
 
     /**
      * When enabled, main windows will synchronize to keep the same document active
      */
     bool isShowImageInAllWindowsEnabled() const;
     void setShowImageInAllWindowsEnabled(bool showInAll);
 
     void activeDocumentChanged(KisDocument *document);
 
-    /**
-     * The name of the last activated window layout or session.
-     * Used by the layout selector.
-     */
-    QString lastLayoutName();
     void setLastUsedLayout(const KisWindowLayoutResource *layout);
 
 private Q_SLOTS:
     void slotFocusChanged(QWidget*, QWidget*);
     void slotScreensChanged();
 
 private:
     struct Private;
     QScopedPointer<Private> d;
 };
 
 #endif
diff --git a/libs/ui/kis_paintop_box.cc b/libs/ui/kis_paintop_box.cc
index f2b71194e8..7d5be239d2 100644
--- a/libs/ui/kis_paintop_box.cc
+++ b/libs/ui/kis_paintop_box.cc
@@ -1,1353 +1,1347 @@
 /*
  *  kis_paintop_box.cc - part of KImageShop/Krayon/Krita
  *
  *  Copyright (c) 2004 Boudewijn Rempt (boud@valdyas.org)
  *  Copyright (c) 2009-2011 Sven Langkamp (sven.langkamp@gmail.com)
  *  Copyright (c) 2010 Lukáš Tvrdý <lukast.dev@gmail.com>
  *  Copyright (C) 2011 Silvio Heinrich <plassy@web.de>
  *  Copyright (C) 2011 Srikanth Tiyyagura <srikanth.tulasiram@gmail.com>
  *  Copyright (c) 2014 Mohit Goyal <mohit.bits2011@gmail.com>
  *
  *  This program is free software; you can redistribute it and/or modify
  *  it under the terms of the GNU General Public License as published by
  *  the Free Software Foundation; either version 2 of the License, or
  *  (at your option) any later version.
  *
  *  This program is distributed in the hope that it will be useful,
  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  *  GNU General Public License for more details.
  *
  *  You should have received a copy of the GNU General Public License
  *  along with this program; if not, write to the Free Software
  *  Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
  */
 
 #include "kis_paintop_box.h"
 
 #include <QHBoxLayout>
 #include <QLabel>
 #include <QToolButton>
 #include <QPixmap>
 #include <QWidgetAction>
 #include <QApplication>
 #include <QMenu>
 #include <QTime>
 
 #include <kis_debug.h>
 
 #include <kactioncollection.h>
 #include <kacceleratormanager.h>
 #include <QKeySequence>
 
 
 #include <kis_icon.h>
 #include <KoColorSpace.h>
 #include <KoCompositeOpRegistry.h>
 #include <KoResourceSelector.h>
 #include <KoResourceServerAdapter.h>
 #include <KoToolManager.h>
 #include <QTemporaryFile>
 #include <KoColorSpaceRegistry.h>
 
 #include <kis_paint_device.h>
 #include <brushengine/kis_paintop_registry.h>
 #include <brushengine/kis_paintop_preset.h>
 #include <brushengine/kis_paintop_settings.h>
 #include <brushengine/kis_paintop_settings_update_proxy.h>
 #include <kis_config_widget.h>
 #include <kis_image.h>
 #include <kis_node.h>
 #include <brushengine/kis_paintop_config_widget.h>
 #include <kis_action.h>
-#include <KisLayoutSelector.h>
 
 #include "kis_canvas2.h"
 #include "kis_node_manager.h"
 #include "KisViewManager.h"
 #include "kis_canvas_resource_provider.h"
 #include "KisResourceServerProvider.h"
 #include "kis_favorite_resource_manager.h"
 #include "kis_config.h"
 
 #include "widgets/kis_popup_button.h"
 #include "widgets/kis_iconwidget.h"
 #include "widgets/kis_tool_options_popup.h"
 #include "widgets/kis_paintop_presets_popup.h"
 #include "widgets/kis_tool_options_popup.h"
 #include "widgets/kis_paintop_presets_chooser_popup.h"
 #include "widgets/kis_workspace_chooser.h"
 #include "widgets/kis_paintop_list_widget.h"
 #include "widgets/kis_slider_spin_box.h"
 #include "widgets/kis_cmb_composite.h"
 #include "widgets/kis_widget_chooser.h"
 #include "tool/kis_tool.h"
 #include "kis_signals_blocker.h"
 #include "kis_action_manager.h"
 #include "kis_highlighted_button.h"
 
 typedef KoResourceServerSimpleConstruction<KisPaintOpPreset, SharedPointerStoragePolicy<KisPaintOpPresetSP> > KisPaintOpPresetResourceServer;
 typedef KoResourceServerAdapter<KisPaintOpPreset, SharedPointerStoragePolicy<KisPaintOpPresetSP> > KisPaintOpPresetResourceServerAdapter;
 
 KisPaintopBox::KisPaintopBox(KisViewManager *view, QWidget *parent, const char *name)
     : QWidget(parent)
     , m_resourceProvider(view->resourceProvider())
     , m_optionWidget(0)
     , m_toolOptionsPopupButton(0)
     , m_brushEditorPopupButton(0)
     , m_presetSelectorPopupButton(0)
     , m_toolOptionsPopup(0)
     , m_viewManager(view)
     , m_previousNode(0)
     , m_currTabletToolID(KoInputDevice::invalid())
     , m_presetsEnabled(true)
     , m_blockUpdate(false)
     , m_dirtyPresetsEnabled(false)
     , m_eraserBrushSizeEnabled(false)
     , m_eraserBrushOpacityEnabled(false)
 {
     Q_ASSERT(view != 0);
 
 
     setObjectName(name);
     KisConfig cfg;
     m_dirtyPresetsEnabled = cfg.useDirtyPresets();
     m_eraserBrushSizeEnabled = cfg.useEraserBrushSize();
     m_eraserBrushOpacityEnabled = cfg.useEraserBrushOpacity();
 
     KAcceleratorManager::setNoAccel(this);
 
     setWindowTitle(i18n("Painter's Toolchest"));
 
     m_favoriteResourceManager = new KisFavoriteResourceManager(this);
 
 
     KConfigGroup grp =  KSharedConfig::openConfig()->group("krita").group("Toolbar BrushesAndStuff");
     int iconsize = grp.readEntry("IconSize", 32);
 
     if (!cfg.toolOptionsInDocker()) {
         m_toolOptionsPopupButton = new KisPopupButton(this);
         m_toolOptionsPopupButton->setIcon(KisIconUtils::loadIcon("configure"));
         m_toolOptionsPopupButton->setToolTip(i18n("Tool Settings"));
         m_toolOptionsPopupButton->setFixedSize(iconsize, iconsize);
     }
 
     m_brushEditorPopupButton = new KisIconWidget(this);
     m_brushEditorPopupButton->setIcon(KisIconUtils::loadIcon("paintop_settings_02"));
     m_brushEditorPopupButton->setToolTip(i18n("Edit brush settings"));
     m_brushEditorPopupButton->setFixedSize(iconsize, iconsize);
 
     m_presetSelectorPopupButton = new KisPopupButton(this);
     m_presetSelectorPopupButton->setIcon(KisIconUtils::loadIcon("paintop_settings_01"));
     m_presetSelectorPopupButton->setToolTip(i18n("Choose brush preset"));
     m_presetSelectorPopupButton->setFixedSize(iconsize, iconsize);
 
     m_eraseModeButton = new KisHighlightedToolButton(this);
     m_eraseModeButton->setFixedSize(iconsize, iconsize);
     m_eraseModeButton->setCheckable(true);
 
     m_eraseAction = m_viewManager->actionManager()->createAction("erase_action");
     m_eraseModeButton->setDefaultAction(m_eraseAction);
 
     m_reloadButton = new QToolButton(this);
     m_reloadButton->setFixedSize(iconsize, iconsize);
 
     m_reloadAction = m_viewManager->actionManager()->createAction("reload_preset_action");
     m_reloadButton->setDefaultAction(m_reloadAction);
 
     m_alphaLockButton = new KisHighlightedToolButton(this);
     m_alphaLockButton->setFixedSize(iconsize, iconsize);
     m_alphaLockButton->setCheckable(true);
 
     KisAction* alphaLockAction = m_viewManager->actionManager()->createAction("preserve_alpha");
     m_alphaLockButton->setDefaultAction(alphaLockAction);
 
     // horizontal and vertical mirror toolbar buttons
 
     // mirror tool options for the X Mirror
     QMenu *toolbarMenuXMirror = new QMenu();
 
     hideCanvasDecorationsX = m_viewManager->actionManager()->createAction("mirrorX-hideDecorations");
     toolbarMenuXMirror->addAction(hideCanvasDecorationsX);
 
     lockActionX = m_viewManager->actionManager()->createAction("mirrorX-lock");
     toolbarMenuXMirror->addAction(lockActionX);
 
     moveToCenterActionX = m_viewManager->actionManager()->createAction("mirrorX-moveToCenter");
     toolbarMenuXMirror->addAction(moveToCenterActionX);
 
 
     // mirror tool options for the Y Mirror
     QMenu *toolbarMenuYMirror = new QMenu();
 
     hideCanvasDecorationsY = m_viewManager->actionManager()->createAction("mirrorY-hideDecorations");
     toolbarMenuYMirror->addAction(hideCanvasDecorationsY);
 
 
     lockActionY = m_viewManager->actionManager()->createAction("mirrorY-lock");
     toolbarMenuYMirror->addAction(lockActionY);
 
     moveToCenterActionY = m_viewManager->actionManager()->createAction("mirrorY-moveToCenter");
     toolbarMenuYMirror->addAction(moveToCenterActionY);
 
 
 
     // create horizontal and vertical mirror buttons
 
     m_hMirrorButton = new KisHighlightedToolButton(this);
     int menuPadding = 10;
     m_hMirrorButton->setFixedSize(iconsize + menuPadding, iconsize);
     m_hMirrorButton->setCheckable(true);
     m_hMirrorAction = m_viewManager->actionManager()->createAction("hmirror_action");
     m_hMirrorButton->setDefaultAction(m_hMirrorAction);
     m_hMirrorButton->setMenu(toolbarMenuXMirror);
     m_hMirrorButton->setPopupMode(QToolButton::MenuButtonPopup);
 
     m_vMirrorButton = new KisHighlightedToolButton(this);
     m_vMirrorButton->setFixedSize(iconsize + menuPadding, iconsize);
     m_vMirrorButton->setCheckable(true);
     m_vMirrorAction = m_viewManager->actionManager()->createAction("vmirror_action");
     m_vMirrorButton->setDefaultAction(m_vMirrorAction);
     m_vMirrorButton->setMenu(toolbarMenuYMirror);
     m_vMirrorButton->setPopupMode(QToolButton::MenuButtonPopup);
 
 
     // add connections for horizontal and mirrror buttons
     connect(lockActionX, SIGNAL(toggled(bool)), this, SLOT(slotLockXMirrorToggle(bool)));
     connect(lockActionY, SIGNAL(toggled(bool)), this, SLOT(slotLockYMirrorToggle(bool)));
 
     connect(moveToCenterActionX, SIGNAL(triggered(bool)), this, SLOT(slotMoveToCenterMirrorX()));
     connect(moveToCenterActionY, SIGNAL(triggered(bool)), this, SLOT(slotMoveToCenterMirrorY()));
 
     connect(hideCanvasDecorationsX, SIGNAL(toggled(bool)), this, SLOT(slotHideDecorationMirrorX(bool)));
     connect(hideCanvasDecorationsY, SIGNAL(toggled(bool)), this, SLOT(slotHideDecorationMirrorY(bool)));
 
     const bool sliderLabels = cfg.sliderLabels();
     int sliderWidth;
 
     if (sliderLabels) {
         sliderWidth = 150 * logicalDpiX() / 96;
     }
     else {
         sliderWidth = 120 * logicalDpiX() / 96;
     }
 
     for (int i = 0; i < 3; ++i) {
         m_sliderChooser[i] = new KisWidgetChooser(i + 1);
 
         KisDoubleSliderSpinBox* slOpacity;
         KisDoubleSliderSpinBox* slFlow;
         KisDoubleSliderSpinBox* slSize;
         if (sliderLabels) {
             slOpacity = m_sliderChooser[i]->addWidget<KisDoubleSliderSpinBox>("opacity");
             slFlow    = m_sliderChooser[i]->addWidget<KisDoubleSliderSpinBox>("flow");
             slSize    = m_sliderChooser[i]->addWidget<KisDoubleSliderSpinBox>("size");
             slOpacity->setPrefix(QString("%1  ").arg(i18n("Opacity:")));
             slFlow->setPrefix(QString("%1  ").arg(i18n("Flow:")));
             slSize->setPrefix(QString("%1  ").arg(i18n("Size:")));
         }
         else {
             slOpacity = m_sliderChooser[i]->addWidget<KisDoubleSliderSpinBox>("opacity", i18n("Opacity:"));
             slFlow    = m_sliderChooser[i]->addWidget<KisDoubleSliderSpinBox>("flow", i18n("Flow:"));
             slSize    = m_sliderChooser[i]->addWidget<KisDoubleSliderSpinBox>("size", i18n("Size:"));
         }
 
         slOpacity->setRange(0, 100, 0);
         slOpacity->setValue(100);
         slOpacity->setSingleStep(5);
         slOpacity->setSuffix("%");
         slOpacity->setMinimumWidth(qMax(sliderWidth, slOpacity->sizeHint().width()));
         slOpacity->setFixedHeight(iconsize);
         slOpacity->setBlockUpdateSignalOnDrag(true);
 
         slFlow->setRange(0, 100, 0);
         slFlow->setValue(100);
         slFlow->setSingleStep(5);
         slFlow->setSuffix("%");
         slFlow->setMinimumWidth(qMax(sliderWidth, slFlow->sizeHint().width()));
         slFlow->setFixedHeight(iconsize);
         slFlow->setBlockUpdateSignalOnDrag(true);
 
         slSize->setRange(0, cfg.readEntry("maximumBrushSize", 1000), 2);
         slSize->setValue(100);
 
         slSize->setSingleStep(1);
         slSize->setExponentRatio(3.0);
         slSize->setSuffix(i18n(" px"));
         slSize->setMinimumWidth(qMax(sliderWidth, slSize->sizeHint().width()));
         slSize->setFixedHeight(iconsize);
         slSize->setBlockUpdateSignalOnDrag(true);
 
         m_sliderChooser[i]->chooseWidget(cfg.toolbarSlider(i + 1));
     }
 
     m_cmbCompositeOp = new KisCompositeOpComboBox();
     m_cmbCompositeOp->setFixedHeight(iconsize);
     Q_FOREACH (KisAction * a, m_cmbCompositeOp->blendmodeActions()) {
         m_viewManager->actionManager()->addAction(a->text(), a);
     }
 
     m_workspaceWidget = new KisPopupButton(this);
     m_workspaceWidget->setIcon(KisIconUtils::loadIcon("view-choose"));
     m_workspaceWidget->setToolTip(i18n("Choose workspace"));
     m_workspaceWidget->setFixedSize(iconsize, iconsize);
     m_workspaceWidget->setPopupWidget(new KisWorkspaceChooser(view));
 
     QHBoxLayout* baseLayout = new QHBoxLayout(this);
     m_paintopWidget = new QWidget(this);
     baseLayout->addWidget(m_paintopWidget);
     baseLayout->setSpacing(4);
     baseLayout->setContentsMargins(0, 0, 0, 0);
 
     m_layout = new QHBoxLayout(m_paintopWidget);
     if (!cfg.toolOptionsInDocker()) {
         m_layout->addWidget(m_toolOptionsPopupButton);
     }
     m_layout->addWidget(m_brushEditorPopupButton);
     m_layout->addWidget(m_presetSelectorPopupButton);
     m_layout->setSpacing(4);
     m_layout->setContentsMargins(0, 0, 0, 0);
 
     QWidget* compositeActions = new QWidget(this);
     QHBoxLayout* compositeLayout = new QHBoxLayout(compositeActions);
     compositeLayout->addWidget(m_cmbCompositeOp);
     compositeLayout->addWidget(m_eraseModeButton);
     compositeLayout->addWidget(m_alphaLockButton);
 
     compositeLayout->setSpacing(4);
     compositeLayout->setContentsMargins(0, 0, 0, 0);
 
     compositeLayout->addWidget(m_reloadButton);
 
     QWidgetAction * action;
 
     action = new QWidgetAction(this);
     view->actionCollection()->addAction("composite_actions", action);
     action->setText(i18n("Brush composite"));
     action->setDefaultWidget(compositeActions);
 
     action = new QWidgetAction(this);
     KisActionRegistry::instance()->propertizeAction("brushslider1", action);
     view->actionCollection()->addAction("brushslider1", action);
     action->setDefaultWidget(m_sliderChooser[0]);
     connect(action, SIGNAL(triggered()), m_sliderChooser[0], SLOT(showPopupWidget()));
     connect(m_viewManager->mainWindow(), SIGNAL(themeChanged()), m_sliderChooser[0], SLOT(updateThemedIcons()));
 
     action = new QWidgetAction(this);
     KisActionRegistry::instance()->propertizeAction("brushslider2", action);
     view->actionCollection()->addAction("brushslider2", action);
     action->setDefaultWidget(m_sliderChooser[1]);
     connect(action, SIGNAL(triggered()), m_sliderChooser[1], SLOT(showPopupWidget()));
     connect(m_viewManager->mainWindow(), SIGNAL(themeChanged()), m_sliderChooser[1], SLOT(updateThemedIcons()));
 
     action = new QWidgetAction(this);
     KisActionRegistry::instance()->propertizeAction("brushslider3", action);
     view->actionCollection()->addAction("brushslider3", action);
     action->setDefaultWidget(m_sliderChooser[2]);
     connect(action, SIGNAL(triggered()), m_sliderChooser[2], SLOT(showPopupWidget()));
         connect(m_viewManager->mainWindow(), SIGNAL(themeChanged()), m_sliderChooser[2], SLOT(updateThemedIcons()));
 
     action = new QWidgetAction(this);
     KisActionRegistry::instance()->propertizeAction("next_favorite_preset", action);
     view->actionCollection()->addAction("next_favorite_preset", action);
     connect(action, SIGNAL(triggered()), this, SLOT(slotNextFavoritePreset()));
 
     action = new QWidgetAction(this);
     KisActionRegistry::instance()->propertizeAction("previous_favorite_preset", action);
     view->actionCollection()->addAction("previous_favorite_preset", action);
     connect(action, SIGNAL(triggered()), this, SLOT(slotPreviousFavoritePreset()));
 
     action = new QWidgetAction(this);
     KisActionRegistry::instance()->propertizeAction("previous_preset", action);
     view->actionCollection()->addAction("previous_preset", action);
     connect(action, SIGNAL(triggered()), this, SLOT(slotSwitchToPreviousPreset()));
 
     if (!cfg.toolOptionsInDocker()) {
         action = new QWidgetAction(this);
         KisActionRegistry::instance()->propertizeAction("show_tool_options", action);
         view->actionCollection()->addAction("show_tool_options", action);
         connect(action, SIGNAL(triggered()), m_toolOptionsPopupButton, SLOT(showPopupWidget()));
     }
 
     action = new QWidgetAction(this);
     KisActionRegistry::instance()->propertizeAction("show_brush_editor", action);
     view->actionCollection()->addAction("show_brush_editor", action);
     connect(action, SIGNAL(triggered()), m_brushEditorPopupButton, SLOT(showPopupWidget()));
 
     action = new QWidgetAction(this);
     KisActionRegistry::instance()->propertizeAction("show_brush_presets", action);
     view->actionCollection()->addAction("show_brush_presets", action);
     connect(action, SIGNAL(triggered()), m_presetSelectorPopupButton, SLOT(showPopupWidget()));
 
     QWidget* mirrorActions = new QWidget(this);
     QHBoxLayout* mirrorLayout = new QHBoxLayout(mirrorActions);
     mirrorLayout->addWidget(m_hMirrorButton);
     mirrorLayout->addWidget(m_vMirrorButton);
     mirrorLayout->setSpacing(4);
     mirrorLayout->setContentsMargins(0, 0, 0, 0);
 
     action = new QWidgetAction(this);
     KisActionRegistry::instance()->propertizeAction("mirror_actions", action);
     action->setDefaultWidget(mirrorActions);
     view->actionCollection()->addAction("mirror_actions", action);
 
-    action = new QWidgetAction(this);
-    KisActionRegistry::instance()->propertizeAction("select_layout", action);
-    view->actionCollection()->addAction("select_layout", action);
-    action->setDefaultWidget(new KisLayoutSelector(this));
-
     action = new QWidgetAction(this);
     KisActionRegistry::instance()->propertizeAction("workspaces", action);
     view->actionCollection()->addAction("workspaces", action);
     action->setDefaultWidget(m_workspaceWidget);
 
     if (!cfg.toolOptionsInDocker()) {
         m_toolOptionsPopup = new KisToolOptionsPopup();
         m_toolOptionsPopupButton->setPopupWidget(m_toolOptionsPopup);
         m_toolOptionsPopup->switchDetached(false);
     }
 
 
     m_savePresetWidget = new KisPresetSaveWidget(this);
 
     m_presetsPopup = new KisPaintOpPresetsPopup(m_resourceProvider, m_favoriteResourceManager, m_savePresetWidget);
     m_brushEditorPopupButton->setPopupWidget(m_presetsPopup);
     m_presetsPopup->parentWidget()->setWindowTitle(i18n("Brush Editor"));
 
 
     connect(m_presetsPopup, SIGNAL(brushEditorShown()), SLOT(slotUpdateOptionsWidgetPopup()));
     connect(m_viewManager->mainWindow(), SIGNAL(themeChanged()), m_presetsPopup, SLOT(updateThemedIcons()));
 
     m_presetsChooserPopup = new KisPaintOpPresetsChooserPopup();
     m_presetsChooserPopup->setMinimumHeight(550);
     m_presetsChooserPopup->setMinimumWidth(450);
     m_presetSelectorPopupButton->setPopupWidget(m_presetsChooserPopup);
 
     m_currCompositeOpID = KoCompositeOpRegistry::instance().getDefaultCompositeOp().id();
 
     slotNodeChanged(view->activeNode());
     // Get all the paintops
     QList<QString> keys = KisPaintOpRegistry::instance()->keys();
     QList<KisPaintOpFactory*> factoryList;
 
     Q_FOREACH (const QString & paintopId, keys) {
         factoryList.append(KisPaintOpRegistry::instance()->get(paintopId));
     }
     m_presetsPopup->setPaintOpList(factoryList);
 
     connect(m_presetsPopup       , SIGNAL(paintopActivated(QString))          , SLOT(slotSetPaintop(QString)));
     connect(m_presetsPopup       , SIGNAL(defaultPresetClicked())             , SLOT(slotSetupDefaultPreset()));
     connect(m_presetsPopup       , SIGNAL(signalResourceSelected(KoResource*)), SLOT(resourceSelected(KoResource*)));
     connect(m_presetsPopup       , SIGNAL(reloadPresetClicked())              , SLOT(slotReloadPreset()));
     connect(m_presetsPopup       , SIGNAL(dirtyPresetToggled(bool))           , SLOT(slotDirtyPresetToggled(bool)));
     connect(m_presetsPopup       , SIGNAL(eraserBrushSizeToggled(bool))       , SLOT(slotEraserBrushSizeToggled(bool)));
     connect(m_presetsPopup       , SIGNAL(eraserBrushOpacityToggled(bool))       , SLOT(slotEraserBrushOpacityToggled(bool)));
 
     connect(m_presetsPopup, SIGNAL(createPresetFromScratch(QString)), this, SLOT(slotCreatePresetFromScratch(QString)));
 
     connect(m_presetsChooserPopup, SIGNAL(resourceSelected(KoResource*))      , SLOT(resourceSelected(KoResource*)));
     connect(m_presetsChooserPopup, SIGNAL(resourceClicked(KoResource*))      , SLOT(resourceSelected(KoResource*)));
 
     connect(m_resourceProvider   , SIGNAL(sigNodeChanged(const KisNodeSP))    , SLOT(slotNodeChanged(const KisNodeSP)));
     connect(m_cmbCompositeOp     , SIGNAL(currentIndexChanged(int))           , SLOT(slotSetCompositeMode(int)));
     connect(m_eraseAction          , SIGNAL(toggled(bool))                    , SLOT(slotToggleEraseMode(bool)));
     connect(alphaLockAction      , SIGNAL(toggled(bool))                    , SLOT(slotToggleAlphaLockMode(bool)));
 
     m_disablePressureAction = m_viewManager->actionManager()->createAction("disable_pressure");
     connect(m_disablePressureAction  , SIGNAL(toggled(bool))                    , SLOT(slotDisablePressureMode(bool)));
     m_disablePressureAction->setChecked(true);
 
     connect(m_hMirrorAction        , SIGNAL(toggled(bool))                    , SLOT(slotHorizontalMirrorChanged(bool)));
     connect(m_vMirrorAction        , SIGNAL(toggled(bool))                    , SLOT(slotVerticalMirrorChanged(bool)));
     connect(m_reloadAction         , SIGNAL(triggered())                        , SLOT(slotReloadPreset()));
 
     connect(m_sliderChooser[0]->getWidget<KisDoubleSliderSpinBox>("opacity"), SIGNAL(valueChanged(qreal)), SLOT(slotSlider1Changed()));
     connect(m_sliderChooser[0]->getWidget<KisDoubleSliderSpinBox>("flow")   , SIGNAL(valueChanged(qreal)), SLOT(slotSlider1Changed()));
     connect(m_sliderChooser[0]->getWidget<KisDoubleSliderSpinBox>("size")   , SIGNAL(valueChanged(qreal)), SLOT(slotSlider1Changed()));
     connect(m_sliderChooser[1]->getWidget<KisDoubleSliderSpinBox>("opacity"), SIGNAL(valueChanged(qreal)), SLOT(slotSlider2Changed()));
     connect(m_sliderChooser[1]->getWidget<KisDoubleSliderSpinBox>("flow")   , SIGNAL(valueChanged(qreal)), SLOT(slotSlider2Changed()));
     connect(m_sliderChooser[1]->getWidget<KisDoubleSliderSpinBox>("size")   , SIGNAL(valueChanged(qreal)), SLOT(slotSlider2Changed()));
     connect(m_sliderChooser[2]->getWidget<KisDoubleSliderSpinBox>("opacity"), SIGNAL(valueChanged(qreal)), SLOT(slotSlider3Changed()));
     connect(m_sliderChooser[2]->getWidget<KisDoubleSliderSpinBox>("flow")   , SIGNAL(valueChanged(qreal)), SLOT(slotSlider3Changed()));
     connect(m_sliderChooser[2]->getWidget<KisDoubleSliderSpinBox>("size")   , SIGNAL(valueChanged(qreal)), SLOT(slotSlider3Changed()));
 
     //Needed to connect canvas to favorite resource manager
     connect(m_viewManager->resourceProvider(), SIGNAL(sigFGColorChanged(KoColor)), SLOT(slotUnsetEraseMode()));
 
 
     connect(m_resourceProvider, SIGNAL(sigFGColorUsed(KoColor)), m_favoriteResourceManager, SLOT(slotAddRecentColor(KoColor)));
 
     connect(m_resourceProvider, SIGNAL(sigFGColorChanged(KoColor)), m_favoriteResourceManager, SLOT(slotChangeFGColorSelector(KoColor)));
     connect(m_resourceProvider, SIGNAL(sigBGColorChanged(KoColor)), m_favoriteResourceManager, SLOT(slotSetBGColor(KoColor)));
     // cold initialization
     m_favoriteResourceManager->slotChangeFGColorSelector(m_resourceProvider->fgColor());
     m_favoriteResourceManager->slotSetBGColor(m_resourceProvider->bgColor());
 
     connect(m_favoriteResourceManager, SIGNAL(sigSetFGColor(KoColor)), m_resourceProvider, SLOT(slotSetFGColor(KoColor)));
     connect(m_favoriteResourceManager, SIGNAL(sigSetBGColor(KoColor)), m_resourceProvider, SLOT(slotSetBGColor(KoColor)));
     connect(m_favoriteResourceManager, SIGNAL(sigEnableChangeColor(bool)), m_resourceProvider, SLOT(slotResetEnableFGChange(bool)));
 
     connect(view->mainWindow(), SIGNAL(themeChanged()), this, SLOT(slotUpdateSelectionIcon()));
 
     slotInputDeviceChanged(KoToolManager::instance()->currentInputDevice());
 
     KisPaintOpPresetResourceServer *rserver = KisResourceServerProvider::instance()->paintOpPresetServer();
     m_eraserName = "eraser_circle";
     m_defaultPresetName = "basic_tip_default";
     bool foundEraser = false;
     bool foundTip = false;
     for (int i=0; i<rserver->resourceCount(); i++) {
         KisPaintOpPresetSP resource = rserver->resources().at(i);
         if (resource->name().toLower().contains("eraser_circle")) {
             m_eraserName = resource->name();
             foundEraser = true;
         } else if (foundEraser == false && (resource->name().toLower().contains("eraser") ||
                                             resource->filename().toLower().contains("eraser"))) {
             m_eraserName = resource->name();
             foundEraser = true;
         }
         if (resource->name().toLower().contains("basic_tip_default")) {
             m_defaultPresetName = resource->name();
             foundTip = true;
         } else if (foundTip == false && (resource->name().toLower().contains("default") ||
                                          resource->filename().toLower().contains("default"))) {
             m_defaultPresetName = resource->name();
             foundTip = true;
         }
     }
 }
 
 KisPaintopBox::~KisPaintopBox()
 {
     KisConfig cfg;
     QMapIterator<TabletToolID, TabletToolData> iter(m_tabletToolMap);
     while (iter.hasNext()) {
         iter.next();
         //qDebug() << "Writing last used preset for" << iter.key().pointer << iter.key().uniqueID << iter.value().preset->name();
         if ((iter.key().pointer) == QTabletEvent::Eraser) {
             cfg.writeEntry(QString("LastEraser_%1").arg(iter.key().uniqueID) , iter.value().preset->name());
         }
         else {
             cfg.writeEntry(QString("LastPreset_%1").arg(iter.key().uniqueID) , iter.value().preset->name());
         }
     }
     // Do not delete the widget, since it is global to the application, not owned by the view
     m_presetsPopup->setPaintOpSettingsWidget(0);
     qDeleteAll(m_paintopOptionWidgets);
     delete m_favoriteResourceManager;
 
     for (int i = 0; i < 3; ++i) {
         delete m_sliderChooser[i];
     }
 }
 
 void KisPaintopBox::restoreResource(KoResource* resource)
 {
 
     KisPaintOpPreset* preset = dynamic_cast<KisPaintOpPreset*>(resource);
     //qDebug() << "restoreResource" << resource << preset;
     if (preset) {
         setCurrentPaintop(preset);
 
         m_presetsPopup->setPresetImage(preset->image());
         m_presetsPopup->resourceSelected(resource);
     }
 }
 
 void KisPaintopBox::newOptionWidgets(const QList<QPointer<QWidget> > &optionWidgetList)
 {
     if (m_toolOptionsPopup) {
         m_toolOptionsPopup->newOptionWidgets(optionWidgetList);
     }
 }
 
 void KisPaintopBox::resourceSelected(KoResource* resource)
 {
     m_presetsPopup->setCreatingBrushFromScratch(false); // show normal UI elements when we are not creating
 
     KisPaintOpPreset* preset = dynamic_cast<KisPaintOpPreset*>(resource);
     if (preset && preset != m_resourceProvider->currentPreset()) {
         if (!preset->settings()->isLoadable())
             return;
 
         if (!m_dirtyPresetsEnabled) {
             KisSignalsBlocker blocker(m_optionWidget);
             if (!preset->load()) {
                 warnKrita << "failed to load the preset.";
             }
         }
         //qDebug() << "resourceSelected" << resource->name();
         setCurrentPaintop(preset);
 
         m_presetsPopup->setPresetImage(preset->image());
         m_presetsPopup->resourceSelected(resource);
     }
 
 
 }
 
 void KisPaintopBox::setCurrentPaintop(const KoID& paintop)
 {
     KisPaintOpPresetSP preset = activePreset(paintop);
     Q_ASSERT(preset && preset->settings());
     //qDebug() << "setCurrentPaintop();" << paintop << preset;
     setCurrentPaintop(preset);
 }
 
 void KisPaintopBox::setCurrentPaintop(KisPaintOpPresetSP preset)
 {
 
     //qDebug() << "setCurrentPaintop(); " << preset->name();
 
     if (preset == m_resourceProvider->currentPreset()) {
 
         if (preset == m_tabletToolMap[m_currTabletToolID].preset) {
             return;
         }
     }
     Q_ASSERT(preset);
     const KoID& paintop = preset->paintOp();
     m_presetConnections.clear();
 
     if (m_resourceProvider->currentPreset()) {
 
         m_resourceProvider->setPreviousPaintOpPreset(m_resourceProvider->currentPreset());
 
         if (m_optionWidget) {
             m_optionWidget->hide();
         }
 
     }
 
     if (!m_paintopOptionWidgets.contains(paintop))
         m_paintopOptionWidgets[paintop] = KisPaintOpRegistry::instance()->get(paintop.id())->createConfigWidget(this);
 
     m_optionWidget = m_paintopOptionWidgets[paintop];
 
     KisSignalsBlocker b(m_optionWidget);
 
     preset->setOptionsWidget(m_optionWidget);
 
     m_optionWidget->setImage(m_viewManager->image());
     m_optionWidget->setNode(m_viewManager->activeNode());
 
     m_presetsPopup->setPaintOpSettingsWidget(m_optionWidget);
 
     m_resourceProvider->setPaintOpPreset(preset);
 
     Q_ASSERT(m_optionWidget && m_presetSelectorPopupButton);
 
     m_presetConnections.addConnection(m_optionWidget, SIGNAL(sigConfigurationUpdated()), this, SLOT(slotGuiChangedCurrentPreset()));
     m_presetConnections.addConnection(m_optionWidget, SIGNAL(sigSaveLockedConfig(KisPropertiesConfigurationSP)), this, SLOT(slotSaveLockedOptionToPreset(KisPropertiesConfigurationSP)));
     m_presetConnections.addConnection(m_optionWidget, SIGNAL(sigDropLockedConfig(KisPropertiesConfigurationSP)), this, SLOT(slotDropLockedOption(KisPropertiesConfigurationSP)));
 
 
     // load the current brush engine icon for the brush editor toolbar button
 
     m_brushEditorPopupButton->slotSetItem(preset.data());
     m_presetsPopup->setCurrentPaintOpId(paintop.id());
 
 
     ////qDebug() << "\tsetting the new preset for" << m_currTabletToolID.uniqueID << "to" << preset->name();
     m_paintOpPresetMap[m_resourceProvider->currentPreset()->paintOp()] = preset;
     m_tabletToolMap[m_currTabletToolID].preset = preset;
     m_tabletToolMap[m_currTabletToolID].paintOpID = preset->paintOp();
 
 
     if (m_presetsPopup->currentPaintOpId() != paintop.id()) {
         // Must change the paintop as the current one is not supported
         // by the new colorspace.
         dbgKrita << "current paintop " << paintop.name() << " was not set, not supported by colorspace";
     }
 }
 
 void KisPaintopBox::slotUpdateOptionsWidgetPopup()
 {
     KisPaintOpPresetSP preset = m_resourceProvider->currentPreset();
     KIS_SAFE_ASSERT_RECOVER_RETURN(preset);
     KIS_SAFE_ASSERT_RECOVER_RETURN(m_optionWidget);
 
     m_optionWidget->setConfigurationSafe(preset->settings());
 
     m_presetsPopup->resourceSelected(preset.data());
     m_presetsPopup->updateViewSettings();
 
     // the m_viewManager->image() is set earlier, but the reference will be missing when the stamp button is pressed
     // need to later do some research on how and when we should be using weak shared pointers (WSP) that creates this situation
     m_optionWidget->setImage(m_viewManager->image());
 }
 
 KisPaintOpPresetSP KisPaintopBox::defaultPreset(const KoID& paintOp)
 {
     QString defaultName = paintOp.id() + ".kpp";
     QString path = KoResourcePaths::findResource("kis_defaultpresets", defaultName);
 
     KisPaintOpPresetSP preset = new KisPaintOpPreset(path);
 
     if (!preset->load()) {
         preset = KisPaintOpRegistry::instance()->defaultPreset(paintOp);
     }
 
     Q_ASSERT(preset);
     Q_ASSERT(preset->valid());
 
     return preset;
 }
 
 KisPaintOpPresetSP KisPaintopBox::activePreset(const KoID& paintOp)
 {
     if (m_paintOpPresetMap[paintOp] == 0) {
         m_paintOpPresetMap[paintOp] = defaultPreset(paintOp);
     }
 
     return m_paintOpPresetMap[paintOp];
 }
 
 void KisPaintopBox::updateCompositeOp(QString compositeOpID)
 {
     if (!m_optionWidget) return;
     KisSignalsBlocker blocker(m_optionWidget);
 
     KisNodeSP node = m_resourceProvider->currentNode();
 
     if (node && node->paintDevice()) {
         if (!node->paintDevice()->colorSpace()->hasCompositeOp(compositeOpID))
             compositeOpID = KoCompositeOpRegistry::instance().getDefaultCompositeOp().id();
 
         {
             KisSignalsBlocker b1(m_cmbCompositeOp);
             m_cmbCompositeOp->selectCompositeOp(KoID(compositeOpID));
         }
         if (compositeOpID != m_currCompositeOpID) {
             m_currCompositeOpID = compositeOpID;
         }
         if (compositeOpID == COMPOSITE_ERASE || m_resourceProvider->eraserMode()) {
             m_eraseModeButton->setChecked(true);
         }
         else {
             m_eraseModeButton->setChecked(false);
         }
     }
 }
 
 void KisPaintopBox::setWidgetState(int flags)
 {
     if (flags & (ENABLE_COMPOSITEOP | DISABLE_COMPOSITEOP)) {
         m_cmbCompositeOp->setEnabled(flags & ENABLE_COMPOSITEOP);
         m_eraseModeButton->setEnabled(flags & ENABLE_COMPOSITEOP);
     }
 
     if (flags & (ENABLE_PRESETS | DISABLE_PRESETS)) {
         m_presetSelectorPopupButton->setEnabled(flags & ENABLE_PRESETS);
         m_brushEditorPopupButton->setEnabled(flags & ENABLE_PRESETS);
     }
 
     for (int i = 0; i < 3; ++i) {
         if (flags & (ENABLE_OPACITY | DISABLE_OPACITY))
             m_sliderChooser[i]->getWidget("opacity")->setEnabled(flags & ENABLE_OPACITY);
 
         if (flags & (ENABLE_FLOW | DISABLE_FLOW))
             m_sliderChooser[i]->getWidget("flow")->setEnabled(flags & ENABLE_FLOW);
 
         if (flags & (ENABLE_SIZE | DISABLE_SIZE))
             m_sliderChooser[i]->getWidget("size")->setEnabled(flags & ENABLE_SIZE);
     }
 }
 
 void KisPaintopBox::setSliderValue(const QString& sliderID, qreal value)
 {
     for (int i = 0; i < 3; ++i) {
         KisDoubleSliderSpinBox* slider = m_sliderChooser[i]->getWidget<KisDoubleSliderSpinBox>(sliderID);
         KisSignalsBlocker b(slider);
 
         if (sliderID == "opacity" || sliderID == "flow") { // opacity and flows UI stored at 0-100%
             slider->setValue(value*100);
         } else {
             slider->setValue(value); // brush size
         }
 
 
     }
 }
 
 void KisPaintopBox::slotSetPaintop(const QString& paintOpId)
 {
     if (KisPaintOpRegistry::instance()->get(paintOpId) != 0) {
         KoID id(paintOpId, KisPaintOpRegistry::instance()->get(paintOpId)->name());
         //qDebug() << "slotsetpaintop" << id;
         setCurrentPaintop(id);
     }
 }
 
 void KisPaintopBox::slotInputDeviceChanged(const KoInputDevice& inputDevice)
 {
     TabletToolMap::iterator toolData = m_tabletToolMap.find(inputDevice);
 
     //qDebug() << "slotInputDeviceChanged()" << inputDevice.device() << inputDevice.uniqueTabletId();
 
     m_currTabletToolID = TabletToolID(inputDevice);
 
     if (toolData == m_tabletToolMap.end()) {
         KisConfig cfg;
         KisPaintOpPresetResourceServer *rserver = KisResourceServerProvider::instance()->paintOpPresetServer();
         KisPaintOpPresetSP preset;
         if (inputDevice.pointer() == QTabletEvent::Eraser) {
             preset = rserver->resourceByName(cfg.readEntry<QString>(QString("LastEraser_%1").arg(inputDevice.uniqueTabletId()), m_eraserName));
         }
         else {
             preset = rserver->resourceByName(cfg.readEntry<QString>(QString("LastPreset_%1").arg(inputDevice.uniqueTabletId()), m_defaultPresetName));
             //if (preset)
                 //qDebug() << "found stored preset " << preset->name() << "for" << inputDevice.uniqueTabletId();
             //else
                 //qDebug() << "no preset found for" << inputDevice.uniqueTabletId();
         }
         if (!preset) {
             preset = rserver->resourceByName(m_defaultPresetName);
         }
         if (preset) {
             //qDebug() << "inputdevicechanged 1" << preset;
             setCurrentPaintop(preset);
         }
     }
     else {
         if (toolData->preset) {
             //qDebug() << "inputdevicechanged 2" << toolData->preset;
             setCurrentPaintop(toolData->preset);
         }
         else {
             //qDebug() << "inputdevicechanged 3" << toolData->paintOpID;
             setCurrentPaintop(toolData->paintOpID);
         }
     }
 }
 
 void KisPaintopBox::slotCreatePresetFromScratch(QString paintop)
 {
     //First try to select an available default preset for that engine. If it doesn't exist, then
     //manually set the engine to use a new preset.
     KoID id(paintop, KisPaintOpRegistry::instance()->get(paintop)->name());
     KisPaintOpPresetSP preset = defaultPreset(id);
 
     slotSetPaintop(paintop);  // change the paintop settings area and update the UI
 
     if (!preset) {
         m_presetsPopup->setCreatingBrushFromScratch(true); // disable UI elements while creating from scratch
         preset = m_resourceProvider->currentPreset();
     } else {
         m_resourceProvider->setPaintOpPreset(preset);
         preset->setOptionsWidget(m_optionWidget);
     }
     m_presetsPopup->resourceSelected(preset.data());  // this helps update the UI on the brush editor
 }
 
 void KisPaintopBox::slotCanvasResourceChanged(int key, const QVariant &value)
 {
     if (m_viewManager) {
         sender()->blockSignals(true);
         KisPaintOpPresetSP preset = m_viewManager->resourceProvider()->resourceManager()->resource(KisCanvasResourceProvider::CurrentPaintOpPreset).value<KisPaintOpPresetSP>();
         if (preset && m_resourceProvider->currentPreset()->name() != preset->name()) {
             QString compositeOp = preset->settings()->getString("CompositeOp");
             updateCompositeOp(compositeOp);
             resourceSelected(preset.data());
         }
 
         /**
          * Update currently selected preset in both the popup widgets
          */
         m_presetsChooserPopup->canvasResourceChanged(preset);
 
         m_presetsPopup->currentPresetChanged(preset);
 
         if (key == KisCanvasResourceProvider::CurrentCompositeOp) {
             if (m_resourceProvider->currentCompositeOp() != m_currCompositeOpID) {
                 updateCompositeOp(m_resourceProvider->currentCompositeOp());
             }
         }
 
         if (key == KisCanvasResourceProvider::Size) {
             setSliderValue("size", m_resourceProvider->size());
         }
 
         if (key == KisCanvasResourceProvider::Opacity) {
             setSliderValue("opacity", m_resourceProvider->opacity());
         }
 
         if (key == KisCanvasResourceProvider::Flow) {
             setSliderValue("flow", m_resourceProvider->flow());
         }
 
         if (key == KisCanvasResourceProvider::EraserMode) {
             m_eraseAction->setChecked(value.toBool());
         }
 
         if (key == KisCanvasResourceProvider::DisablePressure) {
             m_disablePressureAction->setChecked(value.toBool());
         }
 
         sender()->blockSignals(false);
     }
 }
 
 void KisPaintopBox::slotUpdatePreset()
 {
     if (!m_resourceProvider->currentPreset()) return;
 
     // block updates of avoid some over updating of the option widget
     m_blockUpdate = true;
 
     setSliderValue("size", m_resourceProvider->size());
 
     {
         qreal opacity = m_resourceProvider->currentPreset()->settings()->paintOpOpacity();
         m_resourceProvider->setOpacity(opacity);
         setSliderValue("opacity", opacity);
         setWidgetState(ENABLE_OPACITY);
     }
 
     {
         setSliderValue("flow", m_resourceProvider->currentPreset()->settings()->paintOpFlow());
         setWidgetState(ENABLE_FLOW);
     }
 
     {
         updateCompositeOp(m_resourceProvider->currentPreset()->settings()->paintOpCompositeOp());
         setWidgetState(ENABLE_COMPOSITEOP);
     }
 
     m_blockUpdate = false;
 }
 
 void KisPaintopBox::slotSetupDefaultPreset()
 {
     KisPaintOpPresetSP preset = defaultPreset(m_resourceProvider->currentPreset()->paintOp());
     preset->setOptionsWidget(m_optionWidget);
     m_resourceProvider->setPaintOpPreset(preset);
 
     // tell the brush editor that the resource has changed
     // so it can update everything
     m_presetsPopup->resourceSelected(preset.data());
 }
 
 void KisPaintopBox::slotNodeChanged(const KisNodeSP node)
 {
     if (m_previousNode.isValid() && m_previousNode->paintDevice())
         disconnect(m_previousNode->paintDevice().data(), SIGNAL(colorSpaceChanged(const KoColorSpace*)), this, SLOT(slotColorSpaceChanged(const KoColorSpace*)));
 
     // Reconnect colorspace change of node
     if (node && node->paintDevice()) {
         connect(node->paintDevice().data(), SIGNAL(colorSpaceChanged(const KoColorSpace*)), this, SLOT(slotColorSpaceChanged(const KoColorSpace*)));
         m_resourceProvider->setCurrentCompositeOp(m_currCompositeOpID);
         m_previousNode = node;
         slotColorSpaceChanged(node->colorSpace());
     }
 
     if (m_optionWidget) {
         m_optionWidget->setNode(node);
     }
 }
 
 void KisPaintopBox::slotColorSpaceChanged(const KoColorSpace* colorSpace)
 {
     m_cmbCompositeOp->validate(colorSpace);
 }
 
 void KisPaintopBox::slotToggleEraseMode(bool checked)
 {
     const bool oldEraserMode = m_resourceProvider->eraserMode();
     m_resourceProvider->setEraserMode(checked);
 
     if (oldEraserMode != checked && m_eraserBrushSizeEnabled) {
         const qreal currentSize = m_resourceProvider->size();
 
         KisPaintOpSettingsSP settings = m_resourceProvider->currentPreset()->settings();
 
         // remember brush size. set the eraser size to the normal brush size if not set
         if (checked) {
             settings->setSavedBrushSize(currentSize);
             if (qFuzzyIsNull(settings->savedEraserSize())) {
                 settings->setSavedEraserSize(currentSize);
             }
         } else {
             settings->setSavedEraserSize(currentSize);
             if (qFuzzyIsNull(settings->savedBrushSize())) {
                 settings->setSavedBrushSize(currentSize);
             }
         }
 
         //update value in UI (this is the main place the value is 'stored' in memory)
         qreal newSize = checked ? settings->savedEraserSize() : settings->savedBrushSize();
         m_resourceProvider->setSize(newSize);
     }
    if (oldEraserMode != checked && m_eraserBrushOpacityEnabled) {
         const qreal currentOpacity = m_resourceProvider->opacity();
 
         KisPaintOpSettingsSP settings = m_resourceProvider->currentPreset()->settings();
 
         // remember brush opacity. set the eraser opacity to the normal brush opacity if not set
         if (checked) {
             settings->setSavedBrushOpacity(currentOpacity);
             if (qFuzzyIsNull(settings->savedEraserOpacity())) {
                 settings->setSavedEraserOpacity(currentOpacity);
             }
         } else {
             settings->setSavedEraserOpacity(currentOpacity);
             if (qFuzzyIsNull(settings->savedBrushOpacity())) {
                 settings->setSavedBrushOpacity(currentOpacity);
             }
         }
 
         //update value in UI (this is the main place the value is 'stored' in memory)
         qreal newOpacity = checked ? settings->savedEraserOpacity() : settings->savedBrushOpacity();
         m_resourceProvider->setOpacity(newOpacity);
     }
 }
 
 void KisPaintopBox::slotSetCompositeMode(int index)
 {
     Q_UNUSED(index);
     QString compositeOp = m_cmbCompositeOp->selectedCompositeOp().id();
     m_resourceProvider->setCurrentCompositeOp(compositeOp);
 }
 
 void KisPaintopBox::slotHorizontalMirrorChanged(bool value)
 {
     m_resourceProvider->setMirrorHorizontal(value);
 }
 
 void KisPaintopBox::slotVerticalMirrorChanged(bool value)
 {
     m_resourceProvider->setMirrorVertical(value);
 }
 
 void KisPaintopBox::sliderChanged(int n)
 {
     if (!m_optionWidget) // widget will not exist if the are no documents open
         return;
 
 
     KisSignalsBlocker blocker(m_optionWidget);
 
     // flow and opacity are shown as 0-100% on the UI, but their data is actually 0-1. Convert those two values
     // back for further work
     qreal opacity = m_sliderChooser[n]->getWidget<KisDoubleSliderSpinBox>("opacity")->value()/100;
     qreal flow    = m_sliderChooser[n]->getWidget<KisDoubleSliderSpinBox>("flow")->value()/100;
     qreal size    = m_sliderChooser[n]->getWidget<KisDoubleSliderSpinBox>("size")->value();
 
 
     setSliderValue("opacity", opacity);
     setSliderValue("flow"   , flow);
     setSliderValue("size"   , size);
 
     if (m_presetsEnabled) {
         // IMPORTANT: set the PaintOp size before setting the other properties
         //            it wont work the other way
         // TODO: why?!
 
         m_resourceProvider->setSize(size);
         m_resourceProvider->setOpacity(opacity);
         m_resourceProvider->setFlow(flow);
 
 
         KisLockedPropertiesProxySP propertiesProxy = KisLockedPropertiesServer::instance()->createLockedPropertiesProxy(m_resourceProvider->currentPreset()->settings());
         propertiesProxy->setProperty("OpacityValue", opacity);
         propertiesProxy->setProperty("FlowValue", flow);
         m_optionWidget->setConfigurationSafe(m_resourceProvider->currentPreset()->settings().data());
     } else {
         m_resourceProvider->setOpacity(opacity);
     }
 
     m_presetsPopup->resourceSelected(m_resourceProvider->currentPreset().data());
 }
 
 void KisPaintopBox::slotSlider1Changed()
 {
     sliderChanged(0);
 }
 
 void KisPaintopBox::slotSlider2Changed()
 {
     sliderChanged(1);
 }
 
 void KisPaintopBox::slotSlider3Changed()
 {
     sliderChanged(2);
 }
 
 void KisPaintopBox::slotToolChanged(KoCanvasController* canvas, int toolId)
 {
     Q_UNUSED(canvas);
     Q_UNUSED(toolId);
 
     if (!m_viewManager->canvasBase()) return;
 
     QString  id   = KoToolManager::instance()->activeToolId();
     KisTool* tool = dynamic_cast<KisTool*>(KoToolManager::instance()->toolById(m_viewManager->canvasBase(), id));
 
     if (tool) {
         int flags = tool->flags();
 
         if (flags & KisTool::FLAG_USES_CUSTOM_COMPOSITEOP) {
             setWidgetState(ENABLE_COMPOSITEOP | ENABLE_OPACITY);
         } else                                              {
             setWidgetState(DISABLE_COMPOSITEOP | DISABLE_OPACITY);
         }
 
         if (flags & KisTool::FLAG_USES_CUSTOM_PRESET) {
             setWidgetState(ENABLE_PRESETS);
             slotUpdatePreset();
             m_presetsEnabled = true;
         } else {
             setWidgetState(DISABLE_PRESETS);
             m_presetsEnabled = false;
         }
 
         if (flags & KisTool::FLAG_USES_CUSTOM_SIZE) {
             setWidgetState(ENABLE_SIZE | ENABLE_FLOW);
         } else {
             setWidgetState(DISABLE_SIZE | DISABLE_FLOW);
         }
 
     } else setWidgetState(DISABLE_ALL);
 }
 
 void KisPaintopBox::slotPreviousFavoritePreset()
 {
     if (!m_favoriteResourceManager) return;
 
     QVector<KisPaintOpPresetSP> presets = m_favoriteResourceManager->favoritePresetList();
     for (int i=0; i < presets.size(); ++i) {
         if (m_resourceProvider->currentPreset() &&
                 m_resourceProvider->currentPreset()->name() == presets[i]->name()) {
             if (i > 0) {
                 m_favoriteResourceManager->slotChangeActivePaintop(i - 1);
             } else {
                 m_favoriteResourceManager->slotChangeActivePaintop(m_favoriteResourceManager->numFavoritePresets() - 1);
             }
             //floating message should have least 2 lines, otherwise
             //preset thumbnail will be too small to distinguish
             //(because size of image on floating message depends on amount of lines in msg)
             m_viewManager->showFloatingMessage(
                 i18n("%1\nselected",
                         m_resourceProvider->currentPreset()->name()),
                 QIcon(QPixmap::fromImage(m_resourceProvider->currentPreset()->image())));
 
             return;
         }
     }
 }
 
 void KisPaintopBox::slotNextFavoritePreset()
 {
     if (!m_favoriteResourceManager) return;
 
     QVector<KisPaintOpPresetSP> presets = m_favoriteResourceManager->favoritePresetList();
     for(int i = 0; i < presets.size(); ++i) {
         if (m_resourceProvider->currentPreset()->name() == presets[i]->name()) {
             if (i < m_favoriteResourceManager->numFavoritePresets() - 1) {
                 m_favoriteResourceManager->slotChangeActivePaintop(i + 1);
             } else {
                 m_favoriteResourceManager->slotChangeActivePaintop(0);
             }
             m_viewManager->showFloatingMessage(
                 i18n("%1\nselected",
                         m_resourceProvider->currentPreset()->name()),
                 QIcon(QPixmap::fromImage(m_resourceProvider->currentPreset()->image())));
 
             return;
         }
     }
 }
 
 void KisPaintopBox::slotSwitchToPreviousPreset()
 {
     if (m_resourceProvider->previousPreset()) {
         //qDebug() << "slotSwitchToPreviousPreset();" << m_resourceProvider->previousPreset();
         setCurrentPaintop(m_resourceProvider->previousPreset());
         m_viewManager->showFloatingMessage(
                 i18n("%1\nselected",
                         m_resourceProvider->currentPreset()->name()),
             QIcon(QPixmap::fromImage(m_resourceProvider->currentPreset()->image())));
     }
 }
 
 void KisPaintopBox::slotUnsetEraseMode()
 {
     m_eraseAction->setChecked(false);
 }
 
 void KisPaintopBox::slotToggleAlphaLockMode(bool checked)
 {
     if (checked) {
         m_alphaLockButton->actions()[0]->setIcon(KisIconUtils::loadIcon("transparency-locked"));
     } else {
         m_alphaLockButton->actions()[0]->setIcon(KisIconUtils::loadIcon("transparency-unlocked"));
     }
     m_resourceProvider->setGlobalAlphaLock(checked);
 }
 
 void KisPaintopBox::slotDisablePressureMode(bool checked)
 {
     if (checked) {
         m_disablePressureAction->setIcon(KisIconUtils::loadIcon("transform_icons_penPressure"));
     } else {
         m_disablePressureAction->setIcon(KisIconUtils::loadIcon("transform_icons_penPressure_locked"));
     }
 
     m_resourceProvider->setDisablePressure(checked);
 }
 
 void KisPaintopBox::slotReloadPreset()
 {
     KisSignalsBlocker blocker(m_optionWidget);
 
     //Here using the name and fetching the preset from the server was the only way the load was working. Otherwise it was not loading.
     KisPaintOpPresetResourceServer * rserver = KisResourceServerProvider::instance()->paintOpPresetServer();
     KisPaintOpPresetSP preset = rserver->resourceByName(m_resourceProvider->currentPreset()->name());
     if (preset) {
         preset->load();
     }
 }
 void KisPaintopBox::slotGuiChangedCurrentPreset() // Called only when UI is changed and not when preset is changed
 {
     KisPaintOpPresetSP preset = m_resourceProvider->currentPreset();
 
     {
         /**
          * Here we postpone all the settings updates events until the entire writing
          * operation will be finished. As soon as it is finished, the updates will be
          * emitted happily (if there were any).
          */
 
         KisPaintOpPreset::UpdatedPostponer postponer(preset.data());
 
 
         QStringList preserveProperties;
         preserveProperties << "lodUserAllowed";
         preserveProperties << "lodSizeThreshold";
 
         // clear all the properties before dumping the stuff into the preset,
         // some of the options add the values incrementally
         // (e.g. KisPaintOpUtils::RequiredBrushFilesListTag), therefore they
         // may add up if we pass the same preset multiple times
         preset->settings()->resetSettings(preserveProperties);
 
         m_optionWidget->writeConfigurationSafe(const_cast<KisPaintOpSettings*>(preset->settings().data()));
     }
 
     // we should also update the preset strip to update the status of the "dirty" mark
     m_presetsPopup->resourceSelected(m_resourceProvider->currentPreset().data());
 
     // TODO!!!!!!!!
     //m_presetsPopup->updateViewSettings();
 }
 void KisPaintopBox::slotSaveLockedOptionToPreset(KisPropertiesConfigurationSP p)
 {
 
     QMapIterator<QString, QVariant> i(p->getProperties());
     while (i.hasNext()) {
         i.next();
         m_resourceProvider->currentPreset()->settings()->setProperty(i.key(), QVariant(i.value()));
         if (m_resourceProvider->currentPreset()->settings()->hasProperty(i.key() + "_previous")) {
             m_resourceProvider->currentPreset()->settings()->removeProperty(i.key() + "_previous");
         }
 
     }
     slotGuiChangedCurrentPreset();
 
 }
 
 void KisPaintopBox::slotDropLockedOption(KisPropertiesConfigurationSP p)
 {
     KisSignalsBlocker blocker(m_optionWidget);
     KisPaintOpPresetSP preset = m_resourceProvider->currentPreset();
 
     {
         KisPaintOpPreset::DirtyStateSaver dirtySaver(preset.data());
 
         QMapIterator<QString, QVariant> i(p->getProperties());
         while (i.hasNext()) {
             i.next();
             if (preset->settings()->hasProperty(i.key() + "_previous")) {
                 preset->settings()->setProperty(i.key(), preset->settings()->getProperty(i.key() + "_previous"));
                 preset->settings()->removeProperty(i.key() + "_previous");
             }
 
         }
     }
 
     //slotUpdatePreset();
 }
 void KisPaintopBox::slotDirtyPresetToggled(bool value)
 {
     if (!value) {
         slotReloadPreset();
         m_presetsPopup->resourceSelected(m_resourceProvider->currentPreset().data());
         m_presetsPopup->updateViewSettings();
     }
     m_dirtyPresetsEnabled = value;
     KisConfig cfg;
     cfg.setUseDirtyPresets(m_dirtyPresetsEnabled);
 
 }
 void KisPaintopBox::slotEraserBrushSizeToggled(bool value)
 {
     m_eraserBrushSizeEnabled = value;
     KisConfig cfg;
     cfg.setUseEraserBrushSize(m_eraserBrushSizeEnabled);
 }
 
 void KisPaintopBox::slotEraserBrushOpacityToggled(bool value)
 {
     m_eraserBrushOpacityEnabled = value;
     KisConfig cfg;
     cfg.setUseEraserBrushOpacity(m_eraserBrushOpacityEnabled);
 }
 
 void KisPaintopBox::slotUpdateSelectionIcon()
 {
     m_hMirrorAction->setIcon(KisIconUtils::loadIcon("symmetry-horizontal"));
     m_vMirrorAction->setIcon(KisIconUtils::loadIcon("symmetry-vertical"));
 
     KisConfig cfg;
     if (!cfg.toolOptionsInDocker() && m_toolOptionsPopupButton) {
         m_toolOptionsPopupButton->setIcon(KisIconUtils::loadIcon("configure"));
     }
 
     m_presetSelectorPopupButton->setIcon(KisIconUtils::loadIcon("paintop_settings_01"));
     m_brushEditorPopupButton->setIcon(KisIconUtils::loadIcon("paintop_settings_02"));
     m_workspaceWidget->setIcon(KisIconUtils::loadIcon("view-choose"));
 
     m_eraseAction->setIcon(KisIconUtils::loadIcon("draw-eraser"));
     m_reloadAction->setIcon(KisIconUtils::loadIcon("view-refresh"));
 
     if (m_disablePressureAction->isChecked()) {
         m_disablePressureAction->setIcon(KisIconUtils::loadIcon("transform_icons_penPressure"));
     } else {
         m_disablePressureAction->setIcon(KisIconUtils::loadIcon("transform_icons_penPressure_locked"));
     }
 }
 
 void KisPaintopBox::slotLockXMirrorToggle(bool toggleLock) {
     m_resourceProvider->setMirrorHorizontalLock(toggleLock);
 }
 
 void KisPaintopBox::slotLockYMirrorToggle(bool toggleLock) {
     m_resourceProvider->setMirrorVerticalLock(toggleLock);
 }
 
 void KisPaintopBox::slotHideDecorationMirrorX(bool toggled) {
     m_resourceProvider->setMirrorHorizontalHideDecorations(toggled);
 }
 
 void KisPaintopBox::slotHideDecorationMirrorY(bool toggled) {
     m_resourceProvider->setMirrorVerticalHideDecorations(toggled);
 }
 
 void KisPaintopBox::slotMoveToCenterMirrorX() {
   m_resourceProvider->mirrorHorizontalMoveCanvasToCenter();
 }
 
 void KisPaintopBox::slotMoveToCenterMirrorY() {
   m_resourceProvider->mirrorVerticalMoveCanvasToCenter();
 }
diff --git a/libs/ui/widgets/KisLayoutSelector.cpp b/libs/ui/widgets/KisLayoutSelector.cpp
deleted file mode 100644
index 283e920a01..0000000000
--- a/libs/ui/widgets/KisLayoutSelector.cpp
+++ /dev/null
@@ -1,97 +0,0 @@
-/*
- *  Copyright (c) 2018 Jouni Pentikäinen <joupent@gmail.com>
- *
- *  This program is free software; you can redistribute it and/or modify
- *  it under the terms of the GNU General Public License as published by
- *  the Free Software Foundation; either version 2 of the License, or
- *  (at your option) any later version.
- *
- *  This program is distributed in the hope that it will be useful,
- *  but WITHOUT ANY WARRANTY; without even the implied warranty of
- *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- *  GNU General Public License for more details.
- *
- *  You should have received a copy of the GNU General Public License
- *  along with this program; if not, write to the Free Software
- *  Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
- */
-
-#include <KisWindowLayoutResource.h>
-#include <KisResourceServerProvider.h>
-#include <KisWindowLayoutManager.h>
-#include "KisLayoutSelector.h"
-#include "KisSessionResource.h"
-
-struct KisLayoutSelector::Private {
-    enum ItemTypes {
-        WindowLayout,
-        Session
-    };
-
-    KoResourceServer<KisWindowLayoutResource> * windowLayoutServer;
-    KoResourceServer<KisSessionResource> * sessionServer;
-
-    bool blockChange = false;
-};
-
-KisLayoutSelector::KisLayoutSelector(QWidget *parent)
-    : QComboBox(parent)
-    , d(new Private)
-{
-    d->windowLayoutServer = KisResourceServerProvider::instance()->windowLayoutServer();
-    d->sessionServer = KisResourceServerProvider::instance()->sessionServer();
-
-    connect(this, SIGNAL(activated(int)), this, SLOT(slotItemChanged(int)));
-
-    updateItems();
-}
-
-KisLayoutSelector::~KisLayoutSelector() {}
-
-void KisLayoutSelector::updateItems() {
-    d->blockChange = true;
-
-    clear();
-
-    Q_FOREACH(KisWindowLayoutResource *windowLayout, d->windowLayoutServer->resources()) {
-        addItem(windowLayout->name(), Private::WindowLayout);
-    }
-
-    Q_FOREACH(KisSessionResource *session, d->sessionServer->resources()) {
-        addItem(session->name(), Private::Session);
-    }
-
-    const QString &lastLayout = KisWindowLayoutManager::instance()->lastLayoutName();
-    if (!lastLayout.isEmpty()) {
-        int index = findText(lastLayout);
-        if (index >=0) setCurrentIndex(index);
-    }
-
-    d->blockChange = false;
-}
-
-void KisLayoutSelector::slotItemChanged(int index)
-{
-    if (index < 0) return;
-    if (d->blockChange) return;
-
-    const QString name = itemText(index);
-
-    switch (currentData(Qt::UserRole).toInt()) {
-        case Private::WindowLayout: {
-            KisWindowLayoutResource *windowLayout = d->windowLayoutServer->resourceByName(name);
-            if (windowLayout) {
-                windowLayout->applyLayout();
-            }
-        } break;
-        case Private::Session: {
-            KisSessionResource *session = d->sessionServer->resourceByName(name);
-            if (session) {
-                session->restore();
-            }
-        } break;
-        default:
-            qDebug() << "Unexpected item type in KisLayoutSelector.";
-            break;
-    }
-}
diff --git a/libs/ui/widgets/KisLayoutSelector.h b/libs/ui/widgets/KisLayoutSelector.h
deleted file mode 100644
index 5f27a7ed10..0000000000
--- a/libs/ui/widgets/KisLayoutSelector.h
+++ /dev/null
@@ -1,42 +0,0 @@
-/*
- *  Copyright (c) 2018 Jouni Pentikäinen <joupent@gmail.com>
- *
- *  This program is free software; you can redistribute it and/or modify
- *  it under the terms of the GNU General Public License as published by
- *  the Free Software Foundation; either version 2 of the License, or
- *  (at your option) any later version.
- *
- *  This program is distributed in the hope that it will be useful,
- *  but WITHOUT ANY WARRANTY; without even the implied warranty of
- *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- *  GNU General Public License for more details.
- *
- *  You should have received a copy of the GNU General Public License
- *  along with this program; if not, write to the Free Software
- *  Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
- */
-
-#ifndef KISLAYOUTSELECTOR_H
-#define KISLAYOUTSELECTOR_H
-
-#include <QComboBox>
-
-class KisLayoutSelector : public QComboBox
-{
-    Q_OBJECT
-
-public:
-    KisLayoutSelector(QWidget *parent = 0);
-    ~KisLayoutSelector();
-
-private Q_SLOTS:
-    void slotItemChanged(int);
-
-private:
-    void updateItems();
-
-    struct Private;
-    QScopedPointer<Private> d;
-};
-
-#endif
diff --git a/plugins/dockers/CMakeLists.txt b/plugins/dockers/CMakeLists.txt
index 252a364d00..d9cd652821 100644
--- a/plugins/dockers/CMakeLists.txt
+++ b/plugins/dockers/CMakeLists.txt
@@ -1,33 +1,32 @@
 add_subdirectory(defaultdockers)
 add_subdirectory(smallcolorselector)
 add_subdirectory(specificcolorselector)
 add_subdirectory(digitalmixer)
 add_subdirectory(advancedcolorselector)
 add_subdirectory(presetdocker)
 add_subdirectory(historydocker)
 add_subdirectory(channeldocker)
 add_subdirectory(artisticcolorselector)
 add_subdirectory(tasksetdocker)
 add_subdirectory(compositiondocker)
 add_subdirectory(patterndocker)
 add_subdirectory(griddocker)
 add_subdirectory(arrangedocker)
 if(HAVE_OCIO)
     add_subdirectory(lut)
 endif()
 add_subdirectory(overview)
 add_subdirectory(palettedocker)
 add_subdirectory(colorslider)
 add_subdirectory(animation)
 add_subdirectory(presethistory)
 add_subdirectory(svgcollectiondocker)
 add_subdirectory(histogram)
-add_subdirectory(pager)
 if(HAVE_QT_QUICK)
     add_subdirectory(touchdocker)
     option(ENABLE_CPU_THROTTLE "Build the CPU Throttle Docker" OFF)
     if (ENABLE_CPU_THROTTLE)
         add_subdirectory(throttle)
     endif()
 endif()
 
diff --git a/plugins/dockers/pager/CMakeLists.txt b/plugins/dockers/pager/CMakeLists.txt
deleted file mode 100644
index bed0953f45..0000000000
--- a/plugins/dockers/pager/CMakeLists.txt
+++ /dev/null
@@ -1,4 +0,0 @@
-set(KRITA_PAGERDOCKER_SOURCES PagerDockerPlugin.cpp PagerDockerDock.cpp)
-add_library(kritapagerdocker MODULE ${KRITA_PAGERDOCKER_SOURCES})
-target_link_libraries(kritapagerdocker kritaui)
-install(TARGETS kritapagerdocker  DESTINATION ${KRITA_PLUGIN_INSTALL_DIR})
diff --git a/plugins/dockers/pager/PagerDockerDock.cpp b/plugins/dockers/pager/PagerDockerDock.cpp
deleted file mode 100644
index cfe1693a35..0000000000
--- a/plugins/dockers/pager/PagerDockerDock.cpp
+++ /dev/null
@@ -1,163 +0,0 @@
-/*
- *  Copyright (c) 2018 Jouni Pentikäinen <joupent@gmail.com>
- *
- *  This program is free software; you can redistribute it and/or modify
- *  it under the terms of the GNU General Public License as published by
- *  the Free Software Foundation; either version 2 of the License, or
- *  (at your option) any later version.
- *
- *  This program is distributed in the hope that it will be useful,
- *  but WITHOUT ANY WARRANTY; without even the implied warranty of
- *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- *  GNU General Public License for more details.
- *
- *  You should have received a copy of the GNU General Public License
- *  along with this program; if not, write to the Free Software
- *  Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
- */
-
-#include "PagerDockerDock.h"
-
-#include <QHBoxLayout>
-#include <QPushButton>
-#include <QDir>
-#include <kis_canvas2.h>
-#include <KisDocument.h>
-#include <KisPart.h>
-#include <QtWidgets/QtWidgets>
-
-PagerDockerDock::PagerDockerDock()
-    : QDockWidget(i18n("Pager"))
-{
-    auto *widget = new QWidget(this);
-    setWidget(widget);
-
-    auto *layout = new QHBoxLayout(widget);
-    widget->setLayout(layout);
-
-    auto *nextButton = new QPushButton(">>", widget);
-    auto *previousButton = new QPushButton("<<", widget);
-
-    layout->addWidget(previousButton);
-    layout->addWidget(nextButton);
-
-    connect(nextButton, SIGNAL(clicked()), this, SLOT(slotNextPage()));
-    connect(previousButton, SIGNAL(clicked()), this, SLOT(slotPreviousPage()));
-}
-
-PagerDockerDock::~PagerDockerDock() {}
-
-void PagerDockerDock::setCanvas(KoCanvasBase *canvas)
-{
-    m_canvas = qobject_cast<KisCanvas2*>(canvas);
-}
-void PagerDockerDock::unsetCanvas()
-{
-    m_canvas = nullptr;
-}
-
-void PagerDockerDock::slotNextPage()
-{
-    flipPage(true);
-}
-
-void PagerDockerDock::slotPreviousPage()
-{
-    flipPage(false);
-}
-
-void PagerDockerDock::flipPage(bool forward)
-{
-    if (!m_canvas) return;
-
-    KisDocument *activeDocument = m_canvas->imageView()->document();
-
-    QUrl url = activeDocument->url();
-    if (url.isEmpty() || !url.isLocalFile()) return;
-    QFileInfo fileInfo(url.toLocalFile());
-    QDir directory = fileInfo.absoluteDir();
-
-    QStringList openSiblingFiles = getOpenFilesInDirectory(directory.path());
-    QStringList allSiblingFiles = getKraFilesInDirectory(directory);
-
-    int step = chooseStepSize(fileInfo.fileName(), openSiblingFiles, allSiblingFiles, forward);
-    if (step == 0) return;
-
-    pageViews(directory, allSiblingFiles, step);
-}
-
-QStringList PagerDockerDock::getOpenFilesInDirectory(const QString &path)
-{
-    QStringList openSiblingFiles;
-    Q_FOREACH(KisDocument *document, KisPart::instance()->documents()) {
-        if (!document->url().isLocalFile()) continue;
-
-        QFileInfo docFile(document->url().toLocalFile());
-        if (docFile.absoluteDir() == path) {
-            openSiblingFiles.append(docFile.fileName());
-        }
-    }
-
-    return openSiblingFiles;
-}
-
-QStringList PagerDockerDock::getKraFilesInDirectory(QDir directory)
-{
-    directory.setNameFilters({"*.kra"});
-    directory.setFilter(QDir::Files);
-    directory.setSorting(QDir::Name | QDir::IgnoreCase);
-    return directory.entryList();
-}
-
-int PagerDockerDock::chooseStepSize(const QString &baseFile,
-                                    const QStringList &openSiblingFiles, const QStringList &allSiblingFiles, bool forward) const
-{
-    int baseIndex = allSiblingFiles.indexOf(baseFile);
-    if (baseIndex < 0) return 0;
-
-    int step = 1;
-    while (baseIndex > 0 && openSiblingFiles.contains(allSiblingFiles[baseIndex - 1])) {
-        baseIndex--;
-    }
-
-    while (baseIndex + step < allSiblingFiles.count() && openSiblingFiles.contains(allSiblingFiles[baseIndex + step])) {
-        step++;
-    }
-
-    return forward ? step : -step;
-}
-
-void PagerDockerDock::pageViews(const QDir &directory, const QStringList &allSiblingFiles, int step) const
-{
-    QList<QPointer<KisView>> views = KisPart::instance()->views();
-
-    Q_FOREACH(KisView *view, views) {
-        QString newFilename = getSteppedFilename(view->document(), directory, allSiblingFiles, step);
-        if (!newFilename.isEmpty()) {
-            if (!view->queryClose()) return;
-        }
-    }
-
-    Q_FOREACH(KisView *view, views) {
-        QString newFilename = getSteppedFilename(view->document(), directory, allSiblingFiles, step);
-        if (newFilename.isEmpty()) continue;
-
-        view->mainWindow()->openDocument(QUrl::fromLocalFile(newFilename), KisMainWindow::None);
-        view->closeView();
-    }
-}
-
-QString PagerDockerDock::getSteppedFilename(const KisDocument *document, const QDir &directory,
-                                             const QStringList &allSiblingFiles, int step) const
-{
-    QFileInfo file(document->url().toLocalFile());
-    if (file.absoluteDir() != directory.path()) return QString();
-
-    int index = allSiblingFiles.indexOf(file.fileName());
-    if (index < 0) return QString();
-
-    int newIndex = index + step;
-    if (newIndex < 0 || newIndex >= allSiblingFiles.size()) return QString();
-
-    return directory.filePath(allSiblingFiles[newIndex]);
-}
diff --git a/plugins/dockers/pager/PagerDockerDock.h b/plugins/dockers/pager/PagerDockerDock.h
deleted file mode 100644
index 07bd3f8fea..0000000000
--- a/plugins/dockers/pager/PagerDockerDock.h
+++ /dev/null
@@ -1,61 +0,0 @@
-/*
- *  Copyright (c) 2018 Jouni Pentikäinen <joupent@gmail.com>
- *
- *  This program is free software; you can redistribute it and/or modify
- *  it under the terms of the GNU General Public License as published by
- *  the Free Software Foundation; either version 2 of the License, or
- *  (at your option) any later version.
- *
- *  This program is distributed in the hope that it will be useful,
- *  but WITHOUT ANY WARRANTY; without even the implied warranty of
- *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- *  GNU General Public License for more details.
- *
- *  You should have received a copy of the GNU General Public License
- *  along with this program; if not, write to the Free Software
- *  Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
- */
-
-#ifndef PAGERDOCKERDOCK_H
-#define PAGERDOCKERDOCK_H
-
-#include <QObject>
-#include <QDir>
-#include <QString>
-#include <QDockWidget>
-
-#include <KoCanvasObserverBase.h>
-
-class KisDocument;
-class KisCanvas2;
-
-class PagerDockerDock : public QDockWidget, public KoCanvasObserverBase
-{
-    Q_OBJECT
-
-public:
-    PagerDockerDock();
-    ~PagerDockerDock() override;
-
-    QString observerName() override { return "PagerDockerDock"; }
-
-protected:
-    void setCanvas(KoCanvasBase *canvas) override;
-    void unsetCanvas() override;
-
-private Q_SLOTS:
-    void slotNextPage();
-    void slotPreviousPage();
-
-private:
-    void flipPage(bool forward);
-    QStringList getOpenFilesInDirectory(const QString &path);
-    QStringList getKraFilesInDirectory(QDir directory);
-    int chooseStepSize(const QString &baseFile, const QStringList &openSiblingFiles, const QStringList &allSiblingFiles, bool forward) const;
-    void pageViews(const QDir &directory, const QStringList &allSiblingFiles, int step) const;
-    QString getSteppedFilename(const KisDocument *document, const QDir &directory, const QStringList &allSiblingFiles, int step) const;
-
-    KisCanvas2 *m_canvas;
-};
-
-#endif
diff --git a/plugins/dockers/pager/PagerDockerPlugin.cpp b/plugins/dockers/pager/PagerDockerPlugin.cpp
deleted file mode 100644
index 98d270e9aa..0000000000
--- a/plugins/dockers/pager/PagerDockerPlugin.cpp
+++ /dev/null
@@ -1,69 +0,0 @@
-/*
- *  Copyright (c) 2018 Jouni Pentikäinen <joupent@gmail.com>
- *
- *  This program is free software; you can redistribute it and/or modify
- *  it under the terms of the GNU General Public License as published by
- *  the Free Software Foundation; either version 2 of the License, or
- *  (at your option) any later version.
- *
- *  This program is distributed in the hope that it will be useful,
- *  but WITHOUT ANY WARRANTY; without even the implied warranty of
- *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- *  GNU General Public License for more details.
- *
- *  You should have received a copy of the GNU General Public License
- *  along with this program; if not, write to the Free Software
- *  Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
- */
-
-#include "PagerDockerPlugin.h"
-
-#include <kpluginfactory.h>
-#include <KoDockFactoryBase.h>
-#include <KoDockRegistry.h>
-
-#include "PagerDockerDock.h"
-
-K_PLUGIN_FACTORY_WITH_JSON(PagerDockerPluginFactory, "krita_pagerdocker.json", registerPlugin<PagerDockerPlugin>();)
-
-class PagerDockerDockFactory : public KoDockFactoryBase {
-public:
-    PagerDockerDockFactory()
-    {}
-
-    ~PagerDockerDockFactory() override {}
-
-    QString id() const override
-    {
-        return QString( "PagerDocker" );
-    }
-
-    virtual Qt::DockWidgetArea defaultDockWidgetArea() const
-    {
-        return Qt::RightDockWidgetArea;
-    }
-
-    QDockWidget* createDockWidget() override
-    {
-        PagerDockerDock * dockWidget = new PagerDockerDock();
-        dockWidget->setObjectName(id());
-
-        return dockWidget;
-    }
-
-    DockPosition defaultDockPosition() const override
-    {
-        return DockMinimized;
-    }
-};
-
-PagerDockerPlugin::PagerDockerPlugin(QObject *parent, const QVariantList &)
-    : QObject(parent)
-{
-    KoDockRegistry::instance()->add(new PagerDockerDockFactory());
-}
-
-PagerDockerPlugin::~PagerDockerPlugin()
-{}
-
-#include "PagerDockerPlugin.moc"
diff --git a/plugins/dockers/pager/PagerDockerPlugin.h b/plugins/dockers/pager/PagerDockerPlugin.h
deleted file mode 100644
index 935bba6b33..0000000000
--- a/plugins/dockers/pager/PagerDockerPlugin.h
+++ /dev/null
@@ -1,31 +0,0 @@
-/*
- *  Copyright (c) 2018 Jouni Pentikäinen <joupent@gmail.com>
- *
- *  This program is free software; you can redistribute it and/or modify
- *  it under the terms of the GNU General Public License as published by
- *  the Free Software Foundation; either version 2 of the License, or
- *  (at your option) any later version.
- *
- *  This program is distributed in the hope that it will be useful,
- *  but WITHOUT ANY WARRANTY; without even the implied warranty of
- *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- *  GNU General Public License for more details.
- *
- *  You should have received a copy of the GNU General Public License
- *  along with this program; if not, write to the Free Software
- *  Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
- */
-
-#ifndef PAGERDOCKER_H
-#define PAGERDOCKER_H
-
-#include <QObject>
-
-class PagerDockerPlugin : public QObject
-{
-public:
-    PagerDockerPlugin(QObject *parent, const QVariantList &);
-    ~PagerDockerPlugin() override;
-};
-
-#endif
diff --git a/plugins/dockers/pager/krita_pagerdocker.json b/plugins/dockers/pager/krita_pagerdocker.json
deleted file mode 100644
index 6a8f8053e0..0000000000
--- a/plugins/dockers/pager/krita_pagerdocker.json
+++ /dev/null
@@ -1,9 +0,0 @@
-{
-  "Id": "Pager Docker",
-  "Type": "Service",
-  "X-KDE-Library": "kritapagerdocker",
-  "X-KDE-ServiceTypes": [
-    "Krita/Dock"
-  ],
-  "X-Krita-Version": "28"
-}