Merge lp:~njpatel/unity/nicer-glib-signals into lp:unity

[Neil J. Patel]

This branch adds support for a cleaner way to connect to signals on GObjects inside Unity.

The idea behind the branch is that, with the current way, we need to take care of a few very annoying things:
- Connect the signal to a static member in our class and access members/variables from the callback via "self->"
- We need to remember to disconnect the signals (g_signal_handler_disconnect) when our class destructs. This means we need to keep around the signal id returned from g_signal_connect, as well as remember to disconnect in our destructor.

Both of these things have led to clumsy/cluttered code, or bugs where we've accidentally looked over something (like disconnecting).

The idea behind this branch is to:
- Allow the calling class to connect to signals on a GObject using sigc::slots (either sigc::ptr_fun or, more likely, sigc::mem_fun).
- Automatically handle disconnection of the signal on destruction of a Signal instance.
- Add a SignalManager class to manage multiple connections to different GObjects for an object. It will automatically disconnect the signals when it destructs.

Both these things mean that it's possible to ditch the multiple "static void Foo", "guint my_signal_id_", and "g_signal_handler_disconnect", from a class and replace with a simple "SignalManager signal_manger_" variable.

= API/Code =

I've tried to make it as clean as possible to use API-wise. My only real regret is having to use "new Signal<..." with a smartpointer to pass Signal instances to the SignalManager class. As explained in the code, this was mostly to strike a balance between a clean API and also to reduce the likelihood of bugs being introduced if the Signal class was passed in by reference and it's details "stolen" from it by the instance in the Vector (only one Signal class should manage a unique connection at any time).

Apart from that, I heard you like templates, so I put templates in your templates, so you can derive when you derive.

Oh, there're tests.

[Sam Spilsbury (smspillaz)]

Yo Dawg,

I went a little deeper into this code and found that in tests/ you've added what looks like generated marshallers for glib callbacks. It might be better to autogenerate that a build time instead of shipping it in the source distribution since the *.list could change whenever we need a new marshaller. For example

add_executable (test-signals ... ${CMAKE_CURRENT_BINARY_DIR}/generated/test_glib_signals_utils_marshal.cpp
...)

file (MAKE_DIRECTORY ${CMAKE_CURRENT_BUILD_DIR}/generated)
add_custom_command (TARGET test-signals PRE_BUILD
COMMAND glib-genmarshals ${CMAKE_CURRENT_SOURCE_DIR}/test_glib_signals_utils_marshal.list
WORKING_DIRECTORY ${CMAKE_CURRENT_BINARY_DIR}/generated)

That way we can create and perceive the marshallers at the same time, without the person doing the compiling ever knowing that!

(I can't comment on the nature of the code itself, knowing little about glib, however I do intend to run the tests and try it out)

[Neil J. Patel (njpatel)]

Thanks for reminding me, totally forgot to commit and push the generation before proposing the merge.

We already do this in services/CMakeFiles.txt, however the difference was that with all the funky new g++ flags we use, the code glib produces no longer compiles with g++, so had to add a small workaround for that for now. Going to see if I can just patch glib-genmarshal when I get some time.

[Tim Penhey (thumper)]

OK Neil,

Well your description makes me keen to look at the code :-)

First question, since we are looking to use more glib stuff inside nux itself,
do you think perhaps the GLibSignal headers should go into nux itself?

Looking at a line like this:

  signal_manager_.Add (new glib::Signal<void, GDBusProxy*, char*, char*, GVariant*>
    (proxy_, "g-signal", sigc::mem_fun(this, &Impl::OnProxySignalReceived)));

It makes me wonder if we could simplify it. Given that the compiler has
enough type inference based on the sigc::mem_fun, we could perhaps get the
compiler to work out what glib::Signal we need, so we don't need to specify
it. I'm not entirely clear on the magic needed, but I'm 99% sure that it
could be done, allowing something like:

  signal_manager_.Add(proxy_, "g-signal",
                      sigc::mem_fun(this, &Impl::OnProxySignalReceived));

Perhaps for later...

Authored by in UnityCore/GLibSignal-inl.h, do you want to capitalise patel?

Please don't use capital O, or lowercase L for any single character variables
or type markers. It becomes non-obvious as zero is a valid template arg
(if the template is expecting an int tempate param).

Also, aligning the params in a multiline arguement clause actually hinders
readability (for me) - see the "O object"

http://google-styleguide.googlecode.com/svn/trunk/cppguide.xml#Function_Names
recommends that the accessors look like:

  GObject* object() const;
  std::string const& name() const;

The Signal template class constructor should take the std::string as a const&.

You should make the SignalManager non-copyable, and it doesn't need to define
a destructor, and certainly not a virtual destructor. The add method should
take SignalBase::Ptr const& as the param, not SignalBase*.

UnityCore/UnityCore.h makes me sad. Can we delete it?

I'm not clear on why you want the GObject type defined in the Signal template
parameteres. It seems to me that they could be removed completely and just
use a GObject*. Oh... I see now. It is the first param to the callback.
This was a little confusing as you have the first param given a special name.

Comments in tests are OK :-) I'd like to know what
TestGLibSignals.TestCleanDestruction is testing exactly.

Also, why do you sometimes pass in the address of a gboolean to
g_signal_emit_by_name?

I don't undestand the gobject test signal class and marshallers, but I'll
trust you on that.

On the whole, a bit +1 from me, but ask if you want to fix the Add method to
not need new signal ...

review: Needs Information

[Tim Penhey (thumper)]

r1294 fails to compile for me locally... I'm looking into it.

[Tim Penhey (thumper)]

CMakeFiles/test-gtest.dir/test_glib_signals.cpp.o: In function `(anonymous namespace)::TestGLibSignals_TestConstructions_Test::TestBody()':
test_glib_signals.cpp:(.text+0x4f5): undefined reference to `unity::glib::SignalBase::SignalBase()'
test_glib_signals.cpp:(.text+0x69f): undefined reference to `unity::glib::SignalBase::~SignalBase()'
test_glib_signals.cpp:(.text+0x7bc): undefined reference to `unity::glib::SignalBase::~SignalBase()'

and many more. It seems that the test is trying to link against the installed unity-core library rather than the one it has just compiled. Ideas?

[Neil J. Patel (njpatel)]

> OK Neil,
>
> Well your description makes me keen to look at the code :-)
>
> First question, since we are looking to use more glib stuff inside nux itself,
> do you think perhaps the GLibSignal headers should go into nux itself?

Sure, though let's get through a review here and then I can move over to Nux.

> Looking at a line like this:
>
> signal_manager_.Add (new glib::Signal<void, GDBusProxy*, char*, char*,
> GVariant*>
> (proxy_, "g-signal", sigc::mem_fun(this, &Impl::OnProxySignalReceived)));
>
> It makes me wonder if we could simplify it. Given that the compiler has
> enough type inference based on the sigc::mem_fun, we could perhaps get the
> compiler to work out what glib::Signal we need, so we don't need to specify
> it. I'm not entirely clear on the magic needed, but I'm 99% sure that it
> could be done, allowing something like:
>
> signal_manager_.Add(proxy_, "g-signal",
> sigc::mem_fun(this, &Impl::OnProxySignalReceived));

> Perhaps for later...

So, I implemented what we spoke about, however the compiler refuses to let it happen. It expects sigc::slot to be declared with the template types rather than being able to infer them from passes in sigc::bound_mem_functorN

Changing the arguments to take a sigc::bound_mem_functorN (where N is number of args), worked, but this is not a low-level class you can pass around, you'd need to create overrides for all the different types of functor's to make it work.

I'm not against that, but I'm hoping I messed something up that another pair of eyes can take a look at. I've moved everything to sigc::nil, could you try your idea out and let me know if you've more luck with it?

> Authored by in UnityCore/GLibSignal-inl.h, do you want to capitalise patel?
>
> Please don't use capital O, or lowercase L for any single character variables
> or type markers. It becomes non-obvious as zero is a valid template arg
> (if the template is expecting an int tempate param).

Both fixed.

> Also, aligning the params in a multiline arguement clause actually hinders
> readability (for me) - see the "O object"

I like it the way it is but not enough to care, can make that change before committing.

> http://google-styleguide.googlecode.com/svn/trunk/cppguide.xml#Function_Names
> recommends that the accessors look like:
>
> GObject* object() const;
> std::string const& name() const;
>
> The Signal template class constructor should take the std::string as a const&.
>
> You should make the SignalManager non-copyable, and it doesn't need to define
> a destructor, and certainly not a virtual destructor.

All fixed.

> The add method should
> take SignalBase::Ptr const& as the param, not SignalBase*.

Hmm, doing this means that manager->Add becomes Add(SignalBase::Ptr(new Signal<void, GObject*, Bar*> (..... I don't like this. Am I missing something on how this would work? If the idea above works this is moot anyway.

> UnityCore/UnityCore.h makes me sad. Can we delete it?

Why?

> Comments in tests are OK :-) I'd like to know what
> TestGLibSignals.TestCleanDestruction is testing exactly.

If the object is no longer around, we shouldn't do anything stu...

[Tim Penhey (thumper)]

Hi Neil,

After several hours of fluffing around trying to get a nicer Add method, I've
given up as well. It seems that the sigc wrappers don't give us access to the
type information for the function call arguments. We could perhaps submit a
patch to the sigc guys, but not with this branch.

I forgot that the shared_ptr has an explicit constructor, so passing through
the shared pointer would be a bit cumbersome as you mention. So lets not
worry about that here.

By having UnityCore/UnityCore.h we are pulling in headers that we don't care
about, and creating an artificial dependency between our code and other
headers that have no impact on the code in the source file. This increases
coupling between the files and increases compilation time.

review: Approve

[Tim Penhey (thumper)]

Actually, can you just change the using namespace sigc in the header to "using sigc::nul" ?

You should never have a using namespace * in a header.

[Neil J. Patel (njpatel)]

Okay, so last few commits should hopefully make this good for merge. Getting rid of UnityCore.h must have inflated the diff a bit but couldn't help that.

[Neil J. Patel (njpatel)]

Ah, forgot to answer the gboolean comment on this and Jason's merge proposal properly: bool and gboolean can be different sizes because "typedef int gboolean" (on my system sizeof(bool) = 1 and sizeof(gboolean)=4). As timeouts, signal-accumulators etc are often used by sending in a return location for the result (maybe from higher up in the callstack), sending a bool where glib expects to accumulate a gboolean causes all sorts of fun errors (timeouts sometimes return false but that is evaluated to TRUE, ask Sam :) and for things like GVariant we can easily cause memory errors.

So, since tackling a lot of this at the end of the last cycle (we managed to fix some of the worst crashes by auditing the bool/gboolean code), I've tried to make absolutely sure that we don't mix them up at all, even if it might be okay in some cases, I'd rather be more strict about it.

Ideally we'd reach a point where the few areas where we hit gboolean/guint32/etc/etc are handled by a wrapper that does the conversion back into standard C++ types internally and safely.

[Sam Spilsbury (smspillaz)]

Yep, that's static_cast <gboolean> ((bool) false) == TRUE :)

[Tim Penhey (thumper)]

On Mon, 18 Jul 2011 02:56:22 you wrote:
> Yep, that's static_cast <gboolean> ((bool) false) == TRUE :)

Casting can the be the source of many many problems. This is just one of the
reasons I don't like them.

They are a useful tool, but just because you have a hammer doesn't mean you
need to hit everything with it.

[Neil J. Patel (njpatel)]

Honestly I just do bool foo = my_gboolean == TRUE;

Seems the safest to me :)

Sent from my iPhone

On 17 Jul 2011, at 15:56, Sam Spilsbury <email address hidden> wrote:

> Yep, that's static_cast <gboolean> ((bool) false) == TRUE :)
>
> --
> https://code.launchpad.net/~njpatel/unity/nicer-glib-signals/+merge/67439
> You are the owner of lp:~njpatel/unity/nicer-glib-signals.

[Tim Penhey (thumper)]

On Mon, 18 Jul 2011 09:42:36 you wrote:
> Honestly I just do bool foo = my_gboolean == TRUE;
>
> Seems the safest to me :)

