Merge lp:~azzar1/unity/gsettings-property into lp:unity

[Andrea Azzarone]

[lp:~azzar1/unity/gsettings-property]

3915. By Andrea Azzarone on 2015-02-05

Actually connect to changed::* signal in MenuManager.cpp. Fixes: #1411620
Approved by: PS Jenkins bot, Marco Trevisan (Treviño)

3916. By Andrea Azzarone on 2015-02-05

Actually connect to changed::* signal in UnitySettings.cpp. Fixes: #1408212
Approved by: PS Jenkins bot, Marco Trevisan (Treviño)

3917. By Brandon Schaefer on 2015-02-05

Try to set the folder permission otherwise Handle permission error. Fixes: #1418255
Approved by: PS Jenkins bot, Andrea Azzarone, Marco Trevisan (Treviño)

3918. By CI Train Bot Account on 2015-02-05

Releasing 7.3.1+15.04.20150205-0ubuntu1

3919. By Stephen M. Webb on 2015-02-11

Release 7.3.1

3920. By Marco Trevisan (Treviño) on 2015-02-19

Decorations, Panel: add menus for unfocused windows as well

Now the indicator-appmenu exports the menus for all the windows,
then it's up to us to filter them based on their parent window and
show on relevant place.
Also, set LIM as default now. Fixes: #1309778
Approved by: Andrea Azzarone, PS Jenkins bot

3921. By CI Train Bot Account on 2015-02-19

Releasing 7.3.1+15.04.20150219.2-0ubuntu1

3922. By Andrea Azzarone on 2015-02-20

Merge with trunk and change API.

3923. By Andrea Azzarone on 2015-02-20

Use GSettingsProperty in GnomeSessionManager.cpp

3924. By Andrea Azzarone on 2015-02-20

Lazy initialize GSettingsProperty.

3925. By Andrea Azzarone on 2015-02-20

Use GsettingsProperty in DevicesSettingsImp.cpp

3926. By Andrea Azzarone on 2015-02-20

Move template specialiazation in a cpp file.

3927. By Andrea Azzarone on 2015-02-20

Use GSettingsProperty in LockScreenAcceleratorController.cpp

3928. By Andrea Azzarone on 2015-02-27

Commit to save changes.

Unmerged revisions

3928. By Andrea Azzarone on 2015-02-27

Commit to save changes.

3927. By Andrea Azzarone on 2015-02-20

Use GSettingsProperty in LockScreenAcceleratorController.cpp

3926. By Andrea Azzarone on 2015-02-20

Move template specialiazation in a cpp file.

3925. By Andrea Azzarone on 2015-02-20

Use GsettingsProperty in DevicesSettingsImp.cpp

3924. By Andrea Azzarone on 2015-02-20

Lazy initialize GSettingsProperty.

3923. By Andrea Azzarone on 2015-02-20

Use GSettingsProperty in GnomeSessionManager.cpp

3922. By Andrea Azzarone on 2015-02-20

Merge with trunk and change API.

=== modified file 'UnityCore/CMakeLists.txt'
--- UnityCore/CMakeLists.txt	2014-12-19 16:37:49 +0000
+++ UnityCore/CMakeLists.txt	2015-02-27 17:17:17 +0000
@@ -33,6 +33,8 @@
      GLibWrapper.h
      GLibWrapper-inl.h
      GnomeSessionManager.h
+     GSettingsProperty.h
+     GSettingsProperty-inl.h
      GSettingsScopes.h
      Hud.h
      IndicatorEntry.h
@@ -86,6 +88,7 @@
      GLibSource.cpp
      GLibWrapper.cpp
      GnomeSessionManager.cpp
+     GSettingsProperty.cpp
      GSettingsScopes.cpp
      Hud.cpp
      Indicator.cpp
 
=== added file 'UnityCore/GSettingsProperty-inl.h'
--- UnityCore/GSettingsProperty-inl.h	1970-01-01 00:00:00 +0000
+++ UnityCore/GSettingsProperty-inl.h	2015-02-27 17:17:17 +0000
@@ -0,0 +1,129 @@
+// -*- Mode: C++; indent-tabs-mode: nil; tab-width: 2 -*-
+/*
+ * Copyright (C) 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 version 3 as
+ * published by the Free Software Foundation.
+ *
+ * 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 detais.
+ *
+ * You shoud have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ *
+ * Authored by: Andrea Azzarone <[e-mail]>
+ */
+
+#ifndef UNITY_GSETTINGS_PROPERTY_INL_H
+#define UNITY_GSETTINGS_PROPERTY_INL_H
+
+#include <type_traits>
+
+namespace unity
+{
+
+template<typename VALUE_TYPE>
+GSettingsProperty<VALUE_TYPE>::GSettingsProperty(glib::Object<GSettings> const& gsettings,
+                                                 std::string const& key,
+                                                 CallbackType const& cb)
+  : gsettings_(gsettings)
+  , key_(key)
+  , cb_(cb)
+  , loaded_(false)
+{
+  if (cb_)
+    key_changed_.Connect(gsettings_, "changed::"+key, [this] (GSettings*, gchar*) { OnChangedCb(); });
+}
+
+template<typename VALUE_TYPE>
+GSettingsProperty<VALUE_TYPE>::GSettingsProperty(std::string const& schema_id,
+                                                 std::string const& key,
+                                                 CallbackType const& cb)
+  : GSettingsProperty(glib::Object<GSettings>(g_settings_new(schema_id.c_str())), key, cb)
+{}
+
+template <typename VALUE_TYPE>
+VALUE_TYPE GSettingsProperty<VALUE_TYPE>::operator=(VALUE_TYPE const& value)
+{
+  return Set(value);
+}
+
+template <typename VALUE_TYPE>
+GSettingsProperty<VALUE_TYPE>::operator VALUE_TYPE() const
+{
+  return Get();
+}
+
+template <typename VALUE_TYPE>
+VALUE_TYPE GSettingsProperty<VALUE_TYPE>::operator()() const
+{
+  return Get();
+}
+
+template <typename VALUE_TYPE>
+VALUE_TYPE GSettingsProperty<VALUE_TYPE>::operator()(VALUE_TYPE const& value)
+{
+  return Set(value);
+}
+
+template <typename VALUE_TYPE>
+VALUE_TYPE GSettingsProperty<VALUE_TYPE>::Get() const
+{
+  if (cb_ && loaded_)
+  {
+    return value_;
+  }
+  else
+  {
+    loaded_ = true;
+    return getter_function<VALUE_TYPE>();
+  }
+}
+
+template <typename VALUE_TYPE>
+VALUE_TYPE GSettingsProperty<VALUE_TYPE>::Set(VALUE_TYPE const& value)
+{
+  if (cb_ && loaded_ && value != value_)
+  {
+    if (setter_function<VALUE_TYPE>(value))
+      value_ = value;
+    return value_;
+  }
+  else
+  {
+    setter_function<VALUE_TYPE>(value);
+    return value;
+  }
+}
+
+template<typename VALUE_TYPE>
+void GSettingsProperty<VALUE_TYPE>::OnChangedCb()
+{
+  auto value = getter_function<VALUE_TYPE>();
+
+  if (value_ != value)
+    cb_(value_ = value);
+}
+
+// enum
+template<typename VALUE_TYPE> template<typename X>
+typename std::enable_if<std::is_enum<X>::value, bool>::type
+GSettingsProperty<VALUE_TYPE>::setter_function(X const& value)
+{
+  return g_settings_set_enum(gsettings_, key_.c_str(), static_cast<int>(value)) != FALSE;
+}
+
+template<typename VALUE_TYPE> template<typename X>
+typename std::enable_if<std::is_enum<X>::value, X>::type
+GSettingsProperty<VALUE_TYPE>::getter_function() const
+{
+  return static_cast<X>(g_settings_get_enum(gsettings_, key_.c_str()));
+}
+
+
+}
+
+#endif
 \ No newline at end of file
 
