Merge lp:~timo-jyrinki/unity/xpathselect-1.4 into lp:unity

[Timo Jyrinki]

DebugDBusInterface: add support to libxpathselect-1.4

Some cleanups and reworking of glib::Variant and debug::DBusInterface

Same as lp:~3v1n0/unity/xpathselect-1.4 but with double function removed and packaging dependencies added.

Requires https://code.launchpad.net/~bregma/cmake/lp-1247787/+merge/193961 for Unity to build, then builds against AP1.4.

[PS Jenkins bot (ps-jenkins)]

FAILED: Continuous integration, rev:3590
http://jenkins.qa.ubuntu.com/job/unity-ci/491/
Executed test runs:
    FAILURE: http://jenkins.qa.ubuntu.com/job/unity-trusty-amd64-ci/22/console
    FAILURE: http://jenkins.qa.ubuntu.com/job/unity-trusty-armhf-ci/22/console
    FAILURE: http://jenkins.qa.ubuntu.com/job/unity-trusty-i386-ci/22/console

Click here to trigger a rebuild:
http://10.97.0.26:8080/job/unity-ci/491/rebuild

review: Needs Fixing (continuous-integration)

[Marco Trevisan (Treviño) (3v1n0)]

This should be fixed as well now https://code.launchpad.net/~3v1n0/unity/xpathselect-1.4/+merge/186092

[Christopher Townsend (townsend)]

Marco's branch was still missing the change to CMakeLists.txt, so we'll use this branch instead.

I've compiled and ran make check on this and it works, so approving.

review: Approve

[PS Jenkins bot (ps-jenkins)]

FAILED: Autolanding.
More details in the following jenkins job:
http://jenkins.qa.ubuntu.com/job/unity-autolanding/380/
Executed test runs:
    FAILURE: http://10.97.0.26:8080/job/generic-cleanup-mbs/3120/console
    FAILURE: http://jenkins.qa.ubuntu.com/job/unity-trusty-amd64-autolanding/10/console
    FAILURE: http://jenkins.qa.ubuntu.com/job/unity-trusty-armhf-autolanding/10/console
    FAILURE: http://jenkins.qa.ubuntu.com/job/unity-trusty-i386-autolanding/10/console

review: Needs Fixing (continuous-integration)

[PS Jenkins bot (ps-jenkins)]

FAILED: Autolanding.
More details in the following jenkins job:
http://jenkins.qa.ubuntu.com/job/unity-autolanding/381/
Executed test runs:
    FAILURE: http://10.97.0.26:8080/job/generic-cleanup-mbs/3121/console
    FAILURE: http://jenkins.qa.ubuntu.com/job/unity-trusty-amd64-autolanding/11/console
    FAILURE: http://jenkins.qa.ubuntu.com/job/unity-trusty-armhf-autolanding/11/console
    FAILURE: http://jenkins.qa.ubuntu.com/job/unity-trusty-i386-autolanding/11/console

review: Needs Fixing (continuous-integration)

=== modified file 'CMakeLists.txt'
--- CMakeLists.txt	2013-10-29 20:50:07 +0000
+++ CMakeLists.txt	2013-11-06 08:52:17 +0000
@@ -233,7 +233,7 @@
     nux-4.0>=4.0.1
     sigc++-2.0
     unity-misc>=0.4.0
-    xpathselect>=1.2
+    xpathselect=1.4
     zeitgeist-2.0
 )
 

=== modified file 'UnityCore/Filters.cpp'
--- UnityCore/Filters.cpp	2013-08-15 09:59:40 +0000
+++ UnityCore/Filters.cpp	2013-11-06 08:52:17 +0000
@@ -103,7 +103,7 @@
     current_hints[iter->first] = iter->second;
   }
 
-  dee_model_set_value(model_, iter_, FilterColumn::RENDERER_STATE, glib::Variant::FromHints(current_hints));
+  dee_model_set_value(model_, iter_, FilterColumn::RENDERER_STATE, glib::Variant(current_hints));
 }
 
 

=== modified file 'UnityCore/Result.cpp'
--- UnityCore/Result.cpp	2013-02-21 14:01:55 +0000
+++ UnityCore/Result.cpp	2013-11-06 08:52:17 +0000
@@ -150,18 +150,11 @@
 
 std::vector<glib::Variant> LocalResult::Variants() const
 {
-  std::vector<glib::Variant> vars;
-  vars.push_back(g_variant_new_string(uri.c_str()));
-  vars.push_back(g_variant_new_string(icon_hint.c_str()));
-  vars.push_back(g_variant_new_uint32(category_index));
-  vars.push_back(g_variant_new_uint32(result_type));
-  vars.push_back(g_variant_new_string(mimetype.c_str()));
-  vars.push_back(g_variant_new_string(name.c_str()));
-  vars.push_back(g_variant_new_string(comment.c_str()));
-  vars.push_back(g_variant_new_string(dnd_uri.c_str()));
-  vars.push_back(glib::Variant::FromHints(hints));
-
-  return vars;
+  return {
+    glib::Variant(uri), glib::Variant(icon_hint), glib::Variant(category_index),
+    glib::Variant(result_type), glib::Variant(mimetype), glib::Variant(name),
+    glib::Variant(comment), glib::Variant(dnd_uri), glib::Variant(hints)
+  };
 }
 
 glib::Variant LocalResult::Variant() const

=== modified file 'UnityCore/Scope.cpp'
--- UnityCore/Scope.cpp	2013-09-25 11:51:08 +0000
+++ UnityCore/Scope.cpp	2013-11-06 08:52:17 +0000
@@ -278,7 +278,7 @@
   }
 
   glib::HintsMap tmp_hints = hints;
-  tmp_hints["preview-action-id"] = g_variant_new_string(action->id.c_str());
+  tmp_hints["preview-action-id"] = action->id;
   pimpl->Activate(result, UNITY_PROTOCOL_ACTION_TYPE_PREVIEW_ACTION, tmp_hints, callback, cancellable);
 }
 

=== modified file 'UnityCore/ScopeProxy.cpp'
--- UnityCore/ScopeProxy.cpp	2013-09-25 11:51:08 +0000
+++ UnityCore/ScopeProxy.cpp	2013-11-06 08:52:17 +0000
@@ -401,7 +401,7 @@
     glib::HintsMap hints;
     if (!owner_->form_factor().empty())
     {
-      hints["form-factor"] = g_variant_new_string(owner_->form_factor().c_str());
+      hints["form-factor"] = owner_->form_factor();
     }
     hints["changed-filter-row"] = filter->VariantValue();
     Search(last_search_, hints, nullptr, cancel_scope_);
@@ -521,7 +521,7 @@
         glib::HintsMap updated_hints(hints);
         if (!owner_->form_factor().empty())
         {
-          updated_hints["form-factor"] = g_variant_new_string(owner_->form_factor().c_str());
+          updated_hints["form-factor"] = owner_->form_factor();
         }
         Search(search_string, updated_hints, callback, canc);
       }
@@ -791,9 +791,9 @@
 void ScopeProxy::Search(std::string const& search_string, glib::HintsMap const& user_hints, SearchCallback const& callback, GCancellable* cancellable)
 {
   glib::HintsMap hints = user_hints;
-  if (!form_factor.Get().empty() && hints.find("form-factor") == hints.end())
+  if (!form_factor().empty() && hints.find("form-factor") == hints.end())
   {
-    hints["form-factor"] = g_variant_new_string(form_factor().c_str());
+    hints["form-factor"] = form_factor();
   }
   pimpl->Search(search_string, hints, callback, cancellable);
 }

=== modified file 'UnityCore/Variant.cpp'
--- UnityCore/Variant.cpp	2013-08-23 17:21:44 +0000
+++ UnityCore/Variant.cpp	2013-11-06 08:52:17 +0000
@@ -1,6 +1,6 @@
 // -*- Mode: C++; indent-tabs-mode: nil; tab-width: 2 -*-
 /*
- * Copyright (C) 2010 Canonical Ltd
+ * Copyright (C) 2010-2013 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
@@ -15,6 +15,7 @@
  * along with this program.  If not, see <http://www.gnu.org/licenses/>.
  *
  * Authored by: Tim Penhey <[e-mail]>
+ *              Marco Trevisan <[e-mail]>
  */
 
 #include "Variant.h"
@@ -27,7 +28,7 @@
 DECLARE_LOGGER(logger, "unity.glib.variant");
 
 Variant::Variant()
-  : variant_(NULL)
+  : variant_(nullptr)
 {}
 
 Variant::Variant(GVariant* variant)
@@ -41,9 +42,71 @@
 {}
 
 Variant::Variant(Variant const& other)
-  : variant_(other.variant_)
+  : Variant(other.variant_)
+{}
+
+Variant::Variant(std::nullptr_t)
+  : Variant()
+{}
+
+Variant::Variant(const char* value)
+  : Variant(g_variant_new_string(value ? value : value))
+{}
+
+Variant::Variant(std::string const& value)
+  : Variant(g_variant_new_string(value.c_str()))
+{}
+
+Variant::Variant(unsigned char value)
+  : Variant(g_variant_new_byte(value))
+{}
+
+Variant::Variant(int16_t value)
+  : Variant(g_variant_new_int16(value))
+{}
+
+Variant::Variant(uint16_t value)
+  : Variant(g_variant_new_uint16(value))
+{}
+
+Variant::Variant(int32_t value)
+  : Variant(g_variant_new_int32(value))
+{}
+
+Variant::Variant(uint32_t value)
+  : Variant(g_variant_new_uint32(value))
+{}
+
+Variant::Variant(int64_t value)
+  : Variant(g_variant_new_int64(value))
+{}
+
+Variant::Variant(uint64_t value)
+  : Variant(g_variant_new_uint64(value))
+{}
+
+Variant::Variant(bool value)
+  : Variant(g_variant_new_boolean(value))
+{}
+
+Variant::Variant(double value)
+  : Variant(g_variant_new_double(value))
+{}
+
+Variant::Variant(float value)
+  : Variant(static_cast<double>(value))
+{}
+
+Variant::Variant(HintsMap const& hints)
 {
-  if (variant_) g_variant_ref_sink(variant_);
+  GVariantBuilder b;
+  g_variant_builder_init(&b, G_VARIANT_TYPE("a{sv}"));
+
+  for (auto const& hint : hints)
+    g_variant_builder_add(&b, "{sv}", hint.first.c_str(), static_cast<GVariant*>(hint.second));
+
+  variant_ = g_variant_builder_end(&b);
+  g_variant_ref_sink(variant_);
 }
 
 Variant::~Variant()
@@ -51,6 +114,25 @@
   if (variant_) g_variant_unref(variant_);
 }
 
+glib::Variant get_variant(GVariant *variant_)
+{
+  Variant value;
+
+  if (!variant_)
+    return value;
+
+  if (g_variant_is_of_type(variant_, G_VARIANT_TYPE_VARIANT))
+  {
+    value = Variant(g_variant_get_variant(variant_), StealRef());
+  }
+  else if (g_variant_is_of_type(variant_, G_VARIANT_TYPE("(v)")))
+  {
+    g_variant_get(variant_, "(v)", &value);
+  }
+
+  return value;
+}
+
 std::string Variant::GetString() const
 {
   const gchar *result = nullptr;
@@ -70,182 +152,91 @@
   }
   else
   {
-    auto const& variant = GetVariant();
+    auto const& variant = get_variant(variant_);
     if (variant)
       return variant.GetString();
 
-    LOG_ERROR(logger) << "You're trying to extract a String from a variant which is of type "
-                      << g_variant_type_peek_string(g_variant_get_type(variant_));
+    LOG_ERROR(logger) << "You're trying to extract a 's' from a variant which is of type '"
+                      << g_variant_type_peek_string(g_variant_get_type(variant_)) << "'";
   }
 
   return result ? result : "";
 }
 
