diff --git a/libs/ui/CMakeLists.txt b/libs/ui/CMakeLists.txt
index 2c613bfefd..12c47b43d1 100644
--- a/libs/ui/CMakeLists.txt
+++ b/libs/ui/CMakeLists.txt
@@ -1,557 +1,557 @@
 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_send_telemetry.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
 
     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
 
     kis_telemetry_abstruct.cpp
-    kis_telemetry_sensor.cpp
+    kis_telemetry_actions.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
     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
     forms/wdgtelemetry.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/KisMainWindow.cpp b/libs/ui/KisMainWindow.cpp
index b7ae94b934..1828a7de48 100644
--- a/libs/ui/KisMainWindow.cpp
+++ b/libs/ui/KisMainWindow.cpp
@@ -1,2427 +1,2426 @@
 /* This file is part of the KDE project
    Copyright (C) 1998, 1999 Torben Weis <weis@kde.org>
    Copyright (C) 2000-2006 David Faure <faure@kde.org>
    Copyright (C) 2007, 2009 Thomas zander <zander@kde.org>
    Copyright (C) 2010 Benjamin Port <port.benjamin@gmail.com>
 
    This library is free software; you can redistribute it and/or
    modify it under the terms of the GNU Library General Public
    License as published by the Free Software Foundation; either
    version 2 of the License, or (at your option) any later version.
 
    This library is distributed in the hope that it will be useful,
    but WITHOUT ANY WARRANTY; without even the implied warranty of
    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
    Library General Public License for more details.
 
    You should have received a copy of the GNU Library General Public License
    along with this library; see the file COPYING.LIB.  If not, write to
    the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
  * Boston, MA 02110-1301, USA.
 */
 
 #include "KisMainWindow.h"
 
 #include <KoConfig.h>
 
 // qt includes
 #include <QApplication>
 #include <QByteArray>
 #include <QCloseEvent>
 #include <QDesktopServices>
 #include <QDesktopWidget>
 #include <QDockWidget>
 #include <QIcon>
 #include <QLabel>
 #include <QLayout>
 #include <QMdiArea>
 #include <QMdiSubWindow>
 #include <QMutex>
 #include <QMutexLocker>
 #include <QPointer>
 #include <QPrintDialog>
 #include <QPrinter>
 #include <QPrintPreviewDialog>
 #include <QProgressBar>
 #include <QToolButton>
 #include <QSignalMapper>
 #include <QTabBar>
 #include <QMoveEvent>
 #include <QUrl>
 #include <QMessageBox>
 #include <QTemporaryFile>
 #include <QStatusBar>
 #include <QMenu>
 #include <QMenuBar>
 #include <KisMimeDatabase.h>
 #include <QMimeData>
 
 #include <kactioncollection.h>
 #include <QAction>
 #include <kactionmenu.h>
 #include <kis_debug.h>
 #include <kedittoolbar.h>
 #include <khelpmenu.h>
 #include <klocalizedstring.h>
 #include <kaboutdata.h>
 
 #ifdef HAVE_KIO
 #include <krecentdocument.h>
 #endif
 #include <krecentfilesaction.h>
 #include <KoResourcePaths.h>
 #include <ktoggleaction.h>
 #include <ktoolbar.h>
 #include <kmainwindow.h>
 #include <kxmlguiwindow.h>
 #include <kxmlguifactory.h>
 #include <kxmlguiclient.h>
 #include <kguiitem.h>
 #include <kwindowconfig.h>
 
 #include "KoDockFactoryBase.h"
 #include "KoDockWidgetTitleBar.h"
 #include "KoDocumentInfoDlg.h"
 #include "KoDocumentInfo.h"
 #include "KoFileDialog.h"
 #include <kis_icon.h>
 #include <KoPageLayoutDialog.h>
 #include <KoPageLayoutWidget.h>
 #include <KoToolManager.h>
 #include <KoZoomController.h>
 #include "KoToolDocker.h"
 #include <KoToolBoxFactory.h>
 #include <KoDockRegistry.h>
 #include <KoPluginLoader.h>
 #include <KoColorSpaceEngine.h>
 
 #include <KisMimeDatabase.h>
 #include <brushengine/kis_paintop_settings.h>
 #include "dialogs/kis_about_application.h"
 #include "dialogs/kis_delayed_save_dialog.h"
 #include "dialogs/kis_dlg_preferences.h"
 #include "kis_action.h"
 #include "kis_action_manager.h"
 #include "KisApplication.h"
 #include "kis_canvas2.h"
 #include "kis_canvas_controller.h"
 #include "kis_canvas_resource_provider.h"
 #include "kis_clipboard.h"
 #include "kis_config.h"
 #include "kis_config_notifier.h"
 #include "kis_custom_image_widget.h"
 #include <KisDocument.h>
 #include "KisDocument.h"
 #include "KisDocument.h"
 #include "kis_group_layer.h"
 #include "kis_icon_utils.h"
 #include "kis_image_from_clipboard_widget.h"
 #include "kis_image.h"
 #include <KisImportExportFilter.h>
 #include "KisImportExportManager.h"
 #include "kis_mainwindow_observer.h"
 #include "kis_node.h"
 #include "KisOpenPane.h"
 #include "kis_paintop_box.h"
 #include "KisPart.h"
 #include "KisPrintJob.h"
 #include "kis_resource_server_provider.h"
 #include "kis_signal_compressor_with_param.h"
 #include "KisView.h"
 #include "KisViewManager.h"
 #include "thememanager.h"
 #include "kis_animation_importer.h"
 #include "dialogs/kis_dlg_import_image_sequence.h"
 #include "kis_animation_exporter.h"
 #include "dialogs/kis_dlg_send_telemetry.h"
 
 #include <mutex>
 
 #ifdef Q_OS_WIN
   #include <QtPlatformHeaders/QWindowsWindowFunctions>
 #endif
 
 class ToolDockerFactory : public KoDockFactoryBase
 {
 public:
     ToolDockerFactory() : KoDockFactoryBase() { }
 
     QString id() const override {
         return "sharedtooldocker";
     }
 
     QDockWidget* createDockWidget() override {
         KoToolDocker* dockWidget = new KoToolDocker();
         dockWidget->setTabEnabled(false);
         return dockWidget;
     }
 
     DockPosition defaultDockPosition() const override {
         return DockRight;
     }
 };
 
 class Q_DECL_HIDDEN KisMainWindow::Private
 {
 public:
     Private(KisMainWindow *parent)
         : q(parent)
         , dockWidgetMenu(new KActionMenu(i18nc("@action:inmenu", "&Dockers"), parent))
         , windowMenu(new KActionMenu(i18nc("@action:inmenu", "&Window"), parent))
         , documentMenu(new KActionMenu(i18nc("@action:inmenu", "New &View"), parent))
         , mdiArea(new QMdiArea(parent))
         , windowMapper(new QSignalMapper(parent))
         , documentMapper(new QSignalMapper(parent))
     {
     }
 
     ~Private() {
         qDeleteAll(toolbarList);
     }
 
     KisMainWindow *q {0};
     KisViewManager *viewManager {0};
 
     QPointer<KisView> activeView;
 
     QPointer<QProgressBar> progress;
     QPointer<QToolButton> progressCancel;
     QMutex progressMutex;
 
     QList<QAction *> toolbarList;
 
     bool firstTime {true};
     bool windowSizeDirty {false};
     bool readOnly {false};
     bool isImporting {false};
     bool isExporting {false};
     bool noCleanup {false};
 
     KisAction *showDocumentInfo {0};
     KisAction *saveAction {0};
     KisAction *saveActionAs {0};
 //    KisAction *printAction;
 //    KisAction *printActionPreview;
 //    KisAction *exportPdf {0};
     KisAction *importAnimation {0};
     KisAction *closeAll {0};
 //    KisAction *reloadFile;
     KisAction *importFile {0};
     KisAction *exportFile {0};
     KisAction *undo {0};
     KisAction *redo {0};
     KisAction *newWindow {0};
     KisAction *close {0};
     KisAction *sendInfo{0};
     KisAction *mdiCascade {0};
     KisAction *mdiTile {0};
     KisAction *mdiNextWindow {0};
     KisAction *mdiPreviousWindow {0};
     KisAction *toggleDockers {0};
     KisAction *toggleDockerTitleBars {0};
 
     KisAction *expandingSpacers[2];
 
     KActionMenu *dockWidgetMenu;
     KActionMenu *windowMenu;
     KActionMenu *documentMenu;
 
     KHelpMenu *helpMenu  {0};
 
     KRecentFilesAction *recentFiles {0};
 
     QUrl lastExportUrl;
 
     QMap<QString, QDockWidget *> dockWidgetsMap;
     QMap<QDockWidget *, bool> dockWidgetVisibilityMap;
     QByteArray dockerStateBeforeHiding;
     KoToolDocker *toolOptionsDocker {0};
 
     QCloseEvent *deferredClosingEvent {0};
 
     Digikam::ThemeManager *themeManager {0};
 
     QMdiArea *mdiArea;
     QMdiSubWindow *activeSubWindow  {0};
     QSignalMapper *windowMapper;
     QSignalMapper *documentMapper;
 
     QByteArray lastExportedFormat;
     QScopedPointer<KisSignalCompressorWithParam<int> > tabSwitchCompressor;
     QMutex savingEntryMutex;
 
     QScopedPointer<KisDlgSendTelemtry > telemetry;
     KisActionManager * actionManager() {
         return viewManager->actionManager();
     }
 
     QTabBar* findTabBarHACK() {
         QObjectList objects = mdiArea->children();
         Q_FOREACH (QObject *object, objects) {
             QTabBar *bar = qobject_cast<QTabBar*>(object);
             if (bar) {
                 return bar;
             }
         }
         return 0;
     }
 };
 
 KisMainWindow::KisMainWindow()
     : KXmlGuiWindow()
     , d(new Private(this))
 {
     KisConfig cfg;
 
     d->viewManager = new KisViewManager(this, actionCollection());
     KConfigGroup group( KSharedConfig::openConfig(), "theme");
     d->themeManager = new Digikam::ThemeManager(group.readEntry("Theme", "Krita dark"), this);
 
     setAcceptDrops(true);
     setStandardToolBarMenuEnabled(true);
     setTabPosition(Qt::AllDockWidgetAreas, QTabWidget::North);
     setDockNestingEnabled(true);
 
     qApp->setStartDragDistance(25);     // 25 px is a distance that works well for Tablet and Mouse events
 
 #ifdef Q_OS_OSX
     setUnifiedTitleAndToolBarOnMac(true);
 #endif
 
     connect(this, SIGNAL(restoringDone()), this, SLOT(forceDockTabFonts()));
     connect(this, SIGNAL(themeChanged()), d->viewManager, SLOT(updateIcons()));
     connect(KisPart::instance(), SIGNAL(documentClosed(QString)), SLOT(updateWindowMenu()));
     connect(KisPart::instance(), SIGNAL(documentOpened(QString)), SLOT(updateWindowMenu()));
     connect(KisConfigNotifier::instance(), SIGNAL(configChanged()), this, SLOT(configChanged()));
 
     actionCollection()->addAssociatedWidget(this);
 
     KoPluginLoader::instance()->load("Krita/ViewPlugin", "Type == 'Service' and ([X-Krita-Version] == 28)", KoPluginLoader::PluginsConfig(), d->viewManager);
 
     KoToolBoxFactory toolBoxFactory;
     QDockWidget *toolbox = createDockWidget(&toolBoxFactory);
     toolbox->setFeatures(QDockWidget::DockWidgetMovable | QDockWidget::DockWidgetFloatable | QDockWidget::DockWidgetClosable);
 
     if (cfg.toolOptionsInDocker()) {
         ToolDockerFactory toolDockerFactory;
         d->toolOptionsDocker = qobject_cast<KoToolDocker*>(createDockWidget(&toolDockerFactory));
         d->toolOptionsDocker->toggleViewAction()->setEnabled(true);
     }
 
     QMap<QString, QAction*> dockwidgetActions;
     dockwidgetActions[toolbox->toggleViewAction()->text()] = toolbox->toggleViewAction();
     Q_FOREACH (const QString & docker, KoDockRegistry::instance()->keys()) {
         KoDockFactoryBase *factory = KoDockRegistry::instance()->value(docker);
         QDockWidget *dw = createDockWidget(factory);
         dockwidgetActions[dw->toggleViewAction()->text()] = dw->toggleViewAction();
     }
 
     if (d->toolOptionsDocker) {
         dockwidgetActions[d->toolOptionsDocker->toggleViewAction()->text()] = d->toolOptionsDocker->toggleViewAction();
     }
     connect(KoToolManager::instance(), SIGNAL(toolOptionWidgetsChanged(KoCanvasController*, QList<QPointer<QWidget> >)), this, SLOT(newOptionWidgets(KoCanvasController*, QList<QPointer<QWidget> >)));
 
     Q_FOREACH (QString title, dockwidgetActions.keys()) {
         d->dockWidgetMenu->addAction(dockwidgetActions[title]);
     }
 
 
     Q_FOREACH (QDockWidget *wdg, dockWidgets()) {
         if ((wdg->features() & QDockWidget::DockWidgetClosable) == 0) {
             wdg->setVisible(true);
         }
     }
 
     Q_FOREACH (KoCanvasObserverBase* observer, canvasObservers()) {
         observer->setObservedCanvas(0);
         KisMainwindowObserver* mainwindowObserver = dynamic_cast<KisMainwindowObserver*>(observer);
         if (mainwindowObserver) {
             mainwindowObserver->setMainWindow(d->viewManager);
         }
     }
 
     d->mdiArea->setHorizontalScrollBarPolicy(Qt::ScrollBarAsNeeded);
     d->mdiArea->setVerticalScrollBarPolicy(Qt::ScrollBarAsNeeded);
     d->mdiArea->setTabPosition(QTabWidget::North);
     d->mdiArea->setTabsClosable(true);
 
     setCentralWidget(d->mdiArea);
 
     connect(d->mdiArea, SIGNAL(subWindowActivated(QMdiSubWindow*)), this, SLOT(subWindowActivated()));
     connect(d->windowMapper, SIGNAL(mapped(QWidget*)), this, SLOT(setActiveSubWindow(QWidget*)));
     connect(d->documentMapper, SIGNAL(mapped(QObject*)), this, SLOT(newView(QObject*)));
 
     createActions();
 
     setAutoSaveSettings("krita", false);
 
 
     subWindowActivated();
     updateWindowMenu();
 
 
     if (isHelpMenuEnabled() && !d->helpMenu) {
         // workaround for KHelpMenu (or rather KAboutData::applicationData()) internally
         // not using the Q*Application metadata ATM, which results e.g. in the bugreport wizard
         // not having the app version preset
         // fixed hopefully in KF5 5.22.0, patch pending
         QGuiApplication *app = qApp;
         KAboutData aboutData(app->applicationName(), app->applicationDisplayName(), app->applicationVersion());
         aboutData.setOrganizationDomain(app->organizationDomain().toUtf8());
         d->helpMenu = new KHelpMenu(this, aboutData, false);
         // workaround-less version:
         // d->helpMenu = new KHelpMenu(this, QString()/*unused*/, false);
 
         // The difference between using KActionCollection->addAction() is that
         // these actions do not get tied to the MainWindow.  What does this all do?
         KActionCollection *actions = d->viewManager->actionCollection();
         QAction *helpContentsAction = d->helpMenu->action(KHelpMenu::menuHelpContents);
         QAction *whatsThisAction = d->helpMenu->action(KHelpMenu::menuWhatsThis);
         QAction *reportBugAction = d->helpMenu->action(KHelpMenu::menuReportBug);
         QAction *switchLanguageAction = d->helpMenu->action(KHelpMenu::menuSwitchLanguage);
         QAction *aboutAppAction = d->helpMenu->action(KHelpMenu::menuAboutApp);
         QAction *aboutKdeAction = d->helpMenu->action(KHelpMenu::menuAboutKDE);
 
         if (helpContentsAction) {
             actions->addAction(helpContentsAction->objectName(), helpContentsAction);
         }
         if (whatsThisAction) {
             actions->addAction(whatsThisAction->objectName(), whatsThisAction);
         }
         if (reportBugAction) {
             actions->addAction(reportBugAction->objectName(), reportBugAction);
         }
         if (switchLanguageAction) {
             actions->addAction(switchLanguageAction->objectName(), switchLanguageAction);
         }
         if (aboutAppAction) {
             actions->addAction(aboutAppAction->objectName(), aboutAppAction);
         }
         if (aboutKdeAction) {
             actions->addAction(aboutKdeAction->objectName(), aboutKdeAction);
         }
 
         connect(d->helpMenu, SIGNAL(showAboutApplication()), SLOT(showAboutApplication()));
     }
 
     // KDE' libs 4''s help contents action is broken outside kde, for some reason... We can handle it just as easily ourselves
     QAction *helpAction = actionCollection()->action("help_contents");
     helpAction->disconnect();
     connect(helpAction, SIGNAL(triggered()), this, SLOT(showManual()));
 
 
 #if 0
     //check for colliding shortcuts
     QSet<QKeySequence> existingShortcuts;
     Q_FOREACH (QAction* action, actionCollection()->actions()) {
         if(action->shortcut() == QKeySequence(0)) {
             continue;
         }
         dbgKrita << "shortcut " << action->text() << " " << action->shortcut();
         Q_ASSERT(!existingShortcuts.contains(action->shortcut()));
         existingShortcuts.insert(action->shortcut());
     }
 #endif
 
     configChanged();
 
     // If we have customized the toolbars, load that first
     setLocalXMLFile(KoResourcePaths::locateLocal("data", "krita.xmlgui"));
     setXMLFile(":/kxmlgui5/krita.xmlgui");
 
     guiFactory()->addClient(this);
 
     // Create and plug toolbar list for Settings menu
     QList<QAction *> toolbarList;
     Q_FOREACH (QWidget* it, guiFactory()->containers("ToolBar")) {
         KToolBar * toolBar = ::qobject_cast<KToolBar *>(it);
 
         if (toolBar) {
             if (toolBar->objectName() == "BrushesAndStuff") {
                 toolBar->setEnabled(false);
             }
 
             KToggleAction* act = new KToggleAction(i18n("Show %1 Toolbar", toolBar->windowTitle()), this);
             actionCollection()->addAction(toolBar->objectName().toUtf8(), act);
             act->setCheckedState(KGuiItem(i18n("Hide %1 Toolbar", toolBar->windowTitle())));
             connect(act, SIGNAL(toggled(bool)), this, SLOT(slotToolbarToggled(bool)));
             act->setChecked(!toolBar->isHidden());
             toolbarList.append(act);
         } else
             warnUI << "Toolbar list contains a " << it->metaObject()->className() << " which is not a toolbar!";
     }
     plugActionList("toolbarlist", toolbarList);
     setToolbarList(toolbarList);
 
     applyToolBarLayout();
 
     d->viewManager->updateGUI();
     d->viewManager->updateIcons();
 
 #ifdef Q_OS_WIN
     auto w = qApp->activeWindow();
     if (w) QWindowsWindowFunctions::setHasBorderInFullScreen(w->windowHandle(), true);
 #endif
 
     QTimer::singleShot(1000, this, SLOT(checkSanity()));
 
     {
         using namespace std::placeholders; // For _1 placeholder
         std::function<void (int)> callback(
             std::bind(&KisMainWindow::switchTab, this, _1));
 
         d->tabSwitchCompressor.reset(
             new KisSignalCompressorWithParam<int>(500, callback, KisSignalCompressor::FIRST_INACTIVE));
     }
 
 
 
 }
 
 void KisMainWindow::setNoCleanup(bool noCleanup)
 {
     d->noCleanup = noCleanup;
 }
 
 KisMainWindow::~KisMainWindow()
 {
 //    Q_FOREACH (QAction *ac, actionCollection()->actions()) {
 //        QAction *action = qobject_cast<QAction*>(ac);
 //        if (action) {
 //        dbgKrita << "<Action"
 //                 << "name=" << action->objectName()
 //                 << "icon=" << action->icon().name()
 //                 << "text="  << action->text().replace("&", "&amp;")
 //                 << "whatsThis="  << action->whatsThis()
 //                 << "toolTip="  << action->toolTip().replace("<html>", "").replace("</html>", "")
 //                 << "iconText="  << action->iconText().replace("&", "&amp;")
 //                 << "shortcut="  << action->shortcut(QAction::ActiveShortcut).toString()
 //                 << "defaultShortcut="  << action->shortcut(QAction::DefaultShortcut).toString()
 //                 << "isCheckable="  << QString((action->isChecked() ? "true" : "false"))
 //                 << "statusTip=" << action->statusTip()
 //                 << "/>"   ;
 //        }
 //        else {
 //            dbgKrita << "Got a QAction:" << ac->objectName();
 //        }
 
 //    }
 
     // The doc and view might still exist (this is the case when closing the window)
     KisPart::instance()->removeMainWindow(this);
 
     if (d->noCleanup)
         return;
 
     delete d->viewManager;
     delete d;
 
 }
 
 void KisMainWindow::addView(KisView *view)
 {
     if (d->activeView == view) return;
 
     if (d->activeView) {
         d->activeView->disconnect(this);
     }
 
     showView(view);
     updateCaption();
     emit restoringDone();
 
     if (d->activeView) {
         connect(d->activeView, SIGNAL(titleModified(QString,bool)), SLOT(slotDocumentTitleModified(QString,bool)));
     }
 }
 
 void KisMainWindow::showView(KisView *imageView)
 {
     if (imageView && activeView() != imageView) {
         // XXX: find a better way to initialize this!
         imageView->setViewManager(d->viewManager);
 
         imageView->canvasBase()->setFavoriteResourceManager(d->viewManager->paintOpBox()->favoriteResourcesManager());
         imageView->slotLoadingFinished();
 
         QMdiSubWindow *subwin = d->mdiArea->addSubWindow(imageView);
         subwin->setAttribute(Qt::WA_DeleteOnClose, true);
         connect(subwin, SIGNAL(destroyed()), SLOT(updateWindowMenu()));
 
         KisConfig cfg;
         subwin->setOption(QMdiSubWindow::RubberBandMove, cfg.readEntry<int>("mdi_rubberband", cfg.useOpenGL()));
         subwin->setOption(QMdiSubWindow::RubberBandResize, cfg.readEntry<int>("mdi_rubberband", cfg.useOpenGL()));
         subwin->setWindowIcon(qApp->windowIcon());
 
         /**
          * Hack alert!
          *
          * Here we explicitly request KoToolManager to emit all the tool
          * activation signals, to reinitialize the tool options docker.
          *
          * That is needed due to a design flaw we have in the
          * initialization procedure.  The tool in the KoToolManager is
          * initialized in KisView::setViewManager() calls, which
          * happens early enough. During this call the tool manager
          * requests KoCanvasControllerWidget to emit the signal to
          * update the widgets in the tool docker. *But* at that moment
          * of time the view is not yet connected to the main window,
          * because it happens in KisViewManager::setCurrentView a bit
          * later. This fact makes the widgets updating signals be lost
          * and never reach the tool docker.
          *
          * So here we just explicitly call the tool activation stub.
          */
 
         KoToolManager::instance()->initializeCurrentToolForCanvas();
 
         if (d->mdiArea->subWindowList().size() == 1) {
             imageView->showMaximized();
         }
         else {
             imageView->show();
         }
 
         // No, no, no: do not try to call this _before_ the show() has
         // been called on the view; only when that has happened is the
         // opengl context active, and very bad things happen if we tell
         // the dockers to update themselves with a view if the opengl
         // context is not active.
         setActiveView(imageView);
 
         updateWindowMenu();
         updateCaption();
     }
 }
 
 void KisMainWindow::slotPreferences()
 {
     if (KisDlgPreferences::editPreferences()) {
         KisConfigNotifier::instance()->notifyConfigChanged();
 
         // XXX: should this be changed for the views in other windows as well?
         Q_FOREACH (QPointer<KisView> koview, KisPart::instance()->views()) {
             KisViewManager *view = qobject_cast<KisViewManager*>(koview);
             if (view) {
                 // Update the settings for all nodes -- they don't query
                 // KisConfig directly because they need the settings during
                 // compositing, and they don't connect to the config notifier
                 // because nodes are not QObjects (because only one base class
                 // can be a QObject).
                 KisNode* node = dynamic_cast<KisNode*>(view->image()->rootLayer().data());
                 node->updateSettings();
             }
 
         }
 
         d->viewManager->showHideScrollbars();
     }
 }
 
 void KisMainWindow::slotThemeChanged()
 {
     // save theme changes instantly
     KConfigGroup group( KSharedConfig::openConfig(), "theme");
     group.writeEntry("Theme", d->themeManager->currentThemeName());
 
     // reload action icons!
     Q_FOREACH (QAction *action, actionCollection()->actions()) {
         KisIconUtils::updateIcon(action);
     }
 
     emit themeChanged();
 }
 
 void KisMainWindow::sendInfo()
 {
     qDebug()<<"send_enfo"<<"\n";
     d->telemetry.reset(new KisDlgSendTelemtry(this->viewManager()));
     if(d->telemetry->exec()== QDialog::Accepted){
         KisTelemetryAbstruct* provider = KisPart::instance()->provider();
         provider->sendData("install");
-        KisTelemetryAbstruct* providerRegular = KisPart::instance()->provider(KisPart::RegularProvider);
-        providerRegular->sendData("tools");
+        provider->sendData("tools");
     };
 }
 
 void KisMainWindow::updateReloadFileAction(KisDocument *doc)
 {
     Q_UNUSED(doc);
 //    d->reloadFile->setEnabled(doc && !doc->url().isEmpty());
 }
 
 void KisMainWindow::setReadWrite(bool readwrite)
 {
     d->saveAction->setEnabled(readwrite);
     d->importFile->setEnabled(readwrite);
     d->readOnly = !readwrite;
     updateCaption();
 }
 
 void KisMainWindow::addRecentURL(const QUrl &url)
 {
     dbgUI << "KisMainWindow::addRecentURL url=" << url.toDisplayString();
     // Add entry to recent documents list
     // (call coming from KisDocument because it must work with cmd line, template dlg, file/open, etc.)
     if (!url.isEmpty()) {
         bool ok = true;
         if (url.isLocalFile()) {
             QString path = url.adjusted(QUrl::StripTrailingSlash).toLocalFile();
             const QStringList tmpDirs = KoResourcePaths::resourceDirs("tmp");
             for (QStringList::ConstIterator it = tmpDirs.begin() ; ok && it != tmpDirs.end() ; ++it)
                 if (path.contains(*it))
                     ok = false; // it's in the tmp resource
 #ifdef HAVE_KIO
             if (ok) {
                 KRecentDocument::add(QUrl::fromLocalFile(path));
             }
 #endif
         }
 #ifdef HAVE_KIO
         else {
             KRecentDocument::add(url.adjusted(QUrl::StripTrailingSlash));
         }
 #endif
         if (ok) {
             d->recentFiles->addUrl(url);
         }
         saveRecentFiles();
 
     }
 }
 
 void KisMainWindow::saveRecentFiles()
 {
     // Save list of recent files
     KSharedConfigPtr config =  KSharedConfig::openConfig();
     d->recentFiles->saveEntries(config->group("RecentFiles"));
     config->sync();
 
     // Tell all windows to reload their list, after saving
     // Doesn't work multi-process, but it's a start
     Q_FOREACH (KMainWindow* window, KMainWindow::memberList())
         static_cast<KisMainWindow *>(window)->reloadRecentFileList();
 }
 
 void KisMainWindow::reloadRecentFileList()
 {
     d->recentFiles->loadEntries( KSharedConfig::openConfig()->group("RecentFiles"));
 }
 
 void KisMainWindow::updateCaption()
 {
     if (!d->mdiArea->activeSubWindow()) {
         updateCaption(QString(), false);
     }
     else if (d->activeView && d->activeView->document()){
         QString caption( d->activeView->document()->caption() );
         if (d->readOnly) {
             caption += ' ' + i18n("(write protected)");
         }
 
         d->activeView->setWindowTitle(caption);
 
         updateCaption(caption, d->activeView->document()->isModified());
 
         if (!d->activeView->document()->url().fileName().isEmpty())
             d->saveAction->setToolTip(i18n("Save as %1", d->activeView->document()->url().fileName()));
         else
             d->saveAction->setToolTip(i18n("Save"));
     }
 }
 
 void KisMainWindow::updateCaption(const QString & caption, bool mod)
 {
     dbgUI << "KisMainWindow::updateCaption(" << caption << "," << mod << ")";
 #ifdef KRITA_ALPHA
     setCaption(QString("ALPHA %1: %2").arg(KRITA_ALPHA).arg(caption), mod);
     return;
 #endif
 #ifdef KRITA_BETA
     setCaption(QString("BETA %1: %2").arg(KRITA_BETA).arg(caption), mod);
     return;
 #endif
 #ifdef KRITA_RC
     setCaption(QString("RELEASE CANDIDATE %1: %2").arg(KRITA_RC).arg(caption), mod);
     return;
 #endif
 
     setCaption(caption, mod);
 }
 
 
 KisView *KisMainWindow::activeView() const
 {
     if (d->activeView) {
         return d->activeView;
     }
     return 0;
 }
 
 bool KisMainWindow::openDocument(const QUrl &url)
 {
     if (!QFile(url.toLocalFile()).exists()) {
         QMessageBox::critical(0, i18nc("@title:window", "Krita"), i18n("The file %1 does not exist.", url.url()));
         d->recentFiles->removeUrl(url); //remove the file from the recent-opened-file-list
         saveRecentFiles();
         return false;
     }
     return openDocumentInternal(url);
 }
 
 bool KisMainWindow::openDocumentInternal(const QUrl &url, KisDocument *newdoc)
 {
     if (!url.isLocalFile()) {
         qDebug() << "KisMainWindow::openDocumentInternal. Not a local file:" << url;
         return false;
     }
 
     if (!newdoc) {
         newdoc = KisPart::instance()->createDocument();
     }
 
     d->firstTime = true;
     connect(newdoc, SIGNAL(sigProgress(int)), this, SLOT(slotProgress(int)));
     connect(newdoc, SIGNAL(completed()), this, SLOT(slotLoadCompleted()));
     connect(newdoc, SIGNAL(canceled(const QString &)), this, SLOT(slotLoadCanceled(const QString &)));
     bool openRet = (!d->isImporting) ? newdoc->openUrl(url) : newdoc->importDocument(url);
     if (!openRet) {
         delete newdoc;
         return false;
     }
 
     KisPart::instance()->addDocument(newdoc);
     updateReloadFileAction(newdoc);
 
     if (!QFileInfo(url.toLocalFile()).isWritable()) {
         setReadWrite(false);
     }
     return true;
 }
 
 void KisMainWindow::addViewAndNotifyLoadingCompleted(KisDocument *document)
 {
     KisView *view = KisPart::instance()->createView(document, resourceManager(), actionCollection(), this);
     addView(view);
 
     emit guiLoadingFinished();
 }
 
 QStringList KisMainWindow::showOpenFileDialog()
 {
     KoFileDialog dialog(this, KoFileDialog::ImportFiles, "OpenDocument");
     dialog.setDefaultDir(QDesktopServices::storageLocation(QDesktopServices::PicturesLocation));
     dialog.setMimeTypeFilters(KisImportExportManager::mimeFilter(KisImportExportManager::Import));
     dialog.setCaption(d->isImporting ? i18n("Import Images") : i18n("Open Images"));
 
     return dialog.filenames();
 }
 
 // Separate from openDocument to handle async loading (remote URLs)
 void KisMainWindow::slotLoadCompleted()
 {
     KisDocument *newdoc = qobject_cast<KisDocument*>(sender());
     if (newdoc && newdoc->image()) {
         addViewAndNotifyLoadingCompleted(newdoc);
 
         disconnect(newdoc, SIGNAL(sigProgress(int)), this, SLOT(slotProgress(int)));
         disconnect(newdoc, SIGNAL(completed()), this, SLOT(slotLoadCompleted()));
         disconnect(newdoc, SIGNAL(canceled(const QString &)), this, SLOT(slotLoadCanceled(const QString &)));
 
         emit loadCompleted();
     }
 }
 
 void KisMainWindow::slotLoadCanceled(const QString & errMsg)
 {
     dbgUI << "KisMainWindow::slotLoadCanceled";
     if (!errMsg.isEmpty())   // empty when canceled by user
         QMessageBox::critical(this, i18nc("@title:window", "Krita"), errMsg);
     // ... can't delete the document, it's the one who emitted the signal...
 
     KisDocument* doc = qobject_cast<KisDocument*>(sender());
     Q_ASSERT(doc);
     disconnect(doc, SIGNAL(sigProgress(int)), this, SLOT(slotProgress(int)));
     disconnect(doc, SIGNAL(completed()), this, SLOT(slotLoadCompleted()));
     disconnect(doc, SIGNAL(canceled(const QString &)), this, SLOT(slotLoadCanceled(const QString &)));
 }
 
 void KisMainWindow::slotSaveCanceled(const QString &errMsg)
 {
     dbgUI << "KisMainWindow::slotSaveCanceled";
     if (!errMsg.isEmpty())   // empty when canceled by user
         QMessageBox::critical(this, i18nc("@title:window", "Krita"), errMsg);
     slotSaveCompleted();
 }
 
 void KisMainWindow::slotSaveCompleted()
 {
     dbgUI << "KisMainWindow::slotSaveCompleted";
     KisDocument* doc = qobject_cast<KisDocument*>(sender());
     Q_ASSERT(doc);
     disconnect(doc, SIGNAL(sigProgress(int)), this, SLOT(slotProgress(int)));
     disconnect(doc, SIGNAL(completed()), this, SLOT(slotSaveCompleted()));
     disconnect(doc, SIGNAL(canceled(const QString &)), this, SLOT(slotSaveCanceled(const QString &)));
 
     if (d->deferredClosingEvent) {
         KXmlGuiWindow::closeEvent(d->deferredClosingEvent);
     }
 }
 
 bool KisMainWindow::hackIsSaving() const
 {
     StdLockableWrapper<QMutex> wrapper(&d->savingEntryMutex);
     std::unique_lock<StdLockableWrapper<QMutex>> l(wrapper, std::try_to_lock);
     return !l.owns_lock();
 }
 
 bool KisMainWindow::saveDocument(KisDocument *document, bool saveas)
 {
     if (!document) {
         return true;
     }
 
     /**
      * Make sure that we cannot enter this method twice!
      *
      * The lower level functions may call processEvents() so
      * double-entry is quite possible to achieve. Here we try to lock
      * the mutex, and if it is failed, just cancel saving.
      */
     StdLockableWrapper<QMutex> wrapper(&d->savingEntryMutex);
     std::unique_lock<StdLockableWrapper<QMutex>> l(wrapper, std::try_to_lock);
     if (!l.owns_lock()) return false;
 
     // no busy wait for saving because it is dangerous!
     KisDelayedSaveDialog dlg(document->image(), KisDelayedSaveDialog::SaveDialog, 0, this);
     dlg.blockIfImageIsBusy();
 
     if (dlg.result() == KisDelayedSaveDialog::Rejected) {
         return false;
     } else if (dlg.result() == KisDelayedSaveDialog::Ignored) {
         QMessageBox::critical(0,
                               i18nc("@title:window", "Krita"),
                               i18n("You are saving a file while the image is "
                                    "still rendering. The saved file may be "
                                    "incomplete or corrupted.\n\n"
                                    "Please select a location where the original "
                                    "file will not be overridden!"));
 
 
         saveas = true;
     }
 
     bool reset_url;
 
     if (document->url().isEmpty()) {
         reset_url = true;
         saveas = true;
     } else {
         reset_url = false;
     }
 
     connect(document, SIGNAL(sigProgress(int)), this, SLOT(slotProgress(int)));
     connect(document, SIGNAL(completed()), this, SLOT(slotSaveCompleted()));
     connect(document, SIGNAL(canceled(const QString &)), this, SLOT(slotSaveCanceled(const QString &)));
 
     QUrl oldURL = document->url();
     QString oldFile = document->localFilePath();
 
     QByteArray _native_format = document->nativeFormatMimeType();
     QByteArray oldOutputFormat = document->outputMimeType();
 
     QUrl suggestedURL = document->url();
 
     QStringList mimeFilter;
 
     mimeFilter = KisImportExportManager::mimeFilter(KisImportExportManager::Export);
 
     if (!mimeFilter.contains(oldOutputFormat) && !d->isExporting) {
         dbgUI << "KisMainWindow::saveDocument no export filter for" << oldOutputFormat;
 
         // --- don't setOutputMimeType in case the user cancels the Save As
         // dialog and then tries to just plain Save ---
 
         // suggest a different filename extension (yes, we fortunately don't all live in a world of magic :))
         QString suggestedFilename = suggestedURL.fileName();
 
         if (!suggestedFilename.isEmpty()) {  // ".kra" looks strange for a name
             int c = suggestedFilename.lastIndexOf('.');
 
             const QString ext = KisMimeDatabase::suffixesForMimeType(_native_format).first();
             if (!ext.isEmpty()) {
                 if (c < 0)
                     suggestedFilename = suggestedFilename + "." + ext;
                 else
                     suggestedFilename = suggestedFilename.left(c) + "." + ext;
             } else { // current filename extension wrong anyway
                 if (c > 0) {
                     // this assumes that a . signifies an extension, not just a .
                     suggestedFilename = suggestedFilename.left(c);
                 }
             }
 
             suggestedURL = suggestedURL.adjusted(QUrl::RemoveFilename);
             suggestedURL.setPath(suggestedURL.path() + suggestedFilename);
         }
 
         // force the user to choose outputMimeType
         saveas = true;
     }
 
     bool ret = false;
 
     if (document->url().isEmpty() || saveas) {
         // if you're just File/Save As'ing to change filter options you
         // don't want to be reminded about overwriting files etc.
         bool justChangingFilterOptions = false;
 
         KoFileDialog dialog(this, KoFileDialog::SaveFile, "SaveAs");
         dialog.setCaption(i18n("untitled"));
         if (d->isExporting && !d->lastExportUrl.isEmpty()) {
             dialog.setDefaultDir(d->lastExportUrl.toLocalFile());
         }
         else {
             dialog.setDefaultDir(suggestedURL.toLocalFile());
         }
         // Default to all supported file types if user is exporting, otherwise use Krita default
         dialog.setMimeTypeFilters(mimeFilter, QString(_native_format));
         QUrl newURL = QUrl::fromUserInput(dialog.filename());
 
         if (newURL.isLocalFile()) {
             QString fn = newURL.toLocalFile();
             if (QFileInfo(fn).completeSuffix().isEmpty()) {
                 fn.append(KisMimeDatabase::suffixesForMimeType(_native_format).first());
                 newURL = QUrl::fromLocalFile(fn);
             }
         }
 
         if (document->documentInfo()->aboutInfo("title") == i18n("Unnamed")) {
             QString fn = newURL.toLocalFile();
             QFileInfo info(fn);
             document->documentInfo()->setAboutInfo("title", info.baseName());
         }
 
         QByteArray outputFormat = _native_format;
 
         QString outputFormatString = KisMimeDatabase::mimeTypeForFile(newURL.toLocalFile());
         outputFormat = outputFormatString.toLatin1();
 
 
         if (!d->isExporting) {
             justChangingFilterOptions = (newURL == document->url()) && (outputFormat == document->mimeType());
         }
         else {
             justChangingFilterOptions = (newURL == d->lastExportUrl) && (outputFormat == d->lastExportedFormat);
         }
 
         bool bOk = true;
         if (newURL.isEmpty()) {
             bOk = false;
         }
 
         if (bOk) {
             bool wantToSave = true;
 
             // don't change this line unless you know what you're doing :)
             if (!justChangingFilterOptions) {
                 if (!document->isNativeFormat(outputFormat))
                     wantToSave = true;
             }
 
             if (wantToSave) {
                 //
                 // Note:
                 // If the user is stupid enough to Export to the current URL,
                 // we do _not_ change this operation into a Save As.  Reasons
                 // follow:
                 //
                 // 1. A check like "d->isExporting && oldURL == newURL"
                 //    doesn't _always_ work on case-insensitive filesystems
                 //    and inconsistent behaviour is bad.
                 // 2. It is probably not a good idea to change document->mimeType
                 //    and friends because the next time the user File/Save's,
                 //    (not Save As) they won't be expecting that they are
                 //    using their File/Export settings
                 //
                 // As a bad side-effect of this, the modified flag will not
                 // be updated and it is possible that what is currently on
                 // their screen is not what is stored on disk (through loss
                 // of formatting).  But if you are dumb enough to change
                 // mimetype but not the filename, then arguably, _you_ are
                 // the "bug" :)
                 //
                 // - Clarence
                 //
                 document->setOutputMimeType(outputFormat);
                 if (!d->isExporting) {  // Save As
                     ret = document->saveAs(newURL);
 
                     if (ret) {
                         dbgUI << "Successful Save As!";
                         addRecentURL(newURL);
                         setReadWrite(true);
                     } else {
                         dbgUI << "Failed Save As!";
                         document->setUrl(oldURL);
                         document->setLocalFilePath(oldFile);
                         document->setOutputMimeType(oldOutputFormat);
                     }
                 } else { // Export
                     ret = document->exportDocument(newURL);
 
                     if (ret) {
                         // a few file dialog convenience things
                         d->lastExportUrl = newURL;
                         d->lastExportedFormat = outputFormat;
                     }
 
                     // always restore output format
                     document->setOutputMimeType(oldOutputFormat);
                 }
 
             }   // if (wantToSave)  {
             else
                 ret = false;
         }   // if (bOk) {
         else
             ret = false;
     } else { // saving
 
         // be sure document has the correct outputMimeType!
         if (d->isExporting || document->isModified()) {
             ret = document->save();
         }
 
         if (!ret) {
             dbgUI << "Failed Save!";
             document->setUrl(oldURL);
             document->setLocalFilePath(oldFile);
         }
     }
 
 
     if (!ret && reset_url)
         document->resetURL(); //clean the suggested filename as the save dialog was rejected
 
     updateReloadFileAction(document);
     updateCaption();
 
     return ret;
 }
 
 void KisMainWindow::undo()
 {
     if (activeView()) {
         activeView()->undoAction()->trigger();
         d->undo->setText(activeView()->undoAction()->text());
     }
 }
 
 void KisMainWindow::redo()
 {
     if (activeView()) {
         activeView()->redoAction()->trigger();
         d->redo->setText(activeView()->redoAction()->text());
     }
 }
 
 void KisMainWindow::closeEvent(QCloseEvent *e)
 {
     d->mdiArea->closeAllSubWindows();
 
     QAction *action= d->viewManager->actionCollection()->action("view_show_canvas_only");
 
     if ((action) && (action->isChecked())) {
         action->setChecked(false);
     }
     KConfigGroup cfg( KSharedConfig::openConfig(), "MainWindow");
     cfg.writeEntry("ko_geometry", saveGeometry().toBase64());
     cfg.writeEntry("ko_windowstate", saveState().toBase64());
 
     {
         KConfigGroup group( KSharedConfig::openConfig(), "theme");
         group.writeEntry("Theme", d->themeManager->currentThemeName());
     }
 
     QList<QMdiSubWindow*> childrenList = d->mdiArea->subWindowList();
 
     if (childrenList.isEmpty()) {
         d->deferredClosingEvent = e;
 
         if (!d->dockerStateBeforeHiding.isEmpty()) {
             restoreState(d->dockerStateBeforeHiding);
         }
         statusBar()->setVisible(true);
         menuBar()->setVisible(true);
 
         saveWindowSettings();
 
         if (d->noCleanup)
             return;
 
         if (!d->dockWidgetVisibilityMap.isEmpty()) { // re-enable dockers for persistency
             Q_FOREACH (QDockWidget* dockWidget, d->dockWidgetsMap)
                 dockWidget->setVisible(d->dockWidgetVisibilityMap.value(dockWidget));
         }
     } else {
         e->setAccepted(false);
     }
 }
 
 void KisMainWindow::saveWindowSettings()
 {
     KSharedConfigPtr config =  KSharedConfig::openConfig();
 
     if (d->windowSizeDirty ) {
         dbgUI << "KisMainWindow::saveWindowSettings";
         KConfigGroup group = config->group("MainWindow");
         KWindowConfig::saveWindowSize(windowHandle(), group);
         config->sync();
         d->windowSizeDirty = false;
     }
 
     if (!d->activeView || d->activeView->document()) {
 
         // Save toolbar position into the config file of the app, under the doc's component name
         KConfigGroup group =  KSharedConfig::openConfig()->group("krita");
         saveMainWindowSettings(group);
 
         // Save collapsable state of dock widgets
         for (QMap<QString, QDockWidget*>::const_iterator i = d->dockWidgetsMap.constBegin();
              i != d->dockWidgetsMap.constEnd(); ++i) {
             if (i.value()->widget()) {
                 KConfigGroup dockGroup = group.group(QString("DockWidget ") + i.key());
                 dockGroup.writeEntry("Collapsed", i.value()->widget()->isHidden());
                 dockGroup.writeEntry("Locked", i.value()->property("Locked").toBool());
                 dockGroup.writeEntry("DockArea", (int) dockWidgetArea(i.value()));
                 dockGroup.writeEntry("xPosition", (int) i.value()->widget()->x());
                 dockGroup.writeEntry("yPosition", (int) i.value()->widget()->y());
 
                 dockGroup.writeEntry("width", (int) i.value()->widget()->width());
                 dockGroup.writeEntry("height", (int) i.value()->widget()->height());
             }
         }
 
     }
 
      KSharedConfig::openConfig()->sync();
     resetAutoSaveSettings(); // Don't let KMainWindow override the good stuff we wrote down
 
 }
 
 void KisMainWindow::resizeEvent(QResizeEvent * e)
 {
     d->windowSizeDirty = true;
     KXmlGuiWindow::resizeEvent(e);
 }
 
 void KisMainWindow::setActiveView(KisView* view)
 {
     d->activeView = view;
     updateCaption();
     actionCollection()->action("edit_undo")->setText(activeView()->undoAction()->text());
     actionCollection()->action("edit_redo")->setText(activeView()->redoAction()->text());
     d->viewManager->setCurrentView(view);
 }
 
 void KisMainWindow::dragEnterEvent(QDragEnterEvent *event)
 {
     if (event->mimeData()->hasUrls() ||
         event->mimeData()->hasFormat("application/x-krita-node") ||
         event->mimeData()->hasFormat("application/x-qt-image")) {
 
         event->accept();
     }
 }
 
 void KisMainWindow::dropEvent(QDropEvent *event)
 {
     if (event->mimeData()->hasUrls() && event->mimeData()->urls().size() > 0) {
         Q_FOREACH (const QUrl &url, event->mimeData()->urls()) {
             openDocument(url);
         }
     }
 }
 
 void KisMainWindow::dragMoveEvent(QDragMoveEvent * event)
 {
     QTabBar *tabBar = d->findTabBarHACK();
 
     if (!tabBar && d->mdiArea->viewMode() == QMdiArea::TabbedView) {
         qWarning() << "WARNING!!! Cannot find QTabBar in the main window! Looks like Qt has changed behavior. Drag & Drop between multiple tabs might not work properly (tabs will not switch automatically)!";
     }
 
     if (tabBar && tabBar->isVisible()) {
         QPoint pos = tabBar->mapFromGlobal(mapToGlobal(event->pos()));
         if (tabBar->rect().contains(pos)) {
             const int tabIndex = tabBar->tabAt(pos);
 
             if (tabIndex >= 0 && tabBar->currentIndex() != tabIndex) {
                 d->tabSwitchCompressor->start(tabIndex);
             }
         } else if (d->tabSwitchCompressor->isActive()) {
             d->tabSwitchCompressor->stop();
         }
     }
 }
 
 void KisMainWindow::dragLeaveEvent(QDragLeaveEvent * /*event*/)
 {
     if (d->tabSwitchCompressor->isActive()) {
         d->tabSwitchCompressor->stop();
     }
 }
 
 void KisMainWindow::switchTab(int index)
 {
     QTabBar *tabBar = d->findTabBarHACK();
     if (!tabBar) return;
 
     tabBar->setCurrentIndex(index);
 }
 
 void KisMainWindow::slotFileNew()
 {
     const QStringList mimeFilter = KisImportExportManager::mimeFilter(KisImportExportManager::Import);
 
     KisOpenPane *startupWidget = new KisOpenPane(this, mimeFilter, QStringLiteral("templates/"));
     startupWidget->setWindowModality(Qt::WindowModal);
 
     KisConfig cfg;
 
     int w = cfg.defImageWidth();
     int h = cfg.defImageHeight();
     const double resolution = cfg.defImageResolution();
     const QString colorModel = cfg.defColorModel();
     const QString colorDepth = cfg.defaultColorDepth();
     const QString colorProfile = cfg.defColorProfile();
 
 
     CustomDocumentWidgetItem item;
     item.widget = new KisCustomImageWidget(startupWidget,
                                            w,
                                            h,
                                            resolution,
                                            colorModel,
                                            colorDepth,
                                            colorProfile,
                                            i18n("Unnamed"));
 
     item.icon = "document-new";
 
     startupWidget->addCustomDocumentWidget(item.widget, item.title, item.icon);
 
     QSize sz = KisClipboard::instance()->clipSize();
     if (sz.isValid() && sz.width() != 0 && sz.height() != 0) {
         w = sz.width();
         h = sz.height();
     }
 
     item.widget = new KisImageFromClipboard(startupWidget,
                                             w,
                                             h,
                                             resolution,
                                             colorModel,
                                             colorDepth,
                                             colorProfile,
                                             i18n("Unnamed"));
 
     item.title = i18n("Create from Clipboard");
     item.icon = "tab-new";
 
     startupWidget->addCustomDocumentWidget(item.widget, item.title, item.icon);
 
     // calls deleteLater
     connect(startupWidget, SIGNAL(documentSelected(KisDocument*)), KisPart::instance(), SLOT(startCustomDocument(KisDocument*)));
     // calls deleteLater
     connect(startupWidget, SIGNAL(openTemplate(const QUrl&)), KisPart::instance(), SLOT(openTemplate(const QUrl&)));
 
     startupWidget->exec();
 
     // Cancel calls deleteLater...
 
 }
 
 void KisMainWindow::slotFileOpen()
 {
     QStringList urls = showOpenFileDialog();
 
     if (urls.isEmpty())
         return;
 
     Q_FOREACH (const QString& url, urls) {
 
         if (!url.isEmpty()) {
             bool res = openDocument(QUrl::fromLocalFile(url));
             if (!res) {
                 warnKrita << "Loading" << url << "failed";
             }
         }
     }
 }
 
 void KisMainWindow::slotFileOpenRecent(const QUrl &url)
 {
     (void) openDocument(QUrl::fromLocalFile(url.toLocalFile()));
 }
 
 void KisMainWindow::slotFileSave()
 {
     if (saveDocument(d->activeView->document())) {
         emit documentSaved();
     }
 }
 
 void KisMainWindow::slotFileSaveAs()
 {
     if (saveDocument(d->activeView->document(), true)) {
         emit documentSaved();
     }
 }
 
 KoCanvasResourceManager *KisMainWindow::resourceManager() const
 {
     return d->viewManager->resourceProvider()->resourceManager();
 }
 
 int KisMainWindow::viewCount() const
 {
     return d->mdiArea->subWindowList().size();
 }
 
 bool KisMainWindow::restoreWorkspace(const QByteArray &state)
 {
     QByteArray oldState = saveState();
     const bool showTitlebars = KisConfig().showDockerTitleBars();
 
     // needed because otherwise the layout isn't correctly restored in some situations
     Q_FOREACH (QDockWidget *dock, dockWidgets()) {
         dock->hide();
         dock->titleBarWidget()->setVisible(showTitlebars);
     }
 
     bool success = KXmlGuiWindow::restoreState(state);
 
     if (!success) {
         KXmlGuiWindow::restoreState(oldState);
         Q_FOREACH (QDockWidget *dock, dockWidgets()) {
             if (dock->titleBarWidget()) {
                 dock->titleBarWidget()->setVisible(showTitlebars || dock->isFloating());
             }
         }
         return false;
     }
 
 
     Q_FOREACH (QDockWidget *dock, dockWidgets()) {
         if (dock->titleBarWidget()) {
             const bool isCollapsed = (dock->widget() && dock->widget()->isHidden()) || !dock->widget();
             dock->titleBarWidget()->setVisible(showTitlebars || (dock->isFloating() && isCollapsed));
         }
     }
 
     return success;
 }
 
 KisViewManager *KisMainWindow::viewManager() const
 {
     return d->viewManager;
 }
 
 void KisMainWindow::slotDocumentInfo()
 {
     if (!d->activeView->document())
         return;
 
     KoDocumentInfo *docInfo = d->activeView->document()->documentInfo();
 
     if (!docInfo)
         return;
 
     KoDocumentInfoDlg *dlg = d->activeView->document()->createDocumentInfoDialog(this, docInfo);
 
     if (dlg->exec()) {
         if (dlg->isDocumentSaved()) {
             d->activeView->document()->setModified(false);
         } else {
             d->activeView->document()->setModified(true);
         }
         d->activeView->document()->setTitleModified();
     }
 
     delete dlg;
 }
 
 bool KisMainWindow::slotFileCloseAll()
 {
     Q_FOREACH (QMdiSubWindow *subwin, d->mdiArea->subWindowList()) {
         if (subwin) {
             if(!subwin->close())
                 return false;
         }
     }
 
     updateCaption();
     return true;
 }
 
 void KisMainWindow::slotFileQuit()
 {
     if(!slotFileCloseAll())
         return;
 
     close();
 
     Q_FOREACH (QPointer<KisMainWindow> mainWin, KisPart::instance()->mainWindows()) {
         if (mainWin != this) {
             if(!mainWin->slotFileCloseAll())
                 return;
 
             mainWin->close();
         }
     }
 }
 
 void KisMainWindow::slotFilePrint()
 {
     if (!activeView())
         return;
     KisPrintJob *printJob = activeView()->createPrintJob();
     if (printJob == 0)
         return;
     applyDefaultSettings(printJob->printer());
     QPrintDialog *printDialog = activeView()->createPrintDialog( printJob, this );
     if (printDialog && printDialog->exec() == QDialog::Accepted) {
         printJob->printer().setPageMargins(0.0, 0.0, 0.0, 0.0, QPrinter::Point);
         printJob->printer().setPaperSize(QSizeF(activeView()->image()->width() / (72.0 * activeView()->image()->xRes()),
                                                 activeView()->image()->height()/ (72.0 * activeView()->image()->yRes())),
                                          QPrinter::Inch);
         printJob->startPrinting(KisPrintJob::DeleteWhenDone);
     }
     else {
         delete printJob;
     }
     delete printDialog;
 }
 
 void KisMainWindow::slotFilePrintPreview()
 {
     if (!activeView())
         return;
     KisPrintJob *printJob = activeView()->createPrintJob();
     if (printJob == 0)
         return;
 
     /* Sets the startPrinting() slot to be blocking.
      The Qt print-preview dialog requires the printing to be completely blocking
      and only return when the full document has been printed.
      By default the KisPrintingDialog is non-blocking and
      multithreading, setting blocking to true will allow it to be used in the preview dialog */
     printJob->setProperty("blocking", true);
     QPrintPreviewDialog *preview = new QPrintPreviewDialog(&printJob->printer(), this);
     printJob->setParent(preview); // will take care of deleting the job
     connect(preview, SIGNAL(paintRequested(QPrinter*)), printJob, SLOT(startPrinting()));
     preview->exec();
     delete preview;
 }
 
 KisPrintJob* KisMainWindow::exportToPdf(QString pdfFileName)
 {
     if (!activeView())
         return 0;
 
     if (!activeView()->document())
         return 0;
 
     KoPageLayout pageLayout;
     pageLayout.width = 0;
     pageLayout.height = 0;
     pageLayout.topMargin = 0;
     pageLayout.bottomMargin = 0;
     pageLayout.leftMargin = 0;
     pageLayout.rightMargin = 0;
 
     if (pdfFileName.isEmpty()) {
         KConfigGroup group =  KSharedConfig::openConfig()->group("File Dialogs");
         QString defaultDir = group.readEntry("SavePdfDialog");
         if (defaultDir.isEmpty())
             defaultDir = QDesktopServices::storageLocation(QDesktopServices::DocumentsLocation);
         QUrl startUrl = QUrl::fromLocalFile(defaultDir);
         KisDocument* pDoc = d->activeView->document();
         /** if document has a file name, take file name and replace extension with .pdf */
         if (pDoc && pDoc->url().isValid()) {
             startUrl = pDoc->url();
             QString fileName = startUrl.toLocalFile();
             fileName = fileName.replace( QRegExp( "\\.\\w{2,5}$", Qt::CaseInsensitive ), ".pdf" );
             startUrl = startUrl.adjusted(QUrl::RemoveFilename);
             startUrl.setPath(startUrl.path() +  fileName );
         }
 
         QPointer<KoPageLayoutDialog> layoutDlg(new KoPageLayoutDialog(this, pageLayout));
         layoutDlg->setWindowModality(Qt::WindowModal);
         if (layoutDlg->exec() != QDialog::Accepted || !layoutDlg) {
             delete layoutDlg;
             return 0;
         }
         pageLayout = layoutDlg->pageLayout();
         delete layoutDlg;
 
         KoFileDialog dialog(this, KoFileDialog::SaveFile, "OpenDocument");
         dialog.setCaption(i18n("Export as PDF"));
         dialog.setDefaultDir(startUrl.toLocalFile());
         dialog.setMimeTypeFilters(QStringList() << "application/pdf");
         QUrl url = QUrl::fromUserInput(dialog.filename());
 
         pdfFileName = url.toLocalFile();
         if (pdfFileName.isEmpty())
             return 0;
     }
 
     KisPrintJob *printJob = activeView()->createPrintJob();
     if (printJob == 0)
         return 0;
     if (isHidden()) {
         printJob->setProperty("noprogressdialog", true);
     }
 
     applyDefaultSettings(printJob->printer());
     // TODO for remote files we have to first save locally and then upload.
     printJob->printer().setOutputFileName(pdfFileName);
     printJob->printer().setDocName(pdfFileName);
     printJob->printer().setColorMode(QPrinter::Color);
 
     if (pageLayout.format == KoPageFormat::CustomSize) {
         printJob->printer().setPaperSize(QSizeF(pageLayout.width, pageLayout.height), QPrinter::Millimeter);
     } else {
         printJob->printer().setPaperSize(KoPageFormat::printerPageSize(pageLayout.format));
     }
 
     printJob->printer().setPageMargins(pageLayout.leftMargin, pageLayout.topMargin, pageLayout.rightMargin, pageLayout.bottomMargin, QPrinter::Millimeter);
 
     switch (pageLayout.orientation) {
     case KoPageFormat::Portrait:
         printJob->printer().setOrientation(QPrinter::Portrait);
         break;
     case KoPageFormat::Landscape:
         printJob->printer().setOrientation(QPrinter::Landscape);
         break;
     }
 
     //before printing check if the printer can handle printing
     if (!printJob->canPrint()) {
         QMessageBox::critical(this, i18nc("@title:window", "Krita"), i18n("Cannot export to the specified file"));
     }
 
     printJob->startPrinting(KisPrintJob::DeleteWhenDone);
     return printJob;
 }
 
 void KisMainWindow::importAnimation()
 {
     if (!activeView()) return;
 
     KisDocument *document = activeView()->document();
     if (!document) return;
 
     KisDlgImportImageSequence dlg(this, document);
 
     if (dlg.exec() == QDialog::Accepted) {
         QStringList files = dlg.files();
         int firstFrame = dlg.firstFrame();
         int step = dlg.step();
 
         document->setFileProgressProxy();
         document->setFileProgressUpdater(i18n("Import frames"));
         KisAnimationImporter importer(document);
         KisImportExportFilter::ConversionStatus status = importer.import(files, firstFrame, step);
         document->clearFileProgressUpdater();
         document->clearFileProgressProxy();
 
         if (status != KisImportExportFilter::OK && status != KisImportExportFilter::InternalError) {
             QString msg = KisImportExportFilter::conversionStatusString(status);
 
             if (!msg.isEmpty())
                 QMessageBox::critical(0, i18nc("@title:window", "Krita"), i18n("Could not finish import animation:\n%1", msg));
         }
         activeView()->canvasBase()->refetchDataFromImage();
     }
 }
 
 void KisMainWindow::slotConfigureToolbars()
 {
     KConfigGroup group =  KSharedConfig::openConfig()->group("krita");
     saveMainWindowSettings(group);
     KEditToolBar edit(factory(), this);
     connect(&edit, SIGNAL(newToolBarConfig()), this, SLOT(slotNewToolbarConfig()));
     (void) edit.exec();
     applyToolBarLayout();
 }
 
 void KisMainWindow::slotNewToolbarConfig()
 {
     applyMainWindowSettings(KSharedConfig::openConfig()->group("krita"));
 
     KXMLGUIFactory *factory = guiFactory();
     Q_UNUSED(factory);
 
     // Check if there's an active view
     if (!d->activeView)
         return;
 
     plugActionList("toolbarlist", d->toolbarList);
     applyToolBarLayout();
 }
 
 void KisMainWindow::slotToolbarToggled(bool toggle)
 {
     //dbgUI <<"KisMainWindow::slotToolbarToggled" << sender()->name() <<" toggle=" << true;
     // The action (sender) and the toolbar have the same name
     KToolBar * bar = toolBar(sender()->objectName());
     if (bar) {
         if (toggle) {
             bar->show();
         }
         else {
             bar->hide();
         }
 
         if (d->activeView && d->activeView->document()) {
             KConfigGroup group =  KSharedConfig::openConfig()->group("krita");
             saveMainWindowSettings(group);
         }
     } else
         warnUI << "slotToolbarToggled : Toolbar " << sender()->objectName() << " not found!";
 }
 
 void KisMainWindow::viewFullscreen(bool fullScreen)
 {
     KisConfig cfg;
     cfg.setFullscreenMode(fullScreen);
 
     if (fullScreen) {
         setWindowState(windowState() | Qt::WindowFullScreen);   // set
     } else {
         setWindowState(windowState() & ~Qt::WindowFullScreen);   // reset
     }
 }
 
 void KisMainWindow::slotProgress(int value)
 {
     qApp->processEvents();
 
     StdLockableWrapper<QMutex> wrapper(&d->progressMutex);
     std::unique_lock<StdLockableWrapper<QMutex>> l(wrapper, std::try_to_lock);
     if (!l.owns_lock()) return;
 
 
     dbgUI << "KisMainWindow::slotProgress" << value;
     if (value <= -1 || value >= 100) {
         if (d->progress) {
             statusBar()->removeWidget(d->progress);
             delete d->progress;
             d->progress = 0;
 
             disconnect(d->progressCancel, SIGNAL(clicked()), this, SLOT(slotProgressCanceled()));
             statusBar()->removeWidget(d->progressCancel);
             delete d->progressCancel;
             d->progressCancel = 0;
         }
         d->firstTime = true;
         return;
     }
     if (d->firstTime || !d->progress) {
         // The statusbar might not even be created yet.
         // So check for that first, and create it if necessary
         QStatusBar *bar = findChild<QStatusBar *>();
         if (!bar) {
             statusBar()->show();
             QApplication::sendPostedEvents(this, QEvent::ChildAdded);
         }
 
         if (d->progress) {
             statusBar()->removeWidget(d->progress);
             delete d->progress;
             d->progress = 0;
 
             disconnect(d->progressCancel, SIGNAL(clicked()), this, SLOT(slotProgressCanceled()));
             statusBar()->removeWidget(d->progressCancel);
             delete d->progressCancel;
             d->progress = 0;
         }
 
         d->progressCancel = new QToolButton(statusBar());
         d->progressCancel->setMaximumHeight(statusBar()->fontMetrics().height());
         d->progressCancel->setIcon(KisIconUtils::loadIcon("process-stop"));
         statusBar()->addPermanentWidget(d->progressCancel);
 
         d->progress = new QProgressBar(statusBar());
         d->progress->setMaximumHeight(statusBar()->fontMetrics().height());
         d->progress->setRange(0, 100);
         statusBar()->addPermanentWidget(d->progress);
 
         connect(d->progressCancel, SIGNAL(clicked()), this, SLOT(slotProgressCanceled()));
 
         d->progress->show();
         d->progressCancel->show();
         d->firstTime = false;
     }
     if (!d->progress.isNull()) {
         d->progress->setValue(value);
     }
     qApp->processEvents();
 }
 
 void KisMainWindow::slotProgressCanceled()
 {
     emit sigProgressCanceled();
 }
 
 void KisMainWindow::setMaxRecentItems(uint _number)
 {
     d->recentFiles->setMaxItems(_number);
 }
 
 void KisMainWindow::slotReloadFile()
 {
     KisDocument* document = d->activeView->document();
     if (!document || document->url().isEmpty())
         return;
 
     if (document->isModified()) {
         bool ok = QMessageBox::question(this,
                                         i18nc("@title:window", "Krita"),
                                         i18n("You will lose all changes made since your last save\n"
                                              "Do you want to continue?"),
                                         QMessageBox::Yes | QMessageBox::No, QMessageBox::Yes) == QMessageBox::Yes;
         if (!ok)
             return;
     }
 
     QUrl url = document->url();
 
     saveWindowSettings();
     if (!document->reload()) {
         QMessageBox::critical(this, i18nc("@title:window", "Krita"), i18n("Error: Could not reload this document"));
     }
 
     return;
 
 }
 
 void KisMainWindow::slotImportFile()
 {
     dbgUI << "slotImportFile()";
 
     d->isImporting = true;
     slotFileOpen();
     d->isImporting = false;
 }
 
 void KisMainWindow::slotExportFile()
 {
     dbgUI << "slotExportFile()";
 
     d->isExporting = true;
     slotFileSaveAs();
     d->isExporting = false;
 }
 
 
 QDockWidget* KisMainWindow::createDockWidget(KoDockFactoryBase* factory)
 {
     QDockWidget* dockWidget = 0;
 
     if (!d->dockWidgetsMap.contains(factory->id())) {
         dockWidget = factory->createDockWidget();
 
         // It is quite possible that a dock factory cannot create the dock; don't
         // do anything in that case.
         if (!dockWidget) {
             warnKrita << "Could not create docker for" << factory->id();
             return 0;
         }
 
         KoDockWidgetTitleBar *titleBar = dynamic_cast<KoDockWidgetTitleBar*>(dockWidget->titleBarWidget());
 
         // Check if the dock widget is supposed to be collapsable
         if (!dockWidget->titleBarWidget()) {
             titleBar = new KoDockWidgetTitleBar(dockWidget);
             dockWidget->setTitleBarWidget(titleBar);
             titleBar->setCollapsable(factory->isCollapsable());
         }
         titleBar->setFont(KoDockRegistry::dockFont());
 
         dockWidget->setObjectName(factory->id());
         dockWidget->setParent(this);
 
         if (dockWidget->widget() && dockWidget->widget()->layout())
             dockWidget->widget()->layout()->setContentsMargins(1, 1, 1, 1);
 
         Qt::DockWidgetArea side = Qt::RightDockWidgetArea;
         bool visible = true;
 
         switch (factory->defaultDockPosition()) {
         case KoDockFactoryBase::DockTornOff:
             dockWidget->setFloating(true); // position nicely?
             break;
         case KoDockFactoryBase::DockTop:
             side = Qt::TopDockWidgetArea; break;
         case KoDockFactoryBase::DockLeft:
             side = Qt::LeftDockWidgetArea; break;
         case KoDockFactoryBase::DockBottom:
             side = Qt::BottomDockWidgetArea; break;
         case KoDockFactoryBase::DockRight:
             side = Qt::RightDockWidgetArea; break;
         case KoDockFactoryBase::DockMinimized:
         default:
             side = Qt::RightDockWidgetArea;
             visible = false;
         }
 
         KConfigGroup group =  KSharedConfig::openConfig()->group("krita").group("DockWidget " + factory->id());
         side = static_cast<Qt::DockWidgetArea>(group.readEntry("DockArea", static_cast<int>(side)));
         if (side == Qt::NoDockWidgetArea) side = Qt::RightDockWidgetArea;
 
         addDockWidget(side, dockWidget);
         if (!visible) {
             dockWidget->hide();
         }
         bool collapsed = factory->defaultCollapsed();
 
         bool locked = false;
         group =  KSharedConfig::openConfig()->group("krita").group("DockWidget " + factory->id());
         collapsed = group.readEntry("Collapsed", collapsed);
         locked = group.readEntry("Locked", locked);
 
         //dbgKrita << "docker" << factory->id() << dockWidget << "collapsed" << collapsed << "locked" << locked << "titlebar" << titleBar;
 
         if (titleBar && collapsed)
             titleBar->setCollapsed(true);
 
         if (titleBar && locked)
             titleBar->setLocked(true);
 
         d->dockWidgetsMap.insert(factory->id(), dockWidget);
     }
     else {
         dockWidget = d->dockWidgetsMap[factory->id()];
     }
 
 #ifdef Q_OS_OSX
     dockWidget->setAttribute(Qt::WA_MacSmallSize, true);
 #endif
     dockWidget->setFont(KoDockRegistry::dockFont());
 
     connect(dockWidget, SIGNAL(dockLocationChanged(Qt::DockWidgetArea)), this, SLOT(forceDockTabFonts()));
 
     return dockWidget;
 }
 
 void KisMainWindow::forceDockTabFonts()
 {
     Q_FOREACH (QObject *child, children()) {
         if (child->inherits("QTabBar")) {
             ((QTabBar *)child)->setFont(KoDockRegistry::dockFont());
         }
     }
 }
 
 QList<QDockWidget*> KisMainWindow::dockWidgets() const
 {
     return d->dockWidgetsMap.values();
 }
 
 QDockWidget* KisMainWindow::dockWidget(const QString &id)
 {
     if (!d->dockWidgetsMap.contains(id)) return 0;
     return d->dockWidgetsMap[id];
 }
 
 QList<KoCanvasObserverBase*> KisMainWindow::canvasObservers() const
 {
     QList<KoCanvasObserverBase*> observers;
 
     Q_FOREACH (QDockWidget *docker, dockWidgets()) {
         KoCanvasObserverBase *observer = dynamic_cast<KoCanvasObserverBase*>(docker);
         if (observer) {
             observers << observer;
         }
         else {
             warnKrita << docker << "is not a canvas observer";
         }
     }
     return observers;
 }
 
 
 void KisMainWindow::toggleDockersVisibility(bool visible)
 {
     if (!visible) {
         d->dockerStateBeforeHiding = saveState();
 
         Q_FOREACH (QObject* widget, children()) {
             if (widget->inherits("QDockWidget")) {
                 QDockWidget* dw = static_cast<QDockWidget*>(widget);
                 if (dw->isVisible()) {
                     dw->hide();
                 }
             }
         }
     }
     else {
         restoreState(d->dockerStateBeforeHiding);
     }
 }
 
 void KisMainWindow::setToolbarList(QList<QAction *> toolbarList)
 {
     qDeleteAll(d->toolbarList);
     d->toolbarList = toolbarList;
 }
 
 void KisMainWindow::slotDocumentTitleModified(const QString &caption, bool mod)
 {
     updateCaption();
     updateCaption(caption, mod);
     updateReloadFileAction(d->activeView ? d->activeView->document() : 0);
 }
 
 
 void KisMainWindow::subWindowActivated()
 {
     bool enabled = (activeKisView() != 0);
 
     d->mdiCascade->setEnabled(enabled);
     d->mdiNextWindow->setEnabled(enabled);
     d->mdiPreviousWindow->setEnabled(enabled);
     d->mdiTile->setEnabled(enabled);
     d->close->setEnabled(enabled);
     d->closeAll->setEnabled(enabled);
 
     setActiveSubWindow(d->mdiArea->activeSubWindow());
     Q_FOREACH (QToolBar *tb, toolBars()) {
         if (tb->objectName() == "BrushesAndStuff") {
             tb->setEnabled(enabled);
         }
     }
 
     updateCaption();
     d->actionManager()->updateGUI();
 }
 
 void KisMainWindow::updateWindowMenu()
 {
     QMenu *menu = d->windowMenu->menu();
     menu->clear();
 
     menu->addAction(d->newWindow);
     menu->addAction(d->documentMenu);
 
     QMenu *docMenu = d->documentMenu->menu();
     docMenu->clear();
 
     Q_FOREACH (QPointer<KisDocument> doc, KisPart::instance()->documents()) {
         if (doc) {
             QString title = doc->url().toDisplayString();
             if (title.isEmpty() && doc->image()) {
                 title = doc->image()->objectName();
             }
             QAction *action = docMenu->addAction(title);
             action->setIcon(qApp->windowIcon());
             connect(action, SIGNAL(triggered()), d->documentMapper, SLOT(map()));
             d->documentMapper->setMapping(action, doc);
         }
     }
 
     menu->addSeparator();
     menu->addAction(d->close);
     menu->addAction(d->closeAll);
     if (d->mdiArea->viewMode() == QMdiArea::SubWindowView) {
         menu->addSeparator();
         menu->addAction(d->mdiTile);
         menu->addAction(d->mdiCascade);
     }
     menu->addSeparator();
     menu->addAction(d->mdiNextWindow);
     menu->addAction(d->mdiPreviousWindow);
     menu->addSeparator();
 
     QList<QMdiSubWindow *> windows = d->mdiArea->subWindowList();
     for (int i = 0; i < windows.size(); ++i) {
         QPointer<KisView>child = qobject_cast<KisView*>(windows.at(i)->widget());
         if (child && child->document()) {
             QString text;
             if (i < 9) {
                 text = i18n("&%1 %2", i + 1, child->document()->url().toDisplayString());
             }
             else {
                 text = i18n("%1 %2", i + 1, child->document()->url().toDisplayString());
             }
 
             QAction *action  = menu->addAction(text);
             action->setIcon(qApp->windowIcon());
             action->setCheckable(true);
             action->setChecked(child == activeKisView());
             connect(action, SIGNAL(triggered()), d->windowMapper, SLOT(map()));
             d->windowMapper->setMapping(action, windows.at(i));
         }
     }
 
     updateCaption();
 }
 
 void KisMainWindow::setActiveSubWindow(QWidget *window)
 {
     if (!window) return;
     QMdiSubWindow *subwin = qobject_cast<QMdiSubWindow *>(window);
     //dbgKrita << "setActiveSubWindow();" << subwin << d->activeSubWindow;
 
     if (subwin && subwin != d->activeSubWindow) {
         KisView *view = qobject_cast<KisView *>(subwin->widget());
         //dbgKrita << "\t" << view << activeView();
         if (view && view != activeView()) {
              d->mdiArea->setActiveSubWindow(subwin);
             setActiveView(view);
         }
         d->activeSubWindow = subwin;
     }
     updateWindowMenu();
     d->actionManager()->updateGUI();
 }
 
 void KisMainWindow::configChanged()
 {
     KisConfig cfg;
     QMdiArea::ViewMode viewMode = (QMdiArea::ViewMode)cfg.readEntry<int>("mdi_viewmode", (int)QMdiArea::TabbedView);
     d->mdiArea->setViewMode(viewMode);
     Q_FOREACH (QMdiSubWindow *subwin, d->mdiArea->subWindowList()) {
         subwin->setOption(QMdiSubWindow::RubberBandMove, cfg.readEntry<int>("mdi_rubberband", cfg.useOpenGL()));
         subwin->setOption(QMdiSubWindow::RubberBandResize, cfg.readEntry<int>("mdi_rubberband", cfg.useOpenGL()));
     }
 
     KConfigGroup group( KSharedConfig::openConfig(), "theme");
     d->themeManager->setCurrentTheme(group.readEntry("Theme", "Krita dark"));
     d->actionManager()->updateGUI();
 
     QBrush brush(cfg.getMDIBackgroundColor());
     d->mdiArea->setBackground(brush);
 
     QString backgroundImage = cfg.getMDIBackgroundImage();
     if (backgroundImage != "") {
         QImage image(backgroundImage);
         QBrush brush(image);
         d->mdiArea->setBackground(brush);
     }
 
     d->mdiArea->update();
 }
 
 void KisMainWindow::newView(QObject *document)
 {
     KisDocument *doc = qobject_cast<KisDocument*>(document);
     addViewAndNotifyLoadingCompleted(doc);
     d->actionManager()->updateGUI();
 }
 
 void KisMainWindow::newWindow()
 {
     KisPart::instance()->createMainWindow()->show();
 }
 
 void KisMainWindow::closeCurrentWindow()
 {
     d->mdiArea->currentSubWindow()->close();
     d->actionManager()->updateGUI();
 }
 
 void KisMainWindow::checkSanity()
 {
     // print error if the lcms engine is not available
     if (!KoColorSpaceEngineRegistry::instance()->contains("icc")) {
         // need to wait 1 event since exiting here would not work.
         m_errorMessage = i18n("The Krita LittleCMS color management plugin is not installed. Krita will quit now.");
         m_dieOnError = true;
         QTimer::singleShot(0, this, SLOT(showErrorAndDie()));
         return;
     }
 
     KisPaintOpPresetResourceServer * rserver = KisResourceServerProvider::instance()->paintOpPresetServer();
     if (rserver->resources().isEmpty()) {
         m_errorMessage = i18n("Krita cannot find any brush presets! Krita will quit now.");
         m_dieOnError = true;
         QTimer::singleShot(0, this, SLOT(showErrorAndDie()));
         return;
     }
 }
 
 void KisMainWindow::showErrorAndDie()
 {
     QMessageBox::critical(0, i18nc("@title:window", "Installation error"), m_errorMessage);
     if (m_dieOnError) {
         exit(10);
     }
 }
 
 void KisMainWindow::showAboutApplication()
 {
     KisAboutApplication dlg(this);
     dlg.exec();
 }
 
 QPointer<KisView>KisMainWindow::activeKisView()
 {
     if (!d->mdiArea) return 0;
     QMdiSubWindow *activeSubWindow = d->mdiArea->activeSubWindow();
     //dbgKrita << "activeKisView" << activeSubWindow;
     if (!activeSubWindow) return 0;
     return qobject_cast<KisView*>(activeSubWindow->widget());
 }
 
 void KisMainWindow::newOptionWidgets(KoCanvasController *controller, const QList<QPointer<QWidget> > &optionWidgetList)
 {
     KIS_ASSERT_RECOVER_NOOP(controller == KoToolManager::instance()->activeCanvasController());
     bool isOurOwnView = false;
 
     Q_FOREACH (QPointer<KisView> view, KisPart::instance()->views()) {
         if (view && view->canvasController() == controller) {
             isOurOwnView = view->mainWindow() == this;
         }
     }
 
     if (!isOurOwnView) return;
 
     Q_FOREACH (QWidget *w, optionWidgetList) {
 #ifdef Q_OS_OSX
         w->setAttribute(Qt::WA_MacSmallSize, true);
 #endif
         w->setFont(KoDockRegistry::dockFont());
     }
 
     if (d->toolOptionsDocker) {
         d->toolOptionsDocker->setOptionWidgets(optionWidgetList);
     }
     else {
         d->viewManager->paintOpBox()->newOptionWidgets(optionWidgetList);
     }
 }
 
 void KisMainWindow::applyDefaultSettings(QPrinter &printer) {
 
     if (!d->activeView) return;
 
     QString title = d->activeView->document()->documentInfo()->aboutInfo("title");
     if (title.isEmpty()) {
         title = d->activeView->document()->url().fileName();
         // strip off the native extension (I don't want foobar.kwd.ps when printing into a file)
         QString extension = KisMimeDatabase::suffixesForMimeType(d->activeView->document()->outputMimeType()).first();
         if (title.endsWith(extension)) {
             title.chop(extension.length());
         }
     }
 
     if (title.isEmpty()) {
         // #139905
         title = i18n("%1 unsaved document (%2)", qApp->applicationDisplayName(),
                      QLocale().toString(QDate::currentDate(), QLocale::ShortFormat));
     }
     printer.setDocName(title);
 }
 
 void KisMainWindow::createActions()
 {
     KisActionManager *actionManager = d->actionManager();
     KisConfig cfg;
 
     actionManager->createStandardAction(KStandardAction::New, this, SLOT(slotFileNew()));
     actionManager->createStandardAction(KStandardAction::Open, this, SLOT(slotFileOpen()));
     actionManager->createStandardAction(KStandardAction::Quit, this, SLOT(slotFileQuit()));
     actionManager->createStandardAction(KStandardAction::ConfigureToolbars, this, SLOT(slotConfigureToolbars()));
     actionManager->createStandardAction(KStandardAction::FullScreen, this, SLOT(viewFullscreen(bool)));
 
     d->recentFiles = KStandardAction::openRecent(this, SLOT(slotFileOpenRecent(QUrl)), actionCollection());
     connect(d->recentFiles, SIGNAL(recentListCleared()), this, SLOT(saveRecentFiles()));
     KSharedConfigPtr configPtr =  KSharedConfig::openConfig();
     d->recentFiles->loadEntries(configPtr->group("RecentFiles"));
 
     d->saveAction = actionManager->createStandardAction(KStandardAction::Save, this, SLOT(slotFileSave()));
     d->saveAction->setActivationFlags(KisAction::ACTIVE_IMAGE);
 
     d->saveActionAs = actionManager->createStandardAction(KStandardAction::SaveAs, this, SLOT(slotFileSaveAs()));
     d->saveActionAs->setActivationFlags(KisAction::ACTIVE_IMAGE);
 
 //    d->printAction = actionManager->createStandardAction(KStandardAction::Print, this, SLOT(slotFilePrint()));
 //    d->printAction->setActivationFlags(KisAction::ACTIVE_IMAGE);
 
 //    d->printActionPreview = actionManager->createStandardAction(KStandardAction::PrintPreview, this, SLOT(slotFilePrintPreview()));
 //    d->printActionPreview->setActivationFlags(KisAction::ACTIVE_IMAGE);
 
     d->undo = actionManager->createStandardAction(KStandardAction::Undo, this, SLOT(undo()));
     d->undo ->setActivationFlags(KisAction::ACTIVE_IMAGE);
 
     d->redo = actionManager->createStandardAction(KStandardAction::Redo, this, SLOT(redo()));
     d->redo->setActivationFlags(KisAction::ACTIVE_IMAGE);
 
 //    d->exportPdf  = actionManager->createAction("file_export_pdf");
 //    connect(d->exportPdf, SIGNAL(triggered()), this, SLOT(exportToPdf()));
 
     d->importAnimation  = actionManager->createAction("file_import_animation");
     connect(d->importAnimation, SIGNAL(triggered()), this, SLOT(importAnimation()));
 
     d->closeAll = actionManager->createAction("file_close_all");
     connect(d->closeAll, SIGNAL(triggered()), this, SLOT(slotFileCloseAll()));
 
 //    d->reloadFile  = actionManager->createAction("file_reload_file");
 //    d->reloadFile->setActivationFlags(KisAction::CURRENT_IMAGE_MODIFIED);
 //    connect(d->reloadFile, SIGNAL(triggered(bool)), this, SLOT(slotReloadFile()));
 
     d->importFile  = actionManager->createAction("file_import_file");
     connect(d->importFile, SIGNAL(triggered(bool)), this, SLOT(slotImportFile()));
 
     d->exportFile  = actionManager->createAction("file_export_file");
     connect(d->exportFile, SIGNAL(triggered(bool)), this, SLOT(slotExportFile()));
 
     /* The following entry opens the document information dialog.  Since the action is named so it
         intends to show data this entry should not have a trailing ellipses (...).  */
     d->showDocumentInfo  = actionManager->createAction("file_documentinfo");
     connect(d->showDocumentInfo, SIGNAL(triggered(bool)), this, SLOT(slotDocumentInfo()));
 
 
     d->themeManager->setThemeMenuAction(new KActionMenu(i18nc("@action:inmenu", "&Themes"), this));
     d->themeManager->registerThemeActions(actionCollection());
     connect(d->themeManager, SIGNAL(signalThemeChanged()), this, SLOT(slotThemeChanged()));
 
 
     d->toggleDockers = actionManager->createAction("view_toggledockers");
     cfg.showDockers(true);
     d->toggleDockers->setChecked(true);
     connect(d->toggleDockers, SIGNAL(toggled(bool)), SLOT(toggleDockersVisibility(bool)));
 
     d->toggleDockerTitleBars = actionManager->createAction("view_toggledockertitlebars");
     d->toggleDockerTitleBars->setChecked(cfg.showDockerTitleBars());
     connect(d->toggleDockerTitleBars, SIGNAL(toggled(bool)), SLOT(showDockerTitleBars(bool)));
 
     actionCollection()->addAction("settings_dockers_menu", d->dockWidgetMenu);
     actionCollection()->addAction("window", d->windowMenu);
 
     d->mdiCascade = actionManager->createAction("windows_cascade");
     connect(d->mdiCascade, SIGNAL(triggered()), d->mdiArea, SLOT(cascadeSubWindows()));
 
     d->mdiTile = actionManager->createAction("windows_tile");
     connect(d->mdiTile, SIGNAL(triggered()), d->mdiArea, SLOT(tileSubWindows()));
 
     d->mdiNextWindow = actionManager->createAction("windows_next");
     connect(d->mdiNextWindow, SIGNAL(triggered()), d->mdiArea, SLOT(activateNextSubWindow()));
 
     d->mdiPreviousWindow = actionManager->createAction("windows_previous");
     connect(d->mdiPreviousWindow, SIGNAL(triggered()), d->mdiArea, SLOT(activatePreviousSubWindow()));
 
     d->newWindow = actionManager->createAction("view_newwindow");
     connect(d->newWindow, SIGNAL(triggered(bool)), this, SLOT(newWindow()));
 
     d->close = actionManager->createAction("file_close");
     connect(d->close, SIGNAL(triggered()), SLOT(closeCurrentWindow()));
 
     d->sendInfo = actionManager->createAction("send_info");
     connect(d->sendInfo, SIGNAL(triggered()), SLOT(sendInfo()));
 
 
     actionManager->createStandardAction(KStandardAction::Preferences, this, SLOT(slotPreferences()));
 
     for (int i = 0; i < 2; i++) {
         d->expandingSpacers[i] = new KisAction(i18n("Expanding Spacer"));
         d->expandingSpacers[i]->setDefaultWidget(new QWidget(this));
         d->expandingSpacers[i]->defaultWidget()->setSizePolicy(QSizePolicy::Expanding, QSizePolicy::Expanding);
         actionManager->addAction(QString("expanding_spacer_%1").arg(i), d->expandingSpacers[i]);
     }
 }
 
 void KisMainWindow::applyToolBarLayout()
 {
     const bool isPlastiqueStyle = style()->objectName() == "plastique";
 
     Q_FOREACH (KToolBar *toolBar, toolBars()) {
         toolBar->layout()->setSpacing(4);
         if (isPlastiqueStyle) {
             toolBar->setContentsMargins(0, 0, 0, 2);
         }
         //Hide text for buttons with an icon in the toolbar
         Q_FOREACH (QAction *ac, toolBar->actions()){
             if (ac->icon().pixmap(QSize(1,1)).isNull() == false){
                 ac->setPriority(QAction::LowPriority);
             }else {
                 ac->setIcon(QIcon());
             }
         }
     }
 }
 
 void KisMainWindow::initializeGeometry()
 {
     // if the user didn's specify the geometry on the command line (does anyone do that still?),
     // we first figure out some good default size and restore the x,y position. See bug 285804Z.
     KConfigGroup cfg( KSharedConfig::openConfig(), "MainWindow");
     QByteArray geom = QByteArray::fromBase64(cfg.readEntry("ko_geometry", QByteArray()));
     if (!restoreGeometry(geom)) {
         const int scnum = QApplication::desktop()->screenNumber(parentWidget());
         QRect desk = QApplication::desktop()->availableGeometry(scnum);
         // if the desktop is virtual then use virtual screen size
         if (QApplication::desktop()->isVirtualDesktop()) {
             desk = QApplication::desktop()->availableGeometry(QApplication::desktop()->screen(scnum));
         }
 
         quint32 x = desk.x();
         quint32 y = desk.y();
         quint32 w = 0;
         quint32 h = 0;
 
         // Default size -- maximize on small screens, something useful on big screens
         const int deskWidth = desk.width();
         if (deskWidth > 1024) {
             // a nice width, and slightly less than total available
             // height to componensate for the window decs
             w = (deskWidth / 3) * 2;
             h = (desk.height() / 3) * 2;
         }
         else {
             w = desk.width();
             h = desk.height();
         }
 
         x += (desk.width() - w) / 2;
         y += (desk.height() - h) / 2;
 
         move(x,y);
         setGeometry(geometry().x(), geometry().y(), w, h);
     }
     restoreWorkspace(QByteArray::fromBase64(cfg.readEntry("ko_windowstate", QByteArray())));
 }
 
 void KisMainWindow::showManual()
 {
     QDesktopServices::openUrl(QUrl("https://docs.krita.org"));
 }
 
 void KisMainWindow::showDockerTitleBars(bool show)
 {
     Q_FOREACH (QDockWidget *dock, dockWidgets()) {
         if (dock->titleBarWidget()) {
             const bool isCollapsed = (dock->widget() && dock->widget()->isHidden()) || !dock->widget();
             dock->titleBarWidget()->setVisible(show || (dock->isFloating() && isCollapsed));
         }
     }
 
     KisConfig cfg;
     cfg.setShowDockerTitleBars(show);
 }
 
 void KisMainWindow::moveEvent(QMoveEvent *e)
 {
     if (qApp->desktop()->screenNumber(this) != qApp->desktop()->screenNumber(e->oldPos())) {
         KisConfigNotifier::instance()->notifyConfigChanged();
     }
 }
 
 
 
 #include <moc_KisMainWindow.cpp>
