diff --git a/krita/main.cc b/krita/main.cc
index 0f3df58f80..37967ef8df 100644
--- a/krita/main.cc
+++ b/krita/main.cc
@@ -1,278 +1,281 @@
 /*
  * Copyright (c) 1999 Matthias Elter <me@kde.org>
  * Copyright (c) 2002 Patrick Julien <freak@codepimps.org>
  * Copyright (c) 2015 Boudewijn Rempt <boud@valdyas.org>
  *
  *  This program is free software; you can redistribute it and/or modify
  *  it under the terms of the GNU General Public License as published by
  *  the Free Software Foundation; either version 2 of the License, or
  *  (at your option) any later version.
  *
  *  This program is distributed in the hope that it will be useful,
  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  *  GNU General Public License for more details.
  *
  *  You should have received a copy of the GNU General Public License
  *  along with this program; if not, write to the Free Software
  *  Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
  */
 
 #include <stdlib.h>
 
 #include <QString>
 #include <QPixmap>
 #include <kis_debug.h>
 #include <QProcess>
 #include <QProcessEnvironment>
 #include <QDesktopServices>
 #include <QDir>
 #include <QDate>
 #include <QLoggingCategory>
 #include <QLocale>
 #include <QSettings>
 
 #include <time.h>
 
 #include <KisApplication.h>
 #include <KoConfig.h>
 #include <KoResourcePaths.h>
 
 #include "data/splash/splash_screen.xpm"
 #include "data/splash/splash_holidays.xpm"
 #include "KisDocument.h"
 #include "kis_splash_screen.h"
 #include "KisPart.h"
 #include "KisApplicationArguments.h"
 #include <opengl/kis_opengl.h>
+#include "input/KisQtWidgetsTweaker.h"
 
 #if defined Q_OS_WIN
 #include <windows.h>
 #include <stdlib.h>
 #include <kis_tablet_support_win.h>
 
 #elif defined HAVE_X11
 #include <kis_tablet_support_x11.h>
 #include <kis_xi2_event_filter.h>
 #endif
 
 #if defined HAVE_KCRASH
 #include <kcrash.h>
 #elif defined USE_DRMINGW
 namespace
 {
 void tryInitDrMingw()
 {
     wchar_t path[MAX_PATH];
     QString pathStr = QCoreApplication::applicationDirPath().replace(L'/', L'\\') + QStringLiteral("\\exchndl.dll");
     if (pathStr.size() > MAX_PATH - 1) {
         return;
     }
     int pathLen = pathStr.toWCharArray(path);
     path[pathLen] = L'\0'; // toWCharArray doesn't add NULL terminator
     HMODULE hMod = LoadLibraryW(path);
     if (!hMod) {
         return;
     }
     // No need to call ExcHndlInit since the crash handler is installed on DllMain
     auto myExcHndlSetLogFileNameA = reinterpret_cast<BOOL (APIENTRY *)(const char *)>(GetProcAddress(hMod, "ExcHndlSetLogFileNameA"));
     if (!myExcHndlSetLogFileNameA) {
         return;
     }
     // Set the log file path to %LocalAppData%\kritacrash.log
     QString logFile = QStandardPaths::writableLocation(QStandardPaths::GenericConfigLocation).replace(L'/', L'\\') + QStringLiteral("\\kritacrash.log");
     myExcHndlSetLogFileNameA(logFile.toLocal8Bit());
 }
 } // namespace
 #endif
 extern "C" int main(int argc, char **argv)
 {
 
     // The global initialization of the random generator
     qsrand(time(0));
     bool runningInKDE = !qgetenv("KDE_FULL_SESSION").isEmpty();
 
 #if defined HAVE_X11
     qputenv("QT_QPA_PLATFORM", "xcb");
 #endif
 
     /**
      * Disable debug output by default. (krita.input enables tablet debugging.)
      * Debug logs can be controlled by an environment variable QT_LOGGING_RULES.
      *
      * As an example, to get full debug output, run the following:
      * export QT_LOGGING_RULES="krita*=true"; krita
      *
      * See: http://doc.qt.io/qt-5/qloggingcategory.html
      */
     QLoggingCategory::setFilterRules("krita*.debug=false\n"
                                      "krita*.warning=true\n"
                                      "krita.tabletlog=true");
 
     // A per-user unique string, without /, because QLocalServer cannot use names with a / in it
     QString key = "Krita3" + QDesktopServices::storageLocation(QDesktopServices::HomeLocation).replace("/", "_");
     key = key.replace(":", "_").replace("\\","_");
 
     QCoreApplication::setAttribute(Qt::AA_ShareOpenGLContexts, true);
     KisOpenGL::setDefaultFormat();
 
     QCoreApplication::setAttribute(Qt::AA_DontCreateNativeWidgetSiblings, true);
     QCoreApplication::setAttribute(Qt::AA_UseHighDpiPixmaps, true);
 
     const QString configPath = QStandardPaths::writableLocation(QStandardPaths::GenericConfigLocation);
 
     bool singleApplication = true;
 #if QT_VERSION >= 0x050600
     {
         QSettings kritarc(configPath + QStringLiteral("/kritadisplayrc"), QSettings::IniFormat);
         singleApplication = kritarc.value("EnableSingleApplication").toBool();
         if (kritarc.value("EnableHiDPI", false).toBool()) {
             QCoreApplication::setAttribute(Qt::AA_EnableHighDpiScaling);
         }
         if (!qgetenv("KRITA_HIDPI").isEmpty()) {
             QCoreApplication::setAttribute(Qt::AA_EnableHighDpiScaling);
         }
     }
 #endif
 
     KLocalizedString::setApplicationDomain("krita");
 
     // first create the application so we can create a pixmap
     KisApplication app(key, argc, argv);
 
 #ifdef Q_OS_LINUX
     qputenv("XDG_DATA_DIRS", QFile::encodeName(KoResourcePaths::getApplicationRoot() + "share") + ":" + qgetenv("XDG_DATA_DIRS"));
 #else
     qputenv("XDG_DATA_DIRS", QFile::encodeName(KoResourcePaths::getApplicationRoot() + "share"));
 #endif
 
     qDebug() << "Setting XDG_DATA_DIRS" << qgetenv("XDG_DATA_DIRS");
     qDebug() << "Available translations" << KLocalizedString::availableApplicationTranslations();
     qDebug() << "Available domain translations" << KLocalizedString::availableDomainTranslations("krita");
 
     // Now that the paths are set, set the language. First check the override from the langage
     // selection dialog.
     {
         QSettings languageoverride(configPath + QStringLiteral("/klanguageoverridesrc"), QSettings::IniFormat);
         languageoverride.beginGroup(QStringLiteral("Language"));
         QString language = languageoverride.value(qAppName(), "").toString();
 
         qDebug() << "Override language:" << language;
 
         if (!language.isEmpty()) {
             KLocalizedString::setLanguages(language.split(":"));
             // And override Qt's locale, too
             qputenv("LANG", language.split(":").first().toUtf8());
             QLocale locale(language.split(":").first());
             QLocale::setDefault(locale);
             qDebug() << "Qt ui languages" << locale.uiLanguages();
         }
         else {
             // And if there isn't one, check the one set by the system.
             // XXX: This doesn't work, for some !@#$% reason.
             QLocale locale = QLocale::system();
             if (locale.bcp47Name() != QStringLiteral("en")) {
                 qputenv("LANG", locale.bcp47Name().toLatin1());
                 KLocalizedString::setLanguages(QStringList() << locale.bcp47Name());
             }
         }
 
     }
 #ifdef Q_OS_WIN
     QDir appdir(KoResourcePaths::getApplicationRoot());
     QString path = qgetenv("PATH");
     qputenv("PATH", QFile::encodeName(appdir.absolutePath() + "/bin" + ";"
                                       + appdir.absolutePath() + "/lib" + ";"
                                       + appdir.absolutePath() + "/Frameworks" + ";"
                                       + appdir.absolutePath() + ";"
                                       + path));
 
     qDebug() << "PATH" << qgetenv("PATH");
 #endif
 
     if (qApp->applicationDirPath().contains(KRITA_BUILD_DIR)) {
         qFatal("FATAL: You're trying to run krita from the build location. You can only run Krita from the installation location.");
     }
 
 
 #if defined HAVE_KCRASH
     KCrash::initialize();
 #elif defined USE_DRMINGW
     tryInitDrMingw();
 #endif
 
     // If we should clear the config, it has to be done as soon as possible after
     // KisApplication has been created. Otherwise the config file may have been read
     // and stored in a KConfig object we have no control over.
     app.askClearConfig();
 
     KisApplicationArguments args(app);
 
     if (singleApplication && app.isRunning()) {
         // only pass arguments to main instance if they are not for batch processing
         // any batch processing would be done in this separate instance
         const bool batchRun = (args.print() || args.exportAs() || args.exportAsPdf());
 
         if (!batchRun) {
             QByteArray ba = args.serialize();
             if (app.sendMessage(ba)) {
                 return 0;
             }
         }
     }
 
     if (!runningInKDE) {
         // Icons in menus are ugly and distracting
         app.setAttribute(Qt::AA_DontShowIconsInMenus);
     }
 
 #if defined HAVE_X11
     app.installNativeEventFilter(KisXi2EventFilter::instance());
 #endif
+    app.installEventFilter(KisQtWidgetsTweaker::instance());
+
 
     // then create the pixmap from an xpm: we cannot get the
     // location of our datadir before we've started our components,
     // so use an xpm.
     QDate currentDate = QDate::currentDate();
     QWidget *splash = 0;
     if (currentDate > QDate(currentDate.year(), 12, 4) ||
             currentDate < QDate(currentDate.year(), 1, 9)) {
         splash = new KisSplashScreen(app.applicationVersion(), QPixmap(splash_holidays_xpm));
     }
     else {
         splash = new KisSplashScreen(app.applicationVersion(), QPixmap(splash_screen_xpm));
     }
 
     app.setSplashScreen(splash);
 
 
 #if defined Q_OS_WIN
     KisTabletSupportWin::init();
     // app.installNativeEventFilter(new KisTabletSupportWin());
 #endif
 
     if (!app.start(args)) {
         return 1;
     }
 
 #if QT_VERSION >= 0x050700
     app.setAttribute(Qt::AA_CompressHighFrequencyEvents, false);
 #endif
 
     // Set up remote arguments.
     QObject::connect(&app, SIGNAL(messageReceived(QByteArray,QObject*)),
                      &app, SLOT(remoteArguments(QByteArray,QObject*)));
 
     QObject::connect(&app, SIGNAL(fileOpenRequest(QString)),
                      &app, SLOT(fileOpenRequested(QString)));
 
     int state = app.exec();
 
     {
         QSettings kritarc(configPath + QStringLiteral("/kritadisplayrc"), QSettings::IniFormat);
         kritarc.setValue("canvasState", "OPENGL_SUCCESS");
     }
 
     return state;
 }
 
