diff --git a/autotests/CMakeLists.txt b/autotests/CMakeLists.txt
index 20acfdea..58c7a42d 100644
--- a/autotests/CMakeLists.txt
+++ b/autotests/CMakeLists.txt
@@ -1,193 +1,199 @@
 enable_testing()
 
 configure_file(mediaplaylisttestconfig.h.in
                ${CMAKE_CURRENT_BINARY_DIR}/mediaplaylisttestconfig.h @ONLY)
 
 include_directories(${elisa_CURRENT_BINARY_DIR})
 include_directories(${elisa_BINARY_DIR})
 include_directories(${elisa_BINARY_DIR}/src)
 
 set(viewManagerTest_SOURCES
     viewmanagertest.cpp
     ../src/elisautils.cpp
 )
 
 ecm_add_test(${viewManagerTest_SOURCES}
     TEST_NAME "viewManagerTest"
     LINK_LIBRARIES
         Qt5::Test elisaLib)
 
 target_include_directories(viewManagerTest PRIVATE ${CMAKE_SOURCE_DIR}/src)
 
 set(databaseInterfaceTest_SOURCES
     databaseinterfacetest.cpp
     databasetestdata.h
 )
 
 ecm_add_test(${databaseInterfaceTest_SOURCES}
     TEST_NAME "databaseInterfaceTest"
     LINK_LIBRARIES
         Qt5::Test elisaLib)
 
 target_include_directories(databaseInterfaceTest PRIVATE ${CMAKE_SOURCE_DIR}/src)
 
 set(managemediaplayercontrolTest_SOURCES
     managemediaplayercontroltest.cpp
     ../src/elisautils.cpp
 )
 
 ecm_add_test(${managemediaplayercontrolTest_SOURCES}
     TEST_NAME "managemediaplayercontrolTest"
     LINK_LIBRARIES
         Qt5::Test elisaLib
 )
 
 set(manageheaderbarTest_SOURCES
     manageheaderbartest.cpp
     ../src/elisautils.cpp
 )
 
 ecm_add_test(${manageheaderbarTest_SOURCES}
     TEST_NAME "manageheaderbarTest"
     LINK_LIBRARIES
         Qt5::Test elisaLib
 )
 
 target_include_directories(manageheaderbarTest PRIVATE ${CMAKE_SOURCE_DIR}/src)
 
 set(manageaudioplayerTest_SOURCES
     manageaudioplayertest.cpp
 )
 
 ecm_add_test(${manageaudioplayerTest_SOURCES}
     TEST_NAME "manageaudioplayerTest"
     LINK_LIBRARIES Qt5::Test elisaLib
 )
 
 target_include_directories(manageaudioplayerTest PRIVATE ${CMAKE_SOURCE_DIR}/src)
 
 set(mediaplaylistTest_SOURCES
     mediaplaylisttest.cpp
     ../src/elisautils.cpp
 )
 
 ecm_qt_declare_logging_category(mediaplaylistTest_SOURCES HEADER elisa_debug.h IDENTIFIER lcModelTest CATEGORY_NAME qt.modeltest)
 
 ecm_add_test(${mediaplaylistTest_SOURCES}
     TEST_NAME "mediaplaylistTest"
     LINK_LIBRARIES
         Qt5::Test elisaLib Qt5::CorePrivate
 )
 
 target_include_directories(mediaplaylistTest PRIVATE ${CMAKE_SOURCE_DIR}/src)
 
 set(trackslistenertest_SOURCES
     trackslistenertest.cpp
     ../src/elisautils.cpp
 )
 
 ecm_add_test(${trackslistenertest_SOURCES}
     TEST_NAME "trackslistenertest"
     LINK_LIBRARIES
         Qt5::Test elisaLib
 )
 
 target_include_directories(trackslistenertest PRIVATE ${CMAKE_SOURCE_DIR}/src)
 
 set(datamodeltest_SOURCES
     datamodeltest.cpp
 )
 
 ecm_qt_declare_logging_category(datamodeltest_SOURCES HEADER elisa_debug.h IDENTIFIER lcModelTest CATEGORY_NAME qt.modeltest)
 
 ecm_add_test(${datamodeltest_SOURCES}
     TEST_NAME "datamodeltest"
     LINK_LIBRARIES
         Qt5::Test elisaLib Qt5::CorePrivate
 )
 
 target_include_directories(datamodeltest PRIVATE ${CMAKE_SOURCE_DIR}/src)
 
 set(trackmetadatamodeltest_SOURCES
     trackmetadatamodeltest.cpp
 )
 
 ecm_qt_declare_logging_category(trackmetadatamodeltest_SOURCES HEADER elisa_debug.h IDENTIFIER lcModelTest CATEGORY_NAME qt.modeltest)
 
 ecm_add_test(${trackmetadatamodeltest_SOURCES}
     TEST_NAME "trackmetadatamodeltest"
     LINK_LIBRARIES
         Qt5::Test elisaLib Qt5::CorePrivate
 )
 
 target_include_directories(trackmetadatamodeltest PRIVATE ${CMAKE_SOURCE_DIR}/src)
 
 set(alltracksproxymodeltest_SOURCES
     alltracksproxymodeltest.cpp
 )
 
 ecm_qt_declare_logging_category(alltracksproxymodeltest_SOURCES HEADER elisa_debug.h IDENTIFIER lcModelTest CATEGORY_NAME qt.modeltest)
 
 ecm_add_test(${alltracksproxymodeltest_SOURCES}
     TEST_NAME "alltracksproxymodeltest"
     LINK_LIBRARIES
         Qt5::Test elisaLib Qt5::CorePrivate
 )
 
 target_include_directories(alltracksproxymodeltest PRIVATE ${CMAKE_SOURCE_DIR}/src)
 
 if (KF5FileMetaData_FOUND)
     set(localfilelistingtest_SOURCES
         localfilelistingtest.cpp
     )
 
     ecm_add_test(${localfilelistingtest_SOURCES}
         TEST_NAME "localfilelistingtest"
         LINK_LIBRARIES
             Qt5::Test elisaLib
     )
 
     target_include_directories(localfilelistingtest PRIVATE ${CMAKE_SOURCE_DIR}/src)
 endif()
 
 if (KF5XmlGui_FOUND AND KF5KCMUtils_FOUND)
     set(elisaapplicationtest_SOURCES
         elisaapplicationtest.cpp
         ../src/elisautils.cpp
     )
 
     ecm_add_test(${elisaapplicationtest_SOURCES}
         TEST_NAME "elisaapplicationtest"
         LINK_LIBRARIES
             Qt5::Test elisaLib
     )
 