diff --git a/libs/ui/KisPart.cpp b/libs/ui/KisPart.cpp
index b9adec8d6e..e86ede0597 100644
--- a/libs/ui/KisPart.cpp
+++ b/libs/ui/KisPart.cpp
@@ -1,516 +1,493 @@
 /* This file is part of the KDE project
  * Copyright (C) 1998-1999 Torben Weis       <weis@kde.org>
  * Copyright (C) 2000-2005 David Faure       <faure@kde.org>
  * Copyright (C) 2007-2008 Thorsten Zachmann <zachmann@kde.org>
  * Copyright (C) 2010-2012 Boudewijn Rempt   <boud@kogmbh.com>
  * Copyright (C) 2011 Inge Wallin            <ingwa@kogmbh.com>
  * Copyright (C) 2015 Michael Abrahams       <miabraha@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 "KisPart.h"
 
 #include "KoProgressProxy.h"
 #include <KoCanvasBase.h>
 #include <KoCanvasController.h>
 #include <KoCanvasControllerWidget.h>
 #include <KoColorSpaceEngine.h>
 #include <KoResourceServerProvider.h>
 #include <KoShapeBasedDocumentBase.h>
 #include <KoToolManager.h>
 #include <kis_icon.h>
 
 #include "KisApplication.h"
 #include "KisDocument.h"
 #include "KisImportExportManager.h"
 #include "KisView.h"
 #include "KisViewManager.h"
 
 #include <KoDialog.h>
 #include <KoResourcePaths.h>
 #include <QKeySequence>
 #include <QMessageBox>
 #include <kactioncollection.h>
 #include <kconfig.h>
 #include <kconfiggroup.h>
 #include <kdesktopfile.h>
 #include <kis_debug.h>
 #include <klocalizedstring.h>
 
 #include <KisMimeDatabase.h>
 #include <QApplication>
 #include <QDialog>
 #include <QDomDocument>
 #include <QDomElement>
 #include <QGlobalStatic>
 
 #include "KisDocument.h"
 #include "KisDocument.h"
 #include "KisImportExportManager.h"
 #include "KisOpenPane.h"
 #include "KisView.h"
 #include "KisViewManager.h"
 #include "KoToolManager.h"
 #include "kis_animation_cache_populator.h"
 #include "kis_config.h"
 #include "kis_idle_watcher.h"
 #include "kis_image.h"
 #include "kis_resource_server_provider.h"
 #include "kis_script_manager.h"
 #include "kis_shape_controller.h"
 
 #include "kis_color_manager.h"
 #include "kis_debug.h"
 
 #include "kis_action.h"
 #include "kis_action_registry.h"
 
 Q_GLOBAL_STATIC(KisPart, s_instance)
 
 class Q_DECL_HIDDEN KisPart::Private {
 public:
     Private(KisPart* _part)
         : part(_part)
         , idleWatcher(2500)
         , animationCachePopulator(_part)
     {
     }
 
     ~Private()
     {
     }
 
     KisPart* part;
 
     QList<QPointer<KisView> > views;
     QList<QPointer<KisMainWindow> > mainWindows;
     QList<QPointer<KisDocument> > documents;
     QList<KisAction*> scriptActions;
 
     KActionCollection* actionCollection{ 0 };
 
     KisIdleWatcher idleWatcher;
     KisAnimationCachePopulator animationCachePopulator;
-    QScopedPointer<KisTelemetryAbstruct> installProvider;
-    QScopedPointer<KisTelemetryAbstruct> regularProvider;
+    QScopedPointer<KisTelemetryAbstruct> telemetryProvider;
 };
 
 KisPart* KisPart::instance()
 {
     return s_instance;
 }
 
 KisPart::KisPart()
     : d(new Private(this))
 {
     // Preload all the resources in the background
     Q_UNUSED(KoResourceServerProvider::instance());
     Q_UNUSED(KisResourceServerProvider::instance());
     Q_UNUSED(KisColorManager::instance());
 
     connect(this, SIGNAL(documentOpened(QString)),
         this, SLOT(updateIdleWatcherConnections()));
 
     connect(this, SIGNAL(documentClosed(QString)),
         this, SLOT(updateIdleWatcherConnections()));
 
     connect(KisActionRegistry::instance(), SIGNAL(shortcutsUpdated()),
         this, SLOT(updateShortcuts()));
     connect(&d->idleWatcher, SIGNAL(startedIdleMode()),
         &d->animationCachePopulator, SLOT(slotRequestRegeneration()));
 
     d->animationCachePopulator.slotRequestRegeneration();
 }
 
 KisPart::~KisPart()
 {
     while (!d->documents.isEmpty()) {
         delete d->documents.takeFirst();
     }
 
     while (!d->views.isEmpty()) {
         delete d->views.takeFirst();
     }
 
     while (!d->mainWindows.isEmpty()) {
         delete d->mainWindows.takeFirst();
     }
 
     delete d;
 }
 
 void KisPart::updateIdleWatcherConnections()
 {
     QVector<KisImageSP> images;
 
     Q_FOREACH (QPointer<KisDocument> document, documents()) {
         if (document->image()) {
             images << document->image();
         }
     }
 
     d->idleWatcher.setTrackedImages(images);
 }
 
 void KisPart::addDocument(KisDocument* document)
 {
     //dbgUI << "Adding document to part list" << document;
     Q_ASSERT(document);
     if (!d->documents.contains(document)) {
         d->documents.append(document);
         emit documentOpened('/' + objectName());
         emit sigDocumentAdded(document);
         connect(document, SIGNAL(sigSavingFinished()), SLOT(slotDocumentSaved()));
     }
 }
 
 QList<QPointer<KisDocument> > KisPart::documents() const
 {
     return d->documents;
 }
 
 KisDocument* KisPart::createDocument() const
 {
     KisDocument* doc = new KisDocument();
     return doc;
 }
 
 int KisPart::documentCount() const
 {
     return d->documents.size();
 }
 
 void KisPart::removeDocument(KisDocument* document)
 {
     d->documents.removeAll(document);
     emit documentClosed('/' + objectName());
     emit sigDocumentRemoved(document->url().toLocalFile());
     document->deleteLater();
 }
 
 KisMainWindow* KisPart::createMainWindow()
 {
     KisMainWindow* mw = new KisMainWindow();
     Q_FOREACH (QAction* action, d->scriptActions) {
         mw->viewManager()->scriptManager()->addAction(action);
     }
     dbgUI << "mainWindow" << (void*)mw << "added to view" << this;
     d->mainWindows.append(mw);
     emit sigWindowAdded(mw);
     return mw;
 }
 
 KisView* KisPart::createView(KisDocument* document,
     KoCanvasResourceManager* resourceManager,
     KActionCollection* actionCollection,
     QWidget* parent)
 {
     // If creating the canvas fails, record this and disable OpenGL next time
     KisConfig cfg;
     KConfigGroup grp(KSharedConfig::openConfig(), "crashprevention");
     if (grp.readEntry("CreatingCanvas", false)) {
         cfg.setUseOpenGL(false);
     }
     if (cfg.canvasState() == "OPENGL_FAILED") {
         cfg.setUseOpenGL(false);
     }
     grp.writeEntry("CreatingCanvas", true);
     grp.sync();
 
     QApplication::setOverrideCursor(Qt::WaitCursor);
     KisView* view = new KisView(document, resourceManager, actionCollection, parent);
     QApplication::restoreOverrideCursor();
 
     // Record successful canvas creation
     grp.writeEntry("CreatingCanvas", false);
     grp.sync();
 
     addView(view);
 
     return view;
 }
 
 void KisPart::addView(KisView* view)
 {
     if (!view)
         return;
 
     if (!d->views.contains(view)) {
         d->views.append(view);
     }
 
     emit sigViewAdded(view);
 }
 
 void KisPart::removeView(KisView* view)
 {
     if (!view)
         return;
 
     /**
      * HACK ALERT: we check here explicitly if the document (or main
      *             window), is saving the stuff. If we close the
      *             document *before* the saving is completed, a crash
      *             will happen.
      */
     KIS_ASSERT_RECOVER_RETURN(!view->mainWindow()->hackIsSaving());
 
     emit sigViewRemoved(view);
 
     QPointer<KisDocument> doc = view->document();
     d->views.removeAll(view);
 
     if (doc) {
         bool found = false;
         Q_FOREACH (QPointer<KisView> view, d->views) {
             if (view && view->document() == doc) {
                 found = true;
                 break;
             }
         }
         if (!found) {
             removeDocument(doc);
         }
     }
 }
 
 QList<QPointer<KisView> > KisPart::views() const
 {
     return d->views;
 }
 
 int KisPart::viewCount(KisDocument* doc) const
 {
     if (!doc) {
         return d->views.count();
     } else {
         int count = 0;
         Q_FOREACH (QPointer<KisView> view, d->views) {
             if (view && view->isVisible() && view->document() == doc) {
                 count++;
             }
         }
         return count;
     }
 }
 
 void KisPart::slotDocumentSaved()
 {
     KisDocument* doc = qobject_cast<KisDocument*>(sender());
     emit sigDocumentSaved(doc->url().toLocalFile());
 }
 
 void KisPart::removeMainWindow(KisMainWindow* mainWindow)
 {
     dbgUI << "mainWindow" << (void*)mainWindow << "removed from doc" << this;
     if (mainWindow) {
         d->mainWindows.removeAll(mainWindow);
     }
 }
 
 const QList<QPointer<KisMainWindow> >& KisPart::mainWindows() const
 {
     return d->mainWindows;
 }
 
 int KisPart::mainwindowCount() const
 {
     return d->mainWindows.count();
 }
 
 KisMainWindow* KisPart::currentMainwindow() const
 {
     QWidget* widget = qApp->activeWindow();
     KisMainWindow* mainWindow = qobject_cast<KisMainWindow*>(widget);
     while (!mainWindow && widget) {
         widget = widget->parentWidget();
         mainWindow = qobject_cast<KisMainWindow*>(widget);
     }
 
     if (!mainWindow && mainWindows().size() > 0) {
         mainWindow = mainWindows().first();
     }
     return mainWindow;
 }
 
 void KisPart::addScriptAction(KisAction* action)
 {
     d->scriptActions << action;
 }
 
 KisIdleWatcher* KisPart::idleWatcher() const
 {
     return &d->idleWatcher;
 }
 
 KisAnimationCachePopulator* KisPart::cachePopulator() const
 {
     return &d->animationCachePopulator;
 }
 
