[merge] GLibSignal branch that makes signal connection a fun and joyous occasion\!

(bzr r1291)

33 files changed, 1352 insertions, 151 deletions

diff --git a/UnityCore/CMakeLists.txt b/UnityCore/CMakeLists.txt
index dfda779ba..cea85d18f 100644
--- a/UnityCore/CMakeLists.txt
+++ b/UnityCore/CMakeLists.txt
@@ -6,17 +6,19 @@ pkg_check_modules (CORE_DEPS REQUIRED glib-2.0 gio-2.0 sigc++-2.0 nux-core-1.0 g
 #
 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
diff --git a/UnityCore/DBusIndicators.cpp b/UnityCore/DBusIndicators.cpp
index 614a93da9..3ee1a6042 100644
--- a/UnityCore/DBusIndicators.cpp
+++ b/UnityCore/DBusIndicators.cpp
@@ -27,6 +27,7 @@
 #include <X11/Xlib.h>
 
 #include "config.h"
+#include "GLibSignal.h"
 #include "GLibWrapper.h"
 #include "Variant.h"
 
@@ -83,12 +84,6 @@ struct ShowEntryData
 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 @@ public:
 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 @@ public:
 
 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 @@ DBusIndicators::Impl::~Impl()
 {
 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 @@ void DBusIndicators::Impl::OnRemoteProxyReady(GDBusProxy *proxy)
 {
 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 @@ bool DBusIndicators::Impl::using_local_service() const
 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 @@ bool run_local_panel_service()
 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,
diff --git a/UnityCore/GLibSignal-inl.h b/UnityCore/GLibSignal-inl.h
new file mode 100644
index 000000000..2cfcfe5d8
--- /dev/null
+++ b/UnityCore/GLibSignal-inl.h
@@ -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 <neil.patel@canonical.com>
+*/
+
+#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
diff --git a/UnityCore/GLibSignal.cpp b/UnityCore/GLibSignal.cpp
new file mode 100644
index 000000000..f526ff6ef
--- /dev/null
+++ b/UnityCore/GLibSignal.cpp
@@ -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 <neil.patel@canonical.com>
+*/
+
+#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);
+ }
+ }
+}
+
+}
+}
+
diff --git a/UnityCore/GLibSignal.h b/UnityCore/GLibSignal.h
new file mode 100644
index 000000000..85879fe63
--- /dev/null
+++ b/UnityCore/GLibSignal.h
@@ -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 <neil.patel@canonical.com>
+*/
+
+#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
diff --git a/UnityCore/UnityCore.h b/UnityCore/UnityCore.h
deleted file mode 100644
index 9f63f2b45..000000000
--- a/UnityCore/UnityCore.h
+++ /dev/null
@@ -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 <neil.patel@canonical.com>
- */
-
-#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_
diff --git a/plugins/unityshell/src/FavoriteStoreGSettings.h b/plugins/unityshell/src/FavoriteStoreGSettings.h
index f38d5195a..091f793fa 100644
--- a/plugins/unityshell/src/FavoriteStoreGSettings.h
+++ b/plugins/unityshell/src/FavoriteStoreGSettings.h
@@ -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
diff --git a/plugins/unityshell/src/IconTexture.cpp b/plugins/unityshell/src/IconTexture.cpp
index ea2bf7243..cb57dda57 100644
--- a/plugins/unityshell/src/IconTexture.cpp
+++ b/plugins/unityshell/src/IconTexture.cpp
@@ -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"
 
