Merge lp:~unity-team/unity/launcher-api into lp:unity

[Mikkel Kamstrup Erlandsen]

First cut at the Unity-side support for the Launcher DBus API.

It implements a set of helper classes that keeps everything in sync, but they are not wired up to the UI yet (except for a small dummy hook).

With this branch in the plan is to do something like:

 * In LauncherController link the LauncherEntryRemotes with LauncherIcons
 * In LauncherController remove the LauncherEntryRemotes from the LauncherEntryRemoteModel when we see apps drop off
 * Add missing rendering bits to the launcher:
  - 'emblem' and 'count' seems to be lacking, but 'progress' looks like it's there
  - quicklists probably need a fair deal of work

[Mikkel Kamstrup Erlandsen (kamstrup)]

Forgot to add - you need lp:libunity trunk (as of today) for the client side libs if you wanna have a play

[Jason Smith (jassmith)]

+1

review: Approve

=== modified file 'src/LauncherController.cpp'
--- src/LauncherController.cpp	2011-01-26 17:48:19 +0000
+++ src/LauncherController.cpp	2011-02-01 13:19:16 +0000
@@ -53,6 +53,9 @@
 
   _launcher->request_reorder_smart.connect (sigc::mem_fun (this, &LauncherController::OnLauncherRequestReorderSmart));
   _launcher->request_reorder_before.connect (sigc::mem_fun (this, &LauncherController::OnLauncherRequestReorderBefore));
+
+  _remote_model = LauncherEntryRemoteModel::GetDefault();
+  _remote_model->entry_added.connect (sigc::mem_fun (this, &LauncherController::OnLauncerEntryRemoteAdded));
 }
 
 LauncherController::~LauncherController()
@@ -188,6 +191,13 @@
 }
 
 void