+template <typename TYPE, typename GTYPE>
+TYPE get_numeric_value(GVariant *variant_, const char *type_str, const char *fallback_type_str)
+{
+  GTYPE value = 0;
+
+  if (!variant_)
+    return static_cast<TYPE>(value);
+
+  if (g_variant_is_of_type(variant_, G_VARIANT_TYPE(type_str)))
+  {
+    g_variant_get(variant_, type_str, &value);
+  }
+  else if (g_variant_is_of_type(variant_, G_VARIANT_TYPE(fallback_type_str)))
+  {
+    g_variant_get(variant_, fallback_type_str, &value);
+  }
+  else
+  {
+    auto const& variant = get_variant(variant_);
+    if (variant)
+      return get_numeric_value<TYPE, GTYPE>(static_cast<GVariant*>(variant), type_str, fallback_type_str);
+
+    LOG_ERROR(logger) << "You're trying to extract a '" << type_str << "'"
+                      << " from a variant which is of type '"
+                      << g_variant_type_peek_string(g_variant_get_type(variant_))
+                      << "'";
+  }
+
+  return static_cast<TYPE>(value);
+}
+
+unsigned char Variant::GetByte() const
+{
+  return get_numeric_value<unsigned char, guchar>(variant_, "y", "(y)");
+}
+
+int16_t Variant::GetInt16() const
+{
+  return get_numeric_value<int16_t, gint16>(variant_, "n", "(n)");
+}
+
+uint16_t Variant::GetUInt16() const
+{
+  return get_numeric_value<uint16_t, guint16>(variant_, "q", "(q)");
+}
+
 int32_t Variant::GetInt32() const
 {
-  gint32 value = 0;
-
-  if (!variant_)
-    return static_cast<int>(value);
-
-  if (g_variant_is_of_type(variant_, G_VARIANT_TYPE_INT32))
-  {
-    value = g_variant_get_int32(variant_);
-  }
-  else if (g_variant_is_of_type(variant_, G_VARIANT_TYPE("(i)")))
-  {
-    g_variant_get(variant_, "(i)", &value);
-  }
-  else
-  {
-    auto const& variant = GetVariant();
-    if (variant)
-      return variant.GetInt32();
-
-    LOG_ERROR(logger) << "You're trying to extract an Int32 from a variant which is of type "
-                      << g_variant_type_peek_string(g_variant_get_type(variant_));
-  }
-
-  return static_cast<int32_t>(value);
+  return get_numeric_value<int32_t, gint32>(variant_, "i", "(i)");
 }
 
 uint32_t Variant::GetUInt32() const
 {
-  guint32 value = 0;
-
-  if (!variant_)
-    return static_cast<unsigned>(value);
-
-  if (g_variant_is_of_type(variant_, G_VARIANT_TYPE_UINT32))
-  {
-    value = g_variant_get_uint32(variant_);
-  }
-  else if (g_variant_is_of_type(variant_, G_VARIANT_TYPE("(u)")))
-  {
-    g_variant_get(variant_, "(u)", &value);
-  }
-  else
-  {
-    auto const& variant = GetVariant();
-    if (variant)
-      return variant.GetUInt32();
-
-    LOG_ERROR(logger) << "You're trying to extract an UInt32 from a variant which is of type "
-                      << g_variant_type_peek_string(g_variant_get_type(variant_));
-  }
-
-  return static_cast<uint32_t>(value);}
+  return get_numeric_value<uint32_t, guint32>(variant_, "u", "(u)");
+}
 
 int64_t Variant::GetInt64() const
 {
-  gint64 value = 0;
-
-  if (!variant_)
-    return static_cast<int64_t>(value);
-
-  if (g_variant_is_of_type(variant_, G_VARIANT_TYPE_INT64))
-  {
-    value = g_variant_get_int64(variant_);
-  }
-  else if (g_variant_is_of_type(variant_, G_VARIANT_TYPE("(x)")))
-  {
-    g_variant_get(variant_, "(x)", &value);
-  }
-  else
-  {
-    auto const& variant = GetVariant();
-    if (variant)
-      return variant.GetInt64();
-
-    LOG_ERROR(logger) << "You're trying to extract an Int64 from a variant which is of type "
-                      << g_variant_type_peek_string(g_variant_get_type(variant_));
-  }
-
-  return static_cast<int64_t>(value);
+  return get_numeric_value<int64_t, gint64>(variant_, "x", "(x)");
 }
 
 uint64_t Variant::GetUInt64() const
 {
-  guint64 value = 0;
-
-  if (!variant_)
-    return static_cast<uint64_t>(value);
-
-  if (g_variant_is_of_type(variant_, G_VARIANT_TYPE_UINT64))
-  {
-    value = g_variant_get_uint64(variant_);
-  }
-  else if (g_variant_is_of_type(variant_, G_VARIANT_TYPE("(t)")))
-  {
-    g_variant_get(variant_, "(t)", &value);
-  }
-  else
-  {
-    auto const& variant = GetVariant();
-    if (variant)
-      return variant.GetUInt64();
-
-    LOG_ERROR(logger) << "You're trying to extract an UInt64 from a variant which is of type "
-                      << g_variant_type_peek_string(g_variant_get_type(variant_));
-  }
-
-  return static_cast<uint64_t>(value);
+  return get_numeric_value<uint64_t, guint64>(variant_, "t", "(t)");
 }
 
 bool Variant::GetBool() const
 {
-  gboolean value = FALSE;
-
-  if (!variant_)
-    return (value != FALSE);
-
-  if (g_variant_is_of_type(variant_, G_VARIANT_TYPE_BOOLEAN))
-  {
-    value = g_variant_get_boolean(variant_);
-  }
-  else if (g_variant_is_of_type(variant_, G_VARIANT_TYPE("(b)")))
-  {
-    g_variant_get(variant_, "(b)", &value);
-  }
-  else
-  {
-    auto const& variant = GetVariant();
-    if (variant)
-      return variant.GetBool();
-
-    LOG_ERROR(logger) << "You're trying to extract a Boolean from a variant which is of type "
-                      << g_variant_type_peek_string(g_variant_get_type(variant_));
-  }
-
-  return (value != FALSE);
+  return get_numeric_value<bool, gboolean>(variant_, "b", "(b)");
 }
 
 double Variant::GetDouble() const
 {
-  double value = 0.0;
-
-  if (!variant_)
-    return value;
-
-  if (g_variant_is_of_type(variant_, G_VARIANT_TYPE_DOUBLE))
-  {
-    value = g_variant_get_double(variant_);
-  }
-  else if (g_variant_is_of_type(variant_, G_VARIANT_TYPE("(d)")))
-  {
-    g_variant_get(variant_, "(d)", &value);
-  }
-  else
-  {
-    auto const& variant = GetVariant();
-    if (variant)
-      return variant.GetDouble();
-
-    LOG_ERROR(logger) << "You're trying to extract a Double from a variant which is of type "
-                      << g_variant_type_peek_string(g_variant_get_type(variant_));
-  }
-
-  return value;
+  return get_numeric_value<double, gdouble>(variant_, "d", "(d)");
 }
 
 float Variant::GetFloat() const
@@ -260,18 +251,12 @@
   if (!variant_)
     return value;
 
-  if (g_variant_is_of_type(variant_, G_VARIANT_TYPE_VARIANT))
-  {
-    value = Variant(g_variant_get_variant(variant_), StealRef());
-  }
-  else if (g_variant_is_of_type(variant_, G_VARIANT_TYPE("(v)")))
-  {
-    g_variant_get(variant_, "(v)", &value);
-  }
-  else
-  {
-    LOG_ERROR(logger) << "You're trying to extract a Variant from a variant which is of type "
-                      << g_variant_type_peek_string(g_variant_get_type(variant_));
+  value = get_variant(variant_);
+
+  if (!value)
+  {
+    LOG_ERROR(logger) << "You're trying to extract a 'v' from a variant which is of type '"
+                      << g_variant_type_peek_string(g_variant_get_type(variant_)) << "'";
   }
 
   return value;
@@ -304,22 +289,6 @@
   return true;
 }
 
-Variant Variant::FromHints(HintsMap const& hints)
-{
-  GVariantBuilder b;
-  g_variant_builder_init(&b, G_VARIANT_TYPE("a{sv}"));
-
-  for (glib::HintsMap::const_iterator it = hints.begin(); it != hints.end(); ++it)
-  {
-    const gchar* key = it->first.c_str();
-    GVariant* ptr = it->second;
-
-    g_variant_builder_add(&b, "{sv}", key, ptr);
-  }
-
-  return g_variant_builder_end(&b);
-}
-
 void Variant::swap(Variant& other)
 {
   std::swap(this->variant_, other.variant_);
@@ -340,6 +309,21 @@
   return *this;
 }
 