+    if (KF5Declarative_FOUND)
+        target_link_libraries(elisaapplicationtest
+            KF5::Declarative
+            )
+    endif()
+
     target_include_directories(elisaapplicationtest PRIVATE ${CMAKE_SOURCE_DIR}/src)
 endif()
 
 if (Qt5Quick_FOUND AND Qt5Widgets_FOUND AND NOT WIN32)
     set(elisaqmltests_SOURCES
         elisaqmltests.cpp
         qmltests/tst_GridBrowserDelegate.qml
         qmltests/tst_NavigationActionBar.qml
         qmltests/tst_PlayListEntry.qml
     )
 
     ecm_add_test(${elisaqmltests_SOURCES}
         TEST_NAME "elisaqmltests"
         LINK_LIBRARIES Qt5::Core Qt5::Widgets Qt5::Test Qt5::QuickTest
         GUI)
 
     target_compile_definitions(elisaqmltests PRIVATE QUICK_TEST_SOURCE_DIR="${CMAKE_SOURCE_DIR}/autotests/qmltests")
 
     target_include_directories(elisaqmltests PRIVATE ${CMAKE_SOURCE_DIR}/src)
 endif()
 
 set(filescannerTest_SOURCES
     filescannertest.cpp
 )
 
 ecm_add_test(${filescannerTest_SOURCES}
     TEST_NAME "filescannerTest"
     LINK_LIBRARIES Qt5::Test elisaLib
 )