diff --git a/libs/ui/CMakeLists.txt b/libs/ui/CMakeLists.txt
index 1634bfdde4..dee0b53228 100644
--- a/libs/ui/CMakeLists.txt
+++ b/libs/ui/CMakeLists.txt
@@ -1,553 +1,554 @@
 include_directories(
     ${CMAKE_CURRENT_SOURCE_DIR}/qtlockedfile
     ${EXIV2_INCLUDE_DIR}
 )
 
 include_directories(SYSTEM
     ${EIGEN3_INCLUDE_DIR}
     ${OCIO_INCLUDE_DIR}
     ${Boost_INCLUDE_DIRS}
 )
 
 add_subdirectory( tests )
 
 if (APPLE)
     find_library(FOUNDATION_LIBRARY Foundation)
 endif ()
 
 set(kritaui_LIB_SRCS
     canvas/kis_canvas_widget_base.cpp
     canvas/kis_canvas2.cpp
     canvas/kis_canvas_updates_compressor.cpp
     canvas/kis_canvas_controller.cpp
     canvas/kis_paintop_transformation_connector.cpp
     canvas/kis_display_color_converter.cpp
     canvas/kis_display_filter.cpp
     canvas/kis_exposure_gamma_correction_interface.cpp
     canvas/kis_tool_proxy.cpp
     canvas/kis_canvas_decoration.cc
     canvas/kis_coordinates_converter.cpp
     canvas/kis_grid_manager.cpp
     canvas/kis_grid_decoration.cpp
     canvas/kis_grid_config.cpp
     canvas/kis_prescaled_projection.cpp
     canvas/kis_qpainter_canvas.cpp
     canvas/kis_projection_backend.cpp
     canvas/kis_update_info.cpp
     canvas/kis_image_patch.cpp
     canvas/kis_image_pyramid.cpp
     canvas/kis_infinity_manager.cpp
     canvas/kis_change_guides_command.cpp
     canvas/kis_guides_decoration.cpp
     canvas/kis_guides_manager.cpp
     canvas/kis_guides_config.cpp
     canvas/kis_snap_config.cpp
     canvas/kis_snap_line_strategy.cpp
     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
     flake/kis_node_dummies_graph.cpp
     flake/kis_dummies_facade_base.cpp
     flake/kis_dummies_facade.cpp
     flake/kis_node_shapes_graph.cpp
     flake/kis_node_shape.cpp
     flake/kis_shape_controller.cpp
     flake/kis_shape_layer.cc
     flake/kis_shape_layer_canvas.cpp
     flake/kis_shape_selection.cpp
     flake/kis_shape_selection_canvas.cpp
     flake/kis_shape_selection_model.cpp
     flake/kis_take_all_shapes_command.cpp
     brushhud/kis_uniform_paintop_property_widget.cpp
     brushhud/kis_brush_hud.cpp
     brushhud/kis_round_hud_button.cpp
     brushhud/kis_dlg_brush_hud_config.cpp
     brushhud/kis_brush_hud_properties_list.cpp
     brushhud/kis_brush_hud_properties_config.cpp
     kis_aspect_ratio_locker.cpp
     kis_autogradient.cc
     kis_bookmarked_configurations_editor.cc
     kis_bookmarked_configurations_model.cc
     kis_bookmarked_filter_configurations_model.cc
     kis_base_option.cpp
     kis_canvas_resource_provider.cpp
     kis_derived_resources.cpp
     kis_categories_mapper.cpp
     kis_categorized_list_model.cpp
     kis_categorized_item_delegate.cpp
     kis_clipboard.cc
     kis_config.cc
     kis_config_notifier.cpp
     kis_control_frame.cpp
     kis_composite_ops_model.cc
     kis_paint_ops_model.cpp
     kis_cursor.cc
     kis_cursor_cache.cpp
     kis_custom_pattern.cc
     kis_file_layer.cpp
     kis_safe_document_loader.cpp
     kis_splash_screen.cpp
     kis_filter_manager.cc
     kis_filters_model.cc
     kis_histogram_view.cc
     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
     kis_painting_assistants_manager.cpp
     kis_paintop_box.cc
     kis_paintop_option.cpp
     kis_paintop_options_model.cpp
     kis_paintop_settings_widget.cpp
     kis_popup_palette.cpp
     kis_png_converter.cpp
     kis_preference_set_registry.cpp
     kis_script_manager.cpp
     kis_resource_server_provider.cpp
     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
     kis_view_plugin.cpp
     kis_canvas_controls_manager.cpp
     kis_tooltip_manager.cpp
     kis_multinode_property.cpp
     kis_stopgradient_editor.cpp
     kisexiv2/kis_exif_io.cpp
     kisexiv2/kis_exiv2.cpp
     kisexiv2/kis_iptc_io.cpp
     kisexiv2/kis_xmp_io.cpp
     opengl/kis_opengl.cpp
     opengl/kis_opengl_canvas2.cpp
     opengl/kis_opengl_canvas_debugger.cpp
     opengl/kis_opengl_image_textures.cpp
     opengl/kis_texture_tile.cpp
     opengl/kis_opengl_shader_loader.cpp
     kis_fps_decoration.cpp
     recorder/kis_node_query_path_editor.cc
     recorder/kis_recorded_action_creator.cc
     recorder/kis_recorded_action_creator_factory.cc
     recorder/kis_recorded_action_creator_factory_registry.cc
     recorder/kis_recorded_action_editor_factory.cc
     recorder/kis_recorded_action_editor_factory_registry.cc
     recorder/kis_recorded_filter_action_editor.cc
     recorder/kis_recorded_filter_action_creator.cpp
     recorder/kis_recorded_paint_action_editor.cc
     tool/kis_selection_tool_helper.cpp
     tool/kis_selection_tool_config_widget_helper.cpp
     tool/kis_rectangle_constraint_widget.cpp
     tool/kis_shape_tool_helper.cpp
     tool/kis_tool.cc
     tool/kis_delegated_tool_policies.cpp
     tool/kis_tool_freehand.cc
     tool/kis_speed_smoother.cpp
     tool/kis_painting_information_builder.cpp
     tool/kis_stabilized_events_sampler.cpp
     tool/kis_tool_freehand_helper.cpp
     tool/kis_tool_multihand_helper.cpp
     tool/kis_figure_painting_tool_helper.cpp
     tool/kis_recording_adapter.cpp
     tool/kis_tool_paint.cc
     tool/kis_tool_shape.cc
     tool/kis_tool_ellipse_base.cpp
     tool/kis_tool_rectangle_base.cpp
     tool/kis_tool_polyline_base.cpp
     tool/kis_tool_utils.cpp
     tool/kis_resources_snapshot.cpp
     tool/kis_smoothing_options.cpp
     tool/KisStabilizerDelayedPaintHelper.cpp
     tool/strokes/freehand_stroke.cpp
     tool/strokes/kis_painter_based_stroke_strategy.cpp
     tool/strokes/kis_filter_stroke_strategy.cpp
     tool/strokes/kis_color_picker_stroke_strategy.cpp
 
     widgets/kis_cmb_composite.cc
     widgets/kis_cmb_contour.cpp
     widgets/kis_cmb_gradient.cpp
     widgets/kis_paintop_list_widget.cpp
     widgets/kis_cmb_idlist.cc
     widgets/kis_color_space_selector.cc
     widgets/kis_advanced_color_space_selector.cc
     widgets/kis_cie_tongue_widget.cpp
     widgets/kis_tone_curve_widget.cpp
     widgets/kis_curve_widget.cpp
     widgets/kis_custom_image_widget.cc
     widgets/kis_image_from_clipboard_widget.cpp
     widgets/kis_double_widget.cc
     widgets/kis_filter_selector_widget.cc
     widgets/kis_gradient_chooser.cc
     widgets/kis_gradient_slider_widget.cc
     widgets/kis_gradient_slider.cpp
     widgets/kis_iconwidget.cc
     widgets/kis_mask_widgets.cpp
     widgets/kis_meta_data_merge_strategy_chooser_widget.cc
     widgets/kis_multi_bool_filter_widget.cc
     widgets/kis_multi_double_filter_widget.cc
     widgets/kis_multi_integer_filter_widget.cc
     widgets/kis_multipliers_double_slider_spinbox.cpp
     widgets/kis_paintop_presets_popup.cpp
     widgets/kis_tool_options_popup.cpp
     widgets/kis_paintop_presets_chooser_popup.cpp
     widgets/kis_pattern_chooser.cc
     widgets/kis_popup_button.cc
     widgets/kis_preset_chooser.cpp
     widgets/kis_progress_widget.cpp
     widgets/kis_selection_options.cc
     widgets/kis_scratch_pad.cpp
     widgets/kis_scratch_pad_event_filter.cpp
     widgets/kis_preset_selector_strip.cpp
     widgets/kis_slider_spin_box.cpp
     widgets/kis_size_group.cpp
     widgets/kis_size_group_p.cpp
     widgets/kis_wdg_generator.cpp
     widgets/kis_workspace_chooser.cpp
     widgets/squeezedcombobox.cpp
     widgets/kis_categorized_list_view.cpp
     widgets/kis_widget_chooser.cpp
     widgets/kis_tool_button.cpp
     widgets/kis_floating_message.cpp
     widgets/kis_lod_availability_widget.cpp
     widgets/kis_color_label_selector_widget.cpp
     widgets/kis_color_filter_combo.cpp
     widgets/kis_elided_label.cpp
     widgets/kis_stopgradient_slider_widget.cpp
     widgets/kis_spinbox_color_selector.cpp
     widgets/kis_screen_color_picker.cpp
     widgets/KoDualColorButton.cpp
     widgets/kis_color_input.cpp
     widgets/kis_color_button.cpp
     widgets/KisVisualColorSelector.cpp
     widgets/KisVisualColorSelectorShape.cpp
     widgets/KisVisualEllipticalSelectorShape.cpp
     widgets/KisVisualRectangleSelectorShape.cpp
     widgets/KisVisualTriangleSelectorShape.cpp
     widgets/KoStrokeConfigWidget.cpp
     widgets/KoFillConfigWidget.cpp
     widgets/KoShapeFillWrapper.cpp
 
     utils/kis_document_aware_spin_box_unit_manager.cpp
 
     input/kis_input_manager.cpp
     input/kis_input_manager_p.cpp
     input/kis_extended_modifiers_mapper.cpp
     input/kis_abstract_input_action.cpp
     input/kis_tool_invocation_action.cpp
     input/kis_pan_action.cpp
     input/kis_alternate_invocation_action.cpp
     input/kis_rotate_canvas_action.cpp
     input/kis_zoom_action.cpp
     input/kis_change_frame_action.cpp
     input/kis_gamma_exposure_action.cpp
     input/kis_show_palette_action.cpp
     input/kis_change_primary_setting_action.cpp
     input/kis_abstract_shortcut.cpp
     input/kis_single_action_shortcut.cpp
     input/kis_stroke_shortcut.cpp
     input/kis_shortcut_matcher.cpp
     input/kis_select_layer_action.cpp
+    input/KisQtWidgetsTweaker.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
     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
     KisUndoStackAction.cpp
     KisView.cpp
 
     thememanager.cpp
 
     kis_mainwindow_observer.cpp
     KisViewManager.cpp
     kis_mirror_manager.cpp
 
     qtlockedfile/qtlockedfile.cpp
 
     qtsingleapplication/qtlocalpeer.cpp
     qtsingleapplication/qtsingleapplication.cpp
 
     KisResourceBundle.cpp
     KisResourceBundleManifest.cpp
 
     kis_md5_generator.cpp
     KisApplicationArguments.cpp
 
     KisNetworkAccessManager.cpp
     KisMultiFeedRSSModel.cpp
     KisRemoteFileFetcher.cpp
 
     KisPaletteModel.cpp
     kis_palette_delegate.cpp
     kis_palette_view.cpp
     KisColorsetChooser.cpp
     KisSaveGroupVisitor.cpp
 )
 
 if(WIN32)
     if (NOT Qt5Gui_PRIVATE_INCLUDE_DIRS)
         message(FATAL_ERROR "Qt5Gui Private header are missing!")
     endif()
     set(kritaui_LIB_SRCS
         ${kritaui_LIB_SRCS}
         input/kis_tablet_event.cpp
         input/wintab/kis_tablet_support_win.cpp
         input/wintab/kis_screen_size_choice_dialog.cpp
         qtlockedfile/qtlockedfile_win.cpp
         )
     include_directories(${Qt5Gui_PRIVATE_INCLUDE_DIRS})
 endif()
 
     set(kritaui_LIB_SRCS
         ${kritaui_LIB_SRCS}
         kis_animation_frame_cache.cpp
         kis_animation_cache_populator.cpp
         KisAnimationCacheRegenerator.cpp
         dialogs/KisAnimationCacheUpdateProgressDialog.cpp
         canvas/kis_animation_player.cpp
         kis_animation_exporter.cpp
         kis_animation_importer.cpp
         KisSyncedAudioPlayback.cpp
     )
 
 if(UNIX)
     set(kritaui_LIB_SRCS
         ${kritaui_LIB_SRCS}
         input/kis_tablet_event.cpp
         input/wintab/kis_tablet_support.cpp
         qtlockedfile/qtlockedfile_unix.cpp
         )
     if(NOT APPLE)
         set(kritaui_LIB_SRCS
             ${kritaui_LIB_SRCS}
             input/wintab/kis_tablet_support_x11.cpp
             input/wintab/qxcbconnection_xi2.cpp
             input/wintab/qxcbconnection.cpp
             input/wintab/kis_xi2_event_filter.cpp
             )
     endif()
 endif()
 
 
 ki18n_wrap_ui(kritaui_LIB_SRCS
     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/wdgdlgblacklistcleanup.ui
     forms/wdgrectangleconstraints.ui
     forms/wdgimportimagesequence.ui
     forms/wdgstrokeselectionproperties.ui
     forms/KisDetailsPaneBase.ui
     forms/KisOpenPaneBase.ui
     forms/wdgstopgradienteditor.ui
     brushhud/kis_dlg_brush_hud_config.ui
     forms/wdgdlginternalcolorselector.ui
     dialogs/kis_delayed_save_dialog.ui
     input/config/kis_input_configuration_page.ui
     input/config/kis_edit_profiles_dialog.ui
     input/config/kis_input_configuration_page_item.ui
     input/config/kis_mouse_input_editor.ui
     input/config/kis_wheel_input_editor.ui
     input/config/kis_key_input_editor.ui
 
     layerstyles/wdgBevelAndEmboss.ui
     layerstyles/wdgblendingoptions.ui
     layerstyles/WdgColorOverlay.ui
     layerstyles/wdgContour.ui
     layerstyles/wdgdropshadow.ui
     layerstyles/WdgGradientOverlay.ui
     layerstyles/wdgInnerGlow.ui
     layerstyles/wdglayerstyles.ui
     layerstyles/WdgPatternOverlay.ui
     layerstyles/WdgSatin.ui
     layerstyles/WdgStroke.ui
     layerstyles/wdgstylesselector.ui
     layerstyles/wdgTexture.ui
 
     wdgsplash.ui
     input/wintab/kis_screen_size_choice_dialog.ui
 
 )
 
 
 QT5_WRAP_CPP(kritaui_HEADERS_MOC KisNodePropertyAction_p.h)
 
 add_library(kritaui SHARED ${kritaui_HEADERS_MOC} ${kritaui_LIB_SRCS} )
 generate_export_header(kritaui BASE_NAME kritaui)
 
 target_link_libraries(kritaui KF5::CoreAddons KF5::Completion KF5::I18n KF5::ItemViews Qt5::Network
                       kritaimpex kritacolor kritaimage kritalibbrush kritawidgets kritawidgetutils ${PNG_LIBRARIES} ${EXIV2_LIBRARIES}
 )
 
 if (HAVE_QT_MULTIMEDIA)
     target_link_libraries(kritaui Qt5::Multimedia)
 endif()
 
 if (HAVE_KIO)
     target_link_libraries(kritaui KF5::KIOCore)
 endif() 
 
 if (NOT WIN32 AND NOT APPLE)
   target_link_libraries(kritaui ${X11_X11_LIB}
                                 ${X11_Xinput_LIB}
                                 ${XCB_LIBRARIES})
 endif()
 
 if(APPLE)
     target_link_libraries(kritaui ${FOUNDATION_LIBRARY})
 endif ()
 
 
 target_link_libraries(kritaui ${OPENEXR_LIBRARIES})
 
 # Add VSync disable workaround
 if(NOT WIN32 AND NOT APPLE)
     target_link_libraries(kritaui ${CMAKE_DL_LIBS} Qt5::X11Extras)
 endif()
 
 if(X11_FOUND)
     target_link_libraries(kritaui Qt5::X11Extras ${X11_LIBRARIES})
 endif()
 
 target_include_directories(kritaui
     PUBLIC
     $<BUILD_INTERFACE:${CMAKE_CURRENT_SOURCE_DIR}/canvas>
     $<BUILD_INTERFACE:${CMAKE_CURRENT_SOURCE_DIR}/flake>
     $<BUILD_INTERFACE:${CMAKE_CURRENT_SOURCE_DIR}/ora>
     $<BUILD_INTERFACE:${CMAKE_CURRENT_SOURCE_DIR}/tool>
     $<BUILD_INTERFACE:${CMAKE_CURRENT_SOURCE_DIR}/utils>
     $<BUILD_INTERFACE:${CMAKE_CURRENT_SOURCE_DIR}/widgets>
     $<BUILD_INTERFACE:${CMAKE_CURRENT_SOURCE_DIR}/input/wintab>
 )
 
 set_target_properties(kritaui
     PROPERTIES VERSION ${GENERIC_KRITA_LIB_VERSION} SOVERSION ${GENERIC_KRITA_LIB_SOVERSION}
 )
 install(TARGETS kritaui  ${INSTALL_TARGETS_DEFAULT_ARGS})
 
 
 if (APPLE)
     install(FILES osx.stylesheet DESTINATION ${DATA_INSTALL_DIR}/krita)
 endif ()