+Variant& Variant::operator=(std::nullptr_t) { return operator=(Variant()); }
+Variant& Variant::operator=(HintsMap const& map) { return operator=(Variant(map)); }
+Variant& Variant::operator=(std::string const& value) { return operator=(Variant(value)); }
+Variant& Variant::operator=(const char* value) { return operator=(Variant(value)); }
+Variant& Variant::operator=(unsigned char value) { return operator=(Variant(value)); }
+Variant& Variant::operator=(int16_t value) { return operator=(Variant(value)); }
+Variant& Variant::operator=(uint16_t value) { return operator=(Variant(value)); }
+Variant& Variant::operator=(int32_t value) { return operator=(Variant(value)); }
+Variant& Variant::operator=(uint32_t value) { return operator=(Variant(value)); }
+Variant& Variant::operator=(int64_t value) { return operator=(Variant(value)); }
+Variant& Variant::operator=(uint64_t value) { return operator=(Variant(value)); }
+Variant& Variant::operator=(bool value) { return operator=(Variant(value)); }
+Variant& Variant::operator=(double value) { return operator=(Variant(value)); }
+Variant& Variant::operator=(float value) { return operator=(Variant(value)); }
+
 Variant::operator GVariant* () const
 {
   return variant_;
@@ -396,90 +380,116 @@
 
 namespace variant
 {
+using namespace glib;
 
 BuilderWrapper::BuilderWrapper(GVariantBuilder* builder)
   : builder_(builder)
 {}
 
-BuilderWrapper& BuilderWrapper::add(char const* name, bool value)
-{
-  g_variant_builder_add(builder_, "{sv}", name, g_variant_new_boolean(value));
-  return *this;
-}
-
-BuilderWrapper& BuilderWrapper::add(char const* name, char const* value)
-{
-  if (value)
-    g_variant_builder_add(builder_, "{sv}", name, g_variant_new_string(value));
-  else
-    g_variant_builder_add(builder_, "{sv}", name, g_variant_new_string(""));
-
-  return *this;
-}
-
-BuilderWrapper& BuilderWrapper::add(char const* name, std::string const& value)
-{
-  g_variant_builder_add(builder_, "{sv}", name,
-                        g_variant_new_string(value.c_str()));
-  return *this;
-}
-
-BuilderWrapper& BuilderWrapper::add(char const* name, int16_t value)
-{
-  g_variant_builder_add(builder_, "{sv}", name, g_variant_new_int16(value));
-  return *this;
-}
-
-BuilderWrapper& BuilderWrapper::add(char const* name, int32_t value)
-{
-  g_variant_builder_add(builder_, "{sv}", name, g_variant_new_int32(value));
-  return *this;
-}
-
-BuilderWrapper& BuilderWrapper::add(char const* name, int64_t value)
-{
-  g_variant_builder_add(builder_, "{sv}", name, g_variant_new_int64(value));
-  return *this;
-}
-
-BuilderWrapper& BuilderWrapper::add(char const* name, uint16_t value)
-{
-  g_variant_builder_add(builder_, "{sv}", name, g_variant_new_uint16(value));
-  return *this;
-}
-
-BuilderWrapper& BuilderWrapper::add(char const* name, uint32_t value)
-{
-  g_variant_builder_add(builder_, "{sv}", name, g_variant_new_uint32(value));
-  return *this;
-}
-
-BuilderWrapper& BuilderWrapper::add(char const* name, uint64_t value)
-{
-  g_variant_builder_add(builder_, "{sv}", name, g_variant_new_uint64(value));
-  return *this;
-}
-
-BuilderWrapper& BuilderWrapper::add(char const* name, float value)
-{
-  g_variant_builder_add(builder_, "{sv}", name, g_variant_new_double(value));
-  return *this;
-}
-
-BuilderWrapper& BuilderWrapper::add(char const* name, double value)
-{
-  g_variant_builder_add(builder_, "{sv}", name, g_variant_new_double(value));
-  return *this;
-}
-
-BuilderWrapper& BuilderWrapper::add(char const* name, GVariant* value)
-{
-  g_variant_builder_add(builder_, "{sv}", name, value);
-  return *this;
+BuilderWrapper& BuilderWrapper::add(std::string const& name, ValueType type, std::vector<Variant> const& values)
+{
+  GVariantBuilder array;
+  g_variant_builder_init(&array, G_VARIANT_TYPE("av"));
+  g_variant_builder_add(&array, "v", g_variant_new_uint32(static_cast<uint32_t>(type)));
+
+  for (auto const& value : values)
+    g_variant_builder_add(&array, "v", static_cast<GVariant*>(value));
+
+  g_variant_builder_add(builder_, "{sv}", name.c_str(), g_variant_builder_end(&array));
+
+  return *this;
+}
+
+BuilderWrapper& BuilderWrapper::add(std::string const& name, bool value)
+{
+  return add(name, ValueType::SIMPLE, {Variant(value)});
+}
+
+BuilderWrapper& BuilderWrapper::add(std::string const& name, char const* value)
+{
+  return add(name, ValueType::SIMPLE, {Variant(value)});
+}
+
+BuilderWrapper& BuilderWrapper::add(std::string const& name, std::string const& value)
+{
+  return add(name, ValueType::SIMPLE, {Variant(value)});
+}
+
+BuilderWrapper& BuilderWrapper::add(std::string const& name, int16_t value)
+{
+  return add(name, ValueType::SIMPLE, {Variant(value)});
+}
+
+BuilderWrapper& BuilderWrapper::add(std::string const& name, int32_t value)
+{
+  return add(name, ValueType::SIMPLE, {Variant(value)});
+}
+
+BuilderWrapper& BuilderWrapper::add(std::string const& name, int64_t value)
+{
+  return add(name, ValueType::SIMPLE, {Variant(value)});
+}
+
+BuilderWrapper& BuilderWrapper::add(std::string const& name, uint16_t value)
+{
+  return add(name, ValueType::SIMPLE, {Variant(value)});
+}
+
+BuilderWrapper& BuilderWrapper::add(std::string const& name, uint32_t value)
+{
+  return add(name, ValueType::SIMPLE, {Variant(value)});
+}
+
+BuilderWrapper& BuilderWrapper::add(std::string const& name, uint64_t value)
+{
+  return add(name, ValueType::SIMPLE, {Variant(value)});
+}
+
+BuilderWrapper& BuilderWrapper::add(std::string const& name, float value)
+{
+  return add(name, ValueType::SIMPLE, {Variant(value)});
+}
+
+BuilderWrapper& BuilderWrapper::add(std::string const& name, double value)
+{
+  return add(name, ValueType::SIMPLE, {Variant(value)});
+}
+
+BuilderWrapper& BuilderWrapper::add(std::string const& name, GVariant* value)
+{
+  return add(name, ValueType::SIMPLE, {Variant(value)});
+}
+
+BuilderWrapper& BuilderWrapper::add(std::string const& name, glib::Variant const& value)
+{
+  return add(name, ValueType::SIMPLE, {value});
+}
+
+BuilderWrapper& BuilderWrapper::add(std::string const& name, nux::Rect const& r)
+{
+  return add(name, ValueType::RECTANGLE, {Variant(r.x), Variant(r.y), Variant(r.width), Variant(r.height)});
+}
+
+BuilderWrapper& BuilderWrapper::add(std::string const& name, nux::Point const& p)
+{
+  return add(name, ValueType::POINT, {Variant(p.x), Variant(p.y)});
+}
+
+BuilderWrapper& BuilderWrapper::add(std::string const& name, nux::Size const& s)
+{
+  return add(name, ValueType::SIZE, {Variant(s.width), Variant(s.height)});
+}
+
+BuilderWrapper& BuilderWrapper::add(std::string const& name, nux::Color const& c)
+{
+  int32_t r = c.red * 255.0f, g = c.green * 255.0f, b = c.blue * 255.0f, a = c.alpha * 255.0f;
+  return add(name, ValueType::COLOR, {Variant(r), Variant(g), Variant(b), Variant(a)});
 }
 
 BuilderWrapper& BuilderWrapper::add(nux::Rect const& value)
 {
+  add("globalRect", value);
+  // Legacy support
   add("x", value.x);
   add("y", value.y);
   add("width", value.width);

=== modified file 'UnityCore/Variant.h'
--- UnityCore/Variant.h	2013-08-23 17:21:44 +0000
+++ UnityCore/Variant.h	2013-11-06 08:52:17 +0000
@@ -1,6 +1,6 @@
 // -*- Mode: C++; indent-tabs-mode: nil; tab-width: 2 -*-
 /*
- * Copyright (C) 2011 Canonical Ltd
+ * Copyright (C) 2011-2013 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
@@ -15,6 +15,7 @@
  * along with this program.  If not, see <http://www.gnu.org/licenses/>.
  *
  * Authored by: Tim Penhey <[e-mail]>
+ *              Marco Trevisan <[e-mail]>
  */
 
 #ifndef UNITY_VARIANT_H
@@ -22,9 +23,11 @@
 
 #include <string>
 #include <glib.h>
+#include <vector>
 #include <map>
 
 #include <NuxCore/Rect.h>
+#include <NuxCore/Color.h>
 
 namespace unity
 {
@@ -45,10 +48,28 @@
   Variant(GVariant*);
   Variant(GVariant*, StealRef const&);
 
+  Variant(HintsMap const& hints);
+  explicit Variant(std::nullptr_t);
+  explicit Variant(std::string const&);
+  explicit Variant(const char*);
+  explicit Variant(unsigned char);
+  explicit Variant(int16_t);
+  explicit Variant(uint16_t);
+  explicit Variant(int32_t);
+  explicit Variant(uint32_t);
+  explicit Variant(int64_t);
+  explicit Variant(uint64_t);
+  explicit Variant(bool);
+  explicit Variant(double);
+  explicit Variant(float);
+
   Variant(Variant const&);
   ~Variant();
 
   std::string GetString() const;
+  unsigned char GetByte() const;
+  int16_t GetInt16() const;
+  uint16_t GetUInt16() const;
   int32_t GetInt32() const;
   uint32_t GetUInt32() const;
   int64_t GetInt64() const;
@@ -59,11 +80,24 @@
   Variant GetVariant() const;
 
   bool ASVToHints(HintsMap& hints) const;
-  static Variant FromHints(HintsMap const& hints);
 
   void swap(Variant&);
   Variant& operator=(GVariant*);
   Variant& operator=(Variant);
+  Variant& operator=(HintsMap const&);
+  Variant& operator=(std::nullptr_t);
+  Variant& operator=(std::string const&);
+  Variant& operator=(const char*);
+  Variant& operator=(unsigned char);
+  Variant& operator=(int16_t);
+  Variant& operator=(uint16_t);
+  Variant& operator=(int32_t);
+  Variant& operator=(uint32_t);
+  Variant& operator=(int64_t);
+  Variant& operator=(uint64_t);
+  Variant& operator=(bool);
+  Variant& operator=(double);
+  Variant& operator=(float);
   operator GVariant*() const;
   operator bool() const;
 
@@ -78,24 +112,44 @@
 
 class BuilderWrapper
 {
+// XXX: Move this to Introspectable
 public:
+  enum class ValueType : uint32_t
+  {
+    // This should match the Autopilot Type IDs
+    SIMPLE = 0,
+    RECTANGLE = 1,
+    POINT = 2,
+    SIZE = 3,
+    COLOR = 4,
+    DATE = 5,
+    TIME = 6,
+  };
+
   BuilderWrapper(GVariantBuilder* builder);
 
-  BuilderWrapper& add(char const* name, bool value);
-  BuilderWrapper& add(char const* name, char const* value);
-  BuilderWrapper& add(char const* name, std::string const& value);
-  BuilderWrapper& add(char const* name, int16_t value);
-  BuilderWrapper& add(char const* name, int32_t value);
-  BuilderWrapper& add(char const* name, int64_t value);
-  BuilderWrapper& add(char const* name, uint16_t value);
-  BuilderWrapper& add(char const* name, uint32_t value);
-  BuilderWrapper& add(char const* name, uint64_t value);
-  BuilderWrapper& add(char const* name, float value);
-  BuilderWrapper& add(char const* name, double value);
-  BuilderWrapper& add(char const* name, GVariant* value);
-  BuilderWrapper& add(nux::Rect const& value);
+  BuilderWrapper& add(std::string const& name, bool);
+  BuilderWrapper& add(std::string const& name, const char*);
+  BuilderWrapper& add(std::string const& name, std::string const&);
+  BuilderWrapper& add(std::string const& name, int16_t);
+  BuilderWrapper& add(std::string const& name, int32_t);
+  BuilderWrapper& add(std::string const& name, int64_t);
+  BuilderWrapper& add(std::string const& name, uint16_t);
+  BuilderWrapper& add(std::string const& name, uint32_t);
+  BuilderWrapper& add(std::string const& name, uint64_t);
+  BuilderWrapper& add(std::string const& name, float);
+  BuilderWrapper& add(std::string const& name, double);
+  BuilderWrapper& add(std::string const& name, glib::Variant const&);
+  BuilderWrapper& add(std::string const& name, GVariant*);
+
+  BuilderWrapper& add(std::string const& name, nux::Rect const&);
+  BuilderWrapper& add(std::string const& name, nux::Point const&);
+  BuilderWrapper& add(std::string const& name, nux::Size const&);
+  BuilderWrapper& add(std::string const& name, nux::Color const&);
+  BuilderWrapper& add(nux::Rect const&);
 
 private:
+  BuilderWrapper& add(std::string const& name, ValueType, std::vector<glib::Variant> const&);
   GVariantBuilder* builder_;
 };
 

=== modified file 'dash/FilterBar.cpp'
--- dash/FilterBar.cpp	2013-01-21 18:05:47 +0000
+++ dash/FilterBar.cpp	2013-11-06 08:52:17 +0000
@@ -144,11 +144,7 @@
 
 void FilterBar::AddProperties(GVariantBuilder* builder)
 {
-  variant::BuilderWrapper(builder)
-    .add("x", GetAbsoluteX())
-    .add("y", GetAbsoluteY())
-    .add("width", GetAbsoluteWidth())
-    .add("height", GetAbsoluteHeight());
+  variant::BuilderWrapper(builder).add(GetAbsoluteGeometry());
 }
 
 } // namespace dash

=== modified file 'dash/PlacesGroup.cpp'
--- dash/PlacesGroup.cpp	2013-05-01 18:11:32 +0000
+++ dash/PlacesGroup.cpp	2013-11-06 08:52:17 +0000
@@ -649,6 +649,7 @@
   wrapper.add("header-y", _header_view->GetAbsoluteY());
   wrapper.add("header-width", _header_view->GetAbsoluteWidth());
   wrapper.add("header-height", _header_view->GetAbsoluteHeight());
+  wrapper.add("header-geo", _header_view->GetAbsoluteGeometry());
   wrapper.add("header-has-keyfocus", HeaderHasKeyFocus());
   wrapper.add("header-is-highlighted", ShouldBeHighlighted());
   wrapper.add("name", _name->GetText());
@@ -656,22 +657,24 @@
   wrapper.add("is-expanded", GetExpanded());
   wrapper.add("expand-label-is-visible", _expand_label->IsVisible());
   wrapper.add("expand-label-y", _expand_label->GetAbsoluteY());
+  wrapper.add("expand-label-geo", _expand_label->GetAbsoluteGeometry());
   wrapper.add("expand-label-baseline", _expand_label->GetBaseline());
   wrapper.add("name-label-y", _name->GetAbsoluteY());
   wrapper.add("name-label-baseline", _name->GetBaseline());
+  wrapper.add("name-label-geo", _name->GetAbsoluteGeometry());
 }
 
 glib::Variant PlacesGroup::GetCurrentFocus() const
 {
   if (_header_view && _header_view->HasKeyFocus())
   {
-    return g_variant_new_string("HeaderView");
+    return glib::Variant("HeaderView");
   }
   else if (_child_view && _child_view->HasKeyFocus())
   {
     return g_variant_new("(si)", "ResultView", _child_view->GetSelectedIndex());
   }
-  return glib::Variant();
+  return nullptr;
 }
 
 void PlacesGroup::SetCurrentFocus(glib::Variant const& variant)

=== modified file 'dash/previews/MusicPaymentPreview.cpp'
--- dash/previews/MusicPaymentPreview.cpp	2013-07-10 15:14:02 +0000
+++ dash/previews/MusicPaymentPreview.cpp	2013-11-06 08:52:17 +0000
@@ -98,9 +98,8 @@
   {
     // HACK: We need to think a better way to do this
     auto const& password = password_entry_->text_entry()->GetText();
-    glib::Variant variant_pw(g_variant_new_string(password.c_str()));
     glib::HintsMap hints {
-      std::make_pair(MusicPaymentPreview::DATA_PASSWORD_KEY, variant_pw)
+      {MusicPaymentPreview::DATA_PASSWORD_KEY, glib::Variant(password)}
     };
     preview_model_->PerformAction(id, hints);
 

=== modified file 'dash/previews/PaymentPreview.cpp'
--- dash/previews/PaymentPreview.cpp	2013-07-10 15:14:02 +0000
+++ dash/previews/PaymentPreview.cpp	2013-11-06 08:52:17 +0000
@@ -170,13 +170,7 @@
 
 void OverlaySpinner::AddProperties(GVariantBuilder* builder)
 {
-  nux::Geometry geo = GetGeometry();
-
-  variant::BuilderWrapper(builder)
-    .add("x", geo.x)
-    .add("y", geo.y)
-    .add("width", geo.width)
-    .add("height", geo.height);
+  variant::BuilderWrapper(builder).add(GetAbsoluteGeometry());
 }
 
 

=== modified file 'dash/previews/PreviewNavigator.cpp'
--- dash/previews/PreviewNavigator.cpp	2012-11-29 10:19:01 +0000
+++ dash/previews/PreviewNavigator.cpp	2013-11-06 08:52:17 +0000
@@ -70,6 +70,7 @@
     .add("button-y", texture_->GetAbsoluteY())
     .add("button-width", texture_->GetGeometry().width)
     .add("button-height", texture_->GetGeometry().height)
+    .add("button-geo", texture_->GetAbsoluteGeometry())
     .add("direction", static_cast<int>(direction_));
 }
 

=== modified file 'dash/previews/Track.cpp'
--- dash/previews/Track.cpp	2013-07-01 21:17:59 +0000
+++ dash/previews/Track.cpp	2013-11-06 08:52:17 +0000
@@ -147,7 +147,8 @@
     .add("playpause-x", track_status_layout_->GetAbsoluteX())
     .add("playpause-y", track_status_layout_->GetAbsoluteX())
     .add("playpause-width", track_status_layout_->GetGeometry().width)
-    .add("playpause-height", track_status_layout_->GetGeometry().height);
+    .add("playpause-height", track_status_layout_->GetGeometry().height)
+    .add("playpause-geo", track_status_layout_->GetAbsoluteGeometry());
 }
 
 void Track::Update(dash::Track const& track)

=== modified file 'debian/control'
--- debian/control	2013-10-29 20:50:07 +0000
+++ debian/control	2013-11-06 08:52:17 +0000
@@ -48,7 +48,7 @@
                libxcb-icccm4-dev,
                libxfixes-dev (>= 1:5.0.1-1),
                libxi-dev (>= 2:1.7.1.901),
-               libxpathselect-dev (>=1.3),
+               libxpathselect-dev (>=1.4),
                libzeitgeist-2.0-dev,
                pkg-config,
                python (>= 2.7),
@@ -178,7 +178,7 @@
          python-testtools,
          python-xdg,
          python-xlib,
-         libxpathselect1.3 (>= 1.3),
+         libxpathselect1.4 (>= 1.4),
 Description: Autopiloted tests for Unity
  We test Unity automatically through autopilot, a framework which enables us
  to trigger keyboard and mouse events on the fly as well as introspecting

=== modified file 'launcher/LauncherController.cpp'
--- launcher/LauncherController.cpp	2013-10-21 23:48:47 +0000
+++ launcher/LauncherController.cpp	2013-11-06 08:52:17 +0000
@@ -164,8 +164,7 @@
 
     if (selected)
     {
-      ubus.SendMessage(UBUS_LAUNCHER_SELECTION_CHANGED,
-                       g_variant_new_string(selected->tooltip_text().c_str()));
+      ubus.SendMessage(UBUS_LAUNCHER_SELECTION_CHANGED, glib::Variant(selected->tooltip_text()));
     }
   });
 