diff --git a/plugins/unityshell/src/Launcher.cpp b/plugins/unityshell/src/Launcher.cpp
index e6cd2a297..9e89725bf 100644
--- a/plugins/unityshell/src/Launcher.cpp
+++ b/plugins/unityshell/src/Launcher.cpp
@@ -1,4 +1,4 @@
-// -*- Mode: C++; indent-tabs-mode: nil; tab-width: 2 -*-
+ // -*- Mode: C++; indent-tabs-mode: nil; tab-width: 2 -*-
 /*
 * Copyright (C) 2010 Canonical Ltd
 *
@@ -48,7 +48,9 @@
 #include "ubus-server.h"
 #include "UBusMessages.h"
 
-#include <UnityCore/UnityCore.h>
+#include <UnityCore/Variant.h>
+
+using namespace unity::ui;
 
 using namespace unity::ui;
 
@@ -310,7 +312,6 @@ Launcher::Launcher (nux::BaseWindow* parent,
 
 SetDndEnabled (false, true);
 
-
 icon_renderer = AbstractIconRenderer::Ptr (new IconRenderer ());
 icon_renderer->SetTargetSize (_icon_size, _icon_image_size, _space_between_icons);
 SetAcceptMouseWheelEvent (true);
diff --git a/plugins/unityshell/src/LauncherIcon.cpp b/plugins/unityshell/src/LauncherIcon.cpp
index c77e17683..6605c7667 100644
--- a/plugins/unityshell/src/LauncherIcon.cpp
+++ b/plugins/unityshell/src/LauncherIcon.cpp
@@ -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"
diff --git a/plugins/unityshell/src/PanelHomeButton.cpp b/plugins/unityshell/src/PanelHomeButton.cpp
index 09261722b..4c1bc380c 100644
--- a/plugins/unityshell/src/PanelHomeButton.cpp
+++ b/plugins/unityshell/src/PanelHomeButton.cpp
@@ -33,7 +33,7 @@
 #include <gtk/gtk.h>
 
 #include "PanelStyle.h"
-#include <UnityCore/UnityCore.h>
+#include <UnityCore/Variant.h>
 
 #define PANEL_HEIGHT 24
 
diff --git a/plugins/unityshell/src/PanelIndicatorObjectEntryView.cpp b/plugins/unityshell/src/PanelIndicatorObjectEntryView.cpp
index 24ee867a6..0423b7a07 100644
--- a/plugins/unityshell/src/PanelIndicatorObjectEntryView.cpp
+++ b/plugins/unityshell/src/PanelIndicatorObjectEntryView.cpp
@@ -37,7 +37,8 @@
 #include "PanelIndicatorObjectEntryView.h"
 
 #include "PanelStyle.h"
-#include <UnityCore/UnityCore.h>
+#include <UnityCore/GLibWrapper.h>
+#include <UnityCore/Variant.h>
 
 
 namespace unity {
diff --git a/plugins/unityshell/src/PanelIndicatorObjectEntryView.h b/plugins/unityshell/src/PanelIndicatorObjectEntryView.h
index 00283956b..b0f5b078b 100644
--- a/plugins/unityshell/src/PanelIndicatorObjectEntryView.h
+++ b/plugins/unityshell/src/PanelIndicatorObjectEntryView.h
@@ -25,7 +25,7 @@
 #include <NuxImage/CairoGraphics.h>
 #include <NuxGraphics/GraphicsEngine.h>
 
-#include <UnityCore/UnityCore.h>
+#include <UnityCore/IndicatorEntry.h>
 
 #include "Introspectable.h"
 
diff --git a/plugins/unityshell/src/PanelIndicatorObjectView.h b/plugins/unityshell/src/PanelIndicatorObjectView.h
index 45c016c1f..77765e2e5 100644
--- a/plugins/unityshell/src/PanelIndicatorObjectView.h
+++ b/plugins/unityshell/src/PanelIndicatorObjectView.h
@@ -22,7 +22,7 @@
 
 #include <Nux/View.h>
 
-#include <UnityCore/UnityCore.h>
+#include <UnityCore/Indicator.h>
 #include "PanelIndicatorObjectEntryView.h"
 
 #include "Introspectable.h"
diff --git a/plugins/unityshell/src/PanelMenuView.cpp b/plugins/unityshell/src/PanelMenuView.cpp
index b3d9033c1..01eaa9d42 100644
--- a/plugins/unityshell/src/PanelMenuView.cpp
+++ b/plugins/unityshell/src/PanelMenuView.cpp
@@ -31,7 +31,7 @@
 
 #include "PanelMenuView.h"
 #include "PanelStyle.h"
-#include <UnityCore/UnityCore.h>
+#include <UnityCore/Variant.h>
 
 #include "WindowManager.h"
 
diff --git a/plugins/unityshell/src/PanelTitlebarGrabAreaView.cpp b/plugins/unityshell/src/PanelTitlebarGrabAreaView.cpp
index 68159dd16..b13264e03 100644
--- a/plugins/unityshell/src/PanelTitlebarGrabAreaView.cpp
+++ b/plugins/unityshell/src/PanelTitlebarGrabAreaView.cpp
@@ -28,7 +28,7 @@
 #include "Nux/WindowCompositor.h"
 
 #include "PanelTitlebarGrabAreaView.h"
-#include <UnityCore/UnityCore.h>
+#include <UnityCore/Variant.h>
 
 #include <glib.h>
 
diff --git a/plugins/unityshell/src/PanelTray.h b/plugins/unityshell/src/PanelTray.h
index 5211296cb..7be224bcc 100644
--- a/plugins/unityshell/src/PanelTray.h
+++ b/plugins/unityshell/src/PanelTray.h
@@ -24,8 +24,6 @@
 
 #include <gdk/gdkx.h>
 
-#include <UnityCore/UnityCore.h>
-
 #include "Introspectable.h"
 #include "PanelIndicatorObjectView.h"
 
diff --git a/plugins/unityshell/src/PanelView.cpp b/plugins/unityshell/src/PanelView.cpp
index 0d60cffe7..832d388bf 100644
--- a/plugins/unityshell/src/PanelView.cpp
+++ b/plugins/unityshell/src/PanelView.cpp
@@ -33,7 +33,7 @@
 
 #include "PanelStyle.h"
 #include "PanelIndicatorObjectView.h"
-#include <UnityCore/UnityCore.h>
+#include <UnityCore/Variant.h>
 
 #include "PanelView.h"
 
diff --git a/plugins/unityshell/src/PanelView.h b/plugins/unityshell/src/PanelView.h
index 2c2723d44..ca3ce2f65 100644
--- a/plugins/unityshell/src/PanelView.h
+++ b/plugins/unityshell/src/PanelView.h
@@ -28,7 +28,7 @@
 
 #include <gdk/gdkx.h>
 
-#include <UnityCore/UnityCore.h>
+#include <UnityCore/DBusIndicators.h>
 
 #include "Introspectable.h"
 #include "PanelHomeButton.h"
diff --git a/plugins/unityshell/src/PlacesHomeView.cpp b/plugins/unityshell/src/PlacesHomeView.cpp
index 3d5431082..05e21f702 100644
--- a/plugins/unityshell/src/PlacesHomeView.cpp
+++ b/plugins/unityshell/src/PlacesHomeView.cpp
@@ -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>
diff --git a/plugins/unityshell/src/PlacesSearchBar.cpp b/plugins/unityshell/src/PlacesSearchBar.cpp
index 74a9a89ce..cb6945e6f 100644
--- a/plugins/unityshell/src/PlacesSearchBar.cpp
+++ b/plugins/unityshell/src/PlacesSearchBar.cpp
@@ -40,7 +40,7 @@
 #include "UBusMessages.h"
 
 #include "PlacesSearchBar.h"
-#include <UnityCore/UnityCore.h>
+#include <UnityCore/Variant.h>
 
 #include "PlacesStyle.h"
 
diff --git a/plugins/unityshell/src/PlacesSimpleTile.cpp b/plugins/unityshell/src/PlacesSimpleTile.cpp
index b6a874c3d..328d52296 100644
--- a/plugins/unityshell/src/PlacesSimpleTile.cpp
+++ b/plugins/unityshell/src/PlacesSimpleTile.cpp
@@ -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,
diff --git a/plugins/unityshell/src/PlacesView.cpp b/plugins/unityshell/src/PlacesView.cpp
index ffb8a7811..8bd42ee99 100644
--- a/plugins/unityshell/src/PlacesView.cpp
+++ b/plugins/unityshell/src/PlacesView.cpp
@@ -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);
 
diff --git a/plugins/unityshell/src/QuicklistMenuItem.cpp b/plugins/unityshell/src/QuicklistMenuItem.cpp
index 918b7a116..2c38cc1bc 100644
--- a/plugins/unityshell/src/QuicklistMenuItem.cpp
+++ b/plugins/unityshell/src/QuicklistMenuItem.cpp
@@ -23,7 +23,7 @@
 
 #include "Nux/Nux.h"
 #include "QuicklistMenuItem.h"
-#include <UnityCore/UnityCore.h>
+#include <UnityCore/Variant.h>
 
 #include <X11/Xlib.h>
 
diff --git a/plugins/unityshell/src/WindowButtons.cpp b/plugins/unityshell/src/WindowButtons.cpp
index ce1f4591a..58d226580 100644
--- a/plugins/unityshell/src/WindowButtons.cpp
+++ b/plugins/unityshell/src/WindowButtons.cpp
@@ -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>
diff --git a/po/unity.pot b/po/unity.pot
index 72a47efa8..9a9dcba29 100644
--- a/po/unity.pot
+++ b/po/unity.pot
@@ -8,7 +8,7 @@ msgid ""
 msgstr ""
 "Project-Id-Version: PACKAGE VERSION\n"
 "Report-Msgid-Bugs-To: ayatana-dev@lists.launchpad.net\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 <LL@li.org>\n"
diff --git a/tests/CMakeLists.txt b/tests/CMakeLists.txt
index d72e1e6ef..60533c474 100644
--- a/tests/CMakeLists.txt
+++ b/tests/CMakeLists.txt
@@ -20,6 +20,7 @@ set (CFLAGS
 "-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 @@ set (LIBS ${TEST_UNIT_DEPS_LIBRARIES} "-lunity-core-${UNITY_API_VERSION}")
 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})
 
@@ -287,17 +288,27 @@ add_dependencies (test-places-backend unity-core-${UNITY_API_VERSION})
 #
 # 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_timer.cpp
+ 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
- unit/TestSwitcherModel.cpp
+ test_main.cpp
+ test_timer.cpp
 ${UNITY_SRC}/Timer.h
 ${UNITY_SRC}/Timer.cpp
 ${UNITY_SRC}/AbstractLauncherIcon.h
diff --git a/tests/test_glib_signals.cpp b/tests/test_glib_signals.cpp
new file mode 100644
index 000000000..66747b88c
--- /dev/null
+++ b/tests/test_glib_signals.cpp
@@ -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_);
+}
+
+}
diff --git a/tests/test_glib_signals_utils.cpp b/tests/test_glib_signals_utils.cpp
new file mode 100644
index 000000000..708a06312
--- /dev/null
+++ b/tests/test_glib_signals_utils.cpp
@@ -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)
+{
+}
diff --git a/tests/test_glib_signals_utils.h b/tests/test_glib_signals_utils.h
new file mode 100644
index 000000000..7b85dbe2b
--- /dev/null
+++ b/tests/test_glib_signals_utils.h
@@ -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_ */
diff --git a/tests/test_glib_signals_utils_marshal.list b/tests/test_glib_signals_utils_marshal.list
new file mode 100644
index 000000000..edc0674e5
--- /dev/null
+++ b/tests/test_glib_signals_utils_marshal.list
@@ -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
diff --git a/tests/test_indicator_entry.cpp b/tests/test_indicator_entry.cpp
index a6fc34bba..a623ce466 100644
--- a/tests/test_indicator_entry.cpp
+++ b/tests/test_indicator_entry.cpp
@@ -1,4 +1,4 @@
-#include <UnityCore/UnityCore.h>
+#include <UnityCore/IndicatorEntry.h>
 
 #include <gtest/gtest.h>
 
diff --git a/tests/test_main.cpp b/tests/test_main.cpp
new file mode 100644
index 000000000..8a8cc02e3
--- /dev/null
+++ b/tests/test_main.cpp
@@ -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();
+}