bool foo = my_gboolean is fine.

it is the casting of a bool to gboolean that is the issue.

The big issue here is exactly the above:

gboolean foo = 42; // entirely valid

foo -> true
bool(foo) -> true
foo != FALSE -> true
foo == TRUE -> false !!!!

We should not be doing == TRUE anywhere.

TRUE is defined to be !FALSE.
FALSE is defined to be 0.

The C (and C++) standard say that 0 is false, and anything else is considered
to be true. If we are checking for equality to TRUE on an integral type, we
may well have situations where the variable is neither TRUE nor FALSE. We
should only ever check for FALSE, or != FALSE. Checking for TRUE is a world
of pain for integral types.

=== modified file 'CMakeLists.txt'
--- CMakeLists.txt	2011-07-10 14:16:30 +0000
+++ CMakeLists.txt	2011-07-15 10:26:29 +0000
@@ -16,9 +16,9 @@
 set (UNITY_VERSION "${UNITY_MAJOR}.${UNITY_MINOR}.${UNITY_MICRO}")
 set (UNITY_API_VERSION "4.0")
 
-set (CMAKE_CXX_FLAGS "-fno-permissive")
-set (CMAKE_CXX_FLAGS_DEBUG "-fno-permissive")
-set (CMAKE_CXX_FLAGS_RELEASE "-fno-permissive")
+set (CMAKE_CXX_FLAGS "-std=c++0x -fno-permissive")
+set (CMAKE_CXX_FLAGS_DEBUG "-std=c++0x -fno-permissive")
+set (CMAKE_CXX_FLAGS_RELEASE "-std=c++0x -fno-permissive")
 
 #
 # Niceties
 
=== modified file 'UnityCore/CMakeLists.txt'
--- UnityCore/CMakeLists.txt	2011-06-22 14:08:16 +0000
+++ UnityCore/CMakeLists.txt	2011-07-15 10:26:29 +0000
@@ -6,17 +6,19 @@
 #
 set (CORE_HEADERS
      DBusIndicators.h
+     GLibSignal.h
+     GLibSignal-inl.h
      GLibWrapper.h
      GLibWrapper-inl.h
      IndicatorEntry.h
      Indicator.h
      Indicators.h
-     UnityCore.h
      Variant.h
     )
 
 set (CORE_SOURCES
      DBusIndicators.cpp
+     GLibSignal.cpp
      GLibWrapper.cpp
      Indicator.cpp
      IndicatorEntry.cpp
 
=== modified file 'UnityCore/DBusIndicators.cpp'
--- UnityCore/DBusIndicators.cpp	2011-06-29 15:40:49 +0000
+++ UnityCore/DBusIndicators.cpp	2011-07-15 10:26:29 +0000
@@ -27,6 +27,7 @@
 #include <X11/Xlib.h>
 
 #include "config.h"
+#include "GLibSignal.h"
 #include "GLibWrapper.h"
 #include "Variant.h"
 
@@ -83,12 +84,6 @@
 bool run_local_panel_service();
 gboolean reconnect_to_service(gpointer data);
 void on_proxy_ready_cb(GObject* source, GAsyncResult* res, gpointer data);
-void on_proxy_name_owner_changed(GDBusProxy* proxy, GParamSpec* pspec,
-                                 DBusIndicators::Impl* remote);
-void on_proxy_signal_received(GDBusProxy* proxy,
-                              char* sender_name, char* signal_name,
-                              GVariant* parameters,
-                              DBusIndicators::Impl* remote);
 void request_sync(GDBusProxy* proxy, const char* method, GVariant* name,
                   SyncData* data);
 void on_sync_ready_cb(GObject* source, GAsyncResult* res, gpointer data);
@@ -113,6 +108,11 @@
   void Sync(GVariant* args, SyncData* data);
   void SyncGeometries(std::string const& name,
                       EntryLocationMap const& locations);
+  void OnProxyNameOwnerChanged(GDBusProxy*proxy, GParamSpec *pspec);
+  void OnProxySignalReceived(GDBusProxy* proxy,
+                             char* sender_name,
+                             char* signal_name_,
+                             GVariant* parameters);
 
   virtual void OnEntryScroll(std::string const& entry_id, int delta);
   virtual void OnEntryShowMenu(std::string const& entry_id,
@@ -124,10 +124,10 @@
 
   DBusIndicators* owner_;
   GDBusProxy* proxy_;
-  guint32 proxy_signal_id_;
-  guint32 proxy_name_id_;
   typedef std::vector<SyncDataPtr> PendingSyncs;
   PendingSyncs pending_syncs_;
+  
+  glib::SignalManager signal_manager_;
 };
 
 
@@ -143,8 +143,6 @@
 {
   if (G_IS_OBJECT (proxy_))
   {
-    g_signal_handler_disconnect(proxy_, proxy_signal_id_);
-    g_signal_handler_disconnect(proxy_, proxy_name_id_);
     g_object_unref(proxy_);
   }
 }
@@ -178,12 +176,11 @@
   {
     proxy_ = proxy;
     // Connect to interesting signals
-    proxy_signal_id_ = g_signal_connect(proxy_, "g-signal",
-                                        G_CALLBACK(on_proxy_signal_received),
-                                        this);
-    proxy_name_id_ = g_signal_connect(proxy_, "notify::g-name-owner",
-                                      G_CALLBACK(on_proxy_name_owner_changed),
-                                      this);
+    signal_manager_.Add (new glib::Signal<void, GDBusProxy*, char*, char*, GVariant*>
+      (proxy_, "g-signal", sigc::mem_fun(this, &Impl::OnProxySignalReceived)));
+
+    signal_manager_.Add(new glib::Signal<void, GDBusProxy*,GParamSpec*>
+      (proxy_, "notify::g-name-owner", sigc::mem_fun(this, &Impl::OnProxyNameOwnerChanged)));
   }
   RequestSyncAll();
 }
@@ -373,6 +370,72 @@
   return g_getenv("PANEL_USE_LOCAL_SERVICE") != NULL;
 }
 
+void DBusIndicators::Impl::OnProxyNameOwnerChanged(GDBusProxy* proxy,
+                                                   GParamSpec* pspec)
+{
+  char* name_owner = g_dbus_proxy_get_name_owner(proxy);
+
+  if (name_owner == NULL)
+  {
+    // The panel service has stopped for some reason.  Restart it if not in
+    // dev mode
+    if (!g_getenv("UNITY_DEV_MODE"))
+      Reconnect();
+  }
+
+  g_free (name_owner);
+}
+
+void DBusIndicators::Impl::OnProxySignalReceived(GDBusProxy* proxy,
+                                                 char* sender_name,
+                                                 char* signal_name_,
+                                                 GVariant* parameters)
+{
+  std::string signal_name(signal_name_);
+  if (signal_name == "EntryActivated")
+  {
+    const char* entry_name = g_variant_get_string(g_variant_get_child_value(parameters, 0), NULL);
+    if (entry_name) {
+      owner_->ActivateEntry(entry_name);
+    }
+  }
+  else if (signal_name == "EntryActivateRequest")
+  {
+    const char* entry_name = g_variant_get_string(g_variant_get_child_value(parameters, 0), NULL);
+    if (entry_name) {
+      owner_->on_entry_activate_request.emit(entry_name);
+    }
+  }
+  else if (signal_name == "ReSync")
+  {
+    const char* id = g_variant_get_string(g_variant_get_child_value(parameters, 0), NULL);
+    bool sync_one = !g_strcmp0 (id, "") == 0;
+
+    if (sync_one) {
+      RequestSyncIndicator(id);
+    }
+    else {
+      RequestSyncAll();
+    }
+  }
+  else if (signal_name == "ActiveMenuPointerMotion")
+  {
+    int x = 0;
+    int y = 0;
+    g_variant_get (parameters, "(ii)", &x, &y);
+    owner_->on_menu_pointer_moved.emit(x, y);
+  }
+  else if (signal_name == "EntryShowNowChanged")
+  {
+    gchar    *id = NULL;
+    gboolean  show_now;
+
+    g_variant_get (parameters, "(sb)", &id, &show_now);
+    owner_->SetEntryShowNow(id, show_now);
+
+    g_free (id);
+  }
+}
 
 DBusIndicators::DBusIndicators()
   : pimpl(new Impl(this))
@@ -495,73 +558,6 @@
   return true;
 }
 