diff --git a/libs/ui/KisNodeDelegate.cpp b/libs/ui/KisNodeDelegate.cpp
index a2ede3017c..19fae61fb7 100644
--- a/libs/ui/KisNodeDelegate.cpp
+++ b/libs/ui/KisNodeDelegate.cpp
@@ -1,864 +1,883 @@
 /*
   Copyright (c) 2006 Gábor Lehel <illissius@gmail.com>
   Copyright (c) 2008 Cyrille Berger <cberger@cberger.net>
   Copyright (c) 2011 José Luis Vergara <pentalis@gmail.com>
 
   This library is free software; you can redistribute it and/or
   modify it under the terms of the GNU Library General Public
   License as published by the Free Software Foundation; either
   version 2 of the License, or (at your option) any later version.
 
   This library is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
   Library General Public License for more details.
 
   You should have received a copy of the GNU Library General Public License
   along with this library; see the file COPYING.LIB.  If not, write to
   the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
   Boston, MA 02110-1301, USA.
 */
 #include "kis_config.h"
 #include "KisNodeDelegate.h"
 #include "kis_node_model.h"
 #include "KisNodeToolTip.h"
 #include "KisNodeView.h"
 #include "KisPart.h"
 #include "input/kis_input_manager.h"
 
 #include <QtDebug>
 #include <QApplication>
 #include <QKeyEvent>
 #include <QLineEdit>
 #include <QModelIndex>
 #include <QMouseEvent>
 #include <QPainter>
 #include <QPointer>
 #include <QStyle>
 #include <QStyleOptionViewItem>
 
 #include <klocalizedstring.h>
 #include "kis_node_view_color_scheme.h"
 #include "kis_icon_utils.h"
 #include "kis_layer_properties_icons.h"
 #include "krita_utils.h"
 
 typedef KisBaseNode::Property* OptionalProperty;
 
 #include <kis_base_node.h>
 
 class KisNodeDelegate::Private
 {
 public:
     Private() : view(0), edit(0) { }
 
     KisNodeView *view;
     QPointer<QWidget> edit;
     KisNodeToolTip tip;
 
     QList<OptionalProperty> rightmostProperties(const KisBaseNode::PropertyList &props) const;
     int numProperties(const QModelIndex &index) const;
     OptionalProperty findProperty(KisBaseNode::PropertyList &props, const OptionalProperty &refProp) const;
     OptionalProperty findVisibilityProperty(KisBaseNode::PropertyList &props) const;
 
     void toggleProperty(KisBaseNode::PropertyList &props, OptionalProperty prop, bool controlPressed, const QModelIndex &index);
 };
 
 KisNodeDelegate::KisNodeDelegate(KisNodeView *view, QObject *parent)
     : QAbstractItemDelegate(parent)
     , d(new Private)
 {
     d->view = view;
     QApplication::instance()->installEventFilter(this);
 }
 
 KisNodeDelegate::~KisNodeDelegate()
 {
     delete d;
 }
 
 QSize KisNodeDelegate::sizeHint(const QStyleOptionViewItem &option, const QModelIndex &index) const
 {
     Q_UNUSED(index);
     KisNodeViewColorScheme scm;
     return QSize(option.rect.width(), scm.rowHeight());
 }
 
 void KisNodeDelegate::paint(QPainter *p, const QStyleOptionViewItem &o, const QModelIndex &index) const
 {
     p->save();
 
     {
         QStyleOptionViewItem option = getOptions(o, index);
         QStyle *style = option.widget ? option.widget->style() : QApplication::style();
         style->drawPrimitive(QStyle::PE_PanelItemViewItem, &option, p, option.widget);
 
         bool shouldGrayOut = index.data(KisNodeModel::ShouldGrayOutRole).toBool();
         if (shouldGrayOut) {
             option.state &= ~QStyle::State_Enabled;
         }
 
         p->setFont(option.font);
 
         drawColorLabel(p, option, index);
         drawFrame(p, option, index);
         drawThumbnail(p, option, index);
         drawText(p, option, index);
         drawIcons(p, option, index);
         drawVisibilityIconHijack(p, option, index);
         drawDecoration(p, option, index);
         drawExpandButton(p, option, index);
         drawBranch(p, option, index);
 
         drawProgressBar(p, option, index);
     }
     p->restore();
 }
 
 void KisNodeDelegate::drawBranch(QPainter *p, const QStyleOptionViewItem &option, const QModelIndex &index) const {
     Q_UNUSED(index);
 
     KisNodeViewColorScheme scm;
     const QPoint base = scm.relThumbnailRect().translated(option.rect.topLeft()).topLeft() - QPoint( scm.indentation(), 0);
 
     // there is no indention if we are starting negative, so don't draw a branch
     if (base.x() < 0) {
         return;
     }
 
 
     QPen oldPen = p->pen();
     const qreal oldOpacity = p->opacity(); // remember previous opacity
     p->setOpacity(1.0);
 
     QColor color = scm.gridColor(option, d->view);
     QColor bgColor = option.state & QStyle::State_Selected ?
         qApp->palette().color(QPalette::Base) :
         qApp->palette().color(QPalette::Text);
     color = KritaUtils::blendColors(color, bgColor, 0.9);
 
 
     // TODO: if we are a mask type, use dotted lines for the branch style
     // p->setPen(QPen(p->pen().color(), 2, Qt::DashLine, Qt::RoundCap, Qt::RoundJoin));
     p->setPen(QPen(color, 0, Qt::SolidLine, Qt::RoundCap, Qt::RoundJoin));
 
     QPoint p2 = base + QPoint(scm.iconSize() - scm.decorationMargin()*2, scm.iconSize()*0.45);
     QPoint p3 =  base + QPoint(scm.iconSize() - scm.decorationMargin()*2, scm.iconSize());
     QPoint p4 = base + QPoint(scm.iconSize()*1.4, scm.iconSize());
     p->drawLine(p2, p3);
     p->drawLine(p3, p4);
 
 
 
      // draw parent lines (keep drawing until x position is less than 0
     QPoint p5 = p2 - QPoint(scm.indentation(), 0);
     QPoint p6 = p3 - QPoint(scm.indentation(), 0);
 
      QPoint parentBase1 = p5;
      QPoint parentBase2 = p6;
 
      // indent lines needs to be very subtle to avoid making the docker busy looking
      color = KritaUtils::blendColors(color, bgColor, 0.9); // makes it a little lighter than L lines
      p->setPen(QPen(color, 0, Qt::SolidLine, Qt::RoundCap, Qt::RoundJoin));
 
      while (parentBase1.x() > scm.visibilityColumnWidth()) {
          p->drawLine(parentBase1, parentBase2);
 
          parentBase1 = parentBase1 - QPoint(scm.indentation(), 0);
          parentBase2 = parentBase2 - QPoint(scm.indentation(), 0);
      }
 
 
 
 
      p->setPen(oldPen);
      p->setOpacity(oldOpacity);
 }
 
 void KisNodeDelegate::drawColorLabel(QPainter *p, const QStyleOptionViewItem &option, const QModelIndex &index) const
 {
     KisNodeViewColorScheme scm;
     const int label = index.data(KisNodeModel::ColorLabelIndexRole).toInt();
     QColor color = scm.colorLabel(label);
     if (color.alpha() <= 0) return;
 
     QColor bgColor = qApp->palette().color(QPalette::Base);
     color = KritaUtils::blendColors(color, bgColor, 0.3);
 
     const QRect rect = option.state & QStyle::State_Selected ?
         iconsRect(option, index) :
         option.rect.adjusted(-scm.indentation(), 0, 0, 0);
 
     p->fillRect(rect, color);
 }
 
 void KisNodeDelegate::drawFrame(QPainter *p, const QStyleOptionViewItem &option, const QModelIndex &index) const
 {
     KisNodeViewColorScheme scm;
 
     QPen oldPen = p->pen();
     p->setPen(scm.gridColor(option, d->view));
 
     const QPoint base = option.rect.topLeft();
 
     QPoint p2 = base + QPoint(-scm.indentation() - 1, 0);
     QPoint p3 = base + QPoint(2 * scm.decorationMargin() + scm.decorationSize(), 0);
     QPoint p4 = base + QPoint(-1, 0);
     QPoint p5(iconsRect(option,
                            index).left() - 1, base.y());
     QPoint p6(option.rect.right(), base.y());
 
     QPoint v(0, option.rect.height());
 
 
     // draw a line that goes the length of the entire frame. one for the
     // top, and one for the bottom
     QPoint pTopLeft(0, option.rect.topLeft().y());
     QPoint pTopRight(option.rect.bottomRight().x(),option.rect.topLeft().y() );
     p->drawLine(pTopLeft, pTopRight);
 
     QPoint pBottomLeft(0, option.rect.topLeft().y() + scm.rowHeight());
     QPoint pBottomRight(option.rect.bottomRight().x(),option.rect.topLeft().y() + scm.rowHeight() );
     p->drawLine(pBottomLeft, pBottomRight);
 
 
     const bool paintForParent =
         index.parent().isValid() &&
         !index.row();
 
     if (paintForParent) {
         QPoint p1(-2 * scm.indentation() - 1, 0);
         p1 += base;
         p->drawLine(p1, p2);
     }
 
 
     QPoint k0(0, base.y());
     QPoint k1(1 * scm.border() + 2 * scm.visibilityMargin() + scm.visibilitySize(), base.y());
     p->drawLine(k0, k1);
     p->drawLine(k0 + v, k1 + v);
     p->drawLine(k0, k0 + v);
     p->drawLine(k1, k1 + v);
 
     p->drawLine(p2, p6);
     p->drawLine(p2 + v, p6 + v);
     p->drawLine(p2, p2 + v);
     p->drawLine(p3, p3 + v);
     p->drawLine(p4, p4 + v);
     p->drawLine(p5, p5 + v);
     p->drawLine(p6, p6 + v);
 
     //// For debugging purposes only
     //p->setPen(Qt::blue);
     //KritaUtils::renderExactRect(p, iconsRect(option, index));
     //KritaUtils::renderExactRect(p, textRect(option, index));
     //KritaUtils::renderExactRect(p, scm.relThumbnailRect().translated(option.rect.topLeft()));
 
     p->setPen(oldPen);
 }
 
 void KisNodeDelegate::drawThumbnail(QPainter *p, const QStyleOptionViewItem &option, const QModelIndex &index) const
 {
     KisNodeViewColorScheme scm;
 
     const int thumbSize = scm.thumbnailSize();
     const qreal oldOpacity = p->opacity(); // remember previous opacity
 
     QImage img = index.data(int(KisNodeModel::BeginThumbnailRole) + thumbSize).value<QImage>();
     if (!(option.state & QStyle::State_Enabled)) {
         p->setOpacity(0.35);
     }
 
     QRect fitRect = scm.relThumbnailRect().translated(option.rect.topLeft());
 
     QPoint offset;
     offset.setX((fitRect.width() - img.width()) / 2);
     offset.setY((fitRect.height() - img.height()) / 2);
     offset += fitRect.topLeft();
 
     KisConfig cfg;
 
     // paint in a checkerboard pattern behind the layer contents to represent transparent
     const int step = scm.thumbnailSize() / 6;
     QImage checkers(2 * step, 2 * step, QImage::Format_ARGB32);
     QPainter gc(&checkers);
     gc.fillRect(QRect(0, 0, step, step), cfg.checkersColor1());
     gc.fillRect(QRect(step, 0, step, step), cfg.checkersColor2());
     gc.fillRect(QRect(step, step, step, step), cfg.checkersColor1());
     gc.fillRect(QRect(0, step, step, step), cfg.checkersColor2());
 
     QBrush brush(checkers);
     p->setBrushOrigin(offset);
     p->fillRect(img.rect().translated(offset), brush);
 
     p->drawImage(offset, img);
     p->setOpacity(oldOpacity); // restore old opacity
 
     QRect borderRect = kisGrowRect(img.rect(), 1).translated(offset);
     KritaUtils::renderExactRect(p, borderRect, scm.gridColor(option, d->view));
 }
 
 QRect KisNodeDelegate::iconsRect(const QStyleOptionViewItem &option, const QModelIndex &index) const
 {
     KisNodeViewColorScheme scm;
 
     int propCount = d->numProperties(index);
 
     const int iconsWidth =
         propCount * (scm.iconSize() + 2 * scm.iconMargin()) +
         (propCount - 1) * scm.border();
 
     const int x = option.rect.x() + option.rect.width()
         - (iconsWidth + scm.border());
     const int y = option.rect.y() + scm.border();
 
     return QRect(x, y,
                  iconsWidth,
                  scm.rowHeight() - scm.border());
 }
 
 QRect KisNodeDelegate::textRect(const QStyleOptionViewItem &option, const QModelIndex &index) const
 {
     KisNodeViewColorScheme scm;
 
     static QFont f;
     static int minbearing = 1337 + 666; //can be 0 or negative, 2003 is less likely
     if (minbearing == 2003 || f != option.font) {
         f = option.font; //getting your bearings can be expensive, so we cache them
         minbearing = option.fontMetrics.minLeftBearing() + option.fontMetrics.minRightBearing();
     }
 
     const int decorationOffset =
         2 * scm.border() +
         2 * scm.decorationMargin() +
         scm.decorationSize();
 
     const int width =
         iconsRect(option, index).left() - option.rect.x() -
         scm.border() + minbearing - decorationOffset;
 
     return QRect(option.rect.x() - minbearing + decorationOffset,
                  option.rect.y() + scm.border(),
                  width,
                  scm.rowHeight() - scm.border());
 }
 
 void KisNodeDelegate::drawText(QPainter *p, const QStyleOptionViewItem &option, const QModelIndex &index) const
 {
     KisNodeViewColorScheme scm;
     const QRect rc = textRect(option, index)
         .adjusted(scm.textMargin(), 0, -scm.textMargin(), 0);
 
     QPen oldPen = p->pen();
     const qreal oldOpacity = p->opacity(); // remember previous opacity
 
     p->setPen(option.palette.color(QPalette::Active,QPalette::Text ));
 
 
 
     if (!(option.state & QStyle::State_Enabled)) {
         p->setOpacity(0.55);
     }
 
 
     const QString text = index.data(Qt::DisplayRole).toString();
     const QString elided = elidedText(p->fontMetrics(), rc.width(), Qt::ElideRight, text);
     p->drawText(rc, Qt::AlignLeft | Qt::AlignVCenter, elided);
 
     p->setPen(oldPen); // restore pen settings
     p->setOpacity(oldOpacity);
 }
 
 QList<OptionalProperty> KisNodeDelegate::Private::rightmostProperties(const KisBaseNode::PropertyList &props) const
 {
     QList<OptionalProperty> list;
     QList<OptionalProperty> prependList;
     list << OptionalProperty(0);
     list << OptionalProperty(0);
     list << OptionalProperty(0);
 
     KisBaseNode::PropertyList::const_iterator it = props.constBegin();
     KisBaseNode::PropertyList::const_iterator end = props.constEnd();
     for (; it != end; ++it) {
         if (!it->isMutable) continue;
 
         if (it->id == KisLayerPropertiesIcons::visible.id()) {
             // noop...
         } else if (it->id == KisLayerPropertiesIcons::locked.id()) {
             list[0] = OptionalProperty(&(*it));
         } else if (it->id == KisLayerPropertiesIcons::inheritAlpha.id()) {
             list[1] = OptionalProperty(&(*it));
         } else if (it->id == KisLayerPropertiesIcons::alphaLocked.id()) {
             list[2] = OptionalProperty(&(*it));
         } else {
             prependList.prepend(OptionalProperty(&(*it)));
         }
     }
 
     {
         QMutableListIterator<OptionalProperty> i(prependList);
         i.toBack();
         while (i.hasPrevious()) {
             OptionalProperty val = i.previous();
 
             int emptyIndex = list.lastIndexOf(0);
             if (emptyIndex < 0) break;
 
             list[emptyIndex] = val;
             i.remove();
         }
     }
 
     return prependList + list;
 }
 
 int KisNodeDelegate::Private::numProperties(const QModelIndex &index) const
 {
     KisBaseNode::PropertyList props = index.data(KisNodeModel::PropertiesRole).value<KisBaseNode::PropertyList>();
     QList<OptionalProperty> realProps = rightmostProperties(props);
     return realProps.size();
 }
 
 OptionalProperty KisNodeDelegate::Private::findProperty(KisBaseNode::PropertyList &props, const OptionalProperty &refProp) const
 {
     KisBaseNode::PropertyList::iterator it = props.begin();
     KisBaseNode::PropertyList::iterator end = props.end();
     for (; it != end; ++it) {
         if (it->id == refProp->id) {
             return &(*it);
         }
     }
 
     return 0;
 }
 
 OptionalProperty KisNodeDelegate::Private::findVisibilityProperty(KisBaseNode::PropertyList &props) const
 {
     KisBaseNode::PropertyList::iterator it = props.begin();
     KisBaseNode::PropertyList::iterator end = props.end();
     for (; it != end; ++it) {
         if (it->id == KisLayerPropertiesIcons::visible.id()) {
             return &(*it);
         }
     }
 
     return 0;
 }
 
 void KisNodeDelegate::drawIcons(QPainter *p, const QStyleOptionViewItem &option, const QModelIndex &index) const
 {
     KisNodeViewColorScheme scm;
     const QRect r = iconsRect(option, index);
 
     QTransform oldTransform = p->transform();
     QPen oldPen = p->pen();
     p->setTransform(QTransform::fromTranslate(r.x(), r.y()));
     p->setPen(scm.gridColor(option, d->view));
 
     int x = 0;
     const int y = (scm.rowHeight() - scm.border() - scm.iconSize()) / 2;
     KisBaseNode::PropertyList props = index.data(KisNodeModel::PropertiesRole).value<KisBaseNode::PropertyList>();
     QList<OptionalProperty> realProps = d->rightmostProperties(props);
 
     Q_FOREACH (OptionalProperty prop, realProps) {
         x += scm.iconMargin();
         if (prop) {
             QIcon icon = prop->state.toBool() ? prop->onIcon : prop->offIcon;
             bool fullColor = prop->state.toBool() && option.state & QStyle::State_Enabled;
             const qreal oldOpacity = p->opacity(); // remember previous opacity
 
 
             if (fullColor) {
                  p->setOpacity(1.0);
             }
             else {
                 p->setOpacity(0.35);
             }
 
             p->drawPixmap(x, y, icon.pixmap(scm.iconSize(), QIcon::Normal));
             p->setOpacity(oldOpacity); // restore old opacity
 
 
         }
         x += scm.iconSize() + scm.iconMargin();
         p->drawLine(x, 0, x, scm.rowHeight() - scm.border());
         x += scm.border();
     }
 
     p->setTransform(oldTransform);
     p->setPen(oldPen);
 }
 
 QRect KisNodeDelegate::visibilityClickRect(const QStyleOptionViewItem &option, const QModelIndex &index) const
 {
     Q_UNUSED(index);
     KisNodeViewColorScheme scm;
     return QRect(scm.border(), scm.border() + option.rect.top(),
                  2 * scm.visibilityMargin() + scm.visibilitySize(),
                  scm.rowHeight() - scm.border());
 }
 
 QRect KisNodeDelegate::decorationClickRect(const QStyleOptionViewItem &option, const QModelIndex &index) const
 {
     Q_UNUSED(option);
     Q_UNUSED(index);
     KisNodeViewColorScheme scm;
 
     QRect realVisualRect = d->view->originalVisualRect(index);
 
     return QRect(realVisualRect.left(), scm.border() + realVisualRect.top(),
                  2 * scm.decorationMargin() + scm.decorationSize(),
                  scm.rowHeight() - scm.border());
 }
 
 void KisNodeDelegate::drawVisibilityIconHijack(QPainter *p, const QStyleOptionViewItem &option, const QModelIndex &index) const
 {
     /**
      * Small hack Alert:
      *
      * Here wepaint over the area that sits basically outside our layer's
      * row. Anyway, just update it later...
      */
 
     KisNodeViewColorScheme scm;
 
     KisBaseNode::PropertyList props = index.data(KisNodeModel::PropertiesRole).value<KisBaseNode::PropertyList>();
     OptionalProperty prop = d->findVisibilityProperty(props);
     if (!prop) return;
 
     const int x = scm.border() + scm.visibilityMargin();
     const int y = option.rect.top() + (scm.rowHeight() - scm.border() - scm.visibilitySize()) / 2;
 
     QIcon icon = prop->state.toBool() ? prop->onIcon : prop->offIcon;
     p->setOpacity(1.0);
     p->drawPixmap(x, y, icon.pixmap(scm.visibilitySize(),  QIcon::Normal));
 
     //// For debugging purposes only
     // p->save();
     // p->setPen(Qt::blue);
     // KritaUtils::renderExactRect(p, visibilityClickRect(option, index));
     // p->restore();
 }
 
 void KisNodeDelegate::drawDecoration(QPainter *p, const QStyleOptionViewItem &option, const QModelIndex &index) const
 {
     KisNodeViewColorScheme scm;
     QIcon icon = index.data(Qt::DecorationRole).value<QIcon>();
 
     if (!icon.isNull()) {
         QPixmap pixmap =
             icon.pixmap(scm.decorationSize(),
                         (option.state & QStyle::State_Enabled) ?
                         QIcon::Normal : QIcon::Disabled);
 
         const QRect rc = scm.relDecorationRect().translated(option.rect.topLeft());
         const qreal oldOpacity = p->opacity(); // remember previous opacity
 
         if (!(option.state & QStyle::State_Enabled)) {
             p->setOpacity(0.35);
         }
 
 
         p->drawPixmap(rc.topLeft(), pixmap);
         p->setOpacity(oldOpacity); // restore old opacity
     }
 }
 
 void KisNodeDelegate::drawExpandButton(QPainter *p, const QStyleOptionViewItem &option, const QModelIndex &index) const
 {
     Q_UNUSED(index);
     KisNodeViewColorScheme scm;
     QRect rc = scm.relExpandButtonRect().translated(option.rect.topLeft());
     rc = kisGrowRect(rc, 0);
 
     if (!(option.state & QStyle::State_Children)) {
         return;
     }
 
     QString iconName = option.state & QStyle::State_Open ? "arrow-down" : "arrow-right";
     QIcon icon = KisIconUtils::loadIcon(iconName);
     QPixmap pixmap = icon.pixmap(rc.width(),
                                  (option.state & QStyle::State_Enabled) ?
                                  QIcon::Normal : QIcon::Disabled);
     p->drawPixmap(rc.topLeft(), pixmap);
 }
 
 void KisNodeDelegate::Private::toggleProperty(KisBaseNode::PropertyList &props, OptionalProperty clickedProperty, bool controlPressed, const QModelIndex &index)
 {
     QAbstractItemModel *model = view->model();
 
     // Using Ctrl+click to enter stasis
     if (controlPressed && clickedProperty->canHaveStasis) {
         // STEP 0: Prepare to Enter or Leave control key stasis
         quint16 numberOfLeaves = model->rowCount(index.parent());
         QModelIndex eachItem;
         // STEP 1: Go.
         if (clickedProperty->isInStasis == false) { // Enter
             /* Make every leaf of this node go State = False, saving the old property value to stateInStasis */
             for (quint16 i = 0; i < numberOfLeaves; ++i) { // Foreach leaf in the node (index.parent())
                 eachItem = model->index(i, 1, index.parent());
                 // The entire property list has to be altered because model->setData cannot set individual properties
                 KisBaseNode::PropertyList eachPropertyList = eachItem.data(KisNodeModel::PropertiesRole).value<KisBaseNode::PropertyList>();
                 OptionalProperty prop = findProperty(eachPropertyList, clickedProperty);
                 if (!prop) continue;
                 prop->stateInStasis = prop->state.toBool();
                 prop->state = eachItem == index;
                 prop->isInStasis = true;
                 model->setData(eachItem, QVariant::fromValue(eachPropertyList), KisNodeModel::PropertiesRole);
 
             }
 
             for (quint16 i = 0; i < numberOfLeaves; ++i) { // Foreach leaf in the node (index.parent())
                 eachItem = model->index(i, 1, index.parent());
                 KisBaseNode::PropertyList eachPropertyList = eachItem.data(KisNodeModel::PropertiesRole).value<KisBaseNode::PropertyList>();
                 OptionalProperty prop = findProperty(eachPropertyList, clickedProperty);
                 if (!prop) continue;
             }
         } else { // Leave
             /* Make every leaf of this node go State = stateInStasis */
             for (quint16 i = 0; i < numberOfLeaves; ++i) {
                 eachItem = model->index(i, 1, index.parent());
                 // The entire property list has to be altered because model->setData cannot set individual properties
                 KisBaseNode::PropertyList eachPropertyList = eachItem.data(KisNodeModel::PropertiesRole).value<KisBaseNode::PropertyList>();
                 OptionalProperty prop = findProperty(eachPropertyList, clickedProperty);
                 if (!prop) continue;
 
                 prop->state = prop->stateInStasis;
                 prop->isInStasis = false;
                 model->setData(eachItem, QVariant::fromValue(eachPropertyList), KisNodeModel::PropertiesRole);
             }
         }
     } else {
         clickedProperty->state = !clickedProperty->state.toBool();
         model->setData(index, QVariant::fromValue(props), KisNodeModel::PropertiesRole);
     }
 }
 
 bool KisNodeDelegate::editorEvent(QEvent *event, QAbstractItemModel *model, const QStyleOptionViewItem &option, const QModelIndex &index)
 {
     KisNodeViewColorScheme scm;
 
     if ((event->type() == QEvent::MouseButtonPress || event->type() == QEvent::MouseButtonDblClick)
         && (index.flags() & Qt::ItemIsEnabled))
     {
         QMouseEvent *mouseEvent = static_cast<QMouseEvent*>(event);
 
         /**
          * Small hack Alert:
          *
          * Here we handle clicking even when it happened outside
          * the rectangle of the current index. The point is, we
          * use some virtual scroling offset to move the tree to the
          * right of the visibility icon. So the icon itself is placed
          * in an empty area that doesn't belong to any index. But we still
          * handle it.
          */
 
         const QRect iconsRect = this->iconsRect(option, index);
         const bool iconsClicked = iconsRect.isValid() &&
             iconsRect.contains(mouseEvent->pos());
 
         const QRect visibilityRect = visibilityClickRect(option, index);
         const bool visibilityClicked = visibilityRect.isValid() &&
             visibilityRect.contains(mouseEvent->pos());
 
         const QRect decorationRect = decorationClickRect(option, index);
         const bool decorationClicked = decorationRect.isValid() &&
             decorationRect.contains(mouseEvent->pos());
 
         const bool leftButton = mouseEvent->buttons() & Qt::LeftButton;
 
         if (leftButton && iconsClicked) {
             KisBaseNode::PropertyList props = index.data(KisNodeModel::PropertiesRole).value<KisBaseNode::PropertyList>();
             QList<OptionalProperty> realProps = d->rightmostProperties(props);
             const int numProps = realProps.size();
 
             const int iconWidth = scm.iconSize() + 2 * scm.iconMargin() + scm.border();
             const int xPos = mouseEvent->pos().x() - iconsRect.left();
             const int clickedIcon = xPos / iconWidth;
             const int distToBorder = qMin(xPos % iconWidth, iconWidth - xPos % iconWidth);
 
             if (iconsClicked &&
                 clickedIcon >= 0 &&
                 clickedIcon < numProps &&
                 distToBorder > scm.iconMargin()) {
 
                 OptionalProperty clickedProperty = realProps[clickedIcon];
                 if (!clickedProperty) return false;
                 d->toggleProperty(props, clickedProperty, mouseEvent->modifiers() == Qt::ControlModifier, index);
                 return true;
             }
         } else if (leftButton && visibilityClicked) {
             KisBaseNode::PropertyList props = index.data(KisNodeModel::PropertiesRole).value<KisBaseNode::PropertyList>();
             OptionalProperty clickedProperty = d->findVisibilityProperty(props);
             if (!clickedProperty) return false;
             d->toggleProperty(props, clickedProperty, mouseEvent->modifiers() == Qt::ControlModifier, index);
             return true;
         } else if (leftButton && decorationClicked) {
             bool isExpandable = model->hasChildren(index);
             if (isExpandable) {
                 bool isExpanded = d->view->isExpanded(index);
                 d->view->setExpanded(index, !isExpanded);
                 return true;
             }
         }
 
         if (mouseEvent->button() == Qt::LeftButton &&
             mouseEvent->modifiers() == Qt::AltModifier) {
 
             d->view->setCurrentIndex(index);
             model->setData(index, true, KisNodeModel::AlternateActiveRole);
             return true;
         }
     }
     else if (event->type() == QEvent::ToolTip) {
         if (!KisConfig().hidePopups()) {
             QHelpEvent *helpEvent = static_cast<QHelpEvent*>(event);
             d->tip.showTip(d->view, helpEvent->pos(), option, index);
         }
         return true;
     } else if (event->type() == QEvent::Leave) {
         d->tip.hide();
     }
 
     return false;
 }
 
 QWidget *KisNodeDelegate::createEditor(QWidget *parent, const QStyleOptionViewItem&, const QModelIndex&) const
 {
     d->edit = new QLineEdit(parent);
     d->edit->installEventFilter(const_cast<KisNodeDelegate*>(this)); //hack?
     return d->edit;
 }
 
 void KisNodeDelegate::setEditorData(QWidget *widget, const QModelIndex &index) const
 {
     QLineEdit *edit = qobject_cast<QLineEdit*>(widget);
     Q_ASSERT(edit);
 
     edit->setText(index.data(Qt::DisplayRole).toString());
 }
 
 void KisNodeDelegate::setModelData(QWidget *widget, QAbstractItemModel *model, const QModelIndex &index) const
 {
     QLineEdit *edit = qobject_cast<QLineEdit*>(widget);
     Q_ASSERT(edit);
 
     model->setData(index, edit->text(), Qt::DisplayRole);
 }
 
 void KisNodeDelegate::updateEditorGeometry(QWidget *widget, const QStyleOptionViewItem &option, const QModelIndex &index) const
 {
     Q_UNUSED(index);
     widget->setGeometry(option.rect);
 }
 
 
 // PROTECTED
 
 
 bool KisNodeDelegate::eventFilter(QObject *object, QEvent *event)
 {
     switch (event->type()) {
     case QEvent::MouseButtonPress: {
         if (d->edit) {
             QMouseEvent *me = static_cast<QMouseEvent*>(event);
             if (!QRect(d->edit->mapToGlobal(QPoint()), d->edit->size()).contains(me->globalPos())) {
                 emit commitData(d->edit);
                 emit closeEditor(d->edit);
             }
         }
     } break;
     case QEvent::KeyPress: {
         QLineEdit *edit = qobject_cast<QLineEdit*>(object);
         if (edit && edit == d->edit) {
             QKeyEvent *ke = static_cast<QKeyEvent*>(event);
             switch (ke->key()) {
             case Qt::Key_Escape:
                 emit closeEditor(edit);
                 return true;
             case Qt::Key_Tab:
                 emit commitData(edit);
                 emit closeEditor(edit,EditNextItem);
                 return true;
             case Qt::Key_Backtab:
                 emit commitData(edit);
                 emit closeEditor(edit, EditPreviousItem);
                 return true;
             case Qt::Key_Return:
             case Qt::Key_Enter:
                 emit commitData(edit);
                 emit closeEditor(edit);
                 return true;
             default: break;
             }
         }
     } break;
+    case QEvent::ShortcutOverride : {
+        QLineEdit *edit = qobject_cast<QLineEdit*>(object);
+        if (edit && edit == d->edit){
+            auto* key = static_cast<QKeyEvent*>(event);
+            if (key->modifiers() == Qt::NoModifier){
+                switch (key->key()){
+                case Qt::Key_Escape:
+                case Qt::Key_Tab:
+                case Qt::Key_Backtab:
+                case Qt::Key_Return:
+                case Qt::Key_Enter:
+                    event->accept();
+                    return true;
+                default: break;
+                }
+            }
+        }
+
+    } break;
     case QEvent::FocusOut : {
         QLineEdit *edit = qobject_cast<QLineEdit*>(object);
         if (edit && edit == d->edit) {
             emit commitData(edit);
             emit closeEditor(edit);
         }
     }
     default: break;
     }
 
     return QAbstractItemDelegate::eventFilter(object, event);
 }
 
 
 // PRIVATE
 
 
 QStyleOptionViewItem KisNodeDelegate::getOptions(const QStyleOptionViewItem &o, const QModelIndex &index)
 {
     QStyleOptionViewItem option = o;
     QVariant v = index.data(Qt::FontRole);
     if (v.isValid()) {
         option.font = v.value<QFont>();
         option.fontMetrics = QFontMetrics(option.font);
     }
     v = index.data(Qt::TextAlignmentRole);
     if (v.isValid())
         option.displayAlignment = QFlag(v.toInt());
     v = index.data(Qt::TextColorRole);
     if (v.isValid())
         option.palette.setColor(QPalette::Text, v.value<QColor>());
     v = index.data(Qt::BackgroundColorRole);
     if (v.isValid())
         option.palette.setColor(QPalette::Window, v.value<QColor>());
 
    return option;
 }
 
 QRect KisNodeDelegate::progressBarRect(const QStyleOptionViewItem &option, const QModelIndex &index) const
 {
     return iconsRect(option, index);
 }
 
 void KisNodeDelegate::drawProgressBar(QPainter *p, const QStyleOptionViewItem &option, const QModelIndex &index) const
 {
     QVariant value = index.data(KisNodeModel::ProgressRole);
     if (!value.isNull() && (value.toInt() >= 0 && value.toInt() <= 100)) {
         const QRect r = progressBarRect(option, index);
         p->save();
         {
             p->setClipRect(r);
             QStyle* style = QApplication::style();
             QStyleOptionProgressBar opt;
 
             opt.minimum = 0;
             opt.maximum = 100;
             opt.progress = value.toInt();
             opt.textVisible = true;
             opt.textAlignment = Qt::AlignHCenter;
             opt.text = i18n("%1 %", opt.progress);
             opt.rect = r;
             opt.orientation = Qt::Horizontal;
             opt.state = option.state;
             style->drawControl(QStyle::CE_ProgressBar, &opt, p, 0);
         }
         p->restore();
     }
 }
