diff --git a/CMakeLists.txt b/CMakeLists.txt
index d6e03438..a3281d71 100644
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -1,534 +1,550 @@
 cmake_minimum_required(VERSION 3.2.0)
 project(kphotoalbum VERSION 5.5)
 
 if(POLICY CMP0063)
     cmake_policy(SET CMP0063 NEW)
 endif()
 
 # provide drop-down menu for build-type in cmake-gui:
 set_property(CACHE CMAKE_BUILD_TYPE PROPERTY STRINGS ";Debug;Release;RelWithDebInfo;MinSizeRel")
 
 list(APPEND CMAKE_MODULE_PATH ${CMAKE_CURRENT_SOURCE_DIR}/cmake/modules)
 
 find_package(ECM REQUIRED NO_MODULE)
 list(APPEND CMAKE_MODULE_PATH ${ECM_MODULE_PATH} )
 
 include(KDEInstallDirs)
 include(KDECompilerSettings)
 include(KDECMakeSettings)
 include(FeatureSummary)
 
 # enable exceptions:
 kde_enable_exceptions()
 
 add_definitions(
     -DQT_NO_CAST_FROM_ASCII
     -DQT_NO_CAST_TO_ASCII
     -DQT_NO_URL_CAST_FROM_STRING
     -DQT_NO_CAST_FROM_BYTEARRAY
     -DQT_DEPRECATED_WARNINGS
     )
 
 
 set(CMAKE_CXX_STANDARD 11)
 set(CMAKE_CXX_REQUIRED TRUE)
 
 ########### dependencies  ###############
 
 find_package(Qt5 5.9 REQUIRED COMPONENTS Sql Xml Widgets Network)
 find_package(Phonon4Qt5 REQUIRED)
 find_package(KF5 5.44 REQUIRED COMPONENTS Archive Completion Config CoreAddons DocTools I18n IconThemes JobWidgets KIO TextWidgets XmlGui WidgetsAddons)
 
 find_package(JPEG REQUIRED)
 if(JPEG_FOUND)
     include_directories(${JPEG_INCLUDE_DIR})
 endif()
 
 ### 2018-12-30 jzarl
 # When Exiv2 0.26 can be deprecated, FindExiv2.cmake should be removed
 # and only find_package(exiv2) should be used
 find_package(exiv2 CONFIG QUIET)
 if(exiv2_FOUND)
     # search againg with REQUIRED, so that the feature summary correctly shows exiv as required dependency
     find_package(exiv2 CONFIG REQUIRED)
     set(EXIV2_LIBRARIES exiv2lib)
 else()
     find_package(Exiv2 REQUIRED)
 endif()
 
 find_package(KF5Kipi 5.1.0)
 set_package_properties(KF5Kipi
     PROPERTIES
     TYPE RECOMMENDED
     PURPOSE "Enables integration of KDE image plugin interface (shared functionality between KPhotoAlbum and other apps like gwenview or digikam)"
     )
 set(HASKIPI ${KF5Kipi_FOUND})
 
+find_package(KF5Purpose)
+set_package_properties(KF5Purpose
+    PROPERTIES
+    TYPE RECOMMENDED
+    PURPOSE "Enables integration with KDE Purpose plugins, which provide image sharing and similar functionality."
+    )
+
 find_package(KF5KDcraw)
 set_package_properties(KF5KDcraw
     PROPERTIES
     TYPE OPTIONAL
     PURPOSE "Enables RAW image support"
     )
 set(HAVE_KDCRAW ${KF5KDcraw_FOUND} )
 
 find_package(KF5KGeoMap)
 set_package_properties(KF5KGeoMap
     PROPERTIES
     TYPE OPTIONAL
     PURPOSE "Enables support for geographic map location using embedded GPS information."
     )
 set(HAVE_KGEOMAP ${KF5KGeoMap_FOUND})
 
 add_custom_target(
     UpdateVersion ALL
     COMMAND ${CMAKE_COMMAND}
     -DBASE_DIR=${CMAKE_CURRENT_SOURCE_DIR} -DPROJECT_NAME=KPA -DPROJECT_VERSION="${PROJECT_VERSION}"
     -DCMAKE_BUILD_TYPE="${CMAKE_BUILD_TYPE}" -P "${CMAKE_CURRENT_SOURCE_DIR}/cmake/modules/UpdateVersion.cmake"
     COMMENT "Updating version header."
     BYPRODUCTS "${CMAKE_CURRENT_SOURCE_DIR}/version.h"
     )
 
 # For config-kpa-*.h
 include_directories(${CMAKE_CURRENT_BINARY_DIR})
 
 set(libdatebar_SRCS
     ${CMAKE_CURRENT_SOURCE_DIR}/DateBar/documentation.h
     ${CMAKE_CURRENT_SOURCE_DIR}/DateBar/DateBarWidget.cpp
     ${CMAKE_CURRENT_SOURCE_DIR}/DateBar/ViewHandler.cpp
     ${CMAKE_CURRENT_SOURCE_DIR}/DateBar/MouseHandler.cpp
     ${CMAKE_CURRENT_SOURCE_DIR}/DateBar/MouseHandler.cpp
     )
 
 set(libSettings_SRCS
     ${CMAKE_CURRENT_SOURCE_DIR}/Settings/documentation.h
     ${CMAKE_CURRENT_SOURCE_DIR}/Settings/SettingsData.cpp
     ${CMAKE_CURRENT_SOURCE_DIR}/Settings/SettingsDialog.cpp
     ${CMAKE_CURRENT_SOURCE_DIR}/Settings/ViewerSizeConfig.cpp
     ${CMAKE_CURRENT_SOURCE_DIR}/Settings/CategoryItem.cpp
     ${CMAKE_CURRENT_SOURCE_DIR}/Settings/CategoryPage.cpp
     ${CMAKE_CURRENT_SOURCE_DIR}/Settings/TagGroupsPage.cpp
     ${CMAKE_CURRENT_SOURCE_DIR}/Settings/GeneralPage.cpp
     ${CMAKE_CURRENT_SOURCE_DIR}/Settings/FileVersionDetectionPage.cpp
     ${CMAKE_CURRENT_SOURCE_DIR}/Settings/ThumbnailsPage.cpp
     ${CMAKE_CURRENT_SOURCE_DIR}/Settings/ViewerPage.cpp
     ${CMAKE_CURRENT_SOURCE_DIR}/Settings/DatabaseBackendPage.cpp
     ${CMAKE_CURRENT_SOURCE_DIR}/Settings/UntaggedGroupBox.cpp
     ${CMAKE_CURRENT_SOURCE_DIR}/Settings/CategoriesGroupsWidget.cpp
     ${CMAKE_CURRENT_SOURCE_DIR}/Settings/BirthdayPage.cpp
     ${CMAKE_CURRENT_SOURCE_DIR}/Settings/DateTableWidgetItem.cpp
     ${CMAKE_CURRENT_SOURCE_DIR}/Settings/Logging.cpp
     )
 
 set(libxmldb_SRCS
     ${CMAKE_CURRENT_SOURCE_DIR}/XMLDB/documentation.h
     ${CMAKE_CURRENT_SOURCE_DIR}/XMLDB/Database.cpp
     ${CMAKE_CURRENT_SOURCE_DIR}/XMLDB/XMLCategoryCollection.cpp
     ${CMAKE_CURRENT_SOURCE_DIR}/XMLDB/XMLCategory.cpp
     ${CMAKE_CURRENT_SOURCE_DIR}/XMLDB/XMLImageDateCollection.cpp
     ${CMAKE_CURRENT_SOURCE_DIR}/XMLDB/NumberedBackup.cpp
     ${CMAKE_CURRENT_SOURCE_DIR}/XMLDB/FileReader.cpp
     ${CMAKE_CURRENT_SOURCE_DIR}/XMLDB/FileWriter.cpp
     ${CMAKE_CURRENT_SOURCE_DIR}/XMLDB/ElementWriter.cpp
     ${CMAKE_CURRENT_SOURCE_DIR}/XMLDB/XmlReader.cpp
     ${CMAKE_CURRENT_SOURCE_DIR}/XMLDB/CompressFileInfo.cpp
     ${CMAKE_CURRENT_SOURCE_DIR}/XMLDB/Logging.cpp
     )
 
 set(libThumbnailView_SRCS
     ${CMAKE_CURRENT_SOURCE_DIR}/ThumbnailView/documentation.h
     ${CMAKE_CURRENT_SOURCE_DIR}/ThumbnailView/ThumbnailRequest.cpp
     ${CMAKE_CURRENT_SOURCE_DIR}/ThumbnailView/ThumbnailToolTip.cpp
     ${CMAKE_CURRENT_SOURCE_DIR}/ThumbnailView/ThumbnailWidget.cpp
     ${CMAKE_CURRENT_SOURCE_DIR}/ThumbnailView/GridResizeInteraction.cpp
     ${CMAKE_CURRENT_SOURCE_DIR}/ThumbnailView/GridResizeSlider.cpp
     ${CMAKE_CURRENT_SOURCE_DIR}/ThumbnailView/SelectionInteraction.cpp
     ${CMAKE_CURRENT_SOURCE_DIR}/ThumbnailView/MouseTrackingInteraction.cpp
     ${CMAKE_CURRENT_SOURCE_DIR}/ThumbnailView/CellGeometry.cpp
     ${CMAKE_CURRENT_SOURCE_DIR}/ThumbnailView/ThumbnailModel.cpp
     ${CMAKE_CURRENT_SOURCE_DIR}/ThumbnailView/ThumbnailFacade.cpp
     ${CMAKE_CURRENT_SOURCE_DIR}/ThumbnailView/ThumbnailComponent.cpp
     ${CMAKE_CURRENT_SOURCE_DIR}/ThumbnailView/KeyboardEventHandler.cpp
     ${CMAKE_CURRENT_SOURCE_DIR}/ThumbnailView/ThumbnailDND.cpp
     ${CMAKE_CURRENT_SOURCE_DIR}/ThumbnailView/Delegate.cpp
     ${CMAKE_CURRENT_SOURCE_DIR}/ThumbnailView/SelectionMaintainer.cpp
     ${CMAKE_CURRENT_SOURCE_DIR}/ThumbnailView/VideoThumbnailCycler.cpp
     ${CMAKE_CURRENT_SOURCE_DIR}/ThumbnailView/Logging.cpp
     ${CMAKE_CURRENT_SOURCE_DIR}/ThumbnailView/MouseInteraction.cpp
     ${CMAKE_CURRENT_SOURCE_DIR}/ThumbnailView/ThumbnailFactory.cpp
     ${CMAKE_CURRENT_SOURCE_DIR}/ThumbnailView/enums.cpp
     )
 
-set(libPlugins_SRCS)
+set(libPlugins_SRCS
+    ${CMAKE_CURRENT_SOURCE_DIR}/Plugins/documentation.h
+    ${CMAKE_CURRENT_SOURCE_DIR}/Plugins/Logging.cpp
+    )
 if(KF5Kipi_FOUND)