diff --git a/src/CMakeLists.txt b/src/CMakeLists.txt
index 2b32330e..df6cd283 100644
--- a/src/CMakeLists.txt
+++ b/src/CMakeLists.txt
@@ -1,497 +1,498 @@
 include_directories(${elisa_BINARY_DIR})
 
 set(elisaLib_SOURCES
     mediaplaylist.cpp
     progressindicator.cpp
     databaseinterface.cpp
     datatypes.cpp
     musiclistenersmanager.cpp
     managemediaplayercontrol.cpp
     manageheaderbar.cpp
     manageaudioplayer.cpp
     trackslistener.cpp
     elisaapplication.cpp
     modeldataloader.cpp
     elisautils.cpp
     abstractfile/abstractfilelistener.cpp
     abstractfile/abstractfilelisting.cpp
     filescanner.cpp
     viewmanager.cpp
     powermanagementinterface.cpp
     file/filelistener.cpp
     file/localfilelisting.cpp
     models/datamodel.cpp
     models/abstractmediaproxymodel.cpp
     models/gridviewproxymodel.cpp
     models/alltracksproxymodel.cpp
     models/singlealbumproxymodel.cpp
     models/trackmetadatamodel.cpp
     models/trackcontextmetadatamodel.cpp
     models/viewsmodel.cpp
 )
 
 ecm_qt_declare_logging_category(elisaLib_SOURCES
     HEADER "indexersManager.h"
     IDENTIFIER "orgKdeElisaIndexersManager"
     CATEGORY_NAME "org.kde.elisa.indexers.manager"
     DEFAULT_SEVERITY Info
     )
 
 ecm_qt_declare_logging_category(elisaLib_SOURCES
     HEADER "databaseLogging.h"
     IDENTIFIER "orgKdeElisaDatabase"
     CATEGORY_NAME "org.kde.elisa.database"
     DEFAULT_SEVERITY Info
     )
 
 ecm_qt_declare_logging_category(elisaLib_SOURCES
     HEADER "abstractfile/indexercommon.h"
     IDENTIFIER "orgKdeElisaIndexer"
     CATEGORY_NAME "org.kde.elisa.indexer"
     DEFAULT_SEVERITY Info
     )
 
 ecm_qt_declare_logging_category(elisaLib_SOURCES
     HEADER "models/modelLogging.h"
     IDENTIFIER "orgKdeElisaModel"
     CATEGORY_NAME "org.kde.elisa.model"
     DEFAULT_SEVERITY Info
     )
 
 ecm_qt_declare_logging_category(elisaLib_SOURCES
     HEADER "playListLogging.h"
     IDENTIFIER "orgKdeElisaPlayList"
     CATEGORY_NAME "org.kde.elisa.playlist"
     DEFAULT_SEVERITY Info
     )
 
 if (LIBVLC_FOUND)
     ecm_qt_declare_logging_category(elisaLib_SOURCES
         HEADER "vlcLogging.h"
         IDENTIFIER "orgKdeElisaPlayerVlc"
         CATEGORY_NAME "org.kde.elisa.player.vlc"
         DEFAULT_SEVERITY Info
         )
 
     set(elisaLib_SOURCES
         ${elisaLib_SOURCES}
         audiowrapper_libvlc.cpp
         )
 else()
     ecm_qt_declare_logging_category(elisaLib_SOURCES
         HEADER "qtMultimediaLogging.h"
         IDENTIFIER "orgKdeElisaPlayerQtMultimedia"
         CATEGORY_NAME "org.kde.elisa.player.qtMultimedia"
         DEFAULT_SEVERITY Info
         )
 
     set(elisaLib_SOURCES
         ${elisaLib_SOURCES}
         audiowrapper_qtmultimedia.cpp
         )
 endif()
 
 if (ANDROID)
     set(elisaLib_SOURCES
         ${elisaLib_SOURCES}
         android/androidmusiclistener.cpp
         )
 endif()
 
 if (KF5KIO_FOUND)
     set(elisaLib_SOURCES
         ${elisaLib_SOURCES}
         models/filebrowsermodel.cpp
         models/filebrowserproxymodel.cpp
         )
 endif()
 
 if (KF5Baloo_FOUND)
     if (Qt5DBus_FOUND)
         ecm_qt_declare_logging_category(elisaLib_SOURCES
             HEADER "baloo/baloocommon.h"
             IDENTIFIER "orgKdeElisaBaloo"
             CATEGORY_NAME "org.kde.elisa.baloo"
             DEFAULT_SEVERITY Info
             )
 
         set(elisaLib_SOURCES
             ${elisaLib_SOURCES}
             baloo/localbaloofilelisting.cpp
             baloo/baloolistener.cpp
             baloo/baloodetector.cpp
             )
 
         qt5_add_dbus_interface(elisaLib_SOURCES
             ${BALOO_DBUS_INTERFACES_DIR}/org.kde.baloo.main.xml
             baloo/main)
 
         qt5_add_dbus_interface(elisaLib_SOURCES
             ${BALOO_DBUS_INTERFACES_DIR}/org.kde.baloo.fileindexer.xml
             baloo/fileindexer)
 
         qt5_add_dbus_interface(elisaLib_SOURCES
             ${BALOO_DBUS_INTERFACES_DIR}/org.kde.baloo.scheduler.xml
             baloo/scheduler)
 
         qt5_add_dbus_adaptor(elisaLib_SOURCES
             ${BALOO_DBUS_INTERFACES_DIR}/org.kde.BalooWatcherApplication.xml
             baloo/localbaloofilelisting.h LocalBalooFileListing)
     endif()
 endif()
 
 if (Qt5DBus_FOUND)
     set(elisaLib_SOURCES
         ${elisaLib_SOURCES}
         mpris2/mpris2.cpp
         mpris2/mediaplayer2.cpp
         mpris2/mediaplayer2player.cpp
         )
 endif()
 
 if (UPNPQT_FOUND)
     set(elisaLib_SOURCES
         ${elisaLib_SOURCES}
         upnp/upnpcontrolcontentdirectory.cpp
         upnp/upnpcontentdirectorymodel.cpp
         upnp/upnpcontrolconnectionmanager.cpp
         upnp/upnpcontrolmediaserver.cpp
         upnp/didlparser.cpp
         upnp/upnplistener.cpp
         upnp/upnpdiscoverallmusic.cpp
         )
 endif()
 
 if (KF5Baloo_FOUND)
     if (Qt5DBus_FOUND)
         qt5_add_dbus_interface(elisaLib_SOURCES
             ${BALOO_DBUS_INTERFACES_DIR}/org.kde.baloo.fileindexer.xml
             baloo/fileindexer)
 
         qt5_add_dbus_interface(elisaLib_SOURCES
             ${BALOO_DBUS_INTERFACES_DIR}/org.kde.baloo.scheduler.xml
             baloo/scheduler)
 
         set(elisaLib_SOURCES
             ${elisaLib_SOURCES}
             ../src/baloo/baloolistener.cpp
             ../src/baloo/localbaloofilelisting.cpp
             )
     endif()
 endif()
 
 kconfig_add_kcfg_files(elisaLib_SOURCES ../src/elisa_settings.kcfgc )
 set(elisaLib_SOURCES
     ${elisaLib_SOURCES}
     ../src/elisa_core.kcfg
     )
 
 add_library(elisaLib ${elisaLib_SOURCES})
 target_link_libraries(elisaLib
     LINK_PUBLIC
     Qt5::Multimedia
     LINK_PRIVATE
     Qt5::Core Qt5::Sql Qt5::Widgets Qt5::Concurrent Qt5::Qml
     KF5::I18n KF5::CoreAddons
     KF5::ConfigCore KF5::ConfigGui)
 
 if (KF5FileMetaData_FOUND)
     target_link_libraries(elisaLib
         LINK_PRIVATE
         KF5::FileMetaData
         )
 endif()
 
 if (KF5KIO_FOUND)
     target_link_libraries(elisaLib
         LINK_PUBLIC
         KF5::KIOCore KF5::KIOFileWidgets KF5::KIOWidgets
         )
 endif()
 
 if (KF5XmlGui_FOUND)
     target_link_libraries(elisaLib
         LINK_PUBLIC
         KF5::XmlGui
         )
 endif()
 
 if (KF5ConfigWidgets_FOUND)
     target_link_libraries(elisaLib
         LINK_PUBLIC
         KF5::ConfigWidgets
         )
 endif()
 
 if (KF5KCMUtils_FOUND)
     target_link_libraries(elisaLib
         LINK_PUBLIC
         KF5::KCMUtils
         )
 endif()
 
 if (KF5Baloo_FOUND)
     if (Qt5DBus_FOUND)
         target_link_libraries(elisaLib
             LINK_PUBLIC
             KF5::Baloo
             )
     endif()
 endif()
 
 if (Qt5DBus_FOUND)
     target_link_libraries(elisaLib
         LINK_PUBLIC
         Qt5::DBus
         )
 
     if (KF5DBusAddons_FOUND)
         target_link_libraries(elisaLib
             LINK_PUBLIC
             KF5::DBusAddons
             )
     endif()
 endif()
 
 if (LIBVLC_FOUND)
     target_include_directories(elisaLib
         PRIVATE
         ${LIBVLC_INCLUDE_DIR}
         )
 
     target_link_libraries(elisaLib
         LINK_PRIVATE
         ${LIBVLC_LIBRARY}
         )
 endif()
 
 if (ANDROID)
     target_link_libraries(elisaLib
         LINK_PUBLIC
         Qt5::AndroidExtras
         )
 endif()
 
 generate_export_header(elisaLib BASE_NAME ElisaLib EXPORT_FILE_NAME elisaLib_export.h)
 
 set_target_properties(elisaLib PROPERTIES
     VERSION 0.1
     SOVERSION 0
     EXPORT_NAME ElisaLib
     )
 
 if (NOT APPLE AND NOT WIN32)
     install(TARGETS elisaLib
         LIBRARY DESTINATION ${KDE_INSTALL_FULL_LIBDIR}/elisa NAMELINK_SKIP
         RUNTIME DESTINATION ${KDE_INSTALL_FULL_LIBDIR}/elisa
         BUNDLE DESTINATION ${KDE_INSTALL_FULL_LIBDIR}/elisa
         )
 else()
     install(TARGETS elisaLib ${INSTALL_TARGETS_DEFAULT_ARGS})
 endif()
 
 set(elisaqmlplugin_SOURCES
     elisaqmlplugin.cpp
     elisautils.cpp
 )
 
 if (KF5FileMetaData_FOUND)
     set(elisaqmlplugin_SOURCES
         ${elisaqmlplugin_SOURCES}
         embeddedcoverageimageprovider.cpp
     )
 endif()
 
 add_library(elisaqmlplugin SHARED ${elisaqmlplugin_SOURCES})
 target_link_libraries(elisaqmlplugin
     LINK_PRIVATE
     Qt5::Quick Qt5::Widgets
     KF5::ConfigCore KF5::ConfigGui
     elisaLib
     )
 
 if (KF5FileMetaData_FOUND)
     target_link_libraries(elisaqmlplugin
         LINK_PRIVATE
         KF5::FileMetaData
         )
 endif()
 
 set_target_properties(elisaqmlplugin PROPERTIES
     LIBRARY_OUTPUT_DIRECTORY ${CMAKE_BINARY_DIR}/bin/org/kde/elisa
     )
 
 if (NOT APPLE AND NOT WIN32)
     set_target_properties(elisaqmlplugin PROPERTIES
         INSTALL_RPATH "${KDE_INSTALL_FULL_LIBDIR}/elisa;${CMAKE_INSTALL_RPATH}"
         )
 endif()
 
 install(TARGETS elisaqmlplugin DESTINATION ${QML_INSTALL_DIR}/org/kde/elisa/)
 
 install(FILES qmldir DESTINATION ${QML_INSTALL_DIR}/org/kde/elisa)
 
 add_custom_target(copy)
 add_custom_target(copy2)
 
 file(MAKE_DIRECTORY ${CMAKE_BINARY_DIR}/bin/org/kde/elisa)
 
 add_custom_command(TARGET copy PRE_BUILD
     COMMAND ${CMAKE_COMMAND} -E
     copy ${CMAKE_CURRENT_SOURCE_DIR}/qmldir ${CMAKE_BINARY_DIR}/bin/org/kde/elisa/)
 
 add_custom_command(TARGET copy2 PRE_BUILD
     COMMAND ${CMAKE_COMMAND} -E
     copy ${CMAKE_CURRENT_SOURCE_DIR}/plugins.qmltypes ${CMAKE_BINARY_DIR}/bin/org/kde/elisa/)
 
 add_dependencies(elisaqmlplugin copy copy2)
 
 if (Qt5Quick_FOUND AND Qt5Widgets_FOUND)
     set(elisa_SOURCES
         main.cpp
 
         windows/WindowsTheme.qml
         windows/PlatformIntegration.qml
 
         android/ElisaMainWindow.qml
         android/AndroidTheme.qml
         android/PlatformIntegration.qml
         android/AlbumsView.qml
         android/ArtistsView.qml
         android/TracksView.qml
         android/GenresView.qml
 
         qml/ElisaMainWindow.qml
         qml/ApplicationMenu.qml
         qml/NativeApplicationMenu.qml
         qml/BaseTheme.qml
         qml/Theme.qml
         qml/PlatformIntegration.qml
         qml/LabelWithToolTip.qml
 
         qml/RatingStar.qml
         qml/DraggableItem.qml
         qml/TrackImportNotification.qml
 
         qml/HeaderBar.qml
         qml/NavigationActionBar.qml
         qml/MediaPlayerControl.qml
         qml/ContextView.qml
         qml/ContentView.qml
         qml/ViewSelector.qml
         qml/ViewSelectorDelegate.qml
         qml/DataGridView.qml
         qml/DataListView.qml
 
         qml/MediaPlayListView.qml
         qml/PlayListBasicView.qml
         qml/PlayListEntry.qml
         qml/SimplePlayListView.qml
         qml/PlayListAlbumHeader.qml
         qml/BasicPlayListAlbumHeader.qml
 
         qml/MetaDataDelegate.qml
         qml/EditableMetaDataDelegate.qml
         qml/TracksDiscHeader.qml
         qml/MediaTrackMetadataView.qml
         qml/GridBrowserView.qml
         qml/GridBrowserDelegate.qml
         qml/ListBrowserView.qml
         qml/ListBrowserDelegate.qml
         qml/FileBrowserView.qml
         qml/ScrollHelper.qml
         qml/FlatButtonWithToolTip.qml
         qml/HeaderFooterToolbar.qml
     )
 
     qt5_add_resources(elisa_SOURCES resources.qrc)
     set_property(SOURCE qrc_resources.cpp PROPERTY SKIP_AUTOMOC ON)
 
     set(elisa_ICONS_PNG
         ../icons/128-apps-elisa.png
         ../icons/64-apps-elisa.png
         ../icons/48-apps-elisa.png
         ../icons/32-apps-elisa.png
         ../icons/22-apps-elisa.png
         ../icons/16-apps-elisa.png
         )
 
     # add icons to application sources, to have them bundled
     ecm_add_app_icon(elisa_SOURCES ICONS ${elisa_ICONS_PNG})
 
     add_executable(elisa ${elisa_SOURCES})
 
     target_include_directories(elisa PRIVATE ${KDSoap_INCLUDE_DIRS})
 
     target_link_libraries(elisa
         LINK_PRIVATE
         elisaLib
         Qt5::Widgets Qt5::QuickControls2
         KF5::I18n KF5::CoreAddons KF5::ConfigCore KF5::ConfigGui
         )
 
     if (ANDROID)
         target_link_libraries(elisa
             LINK_PRIVATE
             Qt5::AndroidExtras Qt5::Svg Qt5::Sql Qt5::Concurrent KF5::Kirigami2
         )
     endif()
 
     if (KF5Crash_FOUND)
         target_link_libraries(elisa
             LINK_PRIVATE
             KF5::Crash
             )
     endif()
 
     if (KF5Declarative_FOUND)
         target_link_libraries(elisa
             LINK_PRIVATE
             KF5::Declarative
+            KF5::QuickAddons
             )
     endif()
 
     if (NOT APPLE AND NOT WIN32)
         set_target_properties(elisa PROPERTIES
             INSTALL_RPATH "${KDE_INSTALL_FULL_LIBDIR}/elisa;${CMAKE_INSTALL_RPATH}"
             )
     endif()
 
     install(TARGETS elisa ${INSTALL_TARGETS_DEFAULT_ARGS})
 endif()
 
 if (KF5ConfigWidgets_FOUND AND KF5Declarative_FOUND)
     add_subdirectory(localFileConfiguration)
 endif()
 
 set(elisaImport_SOURCES
     elisaimport.cpp
     elisaimportapplication.cpp
     )
 
 kconfig_add_kcfg_files(elisaImport_SOURCES ../src/elisa_settings.kcfgc )
 set(elisaImport_SOURCES
     ${elisaImport_SOURCES}
     ../src/elisa_core.kcfg
     )
 
 add_executable(elisaImport ${elisaImport_SOURCES})
 
 target_link_libraries(elisaImport
     LINK_PRIVATE
     KF5::ConfigCore KF5::ConfigGui
     elisaLib
     )
 
 if (KF5FileMetaData_FOUND)
     target_link_libraries(elisaImport
         LINK_PRIVATE
         KF5::FileMetaData
         )
 endif()
 
 set(QML_IMPORT_PATH ${CMAKE_BINARY_DIR}/bin CACHE INTERNAL "qml import path" FORCE)
 
 if (ANDROID)
     kirigami_package_breeze_icons(ICONS elisa)
 endif()