diff --git a/libs/ui/input/KisQtWidgetsTweaker.cpp b/libs/ui/input/KisQtWidgetsTweaker.cpp
new file mode 100644
index 0000000000..31921a7c18
--- /dev/null
+++ b/libs/ui/input/KisQtWidgetsTweaker.cpp
@@ -0,0 +1,327 @@
+/* This file is part of the KDE project
+   Copyright (C) 2017 Nikita Vertikov   <kitmouse.nikita@gmail.com>
+
+   This library is free software; you can redistribute it and/or
+   modify it under the terms of the GNU Library General Public
+   License as published by the Free Software Foundation; either
+   version 2 of the License, or (at your option) any later version.
+
+   This library is distributed in the hope that it will be useful,
+   but WITHOUT ANY WARRANTY; without even the implied warranty of
+   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+   Library General Public License for more details.
+
+   You should have received a copy of the GNU Library General Public License
+   along with this library; see the file COPYING.LIB.  If not, write to
+   the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
+ * Boston, MA 02110-1301, USA.
+*/
+
+#include "KisQtWidgetsTweaker.h"
+
+#include <QBitArray>
+#include <QComboBox>
+#include <QDockWidget>
+#include <QDoubleSpinBox>
+#include <QEvent>
+#include <QKeyEvent>
+#include <QKeySequence>
+#include <QLineEdit>
+#include <QSpinBox>
+
+#include "opengl/kis_opengl_canvas2.h"
+#include "canvas/kis_qpainter_canvas.h"
+#include "KisMainWindow.h"
+
+Q_GLOBAL_STATIC(KisQtWidgetsTweaker, kqwt_instance)
+
+
+namespace {
+
+class ShortcutOverriderBase
+{
+public:
+    enum class decisionOnShortcutOverride{overrideShortcut,
+                                          askNext,
+                                          dontOverrideShortcut};
+    constexpr ShortcutOverriderBase() = default;
+    virtual ~ShortcutOverriderBase()
+    {}
+    virtual bool interestedInEvent(QKeyEvent *event) = 0;
+    virtual decisionOnShortcutOverride handleEvent(QObject *receiver, QKeyEvent *event) = 0;
+    virtual decisionOnShortcutOverride FinishedPhysicalKeyPressHandling()
+    {
+        return decisionOnShortcutOverride::askNext;
+    }
+};
+
+class LineTextEditingShortcutOverrider : public ShortcutOverriderBase
+{
+public:
+    constexpr LineTextEditingShortcutOverrider() = default;
+
+    virtual bool interestedInEvent(QKeyEvent *event) override
+    {
+        static constexpr QKeySequence::StandardKey actionsForQLineEdit[]{
+             QKeySequence::MoveToNextChar
+            ,QKeySequence::MoveToPreviousChar
+            ,QKeySequence::MoveToStartOfLine
+            ,QKeySequence::MoveToEndOfLine
+            ,QKeySequence::MoveToPreviousWord
+            ,QKeySequence::MoveToNextWord
+            ,QKeySequence::SelectPreviousChar
+            ,QKeySequence::SelectNextChar
+            ,QKeySequence::SelectNextWord
+            ,QKeySequence::SelectPreviousWord
+            ,QKeySequence::SelectStartOfLine
+            ,QKeySequence::SelectEndOfLine
+            ,QKeySequence::SelectAll
+            ,QKeySequence::Deselect
+            ,QKeySequence::Backspace
+            ,QKeySequence::DeleteStartOfWord
+            ,QKeySequence::Delete
+            ,QKeySequence::DeleteEndOfWord
+            ,QKeySequence::DeleteEndOfLine
+            ,QKeySequence::Copy
+            ,QKeySequence::Paste
+            ,QKeySequence::Cut
+            ,QKeySequence::Undo
+            ,QKeySequence::Redo
+        };
+        for(QKeySequence::StandardKey sk : actionsForQLineEdit) {
+            if (event->matches(sk)) {
+                event->accept();
+                return true;
+            }
+        }
+        return false;
+    }
+    virtual decisionOnShortcutOverride handleEvent(QObject *receiver, QKeyEvent *event)  override
+    {
+        if( (qobject_cast<QLineEdit*>     (receiver) != nullptr)||
+            (qobject_cast<QSpinBox*>      (receiver) != nullptr)||
+            (qobject_cast<QDoubleSpinBox*>(receiver) != nullptr)) {
+
+            return decisionOnShortcutOverride::overrideShortcut;
+        }else{
+            return decisionOnShortcutOverride::askNext;
+        }
+    }
+};
+
+class SpingboxShortcutOverrider : public ShortcutOverriderBase
+{
+public:
+    constexpr SpingboxShortcutOverrider() = default;
+
+    virtual bool interestedInEvent(QKeyEvent *event) override
+    {
+        if(event->modifiers() != Qt::NoModifier) {
+            return false;
+        }
+        switch(event->key()) {
+        case Qt::Key_Down:
+        case Qt::Key_Up:
+        case Qt::Key_PageDown:
+        case Qt::Key_PageUp:
+            event->accept();
+            return true;
+        default:
+            return false;
+        }
+    }
+    virtual decisionOnShortcutOverride handleEvent(QObject *receiver, QKeyEvent *event)  override
+    {
+        if (qobject_cast<QSpinBox*>      (receiver) != nullptr||
+            qobject_cast<QDoubleSpinBox*>(receiver) != nullptr) {
+
+            return decisionOnShortcutOverride::overrideShortcut;
+        }else{
+            return decisionOnShortcutOverride::askNext;
+        }
+
+    }
+};
+
+class TabShortcutOverrider : public ShortcutOverriderBase
+{
+public:
+    constexpr TabShortcutOverrider() = default;
+
+    virtual bool interestedInEvent(QKeyEvent *event) override
+    {
+        bool tab = event->modifiers() == Qt::NoModifier &&
+                    ( event->key() == Qt::Key_Tab ||
+                      event->key() == Qt::Key_Backtab);
+        bool shiftTab = event->modifiers() == Qt::ShiftModifier &&
+                         event->key() == Qt::Key_Backtab;
+        if (tab || shiftTab) {
+            return true;
+        }else{
+            return false;
+        }
+    }
+    virtual decisionOnShortcutOverride handleEvent(QObject *receiver, QKeyEvent *event)  override
+    {
+        if(qobject_cast<KisQPainterCanvas*>(receiver) != nullptr||
+           qobject_cast<KisOpenGLCanvas2*> (receiver) != nullptr) {
+            return decisionOnShortcutOverride::dontOverrideShortcut;
+        }else{
+            m_nooverride = true;
+            return decisionOnShortcutOverride::askNext;
+        }
+    }
+    virtual decisionOnShortcutOverride FinishedPhysicalKeyPressHandling() override
+    {
+        if (m_nooverride){
+            m_nooverride = false;
+            return decisionOnShortcutOverride::overrideShortcut;
+        }
+        return decisionOnShortcutOverride::askNext;
+    }
+private:
+    bool m_nooverride = false;
+
+};
+
+
+//for some reason I can't just populate constexpr
+//pointer array using "new"
+LineTextEditingShortcutOverrider overrider0;
+SpingboxShortcutOverrider overrider1;
+TabShortcutOverrider overrider2;
+
+constexpr ShortcutOverriderBase *allShortcutOverriders[] = {
+    &overrider0, &overrider1, &overrider2
+};
+constexpr size_t numOfShortcutOverriders =
+                    sizeof(allShortcutOverriders)/
+                    sizeof(allShortcutOverriders[0]);
+
+
+
+} //namespace
+
+struct KisQtWidgetsTweaker::Private
+{
+public:
+    Private(KisQtWidgetsTweaker *parent)
+        :q(parent)
+        ,lastKeyPressProcessingComplete(true)
+        ,decision(ShortcutOverriderBase::decisionOnShortcutOverride::askNext)
+        ,interestedHandlers(numOfShortcutOverriders)
+    {    }
+    const KisQtWidgetsTweaker *q;
+
+    QBitArray interestedHandlers = QBitArray(numOfShortcutOverriders);
+
+    ShortcutOverriderBase::decisionOnShortcutOverride decision =
+            ShortcutOverriderBase::decisionOnShortcutOverride::askNext;
+    //unsigned long lastEventTimestamp=0;
+
+    bool lastKeyPressProcessingComplete = true;
+    void newPhysicalKeyPressed(QKeyEvent *event)
+    {
+        for(int i=0; i < numOfShortcutOverriders;++i) {
+            if (allShortcutOverriders[i]->interestedInEvent(event)) {
+                interestedHandlers.setBit(i);
+            }else{
+                interestedHandlers.clearBit(i);
+            }
+        }
+        decision = ShortcutOverriderBase::decisionOnShortcutOverride::askNext;
+        lastKeyPressProcessingComplete = false;
+    }
+};
+
+KisQtWidgetsTweaker::KisQtWidgetsTweaker(QObject *parent)
+    :QObject(parent)
+    , d(new KisQtWidgetsTweaker::Private(this))
+{
+
+}
+
+KisQtWidgetsTweaker::~KisQtWidgetsTweaker()
+{
+    delete d;
+}
+bool KisQtWidgetsTweaker::eventFilter(QObject *receiver, QEvent *event)
+{
+    switch(event->type()) {
+    case QEvent::ShortcutOverride:{
+        //QLineEdit and other widgets lets qt's shortcut system take away it's keyboard events
+        //even is it knows them, such as ctrl+backspace
+        //if there is application-wide shortcut, assigned to it.
+        //The following code fixes it
+        //by accepting ShortcutOverride events.
+
+        //if you press key 'a' and then 'b', qt at first call
+        //all handlers for 'a' key press event, and only after that
+        //for 'b'
+        QKeyEvent *key = static_cast<QKeyEvent*>(event);
+        if (d->lastKeyPressProcessingComplete) {
+            d->newPhysicalKeyPressed(key);
+        }
+        for(int i=0; i < numOfShortcutOverriders;++i) {
+            if (d->decision != ShortcutOverriderBase::decisionOnShortcutOverride::askNext) {
+                break;
+            }
+            if (d->interestedHandlers.at(i)) {
+                d->decision = allShortcutOverriders[i]->handleEvent(receiver, key);
+            }
+        }
+        //if nothing said wether shortcutoverride to be accepted
+        //last widget that qt will ask will be kismainwindow or docker
+        if(qobject_cast<KisMainWindow*>(receiver)!=nullptr||
+           receiver->inherits(QDockWidget::staticMetaObject.className())) {
+            for(int i=0; i < numOfShortcutOverriders;++i) {
+                if (d->decision != ShortcutOverriderBase::decisionOnShortcutOverride::askNext) {
+                    break;
+                }
+                if (d->interestedHandlers.at(i)) {
+                    d->decision = allShortcutOverriders[i]->FinishedPhysicalKeyPressHandling();
+                }
+            }
+
+            d->lastKeyPressProcessingComplete = true;
+        }
+        bool retval = false;
+        switch(d->decision) {
+        case ShortcutOverriderBase::decisionOnShortcutOverride::askNext:
+            event->ignore();
+            retval = false;
+            break;
+        case ShortcutOverriderBase::decisionOnShortcutOverride::dontOverrideShortcut:
+            event->ignore();
+            retval = true;
+            break;
+        case ShortcutOverriderBase::decisionOnShortcutOverride::overrideShortcut:
+            event->accept();
+            //once shortcutoverride acepted, qt stop asking everyone
+            //about it and proceed to handling next event
+            d->lastKeyPressProcessingComplete = true;
+            retval = true;
+            break;
+        }
+
+        return retval || QObject::eventFilter(receiver, event);
+
+    }break;
+
+        //other event types
+    default:
+        break;
+    }
+
+
+    //code for tweaking the behavior of other qt elements will go here
+
+
+    return QObject::eventFilter(receiver, event);
+}
+
+
+KisQtWidgetsTweaker *KisQtWidgetsTweaker::instance()
+{
+    return kqwt_instance;
+}
diff --git a/libs/ui/input/KisQtWidgetsTweaker.h b/libs/ui/input/KisQtWidgetsTweaker.h
new file mode 100644
index 0000000000..0778c956f0
--- /dev/null
+++ b/libs/ui/input/KisQtWidgetsTweaker.h
@@ -0,0 +1,48 @@
+/* This file is part of the KDE project
+   Copyright (C) 2017 Nikita Vertikov   <kitmouse.nikita@gmail.com>
+
+   This library is free software; you can redistribute it and/or
+   modify it under the terms of the GNU Library General Public
+   License as published by the Free Software Foundation; either
+   version 2 of the License, or (at your option) any later version.
+
+   This library is distributed in the hope that it will be useful,
+   but WITHOUT ANY WARRANTY; without even the implied warranty of
+   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+   Library General Public License for more details.
+
+   You should have received a copy of the GNU Library General Public License
+   along with this library; see the file COPYING.LIB.  If not, write to
+   the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
+ * Boston, MA 02110-1301, USA.
+*/
+#ifndef KISQTWIDGETTWEAKER_H
+#define KISQTWIDGETTWEAKER_H
+
+#include <QObject>
+#include "kritaui_export.h"
+
+class QEvent;
+
+/**
+ * KisQtWidgetsTweaker is used to make minor adjustments to
+ * "native" qt widgets' behavior application-wise
+ * by filtering events adressed to them
+ * It expected to be installed on the application
+ */
+class KRITAUI_EXPORT KisQtWidgetsTweaker : public QObject
+{
+    Q_OBJECT
+public:
+    KisQtWidgetsTweaker(QObject* parent = nullptr);
+    ~KisQtWidgetsTweaker();
+    bool eventFilter(QObject *receiver, QEvent* event);
+    static KisQtWidgetsTweaker *instance();
+
+private:
+    struct Private;
+    Private* d;
+};
+
+
+#endif //KISQTWIDGETTWEAKER_H
diff --git a/libs/ui/widgets/kis_slider_spin_box.cpp b/libs/ui/widgets/kis_slider_spin_box.cpp
index 9098e26d24..38def0995e 100644
--- a/libs/ui/widgets/kis_slider_spin_box.cpp
+++ b/libs/ui/widgets/kis_slider_spin_box.cpp
@@ -1,1028 +1,1047 @@
 /* This file is part of the KDE project
  * Copyright (c) 2010 Justin Noel <justin@ics.com>
  * Copyright (c) 2010 Cyrille Berger <cberger@cberger.net>
  * Copyright (c) 2015 Moritz Molch <kde@moritzmolch.de>
  *
  * This library is free software; you can redistribute it and/or
  * modify it under the terms of the GNU Library General Public
  * License as published by the Free Software Foundation; either
  * version 2 of the License, or (at your option) any later version.
  *
  * This library is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  * Library General Public License for more details.
  *
  * You should have received a copy of the GNU Library General Public License
  * along with this library; see the file COPYING.LIB.  If not, write to
  * the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
  * Boston, MA 02110-1301, USA.
  */
 #include "kis_slider_spin_box.h"
 
 #include <math.h>
 
 #include <QPainter>
 #include <QStyle>
 #include <QLineEdit>
 #include <QApplication>
 #include <QKeyEvent>
 #include <QMouseEvent>
 #include <QIntValidator>
 #include <QTimer>
 #include <QtDebug>
 #include <QDoubleSpinBox>
 #include "kis_cursor.h"
 #include "KisPart.h"
 #include "input/kis_input_manager.h"
 
 #include "kis_num_parser.h"
 
 class KisAbstractSliderSpinBoxPrivate {
 public:
     enum Style {
         STYLE_NOQUIRK,
         STYLE_PLASTIQUE,
         STYLE_BREEZE,
         STYLE_FUSION,
     };
 
     QLineEdit* edit;
     QDoubleValidator* validator;
     bool upButtonDown;
     bool downButtonDown;
     int factor;
     int fastSliderStep;
     qreal slowFactor;
     qreal shiftPercent;
     bool shiftMode;
     QString prefix;
     QString suffix;
     qreal exponentRatio;
     int value;
     int maximum;
     int minimum;
     int singleStep;
     QSpinBox* dummySpinBox;
     Style style;
     bool blockUpdateSignalOnDrag;
     bool isDragging;
     bool parseInt;
 };
 
 KisAbstractSliderSpinBox::KisAbstractSliderSpinBox(QWidget* parent, KisAbstractSliderSpinBoxPrivate* _d)
     : QWidget(parent)
     , d_ptr(_d)
 {
     Q_D(KisAbstractSliderSpinBox);
     QEvent e(QEvent::StyleChange);
     changeEvent(&e);
 
     d->upButtonDown = false;
     d->downButtonDown = false;
     d->edit = new QLineEdit(this);
     d->edit->setFrame(false);
     d->edit->setAlignment(Qt::AlignCenter);
     d->edit->hide();
     d->edit->setContentsMargins(0,0,0,0);
     d->edit->installEventFilter(this);
 
     //Make edit transparent
     d->edit->setAutoFillBackground(false);
     QPalette pal = d->edit->palette();
     pal.setColor(QPalette::Base, Qt::transparent);
     d->edit->setPalette(pal);
 
     connect(d->edit, SIGNAL(editingFinished()), this, SLOT(editLostFocus()));
 
     d->validator = new QDoubleValidator(d->edit);
 
     d->value = 0;
     d->minimum = 0;
     d->maximum = 100;
     d->factor = 1.0;
     d->singleStep = 1;
     d->fastSliderStep = 5;
     d->slowFactor = 0.1;
     d->shiftMode = false;
     d->blockUpdateSignalOnDrag = false;
     d->isDragging = false;
 
     d->parseInt = false;
 
     setExponentRatio(1.0);
     setCursor(KisCursor::splitHCursor());
 
     //Set sane defaults
     setFocusPolicy(Qt::StrongFocus);
     setSizePolicy(QSizePolicy::Preferred, QSizePolicy::Fixed);
 
     //dummy needed to fix a bug in the polyester theme
     d->dummySpinBox = new QSpinBox(this);
     d->dummySpinBox->hide();
 }
 
 KisAbstractSliderSpinBox::~KisAbstractSliderSpinBox()
 {
     Q_D(KisAbstractSliderSpinBox);
     delete d;
 }
 
 void KisAbstractSliderSpinBox::showEdit()
 {
     Q_D(KisAbstractSliderSpinBox);
     if (d->edit->isVisible()) return;
     if (d->style == KisAbstractSliderSpinBoxPrivate::STYLE_PLASTIQUE) {
         d->edit->setGeometry(progressRect(spinBoxOptions()).adjusted(0,0,-2,0));
     }
     else {
         d->edit->setGeometry(progressRect(spinBoxOptions()));
     }
     d->edit->setText(valueString());
     d->edit->selectAll();
     d->edit->show();
     d->edit->setFocus(Qt::OtherFocusReason);
     update();
 }
 
 void KisAbstractSliderSpinBox::hideEdit()
 {
     Q_D(KisAbstractSliderSpinBox);
     d->edit->hide();
     update();
 }
 
 void KisAbstractSliderSpinBox::paintEvent(QPaintEvent* e)
 {
     Q_D(KisAbstractSliderSpinBox);
     Q_UNUSED(e)
 
     QPainter painter(this);
 
     switch (d->style) {
     case KisAbstractSliderSpinBoxPrivate::STYLE_FUSION:
         paintFusion(painter);
         break;
     case KisAbstractSliderSpinBoxPrivate::STYLE_PLASTIQUE:
         paintPlastique(painter);
         break;
     case KisAbstractSliderSpinBoxPrivate::STYLE_BREEZE:
         paintBreeze(painter);
         break;
     default:
         paint(painter);
         break;
     }
 
     painter.end();
 }
 
 void KisAbstractSliderSpinBox::paint(QPainter &painter)
 {
     Q_D(KisAbstractSliderSpinBox);
 
     //Create options to draw spin box parts
     QStyleOptionSpinBox spinOpts = spinBoxOptions();
     spinOpts.rect.adjust(0, 2, 0, -2);
 
     //Draw "SpinBox".Clip off the area of the lineEdit to avoid double
     //borders being drawn
     painter.save();
     painter.setClipping(true);
 
     QRect eraseRect(QPoint(rect().x(), rect().y()),
                     QPoint(progressRect(spinOpts).right(), rect().bottom()));
 
     painter.setClipRegion(QRegion(rect()).subtracted(eraseRect));
     style()->drawComplexControl(QStyle::CC_SpinBox, &spinOpts, &painter, d->dummySpinBox);
     painter.setClipping(false);
     painter.restore();
 
 
     QStyleOptionProgressBar progressOpts = progressBarOptions();
     progressOpts.rect.adjust(0, 2, 0, -2);
     style()->drawControl(QStyle::CE_ProgressBar, &progressOpts, &painter, 0);
 
     //Draw focus if necessary
     if (hasFocus() &&
             d->edit->hasFocus()) {
         QStyleOptionFocusRect focusOpts;
         focusOpts.initFrom(this);
         focusOpts.rect = progressOpts.rect;
         focusOpts.backgroundColor = palette().color(QPalette::Window);
         style()->drawPrimitive(QStyle::PE_FrameFocusRect, &focusOpts, &painter, this);
     }
 }
 
 void KisAbstractSliderSpinBox::paintFusion(QPainter &painter)
 {
     Q_D(KisAbstractSliderSpinBox);
 
     QStyleOptionSpinBox spinOpts = spinBoxOptions();
     spinOpts.frame = true;
     spinOpts.rect.adjust(0, -1, 0, 1);
     //spinOpts.palette().setBrush(QPalette::Base, palette().highlight());
     QStyleOptionProgressBar progressOpts = progressBarOptions();
 
     style()->drawComplexControl(QStyle::CC_SpinBox, &spinOpts, &painter, d->dummySpinBox);
 
     painter.save();
 
     QRect rect = progressOpts.rect.adjusted(1,2,-4,-2);
     QRect leftRect;
 
     int progressIndicatorPos = (progressOpts.progress - qreal(progressOpts.minimum)) / qMax(qreal(1.0),
                                qreal(progressOpts.maximum) - progressOpts.minimum) * rect.width();
 
     if (progressIndicatorPos >= 0 && progressIndicatorPos <= rect.width()) {
         leftRect = QRect(rect.left(), rect.top(), progressIndicatorPos, rect.height());
     } else if (progressIndicatorPos > rect.width()) {
         painter.setPen(palette().highlightedText().color());
     } else {
         painter.setPen(palette().buttonText().color());
     }
 
     QRegion rightRect = rect;
     rightRect = rightRect.subtracted(leftRect);
 
     QTextOption textOption(Qt::AlignAbsolute | Qt::AlignHCenter | Qt::AlignVCenter);
     textOption.setWrapMode(QTextOption::NoWrap);
 
     if (!(d->edit && d->edit->isVisible())) {
         painter.setClipRegion(rightRect);
         painter.setClipping(true);
         painter.drawText(rect.adjusted(-2,0,2,0), progressOpts.text, textOption);
         painter.setClipping(false);
     }
 
     if (!leftRect.isNull()) {
         painter.setClipRect(leftRect.adjusted(0, -1, 1, 1));
         painter.setPen(palette().highlight().color());
         painter.setBrush(palette().highlight());
 
         spinOpts.palette.setBrush(QPalette::Base, palette().highlight());
         style()->drawComplexControl(QStyle::CC_SpinBox, &spinOpts, &painter, d->dummySpinBox);
 
         if (!(d->edit && d->edit->isVisible())) {
             painter.setPen(palette().highlightedText().color());
             painter.setClipping(true);
             painter.drawText(rect.adjusted(-2,0,2,0), progressOpts.text, textOption);
         }
         painter.setClipping(false);
     }
 
     painter.restore();
 }
 
 void KisAbstractSliderSpinBox::paintPlastique(QPainter &painter)
 {
     Q_D(KisAbstractSliderSpinBox);
 
     QStyleOptionSpinBox spinOpts = spinBoxOptions();
     QStyleOptionProgressBar progressOpts = progressBarOptions();
 
     style()->drawComplexControl(QStyle::CC_SpinBox, &spinOpts, &painter, d->dummySpinBox);
 
     painter.save();
 
     QRect rect = progressOpts.rect.adjusted(2,0,-2,0);
     QRect leftRect;
 
     int progressIndicatorPos = (progressOpts.progress - qreal(progressOpts.minimum)) / qMax(qreal(1.0),
                                qreal(progressOpts.maximum) - progressOpts.minimum) * rect.width();
 
     if (progressIndicatorPos >= 0 && progressIndicatorPos <= rect.width()) {
         leftRect = QRect(rect.left(), rect.top(), progressIndicatorPos, rect.height());
     } else if (progressIndicatorPos > rect.width()) {
         painter.setPen(palette().highlightedText().color());
     } else {
         painter.setPen(palette().buttonText().color());
     }
 
     QRegion rightRect = rect;
     rightRect = rightRect.subtracted(leftRect);
 
     QTextOption textOption(Qt::AlignAbsolute | Qt::AlignHCenter | Qt::AlignVCenter);
     textOption.setWrapMode(QTextOption::NoWrap);
 
     if (!(d->edit && d->edit->isVisible())) {
         painter.setClipRegion(rightRect);
         painter.setClipping(true);
         painter.drawText(rect.adjusted(-2,0,2,0), progressOpts.text, textOption);
         painter.setClipping(false);
     }
 
     if (!leftRect.isNull()) {
         painter.setPen(palette().highlight().color());
         painter.setBrush(palette().highlight());
         painter.drawRect(leftRect.adjusted(0,0,0,-1));
         if (!(d->edit && d->edit->isVisible())) {
             painter.setPen(palette().highlightedText().color());
             painter.setClipRect(leftRect.adjusted(0,0,1,0));
             painter.setClipping(true);
             painter.drawText(rect.adjusted(-2,0,2,0), progressOpts.text, textOption);
             painter.setClipping(false);
         }
     }
 
     painter.restore();
 }
 
 void KisAbstractSliderSpinBox::paintBreeze(QPainter &painter)
 {
     Q_D(KisAbstractSliderSpinBox);
 
     QStyleOptionSpinBox spinOpts = spinBoxOptions();
     QStyleOptionProgressBar progressOpts = progressBarOptions();
     QString valueText = progressOpts.text;
     progressOpts.text = "";
     progressOpts.rect.adjust(0, 1, 0, -1);
 
     style()->drawComplexControl(QStyle::CC_SpinBox, &spinOpts, &painter, this);
     style()->drawControl(QStyle::CE_ProgressBarGroove, &progressOpts, &painter, this);
 
     painter.save();
 
     QRect leftRect;
 
     int progressIndicatorPos = (progressOpts.progress - qreal(progressOpts.minimum)) / qMax(qreal(1.0),
                                qreal(progressOpts.maximum) - progressOpts.minimum) * progressOpts.rect.width();
 
     if (progressIndicatorPos >= 0 && progressIndicatorPos <= progressOpts.rect.width()) {
         leftRect = QRect(progressOpts.rect.left(), progressOpts.rect.top(), progressIndicatorPos, progressOpts.rect.height());
     } else if (progressIndicatorPos > progressOpts.rect.width()) {
         painter.setPen(palette().highlightedText().color());
     } else {
         painter.setPen(palette().buttonText().color());
     }
 
     QRegion rightRect = progressOpts.rect;
     rightRect = rightRect.subtracted(leftRect);
     painter.setClipRegion(rightRect);
 
     QTextOption textOption(Qt::AlignAbsolute | Qt::AlignHCenter | Qt::AlignVCenter);
     textOption.setWrapMode(QTextOption::NoWrap);
 
     if (!(d->edit && d->edit->isVisible())) {
         painter.drawText(progressOpts.rect, valueText, textOption);
     }
 
     if (!leftRect.isNull()) {
         painter.setPen(palette().highlightedText().color());
         painter.setClipRect(leftRect);
         style()->drawControl(QStyle::CE_ProgressBarContents, &progressOpts, &painter, this);
         if (!(d->edit && d->edit->isVisible())) {
             painter.drawText(progressOpts.rect, valueText, textOption);
         }
     }
 
     painter.restore();
 
 }
 
 void KisAbstractSliderSpinBox::mousePressEvent(QMouseEvent* e)
 {
     Q_D(KisAbstractSliderSpinBox);
     QStyleOptionSpinBox spinOpts = spinBoxOptions();
 
     //Depress buttons or highlight slider
     //Also used to emulate mouse grab...
     if (e->buttons() & Qt::LeftButton) {
         if (upButtonRect(spinOpts).contains(e->pos())) {
             d->upButtonDown = true;
         } else if (downButtonRect(spinOpts).contains(e->pos())) {
             d->downButtonDown = true;
         }
     } else if (e->buttons() & Qt::RightButton) {
         showEdit();
     }
 
 
     update();
 }
 
 void KisAbstractSliderSpinBox::mouseReleaseEvent(QMouseEvent* e)
 {
     Q_D(KisAbstractSliderSpinBox);
     QStyleOptionSpinBox spinOpts = spinBoxOptions();
 
     d->isDragging = false;
 
     //Step up/down for buttons
     //Emualting mouse grab too
     if (upButtonRect(spinOpts).contains(e->pos()) && d->upButtonDown) {
         setInternalValue(d->value + d->singleStep);
     } else if (downButtonRect(spinOpts).contains(e->pos()) && d->downButtonDown) {
         setInternalValue(d->value - d->singleStep);
     } else if (progressRect(spinOpts).contains(e->pos()) &&
                !(d->edit->isVisible()) &&
                !(d->upButtonDown || d->downButtonDown)) {
         //Snap to percentage for progress area
         setInternalValue(valueForX(e->pos().x(),e->modifiers()));
     } else { // Confirm the last known value, since we might be ignoring move events
         setInternalValue(d->value);
     }
 
     d->upButtonDown = false;
     d->downButtonDown = false;
     update();
 }
 
 void KisAbstractSliderSpinBox::mouseMoveEvent(QMouseEvent* e)
 {
     Q_D(KisAbstractSliderSpinBox);
 
     if( e->modifiers() & Qt::ShiftModifier ) {
         if( !d->shiftMode ) {
             d->shiftPercent = pow( qreal(d->value - d->minimum)/qreal(d->maximum - d->minimum), 1/qreal(d->exponentRatio) );
             d->shiftMode = true;
         }
     } else {
         d->shiftMode = false;
     }
 
     //Respect emulated mouse grab.
     if (e->buttons() & Qt::LeftButton &&
             !(d->downButtonDown || d->upButtonDown)) {
         d->isDragging = true;
         setInternalValue(valueForX(e->pos().x(),e->modifiers()), d->blockUpdateSignalOnDrag);
         update();
     }
 }
 
 void KisAbstractSliderSpinBox::keyPressEvent(QKeyEvent* e)
 {
     Q_D(KisAbstractSliderSpinBox);
     switch (e->key()) {
     case Qt::Key_Up:
     case Qt::Key_Right:
         setInternalValue(d->value + d->singleStep);
         break;
     case Qt::Key_Down:
     case Qt::Key_Left:
         setInternalValue(d->value - d->singleStep);
         break;
     case Qt::Key_Shift:
         d->shiftPercent = pow( qreal(d->value - d->minimum)/qreal(d->maximum - d->minimum), 1/qreal(d->exponentRatio) );
         d->shiftMode = true;
         break;
     case Qt::Key_Enter: //Line edit isn't "accepting" key strokes...
     case Qt::Key_Return:
     case Qt::Key_Escape:
     case Qt::Key_Control:
     case Qt::Key_Alt:
     case Qt::Key_AltGr:
     case Qt::Key_Super_L:
     case Qt::Key_Super_R:
         break;
     default:
         showEdit();
         d->edit->event(e);
         break;
     }
 }
 
 void KisAbstractSliderSpinBox::wheelEvent(QWheelEvent *e)
 {
 
     Q_D(KisAbstractSliderSpinBox);
     if ( e->delta() > 0) {
         setInternalValue(d->value + d->singleStep);
     } else {
         setInternalValue(d->value - d->singleStep);
     }
     update();
     e->accept();
 }
 