@@ -1312,12 +1311,12 @@
   if (pimpl->launcher_grabbed)
   {
     pimpl->ubus.SendMessage(UBUS_LAUNCHER_START_KEY_NAV,
-                            g_variant_new_int32(pimpl->keyboard_launcher_->monitor));
+                            glib::Variant(pimpl->keyboard_launcher_->monitor()));
   }
   else
   {
     pimpl->ubus.SendMessage(UBUS_LAUNCHER_START_KEY_SWITCHER,
-                            g_variant_new_int32(pimpl->keyboard_launcher_->monitor));
+                            glib::Variant(pimpl->keyboard_launcher_->monitor()));
   }
 
   AbstractLauncherIcon::Ptr const& selected = pimpl->model_->Selection();
@@ -1325,7 +1324,7 @@
   if (selected)
   {
     pimpl->ubus.SendMessage(UBUS_LAUNCHER_SELECTION_CHANGED,
-                            g_variant_new_string(selected->tooltip_text().c_str()));
+                            glib::Variant(selected->tooltip_text()));
   }
 }
 
@@ -1338,7 +1337,7 @@
   if (selected)
   {
     pimpl->ubus.SendMessage(UBUS_LAUNCHER_SELECTION_CHANGED,
-                            g_variant_new_string(selected->tooltip_text().c_str()));
+                            glib::Variant(selected->tooltip_text()));
   }
 }
 
@@ -1351,7 +1350,7 @@
   if (selected)
   {
     pimpl->ubus.SendMessage(UBUS_LAUNCHER_SELECTION_CHANGED,
-                            g_variant_new_string(selected->tooltip_text().c_str()));
+                            glib::Variant(selected->tooltip_text()));
   }
 }
 
@@ -1376,12 +1375,12 @@
     pimpl->launcher_event_outside_connection_->disconnect();
     pimpl->launcher_grabbed = false;
     pimpl->ubus.SendMessage(UBUS_LAUNCHER_END_KEY_NAV,
-                            g_variant_new_boolean(pimpl->keynav_restore_window_));
+                            glib::Variant(pimpl->keynav_restore_window_));
   }
   else
   {
     pimpl->ubus.SendMessage(UBUS_LAUNCHER_END_KEY_SWITCHER,
-                            g_variant_new_boolean(pimpl->keynav_restore_window_));
+                            glib::Variant(pimpl->keynav_restore_window_));
   }
 
   if (activate)

=== modified file 'launcher/QuicklistView.cpp'
--- launcher/QuicklistView.cpp	2013-10-03 22:31:18 +0000
+++ launcher/QuicklistView.cpp	2013-11-06 08:52:17 +0000
@@ -1303,6 +1303,7 @@
     .add(GetAbsoluteGeometry())
     .add("base_x", GetBaseX())
     .add("base_y", GetBaseY())
+    .add("base", nux::Point(GetBaseX(), GetBaseY()))
     .add("active", IsVisible());
 }
 

=== modified file 'launcher/SwitcherController.cpp'
--- launcher/SwitcherController.cpp	2013-10-02 23:36:48 +0000
+++ launcher/SwitcherController.cpp	2013-11-06 08:52:17 +0000
@@ -395,7 +395,7 @@
     }
 
     ubus_manager_.SendMessage(UBUS_SWITCHER_SELECTION_CHANGED,
-                              g_variant_new_string(icon->tooltip_text().c_str()));
+                              glib::Variant(icon->tooltip_text()));
   }
 }
 
@@ -497,7 +497,7 @@
     }
   }
 
-  ubus_manager_.SendMessage(UBUS_SWITCHER_END, g_variant_new_boolean(!accept_state));
+  ubus_manager_.SendMessage(UBUS_SWITCHER_END, glib::Variant(!accept_state));
   ubus_manager_.SendMessage(UBUS_SWITCHER_SHOWN, g_variant_new("(bi)", false, obj_->monitor_));
 
   sources_.Remove(VIEW_CONSTRUCT_IDLE);

=== modified file 'launcher/Tooltip.cpp'
--- launcher/Tooltip.cpp	2013-10-03 22:30:57 +0000
+++ launcher/Tooltip.cpp	2013-11-06 08:52:17 +0000
@@ -559,11 +559,8 @@
 {
   variant::BuilderWrapper(builder)
     .add("text", text)
-    .add("x", GetBaseX())
-    .add("y", GetBaseY())
-    .add("width", GetBaseWidth())
-    .add("height", GetBaseHeight())
-    .add("active", IsVisible());
+    .add("active", IsVisible())
+    .add(GetAbsoluteGeometry());
 }
 
 } // namespace nux

=== modified file 'panel/PanelIndicatorEntryView.cpp'
--- panel/PanelIndicatorEntryView.cpp	2013-05-17 16:02:09 +0000
+++ panel/PanelIndicatorEntryView.cpp	2013-11-06 08:52:17 +0000
@@ -664,6 +664,7 @@
   .add("menu_y", proxy_->geometry().y)
   .add("menu_width", proxy_->geometry().width)
   .add("menu_height", proxy_->geometry().height)
+  .add("menu_geo", proxy_->geometry())
   .add("focused", IsFocused());
 }
 

=== removed file 'plugins/unityshell/src/AggregateMonitor.cpp'
--- plugins/unityshell/src/AggregateMonitor.cpp	2012-03-14 06:24:18 +0000
+++ plugins/unityshell/src/AggregateMonitor.cpp	1970-01-01 00:00:00 +0000
@@ -1,63 +0,0 @@
-// -*- Mode: C++; indent-tabs-mode: nil; tab-width: 2 -*-
-/*
-* Copyright (C) 2011 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: Alex Launi <[e-mail]>
-*/
-
-#include "AggregateMonitor.h"
-#include "ElapsedTimeMonitor.h"
-#include <UnityCore/Variant.h>
-
-namespace unity {
-namespace performance {
-
-AggregateMonitor::AggregateMonitor()
-{
-  _monitors.push_back(new ElapsedTimeMonitor());
-}
-
-AggregateMonitor::~AggregateMonitor()
-{
-}
-
-std::string AggregateMonitor::GetName() const
-{
-  return "AggregateMonitor";
-}
-
-void AggregateMonitor::StartMonitor()
-{
-  for (std::list<Monitor*>::iterator iter = _monitors.begin(), end = _monitors.end();
-       iter != end; ++iter)
-  {
-    Monitor* monitor = *iter;
-    monitor->Start();
-  }
-}
-
-void AggregateMonitor::StopMonitor(GVariantBuilder* builder)
-{
-  variant::BuilderWrapper wrapper(builder);
-  for (std::list<Monitor*>::iterator iter = _monitors.begin(), end = _monitors.end();
-       iter != end; ++iter)
-  {
-    Monitor* monitor = *iter;
-    wrapper.add(monitor->GetName().c_str(), monitor->Stop());
-  }
-}
-
-}
-}