+LauncherController::OnLauncerEntryRemoteAdded (LauncherEntryRemote *entry)
+{
+  g_debug ("LAUNCHER ENTRY ADDED: %s %s", entry->DBusName (), entry->AppUri ());
+  // FIXME: Wire the signals on entry up to matching LauncherIcon from the LauncherModel
+}
+
+void
 LauncherController::OnExpoClicked (int button)
 {
   if (button == 1)

=== modified file 'src/LauncherController.h'
--- src/LauncherController.h	2011-01-24 23:05:38 +0000
+++ src/LauncherController.h	2011-02-01 13:19:16 +0000
@@ -33,6 +33,9 @@
 #include "FavoriteStore.h"
 #include "PlaceLauncherSection.h"
 
+#include "LauncherEntryRemote.h"
+#include "LauncherEntryRemoteModel.h"
+
 #include <libbamf/libbamf.h>
 #include <sigc++/sigc++.h>
 
@@ -57,6 +60,7 @@
     int                    _sort_priority;
     PlaceLauncherSection*  _place_section;
     DeviceLauncherSection* _device_section;
+    LauncherEntryRemoteModel* _remote_model;
 
     void SortAndSave ();
 
@@ -64,6 +68,8 @@
     void OnLauncherRequestReorderBefore (LauncherIcon *icon, LauncherIcon *before, bool save);
     void OnIconAdded (LauncherIcon *icon);
 
+    void OnLauncerEntryRemoteAdded (LauncherEntryRemote *entry);
+
     void InsertExpoAction ();
     
     void InsertTrash ();

=== added file 'src/LauncherEntryRemote.cpp'
--- src/LauncherEntryRemote.cpp	1970-01-01 00:00:00 +0000
+++ src/LauncherEntryRemote.cpp	2011-02-01 13:19:16 +0000
@@ -0,0 +1,388 @@
+// -*- 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: Mikkel Kamstrup Erlandsen <[e-mail]>
+ */
+
+#include "LauncherEntryRemote.h"
+
+NUX_IMPLEMENT_OBJECT_TYPE (LauncherEntryRemote);
+
+/**
+ * Create a new LauncherEntryRemote parsed from the raw DBus wire format
+ * of the com.canonical.Unity.LauncherEntry.Update signal '(sa{sv})'. The
+ * dbus_name argument should be the unique bus name of the process owning
+ * the launcher entry.
+ *
+ * You don't normally need to use this constructor yourself. The
+ * LauncherEntryRemoteModel will do that for you when needed.
+ */
+LauncherEntryRemote::LauncherEntryRemote(const gchar *dbus_name, GVariant *val)
+{
+  gchar        *app_uri, *prop_key;
+  GVariantIter *prop_iter;
+  GVariant     *prop_value;
+
+  g_return_if_fail (dbus_name != NULL);
+  g_return_if_fail (val != NULL);
+
+  _dbus_name = g_strdup (dbus_name);
+
+  _emblem = NULL;
+  _count = G_GINT64_CONSTANT (0);
+  _progress = 0.0;
+  _quicklist = NULL;
+  
+  _emblem_visible = FALSE;
+  _count_visible = FALSE;
+  _progress_visible = FALSE;
+
+  g_variant_ref_sink (val);
+  g_variant_get (val, "(sa{sv})", &app_uri, &prop_iter);
+
+  _app_uri = app_uri; // steal ref
+
+  while (g_variant_iter_loop (prop_iter, "{sv}", &prop_key, &prop_value))
+    {
+      if (g_str_equal ("emblem", prop_key))
+        g_variant_get (prop_value, "s", &_emblem);
+      else if (g_str_equal ("count", prop_key))
+        _count = g_variant_get_int64 (prop_value);
+      else if (g_str_equal ("progress", prop_key))
+        _progress = g_variant_get_double (prop_value);
+      else if (g_str_equal ("emblem-visible", prop_key))
+        _emblem_visible = g_variant_get_boolean (prop_value);
+      else if (g_str_equal ("count-visible", prop_key))
+        _count_visible = g_variant_get_boolean (prop_value);
+      else if (g_str_equal ("progress-visible", prop_key))
+        _progress_visible = g_variant_get_boolean (prop_value);
+      else if (g_str_equal ("quicklist", prop_key))
+        {
+          const gchar *ql_path;
+          ql_path = g_variant_get_string (prop_value,  NULL);
+          _quicklist = dbusmenu_client_new (_dbus_name, ql_path);
+        }
+    }
+
+  g_variant_iter_free (prop_iter);
+  g_variant_unref (val);
+}
+
+LauncherEntryRemote::~LauncherEntryRemote()
+{
+  if (_dbus_name)
+    {
+      g_free (_dbus_name);
+      _dbus_name = NULL;
+    }
+
+  if (_app_uri)
+    {
+      g_free (_app_uri);
+      _app_uri = NULL;
+    }
+  
+  if (_emblem)
+    {
+      g_free (_emblem);
+      _emblem = NULL;
+    }
+
+  if (_quicklist)
+    {
+      g_object_unref (_quicklist);
+      _quicklist = NULL;
+    }
+}
+
+/**
+ * The appuri property is on the form application://$desktop_file_id and is
+ * used within the LauncherEntryRemoteModel to uniquely identify the various
+ * applications.
+ *
+ * Note that a desktop file id is defined to be the base name of the desktop
+ * file including the extension. Eg. gedit.desktop. Thus a full appuri could be
+ * application://gedit.desktop.
+ */
+const gchar*
+LauncherEntryRemote::AppUri()
+{
+  return _app_uri;
+}
+
+/**
+ * Return the unique DBus name for the remote party owning this launcher entry.
+ */
+const gchar*
+LauncherEntryRemote::DBusName()
+{
+  return _dbus_name;
+}
+
+const gchar*
+LauncherEntryRemote::Emblem()
+{
+  return _emblem;
+}
+
+gint64
+LauncherEntryRemote::Count()
+{
+  return _count;
+}
+
+gdouble
+LauncherEntryRemote::Progress()
+{
+  return _progress;
+}
+
+/**
+ * Return a pointer to the current quicklist of the launcher entry; NULL if
+ * it's unset.
+ *
+ * The returned object should not be freed.
+ */
+DbusmenuClient*
+LauncherEntryRemote::Quicklist()
+{
+  return _quicklist;
+}
+
+gboolean
+LauncherEntryRemote::EmblemVisible()
+{
+  return _emblem_visible;
+}
+
+gboolean
+LauncherEntryRemote::CountVisible()
+{
+  return _count_visible;
+}
+
+gboolean
+LauncherEntryRemote::ProgressVisible()
+{
+  return _progress_visible;
+}
+
+/**
+ * Set the unique DBus name for the process owning the launcher entry.
+ *
+ * If the entry has any exported quicklist it will be removed.
+ */
+void
+LauncherEntryRemote::SetDBusName(const gchar* dbus_name)
+{
+  gchar *old_name;
+
+  if (g_strcmp0 (_dbus_name, dbus_name) == 0)
+    return;
+
+  old_name = _dbus_name;
+  _dbus_name = g_strdup (dbus_name);
+
+  /* Remove the quicklist since we can't know if it it'll be valid on the
+   * new name, and we certainly don't want the quicklist to operate on a
+   * different name than the rest of the launcher API */
+  SetQuicklist (NULL);
+
+  dbus_name_changed.emit (old_name);
+  g_free (old_name);
+}
+
+void
+LauncherEntryRemote::SetEmblem(const gchar* emblem)
+{
+  if (g_strcmp0 (_emblem, emblem) == 0)
+    return;
+
+  if (_emblem)
+    g_free (_emblem);
+
+  _emblem = g_strdup (emblem);
+  emblem_changed.emit ();
+}
+
+void
+LauncherEntryRemote::SetCount(gint64 count)
+{
+  if (_count == count)
+    return;
+
+  _count = count;
+  count_changed.emit ();
+}
+
+void
+LauncherEntryRemote::SetProgress(gdouble progress)
+{
+  if (_progress == progress)
+    return;
+
+  _progress = progress;
+  progress_changed.emit ();
+}
+
+/**
+ * Set the quicklist of this entry to be the Dbusmenu on the given path.
+ * If entry already has a quicklist with the same path this call is a no-op.
+ *
+ * To unset the quicklist pass in a NULL path.
+ */
+void
+LauncherEntryRemote::SetQuicklistPath(const gchar *dbus_path)
+{
+  /* Check if existing quicklist have exact same path
+   * and ignore the change in that case */
+  if (_quicklist)
+    {
+      gchar *ql_path;
+      g_object_get (_quicklist, DBUSMENU_CLIENT_PROP_DBUS_OBJECT, &ql_path, NULL);
+      if (g_strcmp0 (dbus_path, ql_path) == 0)
+        {
+          g_free (ql_path);
+          return;
+        }
+
+      /* Prepare for a new quicklist */
+      g_free (ql_path);
+      g_object_unref (_quicklist);
+    }
+  else if (_quicklist == NULL && dbus_path == NULL)
+    return;
+
+  if (dbus_path != NULL)
+    _quicklist = dbusmenu_client_new (_dbus_name, dbus_path);
+  else
+    _quicklist = NULL;
+
+  quicklist_changed.emit ();
+}
+
+/**
+ * Set the quicklist of this entry to a given DbusmenuClient.
+ * If entry already has a quicklist with the same path this call is a no-op.
+ *
+ * To unset the quicklist for this entry pass in NULL as the quicklist to set.
+ */
+void
+LauncherEntryRemote::SetQuicklist(DbusmenuClient *quicklist)
+{
+  /* Check if existing quicklist have exact same path as the new one
+   * and ignore the change in that case. We also assert that the quicklist
+   * uses the same name as the connection owning this launcher entry */
+  if (_quicklist)
+    {
+      gchar *ql_path, *new_ql_path, *new_ql_name;
+      g_object_get (_quicklist, DBUSMENU_CLIENT_PROP_DBUS_OBJECT, &ql_path, NULL);
+
+      if (quicklist == NULL)
+        {
+          new_ql_path = NULL;
+          new_ql_name = NULL;
+        }
+      else
+        {
+          g_object_get (quicklist, DBUSMENU_CLIENT_PROP_DBUS_OBJECT, &new_ql_path, NULL);
+          g_object_get (quicklist, DBUSMENU_CLIENT_PROP_DBUS_NAME, &new_ql_name, NULL);
+        }
+
+      if (quicklist != NULL && g_strcmp0 (new_ql_name, _dbus_name) != 0)
+        {
+          g_critical ("Mismatch between quicklist- and launcher entry owner:"
+                      "%s and %s respectively", new_ql_name, _dbus_name);
+          g_free (ql_path);
+          g_free (new_ql_path);
+          g_free (new_ql_name);
+          return;
+        }
+
+      if (g_strcmp0 (new_ql_path, ql_path) == 0)
+        {
+          g_free (ql_path);
+          g_free (new_ql_path);
+          g_free (new_ql_name);
+          return;
+        }
+
+      /* Prepare for a new quicklist */
+      g_free (ql_path);
+      g_free (new_ql_path);
+      g_free (new_ql_name);
+      g_object_unref (_quicklist);
+    }
+  else if (_quicklist == NULL && quicklist == NULL)
+    return;
+
+  if (quicklist == NULL)
+    _quicklist = NULL;
+  else
+    _quicklist = (DbusmenuClient *) g_object_ref (quicklist);
+
+  quicklist_changed.emit ();
+}
+
+void
+LauncherEntryRemote::SetEmblemVisible(gboolean visible)
+{
+  if (_emblem_visible == visible)
+    return;
+
+  _emblem_visible = visible;
+  emblem_visible_changed.emit ();
+}
+
+void
+LauncherEntryRemote::SetCountVisible(gboolean visible)
+{
+  if (_count_visible == visible)
+      return;
+
+  _count_visible = visible;
+  count_visible_changed.emit ();
+}
+
+void
+LauncherEntryRemote::SetProgressVisible(gboolean visible)
+{
+  if (_progress_visible == visible)
+      return;
+
+  _progress_visible = visible;
+  progress_visible_changed.emit ();
+}
+
+/**
+ * Set all properties from 'other' on 'this'.
+ */
+void
+LauncherEntryRemote::Update(LauncherEntryRemote *other)
+{
+  /* It's important that we update the DBus name first since it might
+   * unset the quicklist if it changes */
+  SetDBusName (other->DBusName ());
+
+  SetEmblem (other->Emblem ());
+  SetCount (other->Count ());
+  SetProgress (other->Progress ());
+  SetQuicklist (other->Quicklist());
+
+  SetEmblemVisible (other->EmblemVisible ());
+  SetCountVisible(other->CountVisible ());
+  SetProgressVisible(other->ProgressVisible());
+}

=== added file 'src/LauncherEntryRemote.h'
--- src/LauncherEntryRemote.h	1970-01-01 00:00:00 +0000
+++ src/LauncherEntryRemote.h	2011-02-01 13:19:16 +0000
@@ -0,0 +1,96 @@
+// -*- 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: Mikkel Kamstrup Erlandsen <[e-mail]>
+ */
+
+#ifndef LAUNCHER_ENTRY_REMOTE_H
+#define LAUNCHER_ENTRY_REMOTE_H
+
+#include <Nux/Nux.h>
+#include <glib.h>
+#include <sigc++/sigc++.h>
+#include <libdbusmenu-glib/client.h>
+#include <libdbusmenu-glib/menuitem.h>
+
+/**
+ * Instances of this class mirrors the remote metadata for a laucnher entry
+ * exposed by an application via the com.canonical.Unity.LauncherEntry DBus API.
+ *
+ * You do not create instances of LauncherEntryRemote yourself. Instead they
+ * are created and managed dynamically by a LauncherEntryRemoteModel.
+ */
+class LauncherEntryRemote : public nux::InitiallyUnownedObject, public sigc::trackable
+{
+  NUX_DECLARE_OBJECT_TYPE (LauncherEntryRemote, nux::InitiallyUnownedObject);
+public:
+
+  LauncherEntryRemote(const gchar *dbus_name, GVariant *val);
+  ~LauncherEntryRemote();
+
+  const gchar*    AppUri();
+  const gchar*    DBusName();
+  const gchar*    Emblem();
+  gint64          Count();
+  gdouble         Progress();
+  DbusmenuClient* Quicklist ();
+
+  gboolean EmblemVisible();
+  gboolean CountVisible();
+  gboolean ProgressVisible();
+
+  sigc::signal<void, const gchar * > dbus_name_changed; // gives the old name as arg
+  sigc::signal<void> emblem_changed;
+  sigc::signal<void> count_changed;
+  sigc::signal<void> progress_changed;
+  sigc::signal<void> quicklist_changed;
+
+  sigc::signal<void> emblem_visible_changed;
+  sigc::signal<void> count_visible_changed;
+  sigc::signal<void> progress_visible_changed;
+
+private:
+
+  gchar  *_app_uri;
+  gchar  *_emblem;
+  gint64  _count;
+  gdouble _progress;
+
+  gchar *_dbus_name;
+  gchar *_quicklist_dbus_path;
+  DbusmenuClient *_quicklist;
+
+  gboolean _emblem_visible;
+  gboolean _count_visible;
+  gboolean _progress_visible;
+
+  void SetDBusName (const gchar *dbus_name);
+  void SetEmblem (const gchar *emblem);
+  void SetCount (gint64 count);
+  void SetProgress (gdouble progress);
+  void SetQuicklistPath (const gchar *dbus_path);
+  void SetQuicklist (DbusmenuClient *quicklist);
+
+  void SetEmblemVisible (gboolean visible);
+  void SetCountVisible (gboolean visible);
+  void SetProgressVisible (gboolean visible);
+
+  void Update (LauncherEntryRemote *other);
+
+  friend class LauncherEntryRemoteModel;
+};
+
+#endif // LAUNCHER_ENTRY_REMOTE_H

=== added file 'src/LauncherEntryRemoteModel.cpp'
--- src/LauncherEntryRemoteModel.cpp	1970-01-01 00:00:00 +0000
+++ src/LauncherEntryRemoteModel.cpp	2011-02-01 13:19:16 +0000
@@ -0,0 +1,298 @@
+// -*- 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: Mikkel Kamstrup Erlandsen <[e-mail]>
+ */
+
+#include "LauncherEntryRemoteModel.h"
+
+static void on_launcher_entry_signal_received (GDBusConnection *connection,
+                                               const gchar *sender_name,
+                                               const gchar *object_path,
+                                               const gchar *interface_name,
+                                               const gchar *signal_name,
+                                               GVariant *parameters,
+                                               gpointer user_data);
+
+static void nux_object_destroy_notify (nux::Object *obj);
+
+/**
+ * Helper class implementing the remote API to control the icons in the
+ * launcher. Also known as the com.canonical.Unity.LauncherEntry DBus API.
+ * It enables clients to dynamically control their launcher icons by
+ * adding a counter, progress indicator, or emblem to it. It also supports
+ * adding a quicklist menu by means of the dbusmenu library.
+ *
+ * We take care to print out any client side errors or oddities in detail,
+ * in order to help third party developers as much as possible when integrating
+ * with Unity.
+ */
+LauncherEntryRemoteModel::LauncherEntryRemoteModel()
+{
+  GError          *error;
+
+  _launcher_entry_dbus_signal_id = 0;
+
+  error = NULL;
+  _conn = g_bus_get_sync (G_BUS_TYPE_SESSION, NULL, &error);
+  if (error)
+    {
+      g_warning ("Unable to connect to session bus: %s", error->message);
+      g_error_free (error);
+      return;
+    }
+  
+  _entries_by_uri = g_hash_table_new_full (g_str_hash, g_str_equal, g_free,
+                                           (GDestroyNotify) nux_object_destroy_notify);
+
+  /* Listen for *all* signals on the "com.canonical.Unity.LauncherEntry"
+   * interface, no matter who the sender is */
+  _launcher_entry_dbus_signal_id =
+      g_dbus_connection_signal_subscribe (_conn,
+                                          NULL,                       // sender
+                                          "com.canonical.Unity.LauncherEntry",
+                                          NULL,                       // member
+                                          NULL,                       // path
+                                          NULL,                       // arg0
+                                          G_DBUS_SIGNAL_FLAGS_NONE,
+                                          on_launcher_entry_signal_received,
+                                          this,
+                                          NULL);
+}
+
+LauncherEntryRemoteModel::~LauncherEntryRemoteModel()
+{
+  g_hash_table_destroy (_entries_by_uri);
+  _entries_by_uri = NULL;
+
+  if (_launcher_entry_dbus_signal_id && _conn)
+    {
+      g_dbus_connection_signal_unsubscribe (_conn,
+                                            _launcher_entry_dbus_signal_id);
+      _launcher_entry_dbus_signal_id = 0;
+    }
+  
+  if (_conn)
+    {
+      g_object_unref (_conn);
+      _conn = NULL;
+    }
+}
+
+/**
+ * Get a pointer to the default LauncherEntryRemoteModel singleton for this
+ * process. The return value should not be freed.
+ */
+LauncherEntryRemoteModel*
+LauncherEntryRemoteModel::GetDefault()
+{
+  static LauncherEntryRemoteModel *singleton = NULL;
+
+  if (singleton == NULL)
+    singleton = new LauncherEntryRemoteModel ();
+
+  return singleton;
+}
+
+/**
+ * Return the number of unique LauncherEntryRemote objects managed by the model.
+ * The entries are identified by their LauncherEntryRemote::AppUri property.
+ */
+guint
+LauncherEntryRemoteModel::Size ()
+{
+  return g_hash_table_size (_entries_by_uri);
+}
+
+/**
+ * Return a pointer to a LauncherEntryRemote if there is one for app_uri,
+ * otherwise NULL. The returned object should not be freed.
+ *
+ * App Uris look like application://$desktop_file_id, where desktop_file_id
+ * is the base name of the .desktop file for the application including the
+ * .desktop extension. Eg. application://firefox.desktop.
+ */
+LauncherEntryRemote*
+LauncherEntryRemoteModel::LookupByUri (const gchar *app_uri)
+{
+  gpointer entry;
+
+  g_return_val_if_fail (app_uri != NULL, NULL);
+
+  entry = g_hash_table_lookup (_entries_by_uri,  app_uri);
+  return static_cast<LauncherEntryRemote *> (entry);
+}
+
+/**
+ * Return a pointer to a LauncherEntryRemote if there is one for desktop_id,
+ * otherwise NULL. The returned object should not be freed.
+ *
+ * The desktop id is the base name of the .desktop file for the application
+ * including the .desktop extension. Eg. firefox.desktop.
+ */
+LauncherEntryRemote*
+LauncherEntryRemoteModel::LookupByDesktopId (const gchar *desktop_id)
+{
+  LauncherEntryRemote *entry;
+  gchar               *app_uri;
+
+  g_return_val_if_fail (desktop_id != NULL, NULL);
+
+  app_uri = g_strconcat ("application://", desktop_id, NULL);
+  entry = LookupByUri (app_uri);
+  g_free (app_uri);
+
+  return entry;
+}
+
+/**
+ * Return a pointer to a LauncherEntryRemote if there is one for
+ * desktop_file_path, otherwise NULL. The returned object should not be freed.
+ */
+LauncherEntryRemote*
+LauncherEntryRemoteModel::LookupByDesktopFile (const gchar *desktop_file_path)
+{
+  LauncherEntryRemote *entry;
+  gchar               *desktop_id, *app_uri;
+
+  g_return_val_if_fail (desktop_file_path != NULL, NULL);
+
+  desktop_id = g_path_get_basename (desktop_file_path);
+  app_uri = g_strconcat ("application://", desktop_id, NULL);
+  entry = LookupByUri (app_uri);
+  g_free (app_uri);
+  g_free (desktop_id);
+
+  return entry;
+}
+
+/**
+ * Get a list of all application URIs which have registered with the launcher
+ * API. The returned GList should be freed with g_list_free(), but the URIs
+ * should not be changed or freed.
+ */
+GList*
+LauncherEntryRemoteModel::GetUris ()
+{
+  return (GList*) g_hash_table_get_keys (_entries_by_uri);
+}
+
+/**
+ * Add or update a remote launcher entry.
+ *
+ * If 'entry' has a floating reference it will be consumed.
+ */
+void
+LauncherEntryRemoteModel::AddEntry (LauncherEntryRemote *entry)
+{
+  LauncherEntryRemote *existing_entry;
+
+  g_return_if_fail (entry != NULL);
+
+  entry->SinkReference ();
+
+  existing_entry = LookupByUri (entry->AppUri ());
+  if (existing_entry != NULL)
+    {
+      existing_entry->Update (entry);
+      entry->UnReference ();
+    }
+  else
+    {
+      /* The ref on entry will be removed by the hash table itself */
+      g_hash_table_insert (_entries_by_uri, g_strdup (entry->AppUri ()), entry);
+      entry_added.emit (entry);
+    }
+}
+
+/**
+ * Add or update a remote launcher entry.
+ *
+ * If 'entry' has a floating reference it will be consumed.
+ */
+void
+LauncherEntryRemoteModel::RemoveEntry (LauncherEntryRemote *entry)
+{
+  g_return_if_fail (entry != NULL);
+
+  /* We need a temp ref on entry to keep it alive during signal emission */
+  entry->SinkReference ();
+
+  if (g_hash_table_remove (_entries_by_uri, entry->AppUri ()))
+    {
+      entry_removed.emit (entry);
+    }
+
+  entry->UnReference ();
+}
+
+static void
+on_launcher_entry_signal_received (GDBusConnection *connection,
+                                   const gchar     *sender_name,
+                                   const gchar     *object_path,
+                                   const gchar     *interface_name,
+                                   const gchar     *signal_name,
+                                   GVariant        *parameters,
+                                   gpointer         user_data)
+{
+  LauncherEntryRemoteModel *self;
+  LauncherEntryRemote      *entry;
+
+  self = static_cast<LauncherEntryRemoteModel *> (user_data);
+
+  if (parameters == NULL)
+    {
+      g_warning ("Received DBus signal '%s.%s' with empty payload from %s",
+                 interface_name, signal_name, sender_name);
+      return;
+    }
+
+  if (g_strcmp0 (signal_name, "Update") == 0)
+    {
+      if (!g_variant_is_of_type (parameters, G_VARIANT_TYPE ("(sa{sv})")))
+        {
+          g_warning ("Received 'com.canonical.Unity.LauncherEntry.Update' with"
+                     " illegal payload signature '%s'. Expected '(sa{sv})'.",
+                     g_variant_get_type_string (parameters));
+          return;
+        }
+
+      if (sender_name == NULL)
+        {
+          g_critical ("Received 'com.canonical.Unity.LauncherEntry.Update' from"
+                      " an undefined sender. This may happen if you are trying "
+                      "to run Unity on a p2p DBus connection.");
+          return;
+        }
+
+      entry = new LauncherEntryRemote (sender_name, parameters);
+      self->AddEntry (entry); // consumes floating ref on entry
+    }
+  else
+    {
+      g_warning ("Unknown signal '%s.%s' from %s",
+                 interface_name, signal_name, sender_name);
+    }
+
+
+}
+
+static void
+nux_object_destroy_notify (nux::Object *obj)
+{
+  if (G_LIKELY (obj != NULL))
+    obj->UnReference();
+}

=== added file 'src/LauncherEntryRemoteModel.h'
--- src/LauncherEntryRemoteModel.h	1970-01-01 00:00:00 +0000
+++ src/LauncherEntryRemoteModel.h	2011-02-01 13:19:16 +0000
@@ -0,0 +1,56 @@
+// -*- 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: Mikkel Kamstrup Erlandsen <[e-mail]>
+ */
+
+#ifndef LAUNCHER_ENTRY_REMOTE_MODEL_H
+#define LAUNCHER_ENTRY_REMOTE_MODEL_H
+
+#include <glib.h>
+#include <sigc++/sigc++.h>
+
+#include "LauncherEntryRemote.h"
+
+class LauncherEntryRemoteModel : public sigc::trackable
+{
+
+public:
+
+  static LauncherEntryRemoteModel* GetDefault ();
+
+  guint                Size ();
+  LauncherEntryRemote* LookupByUri (const gchar *app_uri);
+  LauncherEntryRemote* LookupByDesktopId (const gchar *desktop_id);
+  LauncherEntryRemote* LookupByDesktopFile (const gchar *desktop_file_path);
+  GList*               GetUris ();
+
+  void AddEntry (LauncherEntryRemote *entry);
+  void RemoveEntry (LauncherEntryRemote *entry);
+
+  sigc::signal<void, LauncherEntryRemote *> entry_added;
+  sigc::signal<void, LauncherEntryRemote *> entry_removed;
+
+private:
+  LauncherEntryRemoteModel();
+  ~LauncherEntryRemoteModel();
+
+  GDBusConnection *_conn;
+  guint            _launcher_entry_dbus_signal_id;
+  GHashTable      *_entries_by_uri;
+};
+
+#endif // LAUNCHER_ENTRY_REMOTE_MODEL_H