-void KisPart::setProvider(KisTelemetryAbstruct *provider, Providers kind)
+void KisPart::setProvider(KisTelemetryAbstruct *provider)
 {
-    if(!d->installProvider.isNull())
-        Q_ASSERT(d->installProvider);
-    switch (kind) {
-    case  InstallProvider: {
-        d->installProvider.reset(provider);
-        break;
-    }
-    case  RegularProvider: {
-        d->regularProvider.reset(provider);
-        break;
-    }
-    default:
-        break;
+    if(!d->telemetryProvider.isNull()){
+        KIS_SAFE_ASSERT_RECOVER_RETURN(false);
     }
+    d->telemetryProvider.reset(provider);
 }
 
-KisTelemetryAbstruct* KisPart::provider(KisPart::Providers kind)
+KisTelemetryAbstruct* KisPart::provider()
 {
-    switch (kind) {
-    case  InstallProvider: {
-        if (d->installProvider.isNull())
-            return nullptr;
-        return d->installProvider.data();
-    }
-    case  RegularProvider: {
-        if (d->regularProvider.isNull())
-            return nullptr;
-        return d->regularProvider.data();
-    }
-    default:
+    if (d->telemetryProvider.isNull())
         return nullptr;
-    }
-
+    return d->telemetryProvider.data();
 }
 
 void KisPart::openExistingFile(const QUrl& url)
 {
     Q_ASSERT(url.isLocalFile());
     qApp->setOverrideCursor(Qt::BusyCursor);
     KisDocument* document = createDocument();
     if (!document->openUrl(url)) {
         delete document;
         return;
     }
     if (!document->image()) {
         delete document;
         return;
     }
     document->setModified(false);
     addDocument(document);
 
     KisMainWindow* mw = currentMainwindow();
     mw->addViewAndNotifyLoadingCompleted(document);
 
     qApp->restoreOverrideCursor();
 }
 
 void KisPart::updateShortcuts()
 {
     // Update any non-UI actionCollections.  That includes:
     //  - Shortcuts called inside of tools
     //  - Perhaps other things?
     KoToolManager::instance()->updateToolShortcuts();
 
     // Now update the UI actions.
     Q_FOREACH (KisMainWindow* mainWindow, d->mainWindows) {
         KActionCollection* ac = mainWindow->actionCollection();
 
         ac->updateShortcuts();
 
         // Loop through mainWindow->actionCollections() to modify tooltips
         // so that they list shortcuts at the end in parentheses
         Q_FOREACH (QAction* action, ac->actions()) {
             // Remove any existing suffixes from the tooltips.
             // Note this regexp starts with a space, e.g. " (Ctrl-a)"
             QString strippedTooltip = action->toolTip().remove(QRegExp("\\s\\(.*\\)"));
 
             // Now update the tooltips with the new shortcut info.
             if (action->shortcut() == QKeySequence(0))
                 action->setToolTip(strippedTooltip);
             else
                 action->setToolTip(strippedTooltip + " (" + action->shortcut().toString() + ")");
         }
     }
 }
 
 void KisPart::openTemplate(const QUrl& url)
 {
     qApp->setOverrideCursor(Qt::BusyCursor);
     KisDocument* document = createDocument();
 
     bool ok = document->loadNativeFormat(url.toLocalFile());
     document->setModified(false);
     document->undoStack()->clear();
 
     if (ok) {
         QString mimeType = KisMimeDatabase::mimeTypeForFile(url.toLocalFile());
         // in case this is a open document template remove the -template from the end
         mimeType.remove(QRegExp("-template$"));
         document->setMimeTypeAfterLoading(mimeType);
         document->resetURL();
     } else {
         if (document->errorMessage().isEmpty()) {
             QMessageBox::critical(0, i18nc("@title:window", "Krita"), i18n("Could not create document from template\n%1", document->localFilePath()));
         } else {
             QMessageBox::critical(0, i18nc("@title:window", "Krita"), i18n("Could not create document from template\n%1\nReason: %2", document->localFilePath(), document->errorMessage()));
         }
         delete document;
         return;
     }
     addDocument(document);
 
     KisMainWindow* mw = currentMainwindow();
     mw->addViewAndNotifyLoadingCompleted(document);
 
     KisOpenPane* pane = qobject_cast<KisOpenPane*>(sender());
     if (pane) {
         pane->hide();
         pane->deleteLater();
     }
 
     qApp->restoreOverrideCursor();
 }
 
 void KisPart::addRecentURLToAllMainWindows(QUrl url)
 {
     // Add to recent actions list in our mainWindows
     Q_FOREACH (KisMainWindow* mainWindow, d->mainWindows) {
         mainWindow->addRecentURL(url);
     }
 }
 
 void KisPart::startCustomDocument(KisDocument* doc)
 {
     addDocument(doc);
     KisMainWindow* mw = currentMainwindow();
     KisOpenPane* pane = qobject_cast<KisOpenPane*>(sender());
     if (pane) {
         pane->hide();
         pane->deleteLater();
     }
     mw->addViewAndNotifyLoadingCompleted(doc);
 }
 
 KisInputManager* KisPart::currentInputManager()
 {
     KisMainWindow* mw = currentMainwindow();
     KisViewManager* manager = mw ? mw->viewManager() : 0;
     return manager ? manager->inputManager() : 0;
 }
diff --git a/libs/ui/KisPart.h b/libs/ui/KisPart.h
index 28880f8f0e..e57326b451 100644
--- a/libs/ui/KisPart.h
+++ b/libs/ui/KisPart.h
@@ -1,279 +1,274 @@
 /* This file is part of the KDE project
    Copyright (C) 1998, 1999 Torben Weis <weis@kde.org>
    Copyright (C) 2000-2005 David Faure  <faure@kde.org>
    Copyright (C) 2007 Thorsten Zachmann <zachmann@kde.org>
    Copyright (C) 2010 Boudewijn Rempt   <boud@kogmbh.com>
    Copyright (C) 2015 Michael Abrahams  <miabraha@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 KIS_PART_H
 #define KIS_PART_H
 
 #include <QList>
 #include <QScopedPointer>
 
 #include <QPointer>
 #include <QUrl>
 
 #include "kritaui_export.h"
 #include <KoConfig.h>
 #include <KisMainWindow.h>
 #include "kis_telemetry_abstruct.h"
 #include <memory>
 
 namespace KIO {
 }
 
 class KisAction;
 class KisDocument;
 class KisView;
 class KisDocument;
 class KisIdleWatcher;
 class KisAnimationCachePopulator;
 
 /**
  * KisPart is the Great Deku Tree of Krita.
  *
  * It is a singleton class which provides the main entry point to the application.
  * Krita supports multiple documents, multiple main windows, and multiple
  * components.  KisPart manages these resources and provides them to the rest of
  * Krita.  It manages lists of Actions and shortcuts as well.
  *
  * The terminology comes from KParts, which is a system allowing one KDE app
  * to be run from inside another, like pressing F4 inside dophin to run konsole.
  *
  * Needless to say, KisPart hasn't got much to do with KParts anymore.
  */
 class KRITAUI_EXPORT KisPart : public QObject
 {
     Q_OBJECT
 
 
 public:
 
-    enum Providers {
-        InstallProvider,
-        RegularProvider
-    };
-
     static KisPart *instance();
 
     /**
      * Constructor.
      *
      * @param parent may be another KisDocument, or anything else.
      *        Usually passed by KPluginFactory::create.
      */
     explicit KisPart();
 
     /**
      *  Destructor.
      *
      * The destructor does not delete any attached KisView objects and it does not
      * delete the attached widget as returned by widget().
      */
     ~KisPart() override;
 
     // ----------------- Document management -----------------
 
     /**
      * create an empty document. The document is not automatically registered with the part.
      */
     KisDocument *createDocument() const;
 
     /**
      * Add the specified document to the list of documents this KisPart manages.
      */
     void addDocument(KisDocument *document);
 
     /**
      * @return a list of all documents this part manages
      */
     QList<QPointer<KisDocument> > documents() const;
 
     /**
      * @return number of documents this part manages.
      */
     int documentCount() const;
 
     void removeDocument(KisDocument *document);
 
     // ----------------- MainWindow management -----------------
 
     /**
      * Create a new main window.
      */
     KisMainWindow *createMainWindow();
 
     /**
      * Removes a main window from the list of managed windows.
      *
      * This is called by the MainWindow after it finishes its shutdown routine.
      */
     void removeMainWindow(KisMainWindow *mainWindow);
 
     /**
      * @return the list of main windows.
      */
     const QList<QPointer<KisMainWindow> >& mainWindows() const;
 
     /**
      * @return the number of shells for the main window
      */
     int mainwindowCount() const;
 
     void addRecentURLToAllMainWindows(QUrl url);
 
     /**
      * @return the currently active main window.
      */
     KisMainWindow *currentMainwindow() const;
 
     /**
      * Add a given action to the list of dynamically defined actions. On creating
      * a mainwindow, all these actions will be added to the script manager.
      */
     void addScriptAction(KisAction *);
 
     /**
      * Load actions for currently active main window into KisActionRegistry.
      */
     void loadActions();
 
     /**
      * @return the application-wide KisIdleWatcher.
      */
     KisIdleWatcher *idleWatcher() const;
 
     /**
      * @return the application-wide AnimationCachePopulator.
      */
     KisAnimationCachePopulator *cachePopulator() const;
 
     // ----------------- Telemetry management -----------------
     /**
      * @return the telemetry provider.
      */
-    void setProvider(KisTelemetryAbstruct *provider, KisPart::Providers kind= InstallProvider);
+    void setProvider(KisTelemetryAbstruct *provider);
     /**
      * @return the telemetry provider.
      */
-    KisTelemetryAbstruct *provider(KisPart::Providers kind = InstallProvider);
+    KisTelemetryAbstruct *provider();
 
 
 public Q_SLOTS:
 
     /**
      * This slot loads an existing file.
      * @param url the file to load
      */
     void openExistingFile(const QUrl &url);
 
     /**
      * This slot loads a template and deletes the sender.
      * @param url the template to load
      */
     void openTemplate(const QUrl &url);
 
 
     /**
      * @brief startCustomDocument adds the given document to the document list and deletes the sender()
      * @param doc
      */
     void startCustomDocument(KisDocument *doc);
 
 private Q_SLOTS:
 
     void updateIdleWatcherConnections();
 
     void updateShortcuts();
 
 Q_SIGNALS:
     /**
      * emitted when a new document is opened. (for the idle watcher)
      */
     void documentOpened(const QString &ref);
 
     /**
      * emitted when an old document is closed. (for the idle watcher)
      */
     void documentClosed(const QString &ref);
 
     // These signals are for libkis or sketch
     void sigViewAdded(KisView *view);
     void sigViewRemoved(KisView *view);
     void sigDocumentAdded(KisDocument *document);
     void sigDocumentSaved(const QString &url);
     void sigDocumentRemoved(const QString &filename);
     void sigWindowAdded(KisMainWindow *window);
 
 public:
 
     KisInputManager *currentInputManager();
 
     //------------------ View management ------------------
 
     /**
      * Create a new view for the document. The view is added to the list of
      * views, and if the document wasn't known yet, it's registered as well.
      */
     KisView *createView(KisDocument *document,
                         KoCanvasResourceManager *resourceManager,
                         KActionCollection *actionCollection,
                         QWidget *parent);
 
     /**
      * Adds a view to the document. If the part doesn't know yet about
      * the document, it is registered.
      *
      * This calls KisView::updateReadWrite to tell the new view
      * whether the document is readonly or not.
      */
     void addView(KisView *view);
 
     /**
      * Removes a view of the document.
      */
     void removeView(KisView *view);
 
     /**
      * @return a list of views this document is displayed in
      */
     QList<QPointer<KisView> > views() const;
 
     /**
      * @return number of views this document is displayed in
      */
     int viewCount(KisDocument *doc) const;
 
 
 private Q_SLOTS:
 
     void slotDocumentSaved();
 
 private:
 
     Q_DISABLE_COPY(KisPart)
 
     class Private;
     Private *const d;
 
 
 };
 
 #endif
diff --git a/libs/ui/canvas/kis_tool_proxy.cpp b/libs/ui/canvas/kis_tool_proxy.cpp
index dd0263bbd2..2020d86a95 100644
--- a/libs/ui/canvas/kis_tool_proxy.cpp
+++ b/libs/ui/canvas/kis_tool_proxy.cpp
@@ -1,255 +1,260 @@
 /*
  *  Copyright (c) 2011 Dmitry Kazakov <dimula73@gmail.com>
  *
  *  This program is free software; you can redistribute it and/or modify
  *  it under the terms of the GNU General Public License as published by
  *  the Free Software Foundation; either version 2 of the License, or
  *  (at your option) any later version.
  *
  *  This program is distributed in the hope that it will be useful,
  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  *  GNU General Public License for more details.
  *
  *  You should have received a copy of the GNU General Public License
  *  along with this program; if not, write to the Free Software
  *  Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
  */
 
 #include "kis_tool_proxy.h"
 #include "kis_canvas2.h"
 #include "input/kis_tablet_debugger.h"
 
 #include <KoToolProxy_p.h>
+#include "kis_telemetry_actions.h"
 
 
 KisToolProxy::KisToolProxy(KoCanvasBase *canvas, QObject *parent)
     : KoToolProxy(canvas, parent),
       m_isActionActivated(false),
       m_lastAction(KisTool::Primary)
 {
 }
 
 void KisToolProxy::initializeImage(KisImageSP image)
 {
     connect(image, SIGNAL(sigUndoDuringStrokeRequested()), SLOT(requestUndoDuringStroke()), Qt::UniqueConnection);
     connect(image, SIGNAL(sigStrokeCancellationRequested()), SLOT(requestStrokeCancellation()), Qt::UniqueConnection);
     connect(image, SIGNAL(sigStrokeEndRequested()), SLOT(requestStrokeEnd()), Qt::UniqueConnection);
 }
 
 QPointF KisToolProxy::tabletToDocument(const QPointF &globalPos)
 {
     const QPointF pos = globalPos - QPointF(canvas()->canvasWidget()->mapToGlobal(QPoint(0, 0)));
     return widgetToDocument(pos);
 }
 
 QPointF KisToolProxy::widgetToDocument(const QPointF &widgetPoint) const
 {
     KisCanvas2 *kritaCanvas = dynamic_cast<KisCanvas2*>(canvas());
     Q_ASSERT(kritaCanvas);
 
     return kritaCanvas->coordinatesConverter()->widgetToDocument(widgetPoint);
 }
 
 KoPointerEvent KisToolProxy::convertEventToPointerEvent(QEvent *event, const QPointF &docPoint, bool *result)
 {
     switch (event->type()) {
     case QEvent::TabletPress:
     case QEvent::TabletRelease:
     case QEvent::TabletMove:
     {
         *result = true;
         QTabletEvent *tabletEvent = static_cast<QTabletEvent*>(event);
         KoPointerEvent ev(tabletEvent, docPoint);
         ev.setTabletButton(Qt::LeftButton);
         return ev;
     }
     case QEvent::MouseButtonPress:
     case QEvent::MouseButtonDblClick:
     case QEvent::MouseButtonRelease:
     case QEvent::MouseMove:
     {
         *result = true;
         QMouseEvent *mouseEvent = static_cast<QMouseEvent*>(event);
         return KoPointerEvent(mouseEvent, docPoint);
     }
     default:
         ;
     }
 
     *result = false;
     QMouseEvent fakeEvent(QEvent::MouseMove, QPoint(),
                           Qt::NoButton, Qt::NoButton,
                           Qt::NoModifier);
 
     return KoPointerEvent(&fakeEvent, QPointF());
 }
 
 void KisToolProxy::forwardHoverEvent(QEvent *event)
 {
     switch (event->type()) {
     case QEvent::TabletMove: {
         QTabletEvent *tabletEvent = static_cast<QTabletEvent*>(event);
         QPointF docPoint = widgetToDocument(tabletEvent->posF());
         this->tabletEvent(tabletEvent, docPoint);
         return;
     }
 
     case QEvent::MouseMove: {
         QMouseEvent *mouseEvent = static_cast<QMouseEvent*>(event);
         QPointF docPoint = widgetToDocument(mouseEvent->posF());
         mouseMoveEvent(mouseEvent, docPoint);
         return;
     }
 
     default: {
         qWarning() << "forwardHoverEvent encountered unknown event type.";
         return;
     }
     }
 }
 
 bool KisToolProxy::forwardEvent(ActionState state, KisTool::ToolAction action, QEvent *event, QEvent *originalEvent)
 {
     bool retval = true;
 
     QTabletEvent *tabletEvent = dynamic_cast<QTabletEvent*>(event);
     QTouchEvent *touchEvent = dynamic_cast<QTouchEvent*>(event);
     QMouseEvent *mouseEvent = dynamic_cast<QMouseEvent*>(event);
 
     if (tabletEvent) {
         QPointF docPoint = widgetToDocument(tabletEvent->posF());
         tabletEvent->accept();
         this->tabletEvent(tabletEvent, docPoint);
         forwardToTool(state, action, tabletEvent, docPoint);
         retval = tabletEvent->isAccepted();
     }
     else if (touchEvent) {
         if (state == END && touchEvent->type() != QEvent::TouchEnd) {
             //Fake a touch end if we are "upgrading" a single-touch gesture to a multi-touch gesture.
             QTouchEvent fakeEvent(QEvent::TouchEnd, touchEvent->device(),
                                   touchEvent->modifiers(), touchEvent->touchPointStates(),
                                   touchEvent->touchPoints());
             this->touchEvent(&fakeEvent);
         } else {
             this->touchEvent(touchEvent);
         }
     }
     else if (mouseEvent) {
         QPointF docPoint = widgetToDocument(mouseEvent->posF());
         mouseEvent->accept();
         if (mouseEvent->type() == QEvent::MouseButtonPress) {
             mousePressEvent(mouseEvent, docPoint);
         } else if (mouseEvent->type() == QEvent::MouseButtonDblClick) {
             mouseDoubleClickEvent(mouseEvent, docPoint);
         } else if (mouseEvent->type() == QEvent::MouseButtonRelease) {
             mouseReleaseEvent(mouseEvent, docPoint);
         } else if (mouseEvent->type() == QEvent::MouseMove) {
             mouseMoveEvent(mouseEvent, docPoint);
         }
         forwardToTool(state, action, originalEvent, docPoint);
         retval = mouseEvent->isAccepted();
     }
     else if (event && event->type() == QEvent::KeyPress) {
         QKeyEvent* kevent = static_cast<QKeyEvent*>(event);
         keyPressEvent(kevent);
     }
     else if (event && event->type() == QEvent::KeyRelease) {
         QKeyEvent* kevent = static_cast<QKeyEvent*>(event);
         keyReleaseEvent(kevent);
     }
 
     return retval;
 }
 
 void KisToolProxy::forwardToTool(ActionState state, KisTool::ToolAction action, QEvent *event, const QPointF &docPoint)
 {
     bool eventValid = false;
     KoPointerEvent ev = convertEventToPointerEvent(event, docPoint, &eventValid);
     KisTool *activeTool = dynamic_cast<KisTool*>(priv()->activeTool);
 
     if (!eventValid || !activeTool) return;
 
     switch (state) {
     case BEGIN:
         if (action == KisTool::Primary) {
             if (event->type() == QEvent::MouseButtonDblClick) {
                 activeTool->beginPrimaryDoubleClickAction(&ev);
             } else {
                 activeTool->beginPrimaryAction(&ev);
+                KisToolsStartUse kisToolsUse;
+                kisToolsUse.doAction(KisPart::instance()->provider(), activeTool->toolId());
             }
         } else {
             if (event->type() == QEvent::MouseButtonDblClick) {
                 activeTool->beginAlternateDoubleClickAction(&ev, KisTool::actionToAlternateAction(action));
             } else {
                 activeTool->beginAlternateAction(&ev, KisTool::actionToAlternateAction(action));
             }
         }
         break;
     case CONTINUE:
         if (action == KisTool::Primary) {
             activeTool->continuePrimaryAction(&ev);
         } else {
             activeTool->continueAlternateAction(&ev, KisTool::actionToAlternateAction(action));
         }
         break;
     case END:
         if (action == KisTool::Primary) {
             activeTool->endPrimaryAction(&ev);
+            KisToolsStopUse kisToolsUse;
+            kisToolsUse.doAction(KisPart::instance()->provider(), activeTool->toolId());
         } else {
             activeTool->endAlternateAction(&ev, KisTool::actionToAlternateAction(action));
         }
         break;
     }
 }
 
 bool KisToolProxy::primaryActionSupportsHiResEvents() const
 {
     KisTool *activeTool = dynamic_cast<KisTool*>(const_cast<KisToolProxy*>(this)->priv()->activeTool);
     return activeTool && activeTool->primaryActionSupportsHiResEvents();
 }
 
 void KisToolProxy::setActiveTool(KoToolBase *tool)
 {
     if (!tool) return;
 
     if (m_isActionActivated) {
         deactivateToolAction(m_lastAction);
         KoToolProxy::setActiveTool(tool);
         activateToolAction(m_lastAction);
     } else {
         KoToolProxy::setActiveTool(tool);
     }
 }
 
 void KisToolProxy::activateToolAction(KisTool::ToolAction action)
 {
     KisTool *activeTool = dynamic_cast<KisTool*>(const_cast<KisToolProxy*>(this)->priv()->activeTool);
 
     if (activeTool) {
         if (action == KisTool::Primary) {
             activeTool->activatePrimaryAction();
         } else {
             activeTool->activateAlternateAction(KisTool::actionToAlternateAction(action));
         }
     }
 
     m_isActionActivated = true;
     m_lastAction = action;
 }
 
 void KisToolProxy::deactivateToolAction(KisTool::ToolAction action)
 {
     KisTool *activeTool = dynamic_cast<KisTool*>(const_cast<KisToolProxy*>(this)->priv()->activeTool);
 
     if (activeTool) {
         if (action == KisTool::Primary) {
             activeTool->deactivatePrimaryAction();
         } else {
             activeTool->deactivateAlternateAction(KisTool::actionToAlternateAction(action));
         }
     }
 
     m_isActionActivated = false;
     m_lastAction = action;
 }
diff --git a/libs/ui/kis_node_filter_proxy_model.cpp b/libs/ui/kis_node_filter_proxy_model.cpp
index e9218bd6bb..2af77e4072 100644
--- a/libs/ui/kis_node_filter_proxy_model.cpp
+++ b/libs/ui/kis_node_filter_proxy_model.cpp
@@ -1,164 +1,165 @@
+
 /*
  *  Copyright (c) 2015 Dmitry Kazakov <dimula73@gmail.com>
  *
  *  This program is free software; you can redistribute it and/or modify
  *  it under the terms of the GNU General Public License as published by
  *  the Free Software Foundation; either version 2 of the License, or
  *  (at your option) any later version.
  *
  *  This program is distributed in the hope that it will be useful,
  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  *  GNU General Public License for more details.
  *
  *  You should have received a copy of the GNU General Public License
  *  along with this program; if not, write to the Free Software
  *  Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
  */
 
 #include "kis_node_filter_proxy_model.h"
 
 #include <QSet>
 #include "kis_node.h"
 #include "kis_node_model.h"
 #include "kis_node_manager.h"
 #include "kis_signal_compressor.h"
 
 #include "kis_image.h"
 
 
 struct KisNodeFilterProxyModel::Private
 {
     Private()
         : nodeModel(0),
           activeNodeCompressor(1000, KisSignalCompressor::FIRST_INACTIVE)
     {}
 
     KisNodeModel *nodeModel;
     KisNodeSP pendingActiveNode;
     KisNodeSP activeNode;
     QSet<int> acceptedLabels;
     KisSignalCompressor activeNodeCompressor;
     bool isUpdatingFilter = false;
 
     bool checkIndexAllowedRecursively(QModelIndex srcIndex);
 };
 
 KisNodeFilterProxyModel::KisNodeFilterProxyModel(QObject *parent)
     : QSortFilterProxyModel(parent),
       m_d(new Private)
 {
     connect(&m_d->activeNodeCompressor, SIGNAL(timeout()), SLOT(slotUpdateCurrentNodeFilter()));
 }
 
 KisNodeFilterProxyModel::~KisNodeFilterProxyModel()
 {
 }
 
 void KisNodeFilterProxyModel::setNodeModel(KisNodeModel *model)
 {
     m_d->nodeModel = model;
     setSourceModel(model);
 }
 
 bool KisNodeFilterProxyModel::setData(const QModelIndex &index, const QVariant &value, int role)
 {
     if (m_d->isUpdatingFilter && role == KisNodeModel::ActiveRole) {
         return false;
     }
 
     return QSortFilterProxyModel::setData(index, value, role);
 }
 
 bool KisNodeFilterProxyModel::Private::checkIndexAllowedRecursively(QModelIndex srcIndex)
 {
     KisNodeSP node = nodeModel->nodeFromIndex(srcIndex);
     if (node == activeNode ||
         acceptedLabels.contains(node->colorLabelIndex())) {
 
         return true;
     }
 
     bool result = false;
 
     const int numChildren = srcIndex.model()->rowCount(srcIndex);
     for (int i = 0; i < numChildren; i++) {
         QModelIndex child = srcIndex.child(i, 0);
         if (checkIndexAllowedRecursively(child)) {
             result = true;
             break;
         }
     }
 
     return result;
 }
 
 bool KisNodeFilterProxyModel::filterAcceptsRow(int source_row, const QModelIndex &source_parent) const
 {
     KIS_ASSERT_RECOVER(m_d->nodeModel) { return true; }
 
     const QModelIndex index = sourceModel()->index(source_row, 0, source_parent);
     KisNodeSP node = m_d->nodeModel->nodeFromIndex(index);
 
     return !node ||
         m_d->acceptedLabels.isEmpty() ||
         m_d->checkIndexAllowedRecursively(index);
 }
 
 KisNodeSP KisNodeFilterProxyModel::nodeFromIndex(const QModelIndex &index) const
 {
     KIS_ASSERT_RECOVER(m_d->nodeModel) { return 0; }
 
     QModelIndex srcIndex = mapToSource(index);
     return m_d->nodeModel->nodeFromIndex(srcIndex);
 }
 
 QModelIndex KisNodeFilterProxyModel::indexFromNode(KisNodeSP node) const
 {
     KIS_ASSERT_RECOVER(m_d->nodeModel) { return QModelIndex(); }
 
     QModelIndex srcIndex = m_d->nodeModel->indexFromNode(node);
     return mapFromSource(srcIndex);
 }
 
 void KisNodeFilterProxyModel::setAcceptedLabels(const QList<int> &value)
 {
     m_d->acceptedLabels = QSet<int>::fromList(value);
     invalidateFilter();
 }
 
 void KisNodeFilterProxyModel::setActiveNode(KisNodeSP node)
 {
     KIS_SAFE_ASSERT_RECOVER_RETURN(node);
     m_d->pendingActiveNode = node;
 
     if (node && indexFromNode(node).isValid()) {
         m_d->activeNodeCompressor.start();
     } else {
         slotUpdateCurrentNodeFilter();
     }
 }
 
 void KisNodeFilterProxyModel::slotUpdateCurrentNodeFilter()
 {
     m_d->activeNode = m_d->pendingActiveNode;
 
     /**
      * During the filter update the model might emit "current changed" signals,
      * which (in their turn) will issue setData(..., KisNodeModel::ActiveRole)
      * call, leading to a double recursion. Which, obviously, crashes Krita.
      *
      * Right now, just blocking the KisNodeModel::ActiveRole call is the
      * most obvious solution for the problem.
      */
     m_d->isUpdatingFilter = true;
     invalidateFilter();
     m_d->isUpdatingFilter = false;
 }
 
 void KisNodeFilterProxyModel::unsetDummiesFacade()
 {
     m_d->nodeModel->setDummiesFacade(0, 0, 0, 0, 0);
     m_d->pendingActiveNode = 0;
     m_d->activeNode = 0;
 }
diff --git a/libs/ui/kis_telemetry_abstruct.cpp b/libs/ui/kis_telemetry_abstruct.cpp
index bcf7dac968..a806969d8b 100644
--- a/libs/ui/kis_telemetry_abstruct.cpp
+++ b/libs/ui/kis_telemetry_abstruct.cpp
@@ -1,20 +1,48 @@
 #include "kis_telemetry_abstruct.h"
 
+void KisTelemetryAbstruct::doTicket(KisToolsActivate &action, QString id)
+{
+    Q_UNUSED(action);
+    id = getToolId(id, UseMode::Activate);
+    getTimeTicket(id);
+}
+
+void KisTelemetryAbstruct::doTicket(KisToolsDeactivate &action, QString id)
+{
+    Q_UNUSED(action);
+    id = getToolId(id, UseMode::Activate);
+    putTimeTicket(id);
+}
+
+void KisTelemetryAbstruct::doTicket(KisToolsStartUse &action, QString id)
+{
+    Q_UNUSED(action);
+    id = getToolId(id, UseMode::Use);
+    getTimeTicket(id);
+}
+
+void KisTelemetryAbstruct::doTicket(KisToolsStopUse &action, QString id)
+{
+    Q_UNUSED(action);
+    id = getToolId(id, UseMode::Use);
+    putTimeTicket(id);
+}
+
 QString KisTelemetryAbstruct::getToolId(QString id, KisTelemetryAbstruct::UseMode mode)
 {
     QString toolId = "Tool" + getUseMode(mode);
     toolId += id;
     return toolId;
 }
 
 QString KisTelemetryAbstruct::getUseMode(KisTelemetryAbstruct::UseMode mode)
 {
     switch (mode) {
     case Activate:
         return "/Activate/";
     case Use:
         return "/Use/";
     default:
         return "/Activate/";
     }
 }
diff --git a/libs/ui/kis_telemetry_abstruct.h b/libs/ui/kis_telemetry_abstruct.h
index 29321962b8..ec79cf0c69 100644
--- a/libs/ui/kis_telemetry_abstruct.h
+++ b/libs/ui/kis_telemetry_abstruct.h
@@ -1,56 +1,60 @@
 /* This file is part of the KDE project
    Copyright (C) 2017 Alexey Kapustin <akapust1n@mail.ru>
 
 
    This library is free software; you can redistribute it and/or
    modify it under the terms of the GNU Library General Public
    License as published by the Free Software Foundation; either
    version 2 of the License, or (at your option) any later version.
 
    This library is distributed in the hope that it will be useful,
    but WITHOUT ANY WARRANTY; without even the implied warranty of
    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
    Library General Public License for more details.
 
    You should have received a copy of the GNU Library General Public License
    along with this library; see the file COPYING.LIB.  If not, write to
    the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
  * Boston, MA 02110-1301, USA.
 */
 
 #ifndef KIS_TELEMETRY_ABSTRUCT_H
 #define KIS_TELEMETRY_ABSTRUCT_H
 #include "QScopedPointer"
 #include "kritaflake_export.h"
 #include <KUserFeedback/AbstractDataSource>
 #include <KUserFeedback/cpuinfosource.h>
 #include <KUserFeedback/provider.h>
 #include <QString>
 #include <QVector>
+#include "kis_telemetry_actions.h"
 
 class KRITAFLAKE_EXPORT KisTelemetryAbstruct {
-public:
-    enum UseMode{
-        Activate,
-        Use
-    };
-    enum Action{
-        getTimeTicket_,
-        putTimeTicket_
-    };
-
 public:
     virtual void sendData(QString path) = 0;
-    virtual void getTimeTicket(QString id, UseMode mode = Activate) = 0;
-    virtual void putTimeTicket(QString id, UseMode mode = Activate) = 0;
-    QString getToolId(QString id, UseMode mode = Activate );
     virtual ~KisTelemetryAbstruct() {}
+    void doTicket(KisToolsActivate &action, QString id);
+    void doTicket(KisToolsDeactivate &action, QString id);
+    void doTicket(KisToolsStartUse &action, QString id);
+    void doTicket(KisToolsStopUse &action, QString id);
+
+
+
+protected:
+    virtual void getTimeTicket(QString id) = 0;
+    virtual void putTimeTicket(QString id) = 0;
 
 protected:
     QString m_adress = "http://localhost:8080/";
     // QString m_adress = "http://akapustin.me:8080/";
 private:
+    enum UseMode{
+        Activate,
+        Use
+    };
+private:
+    QString getToolId(QString id, UseMode mode = Activate);
     QString getUseMode(UseMode mode);
 };
 
 #endif
diff --git a/libs/ui/kis_telemetry_actions.cpp b/libs/ui/kis_telemetry_actions.cpp
new file mode 100644
index 0000000000..4727008e72
--- /dev/null
+++ b/libs/ui/kis_telemetry_actions.cpp
@@ -0,0 +1,23 @@
+#include "kis_telemetry_actions.h"
+#include "kis_telemetry_abstruct.h"
+
+void KisToolsActivate::doAction(KisTelemetryAbstruct *provider,QString id)
+{
+   provider->doTicket(*this, id);
+}
+
+void KisToolsStartUse::doAction(KisTelemetryAbstruct *provider, QString id)
+{
+    provider->doTicket(*this, id);
+}
+
+void KisToolsStopUse::doAction(KisTelemetryAbstruct *provider, QString id)
+{
+    provider->doTicket(*this, id);
+
+}
+
+void KisToolsDeactivate::doAction(KisTelemetryAbstruct *provider, QString id)
+{
+    provider->doTicket(*this, id);
+}
diff --git a/libs/ui/kis_telemetry_sensor.h b/libs/ui/kis_telemetry_actions.h
similarity index 52%
rename from libs/ui/kis_telemetry_sensor.h
rename to libs/ui/kis_telemetry_actions.h
index 3dbb9cc131..f09a8ea570 100644
--- a/libs/ui/kis_telemetry_sensor.h
+++ b/libs/ui/kis_telemetry_actions.h
@@ -1,36 +1,51 @@
 /* This file is part of the KDE project
    Copyright (C) 2017 Alexey Kapustin <akapust1n@mail.ru>
 
 
    This library is free software; you can redistribute it and/or
    modify it under the terms of the GNU Library General Public
    License as published by the Free Software Foundation; either
    version 2 of the License, or (at your option) any later version.
 
    This library is distributed in the hope that it will be useful,
    but WITHOUT ANY WARRANTY; without even the implied warranty of
    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
    Library General Public License for more details.
 
    You should have received a copy of the GNU Library General Public License
    along with this library; see the file COPYING.LIB.  If not, write to
    the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
  * Boston, MA 02110-1301, USA.
 */
 
-#ifndef KIS_TELEMETRY_POINTER_H
-#define KIS_TELEMETRY_POINTER_H
-#include "kis_telemetry_abstruct.h"
-#include "KisPart.h"
+#ifndef KIS_TELEMETRY_ACTIONS_H
+#define KIS_TELEMETRY_ACTIONS_H
+#include <QString>
 
-class KRITAUI_EXPORT KisTelemetrySensor
-{
+class KisTelemetryAbstruct;
+class KisTelemetryAction{
 public:
-    KisTelemetrySensor(QString id, KisTelemetryAbstruct::Action action,  KisTelemetryAbstruct::UseMode mode = KisTelemetryAbstruct::Activate);
-    ~KisTelemetrySensor();
-private:
-    KisTelemetryAbstruct::Action m_action;
-    KisTelemetryAbstruct::UseMode m_useMode;
-    QString m_id;
+    virtual void doAction(KisTelemetryAbstruct *provider, QString id) = 0;
+    virtual ~KisTelemetryAction() = default;
 };
+
+class KisToolsActivate: public KisTelemetryAction{
+public:
+      void doAction(KisTelemetryAbstruct *provider, QString id) override;
+};
+class KisToolsDeactivate: public KisTelemetryAction{
+public:
+      void doAction(KisTelemetryAbstruct *provider, QString id) override;
+};
+
+class KisToolsStartUse: public KisTelemetryAction{
+public:
+      void doAction(KisTelemetryAbstruct *provider, QString id) override;
+};
+class KisToolsStopUse: public KisTelemetryAction{
+public:
+      void doAction(KisTelemetryAbstruct *provider, QString id) override;
+};
+
+
 #endif
diff --git a/libs/ui/kis_telemetry_sensor.cpp b/libs/ui/kis_telemetry_sensor.cpp
deleted file mode 100644
index c4b5bec111..0000000000
--- a/libs/ui/kis_telemetry_sensor.cpp
+++ /dev/null
@@ -1,49 +0,0 @@
-/* This file is part of the KDE project
-   Copyright (C) 2017 Alexey Kapustin <akapust1n@mail.ru>
-
-
-   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_telemetry_sensor.h"
-#include "QDebug"
-
-KisTelemetrySensor::KisTelemetrySensor(QString id, KisTelemetryAbstruct::Action action, KisTelemetryAbstruct::UseMode mode)
-    : m_id(id)
-    , m_action(action)
-    , m_useMode(mode)
-{
-}
-
-KisTelemetrySensor::~KisTelemetrySensor()
-{
-    if (!KisPart::instance()->provider(KisPart::RegularProvider)) {
-       return;
-    }
-    if(m_action==KisTelemetryAbstruct::getTimeTicket_)
-        qDebug()<<"GET TIME TICKET";
-    KisTelemetryAbstruct* provider = KisPart::instance()->provider(KisPart::RegularProvider);
-    switch (m_action) {
-    case KisTelemetryAbstruct::getTimeTicket_:
-        provider->getTimeTicket(m_id, m_useMode);
-        break;
-    case KisTelemetryAbstruct::putTimeTicket_:
-        provider->putTimeTicket(m_id, m_useMode);
-        break;
-    default:
-        break;
-    }
-}
diff --git a/libs/ui/tool/kis_tool.cc b/libs/ui/tool/kis_tool.cc
index b73d580796..4b09a9f9fd 100644
--- a/libs/ui/tool/kis_tool.cc
+++ b/libs/ui/tool/kis_tool.cc
@@ -1,702 +1,698 @@
 /*
  *  Copyright (c) 2006, 2010 Boudewijn Rempt <boud@valdyas.org>
  *
  *  This program is free software; you can redistribute it and/or modify
  *  it under the terms of the GNU General Public License as published by
  *  the Free Software Foundation; either version 2 of the License, or
  *  (at your option) any later version.
  *
  *  This program is distributed in the hope that it will be useful,
  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  *  GNU General Public License for more details.
  *
  *  You should have received a copy of the GNU General Public License
  *  along with this program; if not, write to the Free Software
  *  Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
  */
 #include "kis_tool.h"
 #include <QCursor>
 #include <QLabel>
 #include <QWidget>
 #include <QPolygonF>
 #include <QTransform>
 
 #include <klocalizedstring.h>
 #include <QAction>
 #include <kactioncollection.h>
 
 #include <kis_icon.h>
 #include <KoConfig.h>
 #include <KoColorSpaceRegistry.h>
 #include <KoColor.h>
 #include <KoCanvasBase.h>
 #include <KoCanvasController.h>
 #include <KoToolBase.h>
 #include <KoID.h>
 #include <KoPointerEvent.h>
 #include <KoViewConverter.h>
 #include <KoSelection.h>
 #include <resources/KoAbstractGradient.h>
 #include <KoSnapGuide.h>
 
 #include <KisViewManager.h>
 #include "kis_node_manager.h"
 #include <kis_selection.h>
 #include <kis_image.h>
 #include <kis_group_layer.h>
 #include <kis_adjustment_layer.h>
 #include <kis_mask.h>
 #include <kis_paint_layer.h>
 #include <kis_painter.h>
 #include <brushengine/kis_paintop_preset.h>
 #include <brushengine/kis_paintop_settings.h>
 #include <resources/KoPattern.h>
 #include <kis_floating_message.h>
 
 #include "opengl/kis_opengl_canvas2.h"
 #include "kis_canvas_resource_provider.h"
 #include "canvas/kis_canvas2.h"
 #include "kis_coordinates_converter.h"
 #include "filter/kis_filter_configuration.h"
 #include "kis_config.h"
 #include "kis_config_notifier.h"
 #include "kis_cursor.h"
 #include <recorder/kis_recorded_paint_action.h>
 #include <kis_selection_mask.h>
 #include "kis_resources_snapshot.h"
 #include <KisView.h>
 #include "kis_action_registry.h"
 #include "kis_tool_utils.h"
 #include "KisPart.h"
 #include <QSharedPointer>
+#include "kis_telemetry_actions.h"
 
 
 
 struct Q_DECL_HIDDEN KisTool::Private {
     QCursor cursor; // the cursor that should be shown on tool activation.
 
     // From the canvas resources
     KoPattern* currentPattern{0};
     KoAbstractGradient* currentGradient{0};
     KoColor currentFgColor;
     KoColor currentBgColor;
     float currentExposure{1.0};
     KisFilterConfigurationSP currentGenerator;
     QWidget* optionWidget{0};
     ToolMode m_mode{HOVER_MODE};
     bool m_isActive{false};
 };
 
 KisTool::KisTool(KoCanvasBase * canvas, const QCursor & cursor)
     : KoToolBase(canvas)
     , d(new Private)
 {
     d->cursor = cursor;
 
     connect(KisConfigNotifier::instance(), SIGNAL(configChanged()), SLOT(resetCursorStyle()));
     connect(this, SIGNAL(isActiveChanged()), SLOT(resetCursorStyle()));
 
     KActionCollection *collection = this->canvas()->canvasController()->actionCollection();
 
     if (!collection->action("toggle_fg_bg")) {
         QAction *toggleFgBg = KisActionRegistry::instance()->makeQAction("toggle_fg_bg", collection);
         collection->addAction("toggle_fg_bg", toggleFgBg);
     }
 
     if (!collection->action("reset_fg_bg")) {
         QAction *toggleFgBg = KisActionRegistry::instance()->makeQAction("reset_fg_bg", collection);
         collection->addAction("reset_fg_bg", toggleFgBg);
     }
 
     addAction("toggle_fg_bg", dynamic_cast<QAction *>(collection->action("toggle_fg_bg")));
     addAction("reset_fg_bg", dynamic_cast<QAction *>(collection->action("reset_fg_bg")));
 
 }
 
 KisTool::~KisTool()
 {
     delete d;
 }
 
 void KisTool::activate(ToolActivation activation, const QSet<KoShape*> &shapes)
 {
     KoToolBase::activate(activation, shapes);
-
-    if(KisPart::instance()->provider(KisPart::RegularProvider)){
-        KisTelemetryAbstruct * provider = KisPart::instance()->provider(KisPart::RegularProvider);
-        provider->putTimeTicket(toolId());
-    }
+    KisToolsActivate kisToolsActivate;
+    kisToolsActivate.doAction(KisPart::instance()->provider(),toolId());
 
     resetCursorStyle();
 
     if (!canvas()) return;
     if (!canvas()->resourceManager()) return;
 
 
     d->currentFgColor = canvas()->resourceManager()->resource(KoCanvasResourceManager::ForegroundColor).value<KoColor>();
     d->currentBgColor = canvas()->resourceManager()->resource(KoCanvasResourceManager::BackgroundColor).value<KoColor>();
 
     if (canvas()->resourceManager()->hasResource(KisCanvasResourceProvider::CurrentPattern)) {
         d->currentPattern = canvas()->resourceManager()->resource(KisCanvasResourceProvider::CurrentPattern).value<KoPattern*>();
     }
 
     if (canvas()->resourceManager()->hasResource(KisCanvasResourceProvider::CurrentGradient)) {
         d->currentGradient = canvas()->resourceManager()->resource(KisCanvasResourceProvider::CurrentGradient).value<KoAbstractGradient*>();
     }
 
     KisPaintOpPresetSP preset = canvas()->resourceManager()->resource(KisCanvasResourceProvider::CurrentPaintOpPreset).value<KisPaintOpPresetSP>();
     if (preset && preset->settings()) {
         preset->settings()->activate();
     }
 
     if (canvas()->resourceManager()->hasResource(KisCanvasResourceProvider::HdrExposure)) {
         d->currentExposure = static_cast<float>(canvas()->resourceManager()->resource(KisCanvasResourceProvider::HdrExposure).toDouble());
     }
 
     if (canvas()->resourceManager()->hasResource(KisCanvasResourceProvider::CurrentGeneratorConfiguration)) {
         d->currentGenerator = canvas()->resourceManager()->resource(KisCanvasResourceProvider::CurrentGeneratorConfiguration).value<KisFilterConfiguration*>();
     }
 
     connect(actions().value("toggle_fg_bg"), SIGNAL(triggered()), SLOT(slotToggleFgBg()), Qt::UniqueConnection);
     connect(actions().value("reset_fg_bg"), SIGNAL(triggered()), SLOT(slotResetFgBg()), Qt::UniqueConnection);
 
 
     d->m_isActive = true;
     emit isActiveChanged();
 }
 
 void KisTool::deactivate()
 {
     bool result = true;
-
-    if(KisPart::instance()->provider(KisPart::RegularProvider)){
-        KisTelemetryAbstruct * provider = KisPart::instance()->provider(KisPart::RegularProvider);
-        provider->getTimeTicket(toolId());
-    }
+    KisToolsDeactivate kisToolsDeactivate;
+    kisToolsDeactivate.doAction(KisPart::instance()->provider(),toolId());
 
     result &= disconnect(actions().value("toggle_fg_bg"), 0, this, 0);
     result &= disconnect(actions().value("reset_fg_bg"), 0, this, 0);
 
     if (!result) {
         warnKrita << "WARNING: KisTool::deactivate() failed to disconnect"
                    << "some signal connections. Your actions might be executed twice!";
     }
 
     d->m_isActive = false;
     emit isActiveChanged();
 
     KoToolBase::deactivate();
+
 }
 
 void KisTool::canvasResourceChanged(int key, const QVariant & v)
 {
     switch (key) {
     case(KoCanvasResourceManager::ForegroundColor):
         d->currentFgColor = v.value<KoColor>();
         break;
     case(KoCanvasResourceManager::BackgroundColor):
         d->currentBgColor = v.value<KoColor>();
         break;
     case(KisCanvasResourceProvider::CurrentPattern):
         d->currentPattern = static_cast<KoPattern *>(v.value<void *>());
         break;
     case(KisCanvasResourceProvider::CurrentGradient):
         d->currentGradient = static_cast<KoAbstractGradient *>(v.value<void *>());
         break;
     case(KisCanvasResourceProvider::HdrExposure):
         d->currentExposure = static_cast<float>(v.toDouble());
         break;
     case(KisCanvasResourceProvider::CurrentGeneratorConfiguration):
         d->currentGenerator = static_cast<KisFilterConfiguration*>(v.value<void *>());
         break;
     case(KisCanvasResourceProvider::CurrentPaintOpPreset):
         emit statusTextChanged(v.value<KisPaintOpPresetSP>()->name());
         break;
     case(KisCanvasResourceProvider::CurrentKritaNode):
         resetCursorStyle();
         break;
     default:
         break; // Do nothing
     };
 }
 
 void KisTool::updateSettingsViews()
 {
 }
 
 QPointF KisTool::widgetCenterInWidgetPixels()
 {
     KisCanvas2 *kritaCanvas = dynamic_cast<KisCanvas2*>(canvas());
     Q_ASSERT(kritaCanvas);
 
     const KisCoordinatesConverter *converter = kritaCanvas->coordinatesConverter();
     return converter->flakeToWidget(converter->flakeCenterPoint());
 }
 
 QPointF KisTool::convertDocumentToWidget(const QPointF& pt)
 {
     KisCanvas2 *kritaCanvas = dynamic_cast<KisCanvas2*>(canvas());
     Q_ASSERT(kritaCanvas);
 
     return kritaCanvas->coordinatesConverter()->documentToWidget(pt);
 }
 
 QPointF KisTool::convertToPixelCoord(KoPointerEvent *e)
 {
     if (!image())
         return e->point;
 
     return image()->documentToPixel(e->point);
 }
 
 QPointF KisTool::convertToPixelCoord(const QPointF& pt)
 {
     if (!image())
         return pt;
 
     return image()->documentToPixel(pt);
 }
 
 QPointF KisTool::convertToPixelCoordAndSnap(KoPointerEvent *e, const QPointF &offset, bool useModifiers)
 {
     if (!image())
         return e->point;
 
     KoSnapGuide *snapGuide = canvas()->snapGuide();
     QPointF pos = snapGuide->snap(e->point, offset, useModifiers ? e->modifiers() : Qt::NoModifier);
 
     return image()->documentToPixel(pos);
 }
 
 QPointF KisTool::convertToPixelCoordAndSnap(const QPointF& pt, const QPointF &offset)
 {
     if (!image())
         return pt;
 
     KoSnapGuide *snapGuide = canvas()->snapGuide();
     QPointF pos = snapGuide->snap(pt, offset, Qt::NoModifier);
 
     return image()->documentToPixel(pos);
 }
 
 QPoint KisTool::convertToIntPixelCoord(KoPointerEvent *e)
 {
     if (!image())
         return e->point.toPoint();
 
     return image()->documentToIntPixel(e->point);
 }
 
 QPointF KisTool::viewToPixel(const QPointF &viewCoord) const
 {
     if (!image())
         return viewCoord;
 
     return image()->documentToPixel(canvas()->viewConverter()->viewToDocument(viewCoord));
 }
 
 QRectF KisTool::convertToPt(const QRectF &rect)
 {
     if (!image())
         return rect;
     QRectF r;
     //We add 1 in the following to the extreme coords because a pixel always has size
     r.setCoords(int(rect.left()) / image()->xRes(), int(rect.top()) / image()->yRes(),
                 int(1 + rect.right()) / image()->xRes(), int(1 + rect.bottom()) / image()->yRes());
     return r;
 }
 
 QPointF KisTool::pixelToView(const QPoint &pixelCoord) const
 {
     if (!image())
         return pixelCoord;
     QPointF documentCoord = image()->pixelToDocument(pixelCoord);
     return canvas()->viewConverter()->documentToView(documentCoord);
 }
 
 QPointF KisTool::pixelToView(const QPointF &pixelCoord) const
 {
     if (!image())
         return pixelCoord;
     QPointF documentCoord = image()->pixelToDocument(pixelCoord);
     return canvas()->viewConverter()->documentToView(documentCoord);
 }
 
 QRectF KisTool::pixelToView(const QRectF &pixelRect) const
 {
     if (!image())
         return pixelRect;
     QPointF topLeft = pixelToView(pixelRect.topLeft());
     QPointF bottomRight = pixelToView(pixelRect.bottomRight());
     return QRectF(topLeft, bottomRight);
 }
 
 QPainterPath KisTool::pixelToView(const QPainterPath &pixelPolygon) const
 {
     QTransform matrix;
     qreal zoomX, zoomY;
     canvas()->viewConverter()->zoom(&zoomX, &zoomY);
     matrix.scale(zoomX/image()->xRes(), zoomY/ image()->yRes());
     return matrix.map(pixelPolygon);
 }
 
 QPolygonF KisTool::pixelToView(const QPolygonF &pixelPath) const
 {
     QTransform matrix;
     qreal zoomX, zoomY;
     canvas()->viewConverter()->zoom(&zoomX, &zoomY);
     matrix.scale(zoomX/image()->xRes(), zoomY/ image()->yRes());
     return matrix.map(pixelPath);
 }
 
 void KisTool::updateCanvasPixelRect(const QRectF &pixelRect)
 {
     canvas()->updateCanvas(convertToPt(pixelRect));
 }
 
 void KisTool::updateCanvasViewRect(const QRectF &viewRect)
 {
     canvas()->updateCanvas(canvas()->viewConverter()->viewToDocument(viewRect));
 }
 
 KisImageWSP KisTool::image() const
 {
     // For now, krita tools only work in krita, not for a krita shape. Krita shapes are for 2.1
     KisCanvas2 * kisCanvas = dynamic_cast<KisCanvas2*>(canvas());
     if (kisCanvas) {
         return kisCanvas->currentImage();
     }
 
     return 0;
 
 }
 
 QCursor KisTool::cursor() const
 {
     return d->cursor;
 }
 
 void KisTool::notifyModified() const
 {
     if (image()) {
         image()->setModified();
     }
 }
 
 KoPattern * KisTool::currentPattern()
 {
     return d->currentPattern;
 }
 
 KoAbstractGradient * KisTool::currentGradient()
 {
     return d->currentGradient;
 }
 
 KisPaintOpPresetSP KisTool::currentPaintOpPreset()
 {
     return canvas()->resourceManager()->resource(KisCanvasResourceProvider::CurrentPaintOpPreset).value<KisPaintOpPresetSP>();
 }
 
 KisNodeSP KisTool::currentNode() const
 {
     KisNodeSP node = canvas()->resourceManager()->resource(KisCanvasResourceProvider::CurrentKritaNode).value<KisNodeWSP>();
     return node;
 }
 
 KisNodeList KisTool::selectedNodes() const
 {
     KisCanvas2 * kiscanvas = static_cast<KisCanvas2*>(canvas());
     KisViewManager* viewManager = kiscanvas->viewManager();
     return viewManager->nodeManager()->selectedNodes();
 }
 
 KoColor KisTool::currentFgColor()
 {
     return d->currentFgColor;
 }
 
 KoColor KisTool::currentBgColor()
 {
     return d->currentBgColor;
 }
 
 KisImageWSP KisTool::currentImage()
 {
     return image();
 }
 
 KisFilterConfigurationSP  KisTool::currentGenerator()
 {
     return d->currentGenerator;
 }
 
 void KisTool::setMode(ToolMode mode) {
     d->m_mode = mode;
 }
 
 KisTool::ToolMode KisTool::mode() const {
     return d->m_mode;
 }
 
 void KisTool::setCursor(const QCursor &cursor)
 {
     d->cursor = cursor;
 }
 
 KisTool::AlternateAction KisTool::actionToAlternateAction(ToolAction action) {
     KIS_ASSERT_RECOVER_RETURN_VALUE(action != Primary, Secondary);
     return (AlternateAction)action;
 }
 
 void KisTool::activatePrimaryAction()
 {
     resetCursorStyle();
 }
 
 void KisTool::deactivatePrimaryAction()
 {
     resetCursorStyle();
 }
 
 void KisTool::beginPrimaryAction(KoPointerEvent *event)
 {
     Q_UNUSED(event);
 }
 
 void KisTool::beginPrimaryDoubleClickAction(KoPointerEvent *event)
 {
     beginPrimaryAction(event);
 }
 
 void KisTool::continuePrimaryAction(KoPointerEvent *event)
 {
     Q_UNUSED(event);
 }
 
 void KisTool::endPrimaryAction(KoPointerEvent *event)
 {
     Q_UNUSED(event);
 }
 
 bool KisTool::primaryActionSupportsHiResEvents() const
 {
     return false;
 }
 
 void KisTool::activateAlternateAction(AlternateAction action)
 {
     Q_UNUSED(action);
 }
 
 void KisTool::deactivateAlternateAction(AlternateAction action)
 {
     Q_UNUSED(action);
 }
 
 void KisTool::beginAlternateAction(KoPointerEvent *event, AlternateAction action)
 {
     Q_UNUSED(event);
     Q_UNUSED(action);
 }
 
 void KisTool::beginAlternateDoubleClickAction(KoPointerEvent *event, AlternateAction action)
 {
     beginAlternateAction(event, action);
 }
 
 void KisTool::continueAlternateAction(KoPointerEvent *event, AlternateAction action)
 {
     Q_UNUSED(event);
     Q_UNUSED(action);
 }
 
 void KisTool::endAlternateAction(KoPointerEvent *event, AlternateAction action)
 {
     Q_UNUSED(event);
     Q_UNUSED(action);
 }
 
 void KisTool::mouseDoubleClickEvent(KoPointerEvent *event)
 {
     Q_UNUSED(event);
 }
 
 void KisTool::mouseTripleClickEvent(KoPointerEvent *event)
 {
     mouseDoubleClickEvent(event);
 }
 
 void KisTool::mousePressEvent(KoPointerEvent *event)
 {
     Q_UNUSED(event);
 }
 
 void KisTool::mouseReleaseEvent(KoPointerEvent *event)
 {
     Q_UNUSED(event);
 }
 
 void KisTool::mouseMoveEvent(KoPointerEvent *event)
 {
     Q_UNUSED(event);
 }
 
 void KisTool::deleteSelection()
 {
     KisResourcesSnapshotSP resources =
         new KisResourcesSnapshot(image(), currentNode(), this->canvas()->resourceManager());
 
     if (!blockUntilOperationsFinished()) {
         return;
     }
 
     if (!KisToolUtils::clearImage(image(), resources->currentNode(), resources->activeSelection())) {
         KoToolBase::deleteSelection();
     }
 }
 
 void KisTool::setupPaintAction(KisRecordedPaintAction* action)
 {
     action->setPaintColor(currentFgColor());
     action->setBackgroundColor(currentBgColor());
 }
 
 QWidget* KisTool::createOptionWidget()
 {
     d->optionWidget = new QLabel(i18n("No options"));
     d->optionWidget->setObjectName("SpecialSpacer");
     return d->optionWidget;
 }
 
 #define NEAR_VAL -1000.0
 #define FAR_VAL 1000.0
 #define PROGRAM_VERTEX_ATTRIBUTE 0
 
 void KisTool::paintToolOutline(QPainter* painter, const QPainterPath &path)
 {
     KisOpenGLCanvas2 *canvasWidget = dynamic_cast<KisOpenGLCanvas2 *>(canvas()->canvasWidget());
     if (canvasWidget)  {
         painter->beginNativePainting();
         canvasWidget->paintToolOutline(path);
         painter->endNativePainting();
     }
     else {
         painter->setCompositionMode(QPainter::RasterOp_SourceXorDestination);
         painter->setPen(QColor(128, 255, 128));
         painter->drawPath(path);
     }
 }
 
 void KisTool::resetCursorStyle()
 {
     useCursor(d->cursor);
 }
 
 bool KisTool::overrideCursorIfNotEditable()
 {
     // override cursor for canvas iff this tool is active
     // and we can't paint on the active layer
     if (isActive()) {
         KisNodeSP node = currentNode();
         if (node && !node->isEditable()) {
             canvas()->setCursor(Qt::ForbiddenCursor);
             return true;
         }
     }
     return false;
 }
 
 bool KisTool::blockUntilOperationsFinished()
 {
     KisCanvas2 * kiscanvas = static_cast<KisCanvas2*>(canvas());
     KisViewManager* viewManager = kiscanvas->viewManager();
     return viewManager->blockUntilOperationsFinished(image());
 }
 
 void KisTool::blockUntilOperationsFinishedForced()
 {
     KisCanvas2 * kiscanvas = static_cast<KisCanvas2*>(canvas());
     KisViewManager* viewManager = kiscanvas->viewManager();
     viewManager->blockUntilOperationsFinishedForced(image());
 }
 
 bool KisTool::isActive() const
 {
     return d->m_isActive;
 }
 
 void KisTool::slotToggleFgBg()
 {
     KoCanvasResourceManager* resourceManager = canvas()->resourceManager();
     KoColor newFg = resourceManager->backgroundColor();
     KoColor newBg = resourceManager->foregroundColor();
 
     /**
      * NOTE: Some of color selectors do not differentiate foreground
      *       and background colors, so if one wants them to end up
      *       being set up to foreground color, it should be set the
      *       last.
      */
     resourceManager->setBackgroundColor(newBg);
     resourceManager->setForegroundColor(newFg);
 }
 
 void KisTool::slotResetFgBg()
 {
     KoCanvasResourceManager* resourceManager = canvas()->resourceManager();
 
     // see a comment in slotToggleFgBg()
     resourceManager->setBackgroundColor(KoColor(Qt::white, KoColorSpaceRegistry::instance()->rgb8()));
     resourceManager->setForegroundColor(KoColor(Qt::black, KoColorSpaceRegistry::instance()->rgb8()));
 }
 
 bool KisTool::nodeEditable()
 {
     KisNodeSP node = currentNode();
     if (!node) {
         return false;
     }
 
     bool nodeEditable = node->isEditable();
 
     if (!nodeEditable) {
         KisCanvas2 * kiscanvas = static_cast<KisCanvas2*>(canvas());
         QString message;
         if (!node->visible() && node->userLocked()) {
             message = i18n("Layer is locked and invisible.");
         } else if (node->userLocked()) {
             message = i18n("Layer is locked.");
         } else if(!node->visible()) {
             message = i18n("Layer is invisible.");
         } else {
             message = i18n("Group not editable.");
         }
         kiscanvas->viewManager()->showFloatingMessage(message, KisIconUtils::loadIcon("object-locked"));
     }
     return nodeEditable;
 }
 
 bool KisTool::selectionEditable()
 {
     KisCanvas2 * kisCanvas = static_cast<KisCanvas2*>(canvas());
     KisViewManager * view = kisCanvas->viewManager();
 
     bool editable = view->selectionEditable();
     if (!editable) {
         KisCanvas2 * kiscanvas = static_cast<KisCanvas2*>(canvas());
         kiscanvas->viewManager()->showFloatingMessage(i18n("Local selection is locked."), KisIconUtils::loadIcon("object-locked"));
     }
     return editable;
 }
 
 void KisTool::listenToModifiers(bool listen)
 {
     Q_UNUSED(listen);
 }
 
 bool KisTool::listeningToModifiers()
 {
     return false;
 }
diff --git a/libs/ui/tool/kis_tool.h b/libs/ui/tool/kis_tool.h
index 9d422e5fe1..fc2b09c47e 100644
--- a/libs/ui/tool/kis_tool.h
+++ b/libs/ui/tool/kis_tool.h
@@ -1,348 +1,347 @@
 /*
  *  Copyright (c) 2006 Boudewijn Rempt <boud@valdyas.org>
  *
  *  This program is free software; you can redistribute it and/or modify
  *  it under the terms of the GNU General Public License as published by
  *  the Free Software Foundation; either version 2 of the License, or
  *  (at your option) any later version.
  *
  *  This program is distributed in the hope that it will be useful,
  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  *  GNU General Public License for more details.
  *
  *  You should have received a copy of the GNU General Public License
  *  along with this program; if not, write to the Free Software
  *  Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
  */
 
 #ifndef KIS_TOOL_H_
 #define KIS_TOOL_H_
 
 #include <QCursor>
 
 #include <KoColor.h>
 #include <KoToolBase.h>
 #include <KoID.h>
 #include <KoCanvasResourceManager.h>
 #include <kritaui_export.h>
 #include <kis_types.h>
 #include <KisPart.h>
-#include "kis_telemetry_sensor.h"
 
 
 #define PRESS_CONDITION(_event, _mode, _button, _modifier)              \
     (this->mode() == (_mode) && (_event)->button() == (_button) &&            \
      (_event)->modifiers() == (_modifier))
 
 #define PRESS_CONDITION_WB(_event, _mode, _button, _modifier)            \
     (this->mode() == (_mode) && (_event)->button() & (_button) &&            \
      (_event)->modifiers() == (_modifier))
 
 #define PRESS_CONDITION_OM(_event, _mode, _button, _modifier)           \
     (this->mode() == (_mode) && (_event)->button() == (_button) &&      \
      ((_event)->modifiers() & (_modifier) ||                            \
       (_event)->modifiers() == Qt::NoModifier))
 
 #define RELEASE_CONDITION(_event, _mode, _button)               \
     (this->mode() == (_mode) && (_event)->button() == (_button))
 
 #define RELEASE_CONDITION_WB(_event, _mode, _button)               \
     (this->mode() == (_mode) && (_event)->button() & (_button))
 
 #define MOVE_CONDITION(_event, _mode) (this->mode() == (_mode))
 
 #ifdef __GNUC__
 #define WARN_WRONG_MODE(_mode) warnKrita << "Unexpected tool event has come to" << __func__ << "while being mode" << _mode << "!"
 #else
 #define WARN_WRONG_MODE(_mode) warnKrita << "Unexpected tool event has come while being mode" << _mode << "!"
 #endif
 
 #define CHECK_MODE_SANITY_OR_RETURN(_mode) if (mode() != _mode) { WARN_WRONG_MODE(mode()); return; }
 
 class KoCanvasBase;
 class KoPattern;
 class KoAbstractGradient;
 class KisFilterConfiguration;
 class QPainter;
 class QPainterPath;
 class QPolygonF;
 class KisRecordedPaintAction;
 
 /// Definitions of the toolgroups of Krita
 static const QString TOOL_TYPE_SHAPE = "0 Krita/Shape";         // Geometric shapes like ellipses and lines
 static const QString TOOL_TYPE_TRANSFORM = "2 Krita/Transform"; // Tools that transform the layer;
 static const QString TOOL_TYPE_FILL = "3 Krita/Fill";                // Tools that fill parts of the canvas
 static const QString TOOL_TYPE_VIEW = "4 Krita/View";                // Tools that affect the canvas: pan, zoom, etc.
 static const QString TOOL_TYPE_SELECTION = "5 Krita/Select";          // Tools that select pixels
 
 //activation id for Krita tools, Krita tools are always active and handle locked and invisible layers by themself
 static const QString KRITA_TOOL_ACTIVATION_ID = "flake/always";
 
 class  KRITAUI_EXPORT KisTool
         : public KoToolBase
 {
     Q_OBJECT
 
     Q_PROPERTY(bool isActive READ isActive NOTIFY isActiveChanged)
 
 public:
     enum { FLAG_USES_CUSTOM_PRESET=0x01, FLAG_USES_CUSTOM_COMPOSITEOP=0x02, FLAG_USES_CUSTOM_SIZE=0x04 };
 
     KisTool(KoCanvasBase * canvas, const QCursor & cursor);
     ~KisTool() override;
 
     virtual int flags() const { return 0; }
 
     void deleteSelection() override;
 // KoToolBase Implementation.
 
 public:
 
     /**
      * Called by KisToolProxy when the primary action of the tool is
      * going to be started now, that is when all the modifiers are
      * pressed and the only thing left is just to press the mouse
      * button.  On coming of this callback the tool is supposed to
      * prepare the cursor and/or the outline to show the user shat is
      * going to happen next
      */
     virtual void activatePrimaryAction();
 
     /**
      * Called by KisToolProxy when the primary is no longer possible
      * to be started now, e.g. when its modifiers and released. The
      * tool is supposed revert all the preparetions it has doen in
      * activatePrimaryAction().
      */
     virtual void deactivatePrimaryAction();
 
     /**
      * Called by KisToolProxy when a primary action for the tool is
      * started. The \p event stores the original event that
      * started the stroke. The \p event is _accepted_ by default. If
      * the tool decides to ignore this particular action (e.g. when
      * the node is not editable), it should call event->ignore(). Then
      * no further continuePrimaryAction() or endPrimaryAction() will
      * be called until the next user action.
      */
     virtual void beginPrimaryAction(KoPointerEvent *event);
 
     /**
      * Called by KisToolProxy when the primary action is in progress
      * of pointer movement.  If the tool has ignored the event in
      * beginPrimaryAction(), this method will not be called.
      */
     virtual void continuePrimaryAction(KoPointerEvent *event);
 
     /**
      * Called by KisToolProxy when the primary action is being
      * finished, that is while mouseRelease or tabletRelease event.
      * If the tool has ignored the event in beginPrimaryAction(), this
      * method will not be called.
      */
     virtual void endPrimaryAction(KoPointerEvent *event);
 
     /**
      * The same as beginPrimaryAction(), but called when the stroke is
      * started by a double-click
      *
      * \see beginPrimaryAction()
      */
     virtual void beginPrimaryDoubleClickAction(KoPointerEvent *event);
 
     /**
      * Returns true if the tool can handle (and wants to handle) a
      * very tight flow of input events from the tablet
      */
     virtual bool primaryActionSupportsHiResEvents() const;
 
     enum ToolAction {
         Primary,
         AlternateChangeSize,
         AlternatePickFgNode,
         AlternatePickBgNode,
         AlternatePickFgImage,
         AlternatePickBgImage,
         AlternateSecondary,
         AlternateThird,
         AlternateFourth,
         AlternateFifth,
         Alternate_NONE = 10000
     };
 
     // Technically users are allowed to configure this, but nobody ever would do that.
     // So these can basically be thought of as aliases to ctrl+click, etc.
     enum AlternateAction {
         ChangeSize = AlternateChangeSize, // Default: Shift+Left click
         PickFgNode = AlternatePickFgNode, // Default: Ctrl+Alt+Left click
         PickBgNode = AlternatePickBgNode, // Default: Ctrl+Alt+Right click
         PickFgImage = AlternatePickFgImage, // Default: Ctrl+Left click
         PickBgImage = AlternatePickBgImage, // Default: Ctrl+Right click
         Secondary = AlternateSecondary,
         Third = AlternateThird,
         Fourth = AlternateFourth,
         Fifth = AlternateFifth,
         NONE = 10000
     };
 
     static AlternateAction actionToAlternateAction(ToolAction action);
 
     virtual void activateAlternateAction(AlternateAction action);
     virtual void deactivateAlternateAction(AlternateAction action);
 
     virtual void beginAlternateAction(KoPointerEvent *event, AlternateAction action);
     virtual void continueAlternateAction(KoPointerEvent *event, AlternateAction action);
     virtual void endAlternateAction(KoPointerEvent *event, AlternateAction action);
     virtual void beginAlternateDoubleClickAction(KoPointerEvent *event, AlternateAction action);
 
 
     void mousePressEvent(KoPointerEvent *event) override;
     void mouseDoubleClickEvent(KoPointerEvent *event) override;
     void mouseTripleClickEvent(KoPointerEvent *event) override;
     void mouseReleaseEvent(KoPointerEvent *event) override;
     void mouseMoveEvent(KoPointerEvent *event) override;
 
     bool isActive() const;
 
 public Q_SLOTS:
     void activate(ToolActivation activation, const QSet<KoShape*> &shapes) override;
     void deactivate() override;
     void canvasResourceChanged(int key, const QVariant & res) override;
     // Implement this slot in case there are any widgets or properties which need
     // to be updated after certain operations, to reflect the inner state correctly.
     // At the moment this is used for smoothing options in the freehand brush, but
     // this will likely be expanded.
     virtual void updateSettingsViews();
 
 Q_SIGNALS:
     void isActiveChanged();
 
 protected:
     // conversion methods are also needed by the paint information builder
     friend class KisToolPaintingInformationBuilder;
 
     /// Convert from native (postscript points) to image pixel
     /// coordinates.
     QPointF convertToPixelCoord(KoPointerEvent *e);
     QPointF convertToPixelCoord(const QPointF& pt);
 
     QPointF convertToPixelCoordAndSnap(KoPointerEvent *e, const QPointF &offset = QPointF(), bool useModifiers = true);
     QPointF convertToPixelCoordAndSnap(const QPointF& pt, const QPointF &offset = QPointF());
 
 protected:
     QPointF widgetCenterInWidgetPixels();
     QPointF convertDocumentToWidget(const QPointF& pt);
 
     /// Convert from native (postscript points) to integer image pixel
     /// coordinates. This truncates the floating point components and
     /// should be used in preference to QPointF::toPoint(), which rounds,
     /// to ensure the cursor acts on the pixel it is visually over.
     QPoint convertToIntPixelCoord(KoPointerEvent *e);
 
     QRectF convertToPt(const QRectF &rect);
 
     QPointF viewToPixel(const QPointF &viewCoord) const;
     /// Convert an integer pixel coordinate into a view coordinate.
     /// The view coordinate is at the centre of the pixel.
     QPointF pixelToView(const QPoint &pixelCoord) const;
 
     /// Convert a floating point pixel coordinate into a view coordinate.
     QPointF pixelToView(const QPointF &pixelCoord) const;
 
     /// Convert a pixel rectangle into a view rectangle.
     QRectF pixelToView(const QRectF &pixelRect) const;
 
     /// Convert a pixel path into a view path
     QPainterPath pixelToView(const QPainterPath &pixelPath) const;
 
     /// Convert a pixel polygon into a view path
     QPolygonF pixelToView(const QPolygonF &pixelPolygon) const;
 
     /// Update the canvas for the given rectangle in image pixel coordinates.
     void updateCanvasPixelRect(const QRectF &pixelRect);
 
     /// Update the canvas for the given rectangle in view coordinates.
     void updateCanvasViewRect(const QRectF &viewRect);
 
     QWidget* createOptionWidget() override;
 
     /**
      * To determine whether this tool will change its behavior when
      * modifier keys are pressed
      */
     virtual bool listeningToModifiers();
     /**
      * Request that this tool no longer listen to modifier keys
      * (Responding to the request is optional)
      */
     virtual void listenToModifiers(bool listen);
 
 protected:
     KisImageWSP image() const;
     QCursor cursor() const;
 
     /// Call this to set the document modified
     void notifyModified() const;
 
     KisImageWSP currentImage();
     KoPattern* currentPattern();
     KoAbstractGradient *currentGradient();
     KisNodeSP currentNode() const;
     KisNodeList selectedNodes() const;
     KoColor currentFgColor();
     KoColor currentBgColor();
     KisPaintOpPresetSP currentPaintOpPreset();
     KisFilterConfigurationSP currentGenerator();
 
     virtual void setupPaintAction(KisRecordedPaintAction* action);
 
     /// paint the path which is in view coordinates, default paint mode is XOR_MODE, BW_MODE is also possible
     /// never apply transformations to the painter, they would be useless, if drawing in OpenGL mode. The coordinates in the path should be in view coordinates.
     void paintToolOutline(QPainter * painter, const QPainterPath &path);
 
     /// Checks checks if the current node is editable
     bool nodeEditable();
 
     /// Checks checks if the selection is editable, only applies to local selection as global selection is always editable
     bool selectionEditable();
 
     /// Override the cursor appropriately if current node is not editable
     bool overrideCursorIfNotEditable();
 
     bool blockUntilOperationsFinished();
     void blockUntilOperationsFinishedForced();
 
 protected:
     enum ToolMode {
         HOVER_MODE,
         PAINT_MODE,
         SECONDARY_PAINT_MODE,
         MIRROR_AXIS_SETUP_MODE,
         GESTURE_MODE,
         PAN_MODE,
         OTHER // not used now
     };
 
     virtual void setMode(ToolMode mode);
     virtual ToolMode mode() const;
     void setCursor(const QCursor &cursor);
 
 protected Q_SLOTS:
     /**
      * Called whenever the configuration settings change.
      */
     virtual void resetCursorStyle();
 
 private Q_SLOTS:
     void slotToggleFgBg();
     void slotResetFgBg();
 
 private:
     struct Private;
     Private* const d;
 };
 
 
 
 #endif // KIS_TOOL_H_
diff --git a/libs/ui/tool/kis_tool_rectangle_base.cpp b/libs/ui/tool/kis_tool_rectangle_base.cpp
index f68e6a43a2..fbd8d387aa 100644
--- a/libs/ui/tool/kis_tool_rectangle_base.cpp
+++ b/libs/ui/tool/kis_tool_rectangle_base.cpp
@@ -1,253 +1,249 @@
 /* This file is part of the KDE project
  * Copyright (C) 2009 Boudewijn Rempt <boud@valdyas.org>
  *
  * This library is free software; you can redistribute it and/or
  * modify it under the terms of the GNU Library General Public
  * License as published by the Free Software Foundation; either
  * version 2 of the License, or (at your option) any later version.
  *
  * This library is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  * Library General Public License for more details.
  *
  * You should have received a copy of the GNU Library General Public License
  * along with this library; see the file COPYING.LIB.  If not, write to
  * the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
  * Boston, MA 02110-1301, USA.
  */
 
 #include "kis_tool_rectangle_base.h"
 
 #include <QtCore/qmath.h>
 
 #include <KoPointerEvent.h>
 #include <KoCanvasBase.h>
 #include <KoCanvasController.h>
 #include <KoViewConverter.h>
 
 #include "kis_rectangle_constraint_widget.h"
 
 KisToolRectangleBase::KisToolRectangleBase(KoCanvasBase * canvas, KisToolRectangleBase::ToolType type, const QCursor & cursor)
     : KisToolShape(canvas, cursor)
     , m_dragStart(0, 0)
     , m_dragEnd(0, 0)
     , m_type(type)
     , m_isRatioForced(false)
     , m_isWidthForced(false)
     , m_isHeightForced(false)
     , m_listenToModifiers(true)
     , m_forcedRatio(1.0)
     , m_forcedWidth(0)
     , m_forcedHeight(0)
 {
 }
 
 
 QList<QPointer<QWidget> > KisToolRectangleBase::createOptionWidgets()
 {
   QList<QPointer<QWidget> > widgetsList = KisToolShape::createOptionWidgets();
 
   widgetsList.append(new KisRectangleConstraintWidget(0, this));
 
   return widgetsList;
 }
 
 void KisToolRectangleBase::constraintsChanged(bool forceRatio, bool forceWidth, bool forceHeight, float ratio, float width, float height)
 {
   m_isWidthForced = forceWidth;
   m_isHeightForced = forceHeight;
   m_isRatioForced = forceRatio;
 
   m_forcedHeight = height;
   m_forcedWidth = width;
   m_forcedRatio = ratio;
 
   // Avoid division by zero in size calculations
   if (ratio < 0.0001f) m_isRatioForced = false;
 }
 
 void KisToolRectangleBase::paint(QPainter& gc, const KoViewConverter &converter)
 {
     if(mode() == KisTool::PAINT_MODE) {
         paintRectangle(gc, createRect(m_dragStart, m_dragEnd));
     }
 
     KisToolPaint::paint(gc, converter);
 }
 
 void KisToolRectangleBase::deactivate()
 {
     updateArea();
-    KisTelemetrySensor sensor(toolId(), KisTelemetryAbstruct::getTimeTicket_, KisTelemetryAbstruct::Activate);
     KisToolShape::deactivate();
 }
 
 void KisToolRectangleBase::listenToModifiers(bool listen)
 {
     m_listenToModifiers = listen;
 }
 bool KisToolRectangleBase::listeningToModifiers()
 {
     return m_listenToModifiers;
 }
 
 void KisToolRectangleBase::beginPrimaryAction(KoPointerEvent *event)
 {
     if ((m_type == PAINT && (!nodeEditable() || nodePaintAbility() == NONE)) ||
         (m_type == SELECT && !selectionEditable())) {
 
         event->ignore();
         return;
     }
     setMode(KisTool::PAINT_MODE);
-    KisTelemetrySensor sensor(toolId(), KisTelemetryAbstruct::getTimeTicket_, KisTelemetryAbstruct::Use);
 
 
     QPointF pos = convertToPixelCoordAndSnap(event, QPointF(), false);
     m_dragStart = m_dragCenter = pos;
 
     QSizeF area = QSizeF(0,0);
 
     applyConstraints(area, false);
 
     m_dragEnd.setX(m_dragStart.x() + area.width());
     m_dragEnd.setY(m_dragStart.y() + area.height());
 
     event->accept();
 }
 
 bool KisToolRectangleBase::isFixedSize() {
   if (m_isWidthForced && m_isHeightForced) return true;
   if (m_isRatioForced && (m_isWidthForced || m_isHeightForced)) return true;
 
   return false;
 }
 
 void KisToolRectangleBase::applyConstraints(QSizeF &area, bool overrideRatio) {
   if (m_isWidthForced) {
     area.setWidth(m_forcedWidth);
   }
   if (m_isHeightForced) {
     area.setHeight(m_forcedHeight);
   }
 
   if (m_isHeightForced && m_isWidthForced) return;
 
   if (m_isRatioForced || overrideRatio) {
     float ratio = m_isRatioForced ? m_forcedRatio : 1.0f;
 
     if (m_isWidthForced) {
       area.setHeight(area.width() / ratio);
     } else {
       area.setWidth(area.height() * ratio);
     }
   }
 }
 
 void KisToolRectangleBase::continuePrimaryAction(KoPointerEvent *event)
 {
     CHECK_MODE_SANITY_OR_RETURN(KisTool::PAINT_MODE);
-    KisTelemetrySensor sensor(toolId(), KisTelemetryAbstruct::putTimeTicket_, KisTelemetryAbstruct::Use);
 
     bool constraintToggle = (event->modifiers() & Qt::ShiftModifier) && m_listenToModifiers;
     bool translateMode = (event->modifiers() & Qt::AltModifier) && m_listenToModifiers;
     bool expandFromCenter = (event->modifiers() & Qt::ControlModifier) && m_listenToModifiers;
 
     bool fixedSize = isFixedSize() && !constraintToggle;
 
     QPointF pos = convertToPixelCoordAndSnap(event, QPointF(), false);
 
     if (fixedSize) {
       m_dragStart = pos;
     } else if (translateMode) {
       QPointF trans = pos - m_dragEnd;
       m_dragStart += trans;
       m_dragEnd += trans;
     }
 
     QPointF diag = pos - m_dragStart;
     QSizeF area = QSizeF(fabs(diag.x()), fabs(diag.y()));
 
     bool overrideRatio = constraintToggle && !(m_isHeightForced || m_isWidthForced || m_isRatioForced);
     if (!constraintToggle || overrideRatio) {
       applyConstraints(area, overrideRatio);
     }
 
     diag = QPointF(
       (diag.x() < 0) ? -area.width() : area.width(),
       (diag.y() < 0) ? -area.height() : area.height()
     );
 
     // resize around center point?
     if (expandFromCenter && !fixedSize) {
       m_dragStart = m_dragCenter - diag / 2;
       m_dragEnd = m_dragCenter + diag / 2;
     } else {
       m_dragEnd = m_dragStart + diag;
     }
 
     updateArea();
 
     m_dragCenter = QPointF((m_dragStart.x() + m_dragEnd.x()) / 2,
                            (m_dragStart.y() + m_dragEnd.y()) / 2);
     KisToolPaint::requestUpdateOutline(event->point, event);
 }
 
 void KisToolRectangleBase::endPrimaryAction(KoPointerEvent *event)
 {
     CHECK_MODE_SANITY_OR_RETURN(KisTool::PAINT_MODE);
     setMode(KisTool::HOVER_MODE);
-    KisTelemetrySensor sensor(toolId(), KisTelemetryAbstruct::getTimeTicket_, KisTelemetryAbstruct::Use);
 
 
     updateArea();
 
     finishRect(createRect(m_dragStart, m_dragEnd));
     event->accept();
 }
 
 QRectF KisToolRectangleBase::createRect(const QPointF &start, const QPointF &end)
 {
     /**
      * To make the dragging user-friendly it should work in a bit
      * non-obvious way: the start-drag point must be handled with
      * "ceil"/"floor" (depending on the direction of the drag) and the
      * end-drag point should follow usual "round" semantics.
      */
 
     qreal x0 = start.x();
     qreal y0 = start.y();
     qreal x1 = end.x();
     qreal y1 = end.y();
 
     int newX0 = qRound(x0);
     int newY0 = qRound(y0);
 
     int newX1 = qRound(x1);
     int newY1 = qRound(y1);
 
     QRectF result;
     result.setCoords(newX0, newY0, newX1, newY1);
     return result.normalized();
 }
 
 void KisToolRectangleBase::paintRectangle(QPainter &gc, const QRectF &imageRect)
 {
     KIS_ASSERT_RECOVER_RETURN(canvas());
 
     QRect viewRect = pixelToView(imageRect).toAlignedRect();
 
     QPainterPath path;
     path.addRect(viewRect);
     paintToolOutline(&gc, path);
 }
 
 void KisToolRectangleBase::updateArea() {
     const QRectF bound = createRect(m_dragStart, m_dragEnd);
 
     canvas()->updateCanvas(convertToPt(bound).adjusted(-100, -100, +200, +200));
 
     emit rectangleChanged(bound);
 }
 
diff --git a/plugins/telemetry/CMakeLists.txt b/plugins/telemetry/CMakeLists.txt
index d5ac1da25c..8e141cb2a2 100644
--- a/plugins/telemetry/CMakeLists.txt
+++ b/plugins/telemetry/CMakeLists.txt
@@ -1,14 +1,21 @@
+add_subdirectory( tests )
+
+include_directories(SYSTEM
+    ${EIGEN3_INCLUDE_DIR}
+)
+
 set(kritatelemetry_SOURCES
-    kis_telemetry_install_provider.cpp
-    kis_telemetry_regular_provider.cpp
+    kis_telemetry_provider.cpp
     kis_telemetry.cpp
     kis_cpuinfosource.cpp
     kis_toolsinfosource.cpp
     kis_tickets.cpp
 )
 
 add_library(kritatelemetry MODULE ${kritatelemetry_SOURCES})
+generate_export_header(kritatelemetry EXPORT_MACRO_NAME TELEMETRY_EXPORT)
+
 target_link_libraries(kritatelemetry KUserFeedbackCore kritaui)
 install(TARGETS kritatelemetry  DESTINATION ${KRITA_PLUGIN_INSTALL_DIR})
 
 
diff --git a/plugins/telemetry/kis_telemetry.cpp b/plugins/telemetry/kis_telemetry.cpp
index 8ad566f945..4e26a80b97 100644
--- a/plugins/telemetry/kis_telemetry.cpp
+++ b/plugins/telemetry/kis_telemetry.cpp
@@ -1,48 +1,46 @@
 /* This file is part of the KDE project
    Copyright (C) 2017 Alexey Kapustin <akapust1n@mail.ru>
 
 
    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_telemetry.h"
 #include "KPluginFactory"
 #include <klocalizedstring.h>
 #include <ksharedconfig.h>
 #include <kis_global.h>
 #include <kis_types.h>
 #include <KoToolRegistry.h>
-#include "kis_telemetry_install_provider.h"
+#include "kis_telemetry_provider.h"
 #include "KisPart.h"
-#include "kis_telemetry_regular_provider.h"
 
 
 K_PLUGIN_FACTORY_WITH_JSON(KisTelemetryFactory, "kritatelemetry.json", registerPlugin<KisTelemetry>();)
 
 KisTelemetry::KisTelemetry(QObject* parent, const QVariantList&)
     : QObject(parent)
 {
-    KisPart::instance()->setProvider(new KisTelemetryInstallProvider,KisPart::InstallProvider);
-    KisPart::instance()->setProvider(new KisTelemetryRegularProvider, KisPart::RegularProvider);
+    KisPart::instance()->setProvider(new KisTelemetryProvider);
 }
 
 KisTelemetry::~KisTelemetry()
 {
 
 }
 
 #include "kis_telemetry.moc"
 
diff --git a/plugins/telemetry/kis_telemetry_install_provider.cpp b/plugins/telemetry/kis_telemetry_install_provider.cpp
deleted file mode 100644
index b1b9ee57bd..0000000000
--- a/plugins/telemetry/kis_telemetry_install_provider.cpp
+++ /dev/null
@@ -1,72 +0,0 @@
-/* This file is part of the KDE project
-   Copyright (C) 2017 Alexey Kapustin <akapust1n@mail.ru>
-
-
-   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_telemetry_install_provider.h"
-#include "KPluginFactory"
-#include "KisPart.h"
-#include <klocalizedstring.h>
-#include <ksharedconfig.h>
-
-#include <kis_debug.h>
-#include <kpluginfactory.h>
-
-#include <KoToolRegistry.h>
-#include <iostream>
-#include <kis_global.h>
-#include <kis_types.h>
-#include "Vc/cpuid.h"
-
-KisTelemetryInstallProvider::KisTelemetryInstallProvider()
-{
-    m_provider.reset(new KUserFeedback::Provider);
-    m_provider.data()->setTelemetryMode(KUserFeedback::Provider::DetailedUsageStatistics);
-
-    std::unique_ptr<KUserFeedback::AbstractDataSource> cpu(new KisUserFeedback::CpuInfoSource());
-    m_sources.push_back(std::move(cpu));
-    std::unique_ptr<KUserFeedback::AbstractDataSource> qt(new KUserFeedback::QtVersionSource());
-    m_sources.push_back(std::move(qt));
-    std::unique_ptr<KUserFeedback::AbstractDataSource> compiler(new KUserFeedback::CompilerInfoSource());
-    m_sources.push_back(std::move(compiler));
-    std::unique_ptr<KUserFeedback::AbstractDataSource> locale(new KUserFeedback::LocaleInfoSource());
-    m_sources.push_back(std::move(locale));
-    std::unique_ptr<KUserFeedback::AbstractDataSource> opengl(new KUserFeedback::OpenGLInfoSource());
-    m_sources.push_back(std::move(opengl));
-    std::unique_ptr<KUserFeedback::AbstractDataSource> platform(new KUserFeedback::PlatformInfoSource());
-    m_sources.push_back(std::move(platform));
-    std::unique_ptr<KUserFeedback::AbstractDataSource> screen(new KUserFeedback::ScreenInfoSource());
-    m_sources.push_back(std::move(screen));
-
-    for (auto &source : m_sources) {
-        m_provider.data()->addDataSource(source.get());
-    }
-}
-
-void KisTelemetryInstallProvider::sendData(QString path)
-{
-    // m_provider.data()->setFeedbackServer(QUrl("http://akapustin.me:8080/"));
-    if (!path.endsWith(QLatin1Char('/')))
-        path += QLatin1Char('/');
-    m_provider.data()->setFeedbackServer(QUrl(m_adress+path));
-    m_provider.data()->submit();
-}
-
-KisTelemetryInstallProvider::~KisTelemetryInstallProvider()
-{
-}
diff --git a/plugins/telemetry/kis_telemetry_install_provider.h b/plugins/telemetry/kis_telemetry_install_provider.h
deleted file mode 100644
index 6d14868c1b..0000000000
--- a/plugins/telemetry/kis_telemetry_install_provider.h
+++ /dev/null
@@ -1,54 +0,0 @@
-/* This file is part of the KDE project
-   Copyright (C) 2017 Alexey Kapustin <akapust1n@mail.ru>
-
-
-   This library is free software; you can redistribute it and/or
-   modify it under the terms of the GNU Library General Public
-   License as published by the Free Software Foundation; either
-   version 2 of the License, or (at your option) any later version.
-
-   This library is distributed in the hope that it will be useful,
-   but WITHOUT ANY WARRANTY; without even the implied warranty of
-   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
-   Library General Public License for more details.
-
-   You should have received a copy of the GNU Library General Public License
-   along with this library; see the file COPYING.LIB.  If not, write to
-   the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
- * Boston, MA 02110-1301, USA.
-*/
-
-#ifndef KIS_TELEMETRY_INSTALL_PROVIDER_H
-#define KIS_TELEMETRY_INSTALL_PROVIDER_H
-#include "QScopedPointer"
-#include <KUserFeedback/AbstractDataSource>
-#include <KUserFeedback/CompilerInfoSource>
-#include <KUserFeedback/LocaleInfoSource>
-#include <KUserFeedback/OpenGLInfoSource>
-#include <KUserFeedback/PlatformInfoSource>
-#include <KUserFeedback/QtVersionSource>
-#include <KUserFeedback/QtVersionSource>
-#include <KUserFeedback/ScreenInfoSource>
-#include <KUserFeedback/provider.h>
-#include <QVariant>
-
-#include "kis_cpuinfosource.h"
-
-#include <kis_telemetry_abstruct.h>
-#include <memory>
-#include <vector>
-
-class KisTelemetryInstallProvider : public KisTelemetryAbstruct {
-public:
-    KisTelemetryInstallProvider();
-    void sendData(QString path) override;
-    void getTimeTicket(QString id, UseMode mode = Activate) override {}
-    void putTimeTicket(QString id, UseMode mode = Activate) override {}
-    virtual ~KisTelemetryInstallProvider();
-
-private:
-    QScopedPointer<KUserFeedback::Provider> m_provider;
-    std::vector<std::unique_ptr<KUserFeedback::AbstractDataSource> > m_sources;
-};
-
-#endif
diff --git a/plugins/telemetry/kis_telemetry_regular_provider.cpp b/plugins/telemetry/kis_telemetry_provider.cpp
similarity index 56%
rename from plugins/telemetry/kis_telemetry_regular_provider.cpp
rename to plugins/telemetry/kis_telemetry_provider.cpp
index 9f2b44c2f7..78fdf60b21 100644
--- a/plugins/telemetry/kis_telemetry_regular_provider.cpp
+++ b/plugins/telemetry/kis_telemetry_provider.cpp
@@ -1,127 +1,151 @@
 /* This file is part of the KDE project
    Copyright (C) 2017 Alexey Kapustin <akapust1n@mail.ru>
 
 
    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_telemetry_regular_provider.h"
+#include "kis_telemetry_provider.h"
 #include "KPluginFactory"
 #include "KisPart.h"
 #include <klocalizedstring.h>
 #include <ksharedconfig.h>
 
 #include <kis_debug.h>
 #include <kpluginfactory.h>
 
+#include "Vc/cpuid.h"
 #include "kis_tickets.h"
 #include "kis_toolsinfosource.h"
 #include <KoToolRegistry.h>
 #include <iostream>
 #include <kis_global.h>
 #include <kis_types.h>
 
-KisTelemetryRegularProvider::KisTelemetryRegularProvider()
+KisTelemetryProvider::KisTelemetryProvider()
 {
+    m_installProvider.reset(new KUserFeedback::Provider);
+    m_installProvider.data()->setTelemetryMode(KUserFeedback::Provider::DetailedUsageStatistics);
+
+    std::unique_ptr<KUserFeedback::AbstractDataSource> cpu(new KisUserFeedback::CpuInfoSource());
+    m_installSources.push_back(std::move(cpu));
+    std::unique_ptr<KUserFeedback::AbstractDataSource> qt(new KUserFeedback::QtVersionSource());
+    m_installSources.push_back(std::move(qt));
+    std::unique_ptr<KUserFeedback::AbstractDataSource> compiler(new KUserFeedback::CompilerInfoSource());
+    m_installSources.push_back(std::move(compiler));
+    std::unique_ptr<KUserFeedback::AbstractDataSource> locale(new KUserFeedback::LocaleInfoSource());
+    m_installSources.push_back(std::move(locale));
+    std::unique_ptr<KUserFeedback::AbstractDataSource> opengl(new KUserFeedback::OpenGLInfoSource());
+    m_installSources.push_back(std::move(opengl));
+    std::unique_ptr<KUserFeedback::AbstractDataSource> platform(new KUserFeedback::PlatformInfoSource());
+    m_installSources.push_back(std::move(platform));
+    std::unique_ptr<KUserFeedback::AbstractDataSource> screen(new KUserFeedback::ScreenInfoSource());
+    m_installSources.push_back(std::move(screen));
+
+    for (auto& source : m_installSources) {
+        m_installProvider.data()->addDataSource(source.get());
+    }
+
     m_toolsProvider.reset(new KUserFeedback::Provider);
     m_toolsProvider.data()->setTelemetryMode(KUserFeedback::Provider::DetailedUsageStatistics);
-
     std::unique_ptr<KUserFeedback::AbstractDataSource> tools(new KisUserFeedback::ToolsInfoSource);
     m_toolSources.push_back(std::move(tools));
 
     for (auto& source : m_toolSources) {
         m_toolsProvider.data()->addDataSource(source.get());
     }
 }
 
-void KisTelemetryRegularProvider::sendData(QString path)
+void KisTelemetryProvider::sendData(QString path)
 {
     if (!path.endsWith(QLatin1Char('/')))
         path += QLatin1Char('/');
     TelemetryCategory enumPath = pathToKind(path);
     switch (enumPath) {
     case tools: {
         m_toolsProvider.data()->setFeedbackServer(QUrl(m_adress + path));
         m_toolsProvider.data()->submit();
         break;
     }
+    case install: {
+        m_installProvider.data()->setFeedbackServer(QUrl(m_adress + path));
+        m_installProvider.data()->submit();
+        break;
+    }
     default:
         break;
     }
 }
 
-void KisTelemetryRegularProvider::getTimeTicket(QString id, UseMode mode)
+void KisTelemetryProvider::getTimeTicket(QString id)
 {
-    qDebug() << "get TIme ticket call";
+    //    qDebug() << "get TIme ticket call";
 
-    id = getToolId(id, mode);
-    qDebug() << ppVar(m_tickets.count(id));
+    //    qDebug() << ppVar(m_tickets.count(id));
 
     KisTicket* ticket = m_tickets.value(id).lock().data();
-    KisTimeTicket* timeTicket;
+    if (!ticket) {
+        return;
+    }
+    KisTimeTicket* timeTicket = nullptr;
     KUserFeedback::AbstractDataSource* m_tools = m_toolSources[0].get();
     KisUserFeedback::ToolsInfoSource* tools = nullptr;
 
     timeTicket = dynamic_cast<KisTimeTicket*>(ticket);
-    if (!ticket) {
-        Q_ASSERT_X(1 == 0, "timeTicket is lost", id.);
-        return;
-    }
-    qDebug() << "timeTicket is not lost";
     tools = dynamic_cast<KisUserFeedback::ToolsInfoSource*>(m_tools);
-    if (!timeTicket || !tools) {
-        Q_ASSERT_X(1 == 0, "get tool's timeTicket ", id.toStdString().c_str());
-        return;
-    }
+
+    KIS_SAFE_ASSERT_RECOVER_RETURN(timeTicket);
+    KIS_SAFE_ASSERT_RECOVER_RETURN(tools);
+    KIS_SAFE_ASSERT_RECOVER_RETURN(ticket);
+
     qDebug() << "Before deactivate";
     tools->deactivateTool(id);
     m_tickets.remove(id);
 }
 
-void KisTelemetryRegularProvider::putTimeTicket(QString id, UseMode mode)
+void KisTelemetryProvider::putTimeTicket(QString id)
 {
-    id = getToolId(id, mode);
     if (m_tickets.count(id)) {
         return;
     }
     KUserFeedback::AbstractDataSource* m_tools = m_toolSources[0].get();
     KisUserFeedback::ToolsInfoSource* tools = nullptr;
 
     QSharedPointer<KisTicket> timeTicket;
     timeTicket.reset(new KisTimeTicket(id));
 
     tools = dynamic_cast<KisUserFeedback::ToolsInfoSource*>(m_tools);
 
-    if (!tools) {
-        Q_ASSERT_X(1 == 0, "create tool's timeTicket ", id);
-        return;
-    }
+    KIS_SAFE_ASSERT_RECOVER_RETURN(tools);
+
     QWeakPointer<KisTicket> weakTimeTicket(timeTicket);
 
     m_tickets.insert(id, weakTimeTicket);
     tools->activateTool(timeTicket);
 }
 
-KisTelemetryRegularProvider::~KisTelemetryRegularProvider()
+KisTelemetryProvider::~KisTelemetryProvider()
 {
 }
 
-KisTelemetryRegularProvider::TelemetryCategory KisTelemetryRegularProvider::pathToKind(QString path)
+KisTelemetryProvider::TelemetryCategory KisTelemetryProvider::pathToKind(QString path)
 {
     if (path == "tools/")
         return tools;
+    else if (path == "install/")
+        return install;
     return tools;
 }
diff --git a/plugins/telemetry/kis_telemetry_regular_provider.h b/plugins/telemetry/kis_telemetry_provider.h
similarity index 81%
rename from plugins/telemetry/kis_telemetry_regular_provider.h
rename to plugins/telemetry/kis_telemetry_provider.h
index fd4c87cf38..200766e897 100644
--- a/plugins/telemetry/kis_telemetry_regular_provider.h
+++ b/plugins/telemetry/kis_telemetry_provider.h
@@ -1,67 +1,73 @@
 /* This file is part of the KDE project
    Copyright (C) 2017 Alexey Kapustin <akapust1n@mail.ru>
 
 
    This library is free software; you can redistribute it and/or
    modify it under the terms of the GNU Library General Public
    License as published by the Free Software Foundation; either
    version 2 of the License, or (at your option) any later version.
 
    This library is distributed in the hope that it will be useful,
    but WITHOUT ANY WARRANTY; without even the implied warranty of
    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
    Library General Public License for more details.
 
    You should have received a copy of the GNU Library General Public License
    along with this library; see the file COPYING.LIB.  If not, write to
    the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
  * Boston, MA 02110-1301, USA.
 */
 
 #ifndef KIS_TELEMETRY_REGULAR_PROVIDER_H
 #define KIS_TELEMETRY_REGULAR_PROVIDER_H
 #include "QScopedPointer"
 #include <QVariant>
 #include <KUserFeedback/AbstractDataSource>
 #include <KUserFeedback/QtVersionSource>
 #include <KUserFeedback/CompilerInfoSource>
 #include <KUserFeedback/LocaleInfoSource>
 #include <KUserFeedback/OpenGLInfoSource>
 #include <KUserFeedback/PlatformInfoSource>
 #include <KUserFeedback/QtVersionSource>
 #include <KUserFeedback/ScreenInfoSource>
 #include <KUserFeedback/provider.h>
 
 #include "kis_cpuinfosource.h"
 
 #include <kis_telemetry_abstruct.h>
 #include <memory>
 #include <QVector>
 #include <QMultiMap>
 #include <QWeakPointer>
 #include "kis_tickets.h"
+#include "kis_telemetry_actions.h"
 
 
-class KisTelemetryRegularProvider : public KisTelemetryAbstruct {
+class KisTelemetryProvider : public KisTelemetryAbstruct {
 public:
-    KisTelemetryRegularProvider();
+    KisTelemetryProvider();
     void sendData(QString path) override;
-    void getTimeTicket(QString id, UseMode mode = Activate) override;
-    void putTimeTicket(QString id,  UseMode mode = Activate) override;
 
-    virtual ~KisTelemetryRegularProvider();
+
+    virtual ~KisTelemetryProvider();
+protected:
+    void getTimeTicket(QString id) override;
+    void putTimeTicket(QString id) override;
 
 private:
     enum TelemetryCategory{
-        tools
+        tools,
+        install
     };
 private:
     QScopedPointer<KUserFeedback::Provider> m_toolsProvider;
     std::vector<std::unique_ptr<KUserFeedback::AbstractDataSource> > m_toolSources;
+    QScopedPointer<KUserFeedback::Provider> m_installProvider;
+    std::vector<std::unique_ptr<KUserFeedback::AbstractDataSource> > m_installSources;
     QMultiMap<QString, QWeakPointer<KisTicket>> m_tickets;
     TelemetryCategory pathToKind(QString path);
 
 };
 
 #endif
 
diff --git a/plugins/telemetry/kis_tickets.cpp b/plugins/telemetry/kis_tickets.cpp
index 2c0dab340a..6336980087 100644
--- a/plugins/telemetry/kis_tickets.cpp
+++ b/plugins/telemetry/kis_tickets.cpp
@@ -1,78 +1,79 @@
 /* This file is part of the KDE project
    Copyright (C) 2017 Alexey Kapustin <akapust1n@mail.ru>
 
 
    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_tickets.h"
 #include <QTime>
 #include <limits>
 
 KisTimeTicket::KisTimeTicket(QString id)
     : KisTicket(id)
 {
     m_start = QDateTime::currentDateTime();
+    m_end = m_start;
 }
 
 void KisTimeTicket::setStartTime(QDateTime& time)
 {
     m_start = time;
 }
 
 void KisTimeTicket::setEndTime(QDateTime& time)
 {
     m_end = time;
 }
 
 QDateTime KisTimeTicket::startTime() const
 {
     return m_start;
 }
 
 QDateTime KisTimeTicket::endTime() const
 {
     return m_end;
 }
 
 int KisTimeTicket::useTimeMSeconds() const
 {
     int timeUse =  static_cast<int>(m_end.toMSecsSinceEpoch() - m_start.toMSecsSinceEpoch());
     return timeUse;
 }
 
 void KisTimeTicket::addMSecs(int seconds)
 {
     if(seconds<0){
         seconds = std::numeric_limits<int>::max();
     }
     m_end.addMSecs(seconds);
 }
 
 KisTicket::KisTicket(QString id)
     : m_id(id)
 {
 }
 
 QString KisTicket::ticketId() const
 {
     return m_id;
 }
 
 void KisTicket::setTickedId(QString id)
 {
     m_id = id;
 }
diff --git a/plugins/telemetry/kis_toolsinfosource.cpp b/plugins/telemetry/kis_toolsinfosource.cpp
index e966b927d0..58929892ec 100644
--- a/plugins/telemetry/kis_toolsinfosource.cpp
+++ b/plugins/telemetry/kis_toolsinfosource.cpp
@@ -1,103 +1,106 @@
 /* This file is part of the KDE project
    Copyright (C) 2017 Alexey Kapustin <akapust1n@mail.ru>
 
 
    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_toolsinfosource.h"
 
 #include <QMutexLocker>
 #include <QSysInfo>
 #include <QThread>
 #include <QVariant>
 #include <cmath>
 #include <iostream>
 
 using namespace KisUserFeedback;
 using namespace KUserFeedback;
 
 ToolsInfoSource::ToolsInfoSource()
     : AbstractDataSource(QStringLiteral("Tools"), Provider::DetailedSystemInformation)
 {
 }
 
 QString ToolsInfoSource::description() const
 {
     return QObject::tr("Inforamation about tools");
 }
 
 QVariant ToolsInfoSource::data()
 {
     static int countCalls = 0;
     countCalls++;
     if (!countCalls % 2) { //kuserfeedback feature
         m_tools.clear();
     }
-    foreach (QString id, m_currentTools.keys()) {
-        deactivateTool(id);
-    }
-    foreach (QSharedPointer<KisTicket> tool, m_toolsMap) {
-        KisTicket* ticket = tool.data();
+
+    foreach (toolInfo tool, m_toolsMap) {
+        KisTicket* ticket = tool.ticket.data();
         KisTimeTicket* timeTicket = nullptr;
 
         timeTicket = dynamic_cast<KisTimeTicket*>(ticket);
         if (timeTicket) {
             int timeUse = timeTicket->useTimeMSeconds();
+            if (!timeUse) {
+                continue;
+            }
             QVariantMap m;
-            m.insert(QStringLiteral("toolname"), ticket->ticketId());
-            m.insert(QStringLiteral("timeUseSeconds"), timeUse);
+            m.insert(QStringLiteral("toolName"), ticket->ticketId());
+            m.insert(QStringLiteral("timeUseMSeconds"), timeUse);
+            m.insert(QStringLiteral("countUse"), timeUse);
             std::cout << "Time use" << timeUse << std::endl;
             m_tools.push_back(m);
         }
     }
     m_toolsMap.clear();
-    m_currentTools.clear();
 
     return m_tools;
 }
 
 void ToolsInfoSource::activateTool(QSharedPointer<KisTicket> ticket)
 {
     QMutexLocker locker(&m_mutex);
 
     m_currentTools.insert(ticket->ticketId(), ticket);
-    if (!m_toolsMap.count(ticket->ticketId()))
-        m_toolsMap.insert(ticket->ticketId(), ticket);
+    if (!m_toolsMap.count(ticket->ticketId())){
+        m_toolsMap.insert(ticket->ticketId(), {ticket, 1});
+    }
     std::cout << "ACTIVATE TOOL " << ticket->ticketId().toStdString() << std::endl;
 }
 
 void ToolsInfoSource::deactivateTool(QString id)
 {
     QMutexLocker locker(&m_mutex);
     KisTicket* ticket = m_currentTools.value(id).data();
     KisTimeTicket* timeTicket = dynamic_cast<KisTimeTicket*>(ticket);
     std::cout << "SIZES current:" << m_currentTools.size() << " all" << m_toolsMap.size() << std::endl;
     if (timeTicket) {
         QDateTime deactivateTime = QDateTime::currentDateTime();
         timeTicket->setEndTime(deactivateTime);
 
-        KisTicket* mainTicket = m_toolsMap[id].data();
+        KisTicket* mainTicket = m_toolsMap[id].ticket.data();
         KisTimeTicket* mainTimeTicket = dynamic_cast<KisTimeTicket*>(mainTicket);
 
         if (mainTimeTicket) {
+            m_toolsMap[id].countUse++;
             std::cout << "AdditionalTIme " << timeTicket->useTimeMSeconds() << std::endl;
             mainTimeTicket->addMSecs(timeTicket->useTimeMSeconds());
         }
         std::cout << "DE_ACTIVATE TOOL " << ticket->ticketId().toStdString() << std::endl;
     }
     m_currentTools.remove(id);
 }
diff --git a/plugins/telemetry/kis_toolsinfosource.h b/plugins/telemetry/kis_toolsinfosource.h
index b3f8245e07..3cba55ed86 100644
--- a/plugins/telemetry/kis_toolsinfosource.h
+++ b/plugins/telemetry/kis_toolsinfosource.h
@@ -1,59 +1,65 @@
 /* This file is part of the KDE project
    Copyright (C) 2017 Alexey Kapustin <akapust1n@mail.ru>
 
 
    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 KISUSERFEEDBACK_TOOLSINFOSOURCE_H
 #define KISUSERFEEDBACK_TOOLSINFOSOURCE_H
 
 #include "abstractdatasource.h"
 #include "kuserfeedbackcore_export.h"
 #include <QMap>
 #include <QMutex>
 #include <QPair>
 #include <QSharedPointer>
 #include <QDateTime>
 #include <QVariantMap>
 #include <QVector>
 #include "kis_telemetry_abstruct.h"
 #include "kis_tickets.h"
 
 
 namespace KisUserFeedback {
 
 /*! Data source reporting the type and amount of CPUs.
  *
  *  The default telemetry mode for this source is Provider::DetailedSystemInformation.
  */
 class ToolsInfoSource : public KUserFeedback::AbstractDataSource {
 public:
     ToolsInfoSource();
     QString description() const override;
     QVariant data() override;
     void activateTool(QSharedPointer<KisTicket> ticket);
     void deactivateTool(QString id);
 
+private:
+    struct toolInfo{
+        QSharedPointer<KisTicket> ticket;
+        int countUse ;
+    };
+
 private:
     QVariantList m_tools;
-    QMap<QString,QSharedPointer<KisTicket>> m_toolsMap;
+    QMap<QString, toolInfo> m_toolsMap;
     QMap<QString, QSharedPointer<KisTicket> > m_currentTools;
     QMutex m_mutex;
 };
 }
 
 #endif // KISUSERFEEDBACK_TOOLSINFOSOURCE_H
diff --git a/plugins/tools/basictools/kis_tool_fill.cc b/plugins/tools/basictools/kis_tool_fill.cc
index df124767a6..5208c028f5 100644
--- a/plugins/tools/basictools/kis_tool_fill.cc
+++ b/plugins/tools/basictools/kis_tool_fill.cc
@@ -1,304 +1,302 @@
 /*
 *  kis_tool_fill.cc - part of Krayon
 *
 *  Copyright (c) 2000 John Califf <jcaliff@compuzone.net>
 *  Copyright (c) 2004 Boudewijn Rempt <boud@valdyas.org>
 *  Copyright (c) 2004 Bart Coppens <kde@bartcoppens.be>
 *
 *  This program is free software; you can redistribute it and/or modify
 *  it under the terms of the GNU General Public License as published by
 *  the Free Software Foundation; either version 2 of the License, or
 *  (at your option) any later version.
 *
 *  This program is distributed in the hope that it will be useful,
 *  but WITHOUT ANY WARRANTY; without even the implied warranty of
 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 *  GNU General Public License for more details.
 *
 *  You should have received a copy of the GNU General Public License
 *  along with this program; if not, write to the Free Software
 *  Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
 */
 
 #include "kis_tool_fill.h"
 
 #include <kis_debug.h>
 #include <klocalizedstring.h>
 
 #include <QLabel>
 #include <QLayout>
 #include <QCheckBox>
 #include <QComboBox>
 #include <QVector>
 #include <QRect>
 #include <QColor>
 
 #include <ksharedconfig.h>
 
 #include <KoCanvasBase.h>
 #include <KoPointerEvent.h>
 
 #include <kis_layer.h>
 #include <kis_painter.h>
 #include <resources/KoPattern.h>
 #include <kis_fill_painter.h>
 #include <kis_selection.h>
 
 #include <KisViewManager.h>
 #include <canvas/kis_canvas2.h>
 #include <widgets/kis_cmb_composite.h>
 #include <widgets/kis_slider_spin_box.h>
 #include <kis_cursor.h>
 #include <recorder/kis_recorded_fill_paint_action.h>
 #include <recorder/kis_node_query_path.h>
 #include <recorder/kis_action_recorder.h>
 #include "kis_resources_snapshot.h"
 
 #include <processing/fill_processing_visitor.h>
 #include <kis_processing_applicator.h>
 
 
 KisToolFill::KisToolFill(KoCanvasBase * canvas)
         : KisToolPaint(canvas, KisCursor::load("tool_fill_cursor.png", 6, 6))
 {
     setObjectName("tool_fill");
     m_feather = 0;
     m_sizemod = 0;
     m_threshold = 80;
     m_usePattern = false;
     m_unmerged = false;
     m_fillOnlySelection = false;
 }
 
 KisToolFill::~KisToolFill()
 {
 }
 
 void KisToolFill::resetCursorStyle()
 {
     KisToolPaint::resetCursorStyle();
 
     overrideCursorIfNotEditable();
 }
 
 void KisToolFill::activate(ToolActivation toolActivation, const QSet<KoShape*> &shapes)
 {
     KisToolPaint::activate(toolActivation, shapes);
     m_configGroup =  KSharedConfig::openConfig()->group(toolId());
 }
 
 
 void KisToolFill::beginPrimaryAction(KoPointerEvent *event)
 {
     if (!nodeEditable()) {
         event->ignore();
         return;
     }
 
     setMode(KisTool::PAINT_MODE);
-    KisTelemetrySensor sensor(toolId(), KisTelemetryAbstruct::putTimeTicket_, KisTelemetryAbstruct::Use);
 
     m_startPos = convertToIntPixelCoord(event);
 }
 
 void KisToolFill::endPrimaryAction(KoPointerEvent *event)
 {
     Q_UNUSED(event);
     CHECK_MODE_SANITY_OR_RETURN(KisTool::PAINT_MODE);
 
     setMode(KisTool::HOVER_MODE);
-    KisTelemetrySensor sensor(toolId(), KisTelemetryAbstruct::getTimeTicket_, KisTelemetryAbstruct::Use);
 
 
     if (!currentNode() ||
         (!image()->wrapAroundModePermitted() &&
          !image()->bounds().contains(m_startPos))) {
 
         return;
     }
 
     // TODO: remove this block after recording refactoring
     if (image()) {
         KisNodeSP projectionNode;
         if(m_unmerged) {
             projectionNode = currentNode();
         } else {
             projectionNode = image()->root();
         }
         KisRecordedFillPaintAction paintAction(KisNodeQueryPath::absolutePath(currentNode()), m_startPos, KisNodeQueryPath::absolutePath(projectionNode));
         setupPaintAction(&paintAction);
         paintAction.setPattern(currentPattern());
         if(m_usePattern) {
             paintAction.setFillStyle(KisPainter::FillStylePattern);
         }
         image()->actionRecorder()->addAction(paintAction);
     }
 
     bool useFastMode = m_useFastMode->isChecked();
 
     KisProcessingApplicator applicator(currentImage(), currentNode(),
                                        KisProcessingApplicator::SUPPORTS_WRAPAROUND_MODE,
                                        KisImageSignalVector() << ModifiedSignal,
                                        kundo2_i18n("Flood Fill"));
 
     KisResourcesSnapshotSP resources =
         new KisResourcesSnapshot(image(), currentNode(), this->canvas()->resourceManager());
 
     KisProcessingVisitorSP visitor =
         new FillProcessingVisitor(m_startPos,
                                   resources->activeSelection(),
                                   resources,
                                   useFastMode,
                                   m_usePattern,
                                   m_fillOnlySelection,
                                   m_feather,
                                   m_sizemod,
                                   m_threshold,
                                   m_unmerged,
                                   false);
 
     applicator.applyVisitor(visitor,
                             KisStrokeJobData::SEQUENTIAL,
                             KisStrokeJobData::EXCLUSIVE);
 
     applicator.end();
 }
 
 QWidget* KisToolFill::createOptionWidget()
 {
     QWidget *widget = KisToolPaint::createOptionWidget();
     widget->setObjectName(toolId() + " option widget");
 
     QLabel *lbl_fastMode = new QLabel(i18n("Fast mode: "), widget);
     m_useFastMode = new QCheckBox(QString(), widget);
     m_useFastMode->setToolTip(
         i18n("Fills area faster, but does not take composition "
              "mode into account. Selections and other extended "
              "features will also be disabled."));
 
 
     QLabel *lbl_threshold = new QLabel(i18n("Threshold: "), widget);
     m_slThreshold = new KisSliderSpinBox(widget);
     m_slThreshold->setObjectName("int_widget");
     m_slThreshold->setRange(1, 100);
     m_slThreshold->setPageStep(3);
 
 
     QLabel *lbl_sizemod = new QLabel(i18n("Grow selection: "), widget);
     m_sizemodWidget = new KisSliderSpinBox(widget);
     m_sizemodWidget->setObjectName("sizemod");
     m_sizemodWidget->setRange(-40, 40);
     m_sizemodWidget->setSingleStep(1);
     m_sizemodWidget->setSuffix(i18n(" px"));
 
     QLabel *lbl_feather = new QLabel(i18n("Feathering radius: "), widget);
     m_featherWidget = new KisSliderSpinBox(widget);
     m_featherWidget->setObjectName("feather");
     m_featherWidget->setRange(0, 40);
     m_featherWidget->setSingleStep(1);   
     m_featherWidget->setSuffix(i18n(" px"));
 
     QLabel *lbl_usePattern = new QLabel(i18n("Use pattern:"), widget);
     m_checkUsePattern = new QCheckBox(QString(), widget);
     m_checkUsePattern->setToolTip(i18n("When checked do not use the foreground color, but the gradient selected to fill with"));
 
     QLabel *lbl_sampleMerged = new QLabel(i18n("Limit to current layer:"), widget);
     m_checkSampleMerged = new QCheckBox(QString(), widget);
 
 
     QLabel *lbl_fillSelection = new QLabel(i18n("Fill entire selection:"), widget);
     m_checkFillSelection = new QCheckBox(QString(), widget);
     m_checkFillSelection->setToolTip(i18n("When checked do not look at the current layer colors, but just fill all of the selected area"));
 
     connect (m_useFastMode       , SIGNAL(toggled(bool))    , this, SLOT(slotSetUseFastMode(bool)));
     connect (m_slThreshold       , SIGNAL(valueChanged(int)), this, SLOT(slotSetThreshold(int)));
     connect (m_sizemodWidget     , SIGNAL(valueChanged(int)), this, SLOT(slotSetSizemod(int)));
     connect (m_featherWidget     , SIGNAL(valueChanged(int)), this, SLOT(slotSetFeather(int)));
     connect (m_checkUsePattern   , SIGNAL(toggled(bool))    , this, SLOT(slotSetUsePattern(bool)));
     connect (m_checkSampleMerged , SIGNAL(toggled(bool))    , this, SLOT(slotSetSampleMerged(bool)));
     connect (m_checkFillSelection, SIGNAL(toggled(bool))    , this, SLOT(slotSetFillSelection(bool)));
 
     addOptionWidgetOption(m_useFastMode, lbl_fastMode);
     addOptionWidgetOption(m_slThreshold, lbl_threshold);
     addOptionWidgetOption(m_sizemodWidget      , lbl_sizemod);
     addOptionWidgetOption(m_featherWidget      , lbl_feather);
 
     addOptionWidgetOption(m_checkFillSelection, lbl_fillSelection);
     addOptionWidgetOption(m_checkSampleMerged, lbl_sampleMerged);
     addOptionWidgetOption(m_checkUsePattern, lbl_usePattern);
 
     updateGUI();
 
     widget->setFixedHeight(widget->sizeHint().height());
 
 
 
     // load configuration options
     m_useFastMode->setChecked(m_configGroup.readEntry("useFastMode", false));
     m_slThreshold->setValue(m_configGroup.readEntry("thresholdAmount", 80));
     m_sizemodWidget->setValue(m_configGroup.readEntry("growSelection", 0));
 
     m_featherWidget->setValue(m_configGroup.readEntry("featherAmount", 0));
     m_checkUsePattern->setChecked(m_configGroup.readEntry("usePattern", false));
     m_checkSampleMerged->setChecked(m_configGroup.readEntry("sampleMerged", false));
     m_checkFillSelection->setChecked(m_configGroup.readEntry("fillSelection", false));
 
     return widget;
 }
 
 void KisToolFill::updateGUI()
 {
     bool useAdvancedMode = !m_useFastMode->isChecked();
     bool selectionOnly = m_checkFillSelection->isChecked();
 
     m_useFastMode->setEnabled(!selectionOnly);
     m_slThreshold->setEnabled(!selectionOnly);
 
     m_sizemodWidget->setEnabled(!selectionOnly && useAdvancedMode);
     m_featherWidget->setEnabled(!selectionOnly && useAdvancedMode);
     m_checkSampleMerged->setEnabled(!selectionOnly && useAdvancedMode);
     m_checkUsePattern->setEnabled(useAdvancedMode);
 }
 
 void KisToolFill::slotSetUseFastMode(bool value)
 {
     updateGUI();
     m_configGroup.writeEntry("useFastMode", value);
 }
 
 void KisToolFill::slotSetThreshold(int threshold)
 {
     m_threshold = threshold;
     m_configGroup.writeEntry("thresholdAmount", threshold);
 }
 
 void KisToolFill::slotSetUsePattern(bool state)
 {
     m_usePattern = state;
     m_configGroup.writeEntry("usePattern", state);
 }
 
 void KisToolFill::slotSetSampleMerged(bool state)
 {
     m_unmerged = state;
     m_configGroup.writeEntry("sampleMerged", state);
 }
 
 void KisToolFill::slotSetFillSelection(bool state)
 {
     m_fillOnlySelection = state;
     m_configGroup.writeEntry("fillSelection", state);
     updateGUI();
 }
 
 void KisToolFill::slotSetSizemod(int sizemod)
 {
     m_sizemod = sizemod;
     m_configGroup.writeEntry("growSelection", sizemod);
 }
 
 void KisToolFill::slotSetFeather(int feather)
 {
     m_feather = feather;
     m_configGroup.writeEntry("featherAmount", feather);
 }
diff --git a/plugins/tools/basictools/kis_tool_gradient.cc b/plugins/tools/basictools/kis_tool_gradient.cc
index 309058d174..3406b2e89d 100644
--- a/plugins/tools/basictools/kis_tool_gradient.cc
+++ b/plugins/tools/basictools/kis_tool_gradient.cc
@@ -1,303 +1,301 @@
 /*
  *  kis_tool_gradient.cc - part of Krita
  *
  *  Copyright (c) 2002 Patrick Julien <freak@codepimps.org>
  *  Copyright (c) 2003 Boudewijn Rempt <boud@valdyas.org>
  *  Copyright (c) 2004-2007 Adrian Page <adrian@pagenet.plus.com>
  *
  *  This program is free software; you can redistribute it and/or modify
  *  it under the terms of the GNU General Public License as published by
  *  the Free Software Foundation; either version 2 of the License, or
  *  (at your option) any later version.
  *
  *  This program is distributed in the hope that it will be useful,
  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  *  GNU General Public License for more details.
  *
  *  You should have received a copy of the GNU General Public License
  *  along with this program; if not, write to the Free Software
  *  Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
  */
 
 #include "kis_tool_gradient.h"
 
 #include <cfloat>
 
 #include <QApplication>
 #include <QPainter>
 #include <QLabel>
 #include <QLayout>
 #include <QCheckBox>
 
 #include <kis_transaction.h>
 #include <kis_debug.h>
 #include <klocalizedstring.h>
 #include <kcombobox.h>
 
 
 #include <KoPointerEvent.h>
 #include <KoCanvasBase.h>
 #include <KoViewConverter.h>
 #include <KoUpdater.h>
 #include <KoProgressUpdater.h>
 
 #include <kis_gradient_painter.h>
 #include <kis_painter.h>
 #include <kis_canvas_resource_provider.h>
 #include <kis_layer.h>
 #include <kis_selection.h>
 #include <kis_paint_layer.h>
 
 #include <canvas/kis_canvas2.h>
 #include <KisViewManager.h>
 #include <widgets/kis_cmb_composite.h>
 #include <widgets/kis_double_widget.h>
 #include <widgets/kis_slider_spin_box.h>
 #include <kis_cursor.h>
 #include <kis_config.h>
 #include "kis_resources_snapshot.h"
 
 
 KisToolGradient::KisToolGradient(KoCanvasBase * canvas)
         : KisToolPaint(canvas, KisCursor::load("tool_gradient_cursor.png", 6, 6))
 {
     setObjectName("tool_gradient");
 
     m_startPos = QPointF(0, 0);
     m_endPos = QPointF(0, 0);
 
     m_reverse = false;
     m_shape = KisGradientPainter::GradientShapeLinear;
     m_repeat = KisGradientPainter::GradientRepeatNone;
     m_antiAliasThreshold = 0.2;
 }
 
 KisToolGradient::~KisToolGradient()
 {
 }
 
 void KisToolGradient::resetCursorStyle()
 {
     KisToolPaint::resetCursorStyle();
 
     overrideCursorIfNotEditable();
 }
 
 void KisToolGradient::activate(ToolActivation toolActivation, const QSet<KoShape*> &shapes)
 {
     KisToolPaint::activate(toolActivation, shapes);
     m_configGroup =  KSharedConfig::openConfig()->group(toolId());
 }
 
 void KisToolGradient::paint(QPainter &painter, const KoViewConverter &converter)
 {
     if (mode() == KisTool::PAINT_MODE && m_startPos != m_endPos) {
             qreal sx, sy;
             converter.zoom(&sx, &sy);
             painter.scale(sx / currentImage()->xRes(), sy / currentImage()->yRes());
             paintLine(painter);
     }
 }
 
 void KisToolGradient::beginPrimaryAction(KoPointerEvent *event)
 {
     if (!nodeEditable()) {
         event->ignore();
         return;
     }
-    KisTelemetrySensor sensor(toolId(), KisTelemetryAbstruct::putTimeTicket_, KisTelemetryAbstruct::Use);
 
     setMode(KisTool::PAINT_MODE);
 
     m_startPos = convertToPixelCoordAndSnap(event, QPointF(), false);
     m_endPos = m_startPos;
 }
 
 void KisToolGradient::continuePrimaryAction(KoPointerEvent *event)
 {
     /**
      * TODO: The gradient tool is still not in strokes, so the end of
      *       its action can call processEvent(), which would result in
      *       nested event hadler calls. Please uncomment this line
      *       when the tool is ported to strokes.
      */
     //CHECK_MODE_SANITY_OR_RETURN(KisTool::PAINT_MODE);
 
     QPointF pos = convertToPixelCoordAndSnap(event, QPointF(), false);
 
     QRectF bound(m_startPos, m_endPos);
     canvas()->updateCanvas(convertToPt(bound.normalized()));
 
     if (event->modifiers() == Qt::ShiftModifier) {
         m_endPos = straightLine(pos);
     } else {
         m_endPos = pos;
     }
 
     bound.setTopLeft(m_startPos);
     bound.setBottomRight(m_endPos);
     canvas()->updateCanvas(convertToPt(bound.normalized()));
 }
 
 void KisToolGradient::endPrimaryAction(KoPointerEvent *event)
 {
     Q_UNUSED(event);
     CHECK_MODE_SANITY_OR_RETURN(KisTool::PAINT_MODE);
     setMode(KisTool::HOVER_MODE);
 
     if (!currentNode() || !blockUntilOperationsFinished())
         return;
 
     if (m_startPos == m_endPos) {
         return;
     }
 
     KisPaintDeviceSP device;
     KisImageSP image = this->image();
-    KisTelemetrySensor sensor(toolId(), KisTelemetryAbstruct::getTimeTicket_, KisTelemetryAbstruct::Use);
 
     KisResourcesSnapshotSP resources =
         new KisResourcesSnapshot(image, currentNode(), this->canvas()->resourceManager());
 
     if (image && (device = resources->currentNode()->paintDevice())) {
         QApplication::setOverrideCursor(Qt::BusyCursor);
 
         KUndo2MagicString actionName = kundo2_i18n("Gradient");
         KisUndoAdapter *undoAdapter = image->undoAdapter();
         undoAdapter->beginMacro(actionName);
 
         KisGradientPainter painter(device, resources->activeSelection());
         resources->setupPainter(&painter);
 
         painter.beginTransaction();
 
         KisCanvas2 * canvas = dynamic_cast<KisCanvas2 *>(this->canvas());
         KoProgressUpdater * updater = canvas->viewManager()->createProgressUpdater(KoProgressUpdater::Unthreaded);
 
         updater->start(100, i18nc("@info:progress", "Gradient..."));
         painter.setProgress(updater->startSubtask());
 
         painter.setGradientShape(m_shape);
         painter.paintGradient(m_startPos, m_endPos, m_repeat, m_antiAliasThreshold, m_reverse, 0, 0, image->width(), image->height());
         painter.endTransaction(undoAdapter);
         undoAdapter->endMacro();
 
         QApplication::restoreOverrideCursor();
         currentNode()->setDirty();
         notifyModified();
         delete updater;
     }
     canvas()->updateCanvas(convertToPt(currentImage()->bounds()));
 }
 
 QPointF KisToolGradient::straightLine(QPointF point)
 {
     QPointF comparison = point - m_startPos;
     QPointF result;
 
     if (fabs(comparison.x()) > fabs(comparison.y())) {
         result.setX(point.x());
         result.setY(m_startPos.y());
     } else {
         result.setX(m_startPos.x());
         result.setY(point.y());
     }
 
     return result;
 }
 
 void KisToolGradient::paintLine(QPainter& gc)
 {
     if (canvas()) {
         QPen old = gc.pen();
         QPen pen(Qt::SolidLine);
 
         gc.setPen(pen);
         gc.drawLine(m_startPos, m_endPos);
         gc.setPen(old);
     }
 }
 
 QWidget* KisToolGradient::createOptionWidget()
 {
     QWidget *widget = KisToolPaint::createOptionWidget();
     Q_CHECK_PTR(widget);
     widget->setObjectName(toolId() + " option widget");
 
 
     // Make sure to create the connections last after everything is set up. The initialized values
     // won't be loaded from the configuration file if you add the widget before the connection
     m_lbShape = new QLabel(i18n("Shape:"), widget);
     m_cmbShape = new KComboBox(widget);
     m_cmbShape->setObjectName("shape_combo");
     m_cmbShape->addItem(i18nc("the gradient will be drawn linearly", "Linear"));
     m_cmbShape->addItem(i18nc("the gradient will be drawn bilinearly", "Bi-Linear"));
     m_cmbShape->addItem(i18nc("the gradient will be drawn radially", "Radial"));
     m_cmbShape->addItem(i18nc("the gradient will be drawn in a square around a centre", "Square"));
     m_cmbShape->addItem(i18nc("the gradient will be drawn as an assymmetric cone", "Conical"));
     m_cmbShape->addItem(i18nc("the gradient will be drawn as a symmetric cone", "Conical Symmetric"));
     m_cmbShape->addItem(i18nc("the gradient will be drawn in a selection outline", "Shaped"));
     addOptionWidgetOption(m_cmbShape, m_lbShape);
     connect(m_cmbShape, SIGNAL(currentIndexChanged(int)), this, SLOT(slotSetShape(int)));
 
     m_lbRepeat = new QLabel(i18n("Repeat:"), widget);
     m_cmbRepeat = new KComboBox(widget);
     m_cmbRepeat->setObjectName("repeat_combo");
     m_cmbRepeat->addItem(i18nc("The gradient will not repeat", "None"));
     m_cmbRepeat->addItem(i18nc("The gradient will repeat forwards", "Forwards"));
     m_cmbRepeat->addItem(i18nc("The gradient will repeat alternatingly", "Alternating"));
     addOptionWidgetOption(m_cmbRepeat, m_lbRepeat);
     connect(m_cmbRepeat, SIGNAL(currentIndexChanged(int)), this, SLOT(slotSetRepeat(int)));
 
 
     m_lbAntiAliasThreshold = new QLabel(i18n("Anti-alias threshold:"), widget);
     m_slAntiAliasThreshold = new KisDoubleSliderSpinBox(widget);
     m_slAntiAliasThreshold->setObjectName("threshold_slider");
     m_slAntiAliasThreshold->setRange(0, 1, 3);
     addOptionWidgetOption(m_slAntiAliasThreshold, m_lbAntiAliasThreshold);
     connect(m_slAntiAliasThreshold, SIGNAL(valueChanged(qreal)), this, SLOT(slotSetAntiAliasThreshold(qreal)));
 
     m_ckReverse = new QCheckBox(i18nc("the gradient will be drawn with the color order reversed", "Reverse"), widget);
     m_ckReverse->setObjectName("reverse_check");
     connect(m_ckReverse, SIGNAL(toggled(bool)), this, SLOT(slotSetReverse(bool)));
     addOptionWidgetOption(m_ckReverse);
 
 
     widget->setFixedHeight(widget->sizeHint().height());
 
 
     // load configuration settings into widget (updating UI will update internal variables from signals/slots)
     m_ckReverse->setChecked((bool)m_configGroup.readEntry("reverse", false));
     m_cmbShape->setCurrentIndex((int)m_configGroup.readEntry("shape", 0));
     m_cmbRepeat->setCurrentIndex((int)m_configGroup.readEntry("repeat", 0));
     m_slAntiAliasThreshold->setValue((qreal)m_configGroup.readEntry("antialiasThreshold", 0.0));
 
     return widget;
 }
 
 void KisToolGradient::slotSetShape(int shape)
 {
     m_shape = static_cast<KisGradientPainter::enumGradientShape>(shape);
     m_configGroup.writeEntry("shape", shape);
 }
 
 void KisToolGradient::slotSetRepeat(int repeat)
 {
     m_repeat = static_cast<KisGradientPainter::enumGradientRepeat>(repeat);
     m_configGroup.writeEntry("repeat", repeat);
 }
 
 void KisToolGradient::slotSetReverse(bool state)
 {
     m_reverse = state;
     m_configGroup.writeEntry("reverse", state);
 }
 
 void KisToolGradient::slotSetAntiAliasThreshold(qreal value)
 {
     m_antiAliasThreshold = value;
     m_configGroup.writeEntry("antialiasThreshold", value);
 }
 
 
diff --git a/plugins/tools/basictools/kis_tool_line.cc b/plugins/tools/basictools/kis_tool_line.cc
index db0ff8c233..c0231b43f8 100644
--- a/plugins/tools/basictools/kis_tool_line.cc
+++ b/plugins/tools/basictools/kis_tool_line.cc
@@ -1,379 +1,376 @@
 /*
  *  kis_tool_line.cc - part of Krayon
  *
  *  Copyright (c) 2000 John Califf <jwcaliff@compuzone.net>
  *  Copyright (c) 2002 Patrick Julien <freak@codepimps.org>
  *  Copyright (c) 2003 Boudewijn Rempt <boud@valdyas.org>
  *  Copyright (c) 2009 Lukáš Tvrdý <lukast.dev@gmail.com>
  *  Copyright (c) 2007,2010 Cyrille Berger <cberger@cberger.net>
  *
  *  This program is free software; you can redistribute it and/or modify
  *  it under the terms of the GNU General Public License as published by
  *  the Free Software Foundation; either version 2 of the License, or
  *  (at your option) any later version.
  *
  *  This program is distributed in the hope that it will be useful,
  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  *  GNU General Public License for more details.
  *
  *  You should have received a copy of the GNU General Public License
  *  along with this program; if not, write to the Free Software
  *  Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
  */
 
 #include "kis_tool_line.h"
 
 
 #include <QPushButton>
 
 #include <ksharedconfig.h>
 
 #include <KoCanvasBase.h>
 #include <KoPointerEvent.h>
 #include <KoPathShape.h>
 #include <KoShapeController.h>
 #include <KoShapeStroke.h>
 
 #include <kis_debug.h>
 #include <kis_cursor.h>
 #include <brushengine/kis_paintop_registry.h>
 #include "kis_figure_painting_tool_helper.h"
 #include "kis_canvas2.h"
 
 
 #include <recorder/kis_action_recorder.h>
 #include <recorder/kis_recorded_path_paint_action.h>
 #include <recorder/kis_node_query_path.h>
 
 #include "kis_painting_information_builder.h"
 #include "kis_tool_line_helper.h"
 
 #define ENABLE_RECORDING
 
 const KisCoordinatesConverter* getCoordinatesConverter(KoCanvasBase * canvas)
 {
     KisCanvas2 *kritaCanvas = dynamic_cast<KisCanvas2*>(canvas);
     return kritaCanvas->coordinatesConverter();
 }
 
 
 KisToolLine::KisToolLine(KoCanvasBase * canvas)
     : KisToolShape(canvas, KisCursor::load("tool_line_cursor.png", 6, 6)),
       m_showGuideline(true),
       m_strokeIsRunning(false),
       m_infoBuilder(new KisConverterPaintingInformationBuilder(getCoordinatesConverter(canvas))),
       m_helper(new KisToolLineHelper(m_infoBuilder.data(), kundo2_i18n("Draw Line"))),
       m_strokeUpdateCompressor(500, KisSignalCompressor::POSTPONE),
       m_longStrokeUpdateCompressor(1000, KisSignalCompressor::FIRST_INACTIVE)
 {
     setObjectName("tool_line");
 
     setSupportOutline(true);
 
     connect(&m_strokeUpdateCompressor, SIGNAL(timeout()), SLOT(updateStroke()));
     connect(&m_longStrokeUpdateCompressor, SIGNAL(timeout()), SLOT(updateStroke()));
 }
 
 KisToolLine::~KisToolLine()
 {
 }
 
 int KisToolLine::flags() const
 {
     return KisTool::FLAG_USES_CUSTOM_COMPOSITEOP|KisTool::FLAG_USES_CUSTOM_PRESET;
 }
 
 void KisToolLine::resetCursorStyle()
 {
     KisToolPaint::resetCursorStyle();
 
     overrideCursorIfNotEditable();
 }
 
 void KisToolLine::activate(ToolActivation activation, const QSet<KoShape*> &shapes)
 {
    KisToolPaint::activate(activation, shapes);
    configGroup =  KSharedConfig::openConfig()->group(toolId());
-   KisTelemetrySensor sensor(toolId(), KisTelemetryAbstruct::putTimeTicket_, KisTelemetryAbstruct::Activate);
 }
 
 void KisToolLine::deactivate()
 {
     KisToolPaint::deactivate();
-    KisTelemetrySensor sensor(toolId(), KisTelemetryAbstruct::getTimeTicket_, KisTelemetryAbstruct::Activate);
 
     cancelStroke();
 }
 
 QWidget* KisToolLine::createOptionWidget()
 {
     QWidget* widget = KisToolPaint::createOptionWidget();
 
     m_chkUseSensors = new QCheckBox(i18n("Use sensors"));
     addOptionWidgetOption(m_chkUseSensors);
 
     m_chkShowPreview = new QCheckBox(i18n("Show Preview"));
     addOptionWidgetOption(m_chkShowPreview);
 
     m_chkShowGuideline = new QCheckBox(i18n("Show Guideline"));
     addOptionWidgetOption(m_chkShowGuideline);
 
     // hook up connections for value changing
     connect(m_chkUseSensors, SIGNAL(clicked(bool)), this, SLOT(setUseSensors(bool)) );
     connect(m_chkShowPreview, SIGNAL(clicked(bool)), this, SLOT(setShowPreview(bool)) );
     connect(m_chkShowGuideline, SIGNAL(clicked(bool)), this, SLOT(setShowGuideline(bool)) );
 
 
     // read values in from configuration
     m_chkUseSensors->setChecked(configGroup.readEntry("useSensors", true));
     m_chkShowPreview->setChecked(configGroup.readEntry("showPreview", true));
     m_chkShowGuideline->setChecked(configGroup.readEntry("showGuideline", true));
 
     return widget;
 }
 
 void KisToolLine::setUseSensors(bool value)
 {
     configGroup.writeEntry("useSensors", value);
 }
 
 void KisToolLine::setShowGuideline(bool value)
 {
     m_showGuideline = value;
     configGroup.writeEntry("showGuideline", value);
 }
 
 void KisToolLine::setShowPreview(bool value)
 {
     configGroup.writeEntry("showPreview", value);
 }
 
 void KisToolLine::requestStrokeCancellation()
 {
     cancelStroke();
 }
 
 void KisToolLine::requestStrokeEnd()
 {
     // Terminate any in-progress strokes
     if (nodePaintAbility() == PAINT && m_helper->isRunning()) {
         endStroke();
     }
 }
 
 void KisToolLine::updatePreviewTimer(bool showGuideline)
 {
     // If the user disables the guideline, we will want to try to draw some
     // preview lines even if they're slow, so set the timer to FIRST_ACTIVE.
     if (showGuideline) {
         m_strokeUpdateCompressor.setMode(KisSignalCompressor::POSTPONE);
     } else {
         m_strokeUpdateCompressor.setMode(KisSignalCompressor::FIRST_ACTIVE);
     }
 }
 
 
 void KisToolLine::paint(QPainter& gc, const KoViewConverter &converter)
 {
     Q_UNUSED(converter);
 
     if(mode() == KisTool::PAINT_MODE) {
         paintLine(gc,QRect());
     }
     KisToolPaint::paint(gc,converter);
 }
 
 void KisToolLine::beginPrimaryAction(KoPointerEvent *event)
 {
     NodePaintAbility nodeAbility = nodePaintAbility();
     if (nodeAbility == NONE || !nodeEditable()) {
         event->ignore();
         return;
     }
-    KisTelemetrySensor sensor(toolId(), KisTelemetryAbstruct::putTimeTicket_, KisTelemetryAbstruct::Use);
     setMode(KisTool::PAINT_MODE);
 
     // Always show guideline on vector layers
     m_showGuideline = m_chkShowGuideline->isChecked() || nodeAbility != PAINT;
     updatePreviewTimer(m_showGuideline);
     m_helper->setEnabled(nodeAbility == PAINT);
     m_helper->setUseSensors(m_chkUseSensors->isChecked());
     m_helper->start(event, canvas()->resourceManager());
 
     m_startPoint = convertToPixelCoordAndSnap(event);
     m_endPoint = m_startPoint;
     m_lastUpdatedPoint = m_startPoint;
 
     m_strokeIsRunning = true;
+
 }
 
 void KisToolLine::updateStroke()
 {
     if (!m_strokeIsRunning) return;
 
     m_helper->repaintLine(canvas()->resourceManager(),
                           image(),
                           currentNode(),
                           image().data());
 }
 
 void KisToolLine::continuePrimaryAction(KoPointerEvent *event)
 {
     CHECK_MODE_SANITY_OR_RETURN(KisTool::PAINT_MODE);
     if (!m_strokeIsRunning) return;
 
     // First ensure the old guideline is deleted
     updateGuideline();
-    KisTelemetrySensor sensor(toolId(), KisTelemetryAbstruct::putTimeTicket_, KisTelemetryAbstruct::Use);
 
     QPointF pos = convertToPixelCoordAndSnap(event);
 
     if (event->modifiers() == Qt::AltModifier) {
         QPointF trans = pos - m_endPoint;
         m_helper->translatePoints(trans);
         m_startPoint += trans;
         m_endPoint += trans;
     } else if (event->modifiers() == Qt::ShiftModifier) {
         pos = straightLine(pos);
         m_helper->addPoint(event, pos);
     } else {
         m_helper->addPoint(event, pos);
     }
     m_endPoint = pos;
 
     // Draw preview if requested
     if (m_chkShowPreview->isChecked()) {
         // If the cursor has moved a significant amount, immediately clear the
         // current preview and redraw. Otherwise, do slow redraws periodically.
         auto updateDistance = (pixelToView(m_lastUpdatedPoint) - pixelToView(pos)).manhattanLength(); 
         if (updateDistance > 10) {
             m_helper->clearPaint();
             m_longStrokeUpdateCompressor.stop();
             m_strokeUpdateCompressor.start();
             m_lastUpdatedPoint = pos;
         } else if (updateDistance > 1) {
             m_longStrokeUpdateCompressor.start();
         }
     }
 
 
     updateGuideline();
     KisToolPaint::requestUpdateOutline(event->point, event);
 }
 
 void KisToolLine::endPrimaryAction(KoPointerEvent *event)
 {
     Q_UNUSED(event);
+
     CHECK_MODE_SANITY_OR_RETURN(KisTool::PAINT_MODE);
     setMode(KisTool::HOVER_MODE);
-    KisTelemetrySensor sensor(toolId(), KisTelemetryAbstruct::getTimeTicket_, KisTelemetryAbstruct::Use);
 
     updateGuideline();
     endStroke();
 }
 
 void KisToolLine::endStroke()
 {
     NodePaintAbility nodeAbility = nodePaintAbility();
 
     if (!m_strokeIsRunning || m_startPoint == m_endPoint || nodeAbility == NONE) {
         return;
     }
 
     if (nodeAbility == PAINT) {
         updateStroke();
         m_helper->end();
     }
     else {
         KoPathShape* path = new KoPathShape();
         path->setShapeId(KoPathShapeId);
 
         QTransform resolutionMatrix;
         resolutionMatrix.scale(1 / currentImage()->xRes(), 1 / currentImage()->yRes());
         path->moveTo(resolutionMatrix.map(m_startPoint));
         path->lineTo(resolutionMatrix.map(m_endPoint));
         path->normalize();
 
         KoShapeStrokeSP border(new KoShapeStroke(currentStrokeWidth(), currentFgColor().toQColor()));
         path->setStroke(border);
 
         KUndo2Command * cmd = canvas()->shapeController()->addShape(path);
         canvas()->addCommand(cmd);
     }
 
     m_strokeIsRunning = false;
     m_endPoint = m_startPoint;
 }
 
 void KisToolLine::cancelStroke()
 {
     if (!m_strokeIsRunning) return;
     if (m_startPoint == m_endPoint) return;
 
     /**
      * The actual stroke is run by the timer so it is a legal
      * situation when m_strokeIsRunning is true, but the actual redraw
      * stroke is not running.
      */
     if (m_helper->isRunning()) {
         m_helper->cancel();
     }
 
 
     m_strokeIsRunning = false;
     m_endPoint = m_startPoint;
 }
 
 QPointF KisToolLine::straightLine(QPointF point)
 {
     const QPointF lineVector = point - m_startPoint;
     qreal lineAngle = std::atan2(lineVector.y(), lineVector.x());
 
     if (lineAngle < 0) {
         lineAngle += 2 * M_PI;
     }
 
     const qreal ANGLE_BETWEEN_CONSTRAINED_LINES = (2 * M_PI) / 24;
 
     const quint32 constrainedLineIndex = static_cast<quint32>((lineAngle / ANGLE_BETWEEN_CONSTRAINED_LINES) + 0.5);
     const qreal constrainedLineAngle = constrainedLineIndex * ANGLE_BETWEEN_CONSTRAINED_LINES;
 
     const qreal lineLength = std::sqrt((lineVector.x() * lineVector.x()) + (lineVector.y() * lineVector.y()));
 
     const QPointF constrainedLineVector(lineLength * std::cos(constrainedLineAngle), lineLength * std::sin(constrainedLineAngle));
 
     const QPointF result = m_startPoint + constrainedLineVector;
 
     return result;
 }
 
 
 void KisToolLine::updateGuideline()
 {
     if (canvas()) {
         QRectF bound(m_startPoint, m_endPoint);
         canvas()->updateCanvas(convertToPt(bound.normalized().adjusted(-3, -3, 3, 3)));
     }
 }
 
 
 void KisToolLine::paintLine(QPainter& gc, const QRect&)
 {
     QPointF viewStartPos = pixelToView(m_startPoint);
     QPointF viewStartEnd = pixelToView(m_endPoint);
 
     if (m_showGuideline && canvas()) {
         QPainterPath path;
         path.moveTo(viewStartPos);
         path.lineTo(viewStartEnd);
         paintToolOutline(&gc, path);
     }
 }
 
 QString KisToolLine::quickHelp() const
 {
     return i18n("Alt+Drag will move the origin of the currently displayed line around, Shift+Drag will force you to draw straight lines");
 }