=== removed file 'plugins/unityshell/src/AggregateMonitor.h'
--- plugins/unityshell/src/AggregateMonitor.h	2011-12-08 04:24:00 +0000
+++ plugins/unityshell/src/AggregateMonitor.h	1970-01-01 00:00:00 +0000
@@ -1,50 +0,0 @@
-// -*- Mode: C++; indent-tabs-mode: nil; tab-width: 2 -*-
-/*
-* Copyright (C) 2011 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: Alex Launi <[e-mail]>
-*/
-
-#ifndef UNITY_PERFORMANCE_AGGREGATE_MONITOR
-#define UNITY_PERFORMANCE_AGGREGATE_MONITOR
-
-#include <list>
-#include <string>
-#include <gio/gio.h>
-
-#include "Monitor.h"
-
-namespace unity {
-namespace performance {
-
-class AggregateMonitor : public Monitor
-{
-public:
-  AggregateMonitor();
-  ~AggregateMonitor();
-  std::string GetName() const;
-
-protected:
-  void StartMonitor();
-  void StopMonitor(GVariantBuilder* builder);
-
-private:
-  std::list<Monitor*> _monitors;
-};
-
-}
-}
-
-#endif // UNITY_PERFORMANCE_AGGREGATE_MONITOR

=== removed file 'plugins/unityshell/src/ElapsedTimeMonitor.cpp'
--- plugins/unityshell/src/ElapsedTimeMonitor.cpp	2012-11-30 20:22:13 +0000
+++ plugins/unityshell/src/ElapsedTimeMonitor.cpp	1970-01-01 00:00:00 +0000
@@ -1,49 +0,0 @@
-// -*- Mode: C++; indent-tabs-mode: nil; tab-width: 2 -*-
-/*
-* Copyright (C) 2011 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: Alex Launi <[e-mail]>
-*/
-
-#include <UnityCore/Variant.h>
-
-#include "ElapsedTimeMonitor.h"
-#include "TimeUtil.h"
-
-namespace unity{
-namespace performance {
-
-std::string ElapsedTimeMonitor::GetName() const
-{
-  return "ElapsedTimeMonitor";
-}
-
-void ElapsedTimeMonitor::StartMonitor()
-{
-  clock_gettime(CLOCK_MONOTONIC, &_start);
-}
-
-void ElapsedTimeMonitor::StopMonitor(GVariantBuilder* builder)
-{
-  struct timespec current;
-  clock_gettime(CLOCK_MONOTONIC, &current);
-  DeltaTime diff = TimeUtil::TimeDelta(&current, &_start);
-
-  variant::BuilderWrapper(builder)
-    .add("elapsed-time", diff);
-}
-
-}
-}

=== removed file 'plugins/unityshell/src/ElapsedTimeMonitor.h'
--- plugins/unityshell/src/ElapsedTimeMonitor.h	2011-11-08 18:21:44 +0000
+++ plugins/unityshell/src/ElapsedTimeMonitor.h	1970-01-01 00:00:00 +0000
@@ -1,47 +0,0 @@
-// -*- Mode: C++; indent-tabs-mode: nil; tab-width: 2 -*-
-/*
-* Copyright (C) 2011 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: Alex Launi <[e-mail]>
-*/
-
-#ifndef UNITY_PERFORMANCE_ELAPSED_TIME_MONITOR
-#define UNITY_PERFORMANCE_ELAPSED_TIME_MONITOR
-
-#include <glib.h>
-#include <time.h>
-
-#include "Monitor.h"
-
-namespace unity {
-namespace performance {
-
-class ElapsedTimeMonitor : public Monitor
-{
-public:
-  std::string GetName() const;
-
-protected:
-  void StartMonitor();
-  void StopMonitor(GVariantBuilder* builder);
-
-private:
-  struct timespec _start;
-};
-
-}
-}
-
-#endif // UNITY_PERFORMANCE_ELAPSED_TIME_MONITOR

=== modified file 'plugins/unityshell/src/unityshell.cpp'
--- plugins/unityshell/src/unityshell.cpp	2013-10-22 16:17:43 +0000
+++ plugins/unityshell/src/unityshell.cpp	2013-11-06 08:52:17 +0000
@@ -745,9 +745,9 @@
         unsigned int oldGlAddGeometryIndex = uTrayWindow->gWindow->glAddGeometryGetCurrentIndex ();
         unsigned int oldGlDrawIndex = uTrayWindow->gWindow->glDrawGetCurrentIndex ();
 
-        attrib.opacity = OPAQUE;
-        attrib.brightness = BRIGHT;
-        attrib.saturation = COLOR;
+        attrib.opacity = COMPIZ_COMPOSITE_OPAQUE;
+        attrib.brightness = COMPIZ_COMPOSITE_BRIGHT;
+        attrib.saturation = COMPIZ_COMPOSITE_COLOR;
 
         oTransform.toScreenSpace (output, -DEFAULT_Z_CAMERA);
 
@@ -3504,6 +3504,7 @@
     .add("vertically_maximized", wm.IsWindowVerticallyMaximized(xid))
     .add("minimized", wm.IsWindowMinimized(xid))
     .add("scaled", scaled)
+    .add("scaled_close_geo", close_button_geo_)
     .add("scaled_close_x", close_button_geo_.x)
     .add("scaled_close_y", close_button_geo_.y)
     .add("scaled_close_width", close_button_geo_.width)

=== modified file 'plugins/unityshell/src/unityshell.h'
--- plugins/unityshell/src/unityshell.h	2013-10-21 21:57:54 +0000
+++ plugins/unityshell/src/unityshell.h	2013-11-06 08:52:17 +0000
@@ -32,9 +32,22 @@
 #include <scale/scale.h>
 #include <core/core.h>
 #include <core/pluginclasshandler.h>
-#include <composite/composite.h>
 #include <opengl/opengl.h>
 
+// These fixes some definitions from the composite header
+#ifdef COLOR
+#define COMPIZ_COMPOSITE_COLOR 0xffff
+#undef COLOR
+#endif
+#ifdef OPAQUE
+#define COMPIZ_COMPOSITE_OPAQUE 0xffff
+#undef OPAQUE
+#endif
+#ifdef BRIGHT
+#define COMPIZ_COMPOSITE_BRIGHT 0xffff
+#undef BRIGHT
+#endif
+
 #include "unityshell_options.h"
 
 #include "Introspectable.h"

=== modified file 'shutdown/SessionButton.cpp'
--- shutdown/SessionButton.cpp	2013-03-19 14:54:43 +0000
+++ shutdown/SessionButton.cpp	2013-11-06 08:52:17 +0000
@@ -130,6 +130,7 @@
   unity::variant::BuilderWrapper(builder)
     .add("highlighted", highlighted())
     .add("label", label())
+    .add("label_color", label_view_->GetTextColor())
     .add("label_visible", label_view_->GetTextColor() != nux::color::Transparent);
 }
 

=== modified file 'tests/test_glib_variant.cpp'
--- tests/test_glib_variant.cpp	2013-08-23 17:36:51 +0000
+++ tests/test_glib_variant.cpp	2013-11-06 08:52:17 +0000
@@ -71,6 +71,121 @@
   EXPECT_FALSE(IsFloating(v));
 }
 
+TEST(TestGLibVariant, ConstructNullptr)
+{
+  Variant v(nullptr);
+  EXPECT_FALSE(v);
+}
+
+TEST(TestGLibVariant, ConstructNull)
+{
+  GVariant* value = NULL;
+  Variant v(value);
+  EXPECT_FALSE(v);
+}
+
+TEST(TestGLibVariant, ConstructString)
+{
+  std::string value = "UnityVariant";
+  Variant v(value);
+  EXPECT_EQ(value, g_variant_get_string(v, nullptr));
+}
+
+TEST(TestGLibVariant, ConstructCharString)
+{
+  const char* value = "UnityVariantCharStr";
+  Variant v(value);
+  EXPECT_STREQ(value, g_variant_get_string(v, nullptr));
+}
+
+TEST(TestGLibVariant, ConstructByte)
+{
+  unsigned char value = g_random_int_range(0, 256);
+  Variant v(value);
+  EXPECT_EQ(value, g_variant_get_byte(v));
+}
+
+TEST(TestGLibVariant, ConstructInt16)
+{
+  int16_t value = g_random_int_range(G_MININT16, G_MAXINT16);
+  Variant v(value);
+  EXPECT_EQ(value, g_variant_get_int16(v));
+}
+
+TEST(TestGLibVariant, ConstructUInt16)
+{
+  uint16_t value = g_random_int_range(0, G_MAXUINT16);
+  Variant v(value);
+  EXPECT_EQ(value, g_variant_get_uint16(v));
+}
+
+TEST(TestGLibVariant, ConstructInt32)
+{
+  int32_t value = g_random_int_range(G_MININT32, G_MAXINT32);
+  Variant v(value);
+  EXPECT_EQ(value, g_variant_get_int32(v));
+}
+
+TEST(TestGLibVariant, ConstructUInt32)
+{
+  uint32_t value = g_random_int();
+  Variant v(value);
+  EXPECT_EQ(value, g_variant_get_uint32(v));
+}
+
+TEST(TestGLibVariant, ConstructInt64)
+{
+  int64_t value = g_random_int_range(G_MININT, G_MAXINT);
+  Variant v(value);
+  EXPECT_EQ(value, g_variant_get_int64(v));
+}
+
+TEST(TestGLibVariant, ConstructUInt64)
+{
+  uint64_t value = g_random_int();
+  Variant v(value);
+  EXPECT_EQ(value, g_variant_get_uint64(v));
+}
+
+TEST(TestGLibVariant, ConstructBool)
+{
+  bool value = g_random_int();
+  Variant v(value);
+  EXPECT_EQ(value, g_variant_get_boolean(v));
+}
+
+TEST(TestGLibVariant, ConstructDouble)
+{
+  double value = g_random_int();
+  Variant v(value);
+  EXPECT_DOUBLE_EQ(value, g_variant_get_double(v));
+}
+
+TEST(TestGLibVariant, ConstructFloat)
+{
+  float value = g_random_int();
+  Variant v(value);
+  EXPECT_FLOAT_EQ(value, static_cast<float>(g_variant_get_double(v)));
+}
+
+TEST(TestGLibVariant, ConstructNumericInt)
+{
+  Variant v0(0);
+  EXPECT_EQ(0, v0.GetInt32());
+
+  Variant v1(123456789);
+  EXPECT_EQ(123456789, v1.GetInt32());
+}
+
+TEST(TestGLibVariant, ConstructNumericDouble)
+{
+  Variant v0(0.0f);
+  EXPECT_EQ(0.0f, v0.GetDouble());
+
+  Variant v1(0.987654321);
+  EXPECT_EQ(0.987654321, v1.GetDouble());
+}
+
 TEST(TestGLibVariant, Copy)
 {
   Variant v1 (g_variant_new_string ("bar"));
@@ -108,6 +223,179 @@
   EXPECT_TRUE(ValuesEqual(v, raw_variant));
 }
 