-void on_proxy_signal_received(GDBusProxy* proxy,
-                              char* sender_name, char* signal_name_,
-                              GVariant* parameters,
-                              DBusIndicators::Impl* remote)
-{
-  std::string signal_name(signal_name_);
-  if (signal_name == "EntryActivated")
-  {
-    const char* entry_name = g_variant_get_string(g_variant_get_child_value(parameters, 0), NULL);
-    if (entry_name) {
-      remote->owner_->ActivateEntry(entry_name);
-    }
-  }
-  else if (signal_name == "EntryActivateRequest")
-  {
-    const char* entry_name = g_variant_get_string(g_variant_get_child_value(parameters, 0), NULL);
-    if (entry_name) {
-      remote->owner_->on_entry_activate_request.emit(entry_name);
-    }
-  }
-  else if (signal_name == "ReSync")
-  {
-    const char* id = g_variant_get_string(g_variant_get_child_value(parameters, 0), NULL);
-    bool sync_one = !g_strcmp0 (id, "") == 0;
-
-    if (sync_one) {
-      remote->RequestSyncIndicator(id);
-    }
-    else {
-      remote->RequestSyncAll();
-    }
-  }
-  else if (signal_name == "ActiveMenuPointerMotion")
-  {
-    int x = 0;
-    int y = 0;
-    g_variant_get (parameters, "(ii)", &x, &y);
-    remote->owner_->on_menu_pointer_moved.emit(x, y);
-  }
-  else if (signal_name == "EntryShowNowChanged")
-  {
-    gchar    *id = NULL;
-    gboolean  show_now;
-
-    g_variant_get (parameters, "(sb)", &id, &show_now);
-    remote->owner_->SetEntryShowNow(id, show_now);
-
-    g_free (id);
-  }
-}
-
-void on_proxy_name_owner_changed(GDBusProxy* proxy, GParamSpec* pspec,
-                                 DBusIndicators::Impl* remote)
-{
-  char* name_owner = g_dbus_proxy_get_name_owner(proxy);
-
-  if (name_owner == NULL)
-  {
-    // The panel service has stopped for some reason.  Restart it if not in
-    // dev mode
-    if (!g_getenv("UNITY_DEV_MODE"))
-      remote->Reconnect();
-  }
-
-  g_free (name_owner);
-}
-
 void request_sync(GDBusProxy* proxy, const char* method, GVariant* name, SyncData* data)
 {
   g_dbus_proxy_call(proxy, method, name, G_DBUS_CALL_FLAGS_NONE,
 
=== added file 'UnityCore/GLibSignal-inl.h'
--- UnityCore/GLibSignal-inl.h	1970-01-01 00:00:00 +0000
+++ UnityCore/GLibSignal-inl.h	2011-07-15 10:26:29 +0000
@@ -0,0 +1,299 @@
+// -*- 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: Neil Jagdish patel <[e-mail]>
+*/
+
+#ifndef UNITY_GLIB_SIGNAL_INL_H
+#define UNITY_GLIB_SIGNAL_INL_H
+
+namespace unity {
+namespace glib {
+
+template <typename R, typename G>
+Signal0<R, G>::Signal0()
+{}
+
+template <typename R, typename G>
+void Signal0<R, G>::Connect(G object,
+                            std::string const& signal_name,
+                            SignalCallback callback)
+{
+  object_ = reinterpret_cast<GObject*>(object);
+  name_ = signal_name;
+  callback_ = callback;
+  connection_id_ = g_signal_connect(object, signal_name.c_str (),
+                                    G_CALLBACK(Callback), this);
+}
+
+template <typename R, typename G>
+R Signal0<R, G>::Callback(G object, Signal0* self)
+{
+  return self->callback_(object);
+}
+
+template <typename R, typename G, typename T>
+Signal1<R, G, T>::Signal1()
+{}
+
+template <typename R, typename G, typename T>
+void Signal1<R, G, T>::Connect(G object,
+                               std::string const& signal_name,
+                               SignalCallback callback)
+{
+  object_ = reinterpret_cast<GObject*>(object);
+  name_ = signal_name;
+  callback_ = callback;
+  connection_id_ = g_signal_connect(object, signal_name.c_str (),
+                                    G_CALLBACK(Callback), this);
+}
+
+template <typename R, typename G, typename T>
+R Signal1<R, G, T>::Callback(G object, T data1, Signal1* self)
+{
+  return self->callback_(object, data1);
+}
+
+template <typename R, typename G, typename T1, typename T2>
+Signal2<R, G, T1, T2>::Signal2()
+{}
+
+template <typename R, typename G, typename T1, typename T2>
+void Signal2<R, G, T1, T2>::Connect(G object,
+                                    std::string const& signal_name,
+                                    SignalCallback callback)
+{
+  object_ = reinterpret_cast<GObject*>(object);
+  name_ = signal_name;
+  callback_ = callback;
+  connection_id_ = g_signal_connect(object, signal_name.c_str (),
+                                    G_CALLBACK (Callback), this);
+}
+
+template <typename R, typename G, typename T1, typename T2>
+R Signal2<R, G, T1, T2>::Callback(G object,
+                                  T1 data1,
+                                  T2 data2,
+                                  Signal2* self)
+{
+  return self->callback_(object, data1, data2);
+}
+
+template <typename R, typename G, typename T1, typename T2, typename T3>
+Signal3<R, G, T1, T2, T3>::Signal3()
+{}
+
+template <typename R, typename G, typename T1, typename T2, typename T3>
+void Signal3<R, G, T1, T2, T3>::Connect(G object,
+                                        std::string const& signal_name,
+                                        SignalCallback callback)
+{
+  object_ = reinterpret_cast<GObject*>(object);
+  name_ = signal_name;
+  callback_ = callback;
+  connection_id_ = g_signal_connect(object, signal_name.c_str (),
+                                    G_CALLBACK (Callback), this);
+}
+
+template <typename R, typename G, typename T1, typename T2, typename T3>
+R Signal3<R, G, T1, T2, T3>::Callback(G object,
+                                      T1 data1,
+                                      T2 data2,
+                                      T3 data3,
+                                      Signal3* self)
+{
+  return self->callback_(object, data1, data2, data3);
+}
+
+template <typename R, typename G, typename T1, typename T2, typename T3, typename T4>
+Signal4<R, G, T1, T2, T3, T4>::Signal4()
+{}
+
+template <typename R, typename G, typename T1, typename T2, typename T3, typename T4>
+void Signal4<R, G, T1, T2, T3, T4>::Connect(G object,
+                                            std::string const& signal_name,
+                                            SignalCallback callback)
+{
+  object_ = reinterpret_cast<GObject*>(object);
+  name_ = signal_name;
+  callback_ = callback;
+  connection_id_ = g_signal_connect(object, signal_name.c_str (),
+                                    G_CALLBACK (Callback), this);
+}
+
+template <typename R, typename G, typename T1, typename T2, typename T3, typename T4>
+R Signal4<R, G, T1, T2, T3, T4>::Callback(G object,
+                                          T1 data1,
+                                          T2 data2,
+                                          T3 data3,
+                                          T4 data4,
+                                          Signal4* self)
+{
+  return self->callback_(object, data1, data2, data3, data4);
+}
+
+
+template <typename R, typename G, typename T1, typename T2,
+          typename T3, typename T4, typename T5>
+Signal5<R, G, T1, T2, T3, T4, T5>::Signal5()
+{}
+
+template <typename R, typename G, typename T1, typename T2,
+          typename T3, typename T4, typename T5 >
+void Signal5<R, G, T1, T2, T3, T4, T5>::Connect(G object,
+                                                std::string const& signal_name,
+                                                SignalCallback callback)
+{
+  object_ = reinterpret_cast<GObject*>(object);
+  name_ = signal_name;
+  callback_ = callback;
+  connection_id_ = g_signal_connect(object, signal_name.c_str (),
+                                    G_CALLBACK (Callback), this);
+}
+
+template <typename R, typename G, typename T1, typename T2,
+          typename T3, typename T4, typename T5>
+R Signal5<R, G, T1, T2, T3, T4, T5>::Callback(G object,
+                                              T1 data1,
+                                              T2 data2,
+                                              T3 data3,
+                                              T4 data4,
+                                              T5 data5,
+                                              Signal5* self)
+{
+  return self->callback_(object, data1, data2, data3, data4, data5);
+}
+
+template <typename R, typename G, typename T1, typename T2,
+          typename T3, typename T4, typename T5 , typename T6>
+Signal6<R, G, T1, T2, T3, T4, T5, T6>::Signal6()
+{}
+
+template <typename R, typename G, typename T1, typename T2,
+          typename T3, typename T4, typename T5 , typename T6>
+void Signal6<R, G, T1, T2, T3, T4, T5, T6>::Connect(G object,
+                                                    std::string const& signal_name,
+                                                    SignalCallback callback)
+{
+  object_ = reinterpret_cast<GObject*>(object);
+  name_ = signal_name;
+  callback_ = callback;
+  connection_id_ = g_signal_connect(object, signal_name.c_str (),
+                                    G_CALLBACK (Callback), this);
+}
+
+template <typename R, typename G, typename T1, typename T2,
+          typename T3, typename T4, typename T5, typename T6>
+R Signal6<R, G, T1, T2, T3, T4, T5, T6>::Callback(G object,
+                                                  T1 data1,
+                                                  T2 data2,
+                                                  T3 data3,
+                                                  T4 data4,
+                                                  T5 data5,
+                                                  T6 data6,
+                                                  Signal6* self)
+{
+  return self->callback_(object, data1, data2, data3, data4, data5, data6);
+}
+
+template<typename R, typename G>
+Signal<R, G>::Signal()
+{}
+
+template<typename R, typename G>
+Signal<R, G>::Signal(G object, std::string const& signal_name, SignalCallback callback)
+{
+  Connect(object, signal_name, callback);
+}
+
+template<typename R, typename G, typename T1>
+Signal<R, G, T1>::Signal()
+{}
+
+template<typename R, typename G, typename T1>
+Signal<R, G, T1>::Signal(G object, std::string const& signal_name, SignalCallback callback)
+{
+  Connect(object, signal_name, callback);
+}
+
+template<typename R, typename G, typename T1, typename T2>
+Signal<R, G, T1, T2>::Signal()
+{}
+
+template<typename R, typename G, typename T1, typename T2>
+Signal<R, G, T1, T2>::Signal(G object,
+                             std::string const& signal_name,
+                             SignalCallback callback)
+{
+  Connect(object, signal_name, callback);
+}
+
+template<typename R, typename G, typename T1, typename T2, typename T3>
+Signal<R, G, T1, T2, T3>::Signal()
+{}
+
+template<typename R, typename G, typename T1, typename T2, typename T3>
+Signal<R, G, T1, T2, T3>::Signal(G object,
+                                 std::string const& signal_name,
+                                 SignalCallback callback)
+{
+  Connect(object, signal_name, callback);
+}
+
+template<typename R, typename G, typename T1, typename T2, typename T3, typename T4>
+Signal<R, G, T1, T2, T3, T4>::Signal()
+{}
+
+template<typename R, typename G, typename T1, typename T2, typename T3, typename T4>
+Signal<R, G, T1, T2, T3, T4>::Signal(G object,
+                                     std::string const& signal_name,
+                                     SignalCallback callback)
+{
+  Connect(object, signal_name, callback);
+}
+
+template<typename R, typename G, typename T1, typename T2, typename T3, typename T4,
+         typename T5>
+Signal<R, G, T1, T2, T3, T4, T5>::Signal()
+{}
+
+template<typename R, typename G, typename T1, typename T2, typename T3, typename T4,
+         typename T5>
+Signal<R, G, T1, T2, T3, T4, T5>::Signal(G object,
+                                         std::string const& signal_name,
+                                         SignalCallback callback)
+{
+  Connect(object, signal_name, callback);
+}
+
+template<typename R, typename G, typename T1, typename T2, typename T3, typename T4,
+         typename T5, typename T6>
+Signal<R, G, T1, T2, T3, T4, T5, T6>::Signal()
+{}
+
+template<typename R, typename G, typename T1, typename T2, typename T3, typename T4,
+         typename T5, typename T6>
+Signal<R, G, T1, T2, T3, T4, T5, T6>::Signal(G object,
+                                             std::string const& signal_name,
+                                             SignalCallback callback)
+{
+  Connect(object, signal_name, callback);
+}
+
+}
+}
+
+#endif
 
=== added file 'UnityCore/GLibSignal.cpp'
--- UnityCore/GLibSignal.cpp	1970-01-01 00:00:00 +0000
+++ UnityCore/GLibSignal.cpp	2011-07-15 10:26:29 +0000
@@ -0,0 +1,87 @@
+// -*- 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: Neil Jagdish patel <[e-mail]>
+*/
+
+#include "GLibSignal.h"
+
+namespace unity {
+namespace glib {
+
+SignalBase::SignalBase()
+  : object_(0),
+    connection_id_(0)
+{}
+
+SignalBase::~SignalBase()
+{
+  Disconnect();
+}
+
+void SignalBase::Disconnect()
+{
+  if (G_IS_OBJECT(object_) && connection_id_)
+    g_signal_handler_disconnect(object_, connection_id_);
+  
+  object_ = 0;
+  connection_id_ = 0;
+}
+
+GObject* SignalBase::object() const
+{
+  return object_;
+}
+
+std::string const& SignalBase::name() const
+{
+  return name_;
+}
+
+SignalManager::SignalManager()
+{}
+
+// Ideally this would be SignalBase& but there is a specific requirment to allow
+// only one instance of Signal to control a connection. With the templating, it
+// was too messy to try and write a copy constructor/operator that would steal
+// from "other" and make the new one the owner. Not only did it create
+// opportunity for random bugs, it also made the API bad.
+void SignalManager::Add(SignalBase* signal)
+{
+  SignalBase::Ptr s(signal);
+  connections_.push_back(s);
+}
+
+// This uses void* to keep in line with the g_signal* functions
+// (it allows you to pass in a GObject without casting up).
+void SignalManager::Disconnect(void* object, std::string const& signal_name)
+{
+  for (ConnectionVector::iterator it = connections_.begin();
+       it != connections_.end();
+       ++it)
+  {
+    if ((*it)->object() == object
+        && (*it)->name() == signal_name)
+    {
+      (*it)->Disconnect();
+      connections_.erase(it, it);
+    }
+  }
+}
+
+}
+}
+
 
=== added file 'UnityCore/GLibSignal.h'
--- UnityCore/GLibSignal.h	1970-01-01 00:00:00 +0000
+++ UnityCore/GLibSignal.h	2011-07-15 10:26:29 +0000
@@ -0,0 +1,307 @@
+// -*- 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: Neil Jagdish Patel <[e-mail]>
+*/
+
+#ifndef UNITY_GLIB_SIGNAL_H
+#define UNITY_GLIB_SIGNAL_H
+
+#include <string>
+#include <vector>
+#include <boost/noncopyable.hpp>
+#include <boost/shared_ptr.hpp>
+#include <glib-object.h>
+#include <sigc++/sigc++.h>
+
+namespace unity {
+namespace glib {
+
+using sigc::nil;
+
+class SignalBase
+{
+public:
+  typedef boost::shared_ptr<SignalBase> Ptr;
+
+  SignalBase();
+  virtual ~SignalBase();
+
+  void Disconnect();
+
+  GObject* object() const;
+  std::string const& name() const;
+
+protected:
+  GObject* object_;
+  guint32 connection_id_;
+  std::string name_;
+};
+
+template <typename R, typename G>
+class Signal0 : public SignalBase
+{
+public:
+  typedef sigc::slot<R, G> SignalCallback;
+
+  Signal0();
+ 
+  void Connect(G Object,
+               std::string const& signal_name,
+               SignalCallback     cb);
+private:
+  static R Callback(G object, Signal0* self);
+private:
+  SignalCallback callback_;
+};
+
+template <typename R, typename G, typename T>
+class Signal1 : public SignalBase
+{
+public:
+  typedef sigc::slot<R, G, T> SignalCallback;
+
+  Signal1();
+
+  void Connect(G Object,
+               std::string const& signal_name,
+               SignalCallback callback);
+private:
+  static R Callback(G object, T data1, Signal1* self);
+private:
+  SignalCallback callback_;
+};
+
+template <typename R, typename G, typename T1, typename T2>
+class Signal2 : public SignalBase
+{
+public:
+  typedef sigc::slot<R, G, T1, T2> SignalCallback;
+
+  Signal2();
+
+  void Connect(G Object,
+               std::string const& signal_name,
+               SignalCallback callback);
+private:
+  static R Callback(G Object,
+                    T1 data1,
+                    T2 data2,
+                    Signal2* self);
+private:
+  SignalCallback callback_;
+};
+
+template <typename R, typename G, typename T1, typename T2, typename T3>
+class Signal3 : public SignalBase
+{
+public:
+  typedef sigc::slot<R, G, T1, T2, T3> SignalCallback;
+
+  Signal3();
+
+  void Connect(G Object,
+               std::string const& signal_name,
+               SignalCallback callback);
+private:
+  static R Callback(G Object,
+                    T1 data1,
+                    T2 data2,
+                    T3 data3,
+                    Signal3* self);
+private:
+  SignalCallback callback_;
+};
+
+template <typename R, typename G, typename T1, typename T2, typename T3, typename T4>
+class Signal4 : public SignalBase
+{
+public:
+  typedef sigc::slot<R, G, T1, T2, T3, T4> SignalCallback;
+
+  Signal4();
+
+  void Connect(G Object,
+               std::string const& signal_name,
+               SignalCallback callback);
+private:
+  static R Callback(G Object,
+                    T1 data1,
+                    T2 data2,
+                    T3 data3,
+                    T4 data4,
+                    Signal4* self);
+private:
+  SignalCallback callback_;
+};
+
+template <typename R, typename G, typename T1, typename T2,
+          typename T3, typename T4, typename T5>
+class Signal5 : public SignalBase
+{
+public:
+  typedef sigc::slot<R, G, T1, T2, T3, T4, T5> SignalCallback;
+
+  Signal5();
+
+  void Connect(G Object,
+               std::string const& signal_name,
+               SignalCallback callback);
+private:
+  static R Callback(G Object,
+                    T1 data1,
+                    T2 data2,
+                    T3 data3,
+                    T4 data4,
+                    T5 data5,
+                    Signal5* self);
+private:
+  SignalCallback callback_;
+};
+
+template <typename R, typename G, typename T1, typename T2,
+          typename T3, typename T4, typename T5, typename T6>
+class Signal6 : public SignalBase
+{
+public:
+  typedef sigc::slot<R, G, T1, T2, T3, T4, T5, T6> SignalCallback;
+
+  Signal6();
+
+  void Connect(G Object,
+               std::string const& signal_name,
+               SignalCallback callback);
+private:
+  static R Callback(G Object,
+                    T1 data1,
+                    T2 data2,
+                    T3 data3,
+                    T4 data4,
+                    T5 data5,
+                    T6 data6,
+                    Signal6* self);
+private:
+  SignalCallback callback_;
+};
+
+template <typename R, typename G,
+          typename T1 = nil, typename T2 = nil,
+          typename T3 = nil, typename T4 = nil,
+          typename T5 = nil, typename T6 = nil>
+class Signal : public Signal6<R, G, T1, T2, T3, T4, T5, T6>
+{
+public:
+  typedef sigc::slot<R, G, T1, T2, T3, T4, T5, T6> SignalCallback;
+
+  inline Signal();
+  inline Signal(G Object,
+                std::string const& signal_name,
+                SignalCallback callback);
+};
+
+template <typename R, typename G>
+class Signal<R, G, nil, nil, nil, nil, nil, nil> : public Signal0<R, G>
+{
+public:
+  typedef sigc::slot<R, G> SignalCallback;
+
+  inline Signal();
+  inline Signal(G Object,
+                std::string const& signal_name,
+                SignalCallback callback);
+};
+
+template <typename R, typename G, typename T1>
+class Signal<R, G, T1, nil, nil, nil, nil, nil> : public Signal1<R, G, T1>
+{
+public:
+  typedef sigc::slot<R, G, T1> SignalCallback;
+
+  inline Signal();
+  inline Signal(G Object,
+                std::string const& signal_name,
+                SignalCallback callback);
+};
+
+template <typename R, typename G, typename T1, typename T2>
+class Signal<R, G, T1, T2, nil, nil, nil, nil> : public Signal2<R, G, T1, T2>
+{
+public:
+  typedef sigc::slot<R, G, T1, T2> SignalCallback;
+
+  inline Signal();
+  inline Signal(G Object,
+                std::string const& signal_name,
+                SignalCallback callback);
+};
+
+template <typename R, typename G, typename T1, typename T2, typename T3>
+class Signal<R, G, T1, T2, T3, nil, nil, nil> : public Signal3<R, G, T1, T2 ,T3>
+{
+public:
+  typedef sigc::slot<R, G, T1, T2, T3> SignalCallback;
+
+  inline Signal();
+  inline Signal(G Object,
+                std::string const& signal_name,
+                SignalCallback callback);
+};
+
+template <typename R, typename G, typename T1, typename T2, typename T3, typename T4>
+class Signal<R, G, T1, T2, T3, T4, nil, nil>
+  : public Signal4<R, G, T1, T2 ,T3, T4>
+{
+public:
+  typedef sigc::slot<R, G, T1, T2, T3, T4> SignalCallback;
+
+  inline Signal();
+  inline Signal(G Object,
+                std::string const& signal_name,
+                SignalCallback callback);
+};
+
+template <typename R, typename G, typename T1, typename T2, typename T3, typename T4, typename T5>
+class Signal<R, G, T1, T2, T3, T4, T5, nil>
+  : public Signal5<R, G, T1, T2 ,T3, T4, T5>
+{
+public:
+  typedef sigc::slot<R, G, T1, T2, T3, T4, T5> SignalCallback;
+
+  inline Signal();
+  inline Signal(G Object,
+                std::string const& signal_name,
+                SignalCallback callback);
+};
+
+class SignalManager : public boost::noncopyable
+{
+public:
+  typedef std::vector<SignalBase::Ptr> ConnectionVector;
+
+  SignalManager();  
+  void Add(SignalBase* signal);
+  void Disconnect(void* object, std::string const& signal_name);
+  
+private:
+  ConnectionVector connections_;
+};
+
+}
+}
+
+#include "GLibSignal-inl.h"
+
+#endif
 
=== removed file 'UnityCore/UnityCore.h'
--- UnityCore/UnityCore.h	2011-06-21 12:10:09 +0000
+++ UnityCore/UnityCore.h	1970-01-01 00:00:00 +0000
@@ -1,32 +0,0 @@
-/*
- * 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: Neil Jagdish Patel <[e-mail]>
- */
-
-#ifndef _UNITY_CORE_H_
-#define _UNITY_CORE_H_
-
-// Single include for headers
-
-#include <UnityCore/DBusIndicators.h>
-#include <UnityCore/GLibWrapper.h>
-#include <UnityCore/GLibWrapper-inl.h>
-#include <UnityCore/Indicator.h>
-#include <UnityCore/IndicatorEntry.h>
-#include <UnityCore/Indicators.h>
-#include <UnityCore/Variant.h>
-
-#endif // _UNITY_CORE_H_
 
=== modified file 'plugins/unityshell/src/FavoriteStoreGSettings.h'
--- plugins/unityshell/src/FavoriteStoreGSettings.h	2011-06-21 12:10:09 +0000
+++ plugins/unityshell/src/FavoriteStoreGSettings.h	2011-07-15 10:26:29 +0000
@@ -23,7 +23,7 @@
 #include <gio/gio.h>
 
 #include "FavoriteStore.h"
-#include <UnityCore/UnityCore.h>
+#include <UnityCore/GLibWrapper.h>
 
 // An abstract object that facilitates getting and modifying the list of favorites
 // Use GetDefault () to get the correct store for the session
 
=== modified file 'plugins/unityshell/src/IconTexture.cpp'
--- plugins/unityshell/src/IconTexture.cpp	2011-06-21 12:10:09 +0000
+++ plugins/unityshell/src/IconTexture.cpp	2011-07-15 10:26:29 +0000
@@ -19,16 +19,17 @@
 
 #include "config.h"
 
-#include "Nux/Nux.h"
-#include "NuxGraphics/GLThread.h"
+#include <glib.h>
+#include <gtk/gtk.h>
+#include <pango/pangocairo.h>
+
+#include <Nux/Nux.h>
+#include <NuxGraphics/GLThread.h>
+#include <UnityCore/Variant.h>
+
 #include "IconLoader.h"
 #include "IconTexture.h"
 #include "TextureCache.h"
-#include <UnityCore/UnityCore.h>
-
-#include <glib.h>
-#include <pango/pangocairo.h>
-#include <gtk/gtk.h>
 
 #define DEFAULT_ICON "text-x-preview"
 
 
=== modified file 'plugins/unityshell/src/Launcher.cpp'
--- plugins/unityshell/src/Launcher.cpp	2011-07-14 14:15:37 +0000
+++ plugins/unityshell/src/Launcher.cpp	2011-07-15 10:26:29 +0000
@@ -48,7 +48,7 @@
 #include "ubus-server.h"
 #include "UBusMessages.h"
 
-#include <UnityCore/UnityCore.h>
+#include <UnityCore/Variant.h>
 
 using namespace unity::ui;
 
 
=== modified file 'plugins/unityshell/src/LauncherIcon.cpp'
--- plugins/unityshell/src/LauncherIcon.cpp	2011-07-14 14:37:26 +0000
+++ plugins/unityshell/src/LauncherIcon.cpp	2011-07-15 10:26:29 +0000
@@ -42,7 +42,7 @@
 
 #include "ubus-server.h"
 #include "UBusMessages.h"
-#include <UnityCore/UnityCore.h>
+#include <UnityCore/Variant.h>
 
 #define DEFAULT_ICON "application-default-icon"
 #define MONO_TEST_ICON "gnome-home"
 
=== modified file 'plugins/unityshell/src/PanelHomeButton.cpp'
--- plugins/unityshell/src/PanelHomeButton.cpp	2011-07-01 14:58:41 +0000
+++ plugins/unityshell/src/PanelHomeButton.cpp	2011-07-15 10:26:29 +0000
@@ -33,7 +33,7 @@
 #include <gtk/gtk.h>
 
 #include "PanelStyle.h"
-#include <UnityCore/UnityCore.h>
+#include <UnityCore/Variant.h>
 
 #define PANEL_HEIGHT 24
 
 
=== modified file 'plugins/unityshell/src/PanelIndicatorObjectEntryView.cpp'
--- plugins/unityshell/src/PanelIndicatorObjectEntryView.cpp	2011-07-07 10:22:47 +0000
+++ plugins/unityshell/src/PanelIndicatorObjectEntryView.cpp	2011-07-15 10:26:29 +0000
@@ -37,7 +37,8 @@
 #include "PanelIndicatorObjectEntryView.h"
 
 #include "PanelStyle.h"
-#include <UnityCore/UnityCore.h>
+#include <UnityCore/GLibWrapper.h>
+#include <UnityCore/Variant.h>
 
 
 namespace unity {
 
=== modified file 'plugins/unityshell/src/PanelIndicatorObjectEntryView.h'
--- plugins/unityshell/src/PanelIndicatorObjectEntryView.h	2011-07-11 08:49:45 +0000
+++ plugins/unityshell/src/PanelIndicatorObjectEntryView.h	2011-07-15 10:26:29 +0000
@@ -25,7 +25,7 @@
 #include <NuxImage/CairoGraphics.h>
 #include <NuxGraphics/GraphicsEngine.h>
 
-#include <UnityCore/UnityCore.h>
+#include <UnityCore/IndicatorEntry.h>
 
 #include "Introspectable.h"
 
 
=== modified file 'plugins/unityshell/src/PanelIndicatorObjectView.h'
--- plugins/unityshell/src/PanelIndicatorObjectView.h	2011-06-21 12:10:09 +0000
+++ plugins/unityshell/src/PanelIndicatorObjectView.h	2011-07-15 10:26:29 +0000
@@ -22,7 +22,7 @@
 
 #include <Nux/View.h>
 
-#include <UnityCore/UnityCore.h>
+#include <UnityCore/Indicator.h>
 #include "PanelIndicatorObjectEntryView.h"
 
 #include "Introspectable.h"
 
=== modified file 'plugins/unityshell/src/PanelMenuView.cpp'
--- plugins/unityshell/src/PanelMenuView.cpp	2011-07-10 18:14:49 +0000
+++ plugins/unityshell/src/PanelMenuView.cpp	2011-07-15 10:26:29 +0000
@@ -31,7 +31,7 @@
 
 #include "PanelMenuView.h"
 #include "PanelStyle.h"
-#include <UnityCore/UnityCore.h>
+#include <UnityCore/Variant.h>
 
 #include "WindowManager.h"
 
 
=== modified file 'plugins/unityshell/src/PanelTitlebarGrabAreaView.cpp'
--- plugins/unityshell/src/PanelTitlebarGrabAreaView.cpp	2011-06-21 12:10:09 +0000
+++ plugins/unityshell/src/PanelTitlebarGrabAreaView.cpp	2011-07-15 10:26:29 +0000
@@ -28,7 +28,7 @@
 #include "Nux/WindowCompositor.h"
 
 #include "PanelTitlebarGrabAreaView.h"
-#include <UnityCore/UnityCore.h>
+#include <UnityCore/Variant.h>
 
 #include <glib.h>
 
 
=== modified file 'plugins/unityshell/src/PanelTray.h'
--- plugins/unityshell/src/PanelTray.h	2011-06-21 12:10:09 +0000
+++ plugins/unityshell/src/PanelTray.h	2011-07-15 10:26:29 +0000
@@ -24,8 +24,6 @@
 
 #include <gdk/gdkx.h>
 
-#include <UnityCore/UnityCore.h>
-
 #include "Introspectable.h"
 #include "PanelIndicatorObjectView.h"
 
 
=== modified file 'plugins/unityshell/src/PanelView.cpp'
--- plugins/unityshell/src/PanelView.cpp	2011-07-01 14:58:41 +0000
+++ plugins/unityshell/src/PanelView.cpp	2011-07-15 10:26:29 +0000
@@ -34,7 +34,7 @@
 
 #include "PanelStyle.h"
 #include "PanelIndicatorObjectView.h"
-#include <UnityCore/UnityCore.h>
+#include <UnityCore/Variant.h>
 
 namespace unity {
 
 
=== modified file 'plugins/unityshell/src/PanelView.h'
--- plugins/unityshell/src/PanelView.h	2011-06-22 14:39:34 +0000
+++ plugins/unityshell/src/PanelView.h	2011-07-15 10:26:29 +0000
@@ -28,7 +28,7 @@
 
 #include <gdk/gdkx.h>
 
-#include <UnityCore/UnityCore.h>
+#include <UnityCore/DBusIndicators.h>
 
 #include "Introspectable.h"
 #include "PanelHomeButton.h"
 
=== modified file 'plugins/unityshell/src/PlacesHomeView.cpp'
--- plugins/unityshell/src/PlacesHomeView.cpp	2011-06-21 12:10:09 +0000
+++ plugins/unityshell/src/PlacesHomeView.cpp	2011-07-15 10:26:29 +0000
@@ -42,7 +42,7 @@
 #include "PlacesSettings.h"
 #include "PlacesSimpleTile.h"
 #include "PlacesStyle.h"
-#include <UnityCore/UnityCore.h>
+#include <UnityCore/Variant.h>
 
 #include <string>
 #include <vector>
 
=== modified file 'plugins/unityshell/src/PlacesSearchBar.cpp'
--- plugins/unityshell/src/PlacesSearchBar.cpp	2011-06-28 11:17:23 +0000
+++ plugins/unityshell/src/PlacesSearchBar.cpp	2011-07-15 10:26:29 +0000
@@ -40,7 +40,7 @@
 #include "UBusMessages.h"
 
 #include "PlacesSearchBar.h"
-#include <UnityCore/UnityCore.h>
+#include <UnityCore/Variant.h>
 
 #include "PlacesStyle.h"
 
 
=== modified file 'plugins/unityshell/src/PlacesSimpleTile.cpp'
--- plugins/unityshell/src/PlacesSimpleTile.cpp	2011-07-07 11:52:58 +0000
+++ plugins/unityshell/src/PlacesSimpleTile.cpp	2011-07-15 10:26:29 +0000
@@ -30,7 +30,7 @@
 #include <gtk/gtk.h>
 #include <gdk/gdk.h>
 
-#include <UnityCore/UnityCore.h>
+#include <UnityCore/Variant.h>
 
 PlacesSimpleTile::PlacesSimpleTile (const char *icon_name,
                                     const char *label,
 
=== modified file 'plugins/unityshell/src/PlacesView.cpp'
--- plugins/unityshell/src/PlacesView.cpp	2011-06-28 12:19:37 +0000
+++ plugins/unityshell/src/PlacesView.cpp	2011-07-15 10:26:29 +0000
@@ -34,7 +34,7 @@
 #include "PlacesStyle.h"
 #include "PlacesSettings.h"
 #include "PlacesView.h"
-#include <UnityCore/UnityCore.h>
+#include <UnityCore/Variant.h>
 
 static void place_entry_activate_request (GVariant *payload, PlacesView *self);
 
 
=== modified file 'plugins/unityshell/src/QuicklistMenuItem.cpp'
--- plugins/unityshell/src/QuicklistMenuItem.cpp	2011-06-21 12:10:09 +0000
+++ plugins/unityshell/src/QuicklistMenuItem.cpp	2011-07-15 10:26:29 +0000
@@ -23,7 +23,7 @@
 
 #include "Nux/Nux.h"
 #include "QuicklistMenuItem.h"
-#include <UnityCore/UnityCore.h>
+#include <UnityCore/Variant.h>
 
 #include <X11/Xlib.h>
 
 
=== modified file 'plugins/unityshell/src/WindowButtons.cpp'
--- plugins/unityshell/src/WindowButtons.cpp	2011-06-21 12:10:09 +0000
+++ plugins/unityshell/src/WindowButtons.cpp	2011-07-15 10:26:29 +0000
@@ -25,7 +25,7 @@
 #include "Nux/BaseWindow.h"
 #include "Nux/WindowCompositor.h"
 
-#include <UnityCore/UnityCore.h>
+#include <UnityCore/Variant.h>
 #include "WindowButtons.h"
 
 #include <glib.h>
@@ -58,7 +58,7 @@
     nux::Geometry      geo  = GetGeometry ();
     nux::BaseTexture  *tex;
     nux::TexCoordXForm texxform;
- 
+
     GfxContext.PushClippingRectangle (geo);
 
     if (HasMouseFocus ())
@@ -123,23 +123,25 @@
 {
   WindowButton *but;
 
+  auto lambda_statechanged = [&](int x, int y, unsigned long button_flags, unsigned long key_flags) { redraw_signal.emit (); };
+
   but = new WindowButton (PanelStyle::WINDOW_BUTTON_CLOSE);
   AddView (but, 0, nux::eCenter, nux::eFix);
   but->sigClick.connect (sigc::mem_fun (this, &WindowButtons::OnCloseClicked));
-  but->OnMouseEnter.connect (sigc::mem_fun (this, &WindowButtons::RecvMouseEnter));
-  but->OnMouseLeave.connect (sigc::mem_fun (this, &WindowButtons::RecvMouseLeave));
+  but->OnMouseEnter.connect (lambda_statechanged);
+  but->OnMouseLeave.connect (lambda_statechanged);
 
   but = new WindowButton (PanelStyle::WINDOW_BUTTON_MINIMIZE);
   AddView (but, 0, nux::eCenter, nux::eFix);
   but->sigClick.connect (sigc::mem_fun (this, &WindowButtons::OnMinimizeClicked));
-  but->OnMouseEnter.connect (sigc::mem_fun (this, &WindowButtons::RecvMouseEnter));
-  but->OnMouseLeave.connect (sigc::mem_fun (this, &WindowButtons::RecvMouseLeave));
+  but->OnMouseEnter.connect (lambda_statechanged);
+  but->OnMouseLeave.connect (lambda_statechanged);
 
   but = new WindowButton (PanelStyle::WINDOW_BUTTON_UNMAXIMIZE);
   AddView (but, 0, nux::eCenter, nux::eFix);
   but->sigClick.connect (sigc::mem_fun (this, &WindowButtons::OnRestoreClicked));
-  but->OnMouseEnter.connect (sigc::mem_fun (this, &WindowButtons::RecvMouseEnter));
-  but->OnMouseLeave.connect (sigc::mem_fun (this, &WindowButtons::RecvMouseLeave));
+  but->OnMouseEnter.connect (lambda_statechanged);
+  but->OnMouseLeave.connect (lambda_statechanged);
 
   SetContentDistribution (nux::eStackLeft);
 }
@@ -184,15 +186,3 @@
 {
   unity::variant::BuilderWrapper(builder).add(GetGeometry());
 }
-
-void WindowButtons::RecvMouseEnter (int x, int y, unsigned long button_flags, unsigned long key_flags)
-{
-  redraw_signal.emit ();
-}
-
-void WindowButtons::RecvMouseLeave (int x, int y, unsigned long button_flags, unsigned long key_flags)
-{
-  redraw_signal.emit ();
-}
-
-
 
=== modified file 'po/unity.pot'
--- po/unity.pot	2011-07-13 13:54:57 +0000
+++ po/unity.pot	2011-07-15 10:26:29 +0000
@@ -8,7 +8,7 @@
 msgstr ""
 "Project-Id-Version: PACKAGE VERSION\n"
 "Report-Msgid-Bugs-To: [e-mail]\n"
-"POT-Creation-Date: 2011-07-13 01:33-0400\n"
+"POT-Creation-Date: 2011-07-09 23:12+0100\n"
 "PO-Revision-Date: YEAR-MO-DA HO:MI+ZONE\n"
 "Last-Translator: FULL NAME <EMAIL@ADDRESS>\n"
 "Language-Team: LANGUAGE <[e-mail]>\n"
 
=== modified file 'tests/CMakeLists.txt'
--- tests/CMakeLists.txt	2011-07-13 14:20:07 +0000
+++ tests/CMakeLists.txt	2011-07-15 10:26:29 +0000
@@ -20,6 +20,7 @@
      "-DGETTEXT_PACKAGE=\"unity\""
      "-DINDICATORDIR=\"${CMAKE_BINARY_DIR}/tests\""
      "-DINDICATORICONDIR=\"${CMAKE_BINARY_DIR}/tests\""
+     "-I${CMAKE_CURRENT_BINARY_DIR}"
      )
 add_definitions (${CFLAGS})
 
@@ -27,7 +28,7 @@
 link_libraries (${LIBS})
 
 set (LIB_PATHS ${TEST_UNIT_DEPS_LIBRARY_DIRS})
-link_directories (${LIB_PATHS} ${CMAKE_BINARY_DIR}/UnityCore)
+link_directories (${CMAKE_BINARY_DIR}/UnityCore ${LIB_PATHS})
 
 include_directories (. .. ../services ../UnityCore ${UNITY_SRC} ${CMAKE_BINARY_DIR})
 
@@ -285,16 +286,27 @@
 #
 # GTest tests
 #
+find_program(GLIB_GENMARSHAL glib-genmarshal)
+add_custom_command(OUTPUT ${CMAKE_CURRENT_BINARY_DIR}/test_glib_signals_utils_marshal.cpp
+  COMMAND ${GLIB_GENMARSHAL} ARGS test_glib_signals_utils_marshal.list --body --prefix=test_signals > ${CMAKE_CURRENT_BINARY_DIR}/test_glib_signals_utils_marshal.cpp
+  COMMAND ${GLIB_GENMARSHAL} ARGS test_glib_signals_utils_marshal.list --header --prefix=test_signals > ${CMAKE_CURRENT_BINARY_DIR}/test_glib_signals_utils_marshal.h
+  COMMAND sed ARGS -i "s/glib-object/test_glib_signals_utils_marshal/" ${CMAKE_CURRENT_BINARY_DIR}/test_glib_signals_utils_marshal.cpp
+  WORKING_DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR}
+  DEPENDS test_glib_signals_utils_marshal.list
+  COMMENT "Generating marshallers")
 
 enable_testing()
 find_package(GTest)
-
 if (${GTEST_FOUND} STREQUAL TRUE)
-
   include_directories(${GTEST_INCLUDE_DIRS})
   add_executable(test-gtest
+                 test_glib_signals.cpp
+                 test_glib_signals_utils.cpp
+                 test_glib_signals_utils.h
+                 ${CMAKE_CURRENT_BINARY_DIR}/test_glib_signals_utils_marshal.cpp
+                 test_indicator_entry.cpp
+                 test_main.cpp
                  test_timer.cpp
-                 test_indicator_entry.cpp
                  ${UNITY_SRC}/Timer.h
                  ${UNITY_SRC}/Timer.cpp
                  )
 
=== added file 'tests/test_glib_signals.cpp'
--- tests/test_glib_signals.cpp	1970-01-01 00:00:00 +0000
+++ tests/test_glib_signals.cpp	2011-07-15 10:26:29 +0000
@@ -0,0 +1,366 @@
+#include <UnityCore/GLibSignal.h>
+#include <gtest/gtest.h>
+
+#include "test_glib_signals_utils.h"
+
+using namespace std;
+using namespace unity;
+using namespace unity::glib;
+
+namespace {
+
+class TestGLibSignals : public testing::Test
+{
+public:
+  TestGLibSignals()
+    : signal0_received_(false)
+    , signal1_received_(false)
+    , signal2_received_(false)
+    , signal3_received_(false)
+    , signal4_received_(false)
+    , signal5_received_(false)
+    , signal6_received_(false)
+    , arg1_("")
+    , arg2_(-1)
+    , arg3_(0.0f)
+    , arg4_(0.00)
+    , arg5_(false)
+    , arg6_(0)
+  {
+    test_signals_ = static_cast<TestSignals*>(g_object_new(TEST_TYPE_SIGNALS, NULL));
+  }
+
+  virtual ~TestGLibSignals()
+  {
+    if (G_IS_OBJECT(test_signals_))
+      g_object_unref(test_signals_);
+  }
+
+  void Signal0Callback(TestSignals* signals)
+  {
+   signal0_received_ = true;
+  }
+
+  void Signal1Callback(TestSignals* signals, const char *str)
+  {
+    arg1_ = str;
+    signal1_received_ = true;
+  }
+
+  void Signal2Callback(TestSignals* signals, const char* str, int i)
+  {
+    arg1_ = str;
+    arg2_ = i;
+    signal2_received_ = true;
+  }
+  
+  void Signal3Callback(TestSignals* signals, const char* str, int i, float f)
+  {
+    arg1_ = str;
+    arg2_ = i;
+    arg3_ = f;
+    signal3_received_ = true;
+  }
+
+  void Signal4Callback(TestSignals* signals, const char* str, int i, float f, double d) // heh
+  {
+    arg1_ = str;
+    arg2_ = i;
+    arg3_ = f;
+    arg4_ = d;
+    signal4_received_ = true;
+  }
+
+  void Signal5Callback(TestSignals* signals, const char* str, int i, float f,
+                       double d, gboolean b)
+  {
+    arg1_ = str;
+    arg2_ = i;
+    arg3_ = f;
+    arg4_ = d;
+    arg5_ = b ? true : false;
+    signal5_received_ = true;
+  }
+
+  gboolean Signal6Callback(TestSignals* signals, const char* str, int i, float f,
+                           double d, gboolean b, char c)
+  {
+    arg1_ = str;
+    arg2_ = i;
+    arg3_ = f;
+    arg4_ = d;
+    arg5_ = b ? true : false;
+    arg6_ = c;
+    signal6_received_ = true;
+    return TRUE;
+  }
+
+protected:
+  TestSignals* test_signals_;
+
+  bool signal0_received_;
+  bool signal1_received_;
+  bool signal2_received_;
+  bool signal3_received_;
+  bool signal4_received_;
+  bool signal5_received_;
+  bool signal6_received_;
+
+  string arg1_;
+  int arg2_;
+  float arg3_;
+  double arg4_;
+  bool arg5_;
+  char arg6_;
+};
+
+
+TEST_F(TestGLibSignals, TestConstructions)
+{
+  SignalBase base;
+
+  Signal0<void, TestSignals*> signal0;
+  Signal1<void, TestSignals*, string> signal1;
+  Signal2<void, TestSignals*, string, int> signal2;
+  Signal3<void, TestSignals*, string, int, float> signal3;
+  Signal4<void, TestSignals*, string, int, float, double> signal4;
+  Signal5<void, TestSignals*, string, int, float, double, gboolean> signal5;
+  Signal6<gboolean, TestSignals*, string, int, float, double, gboolean, char> signal6;
+
+  Signal<void, TestSignals*> signal00;
+  Signal<void, TestSignals*, string> signal01;
+  Signal<void, TestSignals*, string, int> signal02;
+  Signal<void, TestSignals*, string, int, float> signal03;
+  Signal<void, TestSignals*, string, int, float, double> signal04;
+  Signal<void, TestSignals*, string, int, float, double, gboolean> signal05;
+  Signal<gboolean, TestSignals*, string, int, float, double, gboolean, char> signal06;
+}
+
+TEST_F(TestGLibSignals, TestSignal0)
+{
+  Signal<void, TestSignals*> signal;
+  signal.Connect(test_signals_, "signal0",
+                 sigc::mem_fun(this, &TestGLibSignals::Signal0Callback));
+  
+  g_signal_emit_by_name(test_signals_, "signal0");
+  
+  EXPECT_TRUE(signal0_received_);
+  EXPECT_EQ(arg1_, "");
+}
+
+TEST_F(TestGLibSignals, TestSignal1)
+{
+  Signal<void, TestSignals*, const char*> signal;
+  signal.Connect(test_signals_, "signal1",
+                 sigc::mem_fun(this, &TestGLibSignals::Signal1Callback));
+
+  g_signal_emit_by_name(test_signals_, "signal1", "test");
+ 
+  EXPECT_TRUE(signal1_received_);
+  EXPECT_EQ(arg1_, "test");
+  EXPECT_EQ(arg2_, -1);
+}
+
+TEST_F(TestGLibSignals, TestSignal2)
+{
+  Signal<void, TestSignals*, const char*, int> signal;
+  signal.Connect(test_signals_, "signal2",
+                 sigc::mem_fun(this, &TestGLibSignals::Signal2Callback));
+
+  g_signal_emit_by_name(test_signals_, "signal2", "test", 100);
+ 
+  EXPECT_TRUE(signal2_received_);
+  EXPECT_EQ(arg1_, "test");
+  EXPECT_EQ(arg2_, 100);
+  EXPECT_EQ(arg3_, 0.0f);
+}
+
+TEST_F(TestGLibSignals, TestSignal3)
+{
+  Signal<void, TestSignals*, const char*, int, float> signal;
+  signal.Connect(test_signals_, "signal3",
+                 sigc::mem_fun(this, &TestGLibSignals::Signal3Callback));
+
+  g_signal_emit_by_name(test_signals_, "signal3", "test", 100, 200.0f);
+ 
+  EXPECT_TRUE(signal3_received_);
+  EXPECT_EQ(arg1_, "test");
+  EXPECT_EQ(arg2_, 100);
+  EXPECT_EQ(arg3_, 200.0f);
+  EXPECT_EQ(arg4_, 0.00);
+}
+
+
+TEST_F(TestGLibSignals, TestSignal4)
+{
+  Signal<void, TestSignals*, const char*, int, float, double> signal;
+  signal.Connect(test_signals_, "signal4",
+                 sigc::mem_fun(this, &TestGLibSignals::Signal4Callback));
+
+  g_signal_emit_by_name(test_signals_, "signal4", "test", 100, 200.0f, 300.00);
+ 
+  EXPECT_TRUE(signal4_received_);
+  EXPECT_EQ(arg1_, "test");
+  EXPECT_EQ(arg2_, 100);
+  EXPECT_EQ(arg3_, 200.0f);
+  EXPECT_EQ(arg4_, 300.00);
+  EXPECT_EQ(arg5_, false);
+}
+
+TEST_F(TestGLibSignals, TestSignal5)
+{
+  Signal<void, TestSignals*, const char*, int, float, double, gboolean> signal;
+  signal.Connect(test_signals_, "signal5",
+                 sigc::mem_fun(this, &TestGLibSignals::Signal5Callback));
+
+  g_signal_emit_by_name(test_signals_, "signal5", "test", 100, 200.0f, 300.00,
+                        TRUE);
+ 
+  EXPECT_TRUE(signal5_received_);
+  EXPECT_EQ(arg1_, "test");
+  EXPECT_EQ(arg2_, 100);
+  EXPECT_EQ(arg3_, 200.0f);
+  EXPECT_EQ(arg4_, 300.00);
+  EXPECT_EQ(arg5_, true);
+  EXPECT_EQ(arg6_, 0);
+}
+
+// This tests accumulation as well
+TEST_F(TestGLibSignals, TestSignal6)
+{
+  Signal<gboolean, TestSignals*, const char*, int, float, double, gboolean, char> signal;
+  signal.Connect(test_signals_, "signal6",
+                 sigc::mem_fun(this, &TestGLibSignals::Signal6Callback));
+
+  gboolean ret = FALSE;
+  g_signal_emit_by_name(test_signals_, "signal6", "test", 100, 200.0f, 300.00,
+                        TRUE, 'x', &ret);
+ 
+  EXPECT_TRUE(signal6_received_);
+  EXPECT_EQ(arg1_, "test");
+  EXPECT_EQ(arg2_, 100);
+  EXPECT_EQ(arg3_, 200.0f);
+  EXPECT_EQ(arg4_, 300.00);
+  EXPECT_EQ(arg5_, true);
+  EXPECT_EQ(arg6_, 'x');
+  EXPECT_EQ(ret, TRUE);
+}
+
+TEST_F(TestGLibSignals, TestDisconnection)
+{
+  Signal<void, TestSignals*> signal;
+  signal.Connect(test_signals_, "signal0",
+                 sigc::mem_fun(this, &TestGLibSignals::Signal0Callback));
+  signal.Disconnect();
+
+  g_signal_emit_by_name(test_signals_, "signal0");
+  
+  EXPECT_FALSE(signal0_received_);
+}
+
+TEST_F(TestGLibSignals, TestAutoDisconnection)
+{
+  {
+    Signal<void, TestSignals*> signal;
+    signal.Connect(test_signals_, "signal0",
+                   sigc::mem_fun(this, &TestGLibSignals::Signal0Callback));
+  }
+
+  g_signal_emit_by_name(test_signals_, "signal0");
+  
+  EXPECT_FALSE(signal0_received_);
+}
+
+TEST_F(TestGLibSignals, TestCleanDestruction)
+{
+  Signal<void, TestSignals*> signal;
+  signal.Connect(test_signals_, "signal0",
+                 sigc::mem_fun(this, &TestGLibSignals::Signal0Callback));
+  g_object_unref (test_signals_);
+}
+
+TEST_F(TestGLibSignals, TestManagerConstruction)
+{
+  SignalManager manager;
+}
+
+TEST_F(TestGLibSignals, TestManagerAddition)
+{
+  SignalManager manager;
+
+  manager.Add(new Signal<void, TestSignals*>(test_signals_,
+    "signal0",
+    sigc::mem_fun(this, &TestGLibSignals::Signal0Callback)));
+  manager.Add(new Signal<void, TestSignals*, const char *>(test_signals_,
+    "signal1",
+    sigc::mem_fun(this, &TestGLibSignals::Signal1Callback)));
+  manager.Add(new Signal<void, TestSignals*, const char *, int>(test_signals_,
+    "signal2",
+     sigc::mem_fun(this, &TestGLibSignals::Signal2Callback)));
+  manager.Add(new Signal<void, TestSignals*, const char *, int, float>(test_signals_,
+    "signal3",
+     sigc::mem_fun(this, &TestGLibSignals::Signal3Callback)));
+  manager.Add(new Signal<void, TestSignals*, const char *, int, float, double>(test_signals_,
+    "signal4",
+     sigc::mem_fun(this, &TestGLibSignals::Signal4Callback)));
+  manager.Add(new Signal<void, TestSignals*, const char *, int, float, double, gboolean>(test_signals_,
+    "signal5",
+     sigc::mem_fun(this, &TestGLibSignals::Signal5Callback)));
+  manager.Add(new Signal<gboolean, TestSignals*, const char *, int, float, double, gboolean, char>(test_signals_,
+    "signal6",
+     sigc::mem_fun(this, &TestGLibSignals::Signal6Callback)));
+}
+
+TEST_F(TestGLibSignals, TestManagerConnection)
+{
+  SignalManager manager;
+
+  manager.Add(new Signal<void, TestSignals*>(test_signals_,
+    "signal0",
+    sigc::mem_fun(this, &TestGLibSignals::Signal0Callback)));
+
+  g_signal_emit_by_name(test_signals_, "signal0");
+  EXPECT_TRUE(signal0_received_);
+
+  manager.Add(new Signal<void, TestSignals*, const char *>(test_signals_,
+    "signal1",
+    sigc::mem_fun(this, &TestGLibSignals::Signal1Callback)));
+  g_signal_emit_by_name(test_signals_, "signal1", "test");
+  EXPECT_TRUE(signal1_received_);
+
+  gboolean ret = FALSE;
+  manager.Add(new Signal<gboolean, TestSignals*, const char *, int, float, double, gboolean, char>(test_signals_,
+    "signal6",
+     sigc::mem_fun(this, &TestGLibSignals::Signal6Callback)));
+  g_signal_emit_by_name(test_signals_, "signal6", "test", 100, 1.0f, 100.00, FALSE, 'x', &ret);
+  EXPECT_TRUE(signal6_received_);
+  EXPECT_TRUE(ret);
+}
+
+TEST_F(TestGLibSignals, TestManagerAutoDisconnect)
+{
+  {
+    SignalManager manager;
+    manager.Add(new Signal<void, TestSignals*>(test_signals_,
+      "signal0",
+      sigc::mem_fun(this, &TestGLibSignals::Signal0Callback)));
+  }
+
+  g_signal_emit_by_name(test_signals_, "signal0");
+  EXPECT_FALSE(signal0_received_);
+}
+
+TEST_F(TestGLibSignals, TestManagerDisconnection)
+{
+  SignalManager manager;
+  
+  manager.Add(new Signal<void, TestSignals*>(test_signals_,
+    "signal0",
+    sigc::mem_fun(this, &TestGLibSignals::Signal0Callback)));
+  manager.Disconnect(test_signals_, "signal0");
+
+  g_signal_emit_by_name(test_signals_, "signal0");
+  EXPECT_FALSE(signal0_received_);
+}
+
+}
 
=== added file 'tests/test_glib_signals_utils.cpp'
--- tests/test_glib_signals_utils.cpp	1970-01-01 00:00:00 +0000
+++ tests/test_glib_signals_utils.cpp	2011-07-15 10:26:29 +0000
@@ -0,0 +1,102 @@
+#include "test_glib_signals_utils.h"
+#include "test_glib_signals_utils_marshal.h"
+
+enum
+{
+  SIGNAL_0,
+  SIGNAL_1,
+  SIGNAL_2,
+  SIGNAL_3,
+  SIGNAL_4,
+  SIGNAL_5,
+  SIGNAL_6,
+
+  LAST_SIGNAL
+};
+
+
+static guint32 _service_signals[LAST_SIGNAL] = { 0 };
+
+G_DEFINE_TYPE (TestSignals, test_signals, G_TYPE_OBJECT);
+
+static void
+test_signals_class_init (TestSignalsClass *klass)
+{
+  GObjectClass *obj_class = G_OBJECT_CLASS (klass);
+
+  /* Signals */
+  _service_signals[SIGNAL_0] =
+    g_signal_new ("signal0",
+                  G_OBJECT_CLASS_TYPE (obj_class),
+                  G_SIGNAL_RUN_LAST,
+                  0,
+                  NULL, NULL,
+                  g_cclosure_marshal_VOID__VOID,
+                  G_TYPE_NONE, 0);
+
+  _service_signals[SIGNAL_1] =
+    g_signal_new ("signal1",
+                  G_OBJECT_CLASS_TYPE (obj_class),
+                  G_SIGNAL_RUN_LAST,
+                  0,
+                  NULL, NULL,
+                  g_cclosure_marshal_VOID__STRING,
+                  G_TYPE_NONE, 1, G_TYPE_STRING);
+
+  _service_signals[SIGNAL_2] =
+    g_signal_new ("signal2",
+                  G_OBJECT_CLASS_TYPE (obj_class),
+                  G_SIGNAL_RUN_LAST,
+                  0,
+                  NULL, NULL,
+                  test_signals_VOID__STRING_INT,
+                  G_TYPE_NONE, 2,
+                  G_TYPE_STRING, G_TYPE_INT);
+
+  _service_signals[SIGNAL_3] =
+    g_signal_new ("signal3",
+                  G_OBJECT_CLASS_TYPE (obj_class),
+                  G_SIGNAL_RUN_LAST,
+                  0,
+                  NULL, NULL,
+                  test_signals_VOID__STRING_INT_FLOAT,
+                  G_TYPE_NONE, 3,
+                  G_TYPE_STRING, G_TYPE_INT, G_TYPE_FLOAT);
+
+  _service_signals[SIGNAL_4] =
+    g_signal_new ("signal4",
+                  G_OBJECT_CLASS_TYPE (obj_class),
+                  G_SIGNAL_RUN_LAST,
+                  0,
+                  NULL, NULL,
+                  test_signals_VOID__STRING_INT_FLOAT_DOUBLE,
+                  G_TYPE_NONE, 4,
+                  G_TYPE_STRING, G_TYPE_INT, G_TYPE_FLOAT, G_TYPE_DOUBLE);
+
+  _service_signals[SIGNAL_5] =
+    g_signal_new ("signal5",
+                  G_OBJECT_CLASS_TYPE (obj_class),
+                  G_SIGNAL_RUN_LAST,
+                  0,
+                  NULL, NULL,
+                  test_signals_VOID__STRING_INT_FLOAT_DOUBLE_BOOLEAN,
+                  G_TYPE_NONE, 5,
+                  G_TYPE_STRING, G_TYPE_INT, G_TYPE_FLOAT,
+                  G_TYPE_DOUBLE, G_TYPE_BOOLEAN);
+
+  _service_signals[SIGNAL_6] =
+    g_signal_new ("signal6",
+                  G_OBJECT_CLASS_TYPE (obj_class),
+                  G_SIGNAL_RUN_LAST,
+                  0,
+                  NULL, NULL,
+                  test_signals_BOOLEAN__STRING_INT_FLOAT_DOUBLE_BOOLEAN_CHAR,
+                  G_TYPE_BOOLEAN, 6,
+                  G_TYPE_STRING, G_TYPE_INT, G_TYPE_FLOAT,
+                  G_TYPE_DOUBLE, G_TYPE_BOOLEAN, G_TYPE_CHAR);
+}
+
+static void
+test_signals_init (TestSignals *self)
+{
+}
 
=== added file 'tests/test_glib_signals_utils.h'
--- tests/test_glib_signals_utils.h	1970-01-01 00:00:00 +0000
+++ tests/test_glib_signals_utils.h	2011-07-15 10:26:29 +0000
@@ -0,0 +1,46 @@
+/*
+ * GObject Class to allow for extensive testing of our Signal wrapper
+ */
+
+#ifndef _TEST_SIGNALS_H_
+#define _TEST_SIGNALS_H_
+
+#include <glib-object.h>
+
+G_BEGIN_DECLS
+
+#define TEST_TYPE_SIGNALS (test_signals_get_type ())
+
+#define TestSignals(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj),\
+	TEST_TYPE_SIGNALS, TestSignals))
+
+#define TestSignals_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass),\
+	TEST_TYPE_SIGNALS, TestSignalsClass))
+
+#define TEST_IS_SIGNALS(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj),\
+	TEST_TYPE_SIGNALS))
+
+#define TEST_IS_SIGNALS_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass),\
+	TEST_TYPE_SIGNALS))
+
+#define TestSignals_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj),\
+	TEST_TYPE_SIGNALS, TestSignalsClass))
+
+typedef struct _TEST_SIGNALS        TestSignals;
+typedef struct _TEST_SIGNALSClass   TestSignalsClass;
+
+struct _TEST_SIGNALS
+{
+  GObject parent;
+};
+
+struct _TEST_SIGNALSClass
+{
+  GObjectClass parent_class;
+};
+
+GType test_signals_get_type(void) G_GNUC_CONST;
+
+G_END_DECLS
+
+#endif /* _TEST_SIGNALS_H_ */
 