=== added file 'UnityCore/GSettingsProperty.cpp'
--- UnityCore/GSettingsProperty.cpp	1970-01-01 00:00:00 +0000
+++ UnityCore/GSettingsProperty.cpp	2015-02-27 17:17:17 +0000
@@ -0,0 +1,118 @@
+// -*- Mode: C++; indent-tabs-mode: nil; tab-width: 2 -*-
+/*
+* Copyright (C) 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 version 3 as
+* published by the Free Software Foundation.
+*
+* 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/>.
+*
+* Authored by: Andrea Azzarone <[e-mail]>
+*/
+
+#include "GSettingsProperty.h"
+#include <vector>
+
+namespace unity
+{
+
+// bool
+template<>template<>
+bool GSettingsProperty<bool>::setter_function<bool>(bool const& value)
+{
+  return g_settings_set_boolean(gsettings_, key_.c_str(), value != 0 ? TRUE : FALSE) != FALSE;
+}
+
+template<>template<>
+bool GSettingsProperty<bool>::getter_function<bool>() const
+{
+  return g_settings_get_boolean(gsettings_, key_.c_str()) != FALSE;
+}
+
+// int
+template<>template<>
+bool GSettingsProperty<int32_t>::setter_function<int32_t>(int32_t const& value)
+{
+  return g_settings_set_int(gsettings_, key_.c_str(), value) != FALSE;
+}
+
+template<>template<>
+int32_t GSettingsProperty<int32_t>::getter_function<int32_t>() const
+{
+  return g_settings_get_int(gsettings_, key_.c_str());
+}
+
+// uint
+template<>template<>
+bool GSettingsProperty<uint32_t>::setter_function<uint32_t>(uint32_t const& value)
+{
+  return g_settings_set_uint(gsettings_, key_.c_str(), value) != FALSE;
+}
+
+template<>template<>
+uint32_t GSettingsProperty<uint32_t>::getter_function<uint32_t>() const
+{
+  return g_settings_get_uint(gsettings_, key_.c_str());
+}
+
+// double
+template<>template<>
+bool GSettingsProperty<double>::setter_function<double>(double const& value)
+{
+  return g_settings_set_double(gsettings_, key_.c_str(), value) != FALSE;
+}
+
+template<>template<>
+double GSettingsProperty<double>::getter_function<double>() const
+{
+  return g_settings_get_double(gsettings_, key_.c_str());
+}
+
+// std::string
+template<>template<>
+bool GSettingsProperty<std::string>::setter_function<std::string>(std::string const& value)
+{
+  return g_settings_set_string(gsettings_, key_.c_str(), value.c_str()) != FALSE;
+}
+
+template<>template<>
+std::string GSettingsProperty<std::string>::getter_function<std::string>() const
+{
+  glib::String ret(g_settings_get_string(gsettings_, key_.c_str()));
+  return ret.Str();
+}
+
+// std::vector<std::string>
+template<>template<>
+bool GSettingsProperty<std::vector<std::string>>::setter_function(std::vector<std::string> const& value)
+{
+  std::vector<char const*> c_style_value;
+  c_style_value.reserve(value.size()+1);
+
+  for (auto const & str : value)
+    c_style_value.push_back(str.c_str());
+  c_style_value.push_back(nullptr);
+
+  return g_settings_set_strv(gsettings_, key_.c_str(), c_style_value.data()) != FALSE;
+}
+
+template<>template<>
+std::vector<std::string> GSettingsProperty<std::vector<std::string>>::getter_function<std::vector<std::string>>() const
+{
+  std::shared_ptr<gchar*> c_style_ret(g_settings_get_strv(gsettings_, key_.c_str()), g_strfreev);
+  std::vector<std::string> ret;
+
+  for (int i = 0; c_style_ret.get()[i]; ++i)
+    ret.push_back(c_style_ret.get()[i]);
+
+  return ret;
+}
+
+}
 