diff --git a/src/main.cpp b/src/main.cpp
index cae991fb..45e2b72c 100644
--- a/src/main.cpp
+++ b/src/main.cpp
@@ -1,180 +1,185 @@
 /*
  * Copyright 2015-2018 Matthieu Gallien <matthieu_gallien@yahoo.fr>
  *
  * This program is free software: you can redistribute it and/or
  * modify it under the terms of the GNU Lesser General Public
  * License as published by the Free Software Foundation; either
  * version 3 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
  * Lesser General Public License for more details.
  *
  * You should have received a copy of the GNU Lesser General Public License
  * along with this program.  If not, see <https://www.gnu.org/licenses/>.
  */
 
 #include "config-upnp-qt.h"
 #include "elisa-version.h"
 
 #include "elisaapplication.h"
 #include "elisa_settings.h"
 
 //#define QT_QML_DEBUG
 
 #if defined KF5Declarative_FOUND && KF5Declarative_FOUND
 #include <KDeclarative/KDeclarative>
+#include <KQuickAddons/QtQuickSettings>
 #endif
 
 #include <KI18n/KLocalizedString>
 #include <KI18n/KLocalizedContext>
 
 #include <KCoreAddons/KAboutData>
 
 #if defined KF5Crash_FOUND && KF5Crash_FOUND
 #include <KCrash>
 #endif
 
 #if defined KF5DBusAddons_FOUND && KF5DBusAddons_FOUND
 #include <KDBusService>
 #endif
 
 #include <QSortFilterProxyModel>
 
 #include <QIcon>
 
 #include <QApplication>
 #include <QCommandLineParser>
 #include <QtGlobal>
 #include <QStandardPaths>
 
 #include <QQmlApplicationEngine>
 #include <QQmlEngine>
 #include <QQmlFileSelector>
 #include <QQmlDebuggingEnabler>
 #include <QQmlContext>
 #include <QQuickStyle>
 #include <QScreen>
 
 #if defined Qt5AndroidExtras_FOUND && Qt5AndroidExtras_FOUND
 #include <QAndroidService>
 #endif
 
 #include <memory>
 
 #if defined Qt5AndroidExtras_FOUND && Qt5AndroidExtras_FOUND
 #include <QAndroidJniObject>
 #include <QtAndroid>
 #endif
 
 #if defined Q_OS_ANDROID
 int __attribute__((visibility("default"))) main(int argc, char *argv[])
 #else
 int main(int argc, char *argv[])
 #endif
 {
 #if defined Q_OS_ANDROID
     if(argc > 1 && strcmp(argv[1], "-service") == 0){
         QAndroidService app(argc, argv);
         qInfo() << "Service starting...";
 
         // My service stuff
 
         return app.exec();
     }
 
     qInfo() << "Application starting...";
 #endif
 
+#if defined KF5Declarative_FOUND && KF5Declarative_FOUND
+    KQuickAddons::QtQuickSettings::init();
+#endif
+
     QApplication::setAttribute(Qt::AA_UseHighDpiPixmaps);
     QApplication::setAttribute(Qt::AA_EnableHighDpiScaling);
 
     qputenv("QT_GSTREAMER_USE_PLAYBIN_VOLUME", "true");
 
     QApplication app(argc, argv);
 
     KLocalizedString::setApplicationDomain("elisa");
 
 #if defined Qt5AndroidExtras_FOUND && Qt5AndroidExtras_FOUND
     qInfo() << QCoreApplication::arguments();
 
     QAndroidJniObject::callStaticMethod<void>("org/kde/elisa/ElisaService",
                                               "startMyService",
                                               "(Landroid/content/Context;)V",
                                               QtAndroid::androidContext().object());
 #endif
 
 #if defined KF5Crash_FOUND && KF5Crash_FOUND
     KCrash::initialize();
 #endif
 
     QApplication::setWindowIcon(QIcon::fromTheme(QStringLiteral("elisa")));
 
     KAboutData aboutData( QStringLiteral("elisa"),
                           i18n("Elisa"),
                           QStringLiteral(ELISA_VERSION_STRING),
                           i18n("A Simple Music Player written with KDE Frameworks"),
                           KAboutLicense::LGPL_V3,
                           i18n("(c) 2015-2019, Elisa contributors"));
 
     aboutData.addAuthor(QStringLiteral("Matthieu Gallien"),i18n("Creator"), QStringLiteral("mgallien@mgallien.fr"));
     aboutData.addAuthor(QStringLiteral("Alexander Stippich"), i18n("Author"), QStringLiteral("a.stippich@gmx.net"));
 
     aboutData.addCredit(QStringLiteral("Andrew Lake"), i18n("Concept and design work"), QStringLiteral("jamboarder@gmail.com"));
     aboutData.addCredit(QStringLiteral("Luigi Toscano"), i18n("Localization support"), QStringLiteral("luigi.toscano@tiscali.it"));
     aboutData.addCredit(QStringLiteral("Safa Alfulaij"), i18n("Right to left support in interface"), QStringLiteral("safa1996alfulaij@gmail.com"));
     aboutData.addCredit(QStringLiteral("Diego Gangl"), i18n("Various improvements to the interface"), QStringLiteral("diego@sinestesia.co"));
 
     KAboutData::setApplicationData(aboutData);
 
     QCommandLineParser parser;
     parser.addHelpOption();
     parser.addVersionOption();
     aboutData.setupCommandLine(&parser);
     parser.process(app);
     aboutData.processCommandLine(&parser);
 
     QQuickStyle::setStyle(QStringLiteral("org.kde.desktop"));
     QQuickStyle::setFallbackStyle(QStringLiteral("Fusion"));
 
     QQmlApplicationEngine engine;
     engine.addImportPath(QStringLiteral("qrc:/imports"));
     QQmlFileSelector selector(&engine);
 
 #if defined KF5Declarative_FOUND && KF5Declarative_FOUND
     KDeclarative::KDeclarative decl;
     decl.setDeclarativeEngine(&engine);
     decl.setupEngine(&engine);
     decl.setupContext();
 #endif
 
     engine.rootContext()->setContextObject(new KLocalizedContext(&engine));
 
 #if defined KF5DBusAddons_FOUND && KF5DBusAddons_FOUND
     KDBusService elisaService(KDBusService::Unique);
 #endif
 
     std::unique_ptr<ElisaApplication> myApp = std::make_unique<ElisaApplication>();
 
 #if defined KF5DBusAddons_FOUND && KF5DBusAddons_FOUND
     QObject::connect(&elisaService, &KDBusService::activateActionRequested, myApp.get(), &ElisaApplication::activateActionRequested);
     QObject::connect(&elisaService, &KDBusService::activateRequested, myApp.get(), &ElisaApplication::activateRequested);
     QObject::connect(&elisaService, &KDBusService::openRequested, myApp.get(), &ElisaApplication::openRequested);
 #endif
 
     auto arguments = ElisaUtils::EntryDataList{};
     auto realArgumentsList = parser.positionalArguments();
 
     for (auto oneArgument : realArgumentsList) {
         arguments.push_back(ElisaUtils::EntryData{{}, {}, QUrl(oneArgument)});
     }
 
     myApp->setArguments(arguments);
 
     engine.rootContext()->setContextProperty(QStringLiteral("elisa"), myApp.release());
 
     engine.load(QUrl(QStringLiteral("qrc:/qml/ElisaMainWindow.qml")));
 
     return app.exec();
 }