diff --git a/CMakeLists.txt b/CMakeLists.txt index c5f101e..81ed172 100644 --- a/CMakeLists.txt +++ b/CMakeLists.txt @@ -1,145 +1,145 @@ cmake_minimum_required(VERSION 3.5) set(KF5_VERSION "5.65.0") # handled by release scripts set(KF5_DEP_VERSION "5.64.0") # handled by release scripts project(KDeclarative VERSION ${KF5_VERSION}) # Dependencies include(FeatureSummary) find_package(ECM 5.64.0 NO_MODULE) set_package_properties(ECM PROPERTIES TYPE REQUIRED DESCRIPTION "Extra CMake Modules." URL "https://projects.kde.org/projects/kdesupport/extra-cmake-modules") feature_summary(WHAT REQUIRED_PACKAGES_NOT_FOUND FATAL_ON_MISSING_REQUIRED_PACKAGES) set(CMAKE_MODULE_PATH ${CMAKE_CURRENT_SOURCE_DIR}/cmake ${ECM_MODULE_PATH}) set(REQUIRED_QT_VERSION 5.11.0) find_package(Qt5 ${REQUIRED_QT_VERSION} NO_MODULE REQUIRED Qml Quick Gui) include(KDEInstallDirs) include(KDEFrameworkCompilerSettings NO_POLICY_SCOPE) include(KDECMakeSettings) find_package(KF5Config ${KF5_DEP_VERSION} REQUIRED) find_package(KF5I18n ${KF5_DEP_VERSION} REQUIRED) find_package(KF5IconThemes ${KF5_DEP_VERSION} REQUIRED) find_package(KF5KIO ${KF5_DEP_VERSION} REQUIRED) find_package(KF5WidgetsAddons ${KF5_DEP_VERSION} REQUIRED) find_package(KF5WindowSystem ${KF5_DEP_VERSION} REQUIRED) find_package(KF5GlobalAccel ${KF5_DEP_VERSION} REQUIRED) find_package(KF5GuiAddons ${KF5_DEP_VERSION} REQUIRED) find_package(KF5Package ${KF5_DEP_VERSION} REQUIRED) ######################################################################### add_definitions(-DQT_DISABLE_DEPRECATED_BEFORE=0x050d00) add_definitions(-DKF_DISABLE_DEPRECATED_BEFORE_AND_AT=0x053f00) #add_definitions(-Wno-deprecated) # Includes include(ECMGenerateExportHeader) include(ECMSetupVersion) include(ECMGenerateHeaders) include(CMakePackageConfigHelpers) include(ECMAddQch) set(EXCLUDE_DEPRECATED_BEFORE_AND_AT 0 CACHE STRING "Control the range of deprecated API excluded from the build [default=0].") option(BUILD_EXAMPLES "Build and install examples." OFF) option(BUILD_QCH "Build API documentation in QCH format (for e.g. Qt Assistant, Qt Creator & KDevelop)" OFF) add_feature_info(QCH ${BUILD_QCH} "API documentation in QCH format (for e.g. Qt Assistant, Qt Creator & KDevelop)") # ECM setup ecm_setup_version( PROJECT VARIABLE_PREFIX KDECLARATIVE VERSION_HEADER "${CMAKE_CURRENT_BINARY_DIR}/kdeclarative_version.h" PACKAGE_VERSION_FILE "${CMAKE_CURRENT_BINARY_DIR}/KF5DeclarativeConfigVersion.cmake" SOVERSION 5) # Subdirectories add_definitions(-DTRANSLATION_DOMAIN=\"kdeclarative5\") if (IS_DIRECTORY "${CMAKE_CURRENT_SOURCE_DIR}/po") ki18n_install(po) endif() find_package(epoxy) set_package_properties(epoxy PROPERTIES DESCRIPTION "libepoxy" - URL "http://github.com/anholt/libepoxy" + URL "https://github.com/anholt/libepoxy" TYPE OPTIONAL PURPOSE "OpenGL dispatch library" ) set(HAVE_EPOXY 0) if(epoxy_FOUND) set(HAVE_EPOXY 1) endif() add_definitions(-DQT_NO_FOREACH) add_subdirectory(src) if (BUILD_TESTING) add_subdirectory(autotests) add_subdirectory(tests) endif() # Create a Config.cmake and a ConfigVersion.cmake file and install them set(CMAKECONFIG_INSTALL_DIR "${KDE_INSTALL_CMAKEPACKAGEDIR}/KF5Declarative") if (BUILD_QCH) ecm_install_qch_export( TARGETS KF5Declarative_QCH FILE KF5DeclarativeQchTargets.cmake DESTINATION "${CMAKECONFIG_INSTALL_DIR}" COMPONENT Devel ) set(PACKAGE_INCLUDE_QCHTARGETS "include(\"\${CMAKE_CURRENT_LIST_DIR}/KF5DeclarativeQchTargets.cmake\")") endif() configure_package_config_file( "${CMAKE_CURRENT_SOURCE_DIR}/KF5DeclarativeConfig.cmake.in" "${CMAKE_CURRENT_BINARY_DIR}/KF5DeclarativeConfig.cmake" INSTALL_DESTINATION "${CMAKECONFIG_INSTALL_DIR}" ) install(FILES "${CMAKE_CURRENT_BINARY_DIR}/KF5DeclarativeConfig.cmake" "${CMAKE_CURRENT_BINARY_DIR}/KF5DeclarativeConfigVersion.cmake" DESTINATION "${CMAKECONFIG_INSTALL_DIR}" COMPONENT Devel ) install(EXPORT KF5DeclarativeTargets DESTINATION "${CMAKECONFIG_INSTALL_DIR}" FILE KF5DeclarativeTargets.cmake NAMESPACE KF5:: COMPONENT Devel ) install(FILES "${CMAKE_CURRENT_BINARY_DIR}/kdeclarative_version.h" DESTINATION "${KDE_INSTALL_INCLUDEDIR_KF5}" COMPONENT Devel ) feature_summary(WHAT ALL FATAL_ON_MISSING_REQUIRED_PACKAGES) if(KF5Config_FOUND AND KF5I18n_FOUND AND KF5IconThemes_FOUND AND KF5KIO_FOUND) message("Dependencies for libkdeclarative found: it will be built") else() message("In order to build libkdeclarative you need KF5Config, KF5I18n, KF5IconThemes and KF5KIO") endif() if(KF5I18n_FOUND AND KF5WidgetsAddons_FOUND AND KF5WindowSystem_FOUND AND KF5GlobalAccel_FOUND AND KF5KIO_FOUND AND KF5GuiAddons_FOUND) message("Dependencies for KQuickControls found: it will be built") else() message("In order to build KQuickControls you need KF5I18n, KF5WidgetsAddons, KF5WindowSystem, KF5GlobalAccel, KF5KIO and KF5GuiAddons") endif() if(KF5CoreAddons_FOUND) message("Dependencies for KCoreAddons QML bindings found; it will be built") else() message("In order to build KCoreAddons QML bindings you need KCoreAddons") endif() diff --git a/src/quickaddons/configmodule.h b/src/quickaddons/configmodule.h index d9e681b..320f6e8 100644 --- a/src/quickaddons/configmodule.h +++ b/src/quickaddons/configmodule.h @@ -1,597 +1,597 @@ /* This file is part of the KDE libraries Copyright (c) 1999 Matthias Hoelzer-Kluepfel Copyright (c) 2001 Michael Goffioul Copyright (C) 2004 Frans Englich Copyright (C) 2009 Dario Freddi Copyright (C) 2015 Marco Martin This library is free software; you can redistribute it and/or modify it under the terms of the GNU Library General Public License as published by the Free Software Foundation; either version 2 of the License, or (at your option) any later version. This library is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Library General Public License for more details. You should have received a copy of the GNU Library General Public License along with this library; see the file COPYING.LIB. If not, write to the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. */ #ifndef CONFIGMODULE_H #define CONFIGMODULE_H #include "quickaddons_export.h" #include #include #include #include class QStringList; class KAboutData; class QQuickItem; class QQmlEngine; namespace KQuickAddons { class ConfigModulePrivate; /** * @class KQuickAddons::ConfigModule configmodule.h KQuickAddons/ConfigModule * * The base class for configuration modules. * * Configuration modules are realized as plugins that are loaded only when * needed. * * The module in principle is a simple widget displaying the * item to be changed. The module has a very small interface. * * All the necessary glue logic and the GUI bells and whistles * are provided by the control center and must not concern * the module author. * * To write a config module, you have to create a C++ library * and an accompaning QML user interface. * The library must contain a factory function like the following: * * \code * #include * * K_PLUGIN_FACTORY(MyConfigModuleFactory, registerPlugin() ) * \endcode * * The constructor of the ConfigModule then looks like this: * \code * YourConfigModule::YourConfigModule( QObject* parent ) * : ConfigModule( parent ) * { * KAboutData *about = new KAboutData( * , i18n( "..." ), * KDE_VERSION_STRING, QString(), KAboutLicense::GPL, * i18n( "Copyright 2006 ..." ) ); * about->addAuthor( i18n(...) ); * setAboutData( about ); * . * . * . * } * \endcode * * The QML part must be in the KPackage format, installed under share/kpackage/kcms. * @see KPackage::Package * The package must have the same name as the KAboutData componentName, to be installed * by CMake with the command: * kpackage_install_package(package kcm_componentName kcms) * given "package" is the subdirectory in the source tree where the package sources are * located, and "kcm_componentName" is the componentname passed to the KAboutData in the * C++ part. * The main config dialog UI will be the file * ui/main.qml from the package (or what X-KPackage-MainScript value is in the * package metadata desktop file). * * The QML part can access all the properties of ConfigModule (together with the properties * defined in its subclass) by accessing to the global object "kcm", or with the * import of "org.kde.kcm 1.0" the ConfigModule attached property. * * \code * import QtQuick 2.1 * import QtQuick.Controls 1.0 as QtControls * import org.kde.kcm 1.0 * import org.kde.plasma.core 2.0 as PlasmaCore * * Item { * //implicitWidth and implicitHeight will be used as initial size * //when loaded in kcmshell5 * implicitWidth: units.gridUnit * 20 * implicitHeight: units.gridUnit * 20 * * ConfigModule.buttons: ConfigModule.Help|ConfigModule.Apply * Label { * text: kcm.needsSave * } * } * \endcode * - * See http://techbase.kde.org/Development/Tutorials/KCM_HowTo + * See https://techbase.kde.org/Development/Tutorials/KCM_HowTo * for more detailed documentation. * */ class QUICKADDONS_EXPORT ConfigModule : public QObject { Q_OBJECT Q_PROPERTY(QQuickItem *mainUi READ mainUi CONSTANT) Q_PROPERTY(KQuickAddons::ConfigModule::Buttons buttons READ buttons WRITE setButtons NOTIFY buttonsChanged) Q_PROPERTY(bool needsSave READ needsSave WRITE setNeedsSave NOTIFY needsSaveChanged) Q_PROPERTY(bool representsDefaults READ representsDefaults WRITE setRepresentsDefaults NOTIFY representsDefaultsChanged) Q_PROPERTY(QString name READ name CONSTANT) Q_PROPERTY(QString description READ description CONSTANT) Q_PROPERTY(QString quickHelp READ quickHelp WRITE setQuickHelp NOTIFY quickHelpChanged) Q_PROPERTY(QString rootOnlyMessage READ rootOnlyMessage WRITE setRootOnlyMessage NOTIFY rootOnlyMessageChanged) Q_PROPERTY(bool useRootOnlyMessage READ useRootOnlyMessage WRITE setUseRootOnlyMessage NOTIFY useRootOnlyMessageChanged) Q_PROPERTY(bool needsAuthorization READ needsAuthorization WRITE setNeedsAuthorization NOTIFY needsAuthorizationChanged) Q_PROPERTY(int columnWidth READ columnWidth WRITE setColumnWidth NOTIFY columnWidthChanged) Q_PROPERTY(int depth READ depth NOTIFY depthChanged) Q_PROPERTY(int currentIndex READ currentIndex WRITE setCurrentIndex NOTIFY currentIndexChanged) public: /** * An enumeration type for the buttons used by this module. * You should only use Help, Default and Apply. The rest is obsolete. * NoAdditionalButton can be used when we do not want have other button that Ok Cancel * * @see ConfigModule::buttons @see ConfigModule::setButtons */ enum Button { NoAdditionalButton = 0, Help = 1, Default = 2, Apply = 4 }; Q_ENUM(Button) Q_DECLARE_FLAGS(Buttons, Button) Q_FLAG(Buttons) /** * Base class for all KControlModules. * * @note do not emit changed signals here, since they are not yet connected * to any slot. * @param aboutData becomes owned by the ConfigModule */ explicit ConfigModule(const KAboutData *aboutData, QObject *parent = nullptr, const QVariantList &args = QVariantList()); /** * @note do not emit changed signals here, since they are not yet connected * to any slot. * @param metaData description for the plugin: it will generate a KAboutData from that * @since 5.11 */ explicit ConfigModule(const KPluginMetaData &metaData, QObject *parent = nullptr, const QVariantList &args = QVariantList()); /** * Base class for all KControlModules. * * @note do not emit changed signals here, since they are not yet connected * to any slot. */ explicit ConfigModule(QObject *parent = nullptr, const QVariantList &args = QVariantList()); /** * Destroys the module. */ ~ConfigModule(); /** * This is generally only called for the KBugReport. * If you override you should have it return a pointer to a constant. * * * @returns the KAboutData for this module */ const KAboutData *aboutData() const; /** * This sets the KAboutData returned by aboutData() * The about data is now owned by ConfigModule. */ void setAboutData(const KAboutData *about); /** * @brief Set if the module's save() method requires authorization to be executed * * It will still have to execute the action itself using the KAuth library, so * this method is not technically needed to perform the action, but * using this method will ensure that hosting * applications like System Settings or kcmshell behave correctly. * * @param action the action that will be used by this ConfigModule */ void setAuthActionName(const QString &action); /** * Returns the action previously set with setAuthActionName(). By default its an invalid action. * * @return The action that has to be authorized to execute the save() method. */ QString authActionName() const; /** * @deturn the qml engine that built the main config UI */ QQmlEngine *engine() const; /** * The status of the mainUi component. * @since 5.64 */ QQmlComponent::Status status() const; /** * The error string in case the mainUi failed to load. * @return 5.64 */ QString errorString() const; //QML property accessors /** * @return The main UI for this configuration module. It's a QQuickItem coming from * the QML package named the same as the KAboutData's component name for * this config module */ QQuickItem *mainUi(); /** * Sets the quick help. */ void setQuickHelp(const QString &help); /** * Return a quick-help text. * * This method is called when the module is docked. * The quick-help text should contain a short description of the module and * links to the module's help files. You can use HTML formatting tags in the text. * * @note make sure the quick help text gets translated (use i18n()). */ QString quickHelp() const; /** * Set this property to true when the user changes something in the module, * signaling that a save (such as user pressing Ok or Apply) is needed. */ void setNeedsSave(bool needs); /** * True when the module has something changed and needs save. */ bool needsSave(); /** * Set this property to true when the user sets the state of the module * to the default settings (e.g. clicking Defaults would do nothing). */ void setRepresentsDefaults(bool defaults); /** * True when the module state represents the default settings. */ bool representsDefaults(); /** * Sets the buttons to display. * * Help: shows a "Help" button. * * Default: shows a "Use Defaults" button. * * Apply: in kcontrol this will show an "Apply" and "Reset" button, * in kcmshell this will show an "Ok", "Apply" and "Cancel" button. * * If Apply is not specified, kcmshell will show a "Close" button. * * @see ConfigModule::buttons */ void setButtons(const Buttons btn); /** * Indicate which buttons will be used. * * The return value is a value or'ed together from * the Button enumeration type. * * @see ConfigModule::setButtons */ Buttons buttons() const; /** * Sets the RootOnly message. * * This message will be shown at the top of the module if useRootOnlyMessage is * set. If no message is set, a default one will be used. * * @see ConfigModule::rootOnlyMessage */ void setRootOnlyMessage(const QString &message); /** * Get the RootOnly message for this module. * * When the module must be run as root, or acts differently * for root and a normal user, it is sometimes useful to * customize the message that appears at the top of the module * when used as a normal user. This function returns this * customized message. If none has been set, a default message * will be used. * * @see ConfigModule::setRootOnlyMessage */ QString rootOnlyMessage() const; /** * Change whether or not the RootOnly message should be shown. * * Following the value of @p on, the RootOnly message will be * shown or not. * * @see ConfigModule::useRootOnlyMessage */ void setUseRootOnlyMessage(bool on); /** * Tell if KControl should show a RootOnly message when run as * a normal user. * * In some cases, the module don't want a RootOnly message to * appear (for example if it has already one). This function * tells KControl if a RootOnly message should be shown * * @see ConfigModule::setUseRootOnlyMessage */ bool useRootOnlyMessage() const; /** * @brief Set if the module's save() method requires authorization to be executed. * * The module can set this property to @c true if it requires authorization. * It will still have to execute the action itself using the KAuth library, so * this method is not technically needed to perform the action, but * using this and/or the setAuthActionName() method will ensure that hosting * applications like System Settings or kcmshell behave correctly. * * Called with @c true, this method will set the action to "org.kde.kcontrol.name.save" where * "name" is aboutData()->appName() return value. This default action won't be set if * the aboutData() object is not valid. * * Note that called with @c false, this method will reset the action name set with setAuthActionName(). * * @param needsAuth Tells if the module's save() method requires authorization to be executed. */ void setNeedsAuthorization(bool needsAuth); /** * Returns the value previously set with setNeedsAuthorization() or setAuthActionName(). By default it's @c false. * * @return @c true if the module's save() method requires authorization, @c false otherwise */ bool needsAuthorization() const; /** * @returns the name of the config module * @since 5.41 */ QString name() const; /** * @returns the description of the config module * @since 5.41 */ QString description() const; /** * returns the width the kcm wants in column mode. * If a columnWidth is valid ( > 0 ) and less than the systemsettings' view width, * more than one will be visible at once, and the first page will be a sidebar to the last page pushed. * As default, this is -1 which will make the shell always show only one page at a time. * @since 5.50 */ int columnWidth() const; /** * Sets the column width we want. * @since 5.50 */ void setColumnWidth(int width); /** * @returns how many pages this kcm has. * It is guaranteed to be at least 1 9the main ui) plus how many times a new page has been pushed without pop */ int depth() const; /** * Sets the current page index this kcm should display * @since 5.53 */ void setCurrentIndex(int index); /** * @returns the index of the page this kcm should display * @since 5.53 */ int currentIndex() const; static ConfigModule *qmlAttachedProperties(QObject *object); public Q_SLOTS: /** * Load the configuration data into the module. * * The load method sets the user interface elements of the * module to reflect the current settings stored in the * configuration files. * * This method is invoked whenever the module should read its configuration * (most of the times from a config file) and update the user interface. * This happens when the user clicks the "Reset" button in the control * center, to undo all of his changes and restore the currently valid * settings. It is also called right after construction. */ virtual void load(); /** * Save the configuration data. * * The save method stores the config information as shown * in the user interface in the config files. * * If necessary, this method also updates the running system, * e.g. by restarting applications. This normally does not apply for * KSettings::Dialog modules where the updating is taken care of by * KSettings::Dispatcher. * * save is called when the user clicks "Apply" or "Ok". * */ virtual void save(); /** * Sets the configuration to sensible default values. * * This method is called when the user clicks the "Default" * button. It should set the display to useful values. */ virtual void defaults(); /** * Push a new sub page in the KCM hyerarchy: pages will be seen as a Kirigami PageRow * @since 5.50 */ void push(const QString &fileName, const QVariantMap &propertyMap = QVariantMap()); /** - * + * */ void push(QQuickItem *item); /** * pop the last page of the KCM hyerarchy * @since 5.50 */ void pop(); Q_SIGNALS: /** * The auth action name has changed: this signal will relay it to the actual KCM */ void authActionNameChanged(); //QML NOTIFY signaling /** * Buttons to display changed. */ void buttonsChanged(); /** * Indicate that the module's quickhelp has changed. * * Emit this signal whenever the module's quickhelp changes. * Modules implemented as tabbed dialogs might want to implement * per-tab quickhelp for example. * */ void quickHelpChanged(); /** * Indicate that the state of the modules contents has changed. * * This signal is emitted whenever the state of the configuration * shown in the module changes. It allows the module container to * keep track of unsaved changes. */ void needsSaveChanged(); /** * Indicate that the state of the modules contents has changed * in a way that it might represents the defaults settings, or * stopped representing them. */ void representsDefaultsChanged(); /** * Emits this signal whenever the need for root authorization to save changes. */ void needsAuthorizationChanged(); /** * Indicate that the module's root message has changed. * * Emits this signal whenever the module's root message changes. * */ void rootOnlyMessageChanged(); /** * Emits this signal whenever the root only message gets used or discarded. */ void useRootOnlyMessageChanged(); /** * Emitted when a new sub page is pushed * @since 5.50 */ void pagePushed(QQuickItem *page); /** * Emitted when a sub page is popped * @since 5.50 */ //RFC: page argument? void pageRemoved(); /** * Emitted when the wanted column width of the kcm changes * @since 5.50 */ void columnWidthChanged(int width); /** * Emitted when the current page changed * @since 5.53 */ void currentIndexChanged(int index); /** * Emitted when the number of pages changed * @since 5.53 */ void depthChanged(int index); private: ConfigModulePrivate *const d; }; } Q_DECLARE_OPERATORS_FOR_FLAGS(KQuickAddons::ConfigModule::Buttons) QML_DECLARE_TYPEINFO(KQuickAddons::ConfigModule, QML_HAS_ATTACHED_PROPERTIES) #endif //ConfigModule_H diff --git a/src/quickaddons/managedconfigmodule.h b/src/quickaddons/managedconfigmodule.h index 34870f5..fb31da2 100644 --- a/src/quickaddons/managedconfigmodule.h +++ b/src/quickaddons/managedconfigmodule.h @@ -1,225 +1,225 @@ /* This file is part of the KDE libraries Copyright (C) 2019 Kevin Ottens This library is free software; you can redistribute it and/or modify it under the terms of the GNU Library General Public License as published by the Free Software Foundation; either version 2 of the License, or (at your option) any later version. This library is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Library General Public License for more details. You should have received a copy of the GNU Library General Public License along with this library; see the file COPYING.LIB. If not, write to the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. */ #ifndef MANAGEDCONFIGMODULE_H #define MANAGEDCONFIGMODULE_H #include namespace KQuickAddons { class ManagedConfigModulePrivate; /** * @class KQuickAddons::ManagedConfigModule managedconfigmodule.h KQuickAddons/ManagedConfigModule * * The base class for configuration modules using KConfigXT settings. * * Configuration modules are realized as plugins that are loaded only when * needed. * * The module in principle is a simple widget displaying the * item to be changed. The module has a very small interface. * * All the necessary glue logic and the GUI bells and whistles * are provided by the control center and must not concern * the module author. * * To write a config module, you have to create a C++ library * and an accompaning QML user interface. * The library must contain a factory function like the following: * * \code * #include * * K_PLUGIN_FACTORY(MyConfigModuleFactory, registerPlugin() ) * \endcode * * The constructor of the ConfigModule then looks like this: * \code * YourConfigModule::YourConfigModule( QObject* parent ) * : ManagedConfigModule( parent ), * SettingsObject( this ) * { * KAboutData *about = new KAboutData( * , i18n( "..." ), * KDE_VERSION_STRING, QString(), KAboutLicense::GPL, * i18n( "Copyright 2006 ..." ) ); * about->addAuthor( i18n(...) ); * setAboutData( about ); * . * . * . * } * \endcode * * We are assuming here that SettingsObject is a class generated from a kcfg file * and that it will be somehow exposed as a constant property to be used from the QML side. * It will be automatically discovered by ManagedConfigModule which will update * the saveNeeded and defaults inherited properties by itself. Thus by inheriting from * this class you shall not try to manage those properties yourselves. * * The QML part must be in the KPackage format, installed under share/kpackage/kcms. * @see KPackage::Package * The package must have the same name as the KAboutData componentName, to be installed * by CMake with the command: * kpackage_install_package(package kcm_componentName kcms) * given "package" is the subdirectory in the source tree where the package sources are * located, and "kcm_componentName" is the componentname passed to the KAboutData in the * C++ part. * The main config dialog UI will be the file * ui/main.qml from the package (or what X-KPackage-MainScript value is in the * package metadata desktop file). * * The QML part can access all the properties of ManagedConfigModule (together with the properties * defined in its subclass) by accessing to the global object "kcm", or with the * import of "org.kde.kcm 1.0" the ConfigModule attached property. * * \code * import QtQuick 2.1 * import QtQuick.Controls 1.0 as QtControls * import org.kde.kcm 1.0 * import org.kde.plasma.core 2.0 as PlasmaCore * * Item { * //implicitWidth and implicitHeight will be used as initial size * //when loaded in kcmshell5 * implicitWidth: units.gridUnit * 20 * implicitHeight: units.gridUnit * 20 * * ConfigModule.buttons: ConfigModule.Help|ConfigModule.Apply * Label { * text: kcm.needsSave * } * } * \endcode * - * See http://techbase.kde.org/Development/Tutorials/KCM_HowTo + * See https://techbase.kde.org/Development/Tutorials/KCM_HowTo * for more detailed documentation. * * @since 5.65 */ class QUICKADDONS_EXPORT ManagedConfigModule : public ConfigModule { Q_OBJECT public: /** * Base class for all modules which manage automatically some of their state. * * @param aboutData becomes owned by the ManagedConfigModule */ explicit ManagedConfigModule(const KAboutData *aboutData, QObject *parent = nullptr, const QVariantList &args = QVariantList()); /** * @param metaData description for the plugin: it will generate a KAboutData from that */ explicit ManagedConfigModule(const KPluginMetaData &metaData, QObject *parent = nullptr, const QVariantList &args = QVariantList()); /** * Base class for all KControlModules. * * @note do not emit changed signals here, since they are not yet connected * to any slot. */ explicit ManagedConfigModule(QObject *parent = nullptr, const QVariantList &args = QVariantList()); /** * Destroys the module. */ ~ManagedConfigModule(); public Q_SLOTS: /** * Load the configuration data into the module. * * This method is invoked whenever the module should read its configuration * (most of the times from a config file) and update the user interface. * This happens when the user clicks the "Reset" button in the control * center, to undo all of his changes and restore the currently valid * settings. It is also called right after construction. * * By default this will load the settings from the child setting objects * of this module. */ void load() override; /** * Save the configuration data. * * The save method stores the config information as shown * in the user interface in the config files. * It is called when the user clicks "Apply" or "Ok". * * By default this will save the child setting objects * of this module. */ void save() override; /** * Sets the configuration to sensible default values. * * This method is called when the user clicks the "Default" * button. It should set the display to useful values. * * By default this will reset to defaults the child setting objects * of this module. */ void defaults() override; protected Q_SLOTS: /** * Forces the module to reevaluate the saveNeeded and * representsDefault state. * * This is required for some modules which might have * some settings managed outside of KConfigXT objects. */ void settingsChanged(); private: /** * Allows to indicate if the module requires saving. * * By default this returns false, it needs to be overriden only * if the module has state outside of the settings declared in * the KConfigXT classes it uses. */ virtual bool isSaveNeeded() const; /** * Allows to indicate if the module state is representing its defaults. * * By default this returns true, it needs to be overriden only * if the module has state outside of the settings declared in * the KConfigXT classes it uses. */ virtual bool isDefaults() const; Q_PRIVATE_SLOT(d, void _k_registerSettings()) ManagedConfigModulePrivate *const d; friend class ManagedConfigModulePrivate; }; } #endif //MANAGEDCONFIGMODULE_H