+TEST(TestGLibVariant, ConstructHintsMap)
+{
+  Variant v({
+    {"charstring-key", g_variant_new_string("charstring-value")},
+    {"string-key", g_variant_new_string(std::string("string-value").c_str())},
+    {"gint32-key", g_variant_new_int32(-1)},
+    {"guint32-key", g_variant_new_uint32(2)},
+    {"gint64-key", g_variant_new_int64(-3)},
+    {"guint64-key", g_variant_new_uint64(4)},
+    {"float-key", g_variant_new_double((float)1.1)},
+    {"double-key", g_variant_new_double(2.2)},
+    {"bool-key", g_variant_new_boolean(true)},
+    {"variant-key", g_variant_new_int32(123)}
+  });
+
+  EXPECT_EQ("charstring-value", Variant(g_variant_lookup_value(v, "charstring-key", nullptr)).GetString());
+  EXPECT_EQ("string-value", Variant(g_variant_lookup_value(v, "string-key", nullptr)).GetString());
+  EXPECT_EQ(-1, Variant(g_variant_lookup_value(v, "gint32-key", nullptr)).GetInt32());
+  EXPECT_EQ(2, Variant(g_variant_lookup_value(v, "guint32-key", nullptr)).GetUInt32());
+  EXPECT_EQ(-3, Variant(g_variant_lookup_value(v, "gint64-key", nullptr)).GetInt64());
+  EXPECT_EQ(4, Variant(g_variant_lookup_value(v, "guint64-key", nullptr)).GetUInt64());
+  EXPECT_FLOAT_EQ(1.1, Variant(g_variant_lookup_value(v, "float-key", nullptr)).GetFloat());
+  EXPECT_DOUBLE_EQ(2.2, Variant(g_variant_lookup_value(v, "double-key", nullptr)).GetDouble());
+  EXPECT_EQ(true, Variant(g_variant_lookup_value(v, "bool-key", nullptr)).GetBool());
+  EXPECT_EQ(123, Variant(g_variant_lookup_value(v, "variant-key", nullptr)).GetInt32());
+}
+
+TEST(TestGLibVariant, AssignString)
+{
+  std::string value = "UnityVariant";
+  Variant v;
+  v = value;
+  EXPECT_EQ(value, g_variant_get_string(v, nullptr));
+}
+
+TEST(TestGLibVariant, AssignCharString)
+{
+  const char* value = "UnityVariantCharStr";
+  Variant v;
+  v = value;
+  EXPECT_STREQ(value, g_variant_get_string(v, nullptr));
+}
+
+TEST(TestGLibVariant, AssignByte)
+{
+  unsigned char value = g_random_int_range(0, 256);
+  Variant v;
+  v = value;
+  EXPECT_EQ(value, g_variant_get_byte(v));
+}
+
+TEST(TestGLibVariant, AssignInt16)
+{
+  int16_t value = g_random_int_range(G_MININT16, G_MAXINT16);
+  Variant v;
+  v = value;
+  EXPECT_EQ(value, g_variant_get_int16(v));
+}
+
+TEST(TestGLibVariant, AssignUInt16)
+{
+  uint16_t value = g_random_int_range(0, G_MAXUINT16);
+  Variant v;
+  v = value;
+  EXPECT_EQ(value, g_variant_get_uint16(v));
+}
+
+TEST(TestGLibVariant, AssignInt32)
+{
+  int32_t value = g_random_int_range(G_MININT32, G_MAXINT32);
+  Variant v;
+  v = value;
+  EXPECT_EQ(value, g_variant_get_int32(v));
+}
+
+TEST(TestGLibVariant, AssignUInt32)
+{
+  uint32_t value = g_random_int();
+  Variant v;
+  v = value;
+  EXPECT_EQ(value, g_variant_get_uint32(v));
+}
+
+TEST(TestGLibVariant, AssignInt64)
+{
+  int64_t value = g_random_int_range(G_MININT, G_MAXINT);
+  Variant v;
+  v = value;
+  EXPECT_EQ(value, g_variant_get_int64(v));
+}
+
+TEST(TestGLibVariant, AssignUInt64)
+{
+  uint64_t value = g_random_int();
+  Variant v;
+  v = value;
+  EXPECT_EQ(value, g_variant_get_uint64(v));
+}
+
+TEST(TestGLibVariant, AssignBool)
+{
+  bool value = g_random_int();
+  Variant v;
+  v = value;
+  EXPECT_EQ(value, g_variant_get_boolean(v));
+}
+
+TEST(TestGLibVariant, AssignDouble)
+{
+  double value = g_random_int();
+  Variant v;
+  v = value;
+  EXPECT_DOUBLE_EQ(value, g_variant_get_double(v));
+}
+
+TEST(TestGLibVariant, AssignFloat)
+{
+  float value = g_random_int();
+  Variant v;
+  v = value;
+  EXPECT_FLOAT_EQ(value, static_cast<float>(g_variant_get_double(v)));
+}
+
+TEST(TestGLibVariant, AssignNumericInt)
+{
+  Variant v0;
+  v0 = 0;
+  EXPECT_EQ(0, v0.GetInt32());
+
+  Variant v1;
+  v1 = 123456789;
+  EXPECT_EQ(123456789, v1.GetInt32());
+}
+
+TEST(TestGLibVariant, AssignNumericDouble)
+{
+  Variant v0;
+  v0 = 0.0f;
+  EXPECT_EQ(0.0f, v0.GetDouble());
+
+  Variant v1;
+  v1 = 0.987654321;
+  EXPECT_EQ(0.987654321, v1.GetDouble());
+}
+
+TEST(TestGLibVariant, AssignHintsMap)
+{
+  Variant v;
+  v = {
+    {"charstring-key", g_variant_new_string("charstring-value")},
+    {"string-key", g_variant_new_string(std::string("string-value").c_str())},
+    {"gint32-key", g_variant_new_int32(-1)},
+    {"guint32-key", g_variant_new_uint32(2)},
+    {"gint64-key", g_variant_new_int64(-3)},
+    {"guint64-key", g_variant_new_uint64(4)},
+    {"float-key", g_variant_new_double((float)1.1)},
+    {"double-key", g_variant_new_double(2.2)},
+    {"bool-key", g_variant_new_boolean(true)},
+    {"variant-key", g_variant_new_int32(123)}
+  };
+
+  EXPECT_EQ("charstring-value", Variant(g_variant_lookup_value(v, "charstring-key", nullptr)).GetString());
+  EXPECT_EQ("string-value", Variant(g_variant_lookup_value(v, "string-key", nullptr)).GetString());
+  EXPECT_EQ(-1, Variant(g_variant_lookup_value(v, "gint32-key", nullptr)).GetInt32());
+  EXPECT_EQ(2, Variant(g_variant_lookup_value(v, "guint32-key", nullptr)).GetUInt32());
+  EXPECT_EQ(-3, Variant(g_variant_lookup_value(v, "gint64-key", nullptr)).GetInt64());
+  EXPECT_EQ(4, Variant(g_variant_lookup_value(v, "guint64-key", nullptr)).GetUInt64());
+  EXPECT_FLOAT_EQ(1.1, Variant(g_variant_lookup_value(v, "float-key", nullptr)).GetFloat());
+  EXPECT_DOUBLE_EQ(2.2, Variant(g_variant_lookup_value(v, "double-key", nullptr)).GetDouble());
+  EXPECT_EQ(true, Variant(g_variant_lookup_value(v, "bool-key", nullptr)).GetBool());
+  EXPECT_EQ(123, Variant(g_variant_lookup_value(v, "variant-key", nullptr)).GetInt32());
+}
+
 TEST(TestGLibVariant, KeepsRef)
 {
   GVariant *gv = g_variant_new_int32 (456);
@@ -141,17 +429,16 @@
   GVariantBuilder b;
 
   g_variant_builder_init (&b, G_VARIANT_TYPE ("a{sv}"));
-  variant::BuilderWrapper bw (&b);
-  bw.add ("charstring-key", "charstring-value");
-  bw.add ("string-key", std::string("string-value"));
-  bw.add ("gint32-key", (gint32)-1);
-  bw.add ("guint32-key", (guint32)-2);
-  bw.add ("gint64-key", (gint64)-3);
-  bw.add ("guint64-key", (guint64)-4);
-  bw.add ("float-key", (float)1.1);
-  bw.add ("double-key", (double)2.2);
-  bw.add ("bool-key", true);
-  bw.add ("variant-key", g_variant_new_int32(123));
+  g_variant_builder_add(&b, "{sv}", "charstring-key", g_variant_new_string("charstring-value"));
+  g_variant_builder_add(&b, "{sv}", "string-key", g_variant_new_string(std::string("string-value").c_str()));
+  g_variant_builder_add(&b, "{sv}", "gint32-key", g_variant_new_int32(-1));
+  g_variant_builder_add(&b, "{sv}", "guint32-key", g_variant_new_uint32(-2));
+  g_variant_builder_add(&b, "{sv}", "gint64-key", g_variant_new_int64(-3));
+  g_variant_builder_add(&b, "{sv}", "guint64-key", g_variant_new_uint64(-4));
+  g_variant_builder_add(&b, "{sv}", "float-key", g_variant_new_double((float)1.1));
+  g_variant_builder_add(&b, "{sv}", "double-key", g_variant_new_double(2.2));
+  g_variant_builder_add(&b, "{sv}", "bool-key", g_variant_new_boolean(true));
+  g_variant_builder_add(&b, "{sv}", "variant-key", g_variant_new_int32(123));
 
   GVariant *dict_variant = g_variant_builder_end (&b);
   Variant dict (g_variant_new_tuple (&dict_variant, 1));
@@ -208,13 +495,76 @@
   EXPECT_EQ(v5.GetString(), "Yeah!!!");
 }
 
+TEST(TestGLibVariant, GetByte)
+{
+  guchar value = g_random_int_range(0, 256);
+  Variant v1(g_variant_new_byte(value));
+  EXPECT_EQ(v1.GetByte(), value);
+
+  value = g_random_int_range(0, 256);
+  Variant v2(g_variant_new("(y)", value));
+  EXPECT_EQ(v2.GetByte(), value);
+
+  Variant v3(g_variant_new("(ny)", value, "fooostring"));
+  EXPECT_EQ(v3.GetByte(), 0);
+
+  Variant v4;
+  EXPECT_EQ(v4.GetByte(), 0);
+
+  value = g_random_int_range(0, 256);
+  Variant v5(g_variant_new_variant(g_variant_new_byte(value)));
+  EXPECT_EQ(v5.GetByte(), value);
+}
+
+TEST(TestGLibVariant, GetInt16)
+{
+  gint16 value = g_random_int_range(G_MININT16, G_MAXINT16);
+  Variant v1(g_variant_new_int16(value));
+  EXPECT_EQ(v1.GetInt16(), value);
+
+  value = g_random_int_range(G_MININT16, G_MAXINT16);
+  Variant v2(g_variant_new("(n)", value));
+  EXPECT_EQ(v2.GetInt16(), value);
+
+  Variant v3(g_variant_new("(ns)", value, "fooostring"));
+  EXPECT_EQ(v3.GetInt16(), 0);
+
+  Variant v4;
+  EXPECT_EQ(v4.GetInt16(), 0);
+
+  value = g_random_int_range(G_MININT16, G_MAXINT16);
+  Variant v5(g_variant_new_variant(g_variant_new_int16(value)));
+  EXPECT_EQ(v5.GetInt16(), value);
+}
+
+TEST(TestGLibVariant, GetUInt16)
+{
+  guint16 value = g_random_int();
+  Variant v1(g_variant_new_uint16(value));
+  EXPECT_EQ(v1.GetUInt16(), value);
+
+  value = g_random_int();
+  Variant v2(g_variant_new("(q)", value));
+  EXPECT_EQ(v2.GetUInt16(), value);
+
+  Variant v3(g_variant_new("(qi)", value, G_MAXINT16));
+  EXPECT_EQ(v3.GetUInt16(), 0);
+
+  Variant v4;
+  EXPECT_EQ(v4.GetUInt16(), 0);
+
+  value = g_random_int();
+  Variant v5(g_variant_new_variant(g_variant_new_uint16(value)));
+  EXPECT_EQ(v5.GetUInt16(), value);
+}
+
 TEST(TestGLibVariant, GetInt32)
 {
-  gint32 value = g_random_int_range(G_MININT, G_MAXINT);
+  gint32 value = g_random_int_range(G_MININT32, G_MAXINT32);
   Variant v1(g_variant_new_int32(value));
   EXPECT_EQ(v1.GetInt32(), value);
 
-  value = g_random_int_range(G_MININT, G_MAXINT);
+  value = g_random_int_range(G_MININT32, G_MAXINT32);
   Variant v2(g_variant_new("(i)", value));
   EXPECT_EQ(v2.GetInt32(), value);
 
@@ -224,7 +574,7 @@
   Variant v4;
   EXPECT_EQ(v4.GetInt32(), 0);
 
-  value = g_random_int_range(G_MININT, G_MAXINT);
+  value = g_random_int_range(G_MININT32, G_MAXINT32);
   Variant v5(g_variant_new_variant(g_variant_new_int32(value)));
   EXPECT_EQ(v5.GetInt32(), value);
 }