=== added file 'UnityCore/GSettingsProperty.h'
--- UnityCore/GSettingsProperty.h	1970-01-01 00:00:00 +0000
+++ UnityCore/GSettingsProperty.h	2015-02-27 17:17:17 +0000
@@ -0,0 +1,85 @@
+// -*- Mode: C++; indent-tabs-mode: nil; tab-width: 2 -*-
+/*
+ * Copyright (C) 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 version 3 as
+ * published by the Free Software Foundation.
+ *
+ * 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 detais.
+ *
+ * You shoud have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ *
+ * Authored by: Andrea Azzarone <[e-mail]>
+ */
+
+#ifndef UNITY_GSETTING_PROPERTY
+#define UNITY_GSETTING_PROPERTY
+
+#include <boost/noncopyable.hpp>
+#include <string>
+
+#include <UnityCore/GLibWrapper.h>
+#include <UnityCore/GLibSignal.h>
+
+namespace unity
+{
+
+template <typename VALUE_TYPE>
+class GSettingsProperty : private boost::noncopyable
+{
+public:
+  typedef std::function<void(VALUE_TYPE const&)> CallbackType;
+
+  GSettingsProperty(std::string const& schema_id, std::string const& key, CallbackType const& cb = nullptr);
+  GSettingsProperty(glib::Object<GSettings> const& gsettings, std::string const& key, CallbackType const& cb = nullptr);
+
+  VALUE_TYPE operator=(VALUE_TYPE const& value);
+  operator VALUE_TYPE() const;
+
+  // function call access
+  VALUE_TYPE operator()() const;
+  VALUE_TYPE operator()(VALUE_TYPE const& value);
+
+  // get and set access
+  VALUE_TYPE Get() const;
+  VALUE_TYPE Set(VALUE_TYPE const& value);
+
+private:
+  void  OnChangedCb();
+
+  template<typename X>
+  typename std::enable_if<!std::is_enum<X>::value, bool>::type
+  setter_function(X const& value);
+
+  template<typename X>
+  typename std::enable_if<std::is_enum<X>::value, bool>::type
+  setter_function(X const& value);
+
+  template<typename X>
+  typename std::enable_if<!std::is_enum<X>::value, X>::type
+  getter_function() const;
+
+  template<typename X>
+  typename std::enable_if<std::is_enum<X>::value, X>::type
+  getter_function() const;
+
+private:
+  glib::Object<GSettings> gsettings_;
+  std::string key_;
+  CallbackType cb_;
+  mutable bool loaded_;
+
+  glib::Signal<void, GSettings*, gchar*> key_changed_;
+  VALUE_TYPE value_;
+};
+
+}
+
+#include "GSettingsProperty-inl.h"
+
+#endif
 
=== modified file 'UnityCore/GSettingsScopes.cpp'
--- UnityCore/GSettingsScopes.cpp	2013-11-14 03:00:29 +0000
+++ UnityCore/GSettingsScopes.cpp	2015-02-27 17:17:17 +0000
@@ -78,7 +78,7 @@
     {
       LoadScopes();
       owner_->scopes_changed.emit(scopes_order_);
-    }    
+    }
   };
 
   scopes_changed.Connect(settings_, "changed::"+SCOPE_SETTINGS_KEY, change_func);
 
=== modified file 'UnityCore/GnomeSessionManager.cpp'
--- UnityCore/GnomeSessionManager.cpp	2015-01-24 00:56:37 +0000
+++ UnityCore/GnomeSessionManager.cpp	2015-02-27 17:17:17 +0000
@@ -20,6 +20,7 @@
 #include "GnomeSessionManagerImpl.h"
 
 #include <NuxCore/Logger.h>
+#include "GSettingsProperty.h"
 #include "Variant.h"
 
 #include <grp.h>
@@ -218,8 +219,7 @@
   if (!schema_found)
     return true;
 
-  glib::Object<GSettings> setting(g_settings_new(SESSION_OPTIONS.c_str()));
-  return g_settings_get_boolean(setting, SUPPRESS_DIALOGS_KEY.c_str()) != TRUE;
+  return !GSettingsProperty<bool>(SESSION_OPTIONS, SUPPRESS_DIALOGS_KEY)();
 }
 
 GVariant* GnomeManager::Impl::OnShellMethodCall(std::string const& method, GVariant* parameters)
@@ -665,9 +665,7 @@
   if (is_locked())
     return true;
 