-    set(libPlugins_SRCS
-        ${CMAKE_CURRENT_SOURCE_DIR}/Plugins/documentation.h
+    set(libPlugins_SRCS ${libPlugins_SRCS}
         ${CMAKE_CURRENT_SOURCE_DIR}/Plugins/Interface.cpp
         ${CMAKE_CURRENT_SOURCE_DIR}/Plugins/ImageCollection.cpp
         ${CMAKE_CURRENT_SOURCE_DIR}/Plugins/ImageInfo.cpp
         ${CMAKE_CURRENT_SOURCE_DIR}/Plugins/CategoryImageCollection.cpp
         ${CMAKE_CURRENT_SOURCE_DIR}/Plugins/ImageCollectionSelector.cpp
         ${CMAKE_CURRENT_SOURCE_DIR}/Settings/PluginsPage.cpp
         ${CMAKE_CURRENT_SOURCE_DIR}/Plugins/UploadWidget.cpp
         ${CMAKE_CURRENT_SOURCE_DIR}/Plugins/UploadImageCollection.cpp
-        ${CMAKE_CURRENT_SOURCE_DIR}/Plugins/Logging.cpp
+        )
+endif()
+if(KF5Purpose_FOUND)
+    set(libPlugins_SRCS ${libPlugins_SRCS}
+        ${CMAKE_CURRENT_SOURCE_DIR}/Plugins/PurposeMenu.cpp
         )
 endif()
 
 set(libViewer_SRCS
     ${CMAKE_CURRENT_SOURCE_DIR}/Viewer/documentation.h
     ${CMAKE_CURRENT_SOURCE_DIR}/Viewer/ViewerWidget.cpp
     ${CMAKE_CURRENT_SOURCE_DIR}/Viewer/ImageDisplay.cpp
     ${CMAKE_CURRENT_SOURCE_DIR}/Viewer/ViewHandler.cpp
     ${CMAKE_CURRENT_SOURCE_DIR}/Viewer/SpeedDisplay.cpp
     ${CMAKE_CURRENT_SOURCE_DIR}/Viewer/InfoBox.cpp
     ${CMAKE_CURRENT_SOURCE_DIR}/Viewer/CategoryImageConfig.cpp
     ${CMAKE_CURRENT_SOURCE_DIR}/Viewer/AbstractDisplay.cpp
     ${CMAKE_CURRENT_SOURCE_DIR}/Viewer/VideoDisplay.cpp
     ${CMAKE_CURRENT_SOURCE_DIR}/Viewer/TextDisplay.cpp
     ${CMAKE_CURRENT_SOURCE_DIR}/Viewer/InfoBoxResizer.cpp
     ${CMAKE_CURRENT_SOURCE_DIR}/Viewer/VisibleOptionsMenu.cpp
     ${CMAKE_CURRENT_SOURCE_DIR}/Viewer/VideoShooter.cpp
     ${CMAKE_CURRENT_SOURCE_DIR}/Viewer/TaggedArea.cpp
     ${CMAKE_CURRENT_SOURCE_DIR}/Viewer/Logging.cpp
     )
 
 set(libCategoryListView_SRCS
     ${CMAKE_CURRENT_SOURCE_DIR}/CategoryListView/documentation.h
     ${CMAKE_CURRENT_SOURCE_DIR}/CategoryListView/DragableTreeWidget.cpp
     ${CMAKE_CURRENT_SOURCE_DIR}/CategoryListView/CheckDropItem.cpp
     ${CMAKE_CURRENT_SOURCE_DIR}/CategoryListView/DragItemInfo.cpp
     ${CMAKE_CURRENT_SOURCE_DIR}/CategoryListView/Logging.cpp
     )
 
 set(libHTMLGenerator_SRCS
     ${CMAKE_CURRENT_SOURCE_DIR}/HTMLGenerator/documentation.h
     ${CMAKE_CURRENT_SOURCE_DIR}/HTMLGenerator/HTMLDialog.cpp
     ${CMAKE_CURRENT_SOURCE_DIR}/HTMLGenerator/Generator.cpp
     ${CMAKE_CURRENT_SOURCE_DIR}/HTMLGenerator/Setup.cpp
     ${CMAKE_CURRENT_SOURCE_DIR}/HTMLGenerator/ImageSizeCheckBox.h
     ${CMAKE_CURRENT_SOURCE_DIR}/HTMLGenerator/Logging.cpp
     ${CMAKE_CURRENT_SOURCE_DIR}/HTMLGenerator/ImageSizeCheckBox.cpp
     )
 
 set(libUtilities_SRCS
     ${CMAKE_CURRENT_SOURCE_DIR}/Utilities/documentation.h
     ${CMAKE_CURRENT_SOURCE_DIR}/Utilities/AlgorithmHelper.cpp
     ${CMAKE_CURRENT_SOURCE_DIR}/Utilities/ShowBusyCursor.cpp
     ${CMAKE_CURRENT_SOURCE_DIR}/Utilities/List.cpp
     ${CMAKE_CURRENT_SOURCE_DIR}/Utilities/UniqFilenameMapper.cpp
     ${CMAKE_CURRENT_SOURCE_DIR}/Utilities/FileUtil.cpp
     ${CMAKE_CURRENT_SOURCE_DIR}/Utilities/BooleanGuard.cpp
     ${CMAKE_CURRENT_SOURCE_DIR}/Utilities/Process.cpp
     ${CMAKE_CURRENT_SOURCE_DIR}/Utilities/DeleteFiles.cpp
     ${CMAKE_CURRENT_SOURCE_DIR}/Utilities/ToolTip.cpp
     ${CMAKE_CURRENT_SOURCE_DIR}/Utilities/Logging.cpp
     ${CMAKE_CURRENT_SOURCE_DIR}/Utilities/JpeglibWithFix.cpp
     ${CMAKE_CURRENT_SOURCE_DIR}/Utilities/StringSet.cpp
     ${CMAKE_CURRENT_SOURCE_DIR}/Utilities/FastJpeg.cpp
     ${CMAKE_CURRENT_SOURCE_DIR}/Utilities/DemoUtil.cpp
     ${CMAKE_CURRENT_SOURCE_DIR}/Utilities/DescriptionUtil.cpp
     ${CMAKE_CURRENT_SOURCE_DIR}/Utilities/FileNameUtil.cpp
     ${CMAKE_CURRENT_SOURCE_DIR}/Utilities/VideoUtil.cpp
     ${CMAKE_CURRENT_SOURCE_DIR}/Utilities/ImageUtil.cpp
     )
 
 set(libMainWindow_SRCS
     ${CMAKE_CURRENT_SOURCE_DIR}/MainWindow/documentation.h
     ${CMAKE_CURRENT_SOURCE_DIR}/MainWindow/DeleteDialog.cpp
     ${CMAKE_CURRENT_SOURCE_DIR}/MainWindow/RunDialog.cpp
     ${CMAKE_CURRENT_SOURCE_DIR}/MainWindow/FeatureDialog.cpp
     ${CMAKE_CURRENT_SOURCE_DIR}/MainWindow/InvalidDateFinder.cpp
     ${CMAKE_CURRENT_SOURCE_DIR}/MainWindow/AutoStackImages.cpp
     ${CMAKE_CURRENT_SOURCE_DIR}/MainWindow/TokenEditor.cpp
     ${CMAKE_CURRENT_SOURCE_DIR}/MainWindow/WelcomeDialog.cpp
     ${CMAKE_CURRENT_SOURCE_DIR}/MainWindow/Window.cpp
     ${CMAKE_CURRENT_SOURCE_DIR}/MainWindow/SplashScreen.cpp
     ${CMAKE_CURRENT_SOURCE_DIR}/MainWindow/ExternalPopup.cpp
     ${CMAKE_CURRENT_SOURCE_DIR}/MainWindow/CategoryImagePopup.cpp
     ${CMAKE_CURRENT_SOURCE_DIR}/MainWindow/SearchBar.cpp
     ${CMAKE_CURRENT_SOURCE_DIR}/MainWindow/ImageCounter.cpp
     ${CMAKE_CURRENT_SOURCE_DIR}/MainWindow/DirtyIndicator.cpp
     ${CMAKE_CURRENT_SOURCE_DIR}/MainWindow/StatisticsDialog.cpp
     ${CMAKE_CURRENT_SOURCE_DIR}/MainWindow/BreadcrumbViewer.cpp
     ${CMAKE_CURRENT_SOURCE_DIR}/MainWindow/StatusBar.cpp
     ${CMAKE_CURRENT_SOURCE_DIR}/MainWindow/UpdateVideoThumbnail.cpp
     ${CMAKE_CURRENT_SOURCE_DIR}/MainWindow/DuplicateMerger/DuplicateMerger.cpp
     ${CMAKE_CURRENT_SOURCE_DIR}/MainWindow/DuplicateMerger/DuplicateMatch.cpp
     ${CMAKE_CURRENT_SOURCE_DIR}/MainWindow/DuplicateMerger/MergeToolTip.cpp
     ${CMAKE_CURRENT_SOURCE_DIR}/MainWindow/CopyPopup.cpp
     ${CMAKE_CURRENT_SOURCE_DIR}/MainWindow/Options.cpp
     ${CMAKE_CURRENT_SOURCE_DIR}/MainWindow/Logging.cpp
     )
 
 set(libImageManager_SRCS
     ${CMAKE_CURRENT_SOURCE_DIR}/ImageManager/documentation.h
     ${CMAKE_CURRENT_SOURCE_DIR}/ImageManager/ImageLoaderThread.cpp
     ${CMAKE_CURRENT_SOURCE_DIR}/ImageManager/AsyncLoader.cpp
     ${CMAKE_CURRENT_SOURCE_DIR}/ImageManager/ImageRequest.cpp
     ${CMAKE_CURRENT_SOURCE_DIR}/ImageManager/ImageClientInterface.cpp
     ${CMAKE_CURRENT_SOURCE_DIR}/ImageManager/ImageDecoder.cpp
     ${CMAKE_CURRENT_SOURCE_DIR}/ImageManager/RawImageDecoder.cpp
     ${CMAKE_CURRENT_SOURCE_DIR}/ImageManager/RequestQueue.cpp
     ${CMAKE_CURRENT_SOURCE_DIR}/ImageManager/ThumbnailCache.cpp
     ${CMAKE_CURRENT_SOURCE_DIR}/ImageManager/ImageEvent.cpp
     ${CMAKE_CURRENT_SOURCE_DIR}/ImageManager/ThumbnailBuilder.cpp
     ${CMAKE_CURRENT_SOURCE_DIR}/ImageManager/PreloadRequest.cpp
     ${CMAKE_CURRENT_SOURCE_DIR}/ImageManager/CancelEvent.cpp
     ${CMAKE_CURRENT_SOURCE_DIR}/ImageManager/VideoImageRescaleRequest.cpp
     ${CMAKE_CURRENT_SOURCE_DIR}/ImageManager/VideoThumbnails.cpp
     ${CMAKE_CURRENT_SOURCE_DIR}/ImageManager/VideoLengthExtractor.cpp
     ${CMAKE_CURRENT_SOURCE_DIR}/ImageManager/ExtractOneVideoFrame.cpp
     ${CMAKE_CURRENT_SOURCE_DIR}/ImageManager/Logging.cpp
     ${CMAKE_CURRENT_SOURCE_DIR}/ImageManager/CacheFileInfo.cpp
     ${CMAKE_CURRENT_SOURCE_DIR}/ImageManager/enums.cpp
     )
 
 set(libDB_SRCS
     ${CMAKE_CURRENT_SOURCE_DIR}/DB/documentation.h
     ${CMAKE_CURRENT_SOURCE_DIR}/DB/ImageInfo.cpp
     ${CMAKE_CURRENT_SOURCE_DIR}/DB/Category.cpp
     ${CMAKE_CURRENT_SOURCE_DIR}/DB/CategoryCollection.cpp
     ${CMAKE_CURRENT_SOURCE_DIR}/DB/ExactCategoryMatcher.cpp
     ${CMAKE_CURRENT_SOURCE_DIR}/DB/ImageDate.cpp
     ${CMAKE_CURRENT_SOURCE_DIR}/DB/MD5Map.cpp
     ${CMAKE_CURRENT_SOURCE_DIR}/DB/MemberMap.cpp
     ${CMAKE_CURRENT_SOURCE_DIR}/DB/ImageInfoList.cpp
     ${CMAKE_CURRENT_SOURCE_DIR}/DB/ImageDB.cpp
     ${CMAKE_CURRENT_SOURCE_DIR}/DB/FileInfo.cpp
     ${CMAKE_CURRENT_SOURCE_DIR}/DB/NegationCategoryMatcher.cpp
     ${CMAKE_CURRENT_SOURCE_DIR}/DB/NewImageFinder.cpp
     ${CMAKE_CURRENT_SOURCE_DIR}/DB/ImageScout.cpp
     ${CMAKE_CURRENT_SOURCE_DIR}/DB/NoTagCategoryMatcher.cpp
     ${CMAKE_CURRENT_SOURCE_DIR}/DB/GroupCounter.cpp
     ${CMAKE_CURRENT_SOURCE_DIR}/DB/CategoryMatcher.cpp
     ${CMAKE_CURRENT_SOURCE_DIR}/DB/ImageSearchInfo.cpp
     ${CMAKE_CURRENT_SOURCE_DIR}/DB/CategoryItem.cpp
     ${CMAKE_CURRENT_SOURCE_DIR}/DB/ContainerCategoryMatcher.cpp
     ${CMAKE_CURRENT_SOURCE_DIR}/DB/ValueCategoryMatcher.cpp
     ${CMAKE_CURRENT_SOURCE_DIR}/DB/OrCategoryMatcher.cpp
     ${CMAKE_CURRENT_SOURCE_DIR}/DB/AndCategoryMatcher.cpp
     ${CMAKE_CURRENT_SOURCE_DIR}/DB/FastDir.cpp
     ${CMAKE_CURRENT_SOURCE_DIR}/DB/OptimizedFileList.cpp
     ${CMAKE_CURRENT_SOURCE_DIR}/DB/FileName.cpp
     ${CMAKE_CURRENT_SOURCE_DIR}/DB/FileNameList.cpp
     ${CMAKE_CURRENT_SOURCE_DIR}/DB/Logging.cpp
     ${CMAKE_CURRENT_SOURCE_DIR}/DB/CategoryPtr.cpp
     ${CMAKE_CURRENT_SOURCE_DIR}/DB/ExifMode.cpp
     ${CMAKE_CURRENT_SOURCE_DIR}/DB/ImageDateCollection.cpp
     ${CMAKE_CURRENT_SOURCE_DIR}/DB/ImageInfoPtr.cpp
     ${CMAKE_CURRENT_SOURCE_DIR}/DB/MD5.cpp
     ${CMAKE_CURRENT_SOURCE_DIR}/DB/MediaCount.cpp
     ${CMAKE_CURRENT_SOURCE_DIR}/DB/RawId.cpp
     ${CMAKE_CURRENT_SOURCE_DIR}/DB/SimpleCategoryMatcher.cpp
     ${CMAKE_CURRENT_SOURCE_DIR}/DB/UIDelegate.cpp
     )
 
 set(libImportExport_SRCS
     ${CMAKE_CURRENT_SOURCE_DIR}/ImportExport/documentation.h
     ${CMAKE_CURRENT_SOURCE_DIR}/ImportExport/Export.cpp
     ${CMAKE_CURRENT_SOURCE_DIR}/ImportExport/Import.cpp
     ${CMAKE_CURRENT_SOURCE_DIR}/ImportExport/ImportMatcher.cpp
     ${CMAKE_CURRENT_SOURCE_DIR}/ImportExport/XMLHandler.cpp
     ${CMAKE_CURRENT_SOURCE_DIR}/ImportExport/MiniViewer.cpp
     ${CMAKE_CURRENT_SOURCE_DIR}/ImportExport/ImportHandler.cpp
     ${CMAKE_CURRENT_SOURCE_DIR}/ImportExport/ImageRow.cpp
     ${CMAKE_CURRENT_SOURCE_DIR}/ImportExport/ImportDialog.cpp
     ${CMAKE_CURRENT_SOURCE_DIR}/ImportExport/ImportSettings.cpp
     ${CMAKE_CURRENT_SOURCE_DIR}/ImportExport/KimFileReader.cpp
     ${CMAKE_CURRENT_SOURCE_DIR}/ImportExport/MD5CheckPage.cpp
     ${CMAKE_CURRENT_SOURCE_DIR}/ImportExport/Logging.cpp
     )
 
 set(libAnnotationDialog_SRCS
     ${CMAKE_CURRENT_SOURCE_DIR}/AnnotationDialog/documentation.h
     ${CMAKE_CURRENT_SOURCE_DIR}/AnnotationDialog/Dialog.cpp
     ${CMAKE_CURRENT_SOURCE_DIR}/AnnotationDialog/ListSelect.cpp
     ${CMAKE_CURRENT_SOURCE_DIR}/AnnotationDialog/ImagePreview.cpp
     ${CMAKE_CURRENT_SOURCE_DIR}/AnnotationDialog/ImagePreviewWidget.cpp
     ${CMAKE_CURRENT_SOURCE_DIR}/AnnotationDialog/DateEdit.cpp
     ${CMAKE_CURRENT_SOURCE_DIR}/AnnotationDialog/CompletableLineEdit.cpp
     ${CMAKE_CURRENT_SOURCE_DIR}/AnnotationDialog/ListViewItemHider.cpp
     ${CMAKE_CURRENT_SOURCE_DIR}/AnnotationDialog/ShowSelectionOnlyManager.cpp
     ${CMAKE_CURRENT_SOURCE_DIR}/AnnotationDialog/ShortCutManager.cpp
     ${CMAKE_CURRENT_SOURCE_DIR}/AnnotationDialog/ResizableFrame.cpp
     ${CMAKE_CURRENT_SOURCE_DIR}/AnnotationDialog/DescriptionEdit.cpp
     ${CMAKE_CURRENT_SOURCE_DIR}/AnnotationDialog/AreaTagSelectDialog.cpp
     ${CMAKE_CURRENT_SOURCE_DIR}/AnnotationDialog/Logging.cpp
     ${CMAKE_CURRENT_SOURCE_DIR}/AnnotationDialog/enums.cpp
     )
 
 set(libBrowser_SRCS
     ${CMAKE_CURRENT_SOURCE_DIR}/Browser/documentation.h
     ${CMAKE_CURRENT_SOURCE_DIR}/Browser/BrowserWidget.cpp
     ${CMAKE_CURRENT_SOURCE_DIR}/Browser/BrowserPage.cpp
     ${CMAKE_CURRENT_SOURCE_DIR}/Browser/OverviewPage.cpp
     ${CMAKE_CURRENT_SOURCE_DIR}/Browser/CategoryPage.cpp
     ${CMAKE_CURRENT_SOURCE_DIR}/Browser/ImageViewPage.cpp
     ${CMAKE_CURRENT_SOURCE_DIR}/Browser/TreeFilter.cpp
     ${CMAKE_CURRENT_SOURCE_DIR}/Browser/Breadcrumb.cpp
     ${CMAKE_CURRENT_SOURCE_DIR}/Browser/BreadcrumbList.cpp
     ${CMAKE_CURRENT_SOURCE_DIR}/Browser/AbstractCategoryModel.cpp
     ${CMAKE_CURRENT_SOURCE_DIR}/Browser/FlatCategoryModel.cpp
     ${CMAKE_CURRENT_SOURCE_DIR}/Browser/TreeCategoryModel.cpp
     ${CMAKE_CURRENT_SOURCE_DIR}/Browser/CenteringIconView.cpp
     ${CMAKE_CURRENT_SOURCE_DIR}/Browser/Logging.cpp
     ${CMAKE_CURRENT_SOURCE_DIR}/Browser/enums.cpp
     )
 
 set(libExif_SRCS
     ${CMAKE_CURRENT_SOURCE_DIR}/Exif/documentation.h
     ${CMAKE_CURRENT_SOURCE_DIR}/Exif/Database.cpp
     ${CMAKE_CURRENT_SOURCE_DIR}/Exif/InfoDialog.cpp
     ${CMAKE_CURRENT_SOURCE_DIR}/Exif/SearchDialog.cpp
     ${CMAKE_CURRENT_SOURCE_DIR}/Exif/SearchInfo.cpp
     ${CMAKE_CURRENT_SOURCE_DIR}/Exif/TreeView.cpp
     ${CMAKE_CURRENT_SOURCE_DIR}/Exif/Info.cpp
     ${CMAKE_CURRENT_SOURCE_DIR}/Exif/RangeWidget.cpp
     ${CMAKE_CURRENT_SOURCE_DIR}/Exif/DatabaseElement.cpp
     ${CMAKE_CURRENT_SOURCE_DIR}/Exif/ReReadDialog.cpp
     ${CMAKE_CURRENT_SOURCE_DIR}/Exif/Grid.cpp
     ${CMAKE_CURRENT_SOURCE_DIR}/Exif/Logging.cpp
     ${CMAKE_CURRENT_SOURCE_DIR}/Exif/SearchDialogSettings.cpp
     ${CMAKE_CURRENT_SOURCE_DIR}/Settings/ExifPage.cpp
     )
 
 set(libBackgroundTaskManager_SRCS
     ${CMAKE_CURRENT_SOURCE_DIR}/BackgroundTaskManager/JobInterface.cpp
     ${CMAKE_CURRENT_SOURCE_DIR}/BackgroundTaskManager/JobManager.cpp
     ${CMAKE_CURRENT_SOURCE_DIR}/BackgroundTaskManager/StatusIndicator.cpp
     ${CMAKE_CURRENT_SOURCE_DIR}/BackgroundTaskManager/JobViewer.cpp
     ${CMAKE_CURRENT_SOURCE_DIR}/BackgroundTaskManager/JobModel.cpp
     ${CMAKE_CURRENT_SOURCE_DIR}/BackgroundTaskManager/JobInfo.cpp
     ${CMAKE_CURRENT_SOURCE_DIR}/BackgroundTaskManager/CompletedJobInfo.cpp
     ${CMAKE_CURRENT_SOURCE_DIR}/BackgroundTaskManager/Priority.cpp
     ${CMAKE_CURRENT_SOURCE_DIR}/BackgroundTaskManager/PriorityQueue.cpp
     ${CMAKE_CURRENT_SOURCE_DIR}/BackgroundTaskManager/Logging.cpp
     )
 
 set(libBackgroundJobs_SRCS
     ${CMAKE_CURRENT_SOURCE_DIR}/BackgroundJobs/SearchForVideosWithoutLengthInfo.cpp
     ${CMAKE_CURRENT_SOURCE_DIR}/BackgroundJobs/ReadVideoLengthJob.cpp
     ${CMAKE_CURRENT_SOURCE_DIR}/BackgroundJobs/SearchForVideosWithoutVideoThumbnailsJob.cpp
     ${CMAKE_CURRENT_SOURCE_DIR}/BackgroundJobs/HandleVideoThumbnailRequestJob.cpp
     ${CMAKE_CURRENT_SOURCE_DIR}/BackgroundJobs/ExtractOneThumbnailJob.cpp
     )
 
 set(libRemoteControl_SRCS
     ${CMAKE_CURRENT_SOURCE_DIR}/RemoteControl/RemoteCommand.cpp
     ${CMAKE_CURRENT_SOURCE_DIR}/RemoteControl/RemoteConnection.cpp
     ${CMAKE_CURRENT_SOURCE_DIR}/RemoteControl/Server.cpp
     ${CMAKE_CURRENT_SOURCE_DIR}/RemoteControl/RemoteInterface.cpp
     ${CMAKE_CURRENT_SOURCE_DIR}/RemoteControl/SearchInfo.cpp
     ${CMAKE_CURRENT_SOURCE_DIR}/RemoteControl/RemoteImageRequest.cpp
     ${CMAKE_CURRENT_SOURCE_DIR}/RemoteControl/ImageNameStore.cpp
     ${CMAKE_CURRENT_SOURCE_DIR}/RemoteControl/ConnectionIndicator.cpp
     ${CMAKE_CURRENT_SOURCE_DIR}/RemoteControl/Logging.cpp
     )
 
 set(libMap_SRCS)
 if(KF5KGeoMap_FOUND)
     set(libMap_SRCS
         ${CMAKE_CURRENT_SOURCE_DIR}/Browser/GeoPositionPage.cpp
         ${CMAKE_CURRENT_SOURCE_DIR}/Browser/PositionBrowserWidget.cpp
         ${CMAKE_CURRENT_SOURCE_DIR}/Map/MapView.cpp
         ${CMAKE_CURRENT_SOURCE_DIR}/Map/MapMarkerModelHelper.cpp
         ${CMAKE_CURRENT_SOURCE_DIR}/Map/SearchMarkerTiler.cpp
         ${CMAKE_CURRENT_SOURCE_DIR}/Map/Logging.cpp
         )
 endif()
 
 add_subdirectory(images)
 add_subdirectory(icons)
 add_subdirectory(demo)
 add_subdirectory(themes)
 add_subdirectory(scripts)
 add_subdirectory(doc)
 
 
 ########### next target ###############
 
 set(kphotoalbum_SRCS
     main.cpp
     ${libdatebar_SRCS}
     ${libSettings_SRCS}
     ${libsurvey_SRCS}
     ${libxmldb_SRCS}
     ${libThumbnailView_SRCS}
     ${libPlugins_SRCS}
     ${libViewer_SRCS}
     ${libCategoryListView_SRCS}
     ${libHTMLGenerator_SRCS}
     ${libMainWindow_SRCS}
     ${libImageManager_SRCS}
     ${libDB_SRCS}
     ${libImportExport_SRCS}
     ${libAnnotationDialog_SRCS}
     ${libExif_SRCS}
     ${libBrowser_SRCS}
     ${libBackgroundTaskManager_SRCS}
     ${libBackgroundJobs_SRCS}
     ${libRemoteControl_SRCS}
     ${libMap_SRCS}
     ${libUtilities_SRCS}
     # add doxygen headers so that they get visibiltiy in IDEs:
     ${CMAKE_CURRENT_SOURCE_DIR}/documentation/coding-standards.h
     ${CMAKE_CURRENT_SOURCE_DIR}/documentation/mainpage.h
     ${CMAKE_CURRENT_SOURCE_DIR}/documentation/phrase-book.h
     ${CMAKE_CURRENT_SOURCE_DIR}/documentation/videothumbnails.h
     )
 
 add_executable(kphotoalbum ${kphotoalbum_SRCS})
 add_dependencies(kphotoalbum UpdateVersion)
 
 # External components
 target_link_libraries(kphotoalbum
     ${JPEG_LIBRARY}
     ${EXIV2_LIBRARIES}
     KF5::Archive
     KF5::Completion
     KF5::ConfigCore
     KF5::ConfigGui
     KF5::CoreAddons
     KF5::I18n
     KF5::IconThemes
     KF5::JobWidgets
     KF5::KIOCore
     KF5::KIOWidgets
     KF5::TextWidgets
     KF5::XmlGui
     KF5::WidgetsAddons
     Phonon::phonon4qt5
     Qt5::Network
     Qt5::Sql
     )
 
 if(KF5Kipi_FOUND)
     target_link_libraries(kphotoalbum KF5::Kipi)
 endif()
+if(KF5Purpose_FOUND)
+    target_link_libraries(kphotoalbum KF5::Purpose KF5::PurposeWidgets)
+endif()
 
 if(KF5KDcraw_FOUND)
     target_link_libraries(kphotoalbum KF5::KDcraw)
 endif()
 
 if(KF5KGeoMap_FOUND)
     target_link_libraries(kphotoalbum KF5::KGeoMap )
 endif()
 
 install(TARGETS kphotoalbum ${KDE_INSTALL_TARGETS_DEFAULT_ARGS})
 
 ########### install files ###############
 
 install(PROGRAMS org.kde.kphotoalbum.desktop org.kde.kphotoalbum-import.desktop DESTINATION ${KDE_INSTALL_APPDIR})
 install(FILES kphotoalbumrc DESTINATION ${KDE_INSTALL_CONFDIR})
 install(FILES tips default-setup DESTINATION ${KDE_INSTALL_DATADIR}/kphotoalbum)
 install(FILES kphotoalbumui.rc DESTINATION ${KDE_INSTALL_KXMLGUI5DIR}/kphotoalbum)
 install(FILES org.kde.kphotoalbum.appdata.xml DESTINATION ${KDE_INSTALL_METAINFODIR})
 
 configure_file(config-kpa-kdcraw.h.cmake ${CMAKE_CURRENT_BINARY_DIR}/config-kpa-kdcraw.h)
 configure_file(config-kpa-kipi.h.cmake ${CMAKE_CURRENT_BINARY_DIR}/config-kpa-kipi.h)
 configure_file(config-kpa-kgeomap.h.cmake ${CMAKE_CURRENT_BINARY_DIR}/config-kpa-kgeomap.h)
 
 feature_summary(WHAT ALL FATAL_ON_MISSING_REQUIRED_PACKAGES)
 
 # vi:expandtab:tabstop=4 shiftwidth=4:
diff --git a/DB/FileName.cpp b/DB/FileName.cpp
index d0469951..29c73b1c 100644
--- a/DB/FileName.cpp
+++ b/DB/FileName.cpp
@@ -1,103 +1,108 @@
 /* Copyright 2012 Jesper K. Pedersen <blackie@kde.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) version 3 or any later version
    accepted by the membership of KDE e.V. (or its successor approved
    by the membership of KDE e.V.), which shall act as a proxy
    defined in Section 14 of version 3 of the license.
 
    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, see <http://www.gnu.org/licenses/>.
 */
 
 #include "FileName.h"
 #include "ImageDB.h"
 
 #include <DB/ImageInfoList.h>
 #include <Utilities/FileNameUtil.h>
 #include <Settings/SettingsData.h>
 
 #include <QFile>
 
 DB::FileName::FileName()
     : m_isNull(true)
 {
 }
 
 DB::FileName DB::FileName::fromAbsolutePath(const QString &fileName)
 {
     const QString imageRoot = Utilities::stripEndingForwardSlash( Settings::SettingsData::instance()->imageDirectory() ) + QLatin1String("/");
     if (!fileName.startsWith(imageRoot))
         return FileName();
 
     FileName res;
     res.m_isNull = false;
     res.m_absoluteFilePath = fileName;
     res.m_relativePath = fileName.mid(imageRoot.length());
     return res;
 }
 
 DB::FileName DB::FileName::fromRelativePath(const QString &fileName)
 {
     Q_ASSERT(!fileName.startsWith(QChar::fromLatin1('/')));
     FileName res;
     res.m_isNull = false;
     res.m_relativePath = fileName;
     res.m_absoluteFilePath = Utilities::stripEndingForwardSlash( Settings::SettingsData::instance()->imageDirectory() ) + QLatin1String("/") + fileName;
     return res;
 }
 
 QString DB::FileName::absolute() const
 {
     Q_ASSERT(!isNull());
     return m_absoluteFilePath;
 }
 
 QString DB::FileName::relative() const
 {
     Q_ASSERT(!m_isNull);
     return m_relativePath;
 }
 
 bool DB::FileName::isNull() const
 {
     return m_isNull;
 }
 
 bool DB::FileName::operator ==(const DB::FileName &other) const
 {
     return m_isNull == other.m_isNull && m_relativePath == other.m_relativePath;
 }
 
 bool DB::FileName::operator !=(const DB::FileName &other) const
 {
     return !(*this == other);
 }
 
 bool DB::FileName::operator <(const DB::FileName &other) const
 {
     return relative() < other.relative();
 }
 
 bool DB::FileName::exists() const
 {
     return QFile::exists(absolute());
 }
 
 DB::ImageInfoPtr DB::FileName::info() const
 {
     return ImageDB::instance()->info(*this);
 }
 
+DB::FileName::operator QUrl() const
+{
+    return QUrl::fromLocalFile(absolute());
+}
+
 uint DB::qHash( const DB::FileName& fileName )
 {
     return qHash(fileName.relative());
 }
 // vi:expandtab:tabstop=4 shiftwidth=4:
diff --git a/DB/FileName.h b/DB/FileName.h
index 5ade91c9..09fd3724 100644
--- a/DB/FileName.h
+++ b/DB/FileName.h
@@ -1,62 +1,68 @@
 /* Copyright 2012 Jesper K. Pedersen <blackie@kde.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) version 3 or any later version
    accepted by the membership of KDE e.V. (or its successor approved
    by the membership of KDE e.V.), which shall act as a proxy
    defined in Section 14 of version 3 of the license.
 
    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, see <http://www.gnu.org/licenses/>.
 */
 
 #ifndef FILENAME_H
 #define FILENAME_H
 
 #include <QString>
 #include <QSet>
+#include <QUrl>
 #include "ImageInfoPtr.h"
 #include <QtCore/qmetatype.h>
 
 namespace DB
 {
 
 class FileName
 {
 public:
     FileName();
     static FileName fromAbsolutePath( const QString& fileName );
     static FileName fromRelativePath( const QString& fileName );
     QString absolute() const;
     QString relative() const;
     bool isNull() const;
     bool operator==( const FileName& other ) const;
     bool operator!=( const FileName& other ) const;
     bool operator<( const FileName& other ) const;
     bool exists() const;
     ImageInfoPtr info() const;
 
+    /**
+     * @brief Conversion to absolute local file url.
+     */
+    explicit operator QUrl() const;
+
 private:
     // During previous profilation it showed that converting between absolute and relative took quite some time,
     // so to avoid that, I store both.
     QString m_relativePath;
     QString m_absoluteFilePath;
     bool m_isNull;
 };
 
 uint qHash( const DB::FileName& fileName );
 typedef QSet<DB::FileName> FileNameSet;
 }
 
 Q_DECLARE_METATYPE(DB::FileName)
 
 
 #endif // FILENAME_H
 // vi:expandtab:tabstop=4 shiftwidth=4:
diff --git a/MainWindow/Window.cpp b/MainWindow/Window.cpp
index 266dc202..128d3315 100644
--- a/MainWindow/Window.cpp
+++ b/MainWindow/Window.cpp
@@ -1,1998 +1,2025 @@
 /* Copyright (C) 2003-2019 The KPhotoAlbum Development Team
 
    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; see the file COPYING.  If not, write to
    the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
    Boston, MA 02110-1301, USA.
 */
 
 #include <config-kpa-kipi.h>
 #include "Window.h"
 
 #include <stdexcept>
 #ifdef HAVE_STDLIB_H
 #  include <stdlib.h>
 #endif
 
 #include <QApplication>
 #include <QClipboard>
 #include <QCloseEvent>
 #include <QContextMenuEvent>
 #include <QCursor>
 #include <QElapsedTimer>
 #include <QDir>
 #include <QFrame>
 #include <QInputDialog>
 #include <QLayout>
 #include <QLoggingCategory>
 #include <QMenu>
 #include <QMessageBox>
 #include <QMimeData>
 #include <QMoveEvent>
 #include <QObject>
 #include <QResizeEvent>
 #include <QStackedWidget>
 #include <QTimer>
 #include <QVBoxLayout>
 #include <QDesktopServices>
 
 #include <KActionCollection>
 #include <KActionMenu>
 #include <KEditToolBar>
 #include <kio_version.h> // for #if KIO_VERSION...
 #include <KIconLoader>
 #include <KLocalizedString>
 #include <KMessageBox>
 #include <KPasswordDialog>
 #include <KProcess>
 #include <KSharedConfig>
 #include <KShortcutsDialog>
 #include <KStandardAction>
 #include <ktip.h>
 #include <KToggleAction>
 #include <KConfigGroup>
 
 #ifdef HASKIPI
 #  include <KIPI/PluginLoader>
 #  include <KIPI/Plugin>
 #endif
 
 #include <AnnotationDialog/Dialog.h>
 #include <BackgroundJobs/SearchForVideosWithoutLengthInfo.h>
 #include <BackgroundJobs/SearchForVideosWithoutVideoThumbnailsJob.h>
 #include <BackgroundTaskManager/JobManager.h>
 #include <Browser/BrowserWidget.h>
 #include <DateBar/DateBarWidget.h>
 #include <DB/CategoryCollection.h>
 #include <DB/ImageDateCollection.h>
 #include <DB/ImageDB.h>
 #include <DB/ImageInfo.h>
 #include <DB/MD5.h>
 #include <DB/MD5Map.h>
 #include <DB/UIDelegate.h>
 #include <Exif/Database.h>
 #include <Exif/InfoDialog.h>
 #include <Exif/Info.h>
 #include <Exif/ReReadDialog.h>
 #include <HTMLGenerator/HTMLDialog.h>
 #include <ImageManager/AsyncLoader.h>
 #include <ImageManager/ThumbnailBuilder.h>
 #include <ImageManager/ThumbnailCache.h>
 #include <ImportExport/Export.h>
 #include <ImportExport/Import.h>
 #ifdef HASKIPI
 #  include <Plugins/Interface.h>
 #endif
+#ifdef KF5Purpose_FOUND
+#  include <Plugins/PurposeMenu.h>
+#endif
 #include <RemoteControl/RemoteInterface.h>
 #include <Settings/SettingsData.h>
 #include <Settings/SettingsDialog.h>
 #include <ThumbnailView/enums.h>
 #include <ThumbnailView/ThumbnailFacade.h>
 #include <Utilities/DemoUtil.h>
 #include <Utilities/FileNameUtil.h>
 #include <Utilities/List.h>
 #include <Utilities/ShowBusyCursor.h>
 #include <Utilities/VideoUtil.h>
 #include <Viewer/ViewerWidget.h>
 
 #include "AutoStackImages.h"
 #include "BreadcrumbViewer.h"
 #include "CopyPopup.h"
 #include "DeleteDialog.h"
 #include "DirtyIndicator.h"
 #include "DuplicateMerger/DuplicateMerger.h"
 #include "ExternalPopup.h"
 #include "FeatureDialog.h"
 #include "ImageCounter.h"
 #include "InvalidDateFinder.h"
 #include "Logging.h"
 #include "Options.h"
 #include "SearchBar.h"
 #include "SplashScreen.h"
 #include "StatisticsDialog.h"
 #include "StatusBar.h"
 #include "TokenEditor.h"
 #include "UpdateVideoThumbnail.h"
 #include "WelcomeDialog.h"
 
 using namespace DB;
 
 MainWindow::Window* MainWindow::Window::s_instance = nullptr;
 
 MainWindow::Window::Window( QWidget* parent )
     :KXmlGuiWindow( parent ),
       m_annotationDialog(nullptr),
       m_deleteDialog( nullptr ), m_htmlDialog(nullptr), m_tokenEditor( nullptr )
 {
 #ifdef HAVE_KGEOMAP
     m_positionBrowser = 0;
 #endif
 
     qCDebug(MainWindowLog) << "Using icon theme: " << QIcon::themeName();
     qCDebug(MainWindowLog) << "Icon search paths: " << QIcon::themeSearchPaths();
     QElapsedTimer timer;
     timer.start();
     SplashScreen::instance()->message( i18n("Loading Database") );
     s_instance = this;
 
     bool gotConfigFile = load();
     if ( !gotConfigFile )
         throw 0;
     qCInfo(TimingLog) << "MainWindow: Loading Database: " << timer.restart() << "ms.";
     SplashScreen::instance()->message( i18n("Loading Main Window") );
 
     QWidget* top = new QWidget( this );
     QVBoxLayout* lay = new QVBoxLayout( top );
     lay->setSpacing(2);
     lay->setContentsMargins(2,2,2,2);
     setCentralWidget( top );
 
     m_stack = new QStackedWidget( top );
     lay->addWidget( m_stack, 1 );
 
     m_dateBar = new DateBar::DateBarWidget( top );
     lay->addWidget( m_dateBar );
 
     m_dateBarLine = new QFrame( top );
     m_dateBarLine->setFrameStyle( QFrame::HLine | QFrame::Plain );
     m_dateBarLine->setLineWidth(0); m_dateBarLine->setMidLineWidth(0);
 
     QPalette pal = m_dateBarLine->palette();
     pal.setColor( QPalette::WindowText, QColor("#c4c1bd") );
     m_dateBarLine->setPalette( pal );
 
     lay->addWidget( m_dateBarLine );
 
     setHistogramVisibilty(Settings::SettingsData::instance()->showHistogram());
 
     m_browser = new Browser::BrowserWidget( m_stack );
     m_thumbnailView = new ThumbnailView::ThumbnailFacade();
 
     m_stack->addWidget( m_browser );
     m_stack->addWidget( m_thumbnailView->gui() );
     m_stack->setCurrentWidget( m_browser );
 
     m_settingsDialog = nullptr;
     qCInfo(TimingLog) << "MainWindow: Loading MainWindow: " << timer.restart() << "ms.";
     setupMenuBar();
     qCInfo(TimingLog) << "MainWindow: setupMenuBar: " << timer.restart() << "ms.";
     createSearchBar();
     qCInfo(TimingLog) << "MainWindow: createSearchBar: " << timer.restart() << "ms.";
     setupStatusBar();
     qCInfo(TimingLog) << "MainWindow: setupStatusBar: " << timer.restart() << "ms.";
 
     // Misc
     m_autoSaveTimer = new QTimer( this );
     connect(m_autoSaveTimer, &QTimer::timeout, this, &Window::slotAutoSave);
     startAutoSaveTimer();
 
     connect(m_browser, &Browser::BrowserWidget::showingOverview, this, &Window::showBrowser);
     connect( m_browser, SIGNAL(pathChanged(Browser::BreadcrumbList)), m_statusBar->mp_pathIndicator, SLOT(setBreadcrumbs(Browser::BreadcrumbList)) );
     connect( m_statusBar->mp_pathIndicator, SIGNAL(widenToBreadcrumb(Browser::Breadcrumb)), m_browser, SLOT(widenToBreadcrumb(Browser::Breadcrumb)) );
     connect( m_browser, SIGNAL(pathChanged(Browser::BreadcrumbList)), this, SLOT(updateDateBar(Browser::BreadcrumbList)) );
 
     connect(m_dateBar, &DateBar::DateBarWidget::dateSelected, m_thumbnailView, &ThumbnailView::ThumbnailFacade::gotoDate);
     connect(m_dateBar, &DateBar::DateBarWidget::toolTipInfo, this, &Window::showDateBarTip);
     connect( Settings::SettingsData::instance(), SIGNAL(histogramSizeChanged(QSize)), m_dateBar, SLOT(setHistogramBarSize(QSize)) );
     connect( Settings::SettingsData::instance(), SIGNAL(actualThumbnailSizeChanged(int)), this, SLOT(slotThumbnailSizeChanged()) );
 
     connect(m_dateBar, &DateBar::DateBarWidget::dateRangeChange, this, &Window::setDateRange);
     connect(m_dateBar, &DateBar::DateBarWidget::dateRangeCleared, this, &Window::clearDateRange);
     connect(m_thumbnailView, &ThumbnailView::ThumbnailFacade::currentDateChanged, m_dateBar, &DateBar::DateBarWidget::setDate);
 
     connect(m_thumbnailView, &ThumbnailView::ThumbnailFacade::showImage, this, &Window::showImage);
     connect( m_thumbnailView, SIGNAL(showSelection()), this, SLOT(slotView()) );
 
     connect(m_thumbnailView, &ThumbnailView::ThumbnailFacade::fileIdUnderCursorChanged, this, &Window::slotSetFileName);
     connect( DB::ImageDB::instance(), SIGNAL(totalChanged(uint)), this, SLOT(updateDateBar()) );
     connect( DB::ImageDB::instance()->categoryCollection(), SIGNAL(categoryCollectionChanged()), this, SLOT(slotOptionGroupChanged()) );
     connect( m_browser, SIGNAL(imageCount(uint)), m_statusBar->mp_partial, SLOT(showBrowserMatches(uint)) );
     connect(m_thumbnailView, &ThumbnailView::ThumbnailFacade::selectionChanged, this, &Window::updateContextMenuFromSelectionSize);
 
     checkIfVideoThumbnailerIsInstalled();
     executeStartupActions();
 
     qCInfo(TimingLog) << "MainWindow: executeStartupActions " << timer.restart() << "ms.";
     QTimer::singleShot( 0, this, SLOT(delayedInit()) );
     updateContextMenuFromSelectionSize(0);
 
     // Automatically save toolbar settings
     setAutoSaveSettings();
 
     qCInfo(TimingLog) << "MainWindow: misc setup time: " << timer.restart() << "ms.";
 }
 
 MainWindow::Window::~Window()
 {
     DB::ImageDB::deleteInstance();
     ImageManager::ThumbnailCache::deleteInstance();
     Exif::Database::deleteInstance();
 }
 
 void MainWindow::Window::delayedInit()
 {
     QElapsedTimer timer;
     timer.start();
     SplashScreen* splash = SplashScreen::instance();
     setupPluginMenu();
     qCInfo(TimingLog) << "MainWindow: setupPluginMenu: " << timer.restart() << "ms.";
 
 
     if ( Settings::SettingsData::instance()->searchForImagesOnStart() ||
          Options::the()->searchForImagesOnStart() ) {
         splash->message( i18n("Searching for New Files") );
         qApp->processEvents();
         DB::ImageDB::instance()->slotRescan();
         qCInfo(TimingLog) << "MainWindow: Search for New Files: " << timer.restart() << "ms.";
     }
 
     if ( !Settings::SettingsData::instance()->delayLoadingPlugins() ) {
         splash->message( i18n( "Loading Plug-ins" ) );
-        loadPlugins();
+        loadKipiPlugins();
         qCInfo(TimingLog) << "MainWindow: Loading Plug-ins: " << timer.restart() << "ms.";
     }
 
     splash->done();
     show();
     updateDateBar();
     qCInfo(TimingLog) << "MainWindow: MainWindow.show():" << timer.restart() << "ms.";
 
     QUrl importUrl = Options::the()->importFile();
     if ( importUrl.isValid() )
     {
         // I need to do this in delayed init to get the import window on top of the normal window
         ImportExport::Import::imageImport( importUrl );
         qCInfo(TimingLog) << "MainWindow: imageImport:" << timer.restart() << "ms.";
     } else {
         // I need to postpone this otherwise the tip dialog will not get focus on start up
         KTipDialog::showTip( this );
     }
 
     Exif::Database::instance(); // Load the database
     qCInfo(TimingLog) << "MainWindow: Loading Exif DB:" << timer.restart() << "ms.";
 
     if (!Options::the()->listen().isNull())
         RemoteControl::RemoteInterface::instance().listen(Options::the()->listen());
     else if ( Settings::SettingsData::instance()->listenForAndroidDevicesOnStartup())
         RemoteControl::RemoteInterface::instance().listen();
 }
 
 
 bool MainWindow::Window::slotExit()
 {
     if ( Options::the()->demoMode() ) {
         QString txt = i18n("<p><b>Delete Your Temporary Demo Database</b></p>"
                            "<p>I hope you enjoyed the KPhotoAlbum demo. The demo database was copied to "
                            "/tmp, should it be deleted now? If you do not delete it, it will waste disk space; "
                            "on the other hand, if you want to come back and try the demo again, you "
                            "might want to keep it around with the changes you made through this session.</p>" );
         int ret = KMessageBox::questionYesNoCancel( this, txt, i18n("Delete Demo Database"),
                                                     KStandardGuiItem::yes(), KStandardGuiItem::no(), KStandardGuiItem::cancel(),
                                                     QString::fromLatin1("deleteDemoDatabase") );
         if ( ret == KMessageBox::Cancel )
             return false;
         else if ( ret == KMessageBox::Yes ) {
             Utilities::deleteDemo();
             goto doQuit;
         }
         else {
             // pass through to the check for dirtyness.
         }
     }
 
     if ( m_statusBar->mp_dirtyIndicator->isSaveDirty() ) {
         int ret = KMessageBox::warningYesNoCancel( this, i18n("Do you want to save the changes?"),
                                                    i18n("Save Changes?") );
         if (ret == KMessageBox::Cancel) {
             return false;
         }
         if ( ret == KMessageBox::Yes ) {
             slotSave();
         }
         if ( ret == KMessageBox::No ) {
             QDir().remove( Settings::SettingsData::instance()->imageDirectory() + QString::fromLatin1(".#index.xml") );
         }
     }
     // Flush any remaining thumbnails
     ImageManager::ThumbnailCache::instance()->save();
 
 doQuit:
     ImageManager::AsyncLoader::instance()->requestExit();
     qApp->quit();
     return true;
 }
 
 void MainWindow::Window::slotOptions()
 {
     if ( ! m_settingsDialog ) {
         m_settingsDialog = new Settings::SettingsDialog( this );
         connect( m_settingsDialog, SIGNAL(changed()), this, SLOT(reloadThumbnails()) );
         connect(m_settingsDialog, &Settings::SettingsDialog::changed, this, &Window::startAutoSaveTimer);
         connect(m_settingsDialog, &Settings::SettingsDialog::changed, m_browser, &Browser::BrowserWidget::reload);
     }
     m_settingsDialog->show();
 }
 
 void MainWindow::Window::slotCreateImageStack()
 {
     const DB::FileNameList list = selected();
     if (list.size() < 2) {
         // it doesn't make sense to make a stack from one image, does it?
         return;
     }
 
     bool ok = DB::ImageDB::instance()->stack( list );
     if ( !ok ) {
         if ( KMessageBox::questionYesNo( this,
                                          i18n("Some of the selected images already belong to a stack. "
                                               "Do you want to remove them from their stacks and create a "
                                               "completely new one?"), i18n("Stacking Error")) == KMessageBox::Yes ) {
             DB::ImageDB::instance()->unstack(list);
             if ( ! DB::ImageDB::instance()->stack(list)) {
                 KMessageBox::sorry( this,
                                     i18n("Unknown error, stack creation failed."),
                                     i18n("Stacking Error"));
                 return;
             }
         } else {
             return;
         }
     }
 
     DirtyIndicator::markDirty();
     // The current item might have just became invisible
     m_thumbnailView->setCurrentItem(list.at(0));
     m_thumbnailView->updateDisplayModel();
 }
 
 /** @short Make the selected image the head of a stack
  *
  * The whole point of image stacking is to group images together and then select
  * one of them as the "most important". This function is (maybe just a
  * temporary) way of promoting a selected image to the "head" of a stack it
  * belongs to. In future, it might get replaced by a Ligtroom-like interface.
  * */
 void MainWindow::Window::slotSetStackHead()
 {
     const DB::FileNameList list = selected();
     if ( list.size() != 1 ) {
         // this should be checked by enabling/disabling of QActions
         return;
     }
 
     setStackHead( *list.begin() );
 }
 
 void MainWindow::Window::setStackHead( const DB::FileName& image )
 {
     if ( ! image.info()->isStacked() )
         return;
 
     unsigned int oldOrder = image.info()->stackOrder();
 
     DB::FileNameList others = DB::ImageDB::instance()->getStackFor(image);
     Q_FOREACH( const DB::FileName& current, others ) {
         if (current == image) {
             current.info()->setStackOrder( 1 );
         } else if ( current.info()->stackOrder() < oldOrder ) {
             current.info()->setStackOrder( current.info()->stackOrder() + 1 );
         }
     }
 
     DirtyIndicator::markDirty();
     m_thumbnailView->updateDisplayModel();
 }
 
 void MainWindow::Window::slotUnStackImages()
 {
     const DB::FileNameList& list = selected();
     if (list.isEmpty())
         return;
 
     DB::ImageDB::instance()->unstack(list);
     DirtyIndicator::markDirty();
     m_thumbnailView->updateDisplayModel();
 }
 
 void MainWindow::Window::slotConfigureAllImages()
 {
     configureImages( false );
 }
 
 void MainWindow::Window::slotConfigureImagesOneAtATime()
 {
     configureImages( true );
 }
 
 void MainWindow::Window::configureImages( bool oneAtATime )
 {
     const DB::FileNameList& list = selected();
     if (list.isEmpty()) {
         KMessageBox::sorry( this, i18n("No item is selected."), i18n("No Selection") );
     }
     else {
         DB::ImageInfoList images;
         Q_FOREACH( const DB::FileName& fileName, list) {
             images.append(fileName.info());
         }
         configureImages( images, oneAtATime );
     }
 }
 
 void MainWindow::Window::configureImages( const DB::ImageInfoList& list, bool oneAtATime )
 {
     s_instance->configImages( list, oneAtATime );
 }
 
 
 void MainWindow::Window::configImages( const DB::ImageInfoList& list, bool oneAtATime )
 {
     createAnnotationDialog();
     if ( m_annotationDialog->configure( list,  oneAtATime ) == QDialog::Rejected )
         return;
 
     reloadThumbnails(  ThumbnailView::MaintainSelection );
 }
 
 
 void MainWindow::Window::slotSearch()
 {
     createAnnotationDialog();
     DB::ImageSearchInfo searchInfo = m_annotationDialog->search();
     if ( !searchInfo.isNull() )
         m_browser->addSearch( searchInfo );
 }
 
 void MainWindow::Window::createAnnotationDialog()
 {
     Utilities::ShowBusyCursor dummy;
     if ( !m_annotationDialog.isNull() )
         return;
 
     m_annotationDialog = new AnnotationDialog::Dialog( nullptr );
     connect(m_annotationDialog.data(), &AnnotationDialog::Dialog::imageRotated, this, &Window::slotImageRotated);
 }
 
 void MainWindow::Window::slotSave()
 {
     Utilities::ShowBusyCursor dummy;
     m_statusBar->showMessage(i18n("Saving..."), 5000 );
     DB::ImageDB::instance()->save( Settings::SettingsData::instance()->imageDirectory() + QString::fromLatin1("index.xml"), false );
     ImageManager::ThumbnailCache::instance()->save();
     m_statusBar->mp_dirtyIndicator->saved();
     QDir().remove( Settings::SettingsData::instance()->imageDirectory() + QString::fromLatin1(".#index.xml") );
     m_statusBar->showMessage(i18n("Saving... Done"), 5000 );
 }
 
 void MainWindow::Window::slotDeleteSelected()
 {
     if ( ! m_deleteDialog )
         m_deleteDialog = new DeleteDialog( this );
     if ( m_deleteDialog->exec( selected() ) != QDialog::Accepted )
         return;
 
     DirtyIndicator::markDirty();
 }
 
 void MainWindow::Window::slotCopySelectedURLs()
 {
     QList<QUrl> urls; int urlcount = 0;
     Q_FOREACH(const DB::FileName &fileName, selected()) {
         urls.append( QUrl::fromLocalFile(fileName.absolute()) );
         urlcount++;
     }
     if (urlcount == 1) m_paste->setEnabled (true); else m_paste->setEnabled(false);
     QMimeData* mimeData = new QMimeData;
     mimeData->setUrls(urls);
 
     QApplication::clipboard()->setMimeData( mimeData );
 }
 
 void MainWindow::Window::slotPasteInformation()
 {
     const QMimeData* mimeData = QApplication::clipboard()->mimeData();
 
     // Idealy this would look like
     // QList<QUrl> urls;
     // urls.fromMimeData(mimeData);
     // if ( urls.count() != 1 ) return;
     // const QString string = urls.first().path();
 
     QString string = mimeData->text();
     // fail silent if more than one image is in clipboard.
     if (string.count(QString::fromLatin1("\n")) != 0) return;
 
     const QString urlHead = QLatin1String("file://");
     if (string.startsWith(urlHead)) {
         string = string.right(string.size()-urlHead.size());
     }
 
     const DB::FileName fileName = DB::FileName::fromAbsolutePath(string);
     // fail silent if there is no file.
     if (fileName.isNull()) return;
 
     MD5 originalSum = MD5Sum( fileName );
     ImageInfoPtr originalInfo;
     if ( DB::ImageDB::instance()->md5Map()->contains( originalSum ) ) {
         originalInfo = DB::ImageDB::instance()->info( fileName );
     } else {
         originalInfo = fileName.info();
     }
     // fail silent if there is no info for the file.
     if (!originalInfo) return;
 
     Q_FOREACH(const DB::FileName& newFile, selected()) {
         newFile.info()->copyExtraData(*originalInfo, false);
     }
     DirtyIndicator::markDirty();
 }
 
 void MainWindow::Window::slotReReadExifInfo()
 {
     DB::FileNameList files = selectedOnDisk();
     static Exif::ReReadDialog* dialog = nullptr;
     if ( ! dialog )
         dialog = new Exif::ReReadDialog( this );
     if ( dialog->exec( files ) == QDialog::Accepted )
         DirtyIndicator::markDirty();
 }
 
 void MainWindow::Window::slotAutoStackImages()
 {
     const DB::FileNameList list = selected();
     if (list.isEmpty()) {
         KMessageBox::sorry( this, i18n("No item is selected."), i18n("No Selection") );
         return;
     }
     QPointer<MainWindow::AutoStackImages> stacker = new AutoStackImages( this, list );
     if ( stacker->exec() == QDialog::Accepted )
         showThumbNails();
     delete stacker;
 }
 
 /**
  * In thumbnail mode, return a list of files that are selected.
  * Otherwise, return all images in the current scope/context.
  */
 DB::FileNameList MainWindow::Window::selected( ThumbnailView::SelectionMode mode) const
 {
     if ( m_thumbnailView->gui() == m_stack->currentWidget() )
         return m_thumbnailView->selection(mode);
     else
         // return all images in the current scope (parameter false: include images not on disk)
         return DB::ImageDB::instance()->currentScope(false);
 }
 
 void MainWindow::Window::slotViewNewWindow()
 {
     slotView( false, false );
 }
 
 /*
  * Returns a list of files that are both selected and on disk. If there are no
  * selected files, returns all files form current context that are on disk.
  * Note: On some setups (NFS), this can be a very time-consuming method!
  * */
 DB::FileNameList MainWindow::Window::selectedOnDisk()
 {
     const DB::FileNameList list = selected(ThumbnailView::NoExpandCollapsedStacks);
 
     DB::FileNameList listOnDisk;
     Q_FOREACH(const DB::FileName& fileName, list) {
         if (DB::ImageInfo::imageOnDisk(fileName))
             listOnDisk.append(fileName);
     }
 
     return listOnDisk;
 }
 
 void MainWindow::Window::slotView( bool reuse, bool slideShow, bool random )
 {
     launchViewer(selected(ThumbnailView::NoExpandCollapsedStacks), reuse, slideShow, random );
 }
 
 void MainWindow::Window::launchViewer(const DB::FileNameList& inputMediaList, bool reuse, bool slideShow, bool random)
 {
     DB::FileNameList mediaList = inputMediaList;
     int seek = -1;
     if (mediaList.isEmpty()) {
         mediaList = m_thumbnailView->imageList( ThumbnailView::ViewOrder );
     } else if (mediaList.size() == 1) {
         // we fake it so it appears the user has selected all images
         // and magically scrolls to the originally selected one
         const DB::FileName first = mediaList.at(0);
         mediaList = m_thumbnailView->imageList( ThumbnailView::ViewOrder );
         seek = mediaList.indexOf(first);
     }
 
     if (mediaList.isEmpty())
         mediaList = DB::ImageDB::instance()->currentScope( false );
 
     if (mediaList.isEmpty()) {
         KMessageBox::sorry( this, i18n("There are no images to be shown.") );
         return;
     }
 
     if (random) {
         mediaList = DB::FileNameList(Utilities::shuffleList(mediaList));
     }
 
     Viewer::ViewerWidget* viewer;
     if ( reuse && Viewer::ViewerWidget::latest() ) {
         viewer = Viewer::ViewerWidget::latest();
         viewer->raise();
         viewer->activateWindow();
     }
     else
         viewer = new Viewer::ViewerWidget(Viewer::ViewerWidget::ViewerWindow,
                                           &m_viewerInputMacros);
     connect(viewer, &Viewer::ViewerWidget::soughtTo, m_thumbnailView, &ThumbnailView::ThumbnailFacade::changeSingleSelection);
     connect(viewer, &Viewer::ViewerWidget::imageRotated, this, &Window::slotImageRotated);
 
     viewer->show( slideShow );
     viewer->load( mediaList, seek < 0 ? 0 : seek );
     viewer->raise();
 }
 
 void MainWindow::Window::slotSortByDateAndTime()
 {
     DB::ImageDB::instance()->sortAndMergeBackIn(selected());
     showThumbNails( DB::ImageDB::instance()->search( Browser::BrowserWidget::instance()->currentContext()));
     DirtyIndicator::markDirty();
 }
 
 void MainWindow::Window::slotSortAllByDateAndTime()
 {
     DB::ImageDB::instance()->sortAndMergeBackIn(DB::ImageDB::instance()->images());
     if ( m_thumbnailView->gui() == m_stack->currentWidget() )
         showThumbNails( DB::ImageDB::instance()->search( Browser::BrowserWidget::instance()->currentContext()));
     DirtyIndicator::markDirty();
 }
 
 
 QString MainWindow::Window::welcome()
 {
     QString configFileName;
     QPointer<MainWindow::WelcomeDialog> dialog = new WelcomeDialog( this );
     // exit if the user dismissed the welcome dialog
     if (!dialog->exec())
     {
         qApp->quit();
     }
     configFileName = dialog->configFileName();
     delete dialog;
     return configFileName;
 }
 
 void MainWindow::Window::closeEvent( QCloseEvent* e )
 {
     bool quit = true;
     quit = slotExit();
     // If I made it here, then the user canceled
     if ( !quit )
         e->ignore();
     else
         e->setAccepted(true);
 }
 
 
 void MainWindow::Window::slotLimitToSelected()
 {
     Utilities::ShowBusyCursor dummy;
     showThumbNails( selected() );
 }
 
 void MainWindow::Window::setupMenuBar()
 {
     // File menu
     KStandardAction::save( this, SLOT(slotSave()), actionCollection() );
     KStandardAction::quit( this, SLOT(slotExit()), actionCollection() );
     m_generateHtml = actionCollection()->addAction( QString::fromLatin1("exportHTML") );
     m_generateHtml->setText( i18n("Generate HTML...") );
     connect(m_generateHtml, &QAction::triggered, this, &Window::slotExportToHTML);
 
     QAction* a = actionCollection()->addAction( QString::fromLatin1("import"), this, SLOT(slotImport()) );
     a->setText( i18n( "Import...") );
 
     a = actionCollection()->addAction( QString::fromLatin1("export"), this, SLOT(slotExport()) );
     a->setText( i18n( "Export/Copy Images...") );
 
 
     // Go menu
     a = KStandardAction::back( m_browser, SLOT(back()), actionCollection() );
     connect(m_browser, &Browser::BrowserWidget::canGoBack, a, &QAction::setEnabled);
     a->setEnabled( false );
 
     a = KStandardAction::forward( m_browser, SLOT(forward()), actionCollection() );
     connect(m_browser, &Browser::BrowserWidget::canGoForward, a, &QAction::setEnabled);
     a->setEnabled( false );
 
     a = KStandardAction::home( m_browser, SLOT(home()), actionCollection() );
     actionCollection()->setDefaultShortcut(a, Qt::CTRL + Qt::Key_Home);
     connect(a, &QAction::triggered, m_dateBar, &DateBar::DateBarWidget::clearSelection);
 
     KStandardAction::redisplay( m_browser, SLOT(go()), actionCollection() );
 
     // The Edit menu
     m_copy = KStandardAction::copy( this, SLOT(slotCopySelectedURLs()), actionCollection() );
     m_paste = KStandardAction::paste( this, SLOT(slotPasteInformation()), actionCollection() );
     m_paste->setEnabled(false);
     m_selectAll = KStandardAction::selectAll( m_thumbnailView, SLOT(selectAll()), actionCollection() );
     m_clearSelection = KStandardAction::deselect( m_thumbnailView, SLOT(clearSelection()), actionCollection() );
     m_clearSelection->setEnabled(false);
     KStandardAction::find( this, SLOT(slotSearch()), actionCollection() );
 
     m_deleteSelected = actionCollection()->addAction(QString::fromLatin1("deleteSelected"));
     m_deleteSelected->setText( i18nc("Delete selected images", "Delete Selected" ) );
     m_deleteSelected->setIcon( QIcon::fromTheme( QString::fromLatin1("edit-delete") ) );
     actionCollection()->setDefaultShortcut(m_deleteSelected, Qt::Key_Delete);
     connect(m_deleteSelected, &QAction::triggered, this, &Window::slotDeleteSelected);
 
     a = actionCollection()->addAction(QString::fromLatin1("removeTokens"), this, SLOT(slotRemoveTokens()));
     a->setText( i18n("Remove Tokens...") );
 
     a = actionCollection()->addAction(QString::fromLatin1("showListOfFiles"), this, SLOT(slotShowListOfFiles()));
     a->setText( i18n("Open List of Files...")) ;
 
 
     m_configOneAtATime = actionCollection()->addAction( QString::fromLatin1("oneProp"), this, SLOT(slotConfigureImagesOneAtATime()) );
     m_configOneAtATime->setText( i18n( "Annotate Individual Items" ) );
     actionCollection()->setDefaultShortcut(m_configOneAtATime, Qt::CTRL + Qt::Key_1);
 
     m_configAllSimultaniously = actionCollection()->addAction( QString::fromLatin1("allProp"), this, SLOT(slotConfigureAllImages()) );
     m_configAllSimultaniously->setText( i18n( "Annotate Multiple Items at a Time" ) );
     actionCollection()->setDefaultShortcut(m_configAllSimultaniously, Qt::CTRL + Qt::Key_2);
 
     m_createImageStack = actionCollection()->addAction( QString::fromLatin1("createImageStack"), this, SLOT(slotCreateImageStack()) );
     m_createImageStack->setText( i18n("Merge Images into a Stack") );
     actionCollection()->setDefaultShortcut(m_createImageStack, Qt::CTRL + Qt::Key_3);
 
     m_unStackImages = actionCollection()->addAction( QString::fromLatin1("unStackImages"), this, SLOT(slotUnStackImages()) );
     m_unStackImages->setText( i18n("Remove Images from Stack") );
 
     m_setStackHead = actionCollection()->addAction( QString::fromLatin1("setStackHead"), this, SLOT(slotSetStackHead()) );
     m_setStackHead->setText( i18n("Set as First Image in Stack") );
     actionCollection()->setDefaultShortcut(m_setStackHead, Qt::CTRL + Qt::Key_4);
 
     m_rotLeft = actionCollection()->addAction( QString::fromLatin1("rotateLeft"), this, SLOT(slotRotateSelectedLeft()) );
     m_rotLeft->setText( i18n( "Rotate counterclockwise" ) );
     actionCollection()->setDefaultShortcut(m_rotLeft, Qt::Key_7);
 
 
     m_rotRight = actionCollection()->addAction( QString::fromLatin1("rotateRight"), this, SLOT(slotRotateSelectedRight()) );
     m_rotRight->setText( i18n( "Rotate clockwise" ) );
     actionCollection()->setDefaultShortcut(m_rotRight, Qt::Key_9);
 
 
     // The Images menu
     m_view = actionCollection()->addAction( QString::fromLatin1("viewImages"), this, SLOT(slotView()) );
     m_view->setText( i18n("View") );
     actionCollection()->setDefaultShortcut(m_view, Qt::CTRL + Qt::Key_I);
 
     m_viewInNewWindow = actionCollection()->addAction( QString::fromLatin1("viewImagesNewWindow"), this, SLOT(slotViewNewWindow()) );
     m_viewInNewWindow->setText( i18n("View (In New Window)") );
 
     m_runSlideShow = actionCollection()->addAction( QString::fromLatin1("runSlideShow"), this, SLOT(slotRunSlideShow()) );
     m_runSlideShow->setText( i18n("Run Slide Show") );
     m_runSlideShow->setIcon( QIcon::fromTheme( QString::fromLatin1("view-presentation") ) );
     actionCollection()->setDefaultShortcut(m_runSlideShow, Qt::CTRL + Qt::Key_R);
 
     m_runRandomSlideShow = actionCollection()->addAction( QString::fromLatin1("runRandomizedSlideShow"), this, SLOT(slotRunRandomizedSlideShow()) );
     m_runRandomSlideShow->setText( i18n( "Run Randomized Slide Show" ) );
 
     a = actionCollection()->addAction( QString::fromLatin1("collapseAllStacks"),
                                        m_thumbnailView, SLOT(collapseAllStacks()) );
     connect(m_thumbnailView, &ThumbnailView::ThumbnailFacade::collapseAllStacksEnabled, a, &QAction::setEnabled);
     a->setEnabled(false);
     a->setText( i18n("Collapse all stacks" ));
 
     a = actionCollection()->addAction( QString::fromLatin1("expandAllStacks"),
                                        m_thumbnailView, SLOT(expandAllStacks()) );
     connect(m_thumbnailView, &ThumbnailView::ThumbnailFacade::expandAllStacksEnabled, a, &QAction::setEnabled);
     a->setEnabled(false);
     a->setText( i18n("Expand all stacks" ));
 
     QActionGroup* grp = new QActionGroup( this );
 
     a = actionCollection()->add<KToggleAction>( QString::fromLatin1("orderIncr"), this, SLOT(slotOrderIncr()) );
     a->setText( i18n("Show &Oldest First") ) ;
     a->setActionGroup(grp);
     a->setChecked( !Settings::SettingsData::instance()->showNewestThumbnailFirst() );
 
     a = actionCollection()->add<KToggleAction>( QString::fromLatin1("orderDecr"), this, SLOT(slotOrderDecr()) );
     a->setText( i18n("Show &Newest First") );
     a->setActionGroup(grp);
     a->setChecked( Settings::SettingsData::instance()->showNewestThumbnailFirst() );
 
     m_sortByDateAndTime = actionCollection()->addAction( QString::fromLatin1("sortImages"), this, SLOT(slotSortByDateAndTime()) );
     m_sortByDateAndTime->setText( i18n("Sort Selected by Date && Time") );
 
     m_limitToMarked = actionCollection()->addAction( QString::fromLatin1("limitToMarked"), this, SLOT(slotLimitToSelected()) );
     m_limitToMarked->setText( i18n("Limit View to Selection") );
 
     m_jumpToContext = actionCollection()->addAction( QString::fromLatin1("jumpToContext"), this, SLOT(slotJumpToContext()) );
     m_jumpToContext->setText( i18n("Jump to Context") );
     actionCollection()->setDefaultShortcut(m_jumpToContext, Qt::CTRL + Qt::Key_J);
     m_jumpToContext->setIcon( QIcon::fromTheme( QString::fromLatin1( "kphotoalbum" ) ) ); // icon suggestion: go-jump (don't know the exact meaning though, so I didn't replace it right away
 
     m_lock = actionCollection()->addAction( QString::fromLatin1("lockToDefaultScope"), this, SLOT(lockToDefaultScope()) );
     m_lock->setText( i18n("Lock Images") );
 
     m_unlock = actionCollection()->addAction( QString::fromLatin1("unlockFromDefaultScope"), this, SLOT(unlockFromDefaultScope()) );
     m_unlock->setText( i18n("Unlock") );
 
     a = actionCollection()->addAction( QString::fromLatin1("changeScopePasswd"), this, SLOT(changePassword()) );
     a->setText( i18n("Change Password...") );
     actionCollection()->setDefaultShortcut(a, 0);
 
     m_setDefaultPos = actionCollection()->addAction( QString::fromLatin1("setDefaultScopePositive"), this, SLOT(setDefaultScopePositive()) );
     m_setDefaultPos->setText( i18n("Lock Away All Other Items") );
 
     m_setDefaultNeg = actionCollection()->addAction( QString::fromLatin1("setDefaultScopeNegative"), this, SLOT(setDefaultScopeNegative()) );
     m_setDefaultNeg->setText( i18n("Lock Away Current Set of Items") );
 
     // Maintenance
     a = actionCollection()->addAction( QString::fromLatin1("findUnavailableImages"), this, SLOT(slotShowNotOnDisk()) );
     a->setText( i18n("Display Images and Videos Not on Disk") );
 
     a = actionCollection()->addAction( QString::fromLatin1("findImagesWithInvalidDate"), this, SLOT(slotShowImagesWithInvalidDate()) );
     a->setText( i18n("Display Images and Videos with Incomplete Dates...") );
 
 #ifdef DOES_STILL_NOT_WORK_IN_KPA4
     a = actionCollection()->addAction( QString::fromLatin1("findImagesWithChangedMD5Sum"), this, SLOT(slotShowImagesWithChangedMD5Sum()) );
     a->setText( i18n("Display Images and Videos with Changed MD5 Sum") );
 #endif //DOES_STILL_NOT_WORK_IN_KPA4
 
     a = actionCollection()->addAction( QLatin1String("mergeDuplicates"), this, SLOT(mergeDuplicates()));
     a->setText(i18n("Merge duplicates"));
     a = actionCollection()->addAction( QString::fromLatin1("rebuildMD5s"), this, SLOT(slotRecalcCheckSums()) );
     a->setText( i18n("Recalculate Checksum") );
 
     a = actionCollection()->addAction( QString::fromLatin1("rescan"), DB::ImageDB::instance(), SLOT(slotRescan()) );
     a->setIcon(QIcon::fromTheme( QString::fromLatin1( "document-import" ) ));
     a->setText( i18n("Rescan for Images and Videos") );
 
     QAction* recreateExif = actionCollection()->addAction( QString::fromLatin1( "recreateExifDB" ), this, SLOT(slotRecreateExifDB()) );
     recreateExif->setText( i18n("Recreate Exif Search Database") );
 
     QAction* rereadExif = actionCollection()->addAction( QString::fromLatin1("reReadExifInfo"), this, SLOT(slotReReadExifInfo()) );
     rereadExif->setText( i18n("Read Exif Info from Files...") );
 
     m_sortAllByDateAndTime = actionCollection()->addAction( QString::fromLatin1("sortAllImages"), this, SLOT(slotSortAllByDateAndTime()) );
     m_sortAllByDateAndTime->setText( i18n("Sort All by Date && Time") );
     m_sortAllByDateAndTime->setEnabled(true);
 
     m_AutoStackImages = actionCollection()->addAction( QString::fromLatin1( "autoStack" ), this, SLOT (slotAutoStackImages()) );
     m_AutoStackImages->setText( i18n("Automatically Stack Selected Images...") );
 
     a = actionCollection()->addAction( QString::fromLatin1("buildThumbs"), this, SLOT(slotBuildThumbnails()) );
     a->setText( i18n("Build Thumbnails") );
 
     a = actionCollection()->addAction( QString::fromLatin1("statistics"), this, SLOT(slotStatistics()) );
     a->setText( i18n("Statistics...") );
 
     m_markUntagged = actionCollection()->addAction(QString::fromUtf8("markUntagged"),
                                                    this, SLOT(slotMarkUntagged()));
     m_markUntagged->setText(i18n("Mark As Untagged"));
 
 
     // Settings
     KStandardAction::preferences( this, SLOT(slotOptions()), actionCollection() );
     KStandardAction::keyBindings( this, SLOT(slotConfigureKeyBindings()), actionCollection() );
     KStandardAction::configureToolbars( this, SLOT(slotConfigureToolbars()), actionCollection() );
 
     a = actionCollection()->addAction( QString::fromLatin1("readdAllMessages"), this, SLOT(slotReenableMessages()) );
     a->setText( i18n("Enable All Messages") );
 
     m_viewMenu = actionCollection()->add<KActionMenu>( QString::fromLatin1("configureView") );
     m_viewMenu->setText( i18n("Configure Current View") );
 
     m_viewMenu->setIcon( QIcon::fromTheme( QString::fromLatin1( "view-list-details" ) ) );
     m_viewMenu->setDelayed( false );
 
     QActionGroup* viewGrp = new QActionGroup( this );
     viewGrp->setExclusive( true );
 
     m_smallListView = actionCollection()->add<KToggleAction>( QString::fromLatin1("smallListView"), m_browser, SLOT(slotSmallListView()) );
     m_smallListView->setText( i18n("Tree") );
     m_viewMenu->addAction( m_smallListView );
     m_smallListView->setActionGroup( viewGrp );
 
     m_largeListView = actionCollection()->add<KToggleAction>( QString::fromLatin1("largelistview"), m_browser, SLOT(slotLargeListView()) );
     m_largeListView->setText( i18n("Tree with User Icons") );
     m_viewMenu->addAction( m_largeListView );
     m_largeListView->setActionGroup( viewGrp );
 
     m_largeIconView = actionCollection()->add<KToggleAction>(  QString::fromLatin1("largeiconview"), m_browser, SLOT(slotLargeIconView()) );
     m_largeIconView->setText( i18n("Icons") );
     m_viewMenu->addAction( m_largeIconView );
     m_largeIconView->setActionGroup( viewGrp );
 
     connect(m_browser, &Browser::BrowserWidget::isViewChangeable, viewGrp, &QActionGroup::setEnabled);
 
     connect(m_browser, &Browser::BrowserWidget::currentViewTypeChanged, this, &Window::slotUpdateViewMenu);
     // The help menu
     KStandardAction::tipOfDay( this, SLOT(showTipOfDay()), actionCollection() );
 
     a = actionCollection()->add<KToggleAction>( QString::fromLatin1("showToolTipOnImages") );
     a->setText( i18n("Show Tooltips in Thumbnails Window") );
     actionCollection()->setDefaultShortcut(a, Qt::CTRL + Qt::Key_T);
     connect(a, &QAction::toggled, m_thumbnailView, &ThumbnailView::ThumbnailFacade::showToolTipsOnImages);
 
 
     a = actionCollection()->addAction( QString::fromLatin1("runDemo"), this, SLOT(runDemo()) );
     a->setText( i18n("Run KPhotoAlbum Demo") );
 
     a = actionCollection()->addAction( QString::fromLatin1("features"), this, SLOT(showFeatures()) );
     a->setText( i18n("KPhotoAlbum Feature Status") );
 
     a = actionCollection()->addAction( QString::fromLatin1("showVideo"), this, SLOT(showVideos()) );
     a->setText( i18n( "Show Demo Videos") );
 
     // Context menu actions
     m_showExifDialog = actionCollection()->addAction( QString::fromLatin1("showExifInfo"), this, SLOT(slotShowExifInfo()) );
     m_showExifDialog->setText( i18n("Show Exif Info") );
 
     m_recreateThumbnails = actionCollection()->addAction( QString::fromLatin1("recreateThumbnails"), m_thumbnailView, SLOT(slotRecreateThumbnail()) );
     m_recreateThumbnails->setText( i18n("Recreate Selected Thumbnails") );
 
     m_useNextVideoThumbnail = actionCollection()->addAction( QString::fromLatin1("useNextVideoThumbnail"), this, SLOT(useNextVideoThumbnail()));
     m_useNextVideoThumbnail->setText(i18n("Use next video thumbnail"));
     actionCollection()->setDefaultShortcut(m_useNextVideoThumbnail, Qt::CTRL + Qt::Key_Plus);
 
     m_usePreviousVideoThumbnail = actionCollection()->addAction( QString::fromLatin1("usePreviousVideoThumbnail"), this, SLOT(usePreviousVideoThumbnail()));
     m_usePreviousVideoThumbnail->setText(i18n("Use previous video thumbnail"));
     actionCollection()->setDefaultShortcut(m_usePreviousVideoThumbnail, Qt::CTRL + Qt::Key_Minus);
 
     createGUI( QString::fromLatin1( "kphotoalbumui.rc" ) );
 }
 
 void MainWindow::Window::slotExportToHTML()
 {
     if ( ! m_htmlDialog )
         m_htmlDialog = new HTMLGenerator::HTMLDialog( this );
     m_htmlDialog->exec(selectedOnDisk());
 }
 
 void MainWindow::Window::startAutoSaveTimer()
 {
     int i = Settings::SettingsData::instance()->autoSave();
     m_autoSaveTimer->stop();
     if ( i != 0 ) {
         m_autoSaveTimer->start( i * 1000 * 60  );
     }
 }
 
 void MainWindow::Window::slotAutoSave()
 {
     if ( m_statusBar->mp_dirtyIndicator->isAutoSaveDirty() ) {
         Utilities::ShowBusyCursor dummy;
         m_statusBar->showMessage(i18n("Auto saving...."));
         DB::ImageDB::instance()->save( Settings::SettingsData::instance()->imageDirectory() + QString::fromLatin1(".#index.xml"), true );
         ImageManager::ThumbnailCache::instance()->save();
         m_statusBar->showMessage(i18n("Auto saving.... Done"), 5000);
         m_statusBar->mp_dirtyIndicator->autoSaved();
     }
 }
 
 
 void MainWindow::Window::showThumbNails()
 {
     m_statusBar->showThumbnailSlider();
     reloadThumbnails( ThumbnailView::ClearSelection );
     m_stack->setCurrentWidget( m_thumbnailView->gui() );
     m_thumbnailView->gui()->setFocus();
     updateStates( true );
 }
 
 void MainWindow::Window::showBrowser()
 {
     m_statusBar->clearMessage();
     m_statusBar->hideThumbnailSlider();
     m_stack->setCurrentWidget( m_browser );
     m_browser->setFocus();
     updateContextMenuFromSelectionSize( 0 );
     updateStates( false );
 }
 
 
 void MainWindow::Window::slotOptionGroupChanged()
 {
     // FIXME: What if annotation dialog is open? (if that's possible)
     delete m_annotationDialog;
     m_annotationDialog = nullptr;
     DirtyIndicator::markDirty();
 }
 
 void MainWindow::Window::showTipOfDay()
 {
     KTipDialog::showTip( this, QString(), true );
 }
 
 
 void MainWindow::Window::runDemo()
 {
     KProcess* process = new KProcess;
     *process << qApp->applicationFilePath() << QLatin1String("--demo");
     process->startDetached();
 }
 
 bool MainWindow::Window::load()
 {
     // Let first try to find a config file.
     QString configFile;
 
     QUrl dbFileUrl = Options::the()->dbFile();
     if ( !dbFileUrl.isEmpty() && dbFileUrl.isLocalFile() )
     {
         configFile = dbFileUrl.toLocalFile();
     }
     else if ( Options::the()->demoMode() )
     {
         configFile = Utilities::setupDemo();
     }
     else {
         bool showWelcome = false;
         KConfigGroup config = KSharedConfig::openConfig()->group(QString::fromUtf8("General"));
         if ( config.hasKey( QString::fromLatin1("imageDBFile") ) ) {
             configFile = config.readEntry<QString>( QString::fromLatin1("imageDBFile"), QString() );
             if ( !QFileInfo( configFile ).exists() )
                 showWelcome = true;
         }
         else
             showWelcome = true;
 
         if ( showWelcome ) {
             SplashScreen::instance()->hide();
             configFile = welcome();
         }
     }
     if ( configFile.isNull() )
         return false;
 
     if (configFile.startsWith( QString::fromLatin1( "~" ) ) )
         configFile = QDir::home().path() + QString::fromLatin1( "/" ) + configFile.mid(1);
 
     // To avoid a race conditions where both the image loader thread creates an instance of
     // Settings, and where the main thread crates an instance, we better get it created now.
     Settings::SettingsData::setup( QFileInfo( configFile ).absolutePath() );
 
     if ( Settings::SettingsData::instance()->showSplashScreen() ) {
         SplashScreen::instance()->show();
         qApp->processEvents();
     }
 
     // Doing some validation on user provided index file
     if ( Options::the()->dbFile().isValid() ) {
         QFileInfo fi( configFile );
 
         if ( !fi.dir().exists() ) {
             KMessageBox::error( this, i18n("<p>Could not open given index.xml as provided directory does not exist.<br />%1</p>",
                                            fi.absolutePath()) );
             return false;
         }
 
         // We use index.xml as the XML backend, thus we want to test for exactly it
         fi.setFile( QString::fromLatin1( "%1/index.xml" ).arg( fi.dir().absolutePath() ) );
         if ( !fi.exists() ) {
             int answer = KMessageBox::questionYesNo(this,i18n("<p>Given index file does not exist, do you want to create following?"
                                                               "<br />%1/index.xml</p>", fi.absolutePath() ) );
             if (answer != KMessageBox::Yes)
                 return false;
         }
         configFile = fi.absoluteFilePath();
     }
     DB::ImageDB::setupXMLDB( configFile, *this );
 
     // some sanity checks:
     if ( ! Settings::SettingsData::instance()->hasUntaggedCategoryFeatureConfigured()
          && ! (Settings::SettingsData::instance()->untaggedCategory().isEmpty()
                && Settings::SettingsData::instance()->untaggedTag().isEmpty() )
          && ! Options::the()->demoMode() )
     {
         KMessageBox::error( this, i18n(
                                 "<p>You have configured a tag for untagged images, but either the tag itself "
                                 "or its category does not exist in the database.</p>"
                                 "<p>Please review your untagged tag setting under "
                                 "<interface>Settings|Configure KPhotoAlbum...|Categories</interface></p>"));
     }
 
     return true;
 }
 
 void MainWindow::Window::contextMenuEvent( QContextMenuEvent* e )
 {
     if ( m_stack->currentWidget() == m_thumbnailView->gui() ) {
         QMenu menu( this );
         menu.addAction( m_configOneAtATime );
         menu.addAction( m_configAllSimultaniously );
         menu.addSeparator();
         menu.addAction( m_createImageStack );
         menu.addAction( m_unStackImages );
         menu.addAction( m_setStackHead );
         menu.addSeparator();
         menu.addAction( m_runSlideShow );
         menu.addAction(m_runRandomSlideShow );
         menu.addAction( m_showExifDialog);
 
         menu.addSeparator();
         menu.addAction(m_rotLeft);
         menu.addAction(m_rotRight);
         menu.addAction(m_recreateThumbnails);
         menu.addAction(m_useNextVideoThumbnail);
         menu.addAction(m_usePreviousVideoThumbnail);
         m_useNextVideoThumbnail->setEnabled(anyVideosSelected());
         m_usePreviousVideoThumbnail->setEnabled(anyVideosSelected());
         menu.addSeparator();
 
         menu.addAction(m_view);
         menu.addAction(m_viewInNewWindow);
 
         // "Invoke external program"
 
         ExternalPopup externalCommands { &menu };
         DB::ImageInfoPtr info = m_thumbnailView->mediaIdUnderCursor().info();
 
         externalCommands.populate( info, selected());
         QAction* action = menu.addMenu( &externalCommands );
         if (!info && selected().isEmpty())
             action->setEnabled( false );
 
         QUrl selectedFile;
         if (info)
             selectedFile = QUrl::fromLocalFile(info->fileName().absolute());
         QList<QUrl> allSelectedFiles;
         for (const QString &selectedPath : selected().toStringList(DB::AbsolutePath)) {
             allSelectedFiles << QUrl::fromLocalFile(selectedPath);
         }
 
         // "Copy image(s) to ..."
         CopyPopup copyMenu (&menu, selectedFile, allSelectedFiles, m_lastTarget, CopyPopup::Copy);
         QAction *copyAction = menu.addMenu(&copyMenu);
         if (!info && selected().isEmpty()) {
             copyAction->setEnabled(false);
         }
 
         // "Link image(s) to ..."
         CopyPopup linkMenu (&menu, selectedFile, allSelectedFiles, m_lastTarget, CopyPopup::Link);
         QAction *linkAction = menu.addMenu(&linkMenu);
         if (!info && selected().isEmpty()) {
             linkAction->setEnabled(false);
         }
 
         menu.exec( QCursor::pos() );
     }
     e->setAccepted(true);
 }
 
 void MainWindow::Window::setDefaultScopePositive()
 {
     Settings::SettingsData::instance()->setCurrentLock( m_browser->currentContext(), false );
 }
 
 void MainWindow::Window::setDefaultScopeNegative()
 {
     Settings::SettingsData::instance()->setCurrentLock( m_browser->currentContext(), true );
 }
 
 void MainWindow::Window::lockToDefaultScope()
 {
     int i = KMessageBox::warningContinueCancel( this,
                                                 i18n( "<p>The password protection is only a means of allowing your little sister "
                                                       "to look in your images, without getting to those embarrassing images from "
                                                       "your last party.</p>"
                                                       "<p><b>In other words, anyone with access to the index.xml file can easily "
                                                       "circumvent this password.</b></p>"),
                                                 i18n("Password Protection"),
                                                 KStandardGuiItem::cont(), KStandardGuiItem::cancel(),
                                                 QString::fromLatin1( "lockPassWordIsNotEncruption" ) );
     if ( i == KMessageBox::Cancel )
         return;
 
     setLocked( true, false );
 }
 
 void MainWindow::Window::unlockFromDefaultScope()
 {
     bool OK = ( Settings::SettingsData::instance()->password().isEmpty() );
     QPointer <KPasswordDialog> dialog = new KPasswordDialog( this );
     while ( !OK ) {
         dialog->setPrompt( i18n("Type in Password to Unlock") );
         const int code = dialog->exec();
         if ( code == QDialog::Rejected )
             return;
         const QString passwd = dialog->password();
 
         OK = (Settings::SettingsData::instance()->password() == passwd);
 
         if ( !OK )
             KMessageBox::sorry( this, i18n("Invalid password.") );
     }
     setLocked( false, false );
     delete dialog;
 }
 
 void MainWindow::Window::setLocked( bool locked, bool force, bool recount )
 {
     m_statusBar->setLocked( locked );
     Settings::SettingsData::instance()->setLocked( locked, force );
 
     m_lock->setEnabled( !locked );
     m_unlock->setEnabled( locked );
     m_setDefaultPos->setEnabled( !locked );
     m_setDefaultNeg->setEnabled( !locked );
     if (recount)
         m_browser->reload();
 }
 
 void MainWindow::Window::changePassword()
 {
     bool OK = ( Settings::SettingsData::instance()->password().isEmpty() );
 
     QPointer<KPasswordDialog> dialog = new KPasswordDialog;
 
     while ( !OK ) {
         dialog->setPrompt( i18n("Type in Old Password") );
         const int code = dialog->exec();
         if ( code == QDialog::Rejected )
             return;
         const QString passwd = dialog->password();
 
         OK = (Settings::SettingsData::instance()->password() == QString(passwd));
 
         if ( !OK )
             KMessageBox::sorry( this, i18n("Invalid password.") );
     }
 
     dialog->setPrompt( i18n("Type in New Password") );
     const int code = dialog->exec();
     if ( code == QDialog::Accepted )
         Settings::SettingsData::instance()->setPassword( dialog->password() );
     delete dialog;
 }
 
 void MainWindow::Window::slotConfigureKeyBindings()
 {
     Viewer::ViewerWidget* viewer = new Viewer::ViewerWidget; // Do not show, this is only used to get a key configuration
     KShortcutsDialog* dialog = new KShortcutsDialog();
     dialog->addCollection( actionCollection(), i18n( "General" ) );
     dialog->addCollection( viewer->actions(), i18n("Viewer") );
 
 #ifdef HASKIPI
-    loadPlugins();
+    loadKipiPlugins();
     Q_FOREACH( const KIPI::PluginLoader::Info *pluginInfo, m_pluginLoader->pluginList() ) {
         KIPI::Plugin* plugin = pluginInfo->plugin();
         if ( plugin )
             dialog->addCollection( plugin->actionCollection(),
                                    i18nc("Add 'Plugin' prefix so that KIPI plugins are obvious in KShortcutsDialog…","Plugin: %1", pluginInfo->name()) );
     }
 #endif
 
     createAnnotationDialog();
     dialog->addCollection( m_annotationDialog->actions(), i18n("Annotation Dialog" ) );
 
     dialog->configure();
 
     delete dialog;
     delete viewer;
 }
 
 void MainWindow::Window::slotSetFileName( const DB::FileName& fileName )
 {
     ImageInfoPtr info;
 
     if ( fileName.isNull() )
         m_statusBar->clearMessage();
     else {
         info = fileName.info();
         if (info != ImageInfoPtr(nullptr) )
             m_statusBar->showMessage( fileName.absolute(), 4000 );
     }
 }
 
 void MainWindow::Window::updateContextMenuFromSelectionSize(int selectionSize)
 {
     m_configAllSimultaniously->setEnabled(selectionSize > 1);
     m_configOneAtATime->setEnabled(selectionSize >= 1);
     m_createImageStack->setEnabled(selectionSize > 1);
     m_unStackImages->setEnabled(selectionSize >= 1);
     m_setStackHead->setEnabled(selectionSize == 1); // FIXME: do we want to check if it's stacked here?
     m_sortByDateAndTime->setEnabled(selectionSize > 1);
     m_recreateThumbnails->setEnabled(selectionSize >= 1);
     m_rotLeft->setEnabled(selectionSize >= 1);
     m_rotRight->setEnabled(selectionSize >= 1);
     m_AutoStackImages->setEnabled(selectionSize > 1);
     m_markUntagged->setEnabled(selectionSize >= 1);
     m_statusBar->mp_selected->setSelectionCount( selectionSize );
     m_clearSelection->setEnabled(selectionSize > 0);
 }
 
 void MainWindow::Window::rotateSelected( int angle )
 {
     const DB::FileNameList list = selected();
     if (list.isEmpty())  {
         KMessageBox::sorry( this, i18n("No item is selected."),
                             i18n("No Selection") );
     } else {
         Q_FOREACH(const DB::FileName& fileName, list) {
             fileName.info()->rotate(angle);
             ImageManager::ThumbnailCache::instance()->removeThumbnail(fileName);
         }
         m_statusBar->mp_dirtyIndicator->markDirty();
     }
 }
 
 void MainWindow::Window::slotRotateSelectedLeft()
 {
     rotateSelected( -90 );
     reloadThumbnails();
 }
 
 void MainWindow::Window::slotRotateSelectedRight()
 {
     rotateSelected( 90 );
     reloadThumbnails();
 }
 
 void MainWindow::Window::reloadThumbnails( ThumbnailView::SelectionUpdateMethod method )
 {
     m_thumbnailView->reload( method );
     updateContextMenuFromSelectionSize( m_thumbnailView->selection().size() );
 }
 
 void MainWindow::Window::slotUpdateViewMenu( DB::Category::ViewType type )
 {
     if ( type == DB::Category::TreeView )
         m_smallListView->setChecked( true );
     else if ( type == DB::Category::ThumbedTreeView )
         m_largeListView->setChecked( true );
     else if ( type == DB::Category::ThumbedIconView )
         m_largeIconView->setChecked( true );
 }
 
 void MainWindow::Window::slotShowNotOnDisk()
 {
     DB::FileNameList notOnDisk;
     Q_FOREACH(const DB::FileName& fileName, DB::ImageDB::instance()->images()) {
         if ( !fileName.exists() )
             notOnDisk.append(fileName);
     }
 
     showThumbNails(notOnDisk);
 }
 
 
 void MainWindow::Window::slotShowImagesWithChangedMD5Sum()
 {
 #ifdef DOES_STILL_NOT_WORK_IN_KPA4
     Utilities::ShowBusyCursor dummy;
     StringSet changed = DB::ImageDB::instance()->imagesWithMD5Changed();
     showThumbNails( changed.toList() );
 #else // DOES_STILL_NOT_WORK_IN_KPA4
     qFatal("Code commented out in MainWindow::Window::slotShowImagesWithChangedMD5Sum");
 #endif // DOES_STILL_NOT_WORK_IN_KPA4
 }
 
 
 void MainWindow::Window::updateStates( bool thumbNailView )
 {
     m_selectAll->setEnabled( thumbNailView );
     m_deleteSelected->setEnabled( thumbNailView );
     m_limitToMarked->setEnabled( thumbNailView );
     m_jumpToContext->setEnabled( thumbNailView );
 }
 
 void MainWindow::Window::slotRunSlideShow()
 {
     slotView( true, true );
 }
 
 void MainWindow::Window::slotRunRandomizedSlideShow()
 {
     slotView( true, true, true );
 }
 
 MainWindow::Window* MainWindow::Window::theMainWindow()
 {
     Q_ASSERT( s_instance );
     return s_instance;
 }
 
 void MainWindow::Window::slotConfigureToolbars()
 {
     QPointer<KEditToolBar> dlg = new KEditToolBar(guiFactory());
     connect(dlg, SIGNAL(newToolbarConfig()),
             SLOT(slotNewToolbarConfig()));
     dlg->exec();
     delete dlg;
 }
 
 void MainWindow::Window::slotNewToolbarConfig()
 {
     createGUI();
     createSearchBar();
 }
 
 void MainWindow::Window::slotImport()
 {
     ImportExport::Import::imageImport();
 }
 
 void MainWindow::Window::slotExport()
 {
     ImportExport::Export::imageExport(selectedOnDisk());
 }
 
 void MainWindow::Window::slotReenableMessages()
 {
     int ret = KMessageBox::questionYesNo( this, i18n("<p>Really enable all message boxes where you previously "
                                                      "checked the do-not-show-again check box?</p>" ) );
     if ( ret == KMessageBox::Yes )
         KMessageBox::enableAllMessages();
 
 }
 
 void MainWindow::Window::setupPluginMenu()
 {
     QMenu* menu = findChild<QMenu*>( QString::fromLatin1("plugins") );
     if ( !menu ) {
         KMessageBox::error( this, i18n("<p>KPhotoAlbum hit an internal error (missing plug-in menu in MainWindow::Window::setupPluginMenu). This indicate that you forgot to do a make install. If you did compile KPhotoAlbum yourself, then please run make install. If not, please report this as a bug.</p><p>KPhotoAlbum will continue execution, but it is not entirely unlikely that it will crash later on due to the missing make install.</p>" ), i18n("Internal Error") );
-        m_hasLoadedPlugins = true;
+        m_hasLoadedKipiPlugins = true;
         return; // This is no good, but lets try and continue.
     }
 
+#ifdef KF5Purpose_FOUND
+    Plugins::PurposeMenu *purposeMenu = new Plugins::PurposeMenu(menu);
+    connect(m_thumbnailView, &ThumbnailView::ThumbnailFacade::selectionChanged,
+            purposeMenu, &Plugins::PurposeMenu::slotSelectionChanged);
+    connect(purposeMenu, &Plugins::PurposeMenu::imageShared
+            , [this](QUrl shareLocation) {
+        QString message;
+        if (shareLocation.isValid())
+        {
+            message = i18n("Successfully shared image(s). Copying location to clipboard...");
+            QGuiApplication::clipboard()->setText(shareLocation.toString());
+        } else {
+            message = i18n("Successfully shared image(s).");
+        }
+        m_statusBar->showMessage(message);
+    });
+    connect(purposeMenu, &Plugins::PurposeMenu::imageSharingFailed
+            , [this](QString errorMessage){
+        QString message = i18n("Image sharing failed with mesage: %1", errorMessage);
+        m_statusBar->showMessage(message);
+    });
+#endif
 
 #ifdef HASKIPI
-    connect(menu, &QMenu::aboutToShow, this, &Window::loadPlugins);
-    m_hasLoadedPlugins = false;
+    connect(menu, &QMenu::aboutToShow, this, &Window::loadKipiPlugins);
+    m_hasLoadedKipiPlugins = false;
 #else
+#ifndef KF5Purpose_FOUND
     menu->setEnabled(false);
-    m_hasLoadedPlugins = true;
+#endif
+    m_hasLoadedKipiPlugins = true;
 #endif
 }
 
-void MainWindow::Window::loadPlugins()
+void MainWindow::Window::loadKipiPlugins()
 {
 #ifdef HASKIPI
     Utilities::ShowBusyCursor dummy;
-    if ( m_hasLoadedPlugins )
+    if ( m_hasLoadedKipiPlugins )
         return;
 
     m_pluginInterface = new Plugins::Interface( this, QString::fromLatin1("KPhotoAlbum kipi interface") );
     connect(m_pluginInterface, &Plugins::Interface::imagesChanged, this, &Window::slotImagesChanged);
 
     QStringList ignores;
     ignores << QString::fromLatin1( "CommentsEditor" )
             << QString::fromLatin1( "HelloWorld" );
 
     m_pluginLoader = new KIPI::PluginLoader();
     m_pluginLoader->setIgnoredPluginsList( ignores );
     m_pluginLoader->setInterface( m_pluginInterface );
     m_pluginLoader->init();
     connect(m_pluginLoader, &KIPI::PluginLoader::replug, this, &Window::plug);
     m_pluginLoader->loadPlugins();
 
     // Setup signals
     connect(m_thumbnailView, &ThumbnailView::ThumbnailFacade::selectionChanged, this, &Window::slotSelectionChanged);
-    m_hasLoadedPlugins = true;
+    m_hasLoadedKipiPlugins = true;
 
     // Make sure selection is updated also when plugin loading is
     // delayed. This is needed, because selection might already be
     // non-empty when loading the plugins.
     slotSelectionChanged(selected().size());
 #endif // HASKIPI
 }
 
 
 void MainWindow::Window::plug()
 {
 #ifdef HASKIPI
     unplugActionList( QString::fromLatin1("import_actions") );
     unplugActionList( QString::fromLatin1("export_actions") );
     unplugActionList( QString::fromLatin1("image_actions") );
     unplugActionList( QString::fromLatin1("tool_actions") );
     unplugActionList( QString::fromLatin1("batch_actions") );
 
     QList<QAction*> importActions;
     QList<QAction*> exportActions;
     QList<QAction*> imageActions;
     QList<QAction*> toolsActions;
     QList<QAction*> batchActions;
 
     KIPI::PluginLoader::PluginList list = m_pluginLoader->pluginList();
     Q_FOREACH( const KIPI::PluginLoader::Info *pluginInfo, list ) {
         KIPI::Plugin* plugin = pluginInfo->plugin();
         if ( !plugin || !pluginInfo->shouldLoad() )
             continue;
 
         plugin->setup( this );
 
         QList<QAction*> actions = plugin->actions();
         Q_FOREACH( QAction *action, actions ) {
             KIPI::Category category = plugin->category( action );
             if (  category == KIPI::ImagesPlugin ||  category == KIPI::CollectionsPlugin )
                 imageActions.append( action );
 
             else if ( category == KIPI::ImportPlugin )
                 importActions.append( action );
 
             else if ( category == KIPI::ExportPlugin )
                 exportActions.append( action );
 
             else if ( category == KIPI::ToolsPlugin )
                 toolsActions.append( action );
 
             else if ( category == KIPI::BatchPlugin )
                 batchActions.append( action );
 
             else {
                 qCWarning(MainWindowLog) << "Unknown category\n";
             }
         }
         KConfigGroup group = KSharedConfig::openConfig()->group( QString::fromLatin1("Shortcuts") );
         plugin->actionCollection()->importGlobalShortcuts( &group );
     }
 
 
     setPluginMenuState( "importplugin", importActions );
     setPluginMenuState( "exportplugin", exportActions );
     setPluginMenuState( "imagesplugins", imageActions );
     setPluginMenuState( "batch_plugins", batchActions );
     setPluginMenuState( "tool_plugins", toolsActions );
 
     // For this to work I need to pass false as second arg for createGUI
     plugActionList( QString::fromLatin1("import_actions"), importActions );
     plugActionList( QString::fromLatin1("export_actions"), exportActions );
     plugActionList( QString::fromLatin1("image_actions"), imageActions );
     plugActionList( QString::fromLatin1("tool_actions"), toolsActions );
     plugActionList( QString::fromLatin1("batch_actions"), batchActions );
 #endif
 }
 
 void MainWindow::Window::setPluginMenuState( const char* name, const QList<QAction*>& actions )
 {
     QMenu* menu = findChild<QMenu*>( QString::fromLatin1(name) );
     if ( menu )
         menu->setEnabled(actions.count() != 0);
 }
 
 
 
 void MainWindow::Window::slotImagesChanged( const QList<QUrl>& urls )
 {
     for( QList<QUrl>::ConstIterator it = urls.begin(); it != urls.end(); ++it ) {
         DB::FileName fileName = DB::FileName::fromAbsolutePath((*it).path());
         if ( !fileName.isNull()) {
             // Plugins may report images outsite of the photodatabase
             // This seems to be the case with the border image plugin, which reports the destination image
             ImageManager::ThumbnailCache::instance()->removeThumbnail( fileName );
             // update MD5sum:
             MD5 md5sum = MD5Sum( fileName );
             fileName.info()->setMD5Sum( md5sum );
         }
     }
     m_statusBar->mp_dirtyIndicator->markDirty();
     reloadThumbnails( ThumbnailView::MaintainSelection );
 }
 
 DB::ImageSearchInfo MainWindow::Window::currentContext()
 {
     return m_browser->currentContext();
 }
 
 QString MainWindow::Window::currentBrowseCategory() const
 {
     return m_browser->currentCategory();
 }
 
 void MainWindow::Window::slotSelectionChanged( int count )
 {
 #ifdef HASKIPI
     m_pluginInterface->slotSelectionChanged( count != 0 );
 #else
     Q_UNUSED( count );
 #endif
 }
 
 void MainWindow::Window::resizeEvent( QResizeEvent* )
 {
     if ( Settings::SettingsData::ready() && isVisible() )
         Settings::SettingsData::instance()->setWindowGeometry( Settings::MainWindow, geometry() );
 }
 
 void MainWindow::Window::moveEvent( QMoveEvent * )
 {
     if ( Settings::SettingsData::ready() && isVisible() )
         Settings::SettingsData::instance()->setWindowGeometry( Settings::MainWindow, geometry() );
 }
 
 
 void MainWindow::Window::slotRemoveTokens()
 {
     if ( !m_tokenEditor )
         m_tokenEditor = new TokenEditor( this );
     m_tokenEditor->show();
     connect(m_tokenEditor, &TokenEditor::finished, m_browser, &Browser::BrowserWidget::go);
 }
 
 void MainWindow::Window::slotShowListOfFiles()
 {
     QStringList list = QInputDialog::getMultiLineText( this,
                                                        i18n("Open List of Files"),
                                                        i18n("You can open a set of files from KPhotoAlbum's image root by listing the files here.")
                                                        )
             .split( QChar::fromLatin1('\n'), QString::SkipEmptyParts );
     if ( list.isEmpty() )
         return;
 
     DB::FileNameList out;
     for ( QStringList::const_iterator it = list.constBegin(); it != list.constEnd(); ++it ) {
         QString fileNameStr = Utilities::imageFileNameToAbsolute( *it );
         if ( fileNameStr.isNull() )
             continue;
         const DB::FileName fileName = DB::FileName::fromAbsolutePath(fileNameStr);
         if ( !fileName.isNull() )
             out.append(fileName);
     }
 
     if (out.isEmpty())
         KMessageBox::sorry( this, i18n("No images matching your input were found."), i18n("No Matches") );
     else
         showThumbNails(out);
 }
 
 void MainWindow::Window::updateDateBar( const Browser::BreadcrumbList& path )
 {
     static QString lastPath = QString::fromLatin1("ThisStringShouldNeverBeSeenSoWeUseItAsInitialContent");
     if ( path.toString() != lastPath )
         updateDateBar();
     lastPath = path.toString();
 }
 
 void MainWindow::Window::updateDateBar()
 {
     m_dateBar->setImageDateCollection( DB::ImageDB::instance()->rangeCollection() );
 }
 
 
 void MainWindow::Window::slotShowImagesWithInvalidDate()
 {
     QPointer<InvalidDateFinder> finder = new InvalidDateFinder( this );
     if ( finder->exec() == QDialog::Accepted )
         showThumbNails();
     delete finder;
 }
 
 void MainWindow::Window::showDateBarTip( const QString& msg )
 {
     m_statusBar->showMessage( msg, 3000 );
 }
 
 void MainWindow::Window::slotJumpToContext()
 {
     const DB::FileName fileName =m_thumbnailView->currentItem();
     if ( !fileName.isNull() ) {
         m_browser->addImageView(fileName);
     }
 }
 
 void MainWindow::Window::setDateRange( const DB::ImageDate& range )
 {
     DB::ImageDB::instance()->setDateRange( range, m_dateBar->includeFuzzyCounts() );
     m_statusBar->mp_partial->showBrowserMatches( this->selected().size() );
     m_browser->reload();
     reloadThumbnails( ThumbnailView::MaintainSelection );
 }
 
 void MainWindow::Window::clearDateRange()
 {
     DB::ImageDB::instance()->clearDateRange();
     m_browser->reload();
     reloadThumbnails( ThumbnailView::MaintainSelection );
 }
 
 void MainWindow::Window::showThumbNails(const DB::FileNameList& items)
 {
     m_thumbnailView->setImageList(items);
     m_statusBar->mp_partial->setMatchCount(items.size());
     showThumbNails();
 }
 
 void MainWindow::Window::slotRecalcCheckSums()
 {
     DB::ImageDB::instance()->slotRecalcCheckSums( selected() );
 }
 
 void MainWindow::Window::slotShowExifInfo()
 {
     DB::FileNameList items = selectedOnDisk();
     if (!items.isEmpty()) {
         Exif::InfoDialog* exifDialog = new Exif::InfoDialog(items.at(0), this);
         exifDialog->show();
     }
 }
 
 void MainWindow::Window::showFeatures()
 {
     FeatureDialog dialog(this);
     dialog.exec();
 }
 
 void MainWindow::Window::showImage( const DB::FileName& fileName )
 {
     launchViewer(DB::FileNameList() << fileName, true, false, false);
 }
 
 void MainWindow::Window::slotBuildThumbnails()
 {
     ImageManager::ThumbnailBuilder::instance()->buildAll( ImageManager::StartNow );
 }
 
 void MainWindow::Window::slotBuildThumbnailsIfWanted()
 {
     ImageManager::ThumbnailCache::instance()->flush();
     if ( ! Settings::SettingsData::instance()->incrementalThumbnails())
         ImageManager::ThumbnailBuilder::instance()->buildAll( ImageManager::StartDelayed );
 }
 
 void MainWindow::Window::slotOrderIncr()
 {
     m_thumbnailView->setSortDirection( ThumbnailView::OldestFirst );
 }
 
 void MainWindow::Window::slotOrderDecr()
 {
     m_thumbnailView->setSortDirection( ThumbnailView::NewestFirst );
 }
 
 void MainWindow::Window::showVideos()
 {
     QDesktopServices::openUrl(QUrl(
         QStringLiteral("http://www.kphotoalbum.org/documentation/videos/")));
 }
 
 void MainWindow::Window::slotStatistics()
 {
     static StatisticsDialog* dialog = new StatisticsDialog(this);
     dialog->show();
 }
 
 void MainWindow::Window::slotMarkUntagged()
 {
     if (Settings::SettingsData::instance()->hasUntaggedCategoryFeatureConfigured()) {
         for (const DB::FileName& newFile : selected()) {
             newFile.info()->addCategoryInfo(Settings::SettingsData::instance()->untaggedCategory(),
                                             Settings::SettingsData::instance()->untaggedTag());
         }
 
         DirtyIndicator::markDirty();
     } else {
         // Note: the same dialog text is used in
         // Browser::OverviewPage::activateUntaggedImagesAction(),
         // so if it is changed, be sure to also change it there!
         KMessageBox::information(this,
                                  i18n("<p>You have not yet configured which tag to use for indicating untagged images."
                                       "</p>"
                                       "<p>Please follow these steps to do so:"
                                       "<ul><li>In the menu bar choose <b>Settings</b></li>"
                                       "<li>From there choose <b>Configure KPhotoAlbum</b></li>"
                                       "<li>Now choose the <b>Categories</b> icon</li>"
                                       "<li>Now configure section <b>Untagged Images</b></li></ul></p>"),
                                  i18n("Feature has not been configured")
                                  );
     }
 }
 
 void MainWindow::Window::setupStatusBar()
 {
     m_statusBar = new MainWindow::StatusBar;
     setStatusBar( m_statusBar );
     setLocked( Settings::SettingsData::instance()->locked(), true, false );
     connect(m_statusBar, &StatusBar::thumbnailSettingsRequested
             , [this](){
         this->slotOptions();
         m_settingsDialog->activatePage(Settings::SettingsPage::ThumbnailsPage);
     });
 }
 
 void MainWindow::Window::slotRecreateExifDB()
 {
     Exif::Database::instance()->recreate();
 }
 
 void MainWindow::Window::useNextVideoThumbnail()
 {
     UpdateVideoThumbnail::useNext(selected());
 }
 
 void MainWindow::Window::usePreviousVideoThumbnail()
 {
     UpdateVideoThumbnail::usePrevious(selected());
 }
 
 void MainWindow::Window::mergeDuplicates()
 {
     DuplicateMerger* merger = new DuplicateMerger;
     merger->show();
 }
 
 void MainWindow::Window::slotThumbnailSizeChanged()
 {
     QString thumbnailSizeMsg = i18nc( "@info:status",
                                       //xgettext:no-c-format
                                       "Thumbnail width: %1px (storage size: %2px)",
                                       Settings::SettingsData::instance()->actualThumbnailSize(),
                                       Settings::SettingsData::instance()->thumbnailSize()
                                       );
     m_statusBar->showMessage( thumbnailSizeMsg, 4000);
 }
 
 void MainWindow::Window::createSearchBar()
 {
     // Set up the search tool bar
     SearchBar* bar = new SearchBar( this );
     bar->setLineEditEnabled(false);
     bar->setObjectName(QString::fromUtf8("searchBar"));
 
     connect(bar, &SearchBar::textChanged, m_browser, &Browser::BrowserWidget::slotLimitToMatch);
     connect(bar, &SearchBar::returnPressed, m_browser, &Browser::BrowserWidget::slotInvokeSeleted);
     connect(bar, &SearchBar::keyPressed, m_browser, &Browser::BrowserWidget::scrollKeyPressed);
     connect(m_browser, &Browser::BrowserWidget::viewChanged, bar, &SearchBar::reset);
     connect(m_browser, &Browser::BrowserWidget::isSearchable, bar, &SearchBar::setLineEditEnabled);
 }
 
 void MainWindow::Window::executeStartupActions()
 {
     new ImageManager::ThumbnailBuilder( m_statusBar, this );
     if ( ! Settings::SettingsData::instance()->incrementalThumbnails())
         ImageManager::ThumbnailBuilder::instance()->buildMissing();
     connect( Settings::SettingsData::instance(), SIGNAL(thumbnailSizeChanged(int)), this, SLOT(slotBuildThumbnailsIfWanted()) );
 
     if ( ! FeatureDialog::hasVideoThumbnailer() ) {
         BackgroundTaskManager::JobManager::instance()->addJob(
                     new BackgroundJobs::SearchForVideosWithoutLengthInfo );
 
         BackgroundTaskManager::JobManager::instance()->addJob(
                     new BackgroundJobs::SearchForVideosWithoutVideoThumbnailsJob );
     }
 }
 
 void MainWindow::Window::checkIfVideoThumbnailerIsInstalled()
 {
     if (Options::the()->demoMode())
         return;
 
     if ( !FeatureDialog::hasVideoThumbnailer() ) {
         KMessageBox::information( this,
                                   i18n("<p>Unable to find ffmpeg on the system.</p>"
                                        "<p>Without it, KPhotoAlbum will not be able to display video thumbnails and video lengths. "
                                        "Please install the ffmpeg package</p>"),
                                   i18n("Video thumbnails are not available"), QString::fromLatin1("VideoThumbnailerNotInstalled"));
     }
 }
 
 bool MainWindow::Window::anyVideosSelected() const
 {
     Q_FOREACH(const DB::FileName& fileName, selected()) {
         if ( Utilities::isVideo(fileName))
             return true;
     }
     return false;
 }
 
 void MainWindow::Window::setHistogramVisibilty( bool visible ) const
 {
     if (visible)
     {
         m_dateBar->show();
         m_dateBarLine->show();
     }
     else
     {
         m_dateBar->hide();
         m_dateBarLine->hide();
     }
 }
 
 void MainWindow::Window::slotImageRotated(const DB::FileName& fileName)
 {
     // An image has been rotated by the annotation dialog or the viewer.
     // We have to reload the respective thumbnail to get it in the right angle
     ImageManager::ThumbnailCache::instance()->removeThumbnail(fileName);
 }
 
 bool MainWindow::Window::dbIsDirty() const
 {
     return m_statusBar->mp_dirtyIndicator->isSaveDirty();
 }
 
 #ifdef HAVE_KGEOMAP
 void MainWindow::Window::showPositionBrowser()
 {
     Browser::PositionBrowserWidget *positionBrowser = positionBrowserWidget();
     m_stack->setCurrentWidget(positionBrowser);
     updateStates( false );
 }
 
 Browser::PositionBrowserWidget* MainWindow::Window::positionBrowserWidget()
 {
     if (m_positionBrowser == 0) {
         m_positionBrowser = createPositionBrowser();
     }
     return m_positionBrowser;
 }
 
 Browser::PositionBrowserWidget* MainWindow::Window::createPositionBrowser()
 {
     Browser::PositionBrowserWidget* widget = new Browser::PositionBrowserWidget(m_stack);
     m_stack->addWidget(widget);
     return widget;
 }
 #endif
 
 UserFeedback MainWindow::Window::askWarningContinueCancel(const QString &msg, const QString &title, const QString &dialogId)
 {
     auto answer = KMessageBox::warningContinueCancel(this, msg, title, KStandardGuiItem::cont(), KStandardGuiItem::cancel(), dialogId);
     return (answer==KMessageBox::Continue) ? UserFeedback::Confirm : UserFeedback::Deny;
 }
 
 UserFeedback MainWindow::Window::askQuestionYesNo(const QString &msg, const QString &title, const QString &dialogId)
 {
     auto answer = KMessageBox::questionYesNo(this, msg, title, KStandardGuiItem::yes(), KStandardGuiItem::no(), dialogId);
     return (answer==KMessageBox::Yes) ? UserFeedback::Confirm : UserFeedback::Deny;
 }
 
 void MainWindow::Window::showInformation(const QString &msg, const QString &title, const QString &dialogId)
 {
     KMessageBox::information(this, msg, title, dialogId);
 }
 
 void MainWindow::Window::showSorry(const QString &msg, const QString &title, const QString &)
 {
     KMessageBox::sorry(this, msg, title);
 }
 
 void MainWindow::Window::showError(const QString &msg, const QString &title, const QString &)
 {
     KMessageBox::error(this, msg, title);
 }
 
 bool MainWindow::Window::isDialogDisabled(const QString &dialogId)
 {
     // Note(jzarl): there are different methods for different kinds of dialogs.
     // However, all these methods share exactly the same code in KMessageBox.
     // If that ever changes, we can still update our implementation - until then I won't just copy a stupid API...
     return !KMessageBox::shouldBeShownContinue(dialogId);
 }
 
 // vi:expandtab:tabstop=4 shiftwidth=4:
diff --git a/MainWindow/Window.h b/MainWindow/Window.h
index bda1cb55..16f1f37a 100644
--- a/MainWindow/Window.h
+++ b/MainWindow/Window.h
@@ -1,283 +1,283 @@
 /* Copyright (C) 2003-2019 The KPhotoAlbum Development Team
 
    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; see the file COPYING.  If not, write to
    the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
    Boston, MA 02110-1301, USA.
 */
 
 #ifndef MAINWINDOW_WINDOW_H
 #define MAINWINDOW_WINDOW_H
 #include <config-kpa-kipi.h>
 
 #include <QList>
 #include <QPointer>
 #include <QUrl>
 
 #include <KXmlGuiWindow>
 
 #include <DB/Category.h>
 #include <DB/FileNameList.h>
 #include <DB/ImageSearchInfo.h>
 #include <DB/UIDelegate.h>
 #include <ThumbnailView/enums.h>
 #ifdef HAVE_KGEOMAP
 #include <Browser/PositionBrowserWidget.h>
 #endif
 
 class QAction;
 class QCloseEvent;
 class QContextMenuEvent;
 class QFrame;
 class QLabel;
 class QMoveEvent;
 class QResizeEvent;
 class QStackedWidget;
 class QTimer;
 
 class KActionMenu;
 class KTipDialog;
 class KToggleAction;
 
 #ifdef HASKIPI
 namespace KIPI { class PluginLoader; }
 #endif
 
 namespace AnnotationDialog { class Dialog; }
 namespace Browser{ class BrowserWidget; class BreadcrumbList; }
 namespace DateBar { class DateBarWidget; }
 namespace DB { class ImageInfoList; }
 namespace HTMLGenerator { class HTMLDialog; }
 namespace Plugins { class Interface; }
 namespace Settings { class SettingsDialog; }
 namespace ThumbnailView { class ThumbnailFacade; }
 
 class BreadcrumbViewer;
 
 namespace MainWindow
 {
 class DeleteDialog;
 class StatusBar;
 class TokenEditor;
 
 class Window :public KXmlGuiWindow
         , public DB::UIDelegate
 {
     Q_OBJECT
 
 public:
     explicit Window( QWidget* parent );
     ~Window() override;
     static void configureImages( const DB::ImageInfoList& list, bool oneAtATime );
     static Window* theMainWindow();
     DB::FileNameList selected( ThumbnailView::SelectionMode mode = ThumbnailView::ExpandCollapsedStacks ) const;
     DB::ImageSearchInfo currentContext();
     QString currentBrowseCategory() const;
     void setStackHead( const DB::FileName& image );
     void setHistogramVisibilty( bool visible ) const;
     bool dbIsDirty() const;
 #ifdef HAVE_KGEOMAP
     void showPositionBrowser();
     Browser::PositionBrowserWidget* positionBrowserWidget();
 #endif
 
     // implement UI delegate interface
     // Note(jzarl): we just could create a UIDelegate class that takes a QWidget,
     // implementing the same messageParent approach that we took before.
     // For now, I don't see anything wrong with directly implementing the interface instead.
     // I may change my mind later and I'm ready to convinced of the errors of my way, though...
     DB::UserFeedback askWarningContinueCancel(const QString &msg, const QString &title, const QString &dialogId) override;
     DB::UserFeedback askQuestionYesNo(const QString &msg, const QString &title, const QString &dialogId) override;
     void showInformation(const QString &msg, const QString &title, const QString &dialogId) override;
     void showSorry(const QString &msg, const QString &title, const QString &) override;
     void showError(const QString &msg, const QString &title, const QString &) override;
     bool isDialogDisabled(const QString &dialogId) override;
 
 public slots:
     void showThumbNails(const DB::FileNameList& items);
-    void loadPlugins();
+    void loadKipiPlugins();
     void reloadThumbnails( ThumbnailView::SelectionUpdateMethod method = ThumbnailView::MaintainSelection );
     void runDemo();
     void slotImageRotated(const DB::FileName& fileName);
     void slotSave();
 
 protected slots:
     void showThumbNails();
     bool slotExit();
     void slotOptions();
     void slotConfigureAllImages();
     void slotConfigureImagesOneAtATime();
     void slotCreateImageStack();
     void slotUnStackImages();
     void slotSetStackHead();
     void slotCopySelectedURLs();
     void slotPasteInformation();
     void slotDeleteSelected();
     void slotReReadExifInfo();
     void slotAutoStackImages();
     void slotSearch();
     void slotView( bool reuse = true, bool slideShow = false, bool random = false );
     void slotViewNewWindow();
     void slotSortByDateAndTime();
     void slotSortAllByDateAndTime();
     void slotLimitToSelected();
     void slotExportToHTML();
     void slotAutoSave();
     void showBrowser();
     void slotOptionGroupChanged();
     void showTipOfDay();
     void lockToDefaultScope();
     void setDefaultScopePositive();
     void setDefaultScopeNegative();
     void unlockFromDefaultScope();
     void changePassword();
     void slotConfigureKeyBindings();
     void slotSetFileName( const DB::FileName& );
     void updateContextMenuFromSelectionSize(int selectionSize);
     void slotUpdateViewMenu( DB::Category::ViewType );
     void slotShowNotOnDisk();
     void slotBuildThumbnails();
     void slotBuildThumbnailsIfWanted();
     void slotRunSlideShow();
     void slotRunRandomizedSlideShow();
     void slotConfigureToolbars();
     void slotNewToolbarConfig();
     void slotImport();
     void slotExport();
     void delayedInit();
     void slotReenableMessages();
     void slotImagesChanged( const QList<QUrl>& );
     void slotSelectionChanged(int count);
     void plug();
     void slotRemoveTokens();
     void slotShowListOfFiles();
     void updateDateBar( const Browser::BreadcrumbList& );
     void updateDateBar();
     void slotShowImagesWithInvalidDate();
     void slotShowImagesWithChangedMD5Sum();
     void showDateBarTip( const QString& );
     void slotJumpToContext();
     void setDateRange( const DB::ImageDate& );
     void clearDateRange();
     void startAutoSaveTimer();
     void slotRecalcCheckSums();
     void slotShowExifInfo();
     void showFeatures();
     void showImage( const DB::FileName& fileName );
     void slotOrderIncr();
     void slotOrderDecr();
     void slotRotateSelectedLeft();
     void slotRotateSelectedRight();
     void rotateSelected( int angle );
     void showVideos();
     void slotStatistics();
     void slotRecreateExifDB();
     void useNextVideoThumbnail();
     void usePreviousVideoThumbnail();
     void mergeDuplicates();
     void slotThumbnailSizeChanged();
     void slotMarkUntagged();
 
 protected:
     void configureImages( bool oneAtATime );
     QString welcome();
     void closeEvent( QCloseEvent* e ) override;
     void resizeEvent( QResizeEvent* ) override;
     void moveEvent ( QMoveEvent * ) override;
     void setupMenuBar();
     void createAnnotationDialog();
     bool load();
     void contextMenuEvent( QContextMenuEvent* e ) override;
     void setLocked( bool b, bool force, bool recount=true );
     void configImages( const DB::ImageInfoList& list, bool oneAtATime );
     void updateStates( bool thumbNailView );
     DB::FileNameList selectedOnDisk();
     void setupPluginMenu();
     void launchViewer(const DB::FileNameList& mediaList, bool reuse, bool slideShow, bool random);
     void setupStatusBar();
     void setPluginMenuState( const char* name, const QList<QAction*>& actions );
     void createSearchBar();
     void executeStartupActions();
     void checkIfVideoThumbnailerIsInstalled();
     bool anyVideosSelected() const;
 #ifdef HAVE_KGEOMAP
     Browser::PositionBrowserWidget* createPositionBrowser();
 #endif
 
 private:
     static Window* s_instance;
 
     ThumbnailView::ThumbnailFacade* m_thumbnailView;
     Settings::SettingsDialog* m_settingsDialog;
     QPointer<AnnotationDialog::Dialog> m_annotationDialog;
     QStackedWidget* m_stack;
     QTimer* m_autoSaveTimer;
     Browser::BrowserWidget* m_browser;
     DeleteDialog* m_deleteDialog;
     QAction* m_lock;
     QAction* m_unlock;
     QAction* m_setDefaultPos;
     QAction* m_setDefaultNeg;
     QAction* m_jumpToContext;
     HTMLGenerator::HTMLDialog* m_htmlDialog;
     QAction* m_configOneAtATime;
     QAction* m_configAllSimultaniously;
     QAction* m_createImageStack;
     QAction* m_unStackImages;
     QAction* m_setStackHead;
     QAction* m_view;
     QAction* m_rotLeft;
     QAction* m_rotRight;
     QAction* m_sortByDateAndTime;
     QAction* m_sortAllByDateAndTime;
     QAction* m_AutoStackImages;
     QAction* m_viewInNewWindow;
     KActionMenu* m_viewMenu;
     KToggleAction* m_smallListView;
     KToggleAction* m_largeListView;
     KToggleAction* m_largeIconView;
     QAction* m_generateHtml;
     QAction* m_copy;
     QAction* m_paste;
     QAction* m_deleteSelected;
     QAction* m_limitToMarked;
     QAction* m_selectAll;
     QAction* m_clearSelection;
     QAction* m_runSlideShow;
     QAction* m_runRandomSlideShow;
     Plugins::Interface* m_pluginInterface;
     QAction* m_showExifDialog;
 #ifdef HASKIPI
     KIPI::PluginLoader* m_pluginLoader;
 #endif
     QAction* m_recreateThumbnails;
     QAction* m_useNextVideoThumbnail;
     QAction* m_usePreviousVideoThumbnail;
     QAction* m_markUntagged;
     TokenEditor* m_tokenEditor;
     DateBar::DateBarWidget* m_dateBar;
     QFrame* m_dateBarLine;
-    bool m_hasLoadedPlugins;
+    bool m_hasLoadedKipiPlugins;
     QMap<Qt::Key, QPair<QString,QString> > m_viewerInputMacros;
     MainWindow::StatusBar* m_statusBar;
     QString m_lastTarget;
 #ifdef HAVE_KGEOMAP
     Browser::PositionBrowserWidget* m_positionBrowser;
 #endif
 };
 
 }
 
 #endif /* MAINWINDOW_WINDOW_H */
 
 // vi:expandtab:tabstop=4 shiftwidth=4:
diff --git a/Plugins/PurposeMenu.cpp b/Plugins/PurposeMenu.cpp
new file mode 100644
index 00000000..9d61dfa6
--- /dev/null
+++ b/Plugins/PurposeMenu.cpp
@@ -0,0 +1,97 @@
+/* Copyright (C) 2019 The KPhotoAlbum Development Team
+ *
+ *  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) version 3 or any later version
+ *  accepted by the membership of KDE e. V. (or its successor approved
+ *  by the membership of KDE e. V.), which shall act as a proxy
+ *  defined in Section 14 of version 3 of the license.
+ *
+ *  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, see <http://www.gnu.org/licenses/>.
+*/
+
+#include "PurposeMenu.h"
+#include "Logging.h"
+
+#include <MainWindow/Window.h>
+
+#include <KLocalizedString>
+#include <Purpose/AlternativesModel>
+#include <PurposeWidgets/Menu>
+#include <QJsonArray>
+#include <QJsonObject>
+#include <QMenu>
+
+Plugins::PurposeMenu::PurposeMenu(QMenu *parent)
+    : QObject(parent)
+    , m_parentMenu(parent)
+    , m_purposeMenu(new Purpose::Menu(parent))
+    , m_menuUpdateNeeded(true)
+{
+    loadPurposeMenu();
+}
+
+void Plugins::PurposeMenu::slotSelectionChanged()
+{
+    m_menuUpdateNeeded = true;
+    m_purposeMenu->clear();
+    qCDebug(PluginsLog) << "Purpose menu items invalidated...";
+}
+
+void Plugins::PurposeMenu::loadPurposeMenu()
+{
+    // attach the menu
+    QAction *purposeMenu = m_parentMenu->addMenu(m_purposeMenu);
+    purposeMenu->setText(i18n("Share"));
+    purposeMenu->setIcon(QIcon::fromTheme(QStringLiteral("document-share")));
+
+    // set up the callback signal
+    connect(m_purposeMenu, &Purpose::Menu::finished, this, [this](const QJsonObject &output, int error, const QString &message) {
+        if (error) {
+            qCDebug(PluginsLog) << "Failed to share image:" << message;
+            emit imageSharingFailed(message);
+        } else {
+            // Note: most plugins don't seem to actually return anything in the url field...
+            const QUrl returnUrl = QUrl(output[QStringLiteral("url")].toString(), QUrl::ParsingMode::StrictMode);
+            qCDebug(PluginsLog) << "Image shared successfully.";
+            qCDebug(PluginsLog) << "Raw json data: " << output;
+            emit imageShared(returnUrl);
+        }
+    });
+
+    // update available options based on the latest picture
+    connect(m_purposeMenu, &QMenu::aboutToShow, this, &PurposeMenu::loadPurposeItems);
+    qCDebug(PluginsLog) << "Purpose menu loaded...";
+}
+
+void Plugins::PurposeMenu::loadPurposeItems()
+{
+    if (!m_menuUpdateNeeded) {
+        return;
+    }
+    m_menuUpdateNeeded = false;
+
+    const DB::FileNameList images = MainWindow::Window::theMainWindow()->selected(ThumbnailView::NoExpandCollapsedStacks);
+    QJsonArray urls;
+    for (const auto &image : images)
+    {
+        urls.append(QUrl(image).toString());
+    }
+
+    // "image/jpeg" is certainly not always true, but the interface does not allow a mimeType list
+    // and the plugins likely won't care...
+    m_purposeMenu->model()->setInputData(QJsonObject {
+        {  QStringLiteral("mimeType"), QStringLiteral("image/jpeg") },
+        { QStringLiteral("urls"), urls }
+    });
+    m_purposeMenu->model()->setPluginType(QStringLiteral("Export"));
+    m_purposeMenu->reload();
+    qCDebug(PluginsLog) << "Purpose menu items loaded...";
+}
diff --git a/Plugins/PurposeMenu.h b/Plugins/PurposeMenu.h
new file mode 100644
index 00000000..bc3e2ea3
--- /dev/null
+++ b/Plugins/PurposeMenu.h
@@ -0,0 +1,76 @@
+/* Copyright (C) 2019 The KPhotoAlbum Development Team
+ *
+ *  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) version 3 or any later version
+ *  accepted by the membership of KDE e. V. (or its successor approved
+ *  by the membership of KDE e. V.), which shall act as a proxy
+ *  defined in Section 14 of version 3 of the license.
+ *
+ *  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, see <http://www.gnu.org/licenses/>.
+*/
+
+#ifndef KPHOTOALBUM_PURPOSEMENU_H
+#define KPHOTOALBUM_PURPOSEMENU_H
+
+#include <config-kpa-kipi.h>
+
+#include <QObject>
+#include <QString>
+#include <QUrl>
+
+class QMenu;
+
+namespace Purpose {
+class Menu;
+}
+
+namespace Plugins
+{
+
+class PurposeMenu: public QObject
+{
+    Q_OBJECT
+public:
+    explicit PurposeMenu( QMenu *parent);
+
+public slots:
+    void slotSelectionChanged();
+
+signals:
+    /**
+     * @brief imageShared is emitted when an image was shared successfully.
+     * The url contains the optional location of the shared data
+     * (e.g. for plugins that upload to a remote location).
+     */
+    void imageShared(QUrl);
+    void imageSharingFailed(QString message);
+
+private:
+    QMenu *m_parentMenu;
+    Purpose::Menu *m_purposeMenu;
+    bool m_menuUpdateNeeded; ///< Keeps track of changed image selection
+    /**
+     * @brief Load the Purpose::Menu, add it to the parent menu, and set up connections.
+     */
+    void loadPurposeMenu();
+    /**
+     * @brief Load Purpose menu items into the Purpose::Menu.
+     * This is dependent on the current set of images.
+     */
+    void loadPurposeItems();
+};
+
+}
+
+
+#endif /* PURPOSEMENU_H */
+
+// vi:expandtab:tabstop=4 shiftwidth=4:
diff --git a/Plugins/documentation.h b/Plugins/documentation.h
index a331c110..3d47d990 100644
--- a/Plugins/documentation.h
+++ b/Plugins/documentation.h
@@ -1,14 +1,21 @@
 //krazy:skip
 /**
   \namespace Plugins
-  \brief Implementation of the KIPI interface.
+  \brief Implementation of the KIPI and Purpose interfaces.
 
-  Status:
+  As of this writing, KIPI is no longer maintained and will probably phase out of distributions soon.
+  Purpose, on the other hand, is a replacement for some, but not (yet) all things that KIPI plugins could do.
+
+  ## KIPI Status:
   <ul>
   <li>Last checked against libkipi version 5.1.0 (v16.07.80).</li>
   <li>Implemented features are described by Plugins::Interface::features()</li>
   <li>As far as implemented, everything should work.</li>
   <li>Some concepts, such as image orientation, have no exact match between libkipi and kphotoalbum.</li>
   </ul>
+
+  ## Purpose Status:
+   - Sharing images is possible
+   - Success/error feedback does not yet work correctly
 **/
 // vi:expandtab:tabstop=4 shiftwidth=4:
diff --git a/Settings/PluginsPage.cpp b/Settings/PluginsPage.cpp
index 4e243363..e486c207 100644
--- a/Settings/PluginsPage.cpp
+++ b/Settings/PluginsPage.cpp
@@ -1,62 +1,62 @@
-/* Copyright (C) 2003-2010 Jesper K. Pedersen <blackie@kde.org>
+/* Copyright (C) 2003-2019 The KPhotoAlbum Development Team
 
    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; see the file COPYING.  If not, write to
    the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
    Boston, MA 02110-1301, USA.
 */
 #include <config-kpa-kipi.h>
 #include "PluginsPage.h"
 
 #include <QCheckBox>
 #include <QLabel>
 #include <QVBoxLayout>
 
 #include <KLocalizedString>
 
 #ifdef HASKIPI
 #  include <KIPI/ConfigWidget>
 #  include <KIPI/PluginLoader>
 #endif
 
 #include <MainWindow/Window.h>
 #include <Settings/SettingsData.h>
 
 Settings::PluginsPage::PluginsPage( QWidget* parent )
     : QWidget(parent)
 {
     // TODO: DEPENDENCY: the circular dependency on mainwindow is unfortunate.
-    ::MainWindow::Window::theMainWindow()->loadPlugins();
+    ::MainWindow::Window::theMainWindow()->loadKipiPlugins();
     QVBoxLayout* lay1 = new QVBoxLayout( this );
 
     QLabel* label = new QLabel( i18n("Choose Plugins to load:"), this );
     lay1->addWidget( label );
 
     m_pluginConfig = KIPI::PluginLoader::instance()->configWidget( this );
     lay1->addWidget( m_pluginConfig );
 
     m_delayLoadingPlugins = new QCheckBox( i18n("Delay loading plugins until the plugin menu is opened"), this );
     lay1->addWidget( m_delayLoadingPlugins );
 }
 
 void Settings::PluginsPage::saveSettings( Settings::SettingsData* opt )
 {
     m_pluginConfig->apply();
     opt->setDelayLoadingPlugins( m_delayLoadingPlugins->isChecked() );
 }
 
 void Settings::PluginsPage::loadSettings( Settings::SettingsData* opt )
 {
     m_delayLoadingPlugins->setChecked( opt->delayLoadingPlugins() );
 }
 // vi:expandtab:tabstop=4 shiftwidth=4:
diff --git a/config-kpa-kipi.h.cmake b/config-kpa-kipi.h.cmake
index 9ed05e6c..2052186c 100644
--- a/config-kpa-kipi.h.cmake
+++ b/config-kpa-kipi.h.cmake
@@ -1,2 +1,3 @@
 /* Define to 1 if you have KIPI installed */
 #cmakedefine HASKIPI 1
+#cmakedefine KF5Purpose_FOUND 1