@@ -239,7 +589,7 @@
   Variant v2(g_variant_new("(u)", value));
   EXPECT_EQ(v2.GetUInt32(), value);
 
-  Variant v3(g_variant_new("(ui)", value, G_MAXINT));
+  Variant v3(g_variant_new("(ui)", value, G_MAXUINT32));
   EXPECT_EQ(v3.GetUInt32(), 0);
 
   Variant v4;
@@ -250,6 +600,48 @@
   EXPECT_EQ(v5.GetUInt32(), value);
 }
 
+TEST(TestGLibVariant, GetInt64)
+{
+  gint64 value = g_random_int_range(G_MININT, G_MAXINT);
+  Variant v1(g_variant_new_int64(value));
+  EXPECT_EQ(v1.GetInt64(), value);
+
+  value = g_random_int_range(G_MININT, G_MAXINT);
+  Variant v2(g_variant_new("(x)", value));
+  EXPECT_EQ(v2.GetInt64(), value);
+
+  Variant v3(g_variant_new("(xs)", value, "fooostring"));
+  EXPECT_EQ(v3.GetInt64(), 0);
+
+  Variant v4;
+  EXPECT_EQ(v4.GetInt64(), 0);
+
+  value = g_random_int_range(G_MININT, G_MAXINT);
+  Variant v5(g_variant_new_variant(g_variant_new_int64(value)));
+  EXPECT_EQ(v5.GetInt64(), value);
+}
+
+TEST(TestGLibVariant, GetUInt64)
+{
+  guint64 value = g_random_int();
+  Variant v1(g_variant_new_uint64(value));
+  EXPECT_EQ(v1.GetUInt64(), value);
+
+  value = g_random_int();
+  Variant v2(g_variant_new("(t)", value));
+  EXPECT_EQ(v2.GetUInt64(), value);
+
+  Variant v3(g_variant_new("(ti)", value, G_MAXINT64));
+  EXPECT_EQ(v3.GetUInt64(), 0);
+
+  Variant v4;
+  EXPECT_EQ(v4.GetUInt64(), 0);
+
+  value = g_random_int();
+  Variant v5(g_variant_new_variant(g_variant_new_uint64(value)));
+  EXPECT_EQ(v5.GetUInt64(), value);
+}
+
 TEST(TestGLibVariant, GetBool)
 {
   gboolean value = (g_random_int() % 2) ? TRUE : FALSE;

=== modified file 'tests/test_panel_menu_view.cpp'
--- tests/test_panel_menu_view.cpp	2013-10-14 17:36:51 +0000
+++ tests/test_panel_menu_view.cpp	2013-11-06 08:52:17 +0000
@@ -81,7 +81,7 @@
   UBusManager ubus;
   ubus.SendMessage(UBUS_LAUNCHER_START_KEY_NAV);
   ubus.SendMessage(UBUS_LAUNCHER_SELECTION_CHANGED,
-                   g_variant_new_string(escapedText));
+                   glib::Variant(escapedText));
   Utils::WaitUntilMSec([this] {return menu_view.GetCurrentTitle() == escapedText;});
 
 

=== modified file 'tests/test_results.cpp'
--- tests/test_results.cpp	2013-07-10 16:07:04 +0000
+++ tests/test_results.cpp	2013-11-06 08:52:17 +0000
@@ -279,8 +279,8 @@
   local_result_1.comment = "comment";
   local_result_1.dnd_uri = "dnd_uri";
   
-  local_result_1.hints["key1"] = g_variant_new_string("value1");
-  local_result_1.hints["key2"] = g_variant_new_string("value2");
+  local_result_1.hints["key1"] = glib::Variant("value1");
+  local_result_1.hints["key2"] = glib::Variant("value2");
 
   glib::Variant variant_value = local_result_1.Variant();
   LocalResult local_result_2 = LocalResult::FromVariant(variant_value);

=== modified file 'unity-shared/DebugDBusInterface.cpp'
--- unity-shared/DebugDBusInterface.cpp	2013-10-29 20:50:07 +0000
+++ unity-shared/DebugDBusInterface.cpp	2013-11-06 08:52:17 +0000
@@ -1,6 +1,6 @@
 // -*- Mode: C++; indent-tabs-mode: nil; tab-width: 2 -*-
 /*
- * Copyright (C) 2010 Canonical Ltd
+ * Copyright (C) 2010-2013 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
@@ -15,20 +15,16 @@
  * along with this program.  If not, see <http://www.gnu.org/licenses/>.
  *
  * Authored by: Alex Launi <[e-mail]>
+ *              Thomi Richards <[e-mail]>
+ *              Marco Trevisan <[e-mail]>
  */
 
-#include <queue>
-#include <iostream>
 #include <fstream>
 #include <sstream>
-#include <iostream>
 #include <boost/algorithm/string.hpp>
-#include <boost/algorithm/string/split.hpp>
-#include <boost/algorithm/string/classification.hpp>
-#include <boost/bind.hpp>
 #include <NuxCore/Logger.h>
 #include <NuxCore/LoggingWriter.h>
-#include <xpathselect/node.h>
+#include <UnityCore/Variant.h>
 #include <xpathselect/xpathselect.h>
 #include <dlfcn.h>
 
@@ -45,17 +41,25 @@
 {
 namespace local
 {
+  const std::string PROTOCOL_VERSION = "1.4";
+  const std::string XPATH_SELECT_LIB = "libxpathselect.so.1.4";
+
   std::ofstream output_file;
-  void* xpathselect_driver_ = NULL;
+  void* xpathselect_driver_ = nullptr;
 
-  class IntrospectableAdapter: public xpathselect::Node
+  class IntrospectableAdapter : public std::enable_shared_from_this<IntrospectableAdapter>, public xpathselect::Node
   {
   public:
-    typedef std::shared_ptr<IntrospectableAdapter> Ptr;
-    IntrospectableAdapter(Introspectable* node, std::string const& parent_path)
-    : node_(node)
+    typedef std::shared_ptr<IntrospectableAdapter const> Ptr;
+    IntrospectableAdapter(Introspectable* node, IntrospectableAdapter::Ptr const& parent = nullptr)
+      : node_(node)
+      , parent_(parent)
+      , full_path_((parent_ ? parent_->GetPath() : "") + "/" + GetName())
+    {}
+
+    int32_t GetId() const
     {
-      full_path_ = parent_path + "/" + GetName();
+      return node_->GetIntrospectionId();
     }
 
     std::string GetName() const
@@ -68,145 +72,124 @@
       return full_path_;
     }
 
-    bool MatchProperty(const std::string& name, const std::string& value) const
-    {
-      bool matches = false;
-
-      GVariantBuilder  child_builder;
-      g_variant_builder_init(&child_builder, G_VARIANT_TYPE("a{sv}"));
-      g_variant_builder_add(&child_builder, "{sv}", "id", g_variant_new_uint64(node_->GetIntrospectionId()));
-      node_->AddProperties(&child_builder);
-      GVariant* prop_dict = g_variant_builder_end(&child_builder);
-      GVariant *prop_value = g_variant_lookup_value(prop_dict, name.c_str(), NULL);
-
-      if (prop_value != NULL)
+    Node::Ptr GetParent() const
+    {
+      return parent_;
+    }
+
+    bool MatchStringProperty(std::string const& name, std::string const& value) const
+    {
+      auto const& prop_value = GetPropertyValue(name);
+
+      if (prop_value)
+      {
+        if (!g_variant_is_of_type(prop_value, G_VARIANT_TYPE_STRING))
+        {
+          LOG_WARNING(logger) << "Unable to match '"<< name << "', it's not a string property.";
+          return false;
+        }
+
+        return (prop_value.GetString() == value);
+      }
+
+      return false;
+    }
+
+    bool MatchBooleanProperty(std::string const& name, bool value) const
+    {
+      auto const& prop_value = GetPropertyValue(name);
+
+      if (prop_value)
+      {
+        if (!g_variant_is_of_type(prop_value, G_VARIANT_TYPE_BOOLEAN))
+        {
+          LOG_WARNING(logger) << "Unable to match '"<< name << "', it's not a boolean property.";
+          return false;
+        }
+
+        return (prop_value.GetBool() == value);
+      }
+
+      return false;
+    }
+
+    bool MatchIntegerProperty(std::string const& name, int32_t value) const
+    {
+      auto const& prop_value = GetPropertyValue(name);
+
+      if (prop_value)
       {
         GVariantClass prop_val_type = g_variant_classify(prop_value);
-        // it'd be nice to be able to do all this with one method. However, the booleans need
-        // special treatment, and I can't figure out how to group all the integer types together
-        // without resorting to template functions.... and we all know what happens when you
-        // start doing that...
+        // it'd be nice to be able to do all this with one method.
+        // I can't figure out how to group all the integer types together
         switch (prop_val_type)
         {
-          case G_VARIANT_CLASS_STRING:
-          {
-            const gchar* prop_val = g_variant_get_string(prop_value, NULL);
-            if (g_strcmp0(prop_val, value.c_str()) == 0)
-            {
-              matches = true;
-            }
-          }
-          break;
-          case G_VARIANT_CLASS_BOOLEAN:
-          {
-            std::string value = boost::to_upper_copy(value);
-            bool p = value == "TRUE" ||
-                      value == "ON" ||
-                      value == "YES" ||
-                      value == "1";
-            matches = (g_variant_get_boolean(prop_value) == p);
-          }
-          break;
           case G_VARIANT_CLASS_BYTE:
-          {
-            // It would be nice if I could do all the integer types together, but I couldn't see how...
-            std::stringstream stream(value);
-            int val; // changing this to guchar causes problems.
-            stream >> val;
-            matches = (stream.rdstate() & (stream.badbit|stream.failbit)) == 0 &&
-                      val == g_variant_get_byte(prop_value);
-          }
-          break;
+            return static_cast<unsigned char>(value) == prop_value.GetByte();
           case G_VARIANT_CLASS_INT16:
-          {
-            std::stringstream stream(value);
-            gint16 val;
-            stream >> val;
-            matches = (stream.rdstate() & (stream.badbit|stream.failbit)) == 0 &&
-                      val == g_variant_get_int16(prop_value);
-          }
-          break;
+            return value == prop_value.GetInt16();
           case G_VARIANT_CLASS_UINT16:
-          {
-            std::stringstream stream(value);
-            guint16 val;
-            stream >> val;
-            matches = (stream.rdstate() & (stream.badbit|stream.failbit)) == 0 &&
-                      val == g_variant_get_uint16(prop_value);
-          }
-          break;
+            return static_cast<uint16_t>(value) == prop_value.GetUInt16();
           case G_VARIANT_CLASS_INT32:
-          {
-            std::stringstream stream(value);
-            gint32 val;
-            stream >> val;
-            matches = (stream.rdstate() & (stream.badbit|stream.failbit)) == 0 &&
-                      val == g_variant_get_int32(prop_value);
-          }
-          break;
+            return value == prop_value.GetInt32();
           case G_VARIANT_CLASS_UINT32:
-          {
-            std::stringstream stream(value);
-            guint32 val;
-            stream >> val;
-            matches = (stream.rdstate() & (stream.badbit|stream.failbit)) == 0 &&
-                      val == g_variant_get_uint32(prop_value);
-          }
-          break;
+            return static_cast<uint32_t>(value) == prop_value.GetUInt32();
           case G_VARIANT_CLASS_INT64:
-          {
-            std::stringstream stream(value);
-            gint64 val;
-            stream >> val;
-            matches = (stream.rdstate() & (stream.badbit|stream.failbit)) == 0 &&
-                      val == g_variant_get_int64(prop_value);
-          }
-          break;
+            return value == prop_value.GetInt64();
           case G_VARIANT_CLASS_UINT64:
-          {
-            std::stringstream stream(value);
-            guint64 val;
-            stream >> val;
-            matches = (stream.rdstate() & (stream.badbit|stream.failbit)) == 0 &&
-                      val == g_variant_get_uint64(prop_value);
-          }
-          break;
+            return static_cast<uint64_t>(value) == prop_value.GetUInt64();
         default:
-          LOG_WARNING(logger) << "Unable to match against property of unknown type.";
+          LOG_WARNING(logger) << "Unable to match '"<< name << "' against property of unknown integer type.";
         };
       }
-      g_variant_unref(prop_value);
-      g_variant_unref(prop_dict);
-      return matches;
+
+      return false;
+    }
+
+    glib::Variant GetPropertyValue(std::string const& name) const
+    {
+      if (name == "id")
+        return glib::Variant(GetId());
+
+      GVariantBuilder properties_builder;
+      g_variant_builder_init(&properties_builder, G_VARIANT_TYPE("a{sv}"));
+      node_->AddProperties(&properties_builder);
+      glib::Variant props_dict(g_variant_builder_end(&properties_builder));
+      return g_variant_lookup_value(props_dict, name.c_str(), nullptr);
     }
 
     std::vector<xpathselect::Node::Ptr> Children() const
     {
       std::vector<xpathselect::Node::Ptr> children;
-      for(auto child: node_->GetIntrospectableChildren())
-      {
-        children.push_back(std::make_shared<IntrospectableAdapter>(child, GetPath() ));
-      }
+      auto const& this_ptr = shared_from_this();
+
+      for(auto const& child: node_->GetIntrospectableChildren())
+        children.push_back(std::make_shared<IntrospectableAdapter>(child, this_ptr));
+
       return children;
-
-    }
-
+    }
+
+    Introspectable* Node() const
+    {
+      return node_;
+    }
+
+  private:
     Introspectable* node_;
-  private:
+    IntrospectableAdapter::Ptr parent_;
     std::string full_path_;
   };
 
-  xpathselect::NodeList select_nodes(local::IntrospectableAdapter::Ptr root,
-                                     std::string const& query)
+  xpathselect::NodeVector select_nodes(IntrospectableAdapter::Ptr const& root, std::string const& query)
   {
-    if (xpathselect_driver_ == NULL)
-      xpathselect_driver_ = dlopen("libxpathselect.so.1.3", RTLD_LAZY);
+    if (!xpathselect_driver_)
+      xpathselect_driver_ = dlopen(XPATH_SELECT_LIB.c_str(), RTLD_LAZY);
 
     if (xpathselect_driver_)
     {
-      typedef decltype(&xpathselect::SelectNodes) entry_t;
+      typedef decltype(&xpathselect::SelectNodes) select_nodes_t;
       dlerror();
-      entry_t entry_point = (entry_t) dlsym(xpathselect_driver_, "SelectNodes");
+      auto SelectNodes = reinterpret_cast<select_nodes_t>(dlsym(xpathselect_driver_, "SelectNodes"));
       const char* err = dlerror();
       if (err)
       {
@@ -214,7 +197,7 @@
       }
       else
       {
-        return entry_point(root, query);
+        return SelectNodes(root, query);
       }
     }
     else
@@ -223,7 +206,7 @@
     }
 
     // Fallen through here as we've hit an error
-    return xpathselect::NodeList();
+    return xpathselect::NodeVector();
   }
 
   // This needs to be called at destruction to cleanup the dlopen