+bool KisAbstractSliderSpinBox::event(QEvent *event)
+{
+    if (event->type() == QEvent::ShortcutOverride){
+        QKeyEvent* key = static_cast<QKeyEvent*>(event);
+        if (key->modifiers() == Qt::NoModifier){
+            switch(key->key()){
+            case Qt::Key_Up:
+            case Qt::Key_Right:
+            case Qt::Key_Down:
+            case Qt::Key_Left:
+                event->accept();
+                return true;
+            default: break;
+            }
+        }
+    }
+    return QWidget::event(event);
+}
+
 void KisAbstractSliderSpinBox::commitEnteredValue()
 {
     Q_D(KisAbstractSliderSpinBox);
 
     //QLocale locale;
     bool ok = false;
 
     //qreal value = locale.toDouble(d->edit->text(), &ok) * d->factor;
     qreal value;
 
     if (d->parseInt) {
         value = KisNumericParser::parseIntegerMathExpr(d->edit->text(), &ok) * d->factor;
     } else {
         value = KisNumericParser::parseSimpleMathExpr(d->edit->text(), &ok) * d->factor;
     }
 
     if (ok) {
         setInternalValue(value);
     }
 }
 
 bool KisAbstractSliderSpinBox::eventFilter(QObject* recv, QEvent* e)
 {
     Q_D(KisAbstractSliderSpinBox);
     if (recv == static_cast<QObject*>(d->edit) &&
             e->type() == QEvent::KeyRelease) {
         QKeyEvent* keyEvent = static_cast<QKeyEvent*>(e);
 
         switch (keyEvent->key()) {
         case Qt::Key_Enter:
         case Qt::Key_Return: {
             commitEnteredValue();
             hideEdit();
             return true;
         }
         case Qt::Key_Escape:
             d->edit->setText(valueString());
             hideEdit();
             return true;
         default:
             break;
         }
     }
 
     return false;
 }
 
 QSize KisAbstractSliderSpinBox::sizeHint() const
 {
     const Q_D(KisAbstractSliderSpinBox);
     QStyleOptionSpinBox spinOpts = spinBoxOptions();
 
     QFont ft(font());
     if (d->style == KisAbstractSliderSpinBoxPrivate::STYLE_NOQUIRK) {
         // Some styles use bold font in progressbars
         // unfortunately there is no reliable way to check for that
         ft.setBold(true);
     }
 
     QFontMetrics fm(ft);
     QSize hint(fm.boundingRect(d->prefix + QString::number(d->maximum) + d->suffix).size());
     hint += QSize(0, 2);
 
     switch (d->style) {
     case KisAbstractSliderSpinBoxPrivate::STYLE_FUSION:
         hint += QSize(8, 8);
         break;
     case KisAbstractSliderSpinBoxPrivate::STYLE_PLASTIQUE:
         hint += QSize(8, 0);
         break;
     case KisAbstractSliderSpinBoxPrivate::STYLE_BREEZE:
         hint += QSize(2, 0);
         break;
     case KisAbstractSliderSpinBoxPrivate::STYLE_NOQUIRK:
         // almost all "modern" styles have a margin around controls
         hint += QSize(6, 6);
         break;
     default:
         break;
     }
 
     //Getting the size of the buttons is a pain as the calcs require a rect
     //that is "big enough". We run the calc twice to get the "smallest" buttons
     //This code was inspired by QAbstractSpinBox
     QSize extra(1000, 0);
     spinOpts.rect.setSize(hint + extra);
     extra += hint - style()->subControlRect(QStyle::CC_SpinBox, &spinOpts,
                                             QStyle::SC_SpinBoxEditField, this).size();
     spinOpts.rect.setSize(hint + extra);
     extra += hint - style()->subControlRect(QStyle::CC_SpinBox, &spinOpts,
                                             QStyle::SC_SpinBoxEditField, this).size();
     hint += extra;
 
 
     spinOpts.rect.setSize(hint);
     return style()->sizeFromContents(QStyle::CT_SpinBox, &spinOpts, hint)
             .expandedTo(QApplication::globalStrut());
 
 }
 
 QSize KisAbstractSliderSpinBox::minimumSizeHint() const
 {
     return sizeHint();
 }
 
 QSize KisAbstractSliderSpinBox::minimumSize() const
 {
     return QWidget::minimumSize().expandedTo(minimumSizeHint());
 }
 
 QStyleOptionSpinBox KisAbstractSliderSpinBox::spinBoxOptions() const
 {
     const Q_D(KisAbstractSliderSpinBox);
     QStyleOptionSpinBox opts;
     opts.initFrom(this);
     opts.frame = false;
     opts.buttonSymbols = QAbstractSpinBox::UpDownArrows;
     opts.subControls = QStyle::SC_SpinBoxUp | QStyle::SC_SpinBoxDown;
 
     //Disable non-logical buttons
     if (d->value == d->minimum) {
         opts.stepEnabled = QAbstractSpinBox::StepUpEnabled;
     } else if (d->value == d->maximum) {
         opts.stepEnabled = QAbstractSpinBox::StepDownEnabled;
     } else {
         opts.stepEnabled = QAbstractSpinBox::StepUpEnabled | QAbstractSpinBox::StepDownEnabled;
     }
 
     //Deal with depressed buttons
     if (d->upButtonDown) {
         opts.activeSubControls = QStyle::SC_SpinBoxUp;
     } else if (d->downButtonDown) {
         opts.activeSubControls = QStyle::SC_SpinBoxDown;
     } else {
         opts.activeSubControls = 0;
     }
 
     return opts;
 }
 
 QStyleOptionProgressBar KisAbstractSliderSpinBox::progressBarOptions() const
 {
     const Q_D(KisAbstractSliderSpinBox);
     QStyleOptionSpinBox spinOpts = spinBoxOptions();
 
     //Create opts for drawing the progress portion
     QStyleOptionProgressBar progressOpts;
     progressOpts.initFrom(this);
     progressOpts.maximum = d->maximum;
     progressOpts.minimum = d->minimum;
 
     qreal minDbl = d->minimum;
 
     qreal dValues = (d->maximum - minDbl);
 
     progressOpts.progress = dValues * pow((d->value - minDbl) / dValues, 1.0 / d->exponentRatio) + minDbl;
     progressOpts.text = d->prefix + valueString() + d->suffix;
     progressOpts.textAlignment = Qt::AlignCenter;
     progressOpts.textVisible = !(d->edit->isVisible());
 
     //Change opts rect to be only the ComboBox's text area
     progressOpts.rect = progressRect(spinOpts);
 
     return progressOpts;
 }
 
 QRect KisAbstractSliderSpinBox::progressRect(const QStyleOptionSpinBox& spinBoxOptions) const
 {
     const Q_D(KisAbstractSliderSpinBox);
     QRect ret = style()->subControlRect(QStyle::CC_SpinBox, &spinBoxOptions,
                                         QStyle::SC_SpinBoxEditField);
 
     switch (d->style) {
     case KisAbstractSliderSpinBoxPrivate::STYLE_PLASTIQUE:
         ret.adjust(-2, 0, 1, 0);
         break;
     case KisAbstractSliderSpinBoxPrivate::STYLE_BREEZE:
         ret.adjust(1, 0, 0, 0);
         break;
     default:
         break;
     }
 
     return ret;
 }
 
 QRect KisAbstractSliderSpinBox::upButtonRect(const QStyleOptionSpinBox& spinBoxOptions) const
 {
     return style()->subControlRect(QStyle::CC_SpinBox, &spinBoxOptions,
                                    QStyle::SC_SpinBoxUp);
 }
 
 QRect KisAbstractSliderSpinBox::downButtonRect(const QStyleOptionSpinBox& spinBoxOptions) const
 {
     return style()->subControlRect(QStyle::CC_SpinBox, &spinBoxOptions,
                                    QStyle::SC_SpinBoxDown);
 }
 
 int KisAbstractSliderSpinBox::valueForX(int x, Qt::KeyboardModifiers modifiers) const
 {
     const Q_D(KisAbstractSliderSpinBox);
     QStyleOptionSpinBox spinOpts = spinBoxOptions();
 
     QRect correctedProgRect;
     if (d->style == KisAbstractSliderSpinBoxPrivate::STYLE_FUSION) {
         correctedProgRect = progressRect(spinOpts).adjusted(2, 0, -2, 0);
     }
     else if (d->style == KisAbstractSliderSpinBoxPrivate::STYLE_BREEZE) {
         correctedProgRect = progressRect(spinOpts);
     }
     else {
         //Adjust for magic number in style code (margins)
         correctedProgRect = progressRect(spinOpts).adjusted(2, 2, -2, -2);
     }
 
     //Compute the distance of the progress bar, in pixel
     qreal leftDbl = correctedProgRect.left();
     qreal xDbl = x - leftDbl;
 
     //Compute the ration of the progress bar used, linearly (ignoring the exponent)
     qreal rightDbl = correctedProgRect.right();
     qreal minDbl = d->minimum;
     qreal maxDbl = d->maximum;
 
     qreal dValues = (maxDbl - minDbl);
     qreal percent = (xDbl / (rightDbl - leftDbl));
 
     //If SHIFT is pressed, movement should be slowed.
     if( modifiers & Qt::ShiftModifier ) {
         percent = d->shiftPercent + ( percent - d->shiftPercent ) * d->slowFactor;
     }
 
     //Final value
     qreal realvalue = ((dValues * pow(percent, d->exponentRatio)) + minDbl);
     //If key CTRL is pressed, round to the closest step.
     if( modifiers & Qt::ControlModifier ) {
         qreal fstep = d->fastSliderStep;
         if( modifiers & Qt::ShiftModifier ) {
             fstep*=d->slowFactor;
         }
         realvalue = floor( (realvalue+fstep/2) / fstep ) * fstep;
     }
     //Return the value
     return int(realvalue);
 }
 
 void KisAbstractSliderSpinBox::setPrefix(const QString& prefix)
 {
     Q_D(KisAbstractSliderSpinBox);
     d->prefix = prefix;
 }
 
 void KisAbstractSliderSpinBox::setSuffix(const QString& suffix)
 {
     Q_D(KisAbstractSliderSpinBox);
     d->suffix = suffix;
 }
 
 void KisAbstractSliderSpinBox::setExponentRatio(qreal dbl)
 {
     Q_D(KisAbstractSliderSpinBox);
     Q_ASSERT(dbl > 0);
     d->exponentRatio = dbl;
 }
 
 void KisAbstractSliderSpinBox::setBlockUpdateSignalOnDrag(bool blockUpdateSignal)
 {
     Q_D(KisAbstractSliderSpinBox);
     d->blockUpdateSignalOnDrag = blockUpdateSignal;
 }
 
 void KisAbstractSliderSpinBox::contextMenuEvent(QContextMenuEvent* event)
 {
     event->accept();
 }
 
 void KisAbstractSliderSpinBox::editLostFocus()
 {
     Q_D(KisAbstractSliderSpinBox);
     if (!d->edit->hasFocus()) {
         commitEnteredValue();
         hideEdit();
     }
 }
 
 void KisAbstractSliderSpinBox::setInternalValue(int value)
 {
     setInternalValue(value, false);
 }
 
 bool KisAbstractSliderSpinBox::isDragging() const
 {
     Q_D(const KisAbstractSliderSpinBox);
     return d->isDragging;
 }
 
 class KisSliderSpinBoxPrivate : public KisAbstractSliderSpinBoxPrivate {
 };
 
 KisSliderSpinBox::KisSliderSpinBox(QWidget* parent) : KisAbstractSliderSpinBox(parent, new KisSliderSpinBoxPrivate)
 {
     Q_D(KisSliderSpinBox);
 
     d->parseInt = true;
 
     setRange(0,99);
 }
 
 KisSliderSpinBox::~KisSliderSpinBox()
 {
 }
 
 void KisSliderSpinBox::setRange(int minimum, int maximum)
 {
     Q_D(KisSliderSpinBox);
     d->minimum = minimum;
     d->maximum = maximum;
     d->fastSliderStep = (maximum-minimum+1)/20;
     d->validator->setRange(minimum, maximum, 0);
     update();
 }
 
 int KisSliderSpinBox::minimum() const
 {
     const Q_D(KisSliderSpinBox);
     return d->minimum;
 }
 
 void KisSliderSpinBox::setMinimum(int minimum)
 {
     Q_D(KisSliderSpinBox);
     setRange(minimum, d->maximum);
 }
 
 int KisSliderSpinBox::maximum() const
 {
     const Q_D(KisSliderSpinBox);
     return d->maximum;
 }
 
 void KisSliderSpinBox::setMaximum(int maximum)
 {
     Q_D(KisSliderSpinBox);
     setRange(d->minimum, maximum);
 }
 
 int KisSliderSpinBox::fastSliderStep() const
 {
     const Q_D(KisSliderSpinBox);
     return d->fastSliderStep;
 }
 
 void KisSliderSpinBox::setFastSliderStep(int step)
 {
     Q_D(KisSliderSpinBox);
     d->fastSliderStep = step;
 }
 
 int KisSliderSpinBox::value()
 {
     Q_D(KisSliderSpinBox);
     return d->value;
 }
 
 void KisSliderSpinBox::setValue(int value)
 {
     setInternalValue(value, false);
     update();
 }
 
 QString KisSliderSpinBox::valueString() const
 {
     const Q_D(KisSliderSpinBox);
 
     QLocale locale;
     return locale.toString((qreal)d->value, 'f', d->validator->decimals());
 }
 
 void KisSliderSpinBox::setSingleStep(int value)
 {
     Q_D(KisSliderSpinBox);
     d->singleStep = value;
 }
 
 void KisSliderSpinBox::setPageStep(int value)
 {
     Q_UNUSED(value);
 }
 
 void KisSliderSpinBox::setInternalValue(int _value, bool blockUpdateSignal)
 {
     Q_D(KisAbstractSliderSpinBox);
     d->value = qBound(d->minimum, _value, d->maximum);
 
     if(!blockUpdateSignal) {
         emit(valueChanged(value()));
     }
 }
 
 class KisDoubleSliderSpinBoxPrivate : public KisAbstractSliderSpinBoxPrivate {
 };
 
 KisDoubleSliderSpinBox::KisDoubleSliderSpinBox(QWidget* parent) : KisAbstractSliderSpinBox(parent, new KisDoubleSliderSpinBoxPrivate)
 {
     Q_D(KisDoubleSliderSpinBox);
     d->parseInt = false;
 }
 
 KisDoubleSliderSpinBox::~KisDoubleSliderSpinBox()
 {
 }
 
 void KisDoubleSliderSpinBox::setRange(qreal minimum, qreal maximum, int decimals)
 {
     Q_D(KisDoubleSliderSpinBox);
     d->factor = pow(10.0, decimals);
 
     d->minimum = minimum * d->factor;
     d->maximum = maximum * d->factor;
     //This code auto-compute a new step when pressing control.
     //A flag defaulting to "do not change the fast step" should be added, but it implies changing every call
     if(maximum - minimum >= 2.0 || decimals <= 0) {  //Quick step on integers
         d->fastSliderStep = int(pow(10.0, decimals));
     } else if(decimals == 1) {
         d->fastSliderStep = (maximum-minimum)*d->factor/10;
     } else {
         d->fastSliderStep = (maximum-minimum)*d->factor/20;
     }
     d->validator->setRange(minimum, maximum, decimals);
     update();
     setValue(value());
 }
 
 qreal KisDoubleSliderSpinBox::minimum() const
 {
     const Q_D(KisAbstractSliderSpinBox);
     return d->minimum / d->factor;
 }
 
 void KisDoubleSliderSpinBox::setMinimum(qreal minimum)
 {
     Q_D(KisAbstractSliderSpinBox);
     setRange(minimum, d->maximum);
 }
 
 qreal KisDoubleSliderSpinBox::maximum() const
 {
     const Q_D(KisAbstractSliderSpinBox);
     return d->maximum / d->factor;
 }
 
 void KisDoubleSliderSpinBox::setMaximum(qreal maximum)
 {
     Q_D(KisAbstractSliderSpinBox);
     setRange(d->minimum, maximum);
 }
 
 qreal KisDoubleSliderSpinBox::fastSliderStep() const
 {
     const Q_D(KisAbstractSliderSpinBox);
     return d->fastSliderStep;
 }
 void KisDoubleSliderSpinBox::setFastSliderStep(qreal step)
 {
     Q_D(KisAbstractSliderSpinBox);
     d->fastSliderStep = step;
 }
 
 qreal KisDoubleSliderSpinBox::value()
 {
     Q_D(KisAbstractSliderSpinBox);
     return (qreal)d->value / d->factor;
 }
 
 void KisDoubleSliderSpinBox::setValue(qreal value)
 {
     Q_D(KisAbstractSliderSpinBox);
     setInternalValue(d->value = qRound(value * d->factor), false);
     update();
 }
 
 void KisDoubleSliderSpinBox::setSingleStep(qreal value)
 {
     Q_D(KisAbstractSliderSpinBox);
     d->singleStep = value * d->factor;
 }
 
 QString KisDoubleSliderSpinBox::valueString() const
 {
     const Q_D(KisAbstractSliderSpinBox);
 
     QLocale locale;
     return locale.toString((qreal)d->value / d->factor, 'f', d->validator->decimals());
 }
 
 void KisDoubleSliderSpinBox::setInternalValue(int _value, bool blockUpdateSignal)
 {
     Q_D(KisAbstractSliderSpinBox);
     d->value = qBound(d->minimum, _value, d->maximum);
 
     if(!blockUpdateSignal) {
         emit(valueChanged(value()));
     }
 }
 
 
 void KisAbstractSliderSpinBox::changeEvent(QEvent *e)
 {
     Q_D(KisAbstractSliderSpinBox);
 
     QWidget::changeEvent(e);
 
     switch (e->type()) {
     case QEvent::StyleChange:
         if (style()->objectName() == "fusion") {
             d->style = KisAbstractSliderSpinBoxPrivate::STYLE_FUSION;
         }
         else if (style()->objectName() == "plastique") {
             d->style = KisAbstractSliderSpinBoxPrivate::STYLE_PLASTIQUE;
         }
         else if (style()->objectName() == "breeze") {
             d->style = KisAbstractSliderSpinBoxPrivate::STYLE_BREEZE;
         }
         else {
             d->style = KisAbstractSliderSpinBoxPrivate::STYLE_NOQUIRK;
         }
         break;
     default:
         break;
     }
 }