-  glib::Object<GSettings> lockdown_settings(g_settings_new(GNOME_LOCKDOWN_OPTIONS.c_str()));
-
-  if (g_settings_get_boolean(lockdown_settings, DISABLE_LOCKSCREEN_KEY.c_str()) ||
+  if (GSettingsProperty<bool>(GNOME_LOCKDOWN_OPTIONS, DISABLE_LOCKSCREEN_KEY)() ||
       UserName().find("guest-") == 0 ||
       impl_->IsUserInGroup(UserName(), "nopasswdlogin"))
   {
 
=== modified file 'UnityCore/Variant.cpp'
--- UnityCore/Variant.cpp	2013-11-19 20:28:13 +0000
+++ UnityCore/Variant.cpp	2015-02-27 17:17:17 +0000
@@ -58,6 +58,18 @@
   : Variant(g_variant_new_string(value.c_str()))
 {}
 
+Variant::Variant(std::vector<std::string> const& strings)
+{
+  GVariantBuilder b;
+  g_variant_builder_init(&b, G_VARIANT_TYPE("as"));
+
+  for (auto const& str : strings)
+    g_variant_builder_add(&b, "s", str.c_str());
+
+  variant_ = g_variant_builder_end(&b);
+  g_variant_ref_sink(variant_);
+}
+
 Variant::Variant(unsigned char value)
   : Variant(g_variant_new_byte(value))
 {}
@@ -174,6 +186,33 @@
   return result ? result : "";
 }
 
+bool Variant::ASToVectorOfStrings(std::vector<std::string>& vector) const
+{
+  GVariantIter* iter;
+  gchar* value = nullptr;
+
+  if (!variant_)
+    return false;
+
+  if (!g_variant_is_of_type (variant_, G_VARIANT_TYPE ("(av)")) &&
+      !g_variant_is_of_type (variant_, G_VARIANT_TYPE ("as")))
+  {
+    return false;
+  }
+
+  g_variant_get(variant_, g_variant_get_type_string(variant_), &iter);
+
+  vector.clear();
+  while (g_variant_iter_loop(iter, "s",  &value))
+  {
+    vector.push_back(value);
+  }
+
+  g_variant_iter_free(iter);
+
+  return true;
+}
+
 template <typename TYPE, typename GTYPE>
 TYPE get_numeric_value(GVariant *variant_, const char *type_str, const char *fallback_type_str)
 {
 
=== modified file 'UnityCore/Variant.h'
--- UnityCore/Variant.h	2013-11-19 20:28:13 +0000
+++ UnityCore/Variant.h	2015-02-27 17:17:17 +0000
@@ -48,6 +48,7 @@
   Variant(HintsMap const& hints);
   explicit Variant(std::nullptr_t);
   explicit Variant(std::string const&);
+  explicit Variant(std::vector<std::string> const&);
   explicit Variant(const char*);
   explicit Variant(unsigned char);
   explicit Variant(int16_t);
@@ -80,6 +81,7 @@
   float GetFloat() const;
   Variant GetVariant() const;
 
+  bool ASToVectorOfStrings(std::vector<std::string>&) const;
   bool ASVToHints(HintsMap& hints) const;
 
   template <typename T>
 
=== modified file 'launcher/DevicesSettingsImp.cpp'
--- launcher/DevicesSettingsImp.cpp	2012-10-29 09:34:54 +0000
+++ launcher/DevicesSettingsImp.cpp	2015-02-27 17:17:17 +0000
@@ -17,25 +17,19 @@
  * Authored by: Andrea Azzarone <[e-mail]>
  */
 
-#include <list>
-
-#include <gio/gio.h>
-#include <NuxCore/Logger.h>
-
 #include "DevicesSettingsImp.h"
-#include <UnityCore/GLibSignal.h>
-#include <UnityCore/GLibWrapper.h>
+
+#include <vector>
+#include <UnityCore/GSettingsProperty.h>
 
 namespace unity
 {
 namespace launcher
 {
-DECLARE_LOGGER(logger, "unity.device.settings");
 namespace
 {
 const std::string SETTINGS_NAME = "com.canonical.Unity.Devices";
 const std::string KEY_NAME = "blacklist";
-
 }
 
 //
@@ -46,51 +40,13 @@
 public:
   Impl(DevicesSettingsImp* parent)
     : parent_(parent)
-    , settings_(g_settings_new(SETTINGS_NAME.c_str()))
-  {
-    DownloadBlacklist();
-    ConnectSignals();
-  }
-
-  void ConnectSignals()
-  {
-    settings_changed_signal_.Connect(settings_, "changed::" + KEY_NAME, [this] (GSettings*, gchar*) {
-      DownloadBlacklist();
-      parent_->changed.emit();
-    });
-  }
-
-  void DownloadBlacklist()
-  {
-    std::shared_ptr<gchar*> downloaded_blacklist(g_settings_get_strv(settings_, KEY_NAME.c_str()), g_strfreev);
-
-    blacklist_.clear();
-
-    auto downloaded_blacklist_raw = downloaded_blacklist.get();
-    for (int i = 0; downloaded_blacklist_raw[i]; ++i)
-      blacklist_.push_back(downloaded_blacklist_raw[i]);
-  }
-
-  void UploadBlacklist()
-  {
-    const int size = blacklist_.size();
-    const char* blacklist_to_be_uploaded[size+1];
-
-    int index = 0;
-    for (auto item : blacklist_)
-      blacklist_to_be_uploaded[index++] = item.c_str();
-    blacklist_to_be_uploaded[index] = nullptr;
-
-    if (!g_settings_set_strv(settings_, KEY_NAME.c_str(), blacklist_to_be_uploaded))
-    {
-      LOG_WARNING(logger) << "Saving blacklist failed.";
-    }
-  }
+    , blacklist_(SETTINGS_NAME, KEY_NAME, sigc::hide(sigc::mem_fun(&parent_->changed, &sigc::signal<void>::emit)))
+  {}
 
   bool IsABlacklistedDevice(std::string const& uuid) const
   {
-    auto begin = std::begin(blacklist_);
-    auto end = std::end(blacklist_);
+    auto begin = std::begin(blacklist_());
+    auto end = std::end(blacklist_());
     return std::find(begin, end, uuid) != end;
   }
 
@@ -99,8 +55,9 @@
     if (uuid.empty() || IsABlacklistedDevice(uuid))
       return;
 
-    blacklist_.push_back(uuid);
-    UploadBlacklist();
+    auto temp = blacklist_();
+    temp.push_back(uuid);
+    blacklist_ = temp;
   }
 
   void TryToUnblacklist(std::string const& uuid)
@@ -108,15 +65,13 @@
     if (uuid.empty() || !IsABlacklistedDevice(uuid))
       return;
 
-    blacklist_.remove(uuid);
-    UploadBlacklist();
+    auto temp = blacklist_();
+    temp.erase(std::remove(std::begin(temp), std::end(temp), uuid), std::end(temp));
+    blacklist_ = temp;
   }
 
   DevicesSettingsImp* parent_;
-  glib::Object<GSettings> settings_;
-  std::list<std::string> blacklist_;
-  glib::Signal<void, GSettings*, gchar*> settings_changed_signal_;
-
+  GSettingsProperty<std::vector<std::string>> blacklist_;
 };
 
 //
 
=== modified file 'lockscreen/LockScreenAcceleratorController.cpp'
--- lockscreen/LockScreenAcceleratorController.cpp	2014-05-16 04:51:34 +0000
+++ lockscreen/LockScreenAcceleratorController.cpp	2015-02-27 17:17:17 +0000
@@ -20,6 +20,7 @@
 #include "LockScreenAcceleratorController.h"
 
 #include <UnityCore/GLibDBusProxy.h>
+#include <UnityCore/GSettingsProperty.h>
 
 namespace unity
 {
@@ -103,8 +104,7 @@
 
 void PowerAction(session::Manager::Ptr const& session, const char *action_key)
 {
-  glib::Object<GSettings> settings(g_settings_new(POWER_SCHEMA));
-  auto const& action = glib::String(g_settings_get_string(settings, action_key)).Str();
+  auto const& action = GSettingsProperty<std::string>(POWER_SCHEMA, action_key)();
 
   if (action == "interactive")
     session->shutdown_requested.emit(session->HasInhibitors());
@@ -124,15 +124,15 @@
 {
   auto settings = glib::Object<GSettings>(g_settings_new(MEDIA_KEYS_SCHEMA));
 
-  auto accelerator = std::make_shared<Accelerator>(glib::String(g_settings_get_string(settings, MEDIA_KEYS_KEY_VOLUME_MUTE)));
+  auto accelerator = std::make_shared<Accelerator>(GSettingsProperty<std::string>(settings, MEDIA_KEYS_KEY_VOLUME_MUTE));
   accelerator->activated.connect(std::function<void()>(MuteIndicatorSound));
   accelerators_->Add(accelerator);
 
-  accelerator = std::make_shared<Accelerator>(glib::String(g_settings_get_string(settings, MEDIA_KEYS_KEY_VOLUME_DOWN)));
+  accelerator = std::make_shared<Accelerator>(GSettingsProperty<std::string>(settings, MEDIA_KEYS_KEY_VOLUME_DOWN));
   accelerator->activated.connect(std::bind(ScrollIndicatorSound, -1));
   accelerators_->Add(accelerator);
 
-  accelerator = std::make_shared<Accelerator>(glib::String(g_settings_get_string(settings, MEDIA_KEYS_KEY_VOLUME_UP)));
+  accelerator = std::make_shared<Accelerator>(GSettingsProperty<std::string>(settings, MEDIA_KEYS_KEY_VOLUME_UP));
   accelerator->activated.connect(std::bind(ScrollIndicatorSound, +1));
   accelerators_->Add(accelerator);
 
@@ -154,31 +154,17 @@
 
   settings = glib::Object<GSettings>(g_settings_new(INPUT_SWITCH_SCHEMA));
 
-  auto variant = glib::Variant(g_settings_get_value(settings, INPUT_SWITCH_KEY_PREVIOUS_SOURCE), glib::StealRef());
-
-  if (g_variant_n_children(variant) > 0)
-  {
-    const gchar* string;
-
-    g_variant_get_child(variant, 0, "&s", &string);
-
+  auto strings = GSettingsProperty<std::vector<std::string>>(settings, INPUT_SWITCH_KEY_PREVIOUS_SOURCE)();
+  std::for_each(std::begin(strings), std::end(strings), [&](std::string const& string) {
     accelerator = std::make_shared<Accelerator>(string);
     accelerator->activated.connect(std::bind(ScrollIndicatorKeyboard, -1));
-    accelerators_->Add(accelerator);
-  }
-
-  variant = glib::Variant(g_settings_get_value(settings, INPUT_SWITCH_KEY_NEXT_SOURCE), glib::StealRef());
-
-  if (g_variant_n_children(variant) > 0)
-  {
-    const gchar* string;
-
-    g_variant_get_child(variant, 0, "&s", &string);
-
+  });
+
+  strings = GSettingsProperty<std::vector<std::string>>(settings, INPUT_SWITCH_KEY_NEXT_SOURCE)();
+  std::for_each(std::begin(strings), std::end(strings), [&](std::string const& string) {
     accelerator = std::make_shared<Accelerator>(string);
     accelerator->activated.connect(std::bind(ScrollIndicatorKeyboard, +1));
-    accelerators_->Add(accelerator);
-  }
+  });
 }
 
 Accelerators::Ptr const& AcceleratorController::GetAccelerators() const
 
=== modified file 'plugins/unityshell/src/WindowMinimizeSpeedController.cpp'
--- plugins/unityshell/src/WindowMinimizeSpeedController.cpp	2013-11-14 03:00:29 +0000
+++ plugins/unityshell/src/WindowMinimizeSpeedController.cpp	2015-02-27 17:17:17 +0000
@@ -35,39 +35,18 @@
 
 WindowMinimizeSpeedController::WindowMinimizeSpeedController()
   : _settings(g_settings_new(local::UNITY_SCHEMA.c_str()))
-  , _minimize_count(g_settings_get_int(_settings, "minimize-count"))
-  , _minimize_speed_threshold(g_settings_get_int(_settings, "minimize-speed-threshold"))
-  , _minimize_slow_duration(g_settings_get_int(_settings, "minimize-slow-duration"))
-  , _minimize_fast_duration(g_settings_get_int(_settings, "minimize-fast-duration"))
+  , _minimize_count(_settings, "minimize-count", sigc::hide(sigc::mem_fun(this, &WindowMinimizeSpeedController::SetDuration)))
+  , _minimize_speed_threshold(_settings, "minimize-speed-threshold", sigc::hide(sigc::mem_fun(this, &WindowMinimizeSpeedController::SetDuration)))
+  , _minimize_slow_duration(_settings, "minimize-slow-duration", sigc::hide(sigc::mem_fun(this, &WindowMinimizeSpeedController::SetDuration)))
+  , _minimize_fast_duration(_settings, "minimize-fast-duration", sigc::hide(sigc::mem_fun(this, &WindowMinimizeSpeedController::SetDuration)))
   , _duration(200) // going to be overridden anyway, but at least it is initialised
-{
-  _minimize_count_changed.Connect(_settings, "changed::minimize-count",
-                                  [this] (GSettings*, gchar* name) {
-    _minimize_count = g_settings_get_int(_settings, name);
-    SetDuration();
-  });
-  _minimize_speed_threshold_changed.Connect(_settings, "changed::minimize-speed-threshold",
-                                            [this] (GSettings*, gchar* name) {
-    _minimize_speed_threshold = g_settings_get_int(_settings, name);
-    SetDuration();
-  });
-  _minimize_fast_duration_changed.Connect(_settings, "changed::minimize-fast-duration",
-                                      [this] (GSettings*, gchar* name) {
-    _minimize_fast_duration = g_settings_get_int(_settings, name);
-    SetDuration();
-  });
-  _minimize_slow_duration_changed.Connect(_settings, "changed::minimize-slow-duration",
-                                      [this] (GSettings*, gchar* name) {
-    _minimize_slow_duration = g_settings_get_int(_settings, name);
-    SetDuration();
-  });
-}
+{}
 
 void WindowMinimizeSpeedController::UpdateCount()
 {
-  if (_minimize_count < _minimize_speed_threshold) {
-    _minimize_count += 1;
-    g_settings_set_int(_settings, "minimize-count", _minimize_count);
+  if (_minimize_count() < _minimize_speed_threshold()) {
+    auto temp = _minimize_count();
+    _minimize_count = ++temp;
   }
 }
 
@@ -79,26 +58,24 @@
 void WindowMinimizeSpeedController::SetDuration()
 {
   /* Perform some sanity checks on the configuration values */
-  if (_minimize_fast_duration > _minimize_slow_duration)
+  if (_minimize_fast_duration() > _minimize_slow_duration())
   {
     LOG_WARN(logger) << "Configuration mismatch: minimize-fast-duration ("
-                      << _minimize_fast_duration
+                      << _minimize_fast_duration()
                       << ") is longer than minimize-slow-duration ("
-                      << _minimize_slow_duration << "). Not changing speed.";
+                      << _minimize_slow_duration() << "). Not changing speed.";
     return;
   }
 
-  if (_minimize_count < 0)
-    _minimize_count = 0;
-  if (_minimize_count > _minimize_speed_threshold)
-    _minimize_count = _minimize_speed_threshold;
+  auto minimize_count = _minimize_count();
+  minimize_count = std::max(0, std::min(minimize_count, _minimize_speed_threshold()));
 
   /* Adjust the speed so that it gets linearly closer to maximum speed as we
      approach the threshold */
-  int speed_range = _minimize_slow_duration - _minimize_fast_duration;
-  float position = (_minimize_speed_threshold <= 0) ? 1.0 :
-                   static_cast<float>(_minimize_count) / _minimize_speed_threshold;
-  int duration = _minimize_slow_duration - std::ceil(position * speed_range);
+  int speed_range = _minimize_slow_duration() - _minimize_fast_duration();
+  float position = (_minimize_speed_threshold() <= 0) ? 1.0 :
+                   static_cast<float>(_minimize_count) / _minimize_speed_threshold();
+  int duration = _minimize_slow_duration() - std::ceil(position * speed_range);
 
   if (duration != _duration) {
     _duration = duration;
 
=== modified file 'plugins/unityshell/src/WindowMinimizeSpeedController.h'
--- plugins/unityshell/src/WindowMinimizeSpeedController.h	2012-09-12 04:08:06 +0000
+++ plugins/unityshell/src/WindowMinimizeSpeedController.h	2015-02-27 17:17:17 +0000
@@ -22,13 +22,9 @@
 #ifndef WINDOWMINIMIZESPEEDCONTROLLER_H
 #define WINDOWMINIMIZESPEEDCONTROLLER_H
 
-#include <core/core.h>
-#include <UnityCore/GLibWrapper.h>
-#include <UnityCore/GLibSignal.h>
+#include <UnityCore/GSettingsProperty.h>
 #include <sigc++/sigc++.h>
 
-typedef struct _GSettings GSettings;
-
 using namespace unity;
 
 class WindowMinimizeSpeedController
@@ -43,14 +39,10 @@
   void SetDuration();
 
   glib::Object<GSettings> _settings;
-  int _minimize_count;
-  int _minimize_speed_threshold;
-  int _minimize_slow_duration;
-  int _minimize_fast_duration;
-  glib::Signal<void, GSettings*, gchar* > _minimize_count_changed;
-  glib::Signal<void, GSettings*, gchar* > _minimize_speed_threshold_changed;
-  glib::Signal<void, GSettings*, gchar* > _minimize_slow_duration_changed;
-  glib::Signal<void, GSettings*, gchar* > _minimize_fast_duration_changed;
+  GSettingsProperty<int> _minimize_count;
+  GSettingsProperty<int> _minimize_speed_threshold;
+  GSettingsProperty<int> _minimize_slow_duration;
+  GSettingsProperty<int> _minimize_fast_duration;
   int _duration;
 };
 
 
=== modified file 'tests/CMakeLists.txt'
--- tests/CMakeLists.txt	2014-11-04 19:00:40 +0000
+++ tests/CMakeLists.txt	2015-02-27 17:17:17 +0000
@@ -119,6 +119,7 @@
        test_glib_source.cpp
        test_glib_variant.cpp
        test_grabhandle.cpp
+       test_gsettings_property.cpp
        test_gsettings_scopes.cpp
        test_desktop_utilities.cpp
        test_desktop_application_subject.cpp
 
=== modified file 'tests/data/external.gschema.xml'
--- tests/data/external.gschema.xml	2014-04-18 11:45:59 +0000
+++ tests/data/external.gschema.xml	2015-02-27 17:17:17 +0000
@@ -142,4 +142,34 @@
       <default>["&lt;Super&gt;space"]</default>
     </key>
   </schema>
+
+  <enum id='com.canonical.unity.test.enum'>
+    <value nick='e1' value='0'/>
+    <value nick='e2' value='1'/>
+    <value nick='e3' value='2'/>
+  </enum>
+
+  <schema path = "/com/canonical/unity/test/" id="com.canonical.unity.test">
+    <key type="b" name="bool">
+      <default>true</default>
+    </key>
+    <key type="i" name="int">
+      <default>-123</default>
+    </key>
+    <key type="u" name="uint">
+      <default>123</default>
+    </key>
+    <key type="d" name="double">
+      <default>123.456</default>
+    </key>
+    <key type="s" name="string">
+      <default>'abcdef'</default>
+    </key>
+    <key name='enum' enum='com.canonical.unity.test.enum'>
+      <default>'e1'</default>
+    </key>
+    <key type="as" name='vector-string'>
+      <default>['a', 'b', 'c']</default>
+    </key>
+  </schema>
 </schemalist>
 
=== added file 'tests/test_gsettings_property.cpp'
--- tests/test_gsettings_property.cpp	1970-01-01 00:00:00 +0000
+++ tests/test_gsettings_property.cpp	2015-02-27 17:17:17 +0000
@@ -0,0 +1,423 @@
+// -*- Mode: C++; indent-tabs-mode: nil; tab-width: 2 -*-
+/*
+ * Copyright (C) 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 version 3 as
+ * published by the Free Software Foundation.
+ *
+ * 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/>.
+ *
+ * Authored by: Andrea Azzarone <[e-mail]>
+ */
+
+#include <gtest/gtest.h>
+using namespace testing;
+
+#include <UnityCore/GSettingsProperty.h>
+#include <UnityCore/Variant.h>
+
+namespace
+{
+
+const gchar* SETTINGS_NAME = "com.canonical.unity.test";
+
+/* Define setter and getter external functions. For the getter functions we need to be more specific
+ * because unity::glib::Variant is not templated.
+ */ 
+template<typename T>
+typename std::enable_if<!std::is_enum<T>::value, void>::type
+setter_function(unity::glib::Object<GSettings> gsettings, std::string const& key, T const& value)
+{
+  g_settings_set_value(gsettings, key.c_str(), unity::glib::Variant(value));
+}
+
+template<typename T>
+typename std::enable_if<std::is_enum<T>::value, void>::type
+setter_function(unity::glib::Object<GSettings> gsettings, std::string const& key, T const& value)
+{
+  g_settings_set_enum(gsettings, key.c_str(), static_cast<int>(value));
+}
+
+template<typename T>
+typename std::enable_if<std::is_same<T, bool>::value, T>::type
+getter_function(unity::glib::Object<GSettings> gsettings, std::string const& key)
+{
+  return g_settings_get_boolean(gsettings, key.c_str());
+}
+
+template<typename T>
+typename std::enable_if<std::is_same<T, int>::value, T>::type
+  getter_function(unity::glib::Object<GSettings> gsettings, std::string const& key)
+{
+  return g_settings_get_int(gsettings, key.c_str());
+}
+
+template<typename T>
+typename std::enable_if<std::is_same<T, uint>::value, T>::type
+getter_function(unity::glib::Object<GSettings> gsettings, std::string const& key)
+{
+  return g_settings_get_uint(gsettings, key.c_str());
+}
+
+template<typename T>
+typename std::enable_if<std::is_same<T, double>::value, T>::type
+getter_function(unity::glib::Object<GSettings> gsettings, std::string const& key)
+{
+  return g_settings_get_double(gsettings, key.c_str());
+}
+
+template<typename T>
+typename std::enable_if<std::is_same<T, std::string>::value, T>::type
+getter_function(unity::glib::Object<GSettings> gsettings, std::string const& key)
+{
+  unity::glib::Variant ret(g_settings_get_value(gsettings, key.c_str()));
+  return ret.GetString();
+}
+
+template<typename T>
+typename std::enable_if<std::is_same<T, std::vector<std::string>>::value, T>::type
+getter_function(unity::glib::Object<GSettings> gsettings, std::string const& key)
+{
+  std::vector<std::string> vec;
+
+  unity::glib::Variant variant(g_settings_get_value(gsettings, key.c_str()));
+  variant.ASToVectorOfStrings(vec);
+
+  return vec;
+}
+
+template<typename T>
+typename std::enable_if<std::is_enum<T>::value, T>::type
+getter_function(unity::glib::Object<GSettings> gsettings, std::string const& key)
+{
+  return static_cast<T>(g_settings_get_enum(gsettings, key.c_str()));
+}
+
+// End defintion setter/getter functions
+
+template<typename T>
+class TestGSettingsProperty : public Test
+{
+public:
+  unity::glib::Object<GSettings> gsettings_;
+
+  static T initial_value;
+  static T target_value;
+  static std::string key;
+
+  void SetUp()
+  {
+    // Setting the test values
+    gsettings_ = g_settings_new(SETTINGS_NAME);
+    setter_function<T>(gsettings_, key, initial_value);
+  }
+};
+
+TYPED_TEST_CASE_P(TestGSettingsProperty);
+
+TYPED_TEST_P(TestGSettingsProperty, ConstructionSchemaId)
+{
+  {
+    unity::GSettingsProperty<TypeParam> prop(SETTINGS_NAME, this->key);
+    EXPECT_EQ(this->initial_value, prop());
+  }
+
+  {
+    unity::GSettingsProperty<TypeParam> prop(SETTINGS_NAME, this->key, [](TypeParam const&) {});
+    EXPECT_EQ(this->initial_value, prop());
+  }
+}
+
+TYPED_TEST_P(TestGSettingsProperty, ConstructionGSetting)
+{
+  {
+    ASSERT_EQ(1, G_OBJECT(this->gsettings_.RawPtr())->ref_count);
+
+    unity::GSettingsProperty<TypeParam> prop(this->gsettings_, this->key);
+
+    ASSERT_EQ(2, G_OBJECT(this->gsettings_.RawPtr())->ref_count);
+    EXPECT_EQ(this->initial_value, prop());
+  }
+
+  {
+    ASSERT_EQ(1, G_OBJECT(this->gsettings_.RawPtr())->ref_count);
+
+    unity::GSettingsProperty<TypeParam> prop(this->gsettings_, this->key, [](TypeParam const&) {});
+
+    ASSERT_EQ(2, G_OBJECT(this->gsettings_.RawPtr())->ref_count);
+    EXPECT_EQ(this->initial_value, prop());
+  }
+
+  ASSERT_EQ(1, G_OBJECT(this->gsettings_.RawPtr())->ref_count);
+}
+
+TYPED_TEST_P(TestGSettingsProperty, Cast)
+{
+  {
+    unity::GSettingsProperty<TypeParam> prop(this->gsettings_,this->key);
+    EXPECT_EQ(this->initial_value, static_cast<TypeParam>(prop));
+  }
+
+  {
+    unity::GSettingsProperty<TypeParam> prop(this->gsettings_,this->key, [](TypeParam const&) {});
+    EXPECT_EQ(this->initial_value, static_cast<TypeParam>(prop));
+  }
+}
+
+TYPED_TEST_P(TestGSettingsProperty, ChangedSignal)
+{
+  bool signal_received = false;
+  TypeParam signal_value = this->initial_value;
+
+  // Make sure we get the changed signal if the settings key is modified by an external agent
+  unity::GSettingsProperty<TypeParam> prop(this->gsettings_, this->key, [&] (TypeParam value) {
+    signal_received = true;
+    signal_value = value;
+  });
+
+  setter_function(this->gsettings_, this->key.c_str(), this->target_value);
+
+  ASSERT_TRUE(signal_received);
+  EXPECT_EQ(this->target_value, signal_value);
+}
+
+
+TYPED_TEST_P(TestGSettingsProperty, OperatorEqCb)
+{
+  bool signal_received = false;
+  TypeParam signal_value = this->initial_value;
+
+  unity::GSettingsProperty<TypeParam> prop(this->gsettings_, this->key, [&](TypeParam value) {
+    signal_received = true;
+    signal_value = value;
+  });
+
+  // Make sure ::opertor= works:
+  // - when old_value != new_value
+  prop = this->target_value;
+
+  ASSERT_TRUE(signal_received);
+  EXPECT_EQ(this->target_value, signal_value);
+  EXPECT_EQ(this->target_value, getter_function<TypeParam>(this->gsettings_, this->key));
+  EXPECT_EQ(this->target_value, prop());
+
+  // - when old_value == new_value
+  signal_received = false;
+  prop = this->target_value;
+
+  ASSERT_FALSE(signal_received);
+  EXPECT_EQ(this->target_value, getter_function<TypeParam>(this->gsettings_, this->key));
+  EXPECT_EQ(this->target_value, prop());
+}
+
+TYPED_TEST_P(TestGSettingsProperty, OperatorEqNoCb)
+{
+  unity::GSettingsProperty<TypeParam> prop(this->gsettings_, this->key);
+
+  // Make sure ::opertor= works:
+  // - when old_value != new_value
+  prop = this->target_value;
+
+  EXPECT_EQ(this->target_value, getter_function<TypeParam>(this->gsettings_, this->key));
+  EXPECT_EQ(this->target_value, prop());
+
+  // - when old_value == new_value
+  prop = this->target_value;
+
+  EXPECT_EQ(this->target_value, getter_function<TypeParam>(this->gsettings_, this->key));
+  EXPECT_EQ(this->target_value, prop());
+}
+
+
+TYPED_TEST_P(TestGSettingsProperty, OperatorCallCb)
+{
+  bool signal_received = false;
+  TypeParam signal_value = this->initial_value;
+
+  unity::GSettingsProperty<TypeParam> prop(this->gsettings_, this->key, [&](TypeParam value) {
+    signal_received = true;
+    signal_value = value;
+  });
+
+  // Make sure ::opertor() works:
+  // - when old_value != new_value
+  prop(this->target_value);
+
+  ASSERT_TRUE(signal_received);
+  EXPECT_EQ(this->target_value, signal_value);
+  EXPECT_EQ(this->target_value, getter_function<TypeParam>(this->gsettings_, this->key));
+  EXPECT_EQ(this->target_value, prop());
+
+  // - when old_value == new_value
+  signal_received = false;
+  prop(this->target_value);
+
+  ASSERT_FALSE(signal_received);
+  EXPECT_EQ(this->target_value, getter_function<TypeParam>(this->gsettings_, this->key));
+  EXPECT_EQ(this->target_value, prop());
+}
+
+TYPED_TEST_P(TestGSettingsProperty, OperatorCallNoCb)
+{
+  unity::GSettingsProperty<TypeParam> prop(this->gsettings_, this->key);
+
+  // Make sure ::opertor() works:
+  // - when old_value != new_value
+  prop(this->target_value);
+
+  EXPECT_EQ(this->target_value, getter_function<TypeParam>(this->gsettings_, this->key));
+  EXPECT_EQ(this->target_value, prop());
+
+  // - when old_value == new_value
+  prop(this->target_value);
+
+  EXPECT_EQ(this->target_value, getter_function<TypeParam>(this->gsettings_, this->key));
+  EXPECT_EQ(this->target_value, prop());
+}
+
+TYPED_TEST_P(TestGSettingsProperty, GetCb)
+{
+  // Make sure ::Get works:
+  // - after construction
+  unity::GSettingsProperty<TypeParam> prop(this->gsettings_, this->key, [](TypeParam const&){});
+  EXPECT_EQ(this->initial_value, prop.Get());
+
+  // - after operator=
+  prop = this->target_value;
+  EXPECT_EQ(this->target_value, prop.Get());
+
+  // - after extenal editing
+  setter_function(this->gsettings_, this->key, this->initial_value);
+  EXPECT_EQ(this->initial_value, prop.Get());
+}
+
+TYPED_TEST_P(TestGSettingsProperty, GetNoCb)
+{
+  // Make sure ::Get works:
+  // - after construction
+  unity::GSettingsProperty<TypeParam> prop(this->gsettings_, this->key);
+  EXPECT_EQ(this->initial_value, prop.Get());
+
+  // - after operator=
+  prop = this->target_value;
+  EXPECT_EQ(this->target_value, prop.Get());
+
+  // - after extenal editing
+  setter_function(this->gsettings_, this->key, this->initial_value);
+  EXPECT_EQ(this->initial_value, prop.Get());
+}
+
+TYPED_TEST_P(TestGSettingsProperty, SetCb)
+{
+  bool signal_received = false;
+  TypeParam signal_value = this->initial_value;
+
+  unity::GSettingsProperty<TypeParam> prop(this->gsettings_, this->key, [&](TypeParam value){
+    signal_received = true;
+    signal_value = value;
+  });
+
+  // Make sure ::Set works:
+  // - when old_value != new_value
+  prop.Set(this->target_value);
+
+  ASSERT_TRUE(signal_received);
+  EXPECT_EQ(this->target_value, signal_value);
+  EXPECT_EQ(this->target_value, getter_function<TypeParam>(this->gsettings_, this->key));
+  EXPECT_EQ(this->target_value, prop());
+
+  // - when old_value == new_value
+  signal_received = false;
+  prop.Set(this->target_value);
+
+  ASSERT_FALSE(signal_received);
+  EXPECT_EQ(this->target_value, getter_function<TypeParam>(this->gsettings_, this->key));
+  EXPECT_EQ(this->target_value, prop());
+}
+
+TYPED_TEST_P(TestGSettingsProperty, SetNoCb)
+{
+  unity::GSettingsProperty<TypeParam> prop(this->gsettings_, this->key);
+
+  // Make sure ::Set works:
+  // - when old_value != new_value
+  prop.Set(this->target_value);
+
+  EXPECT_EQ(this->target_value, getter_function<TypeParam>(this->gsettings_, this->key));
+  EXPECT_EQ(this->target_value, prop());
+
+  // - when old_value == new_value
+  prop.Set(this->target_value);
+
+  EXPECT_EQ(this->target_value, getter_function<TypeParam>(this->gsettings_, this->key));
+  EXPECT_EQ(this->target_value, prop());
+}
+
+
+REGISTER_TYPED_TEST_CASE_P(TestGSettingsProperty,
+                           ConstructionSchemaId, ConstructionGSetting,
+                           Cast, ChangedSignal,
+                           OperatorEqCb, OperatorEqNoCb,
+                           OperatorCallCb, OperatorCallNoCb,
+                           GetCb, GetNoCb,
+                           SetCb, SetNoCb);
+
+enum class EC {
+  E1 = 0, E2, E3
+};
+
+enum E {
+  E1 = 0, E2, E3
+};
+
+typedef ::testing::Types<bool, int, uint, double, std::string, std::vector<std::string>, EC, E> MyTypes;
+INSTANTIATE_TYPED_TEST_CASE_P(TestGSettingsProperty, TestGSettingsProperty, MyTypes);
+
+// bool
+template<> bool TestGSettingsProperty<bool>::initial_value = true;
+template<> bool TestGSettingsProperty<bool>::target_value = false;
+template<> std::string TestGSettingsProperty<bool>::key = "bool";
+
+// int
+template<> int TestGSettingsProperty<int>::initial_value = -123;
+template<> int TestGSettingsProperty<int>::target_value = 456;
+template<> std::string TestGSettingsProperty<int>::key = "int";
+
+// uint
+template<> uint TestGSettingsProperty<uint>::initial_value = 123;
+template<> uint TestGSettingsProperty<uint>::target_value = 456;
+template<> std::string TestGSettingsProperty<uint>::key = "uint";
+
+// double
+template<> double TestGSettingsProperty<double>::initial_value = 123.456;
+template<> double TestGSettingsProperty<double>::target_value = 456.123;
+template<> std::string TestGSettingsProperty<double>::key = "double";
+
+// std::string
+template<> std::string TestGSettingsProperty<std::string>::initial_value = "abcdef";
+template<> std::string TestGSettingsProperty<std::string>::target_value = "dlkasdf";
+template<> std::string TestGSettingsProperty<std::string>::key = "string";
+
+// std::vector<std::string>
+template<> std::vector<std::string> TestGSettingsProperty<std::vector<std::string>>::initial_value = {"a", "b", "c"};
+template<> std::vector<std::string> TestGSettingsProperty<std::vector<std::string>>::target_value = {"d", "e", "f"};
+template<> std::string TestGSettingsProperty<std::vector<std::string>>::key = "vector-string";
+
+// enum class
+template<> EC TestGSettingsProperty<EC>::initial_value = EC::E1;
+template<> EC TestGSettingsProperty<EC>::target_value = EC::E2;
+template<> std::string TestGSettingsProperty<EC>::key = "enum";
+
+// enum
+template<> E TestGSettingsProperty<E>::initial_value = E::E1;
+template<> E TestGSettingsProperty<E>::target_value = E::E2;
+template<> std::string TestGSettingsProperty<E>::key = "enum";
+
+}