@@ -240,10 +223,8 @@
 GVariant* GetState(std::string const& query);
 void StartLogToFile(std::string const& file_path);
 void ResetLogging();
-void SetLogSeverity(std::string const& log_component,
-  std::string const& severity);
-void LogMessage(std::string const& severity,
-  std::string const& message);
+void SetLogSeverity(std::string const& log_component, std::string const& severity);
+void LogMessage(std::string const& severity, std::string const& message);
 
 namespace dbus
 {
@@ -317,7 +298,7 @@
   }
   else if (method == "GetVersion")
   {
-    return g_variant_new("(s)", "1.3");
+    return g_variant_new("(s)", local::PROTOCOL_VERSION.c_str());
   }
   else if (method == "StartLogToFile")
   {
@@ -352,16 +333,15 @@
 
 GVariant* GetState(std::string const& query)
 {
-  GVariantBuilder  builder;
+  GVariantBuilder builder;
   g_variant_builder_init(&builder, G_VARIANT_TYPE("a(sv)"));
 
-  local::IntrospectableAdapter::Ptr root_node = std::make_shared<local::IntrospectableAdapter>(_parent_introspectable, std::string());
-  auto nodes = local::select_nodes(root_node, query);
-  for (auto n : nodes)
+  auto root_node = std::make_shared<local::IntrospectableAdapter>(_parent_introspectable);
+  for (auto const& n : local::select_nodes(root_node, query))
   {
-    auto p = std::static_pointer_cast<local::IntrospectableAdapter>(n);
+    auto p = std::static_pointer_cast<local::IntrospectableAdapter const>(n);
     if (p)
-      g_variant_builder_add(&builder, "(sv)", p->GetPath().c_str(), p->node_->Introspect());
+      g_variant_builder_add(&builder, "(sv)", p->GetPath().c_str(), p->Node()->Introspect());
   }
 
   return g_variant_new("(a(sv))", &builder);

=== modified file 'unity-shared/Introspectable.cpp'
--- unity-shared/Introspectable.cpp	2013-01-23 02:59:06 +0000
+++ unity-shared/Introspectable.cpp	2013-11-06 08:52:17 +0000
@@ -17,6 +17,7 @@
  * Authored by: Alex Launi <[e-mail]>
  */
 
+#include <UnityCore/Variant.h>
 #include "Introspectable.h"
 
 namespace unity
@@ -24,88 +25,85 @@
 namespace debug
 {
 
+const std::string CHILDREN_NAME = "Children";
+
 Introspectable::Introspectable()
 {
-  static guint64 unique_id=0;
-  _id = unique_id++;
+  static int32_t unique_id_ = 0;
+  id_ = unique_id_++;
 }
 
 Introspectable::~Introspectable()
 {
-  for (auto parent : _parents)
-    parent->_children.remove(this);
-  for (auto child : _children)
-    child->_parents.remove(this);
+  for (auto parent : parents_)
+    parent->children_.remove(this);
+  for (auto child : children_)
+    child->parents_.remove(this);
 }
 
 Introspectable::IntrospectableList Introspectable::GetIntrospectableChildren()
 {
-  return _children;
+  return children_;
 }
 
 GVariant*
 Introspectable::Introspect()
 {
-  GVariantBuilder  builder;
-  GVariantBuilder  child_builder;
-  gint             n_children = 0;
+  GVariantBuilder builder;
+  GVariantBuilder child_builder;
+  bool has_valid_children = false;
 
   g_variant_builder_init(&builder, G_VARIANT_TYPE("a{sv}"));
-  g_variant_builder_add(&builder, "{sv}", "id", g_variant_new_uint64(_id));
-
+  variant::BuilderWrapper build_wrapper(&builder);
+  build_wrapper.add("id", id_);
   AddProperties(&builder);
 
   g_variant_builder_init(&child_builder, G_VARIANT_TYPE("as"));
 
-  auto children = GetIntrospectableChildren();
-  for (auto it = children.begin(); it != children.end(); it++)
+  for (auto const& child : GetIntrospectableChildren())
   {
-    if ((*it)->GetName() != "")
+    auto const& child_name = child->GetName();
+
+    if (!child_name.empty())
     {
-      g_variant_builder_add(&child_builder, "s", (*it)->GetName().c_str());
-      n_children++;
+      g_variant_builder_add(&child_builder, "s", child_name.c_str());
+      has_valid_children = true;
     }
   }
 
-  GVariant* child_results = g_variant_builder_end(&child_builder);
-
-  if (n_children > 0)
-    g_variant_builder_add(&builder, "{sv}", GetChildsName().c_str(), child_results);
+  glib::Variant child_results(g_variant_builder_end(&child_builder));
+
+  if (has_valid_children)
+    build_wrapper.add(CHILDREN_NAME, child_results);
+
   return g_variant_builder_end(&builder);
 }
 
 void
 Introspectable::AddChild(Introspectable* child)
 {
-  _children.push_back(child);
-  child->_parents.push_back(this);
+  children_.push_back(child);
+  child->parents_.push_back(this);
 }
 
 void
 Introspectable::RemoveChild(Introspectable* child)
 {
-  _children.remove(child);
-  child->_parents.remove(this);
-}
-
-std::string
-Introspectable::GetChildsName() const
-{
-  return "Children";
-}
-
-guint64 Introspectable::GetIntrospectionId() const
-{
-  return _id;
+  children_.remove(child);
+  child->parents_.remove(this);
+}
+
+int32_t Introspectable::GetIntrospectionId() const
+{
+  return id_;
 }
 
 void Introspectable::RemoveAllChildren()
 {
-  for (auto child : _children)
-  {
-    child->_parents.remove(this);
-  }
-  _children.clear();
+  for (auto child : children_)
+    child->parents_.remove(this);
+
+  children_.clear();
 }
 
 }

=== modified file 'unity-shared/Introspectable.h'
--- unity-shared/Introspectable.h	2013-01-23 02:59:06 +0000
+++ unity-shared/Introspectable.h	2013-11-06 08:52:17 +0000
@@ -41,13 +41,9 @@
   void RemoveChild(Introspectable* child);
   virtual void AddProperties(GVariantBuilder* builder) = 0;
   virtual IntrospectableList GetIntrospectableChildren();
-  guint64 GetIntrospectionId() const;
+  int32_t GetIntrospectionId() const;
 
 protected:
-  /// Please don't override this unless you really need to. The only valid reason
-  /// is if you have a property that simply *must* be called 'Children'.
-  virtual std::string GetChildsName() const;
-
   void RemoveAllChildren();
 
   /*
@@ -61,9 +57,9 @@
    */
 
 private:
-  std::list<Introspectable*> _children;
-  std::list<Introspectable*> _parents;
-  guint64 _id;
+  std::list<Introspectable*> children_;
+  std::list<Introspectable*> parents_;
+  int32_t id_;
 };
 }
 }

=== modified file 'unity-shared/SearchBar.cpp'
--- unity-shared/SearchBar.cpp	2013-07-24 01:01:44 +0000
+++ unity-shared/SearchBar.cpp	2013-11-06 08:52:17 +0000
@@ -617,6 +617,7 @@
   .add("filter-label-y", show_filters_->GetAbsoluteY())
   .add("filter-label-width", show_filters_->GetAbsoluteWidth())
   .add("filter-label-height", show_filters_->GetAbsoluteHeight())
+  .add("filter-label-geo", show_filters_->GetAbsoluteGeometry())
   .add("im_active", pango_entry_->im_active());
 }