Merge lp:~nick-dedekind/ubuntu-settings-components/1390136.laggy-backends into lp:~registry/ubuntu-settings-components/trunk

[Nick Dedekind]

Added ServerActivationSync control for laggy backends (lp#1390136)

Added ServerActivationSync control for laggy backends (lp#1390136)

 * Are there any related MPs required for this MP to build/function as expected? Please list.
No

 * Did you perform an exploratory manual test run of your code change and any related functionality?
Yes

 * If you changed the packaging (debian), did you subscribe the ubuntu-unity team to this MP?
N/A

 * If you changed the UI, has there been a design review?
N/A

[PS Jenkins bot (ps-jenkins)]

PASSED: Continuous integration, rev:89
http://jenkins.qa.ubuntu.com/job/ubuntu-settings-components-ci/97/
Executed test runs:
    SUCCESS: http://jenkins.qa.ubuntu.com/job/ubuntu-settings-components-qmltests-vivid/16
    SUCCESS: http://jenkins.qa.ubuntu.com/job/ubuntu-settings-components-vivid-amd64-ci/4
    SUCCESS: http://jenkins.qa.ubuntu.com/job/ubuntu-settings-components-vivid-armhf-ci/4
        deb: http://jenkins.qa.ubuntu.com/job/ubuntu-settings-components-vivid-armhf-ci/4/artifact/work/output/*zip*/output.zip

Click here to trigger a rebuild:
http://s-jenkins.ubuntu-ci:8080/job/ubuntu-settings-components-ci/97/rebuild

review: Approve (continuous-integration)

[PS Jenkins bot (ps-jenkins)]

PASSED: Continuous integration, rev:90
http://jenkins.qa.ubuntu.com/job/ubuntu-settings-components-ci/98/
Executed test runs:
    SUCCESS: http://jenkins.qa.ubuntu.com/job/ubuntu-settings-components-qmltests-vivid/17
    SUCCESS: http://jenkins.qa.ubuntu.com/job/ubuntu-settings-components-vivid-amd64-ci/5
    SUCCESS: http://jenkins.qa.ubuntu.com/job/ubuntu-settings-components-vivid-armhf-ci/5
        deb: http://jenkins.qa.ubuntu.com/job/ubuntu-settings-components-vivid-armhf-ci/5/artifact/work/output/*zip*/output.zip

Click here to trigger a rebuild:
http://s-jenkins.ubuntu-ci:8080/job/ubuntu-settings-components-ci/98/rebuild

review: Approve (continuous-integration)

[PS Jenkins bot (ps-jenkins)]

FAILED: Continuous integration, rev:91
http://jenkins.qa.ubuntu.com/job/ubuntu-settings-components-ci/99/
Executed test runs:
    UNSTABLE: http://jenkins.qa.ubuntu.com/job/ubuntu-settings-components-qmltests-vivid/18
    SUCCESS: http://jenkins.qa.ubuntu.com/job/ubuntu-settings-components-vivid-amd64-ci/6
    SUCCESS: http://jenkins.qa.ubuntu.com/job/ubuntu-settings-components-vivid-armhf-ci/6
        deb: http://jenkins.qa.ubuntu.com/job/ubuntu-settings-components-vivid-armhf-ci/6/artifact/work/output/*zip*/output.zip

Click here to trigger a rebuild:
http://s-jenkins.ubuntu-ci:8080/job/ubuntu-settings-components-ci/99/rebuild

review: Needs Fixing (continuous-integration)

[PS Jenkins bot (ps-jenkins)]

FAILED: Continuous integration, rev:92
http://jenkins.qa.ubuntu.com/job/ubuntu-settings-components-ci/100/
Executed test runs:
    FAILURE: http://jenkins.qa.ubuntu.com/job/ubuntu-settings-components-qmltests-vivid/19/console
    SUCCESS: http://jenkins.qa.ubuntu.com/job/ubuntu-settings-components-vivid-amd64-ci/7
    SUCCESS: http://jenkins.qa.ubuntu.com/job/ubuntu-settings-components-vivid-armhf-ci/7
        deb: http://jenkins.qa.ubuntu.com/job/ubuntu-settings-components-vivid-armhf-ci/7/artifact/work/output/*zip*/output.zip

Click here to trigger a rebuild:
http://s-jenkins.ubuntu-ci:8080/job/ubuntu-settings-components-ci/100/rebuild

review: Needs Fixing (continuous-integration)

[PS Jenkins bot (ps-jenkins)]

PASSED: Continuous integration, rev:94
http://jenkins.qa.ubuntu.com/job/ubuntu-settings-components-ci/101/
Executed test runs:
    SUCCESS: http://jenkins.qa.ubuntu.com/job/ubuntu-settings-components-qmltests-vivid/20
    SUCCESS: http://jenkins.qa.ubuntu.com/job/ubuntu-settings-components-vivid-amd64-ci/8
    SUCCESS: http://jenkins.qa.ubuntu.com/job/ubuntu-settings-components-vivid-armhf-ci/8
        deb: http://jenkins.qa.ubuntu.com/job/ubuntu-settings-components-vivid-armhf-ci/8/artifact/work/output/*zip*/output.zip

Click here to trigger a rebuild:
http://s-jenkins.ubuntu-ci:8080/job/ubuntu-settings-components-ci/101/rebuild

review: Approve (continuous-integration)

[PS Jenkins bot (ps-jenkins)]

FAILED: Continuous integration, rev:94
http://jenkins.qa.ubuntu.com/job/ubuntu-settings-components-ci/102/
Executed test runs:
    UNSTABLE: http://jenkins.qa.ubuntu.com/job/ubuntu-settings-components-qmltests-vivid/21
    SUCCESS: http://jenkins.qa.ubuntu.com/job/ubuntu-settings-components-vivid-amd64-ci/9
    SUCCESS: http://jenkins.qa.ubuntu.com/job/ubuntu-settings-components-vivid-armhf-ci/9
        deb: http://jenkins.qa.ubuntu.com/job/ubuntu-settings-components-vivid-armhf-ci/9/artifact/work/output/*zip*/output.zip

Click here to trigger a rebuild:
http://s-jenkins.ubuntu-ci:8080/job/ubuntu-settings-components-ci/102/rebuild

review: Needs Fixing (continuous-integration)

[PS Jenkins bot (ps-jenkins)]

FAILED: Continuous integration, rev:95
http://jenkins.qa.ubuntu.com/job/ubuntu-settings-components-ci/104/
Executed test runs:
    UNSTABLE: http://jenkins.qa.ubuntu.com/job/ubuntu-settings-components-qmltests-vivid/23
    SUCCESS: http://jenkins.qa.ubuntu.com/job/ubuntu-settings-components-vivid-amd64-ci/11
    SUCCESS: http://jenkins.qa.ubuntu.com/job/ubuntu-settings-components-vivid-armhf-ci/11
        deb: http://jenkins.qa.ubuntu.com/job/ubuntu-settings-components-vivid-armhf-ci/11/artifact/work/output/*zip*/output.zip

Click here to trigger a rebuild:
http://s-jenkins.ubuntu-ci:8080/job/ubuntu-settings-components-ci/104/rebuild

review: Needs Fixing (continuous-integration)

[PS Jenkins bot (ps-jenkins)]

PASSED: Continuous integration, rev:96
http://jenkins.qa.ubuntu.com/job/ubuntu-settings-components-ci/105/
Executed test runs:
    SUCCESS: http://jenkins.qa.ubuntu.com/job/ubuntu-settings-components-qmltests-vivid/24
    SUCCESS: http://jenkins.qa.ubuntu.com/job/ubuntu-settings-components-vivid-amd64-ci/12
    SUCCESS: http://jenkins.qa.ubuntu.com/job/ubuntu-settings-components-vivid-armhf-ci/12
        deb: http://jenkins.qa.ubuntu.com/job/ubuntu-settings-components-vivid-armhf-ci/12/artifact/work/output/*zip*/output.zip

Click here to trigger a rebuild:
http://s-jenkins.ubuntu-ci:8080/job/ubuntu-settings-components-ci/105/rebuild

review: Approve (continuous-integration)

[Andrea Cimitan (cimi)]

 * Did you perform an exploratory manual test run of the code change and any related functionality?
Yes
 * Did CI run pass? If not, please explain why.
Yes
 * Did you make sure that the branch does not contain spurious tags?
Yes

review: Approve

[Michał Sawicz (saviq)]

You need a bumped debian/changelog here.

review: Needs Fixing

[Nick Dedekind (nick-dedekind)]

> You need a bumped debian/changelog here.

Changelog is there already.

I've moved the plugins to a plugins folder. Mostly because it resolves the relative path issue without changing the QmlPlugins.cmake so that we keep in line with unity8, but also because they are actually plugins anyway.

Fixed other comments as well.

[Michał Sawicz (saviq)]

CMake Error at CMakeLists.txt:98 (add_subdirectory):
  The source directory

    /build/buildd/ubuntu-settings-components-0.6+15.04.20150407/plugins

  does not contain a CMakeLists.txt file.

review: Needs Fixing

[PS Jenkins bot (ps-jenkins)]

FAILED: Continuous integration, rev:98
http://jenkins.qa.ubuntu.com/job/ubuntu-settings-components-ci/106/
Executed test runs:
    FAILURE: http://jenkins.qa.ubuntu.com/job/ubuntu-settings-components-qmltests-vivid/25/console
    FAILURE: http://jenkins.qa.ubuntu.com/job/ubuntu-settings-components-vivid-amd64-ci/13/console
    FAILURE: http://jenkins.qa.ubuntu.com/job/ubuntu-settings-components-vivid-armhf-ci/13/console

Click here to trigger a rebuild:
http://s-jenkins.ubuntu-ci:8080/job/ubuntu-settings-components-ci/106/rebuild

review: Needs Fixing (continuous-integration)

[lp:~nick-dedekind/ubuntu-settings-components/1390136.laggy-backends]

99. By Nick Dedekind on 2015-04-09

added missing files

[PS Jenkins bot (ps-jenkins)]

PASSED: Continuous integration, rev:99
http://jenkins.qa.ubuntu.com/job/ubuntu-settings-components-ci/107/
Executed test runs:
    SUCCESS: http://jenkins.qa.ubuntu.com/job/ubuntu-settings-components-qmltests-vivid/26
    SUCCESS: http://jenkins.qa.ubuntu.com/job/ubuntu-settings-components-vivid-amd64-ci/14
    SUCCESS: http://jenkins.qa.ubuntu.com/job/ubuntu-settings-components-vivid-armhf-ci/14
        deb: http://jenkins.qa.ubuntu.com/job/ubuntu-settings-components-vivid-armhf-ci/14/artifact/work/output/*zip*/output.zip

Click here to trigger a rebuild:
http://s-jenkins.ubuntu-ci:8080/job/ubuntu-settings-components-ci/107/rebuild

review: Approve (continuous-integration)

[Michał Sawicz (saviq)]

review: Abstain

=== modified file 'CMakeLists.txt'
--- CMakeLists.txt	2014-07-31 16:55:11 +0000
+++ CMakeLists.txt	2015-04-09 12:58:32 +0000
@@ -95,6 +95,6 @@
 # Tests
 enable_testing()
 
-add_subdirectory(Ubuntu)
+add_subdirectory(plugins)
 add_subdirectory(examples)
 add_subdirectory(tests)

=== modified file 'cmake/modules/QmlPlugins.cmake'
--- cmake/modules/QmlPlugins.cmake	2014-06-26 14:21:52 +0000
+++ cmake/modules/QmlPlugins.cmake	2015-04-09 12:58:32 +0000
@@ -12,6 +12,12 @@
     set_target_properties(qmlplugindump PROPERTIES IMPORTED_LOCATION ${qmlplugindump_exe})
 endif()
 
+#
+# A custom target for building the qmltypes files manually.
+#
+if (NOT TARGET qmltypes)
+    add_custom_target(qmltypes)
+endif()
 
 # Creates a target for copying resource files into build dir and optionally installing them.
 #
@@ -33,7 +39,7 @@
 macro(export_qmlfiles PLUGIN PATH)
     set(single SEARCH_PATH BINARY_DIR DESTINATION TARGET_PREFIX)
     cmake_parse_arguments(QMLFILES "" "${single}" "" ${ARGN})
- 
+
     if(NOT QMLFILES_SEARCH_PATH)
         set(QMLFILES_SEARCH_PATH ${CMAKE_CURRENT_SOURCE_DIR})
     endif()
@@ -51,6 +57,7 @@
         ${QMLFILES_SEARCH_PATH}/*.png
         ${QMLFILES_SEARCH_PATH}/*.sci
         ${QMLFILES_SEARCH_PATH}/*.svg
+        ${QMLFILES_SEARCH_PATH}/*.qmltypes
         ${QMLFILES_SEARCH_PATH}/qmldir
     )
 
@@ -69,14 +76,14 @@
             DESTINATION ${QMLFILES_DESTINATION}/${PATH}
         )
     endif()
-endmacro(export_qmlfiles)
-
-
-# Creates a target for generating the typeinfo file for a QML plugin and optionally installs it
-# and additional targets.
+endmacro()
+
+
+# Creates a target for generating the typeinfo file for a QML plugin and/or installs the plugin
+# targets.
 #
 # Files will be copied into ${BINARY_DIR}/${path} or ${CMAKE_CURRENT_BINARY_DIR} and installed
-# into ${DESTINATION}/${path}. If you don't pass BINARY_DIR, it's  assumed that current source
+# into ${DESTINATION}/${path}. If you don't pass BINARY_DIR, it's assumed that current source
 # path ends with ${path}.
 #
 # The generated file will be named after the last segment of the plugin name, e.g. Foo.qmltypes.
@@ -87,15 +94,18 @@
 #     [TARGET_PREFIX string]  # Will be prefixed to the target name
 #     [ENVIRONMENT string]    # Will be added to qmlplugindump's env
 #     [TARGETS target1 [target2 ...]] # Targets to depend on and install (e.g. the plugin shared object)
+#     [NO_TYPES] # Do not create the qmltypes target
 # )
 #
 # Created target:
-#   - ${TARGET_PREFIX}${plugin}-qmltypes - Generates the qmltypes file in the binary dir.
+#   - ${TARGET_PREFIX}${plugin}-qmltypes - Generates the qmltypes file in the source dir.
+#     It will be made a dependency of the "qmltypes" target.
 
 macro(export_qmlplugin PLUGIN VERSION PATH)
+    set(options NO_TYPES)
     set(single BINARY_DIR DESTINATION TARGET_PREFIX ENVIRONMENT)
     set(multi TARGETS)
-    cmake_parse_arguments(QMLPLUGIN "" "${single}" "${multi}" ${ARGN})
+    cmake_parse_arguments(QMLPLUGIN "${options}" "${single}" "${multi}" ${ARGN})
 
     get_target_property(qmlplugindump_executable qmlplugindump LOCATION)
 
@@ -103,29 +113,26 @@
         set(qmlplugin_dir ${QMLPLUGIN_BINARY_DIR}/${PATH})
     else()
         # Find import path to point qmlplugindump at
-        string(REGEX REPLACE "${PATH}$" "" QMLPLUGIN_BINARY_DIR "${CMAKE_CURRENT_BINARY_DIR}")
+        string(REGEX REPLACE "/${PATH}$" "" QMLPLUGIN_BINARY_DIR "${CMAKE_CURRENT_BINARY_DIR}")
         set(qmlplugin_dir ${CMAKE_CURRENT_BINARY_DIR})
     endif()
 
-    # Find the last segment of the plugin name to use as qmltypes basename
-    string(REGEX MATCH "[^.]+$" plugin_suffix ${PLUGIN})
-    set(target_prefix ${QMLPLUGIN_TARGET_PREFIX}${PLUGIN})
-    set(qmltypes_path ${qmlplugin_dir}/${plugin_suffix}.qmltypes)
-
-    # Only generate typeinfo if not cross compiling
-    if(NOT CMAKE_CROSSCOMPILING)
-        add_custom_target(${target_prefix}-qmltypes ALL
+    if(NOT QMLPLUGIN_NO_TYPES)
+        # Relative path for the module
+        string(REPLACE "${CMAKE_BINARY_DIR}/" "" QMLPLUGIN_MODULE_DIR "${QMLPLUGIN_BINARY_DIR}")
+
+        # Find the last segment of the plugin name to use as qmltypes basename
+        string(REGEX MATCH "[^.]+$" plugin_suffix ${PLUGIN})
+        set(target_prefix ${QMLPLUGIN_TARGET_PREFIX}${PLUGIN})
+        set(qmltypes_path ${CMAKE_CURRENT_SOURCE_DIR}/${plugin_suffix}.qmltypes)
+
+        add_custom_target(${target_prefix}-qmltypes
             COMMAND env ${QMLPLUGIN_ENVIRONMENT} ${qmlplugindump_executable} -notrelocatable
-                    ${PLUGIN} ${VERSION} ${QMLPLUGIN_BINARY_DIR} > ${qmltypes_path}
+                    ${PLUGIN} ${VERSION} ${QMLPLUGIN_MODULE_DIR} > ${qmltypes_path}
+                    WORKING_DIRECTORY ${CMAKE_BINARY_DIR}
         )
         add_dependencies(${target_prefix}-qmltypes ${target_prefix}-qmlfiles ${QMLPLUGIN_TARGETS})
-
-        if (QMLPLUGIN_DESTINATION)
-            # Install the typeinfo file
-            install(FILES ${qmltypes_path}
-                    DESTINATION ${QMLPLUGIN_DESTINATION}/${PATH}
-            )
-        endif()
+        add_dependencies(qmltypes ${target_prefix}-qmltypes)
     endif()
 
     set_target_properties(${QMLPLUGIN_TARGETS} PROPERTIES

=== modified file 'debian/changelog'
--- debian/changelog	2015-01-23 12:17:25 +0000
+++ debian/changelog	2015-04-09 12:58:32 +0000
@@ -1,3 +1,10 @@
+ubuntu-settings-components (0.6-0ubuntu1) UNRELEASED; urgency=medium
+
+  [ Nick Dedekind ]
+  * Added ServerActivationSync
+
+ -- Nick Dedekind <[e-mail]>  Thu, 12 Mar 2015 14:04:34 +0000
+
 ubuntu-settings-components (0.5+15.04.20150123.1-0ubuntu1) vivid; urgency=medium
 
   [ Sebastien Bacher ]
@@ -5,6 +12,12 @@
 
  -- Ubuntu daily release <[e-mail]>  Fri, 23 Jan 2015 12:17:25 +0000
 
+ubuntu-settings-components (0.5-0ubuntu1) UNRELEASED; urgency=medium
+
+  * Added SyncSwitch & SyncCheckBox components
+
+ -- Nick Dedekind <[e-mail]>  Thu, 23 Oct 2014 17:09:21 -0400
+
 ubuntu-settings-components (0.4+15.04.20141105-0ubuntu1) vivid; urgency=low
 
   [ Sebastien Bacher ]

=== added directory 'plugins'
=== added file 'plugins/CMakeLists.txt'
--- plugins/CMakeLists.txt	1970-01-01 00:00:00 +0000
+++ plugins/CMakeLists.txt	2015-04-09 12:58:32 +0000
@@ -0,0 +1,8 @@
+include(QmlPlugins)
+
+macro(add_usc_plugin PLUGIN VERSION PATH)
+    export_qmlfiles(${PLUGIN} ${PATH} DESTINATION ${QT_IMPORTS_DIR} ${ARGN})
+    export_qmlplugin(${PLUGIN} ${VERSION} ${PATH} DESTINATION ${QT_IMPORTS_DIR} ${ARGN})
+endmacro()
+
+add_subdirectory(Ubuntu)

=== renamed directory 'Ubuntu' => 'plugins/Ubuntu'
=== modified file 'plugins/Ubuntu/Settings/CMakeLists.txt'
--- Ubuntu/Settings/CMakeLists.txt	2014-06-26 14:21:52 +0000
+++ plugins/Ubuntu/Settings/CMakeLists.txt	2015-04-09 12:58:32 +0000
@@ -1,9 +1,2 @@
-include(QmlPlugins)
-
-macro(add_usc_plugin PLUGIN VERSION PATH)
-    export_qmlfiles(${PLUGIN} ${PATH} DESTINATION ${QT_IMPORTS_DIR} ${ARGN})
-    export_qmlplugin(${PLUGIN} ${VERSION} ${PATH} DESTINATION ${QT_IMPORTS_DIR} ${ARGN})
-endmacro()
-
 add_subdirectory(Components)
 add_subdirectory(Menus)

=== modified file 'plugins/Ubuntu/Settings/Components/CMakeLists.txt'
--- Ubuntu/Settings/Components/CMakeLists.txt	2014-07-31 13:05:44 +0000
+++ plugins/Ubuntu/Settings/Components/CMakeLists.txt	2015-04-09 12:58:32 +0000
@@ -1,1 +1,19 @@
-add_usc_plugin(Ubuntu.Settings.Components 0.1 Ubuntu/Settings/Components)
+project(UbuntuSettingsComponentsQml)
+
+find_package(Qt5Core REQUIRED)
+
+include_directories(
+    ${CMAKE_CURRENT_SOURCE_DIR}
+    ${CMAKE_CURRENT_BINARY_DIR}
+)
+
+add_definitions(-DUBUNTUSETTINGSCOMPONENTS_LIBRARY)
+
+add_library(UbuntuSettingsComponentsQml MODULE
+    plugin.cpp
+    serverpropertysynchroniser.cpp
+)
+
+qt5_use_modules(UbuntuSettingsComponentsQml Core Qml Quick)
+
+add_usc_plugin(Ubuntu.Settings.Components 0.1 Ubuntu/Settings/Components TARGETS UbuntuSettingsComponentsQml)

=== added file 'plugins/Ubuntu/Settings/Components/Components.qmltypes'
--- plugins/Ubuntu/Settings/Components/Components.qmltypes	1970-01-01 00:00:00 +0000
+++ plugins/Ubuntu/Settings/Components/Components.qmltypes	2015-04-09 12:58:32 +0000
@@ -0,0 +1,73 @@
+import QtQuick.tooling 1.1
+
+// This file describes the plugin-supplied types contained in the library.
+// It is used for QML tooling purposes only.
+//
+// This file was auto-generated by:
+// 'qmlplugindump -notrelocatable Ubuntu.Settings.Components 0.1 plugins'
+
+Module {
+    Component {
+        name: "ServerPropertySynchroniser"
+        prototype: "QObject"
+        exports: ["Ubuntu.Settings.Components/ServerPropertySynchroniser 0.1"]
+        exportMetaObjectRevisions: [0]
+        Property { name: "serverTarget"; type: "QObject"; isPointer: true }
+        Property { name: "serverProperty"; type: "string" }
+        Property { name: "userTarget"; type: "QObject"; isPointer: true }
+        Property { name: "userProperty"; type: "string" }
+        Property { name: "userTrigger"; type: "string" }
+        Property { name: "syncTimeout"; type: "int" }
+        Property { name: "useWaitBuffer"; type: "bool" }
+        Property { name: "maximumWaitBufferInterval"; type: "int" }
+        Property { name: "bufferedSyncTimeout"; type: "bool" }
+        Property { name: "syncWaiting"; type: "bool"; isReadonly: true }
+        Signal {
+            name: "serverTargetChanged"
+            Parameter { name: "serverTarget"; type: "QObject"; isPointer: true }
+        }
+        Signal {
+            name: "serverPropertyChanged"
+            Parameter { name: "serverProperty"; type: "string" }
+        }
+        Signal {
+            name: "userTargetChanged"
+            Parameter { name: "userTarget"; type: "QObject"; isPointer: true }
+        }
+        Signal {
+            name: "userPropertyChanged"
+            Parameter { name: "serverProperty"; type: "string" }
+        }
+        Signal {
+            name: "userTriggerChanged"
+            Parameter { name: "userTrigger"; type: "string" }
+        }
+        Signal {
+            name: "syncTimeoutChanged"
+            Parameter { name: "timeout"; type: "int" }
+        }
+        Signal {
+            name: "syncWaitingChanged"
+            Parameter { name: "waiting"; type: "bool" }
+        }
+        Signal {
+            name: "bufferedSyncTimeoutChanged"
+            Parameter { type: "bool" }
+        }
+        Signal {
+            name: "useWaitBufferChanged"
+            Parameter { name: "useWaitBuffer"; type: "bool" }
+        }
+        Signal {
+            name: "maximumWaitBufferIntervalChanged"
+            Parameter { name: "timeout"; type: "int" }
+        }
+        Signal {
+            name: "syncTriggered"
+            Parameter { name: "value"; type: "QVariant" }
+        }
+        Method { name: "updateUserValue" }
+        Method { name: "activate" }
+        Method { name: "reset" }
+    }
+}

=== added file 'plugins/Ubuntu/Settings/Components/plugin.cpp'
--- plugins/Ubuntu/Settings/Components/plugin.cpp	1970-01-01 00:00:00 +0000
+++ plugins/Ubuntu/Settings/Components/plugin.cpp	2015-04-09 12:58:32 +0000
@@ -0,0 +1,27 @@
+/*
+ * Copyright (C) 2015 Canonical, Ltd.
+ *
+ * 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; version 3.
+ *
+ * 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 <http://www.gnu.org/licenses/>.
+ */
+
+// local
+#include "plugin.h"
+#include "serverpropertysynchroniser.h"
+
+// Qt
+#include <QtQml/qqml.h>
+
+void UbuntuSettingsComponentsPlugin::registerTypes(const char *uri)
+{
+    qmlRegisterType<ServerPropertySynchroniser>(uri, 0, 1, "ServerPropertySynchroniser");
+}

=== added file 'plugins/Ubuntu/Settings/Components/plugin.h'
--- plugins/Ubuntu/Settings/Components/plugin.h	1970-01-01 00:00:00 +0000
+++ plugins/Ubuntu/Settings/Components/plugin.h	2015-04-09 12:58:32 +0000
@@ -0,0 +1,30 @@
+/*
+ * Copyright (C) 2015 Canonical, Ltd.
+ *
+ * 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; version 3.
+ *
+ * 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 <http://www.gnu.org/licenses/>.
+ */
+
+#ifndef UBUNTUSETTINGSCOMPONENTS_PLUGIN_H
+#define UBUNTUSETTINGSCOMPONENTS_PLUGIN_H
+
+#include <QtQml/QQmlExtensionPlugin>
+
+class UbuntuSettingsComponentsPlugin : public QQmlExtensionPlugin
+{
+    Q_OBJECT
+    Q_PLUGIN_METADATA(IID "org.qt-project.Qt.QQmlExtensionInterface")
+public:
+    void registerTypes(const char *uri);
+};
+
+#endif // UBUNTUSETTINGSCOMPONENTS_PLUGIN_H

=== modified file 'plugins/Ubuntu/Settings/Components/qmldir'
--- Ubuntu/Settings/Components/qmldir	2014-09-15 17:18:27 +0000
+++ plugins/Ubuntu/Settings/Components/qmldir	2015-04-09 12:58:32 +0000
@@ -1,4 +1,6 @@
 module Ubuntu.Settings.Components
+plugin UbuntuSettingsComponentsQml
+typeinfo Components.qmltypes
 
 ActionTextField 0.1 ActionTextField.qml
 Calendar 0.1 Calendar.qml

=== added file 'plugins/Ubuntu/Settings/Components/serverpropertysynchroniser.cpp'
--- plugins/Ubuntu/Settings/Components/serverpropertysynchroniser.cpp	1970-01-01 00:00:00 +0000
+++ plugins/Ubuntu/Settings/Components/serverpropertysynchroniser.cpp	2015-04-09 12:58:32 +0000
@@ -0,0 +1,382 @@
+/*
+ * Copyright (C) 2015 Canonical, Ltd.
+ *
+ * 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; version 3.
+ *
+ * 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 <http://www.gnu.org/licenses/>.
+ */
+
+#include "serverpropertysynchroniser.h"
+
+#include <QQmlProperty>
+#include <QTimer>
+#include <QDebug>
+
+ServerPropertySynchroniser::ServerPropertySynchroniser(QObject* parent)
+    : QObject(parent)
+    , m_serverTarget(nullptr)
+    , m_userTarget(nullptr)
+    , m_classComplete(false)
+    , m_busy(false)
+    , m_connectedServerTarget(nullptr)
+    , m_connectedUserTarget(nullptr)
+    , m_serverSyncTimer(new QTimer(this))
+    , m_bufferTimeout(nullptr)
+    , m_useWaitBuffer(true)
+    , m_buffering(false)
+    , m_bufferedSyncTimeout(false)
+{
+    m_serverSyncTimer->setSingleShot(true);
+    m_serverSyncTimer->setInterval(30000);
+    connect(m_serverSyncTimer, &QTimer::timeout, this, &ServerPropertySynchroniser::serverSyncTimedOut);
+}
+
+void ServerPropertySynchroniser::classBegin()
+{
+    m_classComplete = false;
+}
+
+void ServerPropertySynchroniser::componentComplete()
+{
+    m_classComplete = true;
+    connectServer();
+    connectUser();
+}
+
+void ServerPropertySynchroniser::reset()
+{
+    if (m_serverSyncTimer->isActive()) {
+        m_serverSyncTimer->stop();
+        Q_EMIT syncWaitingChanged(false);
+    }
+    if (m_bufferTimeout) m_bufferTimeout->stop();
+    m_buffering = false;
+}
+
+QObject *ServerPropertySynchroniser::serverTarget() const
+{
+    return m_serverTarget;
+}
+
+void ServerPropertySynchroniser::setServerTarget(QObject *target)
+{
+    if (m_serverTarget != target) {
+        m_serverTarget = target;
+        Q_EMIT serverTargetChanged(m_serverTarget);
+
+        connectServer();
+    }
+}
+
+QString ServerPropertySynchroniser::serverProperty() const
+{
+    return m_serverProperty;
+}
+
+void ServerPropertySynchroniser::setServerProperty(const QString &property)
+{
+    if (m_serverProperty != property) {
+        m_serverProperty = property;
+        Q_EMIT serverPropertyChanged(m_serverProperty);
+
+        connectServer();
+    }
+}
+
+QObject *ServerPropertySynchroniser::userTarget() const
+{
+    return m_userTarget;
+}
+
+void ServerPropertySynchroniser::setUserTarget(QObject *target)
+{
+    if (m_userTarget != target) {
+        m_userTarget = target;
+        Q_EMIT userTargetChanged(m_userTarget);
+
+        connectUser();
+    }
+}
+
+QString ServerPropertySynchroniser::userProperty() const
+{
+    return m_userProperty;
+}
+
+void ServerPropertySynchroniser::setUserProperty(const QString &property)
+{
+    if (m_userProperty != property) {
+        m_userProperty = property;
+        Q_EMIT userPropertyChanged(m_userProperty);
+
+        connectUser();
+    }
+}
+
+QString ServerPropertySynchroniser::userTrigger() const
+{
+    return m_userTrigger;
+}
+
+void ServerPropertySynchroniser::setUserTrigger(const QString &trigger)
+{
+    if (m_userTrigger != trigger) {
+        m_userTrigger = trigger;
+        Q_EMIT userPropertyChanged(m_userTrigger);
+
+        connectUser();
+    }
+}
+
+int ServerPropertySynchroniser::syncTimeout() const
+{
+    return m_serverSyncTimer->interval();
+}
+
+void ServerPropertySynchroniser::setSyncTimeout(int timeout)
+{
+    if (m_serverSyncTimer->interval() != timeout) {
+        m_serverSyncTimer->setInterval(timeout);
+        Q_EMIT syncTimeoutChanged(timeout);
+    }
+}
+
+bool ServerPropertySynchroniser::useWaitBuffer() const
+{
+    return m_useWaitBuffer;
+}
+
+void ServerPropertySynchroniser::setUseWaitBuffer(bool value)
+{
+    if (m_useWaitBuffer != value) {
+        m_useWaitBuffer = value;
+        Q_EMIT useWaitBufferChanged(m_useWaitBuffer);
+    }
+}
+
+int ServerPropertySynchroniser::maximumWaitBufferInterval() const
+{
+    return m_bufferTimeout ? m_bufferTimeout->interval() : -1;
+}
+
+void ServerPropertySynchroniser::setMaximumWaitBufferInterval(int timeout)
+{
+    if (timeout >= 0) {
+        if (!m_bufferTimeout) {
+            m_bufferTimeout = new QTimer(this);
+            m_bufferTimeout->setInterval(timeout);
+            m_bufferTimeout->setSingleShot(true);
+            connect(m_bufferTimeout, &QTimer::timeout, this, &ServerPropertySynchroniser::bufferTimedOut);
+
+            Q_EMIT maximumWaitBufferIntervalChanged(timeout);
+        }
+        else if (timeout != m_bufferTimeout->interval()) {
+            m_bufferTimeout->setInterval(timeout);
+            Q_EMIT maximumWaitBufferIntervalChanged(timeout);
+        }
+
+    } else if (m_bufferTimeout) {
+        if (m_bufferTimeout->isActive()) {
+            m_buffering = false;
+        }
+        delete m_bufferTimeout;
+        m_bufferTimeout = nullptr;
+        Q_EMIT maximumWaitBufferIntervalChanged(timeout);
+    }
+}
+
+bool ServerPropertySynchroniser::bufferedSyncTimeout() const
+{
+    return m_bufferedSyncTimeout;
+}
+
+void ServerPropertySynchroniser::setBufferedSyncTimeout(bool value)
+{
+    if (m_bufferedSyncTimeout != value) {
+        m_bufferedSyncTimeout = value;
+        Q_EMIT bufferedSyncTimeoutChanged(value);
+    }
+}
+
+bool ServerPropertySynchroniser::syncWaiting() const
+{
+    return m_serverSyncTimer->isActive();
+}
+
+void ServerPropertySynchroniser::activate()
+{
+    // Don't want any signals we fire to create binding loops.
+    if (m_busy) return;
+    m_busy = true;
+
+    if (m_useWaitBuffer) {
+        // Dampen the activations? Buffer the change.
+        if (m_bufferTimeout) {
+            if (m_bufferTimeout->isActive()) {
+                m_buffering = true;
+                m_busy = false;
+                return;
+            }
+            m_bufferTimeout->start();
+        // Not using a buffer timer? Buffer the change till server timeout
+        } else if (m_serverSyncTimer->isActive()) {
+            m_buffering = true;
+            m_busy = false;
+            return;
+        }
+    }
+
+    m_serverSyncTimer->start();
+    Q_EMIT syncWaitingChanged(true);
+
+    // Fire off a change to the server user property value
+    QQmlProperty userProp(m_userTarget, m_userProperty);
+    if (!userProp.isValid()) {
+        Q_EMIT syncTriggered(QVariant());
+    } else {
+        Q_EMIT syncTriggered(userProp.read());
+    }
+    m_busy = false;
+}
+
+void ServerPropertySynchroniser::connectServer()
+{
+    // if we havent finished constructing the class, then wait
+    if (!m_classComplete) return;
+
+    if (m_connectedServerTarget) QObject::disconnect(m_connectedServerTarget, 0, this, 0);
+    if (!m_serverTarget || m_serverProperty.isEmpty()) {
+        return;
+    }
+
+    // Connect to the server property change
+    QQmlProperty prop(m_serverTarget, m_serverProperty);
+    if (prop.isValid()) {
+        if (prop.connectNotifySignal(this, SLOT(updateUserValue()))) {
+            m_connectedServerTarget = m_serverTarget;
+        }
+        // once we're connected to the server property, we need to make sure the user target is
+        // set to the server value
+        updateUserValue();
+    }
+}
+
+void ServerPropertySynchroniser::connectUser()
+{
+    // if we havent finished constructing the class, then wait
+    if (!m_classComplete) return;
+
+    if (m_connectedUserTarget) QObject::disconnect(m_connectedUserTarget, 0, this, 0);
+    if (!m_userTarget) {
+        if (!parent()) return;
+        m_userTarget = parent();
+        Q_EMIT userTargetChanged(m_userTarget);
+    }
+
+    if (m_userTrigger.isEmpty()) {
+        // Connect to the user property change
+        QQmlProperty prop(m_userTarget, m_userProperty);
+        if (prop.isValid()) {
+            if (prop.connectNotifySignal(this, SLOT(activate()))) {
+                m_connectedUserTarget = m_userTarget;
+            }
+            // once we're connected to the user property, we need to make sure the user target is
+            // set to the server value
+            updateUserValue();
+        }
+    } else {
+        QQmlProperty prop(m_userTarget, m_userTrigger);
+        if (prop.isValid() && prop.isSignalProperty()) {
+            if (connect(m_userTarget, ("2" + prop.method().methodSignature()).constData(),
+                        this, SLOT(activate()))) {
+                m_connectedUserTarget = m_userTarget;
+            }
+
+            // once we're connected to the user signal, we need to make sure the user target is
+            // set to the server value
+            updateUserValue();
+        }
+    }
+}
+
+void ServerPropertySynchroniser::updateUserValue()
+{
+    // Don't want any signals we fire to create binding loops.
+    if (m_busy) return;
+    m_busy = true;
+
+    bool waitingBufferedServerChange = m_bufferTimeout && m_bufferTimeout->isActive();
+
+    // If we've been waiting for a sync, stop the wait.
+    if (m_serverSyncTimer->isActive()) {
+        m_serverSyncTimer->stop();
+        Q_EMIT syncWaitingChanged(false);
+    }
+
+    QQmlProperty userProp(m_userTarget, m_userProperty);
+    QQmlProperty serverProp(m_serverTarget, m_serverProperty);
+    if (!userProp.isValid() || !serverProp.isValid()) {
+        m_busy = false;
+        return;
+    }
+
+    // If we've been buffering changes since last change was send,
+    // we verify that what the server gave us is what we want, and send another
+    // activation if not.
+    if (m_buffering) {
+        m_buffering = false;
+        m_busy = false;
+        if (serverProp.read() != userProp.read()) {
+            activate();
+        }
+        return;
+    }
+
+    // Don't update until we hit the buffer timeout.
+    if (waitingBufferedServerChange) {
+        m_busy = false;
+        return;
+    }
+
+    // update the user target property.
+    userProp.write(serverProp.read());
+    m_busy = false;
+}
+
+void ServerPropertySynchroniser::serverSyncTimedOut()
+{
+    if (m_buffering && !m_bufferedSyncTimeout) {
+        m_buffering = false;
+    }
+    Q_EMIT syncWaitingChanged(false);
+    updateUserValue();
+}
+
+void ServerPropertySynchroniser::bufferTimedOut()
+{
+    if (m_buffering) {
+        m_buffering = false;
+        activate();
+    } else {
+        // Update the user value.
+        if (m_busy) return;
+        m_busy = true;
+
+        QQmlProperty userProp(m_userTarget, m_userProperty);
+        QQmlProperty serverProp(m_serverTarget, m_serverProperty);
+        if (!userProp.isValid() || !serverProp.isValid()) {
+            m_busy = false;
+            return;
+        }
+        userProp.write(serverProp.read());
+        m_busy = false;
+    }
+}

=== added file 'plugins/Ubuntu/Settings/Components/serverpropertysynchroniser.h'
--- plugins/Ubuntu/Settings/Components/serverpropertysynchroniser.h	1970-01-01 00:00:00 +0000
+++ plugins/Ubuntu/Settings/Components/serverpropertysynchroniser.h	2015-04-09 12:58:32 +0000
@@ -0,0 +1,157 @@
+/*
+ * Copyright (C) 2015 Canonical, Ltd.
+ *
+ * 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; version 3.
+ *
+ * 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 <http://www.gnu.org/licenses/>.
+ */
+
+#ifndef SERVERPROPERTYSYNCHRONISER_H
+#define SERVERPROPERTYSYNCHRONISER_H
+
+#include <QObject>
+#include <QQmlParserStatus>
+#include <QVariant>
+
+class QTimer;
+
+class ServerPropertySynchroniser : public QObject, public QQmlParserStatus
+{
+    Q_OBJECT
+    Q_INTERFACES(QQmlParserStatus)
+
+    // Target object which contains the property to keep the user property in sync with.
+    Q_PROPERTY(QObject* serverTarget READ serverTarget WRITE setServerTarget NOTIFY serverTargetChanged)
+    // Server property to keep the user property in sync with.
+    Q_PROPERTY(QString serverProperty READ serverProperty WRITE setServerProperty NOTIFY serverPropertyChanged)
+
+    // User object (control) which sources the property to update the server property.
+    // Defaults to the object's parent if not set.
+    Q_PROPERTY(QObject* userTarget READ userTarget WRITE setUserTarget NOTIFY userTargetChanged)
+    // User property to update the server property.
+    Q_PROPERTY(QString userProperty READ userProperty WRITE setUserProperty NOTIFY userPropertyChanged)
+    // Trigger that causes an update. By default, the control will use the userProperty change notification.
+    // eg. "onTriggered"
+    Q_PROPERTY(QString userTrigger READ userTrigger WRITE setUserTrigger NOTIFY userTriggerChanged)
+
+    // Time to wait for a change verification before re-asserting the server value.
+    Q_PROPERTY(int syncTimeout READ syncTimeout WRITE setSyncTimeout NOTIFY syncTimeoutChanged)
+
+    // Buffer user property changes until the previous change is verified
+    Q_PROPERTY(bool useWaitBuffer
+               READ useWaitBuffer
+               WRITE setUseWaitBuffer
+               NOTIFY useWaitBufferChanged)
+
+    // Maximum intervals between buffers for the server to respond. If we don't get a response within this interval,
+    // the next buffer will be sent. Good for live sliders. Defaults to disabled.
+    Q_PROPERTY(int maximumWaitBufferInterval
+               READ maximumWaitBufferInterval
+               WRITE setMaximumWaitBufferInterval
+               NOTIFY maximumWaitBufferIntervalChanged)
+
+    // Resend the buffered value if we timeout waiting for a change from the server. Defaults to false
+    Q_PROPERTY(bool bufferedSyncTimeout
+               READ bufferedSyncTimeout
+               WRITE setBufferedSyncTimeout
+               NOTIFY bufferedSyncTimeoutChanged)
+
+    // True if we're waiting for a change verification from the server
+    Q_PROPERTY(bool syncWaiting READ syncWaiting NOTIFY syncWaitingChanged)
+
+public:
+    ServerPropertySynchroniser(QObject* parent = nullptr);
+
+    QObject* serverTarget() const;
+    void setServerTarget(QObject* target);
+
+    QString serverProperty() const;
+    void setServerProperty(const QString& property);
+
+    QObject* userTarget() const;
+    void setUserTarget(QObject* target);
+
+    QString userProperty() const;
+    void setUserProperty(const QString& property);
+
+    QString userTrigger() const;
+    void setUserTrigger(const QString& trigger);
+
+    int syncTimeout() const;
+    void setSyncTimeout(int timeout);
+
+    bool useWaitBuffer() const;
+    void setUseWaitBuffer(bool value);
+
+    int maximumWaitBufferInterval() const;
+    void setMaximumWaitBufferInterval(int timeout);
+
+    bool bufferedSyncTimeout() const;
+    void setBufferedSyncTimeout(bool);
+
+    bool syncWaiting() const;
+
+    void classBegin() override;
+    void componentComplete() override;
+
+    Q_INVOKABLE void reset();
+
+public Q_SLOTS:
+    void updateUserValue();
+    void activate();
+
+Q_SIGNALS:
+    void serverTargetChanged(QObject* serverTarget);
+    void serverPropertyChanged(QString serverProperty);
+
+    void userTargetChanged(QObject* userTarget);
+    void userPropertyChanged(QString serverProperty);
+    void userTriggerChanged(QString userTrigger);
+
+    void syncTimeoutChanged(int timeout);
+    void syncWaitingChanged(bool waiting);
+    void bufferedSyncTimeoutChanged(bool);
+
+    void useWaitBufferChanged(bool useWaitBuffer);
+    void maximumWaitBufferIntervalChanged(int timeout);
+
+    // Emitted when we want to update the backend.
+    void syncTriggered(const QVariant& value);
+
+private Q_SLOTS:
+    void serverSyncTimedOut();
+    void bufferTimedOut();
+
+private:
+    void connectServer();
+    void connectUser();
+
+    QObject* m_serverTarget;
+    QString m_serverProperty;
+
+    QObject* m_userTarget;
+    QString m_userProperty;
+    QString m_userTrigger;
+
+    bool m_classComplete;
+    bool m_busy;
+
+    QObject* m_connectedServerTarget;
+    QObject* m_connectedUserTarget;
+
+    QTimer* m_serverSyncTimer;
+    QTimer* m_bufferTimeout;
+    bool m_useWaitBuffer;
+    bool m_buffering;
+    bool m_bufferedSyncTimeout;
+};
+
+#endif // SERVERPROPERTYSYNCHRONISER_H

=== added file 'plugins/Ubuntu/Settings/Menus/Menus.qmltypes'
--- plugins/Ubuntu/Settings/Menus/Menus.qmltypes	1970-01-01 00:00:00 +0000
+++ plugins/Ubuntu/Settings/Menus/Menus.qmltypes	2015-04-09 12:58:32 +0000
@@ -0,0 +1,30 @@
+import QtQuick.tooling 1.1
+
+// This file describes the plugin-supplied types contained in the library.
+// It is used for QML tooling purposes only.
+//
+// This file was auto-generated by:
+// 'qmlplugindump -notrelocatable Ubuntu.Settings.Menus 0.1 plugins'
+
+Module {
+    Component {
+        name: "TransferState"
+        prototype: "QObject"
+        exports: ["Ubuntu.Settings.Menus/TransferState 0.1"]
+        isCreatable: false
+        exportMetaObjectRevisions: [0]
+        Enum {
+            name: "TransferStates"
+            values: {
+                "Queued": 0,
+                "Running": 1,
+                "Paused": 2,
+                "Canceled": 3,
+                "Hashing": 4,
+                "Processing": 5,
+                "Finished": 6,
+                "Error": 7
+            }
+        }
+    }
+}

=== modified file 'plugins/Ubuntu/Settings/Menus/plugin.cpp'
--- Ubuntu/Settings/Menus/plugin.cpp	2014-06-27 13:56:26 +0000
+++ plugins/Ubuntu/Settings/Menus/plugin.cpp	2015-04-09 12:58:32 +0000
@@ -21,7 +21,7 @@
 // Qt
 #include <QtQml/qqml.h>
 
-void UbuntuSettingsComponentsPlugin::registerTypes(const char *uri)
+void UbuntuSettingsMenusPlugin::registerTypes(const char *uri)
 {
     qmlRegisterUncreatableType<TransferState>(uri, 0, 1, "TransferState", "Can't create TransferState class");
 }

=== modified file 'plugins/Ubuntu/Settings/Menus/plugin.h'
--- Ubuntu/Settings/Menus/plugin.h	2014-06-27 09:39:18 +0000
+++ plugins/Ubuntu/Settings/Menus/plugin.h	2015-04-09 12:58:32 +0000
@@ -14,12 +14,12 @@
  * along with this program.  If not, see <http://www.gnu.org/licenses/>.
  */
 
-#ifndef UBUNTUSETTINGSCOMPOENNTS_PLUGIN_H
-#define UBUNTUSETTINGSCOMPOENNTS_PLUGIN_H
+#ifndef UBUNTUSETTINGSMENUS_PLUGIN_H
+#define UBUNTUSETTINGSMENUS_PLUGIN_H
 
 #include <QtQml/QQmlExtensionPlugin>
 
-class UbuntuSettingsComponentsPlugin : public QQmlExtensionPlugin
+class UbuntuSettingsMenusPlugin : public QQmlExtensionPlugin
 {
     Q_OBJECT
     Q_PLUGIN_METADATA(IID "org.qt-project.Qt.QQmlExtensionInterface")
@@ -27,4 +27,4 @@
     void registerTypes(const char *uri);
 };
 
-#endif // UBUNTUSETTINGSCOMPOENNTS_PLUGIN_H
+#endif // UBUNTUSETTINGSMENUS_PLUGIN_H

=== modified file 'plugins/Ubuntu/Settings/Menus/qmldir'
--- Ubuntu/Settings/Menus/qmldir	2014-07-25 17:53:08 +0000
+++ plugins/Ubuntu/Settings/Menus/qmldir	2015-04-09 12:58:32 +0000
@@ -1,6 +1,6 @@
 module Ubuntu.Settings.Menus
 plugin UbuntuSettingsMenusQml
-typeinfo plugin.qmltypes
+typeinfo Menus.qmltypes
 
 AccessPointMenu 0.1 AccessPointMenu.qml
 ButtonMenu 0.1 ButtonMenu.qml

=== modified file 'tests/qmltests/CMakeLists.txt'
--- tests/qmltests/CMakeLists.txt	2014-07-31 11:29:03 +0000
+++ tests/qmltests/CMakeLists.txt	2015-04-09 12:58:32 +0000
@@ -6,11 +6,12 @@
 set(qmltest_DEFAULT_PROPERTIES ENVIRONMENT "LC_ALL=C")
 
 set(qmltest_DEFAULT_IMPORT_PATHS
-  ${CMAKE_BINARY_DIR}
+  ${CMAKE_BINARY_DIR}/plugins
   ${CMAKE_BINARY_DIR}/tests/utils/modules
 )
 
 add_qml_test(Components Calendar)
+add_qml_test(Components ServerPropertySynchroniser)
 add_qml_test(Components StatusIcon)
 
 add_qml_test(Menus AccessPointMenu)

=== added file 'tests/qmltests/Components/tst_ServerPropertySynchroniser.qml'
--- tests/qmltests/Components/tst_ServerPropertySynchroniser.qml	1970-01-01 00:00:00 +0000
+++ tests/qmltests/Components/tst_ServerPropertySynchroniser.qml	2015-04-09 12:58:32 +0000
@@ -0,0 +1,398 @@
+/*
+ * Copyright 2015 Canonical Ltd.
+ *
+ * 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; version 3.
+ *
+ * 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/>.
+ */
+
+import QtQuick 2.3
+import QtTest 1.0
+import Ubuntu.Test 0.1
+import Ubuntu.Settings.Components 0.1 as USC
+import Ubuntu.Settings.Menus 0.1 as USM
+import Ubuntu.Components 0.1
+
+Item {
+    id: root
+    width: units.gu(60)
+    height: units.gu(70)
+
+    QtObject {
+        id: switchBackend
+
+        property bool checked: false
+        property bool inSync: checked === switchControl.checked
+
+        property Timer timer: Timer {
+            interval: 2000
+            onTriggered: switchBackend.checked = !switchBackend.checked
+        }
+    }
+
+    QtObject {
+        id: checkBackend
+
+        property bool checked: false
+        property bool inSync: checked === checkControl.checked
+
+        property Timer timer: Timer {
+            interval: 2000
+            onTriggered: checkBackend.checked = !checkBackend.checked
+        }
+    }
+
+    QtObject {
+        id: sliderBackend
+
+        property real value: 50
+        property bool inSync: value === slider.value
+        property var changeToValue: undefined
+
+        property Timer timer: Timer {
+            interval: 200
+
+            onTriggered: {
+                sliderBackend.value = sliderBackend.changeToValue;
+            }
+        }
+    }
+
+    QtObject {
+        id: apBackend
+
+        property bool active: false
+        property bool inSync: active === apMenu.active
+
+        property Timer timer: Timer {
+            interval: 2000
+            onTriggered: apBackend.active = !apBackend.active
+        }
+    }
+
+
+    Column {
+        anchors.fill: parent
+        anchors.margins: units.gu(1)
+
+        spacing: units.gu(2)
+
+        Row {
+            spacing: units.gu(3)
+
+            Switch {
+                id: switchControl
+                anchors.verticalCenter: parent.verticalCenter
+
+                USC.ServerPropertySynchroniser {
+                    id: switchSync
+                    objectName: "switchSync"
+
+                    syncTimeout: 3000
+
+                    userTarget: switchControl
+                    userProperty: "checked"
+
+                    serverTarget: switchBackend
+                    serverProperty: "checked"
+
+                    onSyncTriggered: switchBackend.timer.start()
+                    onSyncWaitingChanged: switchSyncSpy.clear()
+                }
+            }
+
+            Column {
+                Label { text: switchBackend.inSync ? "synced" : "out of sync" }
+                Label { text: switchSync.syncWaiting ? "syncWait" : "no syncWait" }
+                Label { text: "activates: " + switchSyncSpy.count }
+            }
+        }
+
+        Row {
+            spacing: units.gu(3)
+
+            CheckBox {
+                id: checkControl
+                anchors.verticalCenter: parent.verticalCenter
+
+                USC.ServerPropertySynchroniser {
+                    id: checkSync
+                    objectName: "checkSync"
+
+                    syncTimeout: 3000
+
+                    userTarget: checkControl
+                    userProperty: "checked"
+
+                    serverTarget: checkBackend
+                    serverProperty: "checked"
+
+                    onSyncTriggered: checkBackend.timer.start()
+
+                    onSyncWaitingChanged: checkSyncSpy.clear()
+                }
+            }
+
+            Column {
+                Label { text: checkBackend.inSync ? "synced" : "out of sync" }
+                Label { text: checkSync.syncWaiting ? "syncWait" : "no syncWait" }
+                Label { text: "activates: " + checkSyncSpy.count }
+            }
+        }
+
+        Row {
+            id: sliderRoot
+            spacing: units.gu(3)
+
+            Slider {
+                id: slider
+                anchors.verticalCenter: parent.verticalCenter
+                live: true
+                minimumValue: 0.0
+                maximumValue: 100.0
+
+                property real serverValue: sliderBackend.value
+                USC.ServerPropertySynchroniser {
+                    id: sliderSync
+                    objectName: "sliderSync"
+
+                    syncTimeout: 3000
+
+                    userTarget: slider
+                    userProperty: "value"
+
+                    serverTarget: slider
+                    serverProperty: "serverValue"
+
+                    onSyncTriggered: {
+                        sliderBackend.changeToValue = value;
+                        sliderBackend.timer.start();
+                    }
+
+                    onSyncWaitingChanged: sliderSyncSpy.clear()
+                }
+            }
+
+            Column {
+                Label { text: sliderBackend.inSync ? "synced" : "out of sync" }
+                Label { text: sliderSync.syncWaiting ? "syncWait" : "no syncWait" }
+                Label { text: "activates: " + sliderSyncSpy.count }
+            }
+        }
+
+        Row {
+            spacing: units.gu(3)
+            height: childrenRect.height
+            anchors.left: parent.left
+            anchors.right: parent.right
+
+            USM.AccessPointMenu {
+                id: apMenu
+                width: units.gu(30)
+
+                text: "Test Check Menu"
+
+                USC.ServerPropertySynchroniser {
+                    id: apMenuSync
+                    objectName: "apMenuSync"
+
+                    syncTimeout: 3000
+
+                    userTarget: apMenu
+                    userProperty: "active"
+                    userTrigger: "onTriggered"
+
+                    serverTarget: apBackend
+                    serverProperty: "active"
+
+                    onSyncTriggered: apBackend.timer.start()
+
+                    onSyncWaitingChanged: switchSyncSpy.clear()
+                }
+            }
+
+            Column {
+                Label { text: apBackend.inSync ? "synced" : "out of sync" }
+                Label { text: apMenuSync.syncWaiting ? "syncWait" : "no syncWait" }
+                Label { text: "activates: " + apSyncSpy.count }
+            }
+        }
+    }
+
+    SignalSpy {
+        id: switchSyncSpy
+        target: switchControl
+        signalName: "triggered"
+    }
+    SignalSpy {
+        id: checkSyncSpy
+        target: checkControl
+        signalName: "triggered"
+    }
+    SignalSpy {
+        id: sliderSyncSpy
+        target: slider
+        signalName: "valueChanged"
+    }
+    SignalSpy {
+        id: apSyncSpy
+        target: apMenu
+        signalName: "triggered"
+    }
+    SignalSpy {
+        id: sliderSyncActivatedSpy
+        target: sliderSync
+        signalName: "syncTriggered"
+    }
+    SignalSpy {
+        id:apSyncActivatedSpy
+        target: apMenuSync
+        signalName: "syncTriggered"
+    }
+
+    QtObject {
+        id: switchBackend2
+
+        property bool checked2: false
+        property bool inSync: checked2 === switchControl.checked
+
+        property Timer switchTimer: Timer {
+            interval: 1000
+            onTriggered: switchBackend2.checked2 = !switchBackend2.checked2
+        }
+    }
+
+    UbuntuTestCase {
+        name: "ServerActivationSync"
+        when: windowShown
+
+        function init() {
+            waitForRendering(root);
+            switchBackend.timer.interval = 100;
+            checkBackend.timer.interval = 100;
+            sliderBackend.timer.interval = 100;
+            apBackend.timer.interval = 100;
+
+            switchSync.syncTimeout = 200;
+            checkSync.syncTimeout = 200;
+            sliderSync.syncTimeout = 200;
+            apMenuSync.syncTimeout = 200;
+
+            sliderSyncActivatedSpy.clear();
+            apSyncActivatedSpy.clear();
+        }
+
+        function cleanup() {
+            switchBackend.timer.stop();
+            checkBackend.timer.stop();
+            sliderBackend.timer.stop();
+
+            switchBackend.checked = false;
+            checkBackend.checked = false;
+            sliderBackend.value = 50;
+            apBackend.active = false;
+
+            switchSync.reset();
+            checkSync.reset();
+            sliderSync.reset();
+            apMenuSync.reset();
+            sliderSync.maximumWaitBufferInterval = -1
+
+            tryCompare(switchBackend, "inSync", true);
+            tryCompare(checkBackend, "inSync", true);
+            tryCompare(sliderBackend, "inSync", true);
+
+            switchSync.serverTarget = switchBackend;
+            switchSync.serverProperty = "checked";
+        }
+
+        function test_backend_change() {
+            switchBackend.checked = true;
+            compare(switchControl.checked, true, "Switch should have been toggled");
+            switchBackend.checked = false;
+            compare(switchControl.checked, false, "Switch should have been toggled");
+        }
+
+        function test_frontend_change() {
+            switchControl.clicked();
+            tryCompare(switchBackend, "checked", true);
+        }
+
+        function test_frontend_change_with_value() {
+            slider.value = 60;
+            tryCompare(sliderBackend, "value", 60);
+        }
+
+        function test_break_binding_change() {
+            switchControl.checked = true;
+            switchBackend.checked = true;
+            switchBackend.checked = false;
+            compare(switchControl.checked, false, "Switch should have been toggled");
+        }
+
+        function test_buffered_change_with_value() {
+            slider.value = 60;
+            compare(sliderSyncActivatedSpy.count, 1, "activated signal should have been sent")
+            slider.value = 70;
+            slider.value = 80;
+            slider.value = 90;
+            compare(sliderSyncActivatedSpy.count, 1, "activated signals should have been buffered")
+            tryCompare(sliderBackend, "value", 90);
+            tryCompare(sliderSyncActivatedSpy, "count", 2)
+        }
+
+        function test_buffered_change_with_maximum_interval() {
+            sliderSync.maximumWaitBufferInterval = 50;
+            sliderSync.syncTimeout = 5000;
+
+            slider.value = 60;
+            compare(sliderSyncActivatedSpy.count, 1, "activated signal should have been sent")
+            slider.value = 70;
+            slider.value = 80;
+            tryCompare(sliderSyncActivatedSpy, "count", 2, 500, "activated signal should have been sent after max interval")
+            slider.value = 90;
+            tryCompare(sliderSyncActivatedSpy, "count", 3, 500, "activated signal should have been sent after max interval")
+            slider.value = 100;
+            tryCompare(sliderSyncActivatedSpy, "count", 4, 500);
+            tryCompare(sliderBackend, "value", 100);
+        }
+
+        function test_connect_to_another_object() {
+            switchSync.serverTarget = switchBackend2;
+            switchSync.serverProperty = "checked2";
+
+            switchBackend2.checked2 = true;
+            compare(switchControl.checked, true, "Switch should have been toggled");
+            switchBackend2.checked2 = false;
+            compare(switchControl.checked, false, "Switch should have been toggled");
+        }
+
+        function test_client_revert() {
+            switchBackend.timer.interval = 500;
+            switchControl.clicked();
+            compare(switchControl.checked, true);
+            tryCompare(switchControl, "checked", false);
+        }
+
+        function test_user_trigger() {
+            apMenu.trigger();
+
+            compare(apSyncActivatedSpy.count, 1, "Triggering should have caused signal to be emitted");
+            tryCompare(apBackend, "active", true);
+            compare(apMenu.active, true, "User value should have updated to match server");
+        }
+
+        function test_user_trigger_doesnt_activate_on_user_property_change() {
+            apMenu.active = true;
+            compare(apSyncActivatedSpy.count, 0);
+        }
+    }
+}

=== modified file 'tests/utils/modules/Ubuntu/Test/UbuntuTestCase.qml'
--- tests/utils/modules/Ubuntu/Test/UbuntuTestCase.qml	2014-08-14 11:51:14 +0000
+++ tests/utils/modules/Ubuntu/Test/UbuntuTestCase.qml	2015-04-09 12:58:32 +0000
@@ -14,13 +14,23 @@
  * along with this program.  If not, see <http://www.gnu.org/licenses/>.
  */
 
+import QtQuick 2.0
 import QtTest 1.0
 import Ubuntu.Components 1.1
 import Ubuntu.Test 0.1 as UT
 
 TestCase {
+    id: testCase
     TestUtil {id:util}
 
+    ActivityIndicator {
+        visible: testCase.running
+        anchors.centerIn: parent
+        Component.onCompleted: parent = testCase.parent
+        z: 100
+        running: visible
+    }
+
     // Fake implementation to be provided to items under test
     property var fakeDateTime: new function() {
         this.currentTimeMs = 0
@@ -297,4 +307,13 @@
         event.release(0 /* touchId */, x, y)
         event.commit()
     }
+
+    // TODO This function can be removed altogether once we use Qt 5.5 which has the same feature
+    function waitForRendering(item, timeout) {
+        if (timeout === undefined)
+            timeout = 5000;
+        if (!item)
+            qtest_fail("No item given to waitForRendering", 1);
+        return qtest_results.waitForRendering(item, timeout);
+    }
 }