diff --git a/libs/ui/widgets/kis_slider_spin_box.h b/libs/ui/widgets/kis_slider_spin_box.h
index eaaa1b54b8..565498384c 100644
--- a/libs/ui/widgets/kis_slider_spin_box.h
+++ b/libs/ui/widgets/kis_slider_spin_box.h
@@ -1,179 +1,180 @@
 /* This file is part of the KDE project
  * Copyright (c) 2010 Justin Noel <justin@ics.com>
  *
  * This library is free software; you can redistribute it and/or
  * modify it under the terms of the GNU Library General Public
  * License as published by the Free Software Foundation; either
  * version 2 of the License, or (at your option) any later version.
  *
  * This library is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  * Library General Public License for more details.
  *
  * You should have received a copy of the GNU Library General Public License
  * along with this library; see the file COPYING.LIB.  If not, write to
  * the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
  * Boston, MA 02110-1301, USA.
  */
 #ifndef KISSLIDERSPINBOX_H
 #define KISSLIDERSPINBOX_H
 
 #include <QAbstractSpinBox>
 
 #include <QStyleOptionSpinBox>
 #include <QStyleOptionProgressBar>
 #include <kritaui_export.h>
 
 class KisAbstractSliderSpinBoxPrivate;
 class KisSliderSpinBoxPrivate;
 class KisDoubleSliderSpinBoxPrivate;
 
 /**
  * XXX: when inactive, also show the progress bar part as inactive!
  */
 class KRITAUI_EXPORT KisAbstractSliderSpinBox : public QWidget
 {
     Q_OBJECT
     Q_DISABLE_COPY(KisAbstractSliderSpinBox)
     Q_DECLARE_PRIVATE(KisAbstractSliderSpinBox)
 protected:
     explicit KisAbstractSliderSpinBox(QWidget* parent, KisAbstractSliderSpinBoxPrivate*);
 public:
     ~KisAbstractSliderSpinBox() override;
 
     void showEdit();
     void hideEdit();
 
     void setPrefix(const QString& prefix);
     void setSuffix(const QString& suffix);
 
     void setExponentRatio(qreal dbl);
 
     /**
      * If set to block, it informs inheriting classes that they shouldn't emit signals
      * if the update comes from a mouse dragging the slider.
      * Set this to true when dragging the slider and updates during the drag are not needed.
      */
     void setBlockUpdateSignalOnDrag(bool block);
 
     QSize sizeHint() const override;
     QSize minimumSizeHint() const override;
     virtual QSize minimumSize() const;
 
     bool isDragging() const;
 
 protected:
     void paintEvent(QPaintEvent* e) override;
     void mousePressEvent(QMouseEvent* e) override;
     void mouseReleaseEvent(QMouseEvent* e) override;
     void mouseMoveEvent(QMouseEvent* e) override;
     void keyPressEvent(QKeyEvent* e) override;
     void wheelEvent(QWheelEvent *) override;
+    bool event(QEvent *event) override;
 
     bool eventFilter(QObject* recv, QEvent* e) override;
 
     QStyleOptionSpinBox spinBoxOptions() const;
     QStyleOptionProgressBar progressBarOptions() const;
 
     QRect progressRect(const QStyleOptionSpinBox& spinBoxOptions) const;
     QRect upButtonRect(const QStyleOptionSpinBox& spinBoxOptions) const;
     QRect downButtonRect(const QStyleOptionSpinBox& spinBoxOptions) const;
 
     int valueForX(int x, Qt::KeyboardModifiers modifiers = Qt::NoModifier) const;
 
     void commitEnteredValue();
 
     virtual QString valueString() const = 0;
     /**
      * Sets the slider internal value. Inheriting classes should respect blockUpdateSignal
      * so that, in specific cases, we have a performance improvement. See setIgnoreMouseMoveEvents.
      */
     virtual void setInternalValue(int value, bool blockUpdateSignal) = 0;
 
 protected Q_SLOTS:
     void contextMenuEvent(QContextMenuEvent * event) override;
     void editLostFocus();
 protected:
     KisAbstractSliderSpinBoxPrivate* const d_ptr;
 
     // QWidget interface
 protected:
     void changeEvent(QEvent *e) override;
     void paint(QPainter& painter);
     void paintFusion(QPainter& painter);
     void paintPlastique(QPainter& painter);
     void paintBreeze(QPainter& painter);
 
 private:
     void setInternalValue(int value);
 };
 
 class KRITAUI_EXPORT KisSliderSpinBox : public KisAbstractSliderSpinBox
 {
     Q_OBJECT
     Q_DECLARE_PRIVATE(KisSliderSpinBox)
     Q_PROPERTY( int minimum READ minimum WRITE setMinimum )
     Q_PROPERTY( int maximum READ maximum WRITE setMaximum )
 public:
     KisSliderSpinBox(QWidget* parent = 0);
     ~KisSliderSpinBox() override;
 
     void setRange(int minimum, int maximum);
 
     int minimum() const;
     void setMinimum(int minimum);
     int maximum() const;
     void setMaximum(int maximum);
     int fastSliderStep() const;
     void setFastSliderStep(int step);
 
     ///Get the value, don't use value()
     int value();
 
     void setSingleStep(int value);
     void setPageStep(int value);
 
 public Q_SLOTS:
 
     ///Set the value, don't use setValue()
     void setValue(int value);
 
 protected:
     QString valueString() const override;
     void setInternalValue(int value, bool blockUpdateSignal) override;
 Q_SIGNALS:
     void valueChanged(int value);
 };
 
 class KRITAUI_EXPORT KisDoubleSliderSpinBox : public KisAbstractSliderSpinBox
 {
     Q_OBJECT
     Q_DECLARE_PRIVATE(KisDoubleSliderSpinBox)
 public:
     KisDoubleSliderSpinBox(QWidget* parent = 0);
     ~KisDoubleSliderSpinBox() override;
 
     void setRange(qreal minimum, qreal maximum, int decimals = 0);
 
     qreal minimum() const;
     void setMinimum(qreal minimum);
     qreal maximum() const;
     void setMaximum(qreal maximum);
     qreal fastSliderStep() const;
     void setFastSliderStep(qreal step);
 
     qreal value();
     void setSingleStep(qreal value);
 
 public Q_SLOTS:
     void setValue(qreal value);
 
 protected:
     QString valueString() const override;
     void setInternalValue(int value, bool blockUpdateSignal) override;
 Q_SIGNALS:
     void valueChanged(qreal value);
 };
 
 #endif //kISSLIDERSPINBOX_H