=== added file 'tests/test_glib_signals_utils_marshal.list'
--- tests/test_glib_signals_utils_marshal.list	1970-01-01 00:00:00 +0000
+++ tests/test_glib_signals_utils_marshal.list	2011-07-15 10:26:29 +0000
@@ -0,0 +1,6 @@
+VOID:STRING,INT
+VOID:STRING,INT,FLOAT
+VOID:STRING,INT,FLOAT,DOUBLE
+VOID:STRING,INT,FLOAT,DOUBLE,BOOL
+BOOL:STRING,INT,FLOAT,DOUBLE,BOOL,CHAR
+BOOL:STRING,INT,FLOAT,DOUBLE,BOOL,CHAR,UINT
 
=== modified file 'tests/test_indicator_entry.cpp'
--- tests/test_indicator_entry.cpp	2011-06-21 12:10:09 +0000
+++ tests/test_indicator_entry.cpp	2011-07-15 10:26:29 +0000
@@ -1,4 +1,4 @@
-#include <UnityCore/UnityCore.h>
+#include <UnityCore/IndicatorEntry.h>
 
 #include <gtest/gtest.h>
 
 
=== added file 'tests/test_main.cpp'
--- tests/test_main.cpp	1970-01-01 00:00:00 +0000
+++ tests/test_main.cpp	2011-07-15 10:26:29 +0000
@@ -0,0 +1,10 @@
+#include <gtest/gtest.h>
+#include <glib-object.h>
+
+int main(int argc, char **argv)
+{
+  ::testing::InitGoogleTest(&argc, argv);
+  g_type_init();
+
+  return RUN_ALL_TESTS();
+}