Merge lp:~canonical-dx-team/unity/unity.add-multiple-plugins-to-buildsystem into lp:unity

[Sam Spilsbury]

Allows us to drop more plugins into the package

[Mikkel Kamstrup Erlandsen (kamstrup)]

By looking at the diff it appears you've used plain bzr rm/add to move
the files instead of bzr mv? The latter will preserve the annotation
history for the future afaik.

[Neil J. Patel (njpatel)]

Agreed with Mikkel, though the new bits look good, please re-do using bzr mv to not break the file id's and packaging.

review: Needs Fixing

[Didier Roche-Tolomelli (didrocks)]

I think this fix is totally deprecated with the current code :)

Unmerged revisions

703. By Sam Spilsbury on 2010-12-13

Fixed up the unityshell build

702. By Sam Spilsbury on 2010-12-13

Add the ability to build plugins separately as part of the unity package.

Removed:
 * src/ (We don't need to support a single plugin build)
Added:
 * plugins/
   - Drop whatever plugins we want to build in here
   - CMakeLists.txt will pick up these plugins
Changed:
 * tests/
   - At the moment we need to hardcode ../plugins/unityshell/src for linking

=== modified file 'CMakeLists.txt'
--- CMakeLists.txt	2010-12-09 18:02:17 +0000
+++ CMakeLists.txt	2010-12-13 12:41:23 +0000
@@ -72,18 +72,22 @@
 endif (${GETTEXT_FOUND} STREQUAL "TRUE")
 
 #
-# src (Compiz Plugin)
+# Compiz Plugins
 #
-set (UNITY_PLUGIN_DEPS "nux-0.9;libbamf;dbus-glib-1;dee-1.0;gio-2.0;gio-unix-2.0;dbusmenu-glib;x11;libstartup-notification-1.0;gthread-2.0;indicator")
 
 find_package (Compiz REQUIRED)
-include (CompizPlugin)
-compiz_plugin (unityshell
-               PKGDEPS ${UNITY_PLUGIN_DEPS}
-               PLUGINDEPS composite opengl
-               CFLAGSADD "-DINSTALLPREFIX='\"${CMAKE_INSTALL_PREFIX}\"' -DPKGDATADIR='\"${CMAKE_INSTALL_PREFIX}/share/unity/3\"' -I${CMAKE_BINARY_DIR}"
-               LIBRARIES "unity"
-               )
+
+include (CompizCommon)
+include (CompizPackage)
+
+compiz_add_plugins_in_folder ("${CMAKE_SOURCE_DIR}/plugins")
+
+compiz_print_configure_header ("Compiz Elements Plugins")
+compiz_print_plugin_stats ("${CMAKE_SOURCE_DIR}/plugins")
+compiz_print_configure_footer ()
+
+compiz_package_generation ("Compiz Unity Plugins")
+compiz_add_uninstall ()
 
 #
 # GSettings Schema

=== added directory 'plugins'
=== added file 'plugins/CMakeLists.txt'
--- plugins/CMakeLists.txt	1970-01-01 00:00:00 +0000
+++ plugins/CMakeLists.txt	2010-12-13 12:41:23 +0000
@@ -0,0 +1,10 @@
+find_package (Compiz REQUIRED)
+
+include (CompizCommon)
+include (CompizPackage)
+
+compiz_add_plugins_in_folder ("${CMAKE_CURENT_SOURCE_DIR}")
+
+compiz_print_configure_header ("Unity")
+compiz_print_plugin_stats ("${CMAKE_CURRENT_SOURCE_DIR}")
+compiz_print_configure_footer ()

=== added directory 'plugins/unityshell'
=== added file 'plugins/unityshell/CMakeLists.txt'
--- plugins/unityshell/CMakeLists.txt	1970-01-01 00:00:00 +0000
+++ plugins/unityshell/CMakeLists.txt	2010-12-13 12:41:23 +0000
@@ -0,0 +1,11 @@
+set (UNITY_PLUGIN_DEPS "nux-0.9;libbamf;dbus-glib-1;dee-1.0;gio-2.0;gio-unix-2.0;dbusmenu-glib;x11;libstartup-notification-1.0;gthread-2.0;indicator")
+
+find_package (Compiz REQUIRED)
+include (CompizPlugin)
+
+compiz_plugin (unityshell
+               PKGDEPS ${UNITY_PLUGIN_DEPS}
+               PLUGINDEPS composite opengl
+               CFLAGSADD "-DINSTALLPREFIX='\"${CMAKE_INSTALL_PREFIX}\"' -DPKGDATADIR='\"${CMAKE_INSTALL_PREFIX}/share/unity/3\"' -I${CMAKE_BINARY_DIR}"
+               LIBRARIES "unity"
+               )

=== added directory 'plugins/unityshell/src'
=== added file 'plugins/unityshell/src/BamfLauncherIcon.cpp'
--- plugins/unityshell/src/BamfLauncherIcon.cpp	1970-01-01 00:00:00 +0000
+++ plugins/unityshell/src/BamfLauncherIcon.cpp	2010-12-13 12:41:23 +0000
@@ -0,0 +1,662 @@
+/*
+ * Copyright (C) 2010 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: Jason Smith <[e-mail]>
+ */
+
+#include "Nux/Nux.h"
+#include "Nux/BaseWindow.h"
+
+#include "BamfLauncherIcon.h"
+#include "Launcher.h"
+#include "PluginAdapter.h"
+#include "FavoriteStore.h"
+
+#include <gio/gdesktopappinfo.h>
+#include <libindicator/indicator-desktop-shortcuts.h>
+#include <core/core.h>
+#include <core/atoms.h>
+
+struct _ShortcutData
+{
+  BamfLauncherIcon *self;
+  IndicatorDesktopShortcuts *shortcuts;
+  char *nick;
+};
+typedef struct _ShortcutData ShortcutData;
+static void shortcut_data_destroy (ShortcutData *data)
+{
+  g_object_unref (data->shortcuts);
+  g_free (data->nick);
+  g_slice_free (ShortcutData, data);
+}
+
+static void shortcut_activated (DbusmenuMenuitem* _sender, guint timestamp, gpointer userdata)
+{
+  ShortcutData *data = (ShortcutData *)userdata;
+  indicator_desktop_shortcuts_nick_exec (data->shortcuts, data->nick);
+}
+
+BamfLauncherIcon::BamfLauncherIcon (Launcher* IconManager, BamfApplication *app, CompScreen *screen)
+:   SimpleLauncherIcon(IconManager)
+{
+  m_App = app;
+  m_Screen = screen;
+  _menu_desktop_shortcuts = NULL;
+  char *icon_name = bamf_view_get_icon (BAMF_VIEW (m_App));
+
+  SetTooltipText (bamf_view_get_name (BAMF_VIEW (app)));
+  SetIconName (icon_name);
+  SetIconType (LAUNCHER_ICON_TYPE_APPLICATION);
+
+  if (bamf_view_is_sticky (BAMF_VIEW (m_App)))
+    SetQuirk (LAUNCHER_ICON_QUIRK_VISIBLE, true);
+  else
+    SetQuirk (LAUNCHER_ICON_QUIRK_VISIBLE, bamf_view_user_visible (BAMF_VIEW (m_App)));
+
+  SetQuirk (LAUNCHER_ICON_QUIRK_ACTIVE, bamf_view_is_active (BAMF_VIEW (m_App)));
+  SetQuirk (LAUNCHER_ICON_QUIRK_RUNNING, bamf_view_is_running (BAMF_VIEW (m_App)));
+
+  g_free (icon_name);
+
+  g_signal_connect (app, "child-removed", (GCallback) &BamfLauncherIcon::OnChildRemoved, this);
+  g_signal_connect (app, "child-added", (GCallback) &BamfLauncherIcon::OnChildAdded, this);
+  g_signal_connect (app, "urgent-changed", (GCallback) &BamfLauncherIcon::OnUrgentChanged, this);
+  g_signal_connect (app, "running-changed", (GCallback) &BamfLauncherIcon::OnRunningChanged, this);
+  g_signal_connect (app, "active-changed", (GCallback) &BamfLauncherIcon::OnActiveChanged, this);
+  g_signal_connect (app, "user-visible-changed", (GCallback) &BamfLauncherIcon::OnUserVisibleChanged, this);
+  g_signal_connect (app, "closed", (GCallback) &BamfLauncherIcon::OnClosed, this);
+
+  g_object_ref (m_App);
+
+  EnsureWindowState ();
+  UpdateMenus ();
+}
+
+BamfLauncherIcon::~BamfLauncherIcon()
+{
+  g_signal_handlers_disconnect_by_func (m_App, (void *) &BamfLauncherIcon::OnChildRemoved,       this);
+  g_signal_handlers_disconnect_by_func (m_App, (void *) &BamfLauncherIcon::OnChildAdded,         this);
+  g_signal_handlers_disconnect_by_func (m_App, (void *) &BamfLauncherIcon::OnUrgentChanged,      this);
+  g_signal_handlers_disconnect_by_func (m_App, (void *) &BamfLauncherIcon::OnRunningChanged,     this);
+  g_signal_handlers_disconnect_by_func (m_App, (void *) &BamfLauncherIcon::OnActiveChanged,      this);
+  g_signal_handlers_disconnect_by_func (m_App, (void *) &BamfLauncherIcon::OnUserVisibleChanged, this);
+  g_signal_handlers_disconnect_by_func (m_App, (void *) &BamfLauncherIcon::OnClosed,             this);
+
+  g_object_unref (m_App);
+}
+
+bool 
+BamfLauncherIcon::IsSticky ()
+{
+  return bamf_view_is_sticky (BAMF_VIEW (m_App));
+}
+
+const char* 
+BamfLauncherIcon::DesktopFile ()
+{
+  return bamf_application_get_desktop_file (m_App);
+}
+
+void
+BamfLauncherIcon::AddProperties (GVariantBuilder *builder)
+{
+  LauncherIcon::AddProperties (builder);
+
+  g_variant_builder_add (builder, "{sv}", "desktop-file", g_variant_new_string (bamf_application_get_desktop_file (m_App)));
+  
+  GList *children, *l;
+  BamfView *view;
+  
+  children = bamf_view_get_children (BAMF_VIEW (m_App));
+  GVariant* xids[(int) g_list_length (children)];
+  
+  int i = 0;
+  for (l = children; l; l = l->next)
+  {
+    view = (BamfView *) l->data;
+    
+    if (BAMF_IS_WINDOW (view))
+    {
+      xids[i++] = g_variant_new_uint32 (bamf_window_get_xid (BAMF_WINDOW (view)));
+    }    
+  }
+  g_list_free (children);
+  g_variant_builder_add (builder, "{sv}", "xids", g_variant_new_array (G_VARIANT_TYPE_UINT32, xids, i));
+}
+
+bool
+BamfLauncherIcon::IconOwnsWindow (Window w)
+{
+  GList *children, *l;
+  BamfView *view;
+  bool owns = false;
+
+  children = bamf_view_get_children (BAMF_VIEW (m_App));
+
+  for (l = children; l; l = l->next)
+  {
+    view = (BamfView *) l->data;
+
+    if (BAMF_IS_WINDOW (view))
+    {
+      guint32 xid = bamf_window_get_xid (BAMF_WINDOW (view));
+
+      if (xid == w)
+      {
+        owns = true;
+        break;
+      }
+    }
+  }
+
+  g_list_free (children);
+  return owns;
+}
+
+void
+BamfLauncherIcon::OpenInstance ()
+{
+  GDesktopAppInfo *appInfo;
+  GError *error = NULL;
+
+  appInfo = g_desktop_app_info_new_from_filename (bamf_application_get_desktop_file (BAMF_APPLICATION (m_App)));
+  g_app_info_launch (G_APP_INFO (appInfo), NULL, NULL, &error);
+  g_object_unref (appInfo);
+
+  if (error)
+  {
+    g_warning ("%s\n", error->message);
+    g_error_free (error);
+  }
+
+  UpdateQuirkTime (LAUNCHER_ICON_QUIRK_STARTING);
+}
+
+void
+BamfLauncherIcon::Focus ()
+{
+  GList *children, *l;
+  BamfView *view;
+
+  children = bamf_view_get_children (BAMF_VIEW (m_App));
+
+  CompWindowList windows;
+
+  /* get the list of windows */
+  for (l = children; l; l = l->next)
+  {
+    view = (BamfView *) l->data;
+
+    if (BAMF_IS_WINDOW (view))
+    {
+      guint32 xid = bamf_window_get_xid (BAMF_WINDOW (view));
+
+      CompWindow *window = m_Screen->findWindow ((Window) xid);
+
+      if (window)
+        windows.push_back (window);
+    }
+  }
+
+  if (windows.empty ())
+    return;
+
+  /* sort the list */
+  CompWindowList tmp;
+  CompWindowList::iterator it;
+  for (it = m_Screen->windows ().begin (); it != m_Screen->windows ().end (); it++)
+  {
+    if (std::find (windows.begin (), windows.end (), *it) != windows.end ())
+      tmp.push_back (*it);
+  }
+  windows = tmp;
+
+
+  /* filter based on workspace */
+  bool any_on_current = false;
+
+  for (it = windows.begin (); it != windows.end (); it++)
+  {
+    if ((*it)->defaultViewport () == m_Screen->vp ())
+    {
+      any_on_current = true;
+      break;
+    }
+  }
+
+  /* activate our windows */
+
+  if (any_on_current)
+  {
+    for (it = windows.begin (); it != windows.end (); it++)
+    {
+      if ((*it)->defaultViewport () == m_Screen->vp ())
+      {
+        (*it)->activate ();
+      }
+    }
+  }
+  else
+  {
+    (*(windows.rbegin ()))->activate ();
+  }
+
+  g_list_free (children);
+}
+
+void
+BamfLauncherIcon::Spread ()
+{
+  BamfView *view;
+  GList *children, *l;
+  children = bamf_view_get_children (BAMF_VIEW (m_App));
+
+  std::list<Window> windowList;
+  for (l = children; l; l = l->next)
+  {
+    view = (BamfView *) l->data;
+
+    if (BAMF_IS_WINDOW (view))
+    {
+      guint32 xid = bamf_window_get_xid (BAMF_WINDOW (view));
+
+      windowList.push_back ((Window) xid);
+    }
+  }
+
+  if (windowList.size () > 1)
+  {
+    std::string *match = PluginAdapter::Default ()->MatchStringForXids (&windowList);
+    PluginAdapter::Default ()->InitiateScale (match);
+    delete match;
+  }
+
+  g_list_free (children);
+}
+
+void
+BamfLauncherIcon::OnMouseClick (int button)
+{
+  if (button != 1)
+    return;
+
+  bool active, running;
+
+  active = bamf_view_is_active (BAMF_VIEW (m_App));
+  running = bamf_view_is_running (BAMF_VIEW (m_App));
+  
+  if (!running)
+  {
+    if (GetQuirk (LAUNCHER_ICON_QUIRK_STARTING))
+      return;
+    SetQuirk (LAUNCHER_ICON_QUIRK_STARTING, true);
+    OpenInstance ();
+    return;
+  }
+  else if (active)
+    Spread ();
+  else
+    Focus ();
+}
+
+void
+BamfLauncherIcon::OnClosed (BamfView *view, gpointer data)
+{
+  BamfLauncherIcon *self = (BamfLauncherIcon *) data;
+
+  if (!bamf_view_is_sticky (BAMF_VIEW (self->m_App)))
+    self->Remove ();
+}
+
+void
+BamfLauncherIcon::OnUserVisibleChanged (BamfView *view, gboolean visible, gpointer data)
+{
+  BamfLauncherIcon *self = (BamfLauncherIcon *) data;
+
+  if (!bamf_view_is_sticky (BAMF_VIEW (self->m_App)))
+    self->SetQuirk (LAUNCHER_ICON_QUIRK_VISIBLE, visible);
+}
+
+void
+BamfLauncherIcon::OnRunningChanged (BamfView *view, gboolean running, gpointer data)
+{
+  BamfLauncherIcon *self = (BamfLauncherIcon *) data;
+  self->SetQuirk (LAUNCHER_ICON_QUIRK_RUNNING, running);
+
+  if (running)
+  {
+    self->EnsureWindowState ();
+    self->UpdateIconGeometries (self->GetCenter ());
+  }
+}
+
+void
+BamfLauncherIcon::OnActiveChanged (BamfView *view, gboolean active, gpointer data)
+{
+  BamfLauncherIcon *self = (BamfLauncherIcon *) data;
+  self->SetQuirk (LAUNCHER_ICON_QUIRK_ACTIVE, active);
+}
+
+void
+BamfLauncherIcon::OnUrgentChanged (BamfView *view, gboolean urgent, gpointer data)
+{
+  BamfLauncherIcon *self = (BamfLauncherIcon *) data;
+  self->SetQuirk (LAUNCHER_ICON_QUIRK_URGENT, urgent);
+}
+
+void
+BamfLauncherIcon::EnsureWindowState ()
+{
+  GList *children, *l;
+  int count = 0;
+
+  children = bamf_view_get_children (BAMF_VIEW (m_App));
+  for (l = children; l; l = l->next)
+  {
+    if (BAMF_IS_WINDOW (l->data))
+      count++;
+  }
+
+  SetRelatedWindows (count);
+
+  g_list_free (children);
+}
+
+void
+BamfLauncherIcon::OnChildAdded (BamfView *view, BamfView *child, gpointer data)
+{
+  BamfLauncherIcon *self = (BamfLauncherIcon*) data;
+  self->EnsureWindowState ();
+  self->UpdateMenus ();
+  self->UpdateIconGeometries (self->GetCenter ());
+}
+
+void
+BamfLauncherIcon::OnChildRemoved (BamfView *view, BamfView *child, gpointer data)
+{
+  BamfLauncherIcon *self = (BamfLauncherIcon*) data;
+  self->EnsureWindowState ();
+}
+
+void
+BamfLauncherIcon::UpdateMenus ()
+{
+  GList *children, *l;
+  IndicatorDesktopShortcuts *desktop_shortcuts;
+
+  children = bamf_view_get_children (BAMF_VIEW (m_App));
+  for (l = children; l; l = l->next)
+  {
+    if (!BAMF_IS_INDICATOR (l->data))
+      continue;
+
+    BamfIndicator *indicator = BAMF_INDICATOR (l->data);
+    std::string path = bamf_indicator_get_dbus_menu_path (indicator);
+
+    // we already have this
+    if (_menu_clients.find (path) != _menu_clients.end ())
+      continue;
+
+    DbusmenuClient *client = dbusmenu_client_new (bamf_indicator_get_remote_address (indicator), path.c_str ());
+    _menu_clients[path] = client;
+  }
+
+  g_list_free (children);
+
+  // make a client for desktop file actions
+  if (!DBUSMENU_IS_MENUITEM (_menu_desktop_shortcuts) &&
+      bamf_application_get_desktop_file (m_App) != NULL)
+  {
+
+    DbusmenuMenuitem *root = dbusmenu_menuitem_new ();
+    dbusmenu_menuitem_set_root (root, TRUE);
+    desktop_shortcuts = indicator_desktop_shortcuts_new (bamf_application_get_desktop_file (m_App),
+                                                         "Unity");
+    const gchar **nicks = indicator_desktop_shortcuts_get_nicks (desktop_shortcuts);
+
+    int index = 0;
+    if (nicks) {
+      while (((gpointer*) nicks)[index]) {
+        const char* name;
+        DbusmenuMenuitem *item;
+        name = g_strdup (indicator_desktop_shortcuts_nick_get_name (desktop_shortcuts,
+                                                                    nicks[index]));
+        ShortcutData *data = g_slice_new0 (ShortcutData);
+        data->self = this;
+        data->shortcuts = INDICATOR_DESKTOP_SHORTCUTS (g_object_ref (desktop_shortcuts));
+        data->nick = g_strdup (nicks[index]);
+
+        item = dbusmenu_menuitem_new ();
+        dbusmenu_menuitem_property_set (item, DBUSMENU_MENUITEM_PROP_LABEL, name);
+        dbusmenu_menuitem_property_set_bool (item, DBUSMENU_MENUITEM_PROP_ENABLED, TRUE);
+        dbusmenu_menuitem_property_set_bool (item, DBUSMENU_MENUITEM_PROP_VISIBLE, TRUE);
+        g_signal_connect_data (item, "item-activated",
+                              (GCallback) shortcut_activated, (gpointer) data,
+                              (GClosureNotify) shortcut_data_destroy, (GConnectFlags)0);
+
+        dbusmenu_menuitem_child_append (root, item);
+
+        index++;
+
+        g_free ((void *)name);
+      }
+    }
+
+    _menu_desktop_shortcuts = root;
+  }
+
+}
+
+void
+BamfLauncherIcon::OnLaunch (DbusmenuMenuitem *item, int time, BamfLauncherIcon *self)
+{
+  self->OpenInstance ();
+}
+
+void
+BamfLauncherIcon::OnQuit (DbusmenuMenuitem *item, int time, BamfLauncherIcon *self)
+{
+  GList *children, *l;
+  BamfView *view;
+
+  children = bamf_view_get_children (BAMF_VIEW (self->m_App));
+
+  for (l = children; l; l = l->next)
+  {
+    view = (BamfView *) l->data;
+
+    if (BAMF_IS_WINDOW (view))
+    {
+      guint32 xid = bamf_window_get_xid (BAMF_WINDOW (view));
+      CompWindow *window = self->m_Screen->findWindow ((Window) xid);
+
+      if (window)
+        window->close (self->m_Screen->getCurrentTime ());
+    }
+  }
+
+  g_list_free (children);
+}
+
+void
+BamfLauncherIcon::OnTogglePin (DbusmenuMenuitem *item, int time, BamfLauncherIcon *self)
+{
+  BamfView *view = BAMF_VIEW (self->m_App);
+  bool sticky = bamf_view_is_sticky (view);
+  const gchar *desktop_file = bamf_application_get_desktop_file (self->m_App);
+
+  if (sticky)
+  {
+    bamf_view_set_sticky (view, false);
+    if (bamf_view_is_closed (view))
+      self->Remove ();
+
+    if (desktop_file && strlen (desktop_file) > 0)
+      FavoriteStore::GetDefault ()->RemoveFavorite (desktop_file);
+  }
+  else
+  {
+    bamf_view_set_sticky (view, true);
+
+    if (desktop_file && strlen (desktop_file) > 0)
+      FavoriteStore::GetDefault ()->AddFavorite (desktop_file, -1); //self->SortPriority ());
+  }
+}
+
+void
+BamfLauncherIcon::EnsureMenuItemsReady ()
+{
+  DbusmenuMenuitem *menu_item;
+
+  /* Launch */
+  if (_menu_items.find ("Launch") == _menu_items.end ())
+  {
+    menu_item = dbusmenu_menuitem_new ();
+    g_object_ref (menu_item);
+
+    dbusmenu_menuitem_property_set (menu_item, DBUSMENU_MENUITEM_PROP_LABEL, "Open New Window");
+    dbusmenu_menuitem_property_set_bool (menu_item, DBUSMENU_MENUITEM_PROP_ENABLED, true);
+
+    g_signal_connect (menu_item, DBUSMENU_MENUITEM_SIGNAL_ITEM_ACTIVATED, (GCallback) &BamfLauncherIcon::OnLaunch, this);
+
+    _menu_items["Launch"] = menu_item;
+  }
+
+  /* Pin */
+  if (_menu_items.find ("Pin") == _menu_items.end ())
+  {
+    menu_item = dbusmenu_menuitem_new ();
+    g_object_ref (menu_item);
+
+    dbusmenu_menuitem_property_set (menu_item, DBUSMENU_MENUITEM_PROP_TOGGLE_TYPE, DBUSMENU_MENUITEM_TOGGLE_CHECK);
+    dbusmenu_menuitem_property_set (menu_item, DBUSMENU_MENUITEM_PROP_LABEL, "Keep In Launcher");
+    dbusmenu_menuitem_property_set_bool (menu_item, DBUSMENU_MENUITEM_PROP_ENABLED, true);
+
+    g_signal_connect (menu_item, DBUSMENU_MENUITEM_SIGNAL_ITEM_ACTIVATED, (GCallback) &BamfLauncherIcon::OnTogglePin, this);
+
+    _menu_items["Pin"] = menu_item;
+  }
+  int checked = !bamf_view_is_sticky (BAMF_VIEW (m_App)) ?
+                 DBUSMENU_MENUITEM_TOGGLE_STATE_CHECKED : DBUSMENU_MENUITEM_TOGGLE_STATE_UNCHECKED;
+
+  dbusmenu_menuitem_property_set_int (_menu_items["Pin"],
+                                      DBUSMENU_MENUITEM_PROP_TOGGLE_STATE,
+                                      checked);
+
+
+  /* Quit */
+  if (_menu_items.find ("Quit") == _menu_items.end ())
+  {
+    menu_item = dbusmenu_menuitem_new ();
+    g_object_ref (menu_item);
+
+    dbusmenu_menuitem_property_set (menu_item, DBUSMENU_MENUITEM_PROP_LABEL, "Quit");
+    dbusmenu_menuitem_property_set_bool (menu_item, DBUSMENU_MENUITEM_PROP_ENABLED, true);
+
+    g_signal_connect (menu_item, DBUSMENU_MENUITEM_SIGNAL_ITEM_ACTIVATED, (GCallback) &BamfLauncherIcon::OnQuit, this);
+
+    _menu_items["Quit"] = menu_item;
+  }
+}
+
+std::list<DbusmenuMenuitem *>
+BamfLauncherIcon::GetMenus ()
+{
+  std::map<std::string, DbusmenuClient *>::iterator it;
+  std::list<DbusmenuMenuitem *> result;
+
+  for (it = _menu_clients.begin (); it != _menu_clients.end (); it++)
+  {
+    GList * child = NULL;
+    DbusmenuClient *client = (*it).second;
+    DbusmenuMenuitem *root = dbusmenu_client_get_root (client);
+
+    for (child = dbusmenu_menuitem_get_children(root); child != NULL; child = g_list_next(child))
+    {
+      DbusmenuMenuitem *item = (DbusmenuMenuitem *) child->data;
+
+      if (!item)
+        continue;
+
+      result.push_back (item);
+    }
+  }
+
+  if (DBUSMENU_IS_MENUITEM (_menu_desktop_shortcuts))
+  {
+    GList * child = NULL;
+    DbusmenuMenuitem *root = _menu_desktop_shortcuts;
+
+    for (child = dbusmenu_menuitem_get_children(root); child != NULL; child = g_list_next(child))
+    {
+      DbusmenuMenuitem *item = (DbusmenuMenuitem *) child->data;
+
+      if (!item)
+        continue;
+
+      result.push_back (item);
+    }
+
+  }
+
+  EnsureMenuItemsReady ();
+
+  result.push_back (_menu_items["Launch"]);
+  result.push_back (_menu_items["Pin"]);
+
+  if (bamf_view_is_running (BAMF_VIEW (m_App)))
+    result.push_back (_menu_items["Quit"]);
+
+  return result;
+}
+
+
+void
+BamfLauncherIcon::UpdateIconGeometries (nux::Point3 center)
+{
+  GList *children, *l;
+  BamfView *view;
+  long data[4];
+
+  data[0] = center.x - 24;
+  data[1] = center.y - 24;
+  data[2] = 48;
+  data[3] = 48;
+
+  children = bamf_view_get_children (BAMF_VIEW (m_App));
+
+  for (l = children; l; l = l->next)
+  {
+    view = (BamfView *) l->data;
+
+    if (BAMF_IS_WINDOW (view))
+    {
+      guint32 xid = bamf_window_get_xid (BAMF_WINDOW (view));
+
+      XChangeProperty (m_Screen->dpy (), xid, Atoms::wmIconGeometry,
+                       XA_CARDINAL, 32, PropModeReplace,
+                       (unsigned char *) data, 4);
+    }
+  }
+
+  g_list_free (children);
+}
+
+void
+BamfLauncherIcon::OnCenterStabilized (nux::Point3 center)
+{
+  UpdateIconGeometries (center);
+}

=== added file 'plugins/unityshell/src/BamfLauncherIcon.h'
--- plugins/unityshell/src/BamfLauncherIcon.h	1970-01-01 00:00:00 +0000
+++ plugins/unityshell/src/BamfLauncherIcon.h	2010-12-13 12:41:23 +0000
@@ -0,0 +1,86 @@
+/*
+ * Copyright (C) 2010 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: Jason Smith <[e-mail]>
+ */
+
+#ifndef BAMFLAUNCHERICON_H
+#define BAMFLAUNCHERICON_H
+
+/* Compiz */
+#include <core/core.h>
+
+#include <Nux/BaseWindow.h>
+#include <NuxCore/Math/MathInc.h>
+#include <gdk-pixbuf/gdk-pixbuf.h>
+#include <libbamf/libbamf.h>
+#include <sigc++/sigc++.h>
+
+#include "SimpleLauncherIcon.h"
+
+class Launcher;
+
+class BamfLauncherIcon : public SimpleLauncherIcon
+{
+public:
+    BamfLauncherIcon(Launcher* IconManager, BamfApplication *app, CompScreen *screen);
+    virtual ~BamfLauncherIcon();
+
+    const char* DesktopFile ();
+    bool IsSticky ();
+
+protected:
+    void OnMouseClick (int button);
+    std::list<DbusmenuMenuitem *> GetMenus ();
+
+    void UpdateIconGeometries (nux::Point3 center);
+    void OnCenterStabilized (nux::Point3 center);
+
+    bool IconOwnsWindow (Window w);
+
+    void AddProperties (GVariantBuilder *builder);
+
+private:
+    BamfApplication *m_App;
+    CompScreen *m_Screen;
+    std::map<std::string, DbusmenuClient *> _menu_clients;
+    std::map<std::string, DbusmenuMenuitem *> _menu_items;
+    DbusmenuMenuitem *_menu_desktop_shortcuts;
+
+    void EnsureWindowState ();
+
+    void UpdateMenus ();
+
+    void OpenInstance ();
+    void Focus ();
+    void Spread ();
+
+    void EnsureMenuItemsReady ();
+
+    static void OnClosed (BamfView *view, gpointer data);
+    static void OnUserVisibleChanged (BamfView *view, gboolean visible, gpointer data);
+    static void OnActiveChanged (BamfView *view, gboolean active, gpointer data);
+    static void OnRunningChanged (BamfView *view, gboolean running, gpointer data);
+    static void OnUrgentChanged (BamfView *view, gboolean urgent, gpointer data);
+    static void OnChildAdded (BamfView *view, BamfView *child, gpointer data);
+    static void OnChildRemoved (BamfView *view, BamfView *child, gpointer data);
+
+    static void OnLaunch (DbusmenuMenuitem *item, int time, BamfLauncherIcon *self);
+    static void OnQuit (DbusmenuMenuitem *item, int time, BamfLauncherIcon *self);
+    static void OnTogglePin (DbusmenuMenuitem *item, int time, BamfLauncherIcon *self);
+};
+
+#endif // BAMFLAUNCHERICON_H
+

=== added file 'plugins/unityshell/src/FavoriteStore.cpp'
--- plugins/unityshell/src/FavoriteStore.cpp	1970-01-01 00:00:00 +0000
+++ plugins/unityshell/src/FavoriteStore.cpp	2010-12-13 12:41:23 +0000
@@ -0,0 +1,43 @@
+/*
+* Copyright (C) 2010 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 "FavoriteStoreGSettings.h"
+
+static FavoriteStore *m_store = NULL;
+
+FavoriteStore::FavoriteStore ()
+{
+
+}
+
+FavoriteStore::~FavoriteStore ()
+{
+
+}
+
+FavoriteStore *
+FavoriteStore::GetDefault ()
+{
+  if (m_store)
+    m_store->Reference ();
+  else
+    m_store = new FavoriteStoreGSettings ();
+
+  return m_store;
+}
+

=== added file 'plugins/unityshell/src/FavoriteStore.h'
--- plugins/unityshell/src/FavoriteStore.h	1970-01-01 00:00:00 +0000
+++ plugins/unityshell/src/FavoriteStore.h	2010-12-13 12:41:23 +0000
@@ -0,0 +1,73 @@
+/*
+* Copyright (C) 2010 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 FAVORITE_STORE_H
+#define FAVORITE_STORE_H
+
+#include <NuxCore/NuxCore.h>
+#include <NuxCore/ObjectType.h>
+#include <NuxCore/Object.h>
+#include <string>
+#include <sigc++/signal.h>
+
+#include <glib.h>
+
+// An abstract object that facilitates getting and modifying the list of favorites
+// Use GetDefault () to get the correct store for the session
+
+class FavoriteStore : public nux::Object
+{
+public:
+  FavoriteStore ();
+  ~FavoriteStore ();
+
+  // Returns a referenced FavoriteStore, make sure to UnReference () it
+  static FavoriteStore * GetDefault ();
+
+  // Methods
+
+  // Get's a GSList of char * desktop paths
+  // DO NOT FREE
+  // DO NOT RELY ON THE CHAR *, STRDUP THEM
+  virtual GSList * GetFavorites () = 0;
+  
+  // These will NOT emit the relevant signals, so bare that in mind
+  // i.e. don't hope that you can add stuff and hook the view up to
+  // favorite_added events to update the view. The signals only emit if
+  // there has been a change on the GSettings object from an external
+  // source
+  virtual void AddFavorite    (const char *desktop_path, gint position) = 0;
+  virtual void RemoveFavorite (const char *desktop_path) = 0;
+  virtual void MoveFavorite   (const char *desktop_path, gint position) = 0;
+  virtual void SetFavorites   (std::list<const char*> desktop_paths) = 0;
+
+  // Signals
+  // Therse only emit if something has changed the GSettings object externally
+
+  //desktop_path, position
+  sigc::signal<void, const char *, guint32> favorite_added;
+
+  //desktop_path
+  sigc::signal<void, const char *> favorite_removed;
+
+  sigc::signal<void> reordered;
+
+private:
+};
+
+#endif // FAVORITE_STORE_H

=== added file 'plugins/unityshell/src/FavoriteStoreGSettings.cpp'
--- plugins/unityshell/src/FavoriteStoreGSettings.cpp	1970-01-01 00:00:00 +0000
+++ plugins/unityshell/src/FavoriteStoreGSettings.cpp	2010-12-13 12:41:23 +0000
@@ -0,0 +1,375 @@
+/*
+* Copyright (C) 2010 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 "config.h"
+
+#include <gio/gdesktopappinfo.h>
+
+#include "FavoriteStoreGSettings.h"
+
+#define SETTINGS_NAME "com.canonical.Unity.Launcher"
+
+#define LATEST_SETTINGS_MIGRATION "3.2.0"
+
+static void on_settings_updated (GSettings *settings, const gchar *key, FavoriteStoreGSettings *self);
+
+FavoriteStoreGSettings::FavoriteStoreGSettings ()
+{
+  m_settings = g_settings_new (SETTINGS_NAME);
+
+  Init ();
+}
+
+FavoriteStoreGSettings::FavoriteStoreGSettings (GSettingsBackend *backend)
+{
+  m_settings = g_settings_new_with_backend (SETTINGS_NAME, backend);
+
+  Init ();
+}
+
+void
+FavoriteStoreGSettings::Init ()
+{
+  gchar *latest_migration_update;
+
+  m_favorites = NULL;
+  m_ignore_signals = false;
+
+  /* migrate the favorites if needed and ignore errors */
+  latest_migration_update = g_settings_get_string (m_settings, "favorite-migration");
+  if (g_strcmp0 (latest_migration_update, LATEST_SETTINGS_MIGRATION) < 0)
+    {
+      GError *error = NULL;
+      char *cmd = g_strdup_printf ("%s/lib/unity/migrate_favorites.py", PREFIXDIR);
+      char *output = NULL;
+      
+      g_spawn_command_line_sync (cmd, &output, NULL, NULL, &error);
+      if (error)
+        {
+          printf ("WARNING: Unable to run the migrate favorites tools successfully: %s.\nThe output was:%s\n", error->message,output);
+          g_error_free (error);
+        }
+      g_free (output);
+      g_free (cmd);
+    }
+  g_free (latest_migration_update);
+
+  g_signal_connect (m_settings, "changed",
+                    G_CALLBACK (on_settings_updated), this);
+
+  Refresh ();
+}
+
+FavoriteStoreGSettings::~FavoriteStoreGSettings ()
+{
+  g_slist_foreach (m_favorites, (GFunc)g_free, NULL);
+  g_slist_free (m_favorites);
+  g_object_unref (m_settings);
+}
+
+void
+FavoriteStoreGSettings::Refresh ()
+{
+  int     i = 0;
+  gchar **favs;
+
+  g_slist_foreach (m_favorites, (GFunc)g_free, NULL);
+  g_slist_free (m_favorites);
+  m_favorites = NULL;
+
+  favs = g_settings_get_strv (m_settings, "favorites");
+
+  while (favs[i] != NULL)
+    {
+      /*
+       * We will be storing either full /path/to/desktop/files or foo.desktop id's
+       */
+      if (favs[i][0] == '/')
+        {
+          if (g_file_test (favs[i], G_FILE_TEST_EXISTS))
+            {
+              m_favorites = g_slist_append (m_favorites, g_strdup (favs[i]));
+            }
+          else
+            {
+              g_warning ("Unable to load desktop file: %s", favs[i]);
+            }
+        }
+      else
+        {
+          GDesktopAppInfo *info;
+
+          info = g_desktop_app_info_new (favs[i]);
+          
+          if (info == NULL || g_desktop_app_info_get_filename (info) == NULL)
+            {
+              g_warning ("Unable to load GDesktopAppInfo for '%s'", favs[i]);
+
+              i++;
+              continue;
+            }
+
+          m_favorites = g_slist_append (m_favorites, g_strdup (g_desktop_app_info_get_filename (info)));
+
+          g_object_unref (info);
+        }
+
+      i++;
+    }
+
+  g_strfreev (favs);
+}
+
+GSList *
+FavoriteStoreGSettings::GetFavorites ()
+{
+  return m_favorites;
+}
+
+static gchar *
+get_basename_or_path (const gchar *desktop_path)
+{
+  const gchar * const * dirs;
+  const gchar * dir;
+  gint          i = 0;
+
+  dirs = g_get_system_data_dirs ();
+
+  /* We check to see if the desktop file belongs to one of the system data
+   * directories. If so, then we store it's desktop id, otherwise we store
+   * it's full path. We're clever like that.
+   */
+  while ((dir = dirs[i]))
+    {
+      if (g_str_has_prefix (desktop_path, dir))
+        {
+          return g_path_get_basename (desktop_path);
+        }
+      i++;
+    }
+
+  return g_strdup (desktop_path);
+}
+
+void
+FavoriteStoreGSettings::AddFavorite (const char *desktop_path,
+                                     gint        position)
+{
+  int     n_total_favs;
+  GSList *f;
+  gint    i = 0;
+  
+  g_return_if_fail (desktop_path);
+  g_return_if_fail (position < (gint)g_slist_length (m_favorites));
+  
+  n_total_favs = g_slist_length (m_favorites) + 1;
+  
+  char *favs[n_total_favs + 1];
+  favs[n_total_favs] = NULL;
+
+  for (f = m_favorites; f; f = f->next)
+    {
+      if (i == position)
+        {
+          favs[i] = get_basename_or_path (desktop_path);
+          i++;
+        }
+      
+      favs[i] = get_basename_or_path ((char *)f->data);
+
+      i++;
+    }
+
+  /* Add it to the end of the list */
+  if (position == -1)
+    {
+      favs[i] = get_basename_or_path (desktop_path);
+    }
+
+  m_ignore_signals = true;
+  if (!g_settings_set_strv (m_settings, "favorites", favs))
+    g_warning ("Unable to add a new favorite '%s' at position '%u'", desktop_path, position);
+  m_ignore_signals = false;
+
+  i = 0;
+  while (favs[i] != NULL)
+    {
+      g_free (favs[i]);
+      favs[i] = NULL;
+      i++;
+    }
+
+  Refresh ();
+}
+ 
+void
+FavoriteStoreGSettings::RemoveFavorite (const char *desktop_path)
+{
+  int     n_total_favs;
+  GSList *f;
+  int     i = 0;
+  bool    found = false;
+
+  g_return_if_fail (desktop_path);
+  g_return_if_fail (desktop_path[0] == '/');
+
+  n_total_favs = g_slist_length (m_favorites) - 1;
+  
+  char *favs[n_total_favs + 1];
+  favs[n_total_favs] = NULL;
+
+  for (f = m_favorites; f; f = f->next)
+    {
+      if (g_strcmp0 ((char *)f->data, desktop_path) != 0)
+        {
+          favs[i] = get_basename_or_path ((char *)f->data);
+          i++;
+        }
+      else
+        {
+          found = true;
+        }
+    }
+
+  if (!found)
+    {
+      g_warning ("Unable to remove favorite '%s': Does not exist in favorites",
+                 desktop_path);
+    }
+
+  m_ignore_signals = true;
+  if (!g_settings_set_strv (m_settings, "favorites", favs))
+    g_warning ("Unable to remove favorite '%s'", desktop_path);
+  m_ignore_signals = false;
+
+  i = 0;
+  while (favs[i] != NULL)
+    {
+      g_free (favs[i]);
+      favs[i] = NULL;
+      i++;
+    }
+
+  Refresh ();
+}
+
+void
+FavoriteStoreGSettings::MoveFavorite (const char *desktop_path,
+                                      gint        position)
+{
+  int     n_total_favs;
+  GSList *f;
+  gint    i = 0;
+
+  g_return_if_fail (desktop_path);
+  g_return_if_fail (position < (gint)g_slist_length (m_favorites));
+  
+  n_total_favs = g_slist_length (m_favorites);
+  
+  char *favs[n_total_favs + 1];
+  favs[n_total_favs] = NULL;
+
+  for (f = m_favorites; f; f = f->next)
+    {
+      if (i == position)
+        {
+          favs[i] = get_basename_or_path (desktop_path);
+          i++;
+        }
+
+      if (g_strcmp0 (desktop_path, (char *)f->data) != 0)
+        {
+          favs[i] = get_basename_or_path ((char *)f->data);
+          i++;
+        }
+    }
+
+  /* Add it to the end of the list */
+  if (position == -1)
+    {
+      favs[i] = get_basename_or_path (desktop_path);
+      i++;
+    }
+  favs[i] = NULL;
+
+  m_ignore_signals = true;
+  if (!g_settings_set_strv (m_settings, "favorites", favs))
+    g_warning ("Unable to add a new favorite '%s' at position '%u'", desktop_path, position);
+  m_ignore_signals = false;
+
+  i = 0;
+  while (favs[i] != NULL)
+    {
+      g_free (favs[i]);
+      favs[i] = NULL;
+      i++;
+    }
+
+  Refresh ();
+}
+
+void 
+FavoriteStoreGSettings::SetFavorites (std::list<const char *> desktop_paths)
+{
+  char *favs[desktop_paths.size () + 1];
+  favs[desktop_paths.size ()] = NULL;  
+  
+  int i = 0;
+  std::list<const char*>::iterator it;
+  for (it = desktop_paths.begin (); it != desktop_paths.end (); it++)
+  {
+    favs[i] = get_basename_or_path (*it);
+    i++;
+  }
+  
+  m_ignore_signals = true;
+  if (!g_settings_set_strv (m_settings, "favorites", favs))
+    g_warning ("Unable to set favorites from list");
+  m_ignore_signals = false;
+  
+  i = 0;
+  while (favs[i] != NULL)
+  {
+    g_free (favs[i]);
+    favs[i] = NULL;
+    i++;
+  }
+  
+  Refresh ();
+}
+
+void
+FavoriteStoreGSettings::Changed (const gchar *key)
+{
+  if (m_ignore_signals)
+    return;
+
+  g_print ("Changed: %s\n", key);
+}
+
+/*
+ * These are just callbacks chaining to real class functions
+ */
+static void
+on_settings_updated (GSettings *settings, const gchar *key, FavoriteStoreGSettings *self)
+{
+  g_return_if_fail (key != NULL);
+  g_return_if_fail (self != NULL);
+
+  self->Changed (key);
+}

=== added file 'plugins/unityshell/src/FavoriteStoreGSettings.h'
--- plugins/unityshell/src/FavoriteStoreGSettings.h	1970-01-01 00:00:00 +0000
+++ plugins/unityshell/src/FavoriteStoreGSettings.h	2010-12-13 12:41:23 +0000
@@ -0,0 +1,55 @@
+/*
+* Copyright (C) 2010 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 FAVORITE_STORE_GSETTINGS_H
+#define FAVORITE_STORE_GSETTINGS_H
+
+#include <gio/gio.h>
+
+#include "FavoriteStore.h"
+
+// An abstract object that facilitates getting and modifying the list of favorites
+// Use GetDefault () to get the correct store for the session
+
+class FavoriteStoreGSettings : public FavoriteStore
+{
+public:
+
+  FavoriteStoreGSettings ();
+  FavoriteStoreGSettings (GSettingsBackend *backend);
+  ~FavoriteStoreGSettings ();
+
+  //Methods
+  GSList * GetFavorites ();
+  void     AddFavorite    (const char *desktop_path, gint    position);
+  void     RemoveFavorite (const char *desktop_path);
+  void     MoveFavorite   (const char *desktop_path, gint position);
+  void     SetFavorites   (std::list<const char *> desktop_paths);
+
+  void     Changed        (const char *key);
+
+private:
+  void Init    ();
+  void Refresh ();
+
+  GSList    *m_favorites;
+  GSettings *m_settings;
+  bool       m_ignore_signals;
+};
+
+#endif // FAVORITE_STORE_GSETTINGS_H

=== added file 'plugins/unityshell/src/IndicatorObjectEntryProxy.h'
--- plugins/unityshell/src/IndicatorObjectEntryProxy.h	1970-01-01 00:00:00 +0000
+++ plugins/unityshell/src/IndicatorObjectEntryProxy.h	2010-12-13 12:41:23 +0000
@@ -0,0 +1,48 @@
+/*
+ * Copyright (C) 2010 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 INDICATOR_OBJECT_ENTRY_PROXY_H
+#define INDICATOR_OBJECT_ENTRY_PROXY_H
+
+#include <string>
+#include <sigc++/signal.h>
+#include <sigc++/sigc++.h>
+#include <gdk/gdk.h>
+
+class IndicatorObjectEntryProxy : public sigc::trackable
+{
+public:
+
+  virtual const char * GetId () = 0;
+  virtual const char * GetLabel () = 0;
+  virtual GdkPixbuf  * GetPixbuf () = 0;
+  virtual void         SetActive (bool active) = 0;
+  virtual bool         GetActive () = 0;
+  virtual void         ShowMenu (int x, int y, guint32 timestamp, guint32 button) = 0;
+
+  // Signals
+  sigc::signal<void> Updated;
+
+public:
+  bool label_visible;
+  bool label_sensitive;
+  bool icon_visible;
+  bool icon_sensitive;
+};
+
+#endif // INDICATOR_OBJECT_ENTRY_PROXY_H

=== added file 'plugins/unityshell/src/IndicatorObjectEntryProxyRemote.cpp'
--- plugins/unityshell/src/IndicatorObjectEntryProxyRemote.cpp	1970-01-01 00:00:00 +0000
+++ plugins/unityshell/src/IndicatorObjectEntryProxyRemote.cpp	2010-12-13 12:41:23 +0000
@@ -0,0 +1,157 @@
+/*
+* Copyright (C) 2010 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 "IndicatorObjectEntryProxyRemote.h"
+
+#include <gtk/gtk.h>
+
+IndicatorObjectEntryProxyRemote::IndicatorObjectEntryProxyRemote ()
+: _dirty (false),
+  _active (false),
+  _id (NULL),
+  _label (NULL),
+  _image_type (0),
+  _image_data (NULL)
+{
+  label_visible = false;
+  label_sensitive = true;
+  icon_visible = false;
+  icon_sensitive = true;
+}
+
+
+IndicatorObjectEntryProxyRemote::~IndicatorObjectEntryProxyRemote ()
+{
+  g_free (_id);
+  g_free (_label);
+  g_free (_image_data);
+}
+
+const char *
+IndicatorObjectEntryProxyRemote::GetLabel ()
+{
+  return _label;
+}
+
+GdkPixbuf *
+IndicatorObjectEntryProxyRemote::GetPixbuf ()
+{
+  GdkPixbuf *ret = NULL;
+  
+  if (_image_type == GTK_IMAGE_PIXBUF)
+    {
+      guchar       *decoded;
+      GInputStream *stream;
+      gsize         len = 0;
+     
+      decoded = g_base64_decode (_image_data, &len);
+      stream = g_memory_input_stream_new_from_data (decoded, len, NULL);
+
+      ret = gdk_pixbuf_new_from_stream (stream, NULL, NULL);
+
+      g_free (decoded);
+      g_input_stream_close (stream, NULL, NULL);
+    }
+  else if (_image_type == GTK_IMAGE_STOCK
+           || _image_type == GTK_IMAGE_ICON_NAME)
+    {
+      ret = gtk_icon_theme_load_icon (gtk_icon_theme_get_default (),
+                                      _image_data,
+                                      22,
+                                      (GtkIconLookupFlags)0,
+                                      NULL);
+    }
+  else if (_image_type == GTK_IMAGE_GICON)
+    {
+      GtkIconInfo *info;
+      GIcon       *icon;
+
+      icon = g_icon_new_for_string (_image_data, NULL);
+      info = gtk_icon_theme_lookup_by_gicon (gtk_icon_theme_get_default (),
+                                             icon,
+                                             22,
+                                             (GtkIconLookupFlags)0);
+      if (info)
+        ret = gtk_icon_info_load_icon (info, NULL);
+
+      gtk_icon_info_free (info);
+      g_object_unref (icon);
+    }
+
+  return ret;
+}
+
+void
+IndicatorObjectEntryProxyRemote::SetActive (bool active)
+{
+  if (_active == active)
+    return;
+
+  _active = active;
+
+  Updated.emit ();
+}
+
+bool
+IndicatorObjectEntryProxyRemote::GetActive ()
+{
+  return _active;
+}
+
+void
+IndicatorObjectEntryProxyRemote::Refresh (const char *__id,
+                                          const char *__label,
+                                          bool        __label_sensitive,
+                                          bool        __label_visible,
+                                          guint32     __image_type,
+                                          const char *__image_data,
+                                          bool        __image_sensitive,
+                                          bool        __image_visible)
+{
+  g_free (_id);
+  g_free (_label);
+  g_free (_image_data);
+
+  _id = NULL;
+  _label = NULL;
+  _image_data = NULL;
+
+  _id = g_strdup (__id);
+  _label = g_strdup (__label);
+  label_sensitive = __label_sensitive;
+  label_visible = __label_visible;
+  _image_type = __image_type;
+  if (_image_type)
+    _image_data = g_strdup (__image_data);
+  icon_sensitive = __image_sensitive;
+  icon_visible = __image_visible;
+
+  Updated.emit ();
+}
+
+const char *
+IndicatorObjectEntryProxyRemote::GetId ()
+{
+  return _id;
+}
+
+void
+IndicatorObjectEntryProxyRemote::ShowMenu (int x, int y, guint32 timestamp, guint32 button)
+{
+  OnShowMenuRequest.emit (_id, x, y, timestamp, button);
+}

=== added file 'plugins/unityshell/src/IndicatorObjectEntryProxyRemote.h'
--- plugins/unityshell/src/IndicatorObjectEntryProxyRemote.h	1970-01-01 00:00:00 +0000
+++ plugins/unityshell/src/IndicatorObjectEntryProxyRemote.h	2010-12-13 12:41:23 +0000
@@ -0,0 +1,72 @@
+/*
+* Copyright (C) 2010 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 INDICATOR_OBJECT_ENTRY_PROXY_REMOTE_H
+#define INDICATOR_OBJECT_ENTRY_PROXY_REMOTE_H
+
+#include <string>
+#include <gio/gio.h>
+
+#include "IndicatorObjectEntryProxy.h"
+
+// Represents an IndicatorObjectEntry over DBus through the panel service
+// Basically wraps the DeeModelIter, trying to keep as much info inside 
+// that as possible to avoid duplication
+
+class IndicatorObjectEntryProxyRemote : public IndicatorObjectEntryProxy
+{
+public:
+
+  IndicatorObjectEntryProxyRemote  ();
+  ~IndicatorObjectEntryProxyRemote ();
+
+  virtual const char * GetId ();
+
+  virtual const char * GetLabel ();
+
+  // Call g_object_unref on the returned pixbuf
+  virtual GdkPixbuf  * GetPixbuf ();
+
+  virtual void         SetActive (bool active);
+  virtual bool         GetActive ();
+
+  virtual void         ShowMenu (int x, int y, guint32 timestamp, guint32 button);
+
+  void Refresh (const char *__id,
+                const char *__label,
+                bool        __label_sensitive,
+                bool        __label_visible,
+                guint32     __image_type,
+                const char *__image_data,
+                bool        __image_sensitive,
+                bool        __image_visible);
+
+  // Signals
+  sigc::signal<void, const char *, int, int, guint32, guint32> OnShowMenuRequest;
+
+public:
+  bool     _dirty;
+  bool     _active;
+
+  char    *_id;
+  char    *_label;
+  guint32  _image_type;
+  char    *_image_data;
+};
+
+#endif // INDICATOR_OBJECT_ENTRY_PROXY_REMOTE_H

=== added file 'plugins/unityshell/src/IndicatorObjectFactory.h'
--- plugins/unityshell/src/IndicatorObjectFactory.h	1970-01-01 00:00:00 +0000
+++ plugins/unityshell/src/IndicatorObjectFactory.h	2010-12-13 12:41:23 +0000
@@ -0,0 +1,53 @@
+/*
+ * Copyright (C) 2010 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 INDICATOR_OBJECT_FACTORY_H
+#define INDICATOR_OBJECT_FACTORY_H
+
+#include <string>
+#include <vector>
+#include <sigc++/signal.h>
+#include <sigc++/trackable.h>
+#include "IndicatorObjectProxy.h"
+
+class IndicatorObjectFactory : public sigc::trackable
+{
+public:
+
+  // This could be empty, if the loading of Indicators is async, so you
+  // should be listening to the signals too
+  virtual std::vector<IndicatorObjectProxy *>& GetIndicatorObjects () = 0;
+
+  // If the implementation supports it, you'll get a refreshed list of
+  // Indicators (probably though a bunch of removed/added events)
+  virtual void ForceRefresh () = 0;
+
+  // For adding factory-specific properties
+  virtual void AddProperties (GVariantBuilder *builder) = 0;
+
+  // Signals
+  sigc::signal<void, IndicatorObjectProxy *> OnObjectAdded;
+  sigc::signal<void, IndicatorObjectProxy *> OnObjectRemoved;
+  sigc::signal<void, int, int>               OnMenuPointerMoved;
+  sigc::signal<void, const char *>           OnEntryActivateRequest;
+
+protected:
+  std::vector<IndicatorObjectProxy *>_indicators;
+};
+
+#endif // INDICATOR_OBJECT_FACTORY_H

=== added file 'plugins/unityshell/src/IndicatorObjectFactoryRemote.cpp'
--- plugins/unityshell/src/IndicatorObjectFactoryRemote.cpp	1970-01-01 00:00:00 +0000
+++ plugins/unityshell/src/IndicatorObjectFactoryRemote.cpp	2010-12-13 12:41:23 +0000
@@ -0,0 +1,494 @@
+/*
+ * Copyright (C) 2010 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 "config.h"
+
+#include "IndicatorObjectFactoryRemote.h"
+
+#include "IndicatorObjectProxyRemote.h"
+#include "IndicatorObjectEntryProxyRemote.h"
+#include "IndicatorObjectEntryProxy.h"
+
+#include "Nux/Nux.h"
+#include "Nux/WindowThread.h"
+#include "NuxGraphics/GLWindowManager.h"
+#include <X11/Xlib.h>
+
+#define S_NAME  "com.canonical.Unity.Panel.Service"
+#define S_PATH  "/com/canonical/Unity/Panel/Service"
+#define S_IFACE "com.canonical.Unity.Panel.Service"
+
+typedef struct
+{
+  GDBusProxy *proxy;
+  gchar *entry_id;
+  int x;
+  int y;
+  guint timestamp;
+  guint32 button;
+
+} ShowEntryData;
+
+
+// Forwards
+static void on_proxy_ready_cb (GObject      *source,
+                               GAsyncResult *res,
+                               gpointer      data);
+
+static void on_proxy_signal_received (GDBusProxy *proxy,
+                                      gchar      *sender_name,
+                                      gchar      *signal_name,
+                                      GVariant   *parameters,
+                                      IndicatorObjectFactoryRemote *remote);
+
+static void on_sync_ready_cb (GObject      *source,
+                              GAsyncResult *res,
+                              gpointer      data);
+
+static bool run_local_panel_service ();
+static bool reconnect_to_service (gpointer data);
+
+// Public Methods
+IndicatorObjectFactoryRemote::IndicatorObjectFactoryRemote ()
+{
+  if (g_getenv ("PANEL_USE_LOCAL_SERVICE"))
+  {
+    run_local_panel_service ();
+    g_timeout_add_seconds (1, (GSourceFunc)reconnect_to_service, this);
+  }
+  else
+  {
+    // We want to grab the Panel Service object. This is async, which is fine
+    g_dbus_proxy_new_for_bus (G_BUS_TYPE_SESSION,
+                              G_DBUS_PROXY_FLAGS_DO_NOT_LOAD_PROPERTIES,
+                              NULL,
+                              S_NAME,
+                              S_PATH,
+                              S_IFACE,
+                              NULL,
+                              on_proxy_ready_cb,
+                              this);
+  }
+}
+
+IndicatorObjectFactoryRemote::~IndicatorObjectFactoryRemote ()
+{
+  if (G_IS_OBJECT (_proxy))
+    g_object_unref (_proxy);
+  _proxy = NULL;
+
+  std::vector<IndicatorObjectProxy*>::iterator it;
+  
+  for (it = _indicators.begin(); it != _indicators.end(); it++)
+  {
+    IndicatorObjectProxyRemote *remote = static_cast<IndicatorObjectProxyRemote *> (*it);
+    delete remote;
+  }
+
+  _indicators.erase (_indicators.begin (), _indicators.end ());
+}
+
+std::vector<IndicatorObjectProxy *>&
+IndicatorObjectFactoryRemote::GetIndicatorObjects ()
+{
+  return _indicators;
+}
+
+void
+IndicatorObjectFactoryRemote::ForceRefresh ()
+{
+}
+
+void
+IndicatorObjectFactoryRemote::OnRemoteProxyReady (GDBusProxy *proxy)
+{
+  _proxy = proxy;
+
+  // Connect to interesting signals
+  // FIXME: Add auto-restarting bits here
+  g_signal_connect (_proxy, "g-signal",
+                   G_CALLBACK (on_proxy_signal_received), this);
+
+  g_dbus_proxy_call (_proxy,
+                     "Sync",
+                     NULL,
+                     G_DBUS_CALL_FLAGS_NONE,
+                     -1,
+                     NULL,
+                     on_sync_ready_cb,
+                     this);
+}
+
+static gboolean
+send_show_entry (ShowEntryData *data)
+{
+  g_return_val_if_fail (data != NULL, FALSE);
+  g_return_val_if_fail (G_IS_DBUS_PROXY (data->proxy), FALSE);
+  
+  /* Re-flush 'cos X is crap like that */
+  Display* d = nux::GetThreadGLWindow()->GetX11Display();
+  XFlush (d);
+  
+  g_dbus_proxy_call (data->proxy,
+                     "ShowEntry",
+                     g_variant_new ("(suiii)",
+                                    data->entry_id,
+                                    0,
+                                    data->x,
+                                    data->y,
+                                    data->button),
+                     G_DBUS_CALL_FLAGS_NONE,
+                     -1,
+                     NULL,
+                     NULL,
+                     NULL);
+
+  g_free (data->entry_id);
+  g_slice_free (ShowEntryData, data);
+  return FALSE;
+}
+
+void
+IndicatorObjectFactoryRemote::OnShowMenuRequestReceived (const char *entry_id,
+                                                         int         x,
+                                                         int         y,
+                                                         guint       timestamp,
+                                                         guint32     button)
+{
+  Display* d = nux::GetThreadGLWindow()->GetX11Display();
+  XUngrabPointer(d, CurrentTime);
+  XFlush (d);
+
+  // We have to do this because on certain systems X won't have time to 
+  // respond to our request for XUngrabPointer and this will cause the
+  // menu not to show
+  ShowEntryData *data = g_slice_new0 (ShowEntryData);
+  data->proxy = _proxy;
+  data->entry_id = g_strdup (entry_id);
+  data->x = x;
+  data->y = y;
+  data->timestamp = timestamp;
+  data->button = button;
+
+  g_timeout_add (0, (GSourceFunc)send_show_entry, data);
+
+  // --------------------------------------------------------------------------
+  // FIXME: This is a workaround until the non-paired events issue is fixed in
+  // nux
+  XButtonEvent ev = {
+    ButtonRelease,
+    0,
+    False,
+    d,
+    0,
+    0,
+    0,
+    CurrentTime,
+    x, y,
+    x, y,
+    0,
+    Button1,
+    True
+  };
+  XEvent *e = (XEvent*)&ev;
+  nux::GetGraphicsThread()->ProcessForeignEvent (e, NULL);
+  // --------------------------------------------------------------------------
+}
+
+// We need to unset the last active entry and set the new one as active
+void
+IndicatorObjectFactoryRemote::OnEntryActivated (const char *entry_id)
+{
+  std::vector<IndicatorObjectProxy*>::iterator it;
+  
+  for (it = _indicators.begin(); it != _indicators.end(); it++)
+  {
+    IndicatorObjectProxyRemote *object = static_cast<IndicatorObjectProxyRemote *> (*it);
+    std::vector<IndicatorObjectEntryProxy*>::iterator it;
+  
+    for (it = object->GetEntries ().begin(); it != object->GetEntries ().end(); it++)
+    {
+      IndicatorObjectEntryProxyRemote *entry = static_cast<IndicatorObjectEntryProxyRemote *> (*it);
+
+      entry->SetActive (g_strcmp0 (entry_id, entry->GetId ()) == 0);
+    }
+  } 
+}
+
+void
+IndicatorObjectFactoryRemote::OnEntryActivateRequestReceived (const gchar *entry_id)
+{
+  OnEntryActivateRequest.emit (entry_id);
+}
+
+IndicatorObjectProxyRemote *
+IndicatorObjectFactoryRemote::IndicatorForID (const char *id)
+{
+  IndicatorObjectProxyRemote *remote = NULL;
+  std::vector<IndicatorObjectProxy*>::iterator it;
+  
+  for (it = _indicators.begin(); it != _indicators.end(); it++)
+  {
+    IndicatorObjectProxyRemote *r = static_cast<IndicatorObjectProxyRemote *> (*it);
+
+    if (g_strcmp0 (id, r->GetName ().c_str ()) == 0)
+      {
+        remote = r;
+        break;
+      }
+  }
+
+  if (remote == NULL)
+    {
+      // Create one
+      remote = new IndicatorObjectProxyRemote (id);
+      remote->OnShowMenuRequest.connect (sigc::mem_fun (this,
+                                                        &IndicatorObjectFactoryRemote::OnShowMenuRequestReceived));
+
+      _indicators.push_back (remote);
+
+      OnObjectAdded.emit (remote);
+    }
+
+  return remote;
+}
+
+void
+IndicatorObjectFactoryRemote::Sync (GVariant *args)
+{
+  GVariantIter *iter;
+  gchar        *indicator_id;
+  gchar        *entry_id;
+  gchar        *label;
+  gboolean      label_sensitive;
+  gboolean      label_visible;
+  guint32       image_type;
+  gchar        *image_data;
+  gboolean      image_sensitive;
+  gboolean      image_visible;
+
+  IndicatorObjectProxyRemote *current_proxy = NULL;
+  gchar                      *current_proxy_id = NULL;
+
+  g_variant_get (args, "(a(sssbbusbb))", &iter);
+  while (g_variant_iter_loop (iter, "(sssbbusbb)",
+                              &indicator_id,
+                              &entry_id,
+                              &label,
+                              &label_sensitive,
+                              &label_visible,
+                              &image_type,
+                              &image_data,
+                              &image_sensitive,
+                              &image_visible))
+    {
+      if (g_strcmp0 (current_proxy_id, indicator_id) != 0)
+        {
+          if (current_proxy)
+            current_proxy->EndSync ();
+          g_free (current_proxy_id);
+
+          current_proxy_id = g_strdup (indicator_id);
+          current_proxy = IndicatorForID (indicator_id);
+          current_proxy->BeginSync ();
+        }
+
+      /* NULL entries (id == "") are just padding */
+      if (g_strcmp0 (entry_id, "") != 0)
+        current_proxy->AddEntry (entry_id,
+                                 label,
+                                 label_sensitive,
+                                 label_visible,
+                                 image_type,
+                                 image_data,
+                                 image_sensitive,
+                                 image_visible);
+    }
+  if (current_proxy)
+    current_proxy->EndSync ();
+  
+  g_free (current_proxy_id);
+  g_variant_iter_free (iter);
+}
+
+void
+IndicatorObjectFactoryRemote::AddProperties (GVariantBuilder *builder)
+{
+  gchar *name = NULL;
+  gchar *uname = NULL;
+  
+  g_object_get (_proxy,
+                "g-name", &name,
+                "g-name-owner", &uname,
+                NULL);
+
+  g_variant_builder_add (builder, "{sv}", "backend", g_variant_new_string ("remote"));
+  g_variant_builder_add (builder, "{sv}", "service-name", g_variant_new_string (name));
+  g_variant_builder_add (builder, "{sv}", "service-unique-name", g_variant_new_string (uname));
+  g_variant_builder_add (builder, "{sv}", "using-local-service", g_variant_new_boolean (g_getenv ("PANEL_USE_LOCAL_SERVICE") == NULL ? FALSE : TRUE));
+
+  g_free (name);
+  g_free (uname);
+}
+
+  
+//
+// C callbacks, they just link to class methods and aren't interesting
+//
+
+static bool
+reconnect_to_service (gpointer data)
+{
+  g_dbus_proxy_new_for_bus (G_BUS_TYPE_SESSION,
+                            G_DBUS_PROXY_FLAGS_DO_NOT_LOAD_PROPERTIES,
+                            NULL,
+                            S_NAME,
+                            S_PATH,
+                            S_IFACE,
+                            NULL,
+                            on_proxy_ready_cb,
+                            data);
+
+  return false;
+}
+
+static void
+on_proxy_ready_cb (GObject      *source,
+                   GAsyncResult *res,
+                   gpointer      data)
+{
+  IndicatorObjectFactoryRemote *remote = static_cast<IndicatorObjectFactoryRemote *> (data);
+  GDBusProxy *proxy;
+  GError     *error = NULL;
+  static bool force_tried = false;
+  char       *name_owner;
+
+  proxy = g_dbus_proxy_new_for_bus_finish (res, &error);
+  name_owner = g_dbus_proxy_get_name_owner (proxy);
+
+  if (G_IS_DBUS_PROXY (proxy) && name_owner)
+  {
+    remote->OnRemoteProxyReady (G_DBUS_PROXY (proxy));
+    g_free (name_owner);
+    return;
+  }
+  else
+  {
+    if (force_tried)
+    {
+      printf ("\nWARNING: Unable to connect to the unity-panel-service %s\n",
+              error ? error->message : "Unknown");
+      if (error)
+        g_error_free (error);
+    }
+    else
+    {
+      force_tried = true;
+      run_local_panel_service ();
+
+      g_timeout_add_seconds (2, (GSourceFunc)reconnect_to_service, remote);
+    }
+  }
+
+  g_object_unref (proxy);
+}
+
+static bool
+run_local_panel_service ()
+{
+  GError *error = NULL;
+
+  // This is obviously hackish, but this part of the code is mostly hackish...
+  // Let's attempt to run it from where we expect it to be
+  char *cmd = g_strdup_printf ("%s/lib/unity/unity-panel-service", PREFIXDIR);
+  printf ("\nWARNING: Couldn't load panel from installed services, so trying to"
+          "load panel from known location: %s\n", cmd);
+
+  g_spawn_command_line_async (cmd, &error);
+  g_free (cmd);
+  
+  if (error)
+  {
+    printf ("\nWARNING: Unable to launch remote service manually: %s\n", error->message);
+    g_error_free (error);
+    return false;
+  }
+  return true;
+}
+
+static void
+on_proxy_signal_received (GDBusProxy *proxy,
+                          gchar      *sender_name,
+                          gchar      *signal_name,
+                          GVariant   *parameters,
+                          IndicatorObjectFactoryRemote *remote)
+{
+  if (g_strcmp0 (signal_name, "EntryActivated") == 0)
+  {
+    remote->OnEntryActivated (g_variant_get_string (g_variant_get_child_value (parameters, 0), NULL));
+  }
+  else if (g_strcmp0 (signal_name, "EntryActivateRequest") == 0)
+  {
+    remote->OnEntryActivateRequestReceived (g_variant_get_string (g_variant_get_child_value (parameters, 0), NULL));
+  }
+  else if (g_strcmp0 (signal_name, "ReSync") == 0)
+  {
+    const gchar *id = g_variant_get_string (g_variant_get_child_value (parameters, 0), NULL);
+    bool sync_one = !g_strcmp0 (id, "") == 0;
+
+    g_dbus_proxy_call (proxy,
+                       sync_one ? "SyncOne" : "Sync", 
+                       sync_one ? g_variant_new ("(s)", id) : NULL,
+                       G_DBUS_CALL_FLAGS_NONE,
+                       -1,
+                       NULL,
+                       on_sync_ready_cb,
+                       remote);
+  }
+  else if (g_strcmp0 (signal_name, "ActiveMenuPointerMotion") == 0)
+    {
+      int x=0, y=0;
+
+      g_variant_get (parameters, "(ii)", &x, &y);
+
+      remote->OnMenuPointerMoved.emit (x, y);
+    }
+}
+
+static void
+on_sync_ready_cb (GObject      *source,
+                  GAsyncResult *res,
+                  gpointer      data)
+{
+  IndicatorObjectFactoryRemote *remote = static_cast<IndicatorObjectFactoryRemote *> (data);
+  GVariant     *args;
+  GError       *error = NULL;
+
+  args = g_dbus_proxy_call_finish ((GDBusProxy*)source, res, &error);
+
+  if (args == NULL)
+    {
+      g_warning ("Unable to perform Sync() on panel service: %s", error->message);
+      g_error_free (error);
+      return;
+    }
+
+  remote->Sync (args);
+
+  g_variant_unref (args);
+}

=== added file 'plugins/unityshell/src/IndicatorObjectFactoryRemote.h'
--- plugins/unityshell/src/IndicatorObjectFactoryRemote.h	1970-01-01 00:00:00 +0000
+++ plugins/unityshell/src/IndicatorObjectFactoryRemote.h	2010-12-13 12:41:23 +0000
@@ -0,0 +1,55 @@
+/*
+ * Copyright (C) 2010 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 INDICATOR_OBJECT_FACTORY_REMOTE_H
+#define INDICATOR_OBJECT_FACTORY_REMOTE_H
+
+#include <string>
+#include <gio/gio.h>
+#include <dee.h>
+
+#include "IndicatorObjectFactory.h"
+#include "IndicatorObjectProxyRemote.h"
+
+// Connects to the remote panel service (unity-panel-service) and translates
+// that into something that the panel can show
+class IndicatorObjectFactoryRemote : public IndicatorObjectFactory
+{
+public:
+
+  IndicatorObjectFactoryRemote  ();
+  ~IndicatorObjectFactoryRemote ();
+  
+  virtual std::vector<IndicatorObjectProxy *> &GetIndicatorObjects ();
+  virtual void ForceRefresh ();
+
+  void OnRemoteProxyReady (GDBusProxy *proxy);
+  void OnEntryActivated   (const char *entry_id);
+  void OnShowMenuRequestReceived (const char *id, int x, int y, guint timestamp, guint32 button);
+  void Sync (GVariant *args);
+  void OnEntryActivateRequestReceived (const char *entry_id);
+
+  void AddProperties (GVariantBuilder *builder);
+
+private:
+  IndicatorObjectProxyRemote* IndicatorForID (const char *id);
+private:
+  GDBusProxy *_proxy;
+};
+
+#endif // INDICATOR_OBJECT_FACTORY_REMOTE_H

=== added file 'plugins/unityshell/src/IndicatorObjectProxy.h'
--- plugins/unityshell/src/IndicatorObjectProxy.h	1970-01-01 00:00:00 +0000
+++ plugins/unityshell/src/IndicatorObjectProxy.h	2010-12-13 12:41:23 +0000
@@ -0,0 +1,48 @@
+/*
+ * Copyright (C) 2010 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 INDICATOR_OBJECT_PROXY_H
+#define INDICATOR_OBJECT_PROXY_H
+
+#include <string>
+#include <vector>
+#include <sigc++/signal.h>
+#include <sigc++/sigc++.h>
+
+#include "IndicatorObjectEntryProxy.h"
+
+class IndicatorObjectProxy : public sigc::trackable
+{
+public:
+
+  // The name of the indicator that this proxy represents
+  virtual std::string& GetName () = 0;
+
+  // The current list of IndicatorObjectEntryProxys
+  virtual std::vector<IndicatorObjectEntryProxy *>& GetEntries () = 0;
+
+  // Signals
+  sigc::signal<void, IndicatorObjectEntryProxy *> OnEntryAdded;
+  sigc::signal<void, IndicatorObjectEntryProxy *> OnEntryRemoved;
+  sigc::signal<void, IndicatorObjectEntryProxy *> OnEntryMoved;
+
+protected:
+  std::vector<IndicatorObjectEntryProxy *> _entries;
+};
+
+#endif // INDICATOR_OBJECT_PROXY_H

=== added file 'plugins/unityshell/src/IndicatorObjectProxyRemote.cpp'
--- plugins/unityshell/src/IndicatorObjectProxyRemote.cpp	1970-01-01 00:00:00 +0000
+++ plugins/unityshell/src/IndicatorObjectProxyRemote.cpp	2010-12-13 12:41:23 +0000
@@ -0,0 +1,145 @@
+/*
+ * Copyright (C) 2010 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 "IndicatorObjectProxyRemote.h"
+
+#include "IndicatorObjectEntryProxyRemote.h"
+
+IndicatorObjectProxyRemote::IndicatorObjectProxyRemote (const char *name)
+: _name (name)
+{
+}
+
+IndicatorObjectProxyRemote::~IndicatorObjectProxyRemote ()
+{
+  std::vector<IndicatorObjectEntryProxy*>::iterator it;
+  
+  for (it = _entries.begin(); it != _entries.end(); it++)
+  {
+    IndicatorObjectEntryProxyRemote *remote = static_cast<IndicatorObjectEntryProxyRemote *> (*it);
+    delete remote;
+  }
+
+  _entries.erase (_entries.begin (), _entries.end ());
+}
+  
+std::string&
+IndicatorObjectProxyRemote::GetName ()
+{
+  return _name;
+}
+
+std::vector<IndicatorObjectEntryProxy *>&
+IndicatorObjectProxyRemote::GetEntries ()
+{
+  return _entries;
+}
+
+
+void
+IndicatorObjectProxyRemote::BeginSync ()
+{
+  std::vector<IndicatorObjectEntryProxy*>::iterator it;
+  
+  for (it = _entries.begin(); it != _entries.end(); it++)
+  {
+    IndicatorObjectEntryProxyRemote *remote = static_cast<IndicatorObjectEntryProxyRemote *> (*it);
+    remote->_dirty = true;
+  }
+}
+
+void
+IndicatorObjectProxyRemote::AddEntry (const gchar *entry_id,
+                                      const gchar *label,
+                                      bool         label_sensitive,
+                                      bool         label_visible,
+                                      guint32      image_type,
+                                      const gchar *image_data,
+                                      bool         image_sensitive,
+                                      bool         image_visible)
+{
+  IndicatorObjectEntryProxyRemote *remote = NULL;
+  std::vector<IndicatorObjectEntryProxy*>::iterator it;
+  
+  for (it = _entries.begin(); it != _entries.end(); it++)
+  {
+    IndicatorObjectEntryProxyRemote *r = static_cast<IndicatorObjectEntryProxyRemote *> (*it);
+    if (r->_dirty == true)
+      {
+        remote = r;
+        break;
+      }
+  }
+  
+  /* Create a new one */
+  if (remote == NULL)
+    {
+      remote = new IndicatorObjectEntryProxyRemote ();
+      remote->OnShowMenuRequest.connect (sigc::mem_fun (this,
+                                                        &IndicatorObjectProxyRemote::OnShowMenuRequestReceived));
+      _entries.push_back (remote);
+    }
+
+  remote->Refresh (entry_id,
+                   label,
+                   label_sensitive,
+                   label_visible,
+                   image_type,
+                   image_data,
+                   image_sensitive,
+                   image_visible);
+  if (remote->_dirty)
+    remote->_dirty = false;
+  else
+    OnEntryAdded.emit (remote);
+}
+
+void
+IndicatorObjectProxyRemote::EndSync ()
+{
+  std::vector<IndicatorObjectEntryProxy*>::iterator it;
+ 
+  for (it = _entries.begin(); it != _entries.end(); it++)
+  {
+    IndicatorObjectEntryProxyRemote *remote = static_cast<IndicatorObjectEntryProxyRemote *> (*it);
+    if (remote->_dirty == true)
+      {
+        /* We don't get rid of the entries as there's no real need to, and it saves us
+         * having to do a bunch of object creation everytime the menu changes
+         */
+        remote->Refresh ("|",
+                         "",
+                         false,
+                         false,
+                         0,
+                         "",
+                         false,
+                         false);
+      }
+  }
+}
+
+void
+IndicatorObjectProxyRemote::OnShowMenuRequestReceived (const char *entry_id,
+                                                       int         x,
+                                                       int         y,
+                                                       guint32     timestamp,
+                                                       guint32     button)
+{
+  OnShowMenuRequest.emit (entry_id, x, y, timestamp, button);
+}

=== added file 'plugins/unityshell/src/IndicatorObjectProxyRemote.h'
--- plugins/unityshell/src/IndicatorObjectProxyRemote.h	1970-01-01 00:00:00 +0000
+++ plugins/unityshell/src/IndicatorObjectProxyRemote.h	2010-12-13 12:41:23 +0000
@@ -0,0 +1,60 @@
+/*
+ * Copyright (C) 2010 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 INDICATOR_OBJECT_PROXY_REMOTE_H
+#define INDICATOR_OBJECT_PROXY_REMOTE_H
+
+#include <string>
+#include <gio/gio.h>
+#include <dee.h>
+
+#include "IndicatorObjectProxy.h"
+
+// Represents an IndicatorObject over DBus through the panel service
+
+class IndicatorObjectProxyRemote : public IndicatorObjectProxy
+{
+public:
+
+  IndicatorObjectProxyRemote  (const char *name);
+  ~IndicatorObjectProxyRemote ();
+  
+  virtual std::string& GetName ();
+  virtual std::vector<IndicatorObjectEntryProxy *>& GetEntries ();
+
+  void BeginSync ();
+  void AddEntry  (const gchar *entry_id,
+                  const gchar *label,
+                  bool         label_sensitive,
+                  bool         label_visible,
+                  guint32      image_type,
+                  const gchar *image_data,
+                  bool         image_sensitive,
+                  bool         image_visible);
+  void EndSync   ();
+
+  void OnShowMenuRequestReceived (const char *id, int x, int y, guint timestamp, guint32 button);
+
+  // Signals
+  sigc::signal<void, const char *, int, int, guint32, guint32> OnShowMenuRequest;
+
+private:
+  std::string _name;
+};
+
+#endif // INDICATOR_OBJECT_PROXY_REMOTE_H

=== added file 'plugins/unityshell/src/Introspectable.cpp'
--- plugins/unityshell/src/Introspectable.cpp	1970-01-01 00:00:00 +0000
+++ plugins/unityshell/src/Introspectable.cpp	2010-12-13 12:41:23 +0000
@@ -0,0 +1,75 @@
+/*
+ * Copyright (C) 2010 Canonical Ltd
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 3 as
+ * published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ *
+ * Authored by: Alex Launi <[e-mail]>
+ */
+
+#include "Introspectable.h"
+
+GVariant*
+Introspectable::Introspect ()
+{
+  GVariantBuilder *builder;
+  GVariant		    *result;
+  GVariantBuilder *child_builder;
+  gint             n_children = 0;
+
+  builder = g_variant_builder_new (G_VARIANT_TYPE ("a{sv}"));
+
+  AddProperties (builder);
+
+  child_builder = g_variant_builder_new (G_VARIANT_TYPE ("a{sv}"));
+
+  for (std::list<Introspectable *>::iterator it = _children.begin (); it != _children.end (); it++)
+  {
+    if ((*it)->GetName ())
+      {
+        g_variant_builder_add (child_builder, "{sv}", (*it)->GetName (), (*it)->Introspect () );
+        n_children++;
+      }
+  }
+
+  if (n_children > 0)
+    {
+      GVariant        *child_results;
+
+      child_results = g_variant_new ("(a{sv})", child_builder);
+      g_variant_builder_add (builder, "{sv}", GetChildsName (), child_results);
+    }
+  g_variant_builder_unref (child_builder);
+
+  result = g_variant_new ("(a{sv})", builder);
+  g_variant_builder_unref (builder);
+
+  return result;
+}
+
+void
+Introspectable::AddChild (Introspectable *child)
+{
+  _children.push_back (child);
+}
+
+void
+Introspectable::RemoveChild (Introspectable *child)
+{
+  _children.remove (child);
+}
+
+const gchar *
+Introspectable::GetChildsName ()
+{
+  return GetName ();
+}

=== added file 'plugins/unityshell/src/Introspectable.h'
--- plugins/unityshell/src/Introspectable.h	1970-01-01 00:00:00 +0000
+++ plugins/unityshell/src/Introspectable.h	2010-12-13 12:41:23 +0000
@@ -0,0 +1,55 @@
+/*
+ * Copyright (C) 2010 Canonical Ltd
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 3 as
+ * published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ *
+ * Authored by: Alex Launi <[e-mail]>
+ */
+
+#ifndef _INTROSPECTABLE_H
+#define _INTROSPECTABLE_H 1
+
+#include <glib.h>
+#include <list>
+
+class Introspectable
+{
+public:
+  GVariant *Introspect ();
+  void AddChild (Introspectable *child);
+  void RemoveChild (Introspectable *child);
+
+protected:
+  virtual const gchar *GetName () = 0;
+  virtual const gchar *GetChildsName ();
+  virtual void AddProperties (GVariantBuilder *builder) = 0;
+  /*
+   * AddProperties should be implemented as such ...
+   * void ClassFoo::AddProperties (GVariantBuilder *builder)
+   * {
+   * 	g_variant_builder_add (builder, "{sv}", "label", g_variant_new_string ("_File") );
+   *	g_variant_builder_add (builder, "{sv}", "image", g_variant_new_string ("") );
+   *	g_variant_builder_add (builder, "{sv}", "visible", g_variant_new_boolean (TRUE) );
+   *  	g_variant_builder_add (builder, "{sv}", "sensitive", g_variant_new_boolean (TRUE) );
+   *  	g_variant_builder_add (builder, "{sv}", "active", g_variant_new_boolean (FALSE) );
+   *  	g_variant_builder_add (builder, "{sv}", "label", g_variant_new_int32 (34) );
+   *  	g_variant_builder_add (builder, "{sv}", "label", g_variant_new_int32 (24) );
+   * }
+   * That's all. Just add a bunch of key-value properties to the builder.
+   */
+
+private:
+  std::list<Introspectable *> _children;
+};
+
+#endif

=== added file 'plugins/unityshell/src/IntrospectionDBusInterface.cpp'
--- plugins/unityshell/src/IntrospectionDBusInterface.cpp	1970-01-01 00:00:00 +0000
+++ plugins/unityshell/src/IntrospectionDBusInterface.cpp	2010-12-13 12:41:23 +0000
@@ -0,0 +1,223 @@
+/*
+ * Copyright (C) 2010 Canonical Ltd
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 3 as
+ * published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ *
+ * Authored by: Alex Launi <[e-mail]>
+ */
+
+#include "IntrospectionDBusInterface.h"
+
+#define UNITY_STATE_DEBUG_BUS_NAME "com.canonical.Unity"
+
+void DBusMethodCall (GDBusConnection*, const gchar*, const gchar*,
+					 const gchar*, const gchar*, GVariant*,
+					 GDBusMethodInvocation*, gpointer);
+GVariant* GetState (const gchar*);
+
+static const GDBusInterfaceVTable si_vtable =
+{
+  &DBusMethodCall,
+  NULL,
+  NULL
+};
+
+static const GDBusArgInfo si_getstate_in_args =
+{
+  -1,
+  "piece",
+  "s",
+  NULL
+};
+static const GDBusArgInfo *const si_getstate_in_arg_pointers[] = { &si_getstate_in_args, NULL };
+
+// TODO: this is really a a{sv} or something like that.
+static const GDBusArgInfo si_getstate_out_args =
+{
+  -1,
+  "state",
+  "a{sv}",
+  NULL
+};
+static const GDBusArgInfo *const si_getstate_out_arg_pointers[] = { &si_getstate_out_args, NULL };
+
+static const GDBusMethodInfo si_method_info_getstate =
+{
+  -1,
+  "GetState",
+  (GDBusArgInfo **) &si_getstate_in_arg_pointers,
+  (GDBusArgInfo **) &si_getstate_out_arg_pointers,
+  NULL
+};
+
+static const GDBusMethodInfo *const si_method_info_pointers[] = { &si_method_info_getstate, NULL };
+
+static const GDBusInterfaceInfo si_iface_info =
+{
+  -1,
+  "com.canonical.Unity.Debug.Introspection",
+  (GDBusMethodInfo **) &si_method_info_pointers,
+  NULL,
+  NULL,
+  NULL,
+};
+
+static Introspectable      *_introspectable;
+
+IntrospectionDBusInterface::IntrospectionDBusInterface (Introspectable *introspectable)
+{
+  _introspectable = introspectable;
+  _owner_id = g_bus_own_name (G_BUS_TYPE_SESSION,
+                              UNITY_STATE_DEBUG_BUS_NAME,
+                              G_BUS_NAME_OWNER_FLAGS_NONE,
+                              &IntrospectionDBusInterface::OnBusAcquired,
+                              &IntrospectionDBusInterface::OnNameAcquired,
+                              &IntrospectionDBusInterface::OnNameLost,
+                              this,
+                              NULL);
+}
+
+IntrospectionDBusInterface::~IntrospectionDBusInterface ()
+{
+  g_bus_unown_name (_owner_id);
+}
+
+void 
+IntrospectionDBusInterface::OnBusAcquired (GDBusConnection *connection, const gchar *name, gpointer data)
+{
+  GError *error = NULL;
+  g_dbus_connection_register_object (connection,
+                                     "/com/canonical/Unity/Debug/Introspection",
+                                     (GDBusInterfaceInfo *) &si_iface_info,
+                                     &si_vtable,
+                                     NULL,
+                                     NULL,
+                                     &error);
+  if (error != NULL)
+  {
+    g_warning ("Could not register Introspection object onto d-bus");
+	g_error_free (error);
+  }
+}
+
+void
+IntrospectionDBusInterface::OnNameAcquired (GDBusConnection *connection, const gchar *name, gpointer data)
+{
+}
+
+void
+IntrospectionDBusInterface::OnNameLost (GDBusConnection *connection, const gchar *name, gpointer data)
+{
+}
+
+void
+DBusMethodCall (GDBusConnection *connection,
+                                                 const gchar *sender,
+                                                 const gchar *objectPath,
+                                                 const gchar *ifaceName,
+                                                 const gchar *methodName,
+                                                 GVariant *parameters,
+                                                 GDBusMethodInvocation *invocation,
+                                                 gpointer data)
+{
+  if (g_strcmp0 (methodName, "GetState") == 0)
+  {
+    GVariant *ret;
+    const gchar *input;
+    g_variant_get (parameters, "(&s)", &input);
+
+    ret = GetState (input);
+    g_dbus_method_invocation_return_value (invocation, ret);
+    g_variant_unref (ret);
+  }
+  else
+  {
+    g_dbus_method_invocation_return_dbus_error (invocation, "com.canonical.Unity",
+                                                "Failed to find method");
+  }
+}
+
+GVariant*
+GetState (const gchar *piece)
+{
+  return _introspectable->Introspect ();
+}
+
+/* a very contrived example purely for giving QA something purposes */
+GVariant*
+IntrospectionDBusInterface::BuildFakeReturn ()
+{
+  GVariantBuilder *builder;
+  GVariant *result, *panel_result, *indicators_result, *appmenu_result, *entries_result, *zero_result, *one_result;
+
+  builder = g_variant_builder_new (G_VARIANT_TYPE ("a{sv}") );
+  g_variant_builder_add (builder, "{sv}", "label", g_variant_new_string ("_File") );
+  g_variant_builder_add (builder, "{sv}", "image", g_variant_new_string ("") );
+  g_variant_builder_add (builder, "{sv}", "visible", g_variant_new_boolean (TRUE) );
+  g_variant_builder_add (builder, "{sv}", "sensitive", g_variant_new_boolean (TRUE) );
+  g_variant_builder_add (builder, "{sv}", "active", g_variant_new_boolean (FALSE) );
+  g_variant_builder_add (builder, "{sv}", "label", g_variant_new_int32 (34) );
+  g_variant_builder_add (builder, "{sv}", "label", g_variant_new_int32 (24) );
+  zero_result = g_variant_new ("(a{sv})", builder);
+  g_variant_builder_unref (builder);
+
+  builder = g_variant_builder_new (G_VARIANT_TYPE ("a{sv}") );
+  g_variant_builder_add (builder, "{sv}", "label", g_variant_new_string ("_Edit") );
+  g_variant_builder_add (builder, "{sv}", "image", g_variant_new_string ("") );
+  g_variant_builder_add (builder, "{sv}", "visible", g_variant_new_boolean (TRUE) );
+  g_variant_builder_add (builder, "{sv}", "sensitive", g_variant_new_boolean (TRUE) );
+  g_variant_builder_add (builder, "{sv}", "active", g_variant_new_boolean (FALSE) );
+  g_variant_builder_add (builder, "{sv}", "label", g_variant_new_int32 (34) );
+  g_variant_builder_add (builder, "{sv}", "label", g_variant_new_int32 (24) );
+  one_result = g_variant_new ("(a{sv})", builder);
+  g_variant_builder_unref (builder);
+
+  builder = g_variant_builder_new (G_VARIANT_TYPE ("a{sv}") );
+  g_variant_builder_add (builder, "{sv}", "0", zero_result);
+  g_variant_builder_add (builder, "{sv}", "1", one_result);
+  entries_result = g_variant_new ("(a{sv})", builder);
+  g_variant_builder_unref (builder);
+
+  builder = g_variant_builder_new (G_VARIANT_TYPE ("a{sv}") );
+  g_variant_builder_add (builder, "{sv}", "model-name",
+                         g_variant_new_string ("com.canonical.Unity.Panel.Service.Indicators.appmenu.324234243") );
+  g_variant_builder_add (builder, "{sv}", "entries", entries_result);
+  appmenu_result = g_variant_new ("(a{sv})", builder);
+  g_variant_builder_unref (builder);
+
+  builder = g_variant_builder_new (G_VARIANT_TYPE ("a{sv}") );
+  g_variant_builder_add (builder, "{sv}", "appmenu", appmenu_result);
+  indicators_result = g_variant_new ("(a{sv})", builder);
+  g_variant_builder_unref (builder);
+
+  builder = g_variant_builder_new (G_VARIANT_TYPE ("a{sv}") );
+  g_variant_builder_add (builder, "{sv}", "backend",
+                         g_variant_new_string ("/com/canonical/Unity/Panel/Service/324234243") );
+  g_variant_builder_add (builder, "{sv}", "launch-type",
+                         g_variant_new_string ("dbus") );
+  g_variant_builder_add (builder, "{sv}", "width", g_variant_new_int32 (1024) );
+  g_variant_builder_add (builder, "{sv}", "width", g_variant_new_int32 (32) );
+  g_variant_builder_add (builder, "{sv}", "theme", g_variant_new_string ("gtk") );
+  g_variant_builder_add (builder, "{sv}", "indicators", indicators_result);
+  panel_result = g_variant_new ("(a{sv})", builder);
+  g_variant_builder_unref (builder);
+
+  builder = g_variant_builder_new (G_VARIANT_TYPE ("a{sv}") );
+  g_variant_builder_add (builder, "{sv}", "panel", panel_result);
+  result = g_variant_new ("(a{sv})", builder);
+  g_variant_builder_unref (builder);
+
+  gchar *s = g_variant_print (result, TRUE);
+  g_free (s);
+  return result;
+}

=== added file 'plugins/unityshell/src/IntrospectionDBusInterface.h'
--- plugins/unityshell/src/IntrospectionDBusInterface.h	1970-01-01 00:00:00 +0000
+++ plugins/unityshell/src/IntrospectionDBusInterface.h	2010-12-13 12:41:23 +0000
@@ -0,0 +1,54 @@
+/*
+ * Copyright (C) 2010 Canonical Ltd
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 3 as
+ * published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ *
+ * Authored by: Alex Launi <[e-mail]>
+ */
+
+#ifndef _STATE_INTROSPECTION_DBUS_INTERFACE_H
+#define _STATE_INTROSPECTION_DBUS_INTERFACE_H 1
+
+#include <glib.h>
+#include <gio/gio.h>
+#include "Introspectable.h"
+
+class IntrospectionDBusInterface
+{
+public:
+  IntrospectionDBusInterface  (Introspectable *introspectable);
+  ~IntrospectionDBusInterface ();
+
+  /*static void DBusMethodCall (GDBusConnection *connection, const gchar *sender,
+                              const gchar *objectPath, const gchar *ifaceName,
+                              const gchar *methodName, GVariant *parameters,
+                              GDBusMethodInvocation *invocation, gpointer data);	*/
+
+private:
+  /* methods */
+
+  static void OnBusAcquired (GDBusConnection *connection, const gchar *name, gpointer data);
+
+  static void OnNameAcquired (GDBusConnection *connection, const gchar *name, gpointer data);
+
+  static void OnNameLost (GDBusConnection *connection, const gchar *name, gpointer data);
+
+  //static GVariant *GetState (const char *piece);
+
+  static GVariant *BuildFakeReturn ();
+
+  /* members */
+  guint						_owner_id;
+};
+
+#endif

=== added file 'plugins/unityshell/src/Launcher.cpp'
--- plugins/unityshell/src/Launcher.cpp	1970-01-01 00:00:00 +0000
+++ plugins/unityshell/src/Launcher.cpp	2010-12-13 12:41:23 +0000
@@ -0,0 +1,2075 @@
+/*
+ * Copyright (C) 2010 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: Jason Smith <[e-mail]>
+ * Authored by: Jay Taoko <[e-mail]>
+ */
+
+#include <math.h>
+
+#include "Nux/Nux.h"
+#include "Nux/VScrollBar.h"
+#include "Nux/HLayout.h"
+#include "Nux/VLayout.h"
+#include "Nux/MenuPage.h"
+
+#include "NuxGraphics/NuxGraphics.h"
+#include "NuxGraphics/GpuDevice.h"
+#include "NuxGraphics/GLTextureResourceManager.h"
+
+#include "Nux/BaseWindow.h"
+#include "Nux/WindowCompositor.h"
+
+#include "Launcher.h"
+#include "LauncherIcon.h"
+#include "LauncherModel.h"
+#include "QuicklistManager.h"
+#include "QuicklistView.h"
+
+#define ANIM_DURATION_SHORT 125
+#define ANIM_DURATION       200
+#define ANIM_DURATION_LONG  350
+
+#define URGENT_BLINKS       3
+
+#define MAX_STARTING_BLINKS 5
+#define STARTING_BLINK_LAMBDA 3
+
+#define BACKLIGHT_STRENGTH  0.9f
+
+int
+TimeDelta (struct timespec const *x, struct timespec const *y)
+{
+  return ((x->tv_sec - y->tv_sec) * 1000) + ((x->tv_nsec - y->tv_nsec) / 1000000);
+}
+
+static bool USE_ARB_SHADERS = true;
+/*
+	        Use this shader to pass vertices in screen coordinates in the C++ code and compute use
+	        the fragment shader to perform the texture perspective correct division.
+	        This shader assume the following:
+		        - the projection matrix is orthogonal: glOrtho(0, ScreenWidth, ScreenWidth, 0, Near, Far)
+		        - vertices x and y are in screen coordinates: Vertex(x_screen, y_screen, 0, 1.0)
+		        - the vertices w coordinates has been computed 'manually'
+		        - vertices uv textture coordinates are passed to the shader as:  (u/w, v/w, 0, 1/w)
+
+	        The texture coordinates s=u/w, t=v/w and q=1w are interpolated linearly in screen coordinates.
+	        In the fragment shader we get the texture coordinates used for the sampling by dividing
+	        s and t resulting from the interpolation by q.
+
+        */
+
+nux::NString gPerspectiveCorrectShader = TEXT (
+"[Vertex Shader]                                                        \n\
+#version 120                                                            \n\
+uniform mat4 ViewProjectionMatrix;                                      \n\
+                                                                        \n\
+attribute vec4 iColor;                                                  \n\
+attribute vec4 iTexCoord0;                                              \n\
+attribute vec4 iVertex;                                                 \n\
+                                                                        \n\
+varying vec4 varyTexCoord0;                                             \n\
+varying vec4 varyVertexColor;                                           \n\
+                                                                        \n\
+void main()                                                             \n\
+{                                                                       \n\
+    varyTexCoord0 = iTexCoord0;                                         \n\
+    varyVertexColor = iColor;                                           \n\
+    gl_Position =  ViewProjectionMatrix * iVertex;                      \n\
+}                                                                       \n\
+                                                                        \n\
+[Fragment Shader]                                                       \n\
+#version 120                                                            \n\
+#extension GL_ARB_texture_rectangle : enable                            \n\
+                                                                        \n\
+varying vec4 varyTexCoord0;                                             \n\
+varying vec4 varyVertexColor;                                           \n\
+                                                                        \n\
+uniform sampler2D TextureObject0;                                       \n\
+uniform vec4 color0;                                                     \n\
+vec4 SampleTexture(sampler2D TexObject, vec4 TexCoord)                  \n\
+{                                                                       \n\
+  return texture2D(TexObject, TexCoord.st);                             \n\
+}                                                                       \n\
+                                                                        \n\
+void main()                                                             \n\
+{                                                                       \n\
+  vec4 tex = varyTexCoord0;                                             \n\
+  tex.s = tex.s/varyTexCoord0.w;                                        \n\
+  tex.t = tex.t/varyTexCoord0.w;                                        \n\
+	                                                                      \n\
+  vec4 texel = SampleTexture(TextureObject0, tex);                      \n\
+  gl_FragColor = texel*varyVertexColor;                                 \n\
+}                                                                       \n\
+");
+
+nux::NString PerspectiveCorrectVtx = TEXT (
+                            "!!ARBvp1.0                                 \n\
+                            ATTRIB iPos         = vertex.position;      \n\
+                            ATTRIB iColor       = vertex.attrib[3];     \n\
+                            PARAM  mvp[4]       = {state.matrix.mvp};   \n\
+                            OUTPUT oPos         = result.position;      \n\
+                            OUTPUT oColor       = result.color;         \n\
+                            OUTPUT oTexCoord0   = result.texcoord[0];   \n\
+                            # Transform the vertex to clip coordinates. \n\
+                            DP4   oPos.x, mvp[0], iPos;                 \n\
+                            DP4   oPos.y, mvp[1], iPos;                 \n\
+                            DP4   oPos.z, mvp[2], iPos;                 \n\
+                            DP4   oPos.w, mvp[3], iPos;                 \n\
+                            MOV   oColor, iColor;                       \n\
+                            MOV   oTexCoord0, vertex.attrib[8];         \n\
+                            END");
+
+
+
+nux::NString PerspectiveCorrectTexFrg = TEXT (
+                            "!!ARBfp1.0                                 \n\
+                            PARAM color0 = program.local[0];            \n\
+                            TEMP temp;                                  \n\
+                            TEMP pcoord;                                \n\
+                            TEMP tex0;                                  \n\
+                            TEMP temp1;                                 \n\
+                            TEMP recip;                                 \n\
+                            MOV pcoord, fragment.texcoord[0].w;         \n\
+                            RCP temp, fragment.texcoord[0].w;           \n\
+                            MUL pcoord.xy, fragment.texcoord[0], temp;  \n\
+                            TEX tex0, pcoord, texture[0], 2D;           \n\
+                            MUL result.color, color0, tex0;             \n\
+                            END");
+
+nux::NString PerspectiveCorrectTexRectFrg = TEXT (
+                            "!!ARBfp1.0                                 \n\
+                            PARAM color0 = program.local[0];            \n\
+                            TEMP temp;                                  \n\
+                            TEMP pcoord;                                \n\
+                            TEMP tex0;                                  \n\
+                            MOV pcoord, fragment.texcoord[0].w;         \n\
+                            RCP temp, fragment.texcoord[0].w;           \n\
+                            MUL pcoord.xy, fragment.texcoord[0], temp;  \n\
+                            TEX tex0, pcoord, texture[0], RECT;         \n\
+                            MUL result.color, color0, tex0;     \n\
+                            END");
+
+static void GetInverseScreenPerspectiveMatrix(nux::Matrix4& ViewMatrix, nux::Matrix4& PerspectiveMatrix,
+                                       int ViewportWidth,
+                                       int ViewportHeight,
+                                       float NearClipPlane,
+                                       float FarClipPlane,
+                                       float Fovy);
+
+Launcher::Launcher(nux::BaseWindow *parent, CompScreen *screen, NUX_FILE_LINE_DECL)
+:   View(NUX_FILE_LINE_PARAM)
+,   m_ContentOffsetY(0)
+,   m_RunningIndicator(0)
+,   m_ActiveIndicator(0)
+,   m_BackgroundLayer(0)
+,   _model (0)
+{
+    _parent = parent;
+    _screen = screen;
+    _active_quicklist = 0;
+
+    m_Layout = new nux::HLayout(NUX_TRACKER_LOCATION);
+
+    OnMouseDown.connect(sigc::mem_fun(this, &Launcher::RecvMouseDown));
+    OnMouseUp.connect(sigc::mem_fun(this, &Launcher::RecvMouseUp));
+    OnMouseDrag.connect(sigc::mem_fun(this, &Launcher::RecvMouseDrag));
+    OnMouseEnter.connect(sigc::mem_fun(this, &Launcher::RecvMouseEnter));
+    OnMouseLeave.connect(sigc::mem_fun(this, &Launcher::RecvMouseLeave));
+    OnMouseMove.connect(sigc::mem_fun(this, &Launcher::RecvMouseMove));
+    OnMouseWheel.connect(sigc::mem_fun(this, &Launcher::RecvMouseWheel));
+
+    QuicklistManager::Default ()->quicklist_opened.connect (sigc::mem_fun(this, &Launcher::RecvQuicklistOpened));
+    QuicklistManager::Default ()->quicklist_closed.connect (sigc::mem_fun(this, &Launcher::RecvQuicklistClosed));
+
+    m_ActiveTooltipIcon = NULL;
+    m_ActiveMenuIcon = NULL;
+
+    SetCompositionLayout(m_Layout);
+
+    if(!USE_ARB_SHADERS)
+    {
+      _shader_program_uv_persp_correction = nux::GetThreadGLDeviceFactory()->CreateShaderProgram();
+      _shader_program_uv_persp_correction->LoadIShader(gPerspectiveCorrectShader.GetTCharPtr());
+      _shader_program_uv_persp_correction->Link();
+    }
+    else
+    {
+      _AsmShaderProg = nux::GetThreadGLDeviceFactory()->CreateAsmShaderProgram();
+      _AsmShaderProg->LoadVertexShader (TCHAR_TO_ANSI (*PerspectiveCorrectVtx) );
+
+      if ((nux::GetThreadGLDeviceFactory()->SUPPORT_GL_ARB_TEXTURE_NON_POWER_OF_TWO() == false) &&
+        (nux::GetThreadGLDeviceFactory()->SUPPORT_GL_EXT_TEXTURE_RECTANGLE () || nux::GetThreadGLDeviceFactory()->SUPPORT_GL_ARB_TEXTURE_RECTANGLE ()))
+      {
+        // No support for non power of two textures but support for rectangle textures
+        _AsmShaderProg->LoadPixelShader (TCHAR_TO_ANSI (*PerspectiveCorrectTexRectFrg) );
+      }
+      else
+      {
+        _AsmShaderProg->LoadPixelShader (TCHAR_TO_ANSI (*PerspectiveCorrectTexFrg) );
+      }
+
+      _AsmShaderProg->Link();
+    }
+
+    _folded_angle           = 1.0f;
+    _neg_folded_angle       = -1.0f;
+    _space_between_icons    = 5;
+    _launcher_top_y         = 0;
+    _launcher_bottom_y      = 0;
+    _folded_z_distance      = 10.0f;
+    _launcher_state         = LAUNCHER_FOLDED;
+    _launcher_action_state  = ACTION_NONE;
+    _icon_under_mouse       = NULL;
+    _icon_mouse_down        = NULL;
+    _drag_icon              = NULL;
+    _drag_icon_under_mouse  = NULL;
+    _icon_image_size        = 48;
+    _icon_glow_size         = 62;
+    _icon_image_size_delta  = 6;
+    _icon_size              = _icon_image_size + _icon_image_size_delta;
+
+    _icon_bkg_texture       = nux::CreateTextureFromFile (PKGDATADIR"/round_corner_54x54.png");
+    _icon_outline_texture   = nux::CreateTextureFromFile (PKGDATADIR"/round_outline_54x54.png");
+    _icon_shine_texture     = nux::CreateTextureFromFile (PKGDATADIR"/round_shine_54x54.png");
+    _icon_glow_texture      = nux::CreateTextureFromFile (PKGDATADIR"/round_glow_62x62.png");
+    _icon_2indicator        = nux::CreateTextureFromFile (PKGDATADIR"/2indicate_54x54.png");
+    _icon_3indicator        = nux::CreateTextureFromFile (PKGDATADIR"/3indicate_54x54.png");
+    _icon_4indicator        = nux::CreateTextureFromFile (PKGDATADIR"/4indicate_54x54.png");
+
+    _enter_y                = 0;
+    _dnd_security           = 15;
+    _launcher_drag_delta    = 0;
+    _dnd_delta_y            = 0;
+    _dnd_delta_x            = 0;
+    _anim_handle            = 0;
+    _autohide_handle        = 0;
+    _floating               = false;
+    _hovered                = false;
+    _autohide               = false;
+    _hidden                 = false;
+    _mouse_inside_launcher  = false;
+    _mouse_inside_trigger   = false;
+    _window_over_launcher   = false;
+
+    // 0 out timers to avoid wonky startups
+    _enter_time.tv_sec = 0;
+    _enter_time.tv_nsec = 0;
+    _exit_time.tv_sec = 0;
+    _exit_time.tv_nsec = 0;
+    _drag_end_time.tv_sec = 0;
+    _drag_end_time.tv_nsec = 0;
+    _drag_start_time.tv_sec = 0;
+    _drag_start_time.tv_nsec = 0;
+    _autohide_time.tv_sec = 0;
+    _autohide_time.tv_nsec = 0;
+    
+    _drag_window = NULL;
+}
+
+Launcher::~Launcher()
+{
+
+}
+
+/* Introspection */
+const gchar *
+Launcher::GetName ()
+{
+  return "Launcher";
+}
+
+void
+Launcher::AddProperties (GVariantBuilder *builder)
+{
+  struct timespec current;
+  clock_gettime (CLOCK_MONOTONIC, &current);
+
+  g_variant_builder_add (builder, "{sv}", "hover-progress", g_variant_new_double ((double) GetHoverProgress (current)));
+  g_variant_builder_add (builder, "{sv}", "dnd-exit-progress", g_variant_new_double ((double) DnDExitProgress (current)));
+  g_variant_builder_add (builder, "{sv}", "autohide-progress", g_variant_new_double ((double) AutohideProgress (current)));
+
+  g_variant_builder_add (builder, "{sv}", "dnd-delta", g_variant_new_int32 (_dnd_delta_y));
+  g_variant_builder_add (builder, "{sv}", "floating", g_variant_new_boolean (_floating));
+  g_variant_builder_add (builder, "{sv}", "hovered", g_variant_new_boolean (_hovered));
+  g_variant_builder_add (builder, "{sv}", "autohide", g_variant_new_boolean (_autohide));
+  g_variant_builder_add (builder, "{sv}", "hidden", g_variant_new_boolean (_hidden));
+  g_variant_builder_add (builder, "{sv}", "autohide", g_variant_new_boolean (_autohide));
+  g_variant_builder_add (builder, "{sv}", "mouse-inside-launcher", g_variant_new_boolean (_mouse_inside_launcher));
+}
+
+/* Render Layout Logic */
+
+float Launcher::GetHoverProgress (struct timespec const &current)
+{
+    if (_hovered)
+        return CLAMP ((float) (TimeDelta (&current, &_enter_time)) / (float) ANIM_DURATION, 0.0f, 1.0f);
+    else
+        return 1.0f - CLAMP ((float) (TimeDelta (&current, &_exit_time)) / (float) ANIM_DURATION, 0.0f, 1.0f);
+}
+
+float Launcher::DnDExitProgress (struct timespec const &current)
+{
+    return 1.0f - CLAMP ((float) (TimeDelta (&current, &_drag_end_time)) / (float) ANIM_DURATION_LONG, 0.0f, 1.0f);
+}
+
+float Launcher::DnDStartProgress (struct timespec const &current)
+{
+  return CLAMP ((float) (TimeDelta (&current, &_drag_start_time)) / (float) ANIM_DURATION, 0.0f, 1.0f);
+}
+
+float Launcher::AutohideProgress (struct timespec const &current)
+{
+    if (!_autohide)
+        return 0.0f;
+
+    if (_hidden)
+        return CLAMP ((float) (TimeDelta (&current, &_autohide_time)) / (float) ANIM_DURATION_SHORT, 0.0f, 1.0f);
+    else
+        return 1.0f - CLAMP ((float) (TimeDelta (&current, &_autohide_time)) / (float) ANIM_DURATION_SHORT, 0.0f, 1.0f);
+}
+
+gboolean Launcher::AnimationTimeout (gpointer data)
+{
+    Launcher *self = (Launcher*) data;
+
+    self->NeedRedraw ();
+
+    if (self->AnimationInProgress ())
+      return true;
+
+    // zero out handle so we know we are done
+    self->_anim_handle = 0;
+    return false;
+}
+
+void Launcher::EnsureAnimation ()
+{
+    if (_anim_handle)
+      return;
+
+    NeedRedraw ();
+
+    if (AnimationInProgress ())
+        _anim_handle = g_timeout_add (1000 / 60 - 1, &Launcher::AnimationTimeout, this);
+}
+
+bool Launcher::IconNeedsAnimation (LauncherIcon *icon, struct timespec const &current)
+{
+    struct timespec time = icon->GetQuirkTime (LAUNCHER_ICON_QUIRK_VISIBLE);
+    if (TimeDelta (&current, &time) < ANIM_DURATION_SHORT)
+        return true;
+
+    time = icon->GetQuirkTime (LAUNCHER_ICON_QUIRK_RUNNING);
+    if (TimeDelta (&current, &time) < ANIM_DURATION_SHORT)
+        return true;
+
+    time = icon->GetQuirkTime (LAUNCHER_ICON_QUIRK_STARTING);
+    if (TimeDelta (&current, &time) < (ANIM_DURATION_LONG * MAX_STARTING_BLINKS * STARTING_BLINK_LAMBDA * 2))
+        return true;
+
+    time = icon->GetQuirkTime (LAUNCHER_ICON_QUIRK_URGENT);
+    if (TimeDelta (&current, &time) < (ANIM_DURATION_LONG * URGENT_BLINKS * 2))
+        return true;
+
+    time = icon->GetQuirkTime (LAUNCHER_ICON_QUIRK_PRESENTED);
+    if (TimeDelta (&current, &time) < ANIM_DURATION)
+        return true;
+
+    time = icon->GetQuirkTime (LAUNCHER_ICON_QUIRK_SHIMMER);
+    if (TimeDelta (&current, &time) < ANIM_DURATION_LONG)
+        return true;
+
+    return false;
+}
+
+bool Launcher::AnimationInProgress ()
+{
+    // HACK
+    if (_launcher_action_state == ACTION_DRAG_ICON)
+      return true;
+    // performance here can be improved by caching the longer remaining animation found and short circuiting to that each time
+    // this way extra checks may be avoided
+
+    // short circuit to avoid unneeded calculations
+    struct timespec current;
+    clock_gettime (CLOCK_MONOTONIC, &current);
+
+    // hover in animation
+    if (TimeDelta (&current, &_enter_time) < ANIM_DURATION)
+       return true;
+
+    // hover out animation
+    if (TimeDelta (&current, &_exit_time) < ANIM_DURATION)
+        return true;
+    
+    // drag start animation
+    if (TimeDelta (&current, &_drag_start_time) < ANIM_DURATION)
+        return true;
+    
+    // drag end animation
+    if (TimeDelta (&current, &_drag_end_time) < ANIM_DURATION_LONG)
+        return true;
+
+    if (TimeDelta (&current, &_autohide_time) < ANIM_DURATION_SHORT)
+        return true;
+
+    // animations happening on specific icons
+    LauncherModel::iterator it;
+    for (it = _model->begin  (); it != _model->end (); it++)
+        if (IconNeedsAnimation (*it, current))
+            return true;
+
+    return false;
+}
+
+void Launcher::SetTimeStruct (struct timespec *timer, struct timespec *sister, int sister_relation)
+{
+    struct timespec current;
+    clock_gettime (CLOCK_MONOTONIC, &current);
+
+    if (sister)
+    {
+        int diff = TimeDelta (&current, sister);
+
+        if (diff < sister_relation)
+        {
+            int remove = sister_relation - diff;
+            current.tv_sec -= remove / 1000;
+            remove = remove % 1000;
+
+            if (remove > current.tv_nsec / 1000000)
+            {
+                current.tv_sec--;
+                current.tv_nsec += 1000000000;
+            }
+            current.tv_nsec -= remove * 1000000;
+        }
+    }
+
+    timer->tv_sec = current.tv_sec;
+    timer->tv_nsec = current.tv_nsec;
+}
+
+float IconVisibleProgress (LauncherIcon *icon, struct timespec const &current)
+{
+    if (icon->GetQuirk (LAUNCHER_ICON_QUIRK_VISIBLE))
+    {
+        struct timespec icon_visible_time = icon->GetQuirkTime (LAUNCHER_ICON_QUIRK_VISIBLE);
+        int enter_ms = TimeDelta (&current, &icon_visible_time);
+        return CLAMP ((float) enter_ms / (float) ANIM_DURATION_SHORT, 0.0f, 1.0f);
+    }
+    else
+    {
+        struct timespec icon_hide_time = icon->GetQuirkTime (LAUNCHER_ICON_QUIRK_VISIBLE);
+        int hide_ms = TimeDelta (&current, &icon_hide_time);
+        return 1.0f - CLAMP ((float) hide_ms / (float) ANIM_DURATION_SHORT, 0.0f, 1.0f);
+    }
+}
+
+void Launcher::SetDndDelta (float x, float y, nux::Geometry geo, struct timespec const &current)
+{
+    LauncherIcon *anchor = 0;
+    LauncherModel::iterator it;
+    anchor = MouseIconIntersection (x, _enter_y);
+
+    if (anchor)
+    {
+        float position = y;
+        for (it = _model->begin (); it != _model->end (); it++)
+        {
+            if (*it == anchor)
+            {
+                position += _icon_size / 2;
+                _launcher_drag_delta = _enter_y - position;
+
+                if (position + _icon_size / 2 + _launcher_drag_delta > geo.height)
+                    _launcher_drag_delta -= (position + _icon_size / 2 + _launcher_drag_delta) - geo.height;
+
+                break;
+            }
+            position += (_icon_size + _space_between_icons) * IconVisibleProgress (*it, current);
+        }
+    }
+}
+
+float Launcher::IconPresentProgress (LauncherIcon *icon, struct timespec const &current)
+{
+    struct timespec icon_present_time = icon->GetQuirkTime (LAUNCHER_ICON_QUIRK_PRESENTED);
+    int ms = TimeDelta (&current, &icon_present_time);
+    float result = CLAMP ((float) ms / (float) ANIM_DURATION, 0.0f, 1.0f);
+
+    if (icon->GetQuirk (LAUNCHER_ICON_QUIRK_PRESENTED))
+        return result;
+    else
+        return 1.0f - result;
+}
+
+float Launcher::IconUrgentProgress (LauncherIcon *icon, struct timespec const &current)
+{
+    struct timespec urgent_time = icon->GetQuirkTime (LAUNCHER_ICON_QUIRK_URGENT);
+    int urgent_ms = TimeDelta (&current, &urgent_time);
+    float result = CLAMP ((float) urgent_ms / (float) (ANIM_DURATION_LONG * URGENT_BLINKS * 2), 0.0f, 1.0f);
+
+    if (icon->GetQuirk (LAUNCHER_ICON_QUIRK_URGENT))
+      return result;
+    else
+      return 1.0f - result;
+}
+
+float Launcher::IconShimmerProgress (LauncherIcon *icon, struct timespec const &current)
+{
+    struct timespec shimmer_time = icon->GetQuirkTime (LAUNCHER_ICON_QUIRK_SHIMMER);
+    int shimmer_ms = TimeDelta (&current, &shimmer_time);
+    return CLAMP ((float) shimmer_ms / (float) ANIM_DURATION_LONG, 0.0f, 1.0f);
+}
+
+float Launcher::IconUrgentPulseValue (LauncherIcon *icon, struct timespec const &current)
+{
+    if (!icon->GetQuirk (LAUNCHER_ICON_QUIRK_URGENT))
+        return 1.0f; // we are full on in a normal condition
+
+    double urgent_progress = (double) IconUrgentProgress (icon, current);
+    return 0.5f + (float) (std::cos (M_PI * (float) (URGENT_BLINKS * 2) * urgent_progress)) * 0.5f;
+}
+
+float Launcher::IconStartingPulseValue (LauncherIcon *icon, struct timespec const &current)
+{
+    struct timespec starting_time = icon->GetQuirkTime (LAUNCHER_ICON_QUIRK_STARTING);
+    int starting_ms = TimeDelta (&current, &starting_time);
+    double starting_progress = (double) CLAMP ((float) starting_ms / (float) (ANIM_DURATION_LONG * MAX_STARTING_BLINKS * STARTING_BLINK_LAMBDA * 2), 0.0f, 1.0f);
+
+    if (starting_progress == 1.0f && !icon->GetQuirk (LAUNCHER_ICON_QUIRK_RUNNING))
+    {
+        icon->SetQuirk (LAUNCHER_ICON_QUIRK_STARTING, false);
+        icon->ResetQuirkTime (LAUNCHER_ICON_QUIRK_STARTING);
+    }
+
+    return 1.0f - (0.5f + (float) (std::cos (M_PI * (float) (MAX_STARTING_BLINKS * 2) * starting_progress)) * 0.5f);
+}
+
+float Launcher::IconBackgroundIntensity (LauncherIcon *icon, struct timespec const &current)
+{
+    float result = 0.0f;
+    struct timespec running_time = icon->GetQuirkTime (LAUNCHER_ICON_QUIRK_RUNNING);
+    int running_ms = TimeDelta (&current, &running_time);
+    float running_progress = CLAMP ((float) running_ms / (float) ANIM_DURATION_SHORT, 0.0f, 1.0f);
+
+    // After we finish a fade in from running, we can reset the quirk
+    if (running_progress == 1.0f && icon->GetQuirk (LAUNCHER_ICON_QUIRK_RUNNING))
+    {
+         icon->SetQuirk (LAUNCHER_ICON_QUIRK_STARTING, false);
+         icon->ResetQuirkTime (LAUNCHER_ICON_QUIRK_STARTING);
+    }   
+
+    result = IconStartingPulseValue (icon, current) * BACKLIGHT_STRENGTH;
+
+    if (icon->GetQuirk (LAUNCHER_ICON_QUIRK_RUNNING))
+    {
+        // running progress fades in whatever the pulsing did not fill in already
+        result += running_progress * (BACKLIGHT_STRENGTH - result);
+
+        // urgent serves to bring the total down only
+        if (icon->GetQuirk (LAUNCHER_ICON_QUIRK_URGENT))
+            result *= 0.2f + 0.8f * IconUrgentPulseValue (icon, current);
+    }
+    else
+    {
+        // modestly evil
+        result += BACKLIGHT_STRENGTH - running_progress * BACKLIGHT_STRENGTH;
+    }
+
+    return result;
+}
+
+void Launcher::SetupRenderArg (LauncherIcon *icon, struct timespec const &current, RenderArg &arg)
+{
+    arg.icon            = icon;
+    arg.alpha           = 1.0f;
+    arg.running_arrow   = icon->GetQuirk (LAUNCHER_ICON_QUIRK_RUNNING);
+    arg.active_arrow    = icon->GetQuirk (LAUNCHER_ICON_QUIRK_ACTIVE);
+    arg.running_colored = icon->GetQuirk (LAUNCHER_ICON_QUIRK_URGENT);
+    arg.active_colored  = false;
+    arg.folding_rads    = 0.0f;
+    arg.skip            = false;
+
+
+    // we dont need to show strays
+    if (!icon->GetQuirk (LAUNCHER_ICON_QUIRK_RUNNING))
+        arg.window_indicators = 0;
+    else
+        arg.window_indicators = MIN (4, icon->RelatedWindows ());
+
+    arg.backlight_intensity = IconBackgroundIntensity (icon, current);
+    arg.shimmer_progress = IconShimmerProgress (icon, current);
+
+    float urgent_progress = IconUrgentProgress (icon, current);
+    
+    if (icon->GetQuirk (LAUNCHER_ICON_QUIRK_URGENT))
+      urgent_progress = CLAMP (urgent_progress * 3.0f, 0.0f, 1.0f); // we want to go 3x faster than the urgent normal cycle
+    else
+      urgent_progress = CLAMP (urgent_progress * 3.0f - 2.0f, 0.0f, 1.0f); // we want to go 3x faster than the urgent normal cycle
+    arg.glow_intensity = urgent_progress;
+}
+
+void Launcher::FillRenderArg (LauncherIcon *icon,
+                              RenderArg &arg,
+                              nux::Point3 &center,
+                              float folding_threshold,
+                              float folded_size,
+                              float folded_spacing,
+                              float autohide_offset,
+                              float folded_z_distance,
+                              float animation_neg_rads,
+                              int vertical_offset,
+                              struct timespec const &current)
+{
+    SetupRenderArg (icon, current, arg);
+
+    // reset z
+    center.z = 0;
+    
+    float size_modifier = IconVisibleProgress (icon, current);
+    if (size_modifier < 1.0f)
+    {
+        arg.alpha = size_modifier;
+        center.z = 300.0f * (1.0f - size_modifier);
+    }
+
+    if (size_modifier <= 0.0f || icon == _drag_icon)
+        arg.skip = true;
+
+    // goes for 0.0f when fully unfolded, to 1.0f folded
+    float folding_progress = CLAMP ((center.y + _icon_size - folding_threshold) / (float) _icon_size, 0.0f, 1.0f);
+    float present_progress = IconPresentProgress (icon, current);
+
+    folding_progress *= 1.0f - present_progress;
+
+    float half_size = (folded_size / 2.0f) + (_icon_size / 2.0f - folded_size / 2.0f) * (1.0f - folding_progress);
+
+    float icon_hide_offset = autohide_offset;
+
+    icon_hide_offset *= 1.0f - (present_progress * icon->PresentUrgency ());
+
+    // icon is crossing threshold, start folding
+    center.z += folded_z_distance * folding_progress;
+    arg.folding_rads = animation_neg_rads * folding_progress;
+
+    float spacing_overlap = CLAMP ((float) (center.y + (2.0f * half_size * size_modifier) + (_space_between_icons * size_modifier) - folding_threshold) / (float) _icon_size, 0.0f, 1.0f);
+    float spacing = (_space_between_icons * (1.0f - spacing_overlap) + folded_spacing * spacing_overlap) * size_modifier;
+    
+    center.y += half_size * size_modifier;   // move to center
+    arg.center = nux::Point3 (roundf (center.x + icon_hide_offset), roundf (center.y), roundf (center.z));       // copy center
+    icon->SetCenter (nux::Point3 (roundf (center.x), roundf (center.y + vertical_offset), roundf (center.z)));
+    center.y += (half_size * size_modifier) + spacing;   // move to end
+}
+
+float Launcher::DragLimiter (float x)
+{
+  float result = (1 - std::pow (159.0 / 160,  std::abs (x))) * 160;
+
+  if (x >= 0.0f)
+    return result;
+  return -result;
+}
+
+void Launcher::RenderArgs (std::list<Launcher::RenderArg> &launcher_args,
+                           nux::Geometry &box_geo)
+{
+    nux::Geometry geo = GetGeometry ();
+    LauncherModel::iterator it;
+    nux::Point3 center;
+    struct timespec current;
+    clock_gettime (CLOCK_MONOTONIC, &current);
+
+    float hover_progress = GetHoverProgress (current);
+    float folded_z_distance = _folded_z_distance * (1.0f - hover_progress);
+    float animation_neg_rads = _neg_folded_angle * (1.0f - hover_progress);
+    int vertical_offset = _parent->GetGeometry ().y;
+
+    float folding_constant = 0.25f;
+    float folding_not_constant = folding_constant + ((1.0f - folding_constant) * hover_progress);
+
+    float folded_size = _icon_size * folding_not_constant;
+    float folded_spacing = _space_between_icons * folding_not_constant;
+
+    center.x = geo.width / 2;
+    center.y = _space_between_icons;
+    center.z = 0;
+
+    int launcher_height = geo.height;
+
+    // compute required height of launcher AND folding threshold
+    float sum = 0.0f + center.y;
+    float folding_threshold = launcher_height - _icon_size / 2.5f;
+    for (it = _model->begin (); it != _model->end (); it++)
+    {
+        float height = (_icon_size + _space_between_icons) * IconVisibleProgress (*it, current);
+        sum += height;
+
+        // magic constant must some day be explained, for now suffice to say this constant prevents the bottom from "marching";
+        float magic_constant = 1.2f;
+
+        float present_progress = IconPresentProgress (*it, current);
+        folding_threshold -= CLAMP (sum - launcher_height, 0.0f, height * magic_constant) * (folding_constant + (1.0f - folding_constant) * present_progress);
+    }
+
+    // this happens on hover, basically its a flag and a value in one, we translate this into a dnd offset
+    if (_enter_y != 0 && _enter_y + _icon_size / 2 > folding_threshold)
+        SetDndDelta (center.x, center.y, nux::Geometry (geo.x, geo.y, geo.width, geo.height), current);
+
+    _enter_y = 0;
+
+    if (hover_progress > 0.0f && _launcher_drag_delta != 0)
+    {
+        float delta_y = _launcher_drag_delta;
+
+        // logically dnd exit only restores to the clamped ranges
+        // hover_progress restores to 0
+        float max = 0.0f;
+        float min = MIN (0.0f, launcher_height - sum);
+
+        if (_launcher_drag_delta > max)
+            delta_y = max + DragLimiter (delta_y - max);
+        else if (_launcher_drag_delta < min)
+            delta_y = min + DragLimiter (delta_y - min);
+
+        if (_launcher_action_state != ACTION_DRAG_LAUNCHER)
+        {
+            float dnd_progress = DnDExitProgress (current);
+
+            if (_launcher_drag_delta > max)
+                delta_y = max + (delta_y - max) * dnd_progress;
+            else if (_launcher_drag_delta < min)
+                delta_y = min + (delta_y - min) * dnd_progress;
+
+            if (dnd_progress == 0.0f)
+                _launcher_drag_delta = (int) delta_y;
+        }
+
+        delta_y *= hover_progress;
+        center.y += delta_y;
+        folding_threshold += delta_y;
+    }
+    else
+    {
+        _launcher_drag_delta = 0;
+    }
+
+    float autohide_progress = AutohideProgress (current);
+    float autohide_offset = 0.0f;
+    if (_autohide && autohide_progress > 0.0f)
+    {
+        autohide_offset -= geo.width * autohide_progress;
+    }
+
+    // Inform the painter where to paint the box
+    box_geo = geo;
+
+    if (_autohide)
+        box_geo.x += autohide_offset;
+
+    // The functional position we wish to represent for these icons is not smooth. Rather than introducing
+    // special casing to represent this, we use MIN/MAX functions. This helps ensure that even though our
+    // function is not smooth it is continuous, which is more important for our visual representation (icons
+    // wont start jumping around).  As a general rule ANY if () statements that modify center.y should be seen
+    // as bugs.
+    for (it = _model->main_begin (); it != _model->main_end (); it++)
+    {
+        RenderArg arg;
+        LauncherIcon *icon = *it;
+
+        FillRenderArg (icon, arg, center, folding_threshold, folded_size, folded_spacing, 
+                       autohide_offset, folded_z_distance, animation_neg_rads, vertical_offset, current);
+
+        launcher_args.push_back (arg);
+    }
+
+    // compute maximum height of shelf
+    float shelf_sum = 0.0f;
+    for (it = _model->shelf_begin (); it != _model->shelf_end (); it++)
+    {
+        float height = (_icon_size + _space_between_icons) * IconVisibleProgress (*it, current);
+        shelf_sum += height;
+    }
+
+    // add bottom padding
+    if (shelf_sum > 0.0f)
+      shelf_sum += _space_between_icons;
+
+    float shelf_delta = MAX (((launcher_height - shelf_sum) + _space_between_icons) - center.y, 0.0f);
+    folding_threshold += shelf_delta;
+    center.y += shelf_delta;
+
+    for (it = _model->shelf_begin (); it != _model->shelf_end (); it++)
+    {
+        RenderArg arg;
+        LauncherIcon *icon = *it;
+        
+        FillRenderArg (icon, arg, center, folding_threshold, folded_size, folded_spacing, 
+                       autohide_offset, folded_z_distance, animation_neg_rads, vertical_offset, current);
+        
+        launcher_args.push_back (arg);
+    }
+}
+
+/* End Render Layout Logic */
+
+void Launcher::SetHidden (bool hidden)
+{
+    if (hidden == _hidden)
+        return;
+
+    _hidden = hidden;
+    SetTimeStruct (&_autohide_time, &_autohide_time, ANIM_DURATION_SHORT);
+
+    _parent->EnableInputWindow(!hidden);
+
+    EnsureAnimation ();
+}
+
+gboolean Launcher::OnAutohideTimeout (gpointer data)
+{
+    Launcher *self = (Launcher*) data;
+
+    self->EnsureHiddenState ();
+    self->_autohide_handle = 0;
+    return false;
+}
+
+void
+Launcher::EnsureHiddenState ()
+{
+  if (!_mouse_inside_trigger && 
+      !_mouse_inside_launcher && 
+       _launcher_action_state == ACTION_NONE &&
+      !QuicklistManager::Default ()->Current() &&
+      _window_over_launcher) 
+    SetHidden (true);
+  else
+    SetHidden (false);
+}
+
+void
+Launcher::CheckWindowOverLauncher ()
+{
+  CompWindowList window_list = _screen->windows ();
+  CompWindowList::iterator it;
+  nux::Geometry geo = GetGeometry ();
+
+  for (it = window_list.begin (); it != window_list.end (); it++)
+  {
+    CompWindow *window = *it;
+
+    if (window->type () != CompWindowTypeNormalMask || window->invisible ())
+      continue;
+
+    if (CompRegion (window->inputRect ()).intersects (CompRect (geo.x, geo.y, geo.width, geo.height)))
+    {
+      _window_over_launcher = true;
+      EnsureHiddenState ();
+      return;
+    }
+  }
+
+  _window_over_launcher = false;
+  EnsureHiddenState ();
+}
+
+void
+Launcher::OnWindowMoved (CompWindow *window)
+{
+  if (_autohide)
+    CheckWindowOverLauncher ();
+}
+
+void
+Launcher::OnWindowResized (CompWindow *window)
+{
+  if (_autohide)
+    CheckWindowOverLauncher ();
+}
+
+void
+Launcher::OnWindowAppear (CompWindow *window)
+{
+  if (_autohide)
+    CheckWindowOverLauncher ();
+}
+void
+Launcher::OnWindowDisappear (CompWindow *window)
+{
+  if (_autohide)
+    CheckWindowOverLauncher ();
+}
+
+void Launcher::OnTriggerMouseEnter (int x, int y, unsigned long button_flags, unsigned long key_flags)
+{
+  _mouse_inside_trigger = true;
+  EnsureHiddenState ();
+}
+
+void Launcher::SetupAutohideTimer ()
+{
+  if (_autohide)
+  {
+    if (_autohide_handle > 0)
+      g_source_remove (_autohide_handle);
+    _autohide_handle = g_timeout_add (1000, &Launcher::OnAutohideTimeout, this);
+  }
+}
+
+void Launcher::OnTriggerMouseLeave (int x, int y, unsigned long button_flags, unsigned long key_flags)
+{
+  _mouse_inside_trigger = false;
+  SetupAutohideTimer ();
+}
+
+bool Launcher::AutohideEnabled ()
+{
+    return _autohide;
+}
+
+gboolean Launcher::StrutHack (gpointer data)
+{
+    Launcher *self = (Launcher *) data;
+    self->_parent->InputWindowEnableStruts(false);
+    self->_parent->InputWindowEnableStruts(true);
+
+    return false;
+}
+
+void Launcher::SetAutohide (bool autohide, nux::View *trigger)
+{
+    if (_autohide == autohide)
+        return;
+
+    if (autohide)
+    {
+        _parent->InputWindowEnableStruts(false);
+        _autohide_trigger = trigger;
+        _autohide_trigger->OnMouseEnter.connect (sigc::mem_fun(this, &Launcher::OnTriggerMouseEnter));
+        _autohide_trigger->OnMouseLeave.connect (sigc::mem_fun(this, &Launcher::OnTriggerMouseLeave));
+    }
+    else
+    {
+        _parent->EnableInputWindow(true);
+        g_timeout_add (1000, &Launcher::StrutHack, this);
+        _parent->InputWindowEnableStruts(true);
+    }
+
+    _autohide = autohide;
+    EnsureAnimation ();
+}
+
+void Launcher::SetFloating (bool floating)
+{
+    if (_floating == floating)
+        return;
+
+    _floating = floating;
+    EnsureAnimation ();
+}
+
+void Launcher::SetHover ()
+{
+    if (_hovered)
+        return;
+
+    _enter_y = (int) _mouse_position.y;
+
+    _hovered = true;
+    SetTimeStruct (&_enter_time, &_exit_time, ANIM_DURATION);
+}
+
+void Launcher::UnsetHover ()
+{
+    if (!_hovered)
+        return;
+
+    _hovered = false;
+    SetTimeStruct (&_exit_time, &_enter_time, ANIM_DURATION);
+    SetupAutohideTimer ();
+}
+
+void Launcher::SetIconSize(int tile_size, int icon_size)
+{
+    nux::Geometry geo = _parent->GetGeometry ();
+
+    _icon_size = tile_size;
+    _icon_image_size = icon_size;
+    _icon_image_size_delta = tile_size - icon_size;
+
+    // recreate tile textures
+
+    _parent->SetGeometry (nux::Geometry (geo.x, geo.y, tile_size + 12, geo.height));
+}
+
+void Launcher::OnIconAdded (LauncherIcon *icon)
+{
+    icon->Reference ();
+    EnsureAnimation();
+
+    // How to free these properly?
+    icon->_xform_coords["HitArea"] = new nux::Vector4[4];
+    icon->_xform_coords["Image"]   = new nux::Vector4[4];
+    icon->_xform_coords["Tile"]    = new nux::Vector4[4];
+    icon->_xform_coords["Glow"]    = new nux::Vector4[4];
+
+    // needs to be disconnected
+    icon->needs_redraw.connect (sigc::mem_fun(this, &Launcher::OnIconNeedsRedraw));
+
+    AddChild (icon);
+}
+
+void Launcher::OnIconRemoved (LauncherIcon *icon)
+{
+    icon->UnReference ();
+    EnsureAnimation();
+    RemoveChild (icon);
+}
+
+void Launcher::OnOrderChanged ()
+{
+    EnsureAnimation ();
+}
+
+void Launcher::SetModel (LauncherModel *model)
+{
+    _model = model;
+    _model->icon_added.connect (sigc::mem_fun (this, &Launcher::OnIconAdded));
+    _model->icon_removed.connect (sigc::mem_fun (this, &Launcher::OnIconRemoved));
+    _model->order_changed.connect (sigc::mem_fun (this, &Launcher::OnOrderChanged));
+}
+
+void Launcher::OnIconNeedsRedraw (LauncherIcon *icon)
+{
+    EnsureAnimation();
+}
+
+long Launcher::ProcessEvent(nux::IEvent &ievent, long TraverseInfo, long ProcessEventInfo)
+{
+    long ret = TraverseInfo;
+    ret = PostProcessEvent2(ievent, ret, ProcessEventInfo);
+    return ret;
+}
+
+void Launcher::Draw(nux::GraphicsEngine& GfxContext, bool force_draw)
+{
+
+}
+
+void Launcher::RenderIndicators (nux::GraphicsEngine& GfxContext,
+                                 RenderArg const &arg,
+                                 int running,
+                                 int active,
+                                 nux::Geometry geo)
+{
+  int markerCenter = (int) arg.center.y;
+
+  if (running > 0)
+  {
+    if (!m_RunningIndicator)
+    {
+      GdkPixbuf *pbuf = gdk_pixbuf_new_from_file (PKGDATADIR"/running_indicator.png", NULL);
+      m_RunningIndicator = nux::CreateTextureFromPixbuf (pbuf);
+      g_object_unref (pbuf);
+    }
+    nux::TexCoordXForm texxform;
+
+    nux::Color color = nux::Color::LightGrey;
+
+    if (arg.running_colored)
+      color = nux::Color::SkyBlue;
+
+    std::vector<int> markers;
+    if (running == 1)
+    {
+      markers.push_back (markerCenter);
+    }
+    else if (running == 2)
+    {
+      markers.push_back (markerCenter - 2);
+      markers.push_back (markerCenter + 2);
+    }
+    else
+    {
+      markers.push_back (markerCenter - 4);
+      markers.push_back (markerCenter);
+      markers.push_back (markerCenter + 4);
+    }
+
+    std::vector<int>::iterator it;
+    for (it = markers.begin (); it != markers.end (); it++)
+    {
+      int center = *it;
+      GfxContext.QRP_GLSL_1Tex (geo.x,
+                                center - (m_RunningIndicator->GetHeight () / 2),
+                                (float) m_RunningIndicator->GetWidth(),
+                                (float) m_RunningIndicator->GetHeight(),
+                                m_RunningIndicator->GetDeviceTexture(),
+                                texxform,
+                                color);
+    }
+  }
+
+  if (active > 0)
+  {
+    if (!m_ActiveIndicator)
+    {
+      GdkPixbuf *pbuf = gdk_pixbuf_new_from_file (PKGDATADIR"/focused_indicator.png", NULL);
+      m_ActiveIndicator = nux::CreateTextureFromPixbuf (pbuf);
+      g_object_unref (pbuf);
+    }
+    nux::TexCoordXForm texxform;
+
+    nux::Color color = nux::Color::LightGrey;
+    GfxContext.QRP_GLSL_1Tex ((geo.x + geo.width) - m_ActiveIndicator->GetWidth (),
+                              markerCenter - (m_ActiveIndicator->GetHeight () / 2),
+                              (float) m_ActiveIndicator->GetWidth(),
+                              (float) m_ActiveIndicator->GetHeight(),
+                              m_ActiveIndicator->GetDeviceTexture(),
+                              texxform,
+                              color);
+  }
+}
+
+void Launcher::RenderIcon(nux::GraphicsEngine& GfxContext,
+                          RenderArg const &arg,
+                          nux::BaseTexture *icon,
+                          nux::Color bkg_color,
+                          float alpha,
+                          nux::Vector4 xform_coords[],
+                          nux::Geometry geo)
+{
+  if (icon == NULL || icon->IsNull ())
+    return;
+
+  nux::Matrix4 ObjectMatrix;
+  nux::Matrix4 ViewMatrix;
+  nux::Matrix4 ProjectionMatrix;
+  nux::Matrix4 ViewProjectionMatrix;
+
+  if(nux::Abs (arg.folding_rads) < 0.01f)
+    icon->GetDeviceTexture()->SetFiltering(GL_NEAREST, GL_NEAREST);
+  else
+    icon->GetDeviceTexture()->SetFiltering(GL_LINEAR, GL_LINEAR);
+
+  nux::Vector4 v0;
+  nux::Vector4 v1;
+  nux::Vector4 v2;
+  nux::Vector4 v3;
+
+  v0.x = xform_coords[0].x ;
+  v0.y = xform_coords[0].y ;
+  v0.z = xform_coords[0].z ;
+  v0.w = xform_coords[0].w ;
+  v1.x = xform_coords[1].x ;
+  v1.y = xform_coords[1].y ;
+  v1.z = xform_coords[1].z ;
+  v1.w = xform_coords[1].w ;
+  v2.x = xform_coords[2].x ;
+  v2.y = xform_coords[2].y ;
+  v2.z = xform_coords[2].z ;
+  v2.w = xform_coords[2].w ;
+  v3.x = xform_coords[3].x ;
+  v3.y = xform_coords[3].y ;
+  v3.z = xform_coords[3].z ;
+  v3.w = xform_coords[3].w ;
+
+  float s0, t0, s1, t1, s2, t2, s3, t3;
+  nux::Color color = nux::Color::White;
+
+  if (icon->Type ().IsDerivedFromType(nux::TextureRectangle::StaticObjectType))
+  {
+    s0 = 0.0f;                                  t0 = 0.0f;
+    s1 = 0.0f;                                  t1 = icon->GetHeight();
+    s2 = icon->GetWidth();     t2 = icon->GetHeight();
+    s3 = icon->GetWidth();     t3 = 0.0f;
+  }
+  else
+  {
+    s0 = 0.0f;    t0 = 0.0f;
+    s1 = 0.0f;    t1 = 1.0f;
+    s2 = 1.0f;    t2 = 1.0f;
+    s3 = 1.0f;    t3 = 0.0f;
+  }
+
+  float VtxBuffer[] =
+  {// Perspective correct
+    v0.x, v0.y, 0.0f, 1.0f,     s0/v0.w, t0/v0.w, 0.0f, 1.0f/v0.w,     color.R(), color.G(), color.B(), color.A(),
+    v1.x, v1.y, 0.0f, 1.0f,     s1/v1.w, t1/v1.w, 0.0f, 1.0f/v1.w,     color.R(), color.G(), color.B(), color.A(),
+    v2.x, v2.y, 0.0f, 1.0f,     s2/v2.w, t2/v2.w, 0.0f, 1.0f/v2.w,     color.R(), color.G(), color.B(), color.A(),
+    v3.x, v3.y, 0.0f, 1.0f,     s3/v3.w, t3/v3.w, 0.0f, 1.0f/v3.w,     color.R(), color.G(), color.B(), color.A(),
+  };
+
+  CHECKGL(glBindBufferARB(GL_ARRAY_BUFFER_ARB, 0));
+  CHECKGL(glBindBufferARB(GL_ELEMENT_ARRAY_BUFFER_ARB, 0));
+
+  int TextureObjectLocation;
+  int VertexLocation;
+  int TextureCoord0Location;
+  int VertexColorLocation;
+  int FragmentColor;
+
+  if(!USE_ARB_SHADERS)
+  {
+    _shader_program_uv_persp_correction->Begin();
+
+    TextureObjectLocation   = _shader_program_uv_persp_correction->GetUniformLocationARB("TextureObject0");
+    VertexLocation          = _shader_program_uv_persp_correction->GetAttributeLocation("iVertex");
+    TextureCoord0Location   = _shader_program_uv_persp_correction->GetAttributeLocation("iTexCoord0");
+    VertexColorLocation     = _shader_program_uv_persp_correction->GetAttributeLocation("iColor");
+    FragmentColor           = _shader_program_uv_persp_correction->GetUniformLocationARB ("color");
+
+    nux::GetGraphicsEngine ().SetTexture(GL_TEXTURE0, icon);
+
+    if(TextureObjectLocation != -1)
+      CHECKGL( glUniform1iARB (TextureObjectLocation, 0) );
+
+    int VPMatrixLocation = _shader_program_uv_persp_correction->GetUniformLocationARB("ViewProjectionMatrix");
+    if(VPMatrixLocation != -1)
+    {
+      nux::Matrix4 mat = nux::GetGraphicsEngine ().GetModelViewProjectionMatrix ();
+      _shader_program_uv_persp_correction->SetUniformLocMatrix4fv ((GLint)VPMatrixLocation, 1, false, (GLfloat*)&(mat.m));
+    }
+  }
+  else
+  {
+    _AsmShaderProg->Begin();
+
+    VertexLocation        = nux::VTXATTRIB_POSITION;
+    TextureCoord0Location = nux::VTXATTRIB_TEXCOORD0;
+    VertexColorLocation   = nux::VTXATTRIB_COLOR;
+
+    nux::GetGraphicsEngine().SetTexture(GL_TEXTURE0, icon);
+  }
+
+  CHECKGL( glEnableVertexAttribArrayARB(VertexLocation) );
+  CHECKGL( glVertexAttribPointerARB((GLuint)VertexLocation, 4, GL_FLOAT, GL_FALSE, 48, VtxBuffer) );
+
+  if(TextureCoord0Location != -1)
+  {
+    CHECKGL( glEnableVertexAttribArrayARB(TextureCoord0Location) );
+    CHECKGL( glVertexAttribPointerARB((GLuint)TextureCoord0Location, 4, GL_FLOAT, GL_FALSE, 48, VtxBuffer + 4) );
+  }
+
+  if(VertexColorLocation != -1)
+  {
+    CHECKGL( glEnableVertexAttribArrayARB(VertexColorLocation) );
+    CHECKGL( glVertexAttribPointerARB((GLuint)VertexColorLocation, 4, GL_FLOAT, GL_FALSE, 48, VtxBuffer + 8) );
+  }
+
+  bkg_color.SetAlpha (bkg_color.A () * alpha);
+
+  if(!USE_ARB_SHADERS)
+  {
+    CHECKGL ( glUniform4fARB (FragmentColor, bkg_color.R(), bkg_color.G(), bkg_color.B(), bkg_color.A() ) );
+    nux::GetGraphicsEngine ().SetTexture(GL_TEXTURE0, icon);
+    CHECKGL( glDrawArrays(GL_QUADS, 0, 4) );
+  }
+  else
+  {
+    CHECKGL ( glProgramLocalParameter4fARB (GL_FRAGMENT_PROGRAM_ARB, 0, bkg_color.R(), bkg_color.G(), bkg_color.B(), bkg_color.A() ) );
+    nux::GetGraphicsEngine ().SetTexture(GL_TEXTURE0, icon);
+    CHECKGL( glDrawArrays(GL_QUADS, 0, 4) );
+  }
+
+  if(VertexLocation != -1)
+    CHECKGL( glDisableVertexAttribArrayARB(VertexLocation) );
+  if(TextureCoord0Location != -1)
+    CHECKGL( glDisableVertexAttribArrayARB(TextureCoord0Location) );
+  if(VertexColorLocation != -1)
+    CHECKGL( glDisableVertexAttribArrayARB(VertexColorLocation) );
+
+  if(!USE_ARB_SHADERS)
+  {
+    _shader_program_uv_persp_correction->End();
+  }
+  else
+  {
+    _AsmShaderProg->End();
+  }
+}
+
+void Launcher::DrawRenderArg (nux::GraphicsEngine& GfxContext, RenderArg const &arg, nux::Geometry geo)
+{
+  GfxContext.GetRenderStates ().SetSeparateBlend (true,
+                                                GL_SRC_ALPHA,
+                                                GL_ONE_MINUS_SRC_ALPHA,
+                                                GL_ONE_MINUS_DST_ALPHA,
+                                                GL_ONE);
+
+  GfxContext.GetRenderStates ().SetColorMask (true, true, true, true);
+
+  if (arg.backlight_intensity < 1.0f)
+  {
+    RenderIcon(GfxContext,
+               arg,
+               _icon_outline_texture,
+               nux::Color(0xAAFFFFFF),
+               1.0f - arg.backlight_intensity,
+               arg.icon->_xform_coords["Tile"],
+               geo);
+  }
+
+  if (arg.backlight_intensity > 0.0f)
+  {
+    RenderIcon(GfxContext,
+               arg,
+               _icon_bkg_texture,
+               arg.icon->BackgroundColor (),
+               arg.backlight_intensity,
+               arg.icon->_xform_coords["Tile"],
+               geo);
+  }
+
+  GfxContext.GetRenderStates ().SetSeparateBlend (true,
+                                                GL_SRC_ALPHA,
+                                                GL_ONE_MINUS_SRC_ALPHA,
+                                                GL_ONE_MINUS_DST_ALPHA,
+                                                GL_ONE);
+  GfxContext.GetRenderStates ().SetColorMask (true, true, true, true);
+
+  RenderIcon (GfxContext,
+              arg,
+              arg.icon->TextureForSize (_icon_image_size),
+              nux::Color::White,
+              arg.alpha,
+              arg.icon->_xform_coords["Image"],
+              geo);
+
+  if (arg.backlight_intensity > 0.0f)
+  {
+    RenderIcon(GfxContext,
+               arg,
+               _icon_shine_texture,
+               nux::Color::White,
+               arg.backlight_intensity,
+               arg.icon->_xform_coords["Tile"],
+               geo);
+  }
+
+  if (false)
+  {
+    switch (arg.window_indicators)
+    {
+      case 2:
+        RenderIcon(GfxContext,
+                   arg,
+                   _icon_2indicator,
+                   nux::Color::White,
+                   1.0f,
+                   arg.icon->_xform_coords["Tile"],
+                   geo);
+        break;
+      case 3:
+        RenderIcon(GfxContext,
+                    arg,
+                    _icon_3indicator,
+                    nux::Color::White,
+                    1.0f,
+                    arg.icon->_xform_coords["Tile"],
+                    geo);
+        break;
+      case 4:
+        RenderIcon(GfxContext,
+                   arg,
+                   _icon_4indicator,
+                   nux::Color::White,
+                   1.0f,
+                   arg.icon->_xform_coords["Tile"],
+                   geo);
+        break;
+    }
+  }
+
+  if (arg.glow_intensity > 0.0f)
+  {
+    RenderIcon(GfxContext,
+               arg,
+               _icon_glow_texture,
+               arg.icon->GlowColor (),
+               arg.glow_intensity,
+               arg.icon->_xform_coords["Glow"],
+               geo);
+  }
+
+  if (arg.shimmer_progress > 0.0f && arg.shimmer_progress < 1.0f)
+  {
+    nux::Geometry base = GetGeometry ();
+    int x1 = base.x + base.width;
+    int x2 = base.x + base.width;
+    float shimmer_constant = 1.9f;
+
+    x1 -= geo.width * arg.shimmer_progress * shimmer_constant;
+    GfxContext.PushClippingRectangle(nux::Geometry (x1, geo.y, x2 - x1, geo.height));
+
+    float fade_out = 1.0f - CLAMP (((x2 - x1) - geo.width) / (geo.width * (shimmer_constant - 1.0f)), 0.0f, 1.0f);
+
+    RenderIcon(GfxContext,
+               arg,
+               _icon_glow_texture,
+               arg.icon->GlowColor (),
+               fade_out,
+               arg.icon->_xform_coords["Glow"],
+               geo);
+
+    GfxContext.PopClippingRectangle();
+  }
+
+  RenderIndicators (GfxContext,
+                    arg,
+                    arg.running_arrow ? arg.window_indicators : 0,
+                    arg.active_arrow ? 1 : 0,
+                    geo);
+}
+
+void Launcher::DrawContent(nux::GraphicsEngine& GfxContext, bool force_draw)
+{
+    nux::Geometry base = GetGeometry();
+    GfxContext.PushClippingRectangle(base);
+    nux::Geometry bkg_box;
+    std::list<Launcher::RenderArg> args;
+    std::list<Launcher::RenderArg>::reverse_iterator rev_it;
+    std::list<Launcher::RenderArg>::iterator it;
+
+    nux::ROPConfig ROP;
+    ROP.Blend = false;
+    ROP.SrcBlend = GL_SRC_ALPHA;
+    ROP.DstBlend = GL_ONE_MINUS_SRC_ALPHA;
+
+    RenderArgs (args, bkg_box);
+
+    // clear region
+    gPainter.PushDrawColorLayer(GfxContext, base, nux::Color(0x00000000), true, ROP);
+
+    // clip vertically but not horizontally
+    GfxContext.PushClippingRectangle(nux::Geometry (base.x, bkg_box.y, base.width, bkg_box.height));
+    GfxContext.GetRenderStates ().SetSeparateBlend (true,
+                                                    GL_SRC_ALPHA,
+                                                    GL_ONE_MINUS_SRC_ALPHA,
+                                                    GL_ONE_MINUS_DST_ALPHA,
+                                                    GL_ONE);
+
+    gPainter.Paint2DQuadColor (GfxContext, bkg_box, nux::Color(0xAA000000));
+
+    UpdateIconXForm (args);
+    EventLogic ();
+
+    /* draw launcher */
+    for (rev_it = args.rbegin (); rev_it != args.rend (); rev_it++)
+    {
+      if ((*rev_it).folding_rads >= 0.0f || (*rev_it).skip)
+        continue;
+
+      DrawRenderArg (GfxContext, *rev_it, bkg_box);
+    }
+
+    for (it = args.begin(); it != args.end(); it++)
+    {
+      if ((*it).folding_rads < 0.0f || (*it).skip)
+        continue;
+
+      DrawRenderArg (GfxContext, *it, bkg_box);
+    }
+
+
+    gPainter.Paint2DQuadColor (GfxContext, nux::Geometry (bkg_box.x + bkg_box.width - 1, bkg_box.y, 1, bkg_box.height), nux::Color(0x60FFFFFF));
+
+    GfxContext.GetRenderStates().SetColorMask (true, true, true, true);
+    GfxContext.GetRenderStates ().SetSeparateBlend (false,
+                                                    GL_SRC_ALPHA,
+                                                    GL_ONE_MINUS_SRC_ALPHA,
+                                                    GL_SRC_ALPHA,
+                                                    GL_ONE_MINUS_SRC_ALPHA);
+
+    gPainter.PopBackground();
+    GfxContext.PopClippingRectangle();
+    GfxContext.PopClippingRectangle();
+}
+
+void Launcher::PostDraw(nux::GraphicsEngine& GfxContext, bool force_draw)
+{
+}
+
+void Launcher::PreLayoutManagement()
+{
+    View::PreLayoutManagement();
+    if(m_CompositionLayout)
+    {
+        m_CompositionLayout->SetGeometry(GetGeometry());
+    }
+}
+
+long Launcher::PostLayoutManagement(long LayoutResult)
+{
+  View::PostLayoutManagement(LayoutResult);
+
+  _mouse_position = nux::Point2 (0, 0);
+
+  return nux::eCompliantHeight | nux::eCompliantWidth;
+}
+
+void Launcher::PositionChildLayout(float offsetX, float offsetY)
+{
+}
+
+bool Launcher::TooltipNotify(LauncherIcon* Icon)
+{
+    if(GetActiveMenuIcon())
+        return false;
+    return true;
+}
+
+bool Launcher::MenuNotify(LauncherIcon* Icon)
+{
+
+
+    return true;
+}
+
+void Launcher::NotifyMenuTermination(LauncherIcon* Icon)
+{
+}
+
+void Launcher::StartIconDrag (LauncherIcon *icon)
+{
+  if (!icon)
+    return;
+    
+  _drag_icon = icon;
+
+  if (_drag_window)
+  {
+    _drag_window->ShowWindow (false);
+    _drag_window->UnReference ();
+    _drag_window = NULL;
+  }
+
+  _drag_window = new LauncherDragWindow (icon, _icon_size);
+  _drag_window->SinkReference ();
+  
+  _drag_window->ShowWindow (true);
+
+  nux::GetWindowCompositor ().SetAlwaysOnFrontWindow (_drag_window);
+}
+
+void Launcher::EndIconDrag ()
+{
+  if (_drag_window)
+  {
+    _drag_window->ShowWindow (false);
+    _drag_window->UnReference ();
+    _drag_window = NULL;
+  }
+  
+  _drag_icon_under_mouse = NULL;
+  _drag_icon = NULL;
+}
+
+void Launcher::UpdateDragWindowPosition (int x, int y)
+{
+  if (_drag_window)
+  {
+    nux::Geometry geo = _drag_window->GetGeometry ();
+    _drag_window->SetBaseXY (x - geo.width / 2 + _parent->GetGeometry ().x, y - geo.height / 2 + _parent->GetGeometry ().y);
+    
+    LauncherIcon *hovered_icon = MouseIconIntersection ((int) (GetGeometry ().x / 2.0f), y);
+    
+    if (_drag_icon && hovered_icon && _drag_icon != hovered_icon)
+    {
+      request_reorder.emit (_drag_icon, hovered_icon);
+    }
+  }
+}
+
+void Launcher::RecvMouseDown(int x, int y, unsigned long button_flags, unsigned long key_flags)
+{
+  _mouse_position = nux::Point2 (x, y);
+
+  MouseDownLogic (x, y, button_flags, key_flags);
+  EnsureAnimation ();
+}
+
+void Launcher::RecvMouseUp(int x, int y, unsigned long button_flags, unsigned long key_flags)
+{
+  _mouse_position = nux::Point2 (x, y);
+  nux::Geometry geo = GetGeometry ();
+
+  if (_launcher_action_state != ACTION_NONE && !geo.IsInside(nux::Point(x, y)))
+  {
+    // we are no longer hovered
+    UnsetHover ();
+  }
+  
+  MouseUpLogic (x, y, button_flags, key_flags);
+
+  if (_launcher_action_state == ACTION_DRAG_ICON)
+    EndIconDrag ();
+
+  _launcher_action_state = ACTION_NONE;
+  _dnd_delta_x = 0;
+  _dnd_delta_y = 0;
+  EnsureAnimation ();
+}
+
+void Launcher::RecvMouseDrag(int x, int y, int dx, int dy, unsigned long button_flags, unsigned long key_flags)
+{
+  _mouse_position = nux::Point2 (x, y);
+
+  _dnd_delta_y += dy;
+  _dnd_delta_x += dx;
+  
+  if (nux::Abs (_dnd_delta_y) < 15 &&
+      nux::Abs (_dnd_delta_x) < 15 && 
+      _launcher_action_state == ACTION_NONE)
+      return;
+
+  if (_icon_under_mouse)
+  {
+    _icon_under_mouse->MouseLeave.emit ();
+    _icon_under_mouse->_mouse_inside = false;
+    _icon_under_mouse = 0;
+  }
+
+  if (_launcher_action_state == ACTION_NONE)
+  {
+    SetTimeStruct (&_drag_start_time);
+    
+    if (nux::Abs (_dnd_delta_y) >= nux::Abs (_dnd_delta_x))
+    {
+      _launcher_drag_delta += _dnd_delta_y;
+      _launcher_action_state = ACTION_DRAG_LAUNCHER;
+    }
+    else
+    {
+      LauncherIcon *drag_icon = MouseIconIntersection ((int) (GetGeometry ().x / 2.0f), y);
+      
+      if (drag_icon)
+      {
+        StartIconDrag (drag_icon);
+        _launcher_action_state = ACTION_DRAG_ICON;
+        UpdateDragWindowPosition (x, y);
+      }
+
+    }
+  }
+  else if (_launcher_action_state == ACTION_DRAG_LAUNCHER)
+  {
+    _launcher_drag_delta += dy;
+  }
+  else if (_launcher_action_state == ACTION_DRAG_ICON)
+  {
+    UpdateDragWindowPosition (x, y);
+  }
+  
+  EnsureAnimation ();
+}
+
+void Launcher::RecvMouseEnter(int x, int y, unsigned long button_flags, unsigned long key_flags)
+{
+  _mouse_position = nux::Point2 (x, y);
+  _mouse_inside_launcher = true;
+
+  SetHover ();
+
+  EventLogic ();
+  EnsureAnimation ();
+}
+
+void Launcher::RecvMouseLeave(int x, int y, unsigned long button_flags, unsigned long key_flags)
+{
+  _mouse_position = nux::Point2 (x, y);
+  _mouse_inside_launcher = false;
+
+  if (_launcher_action_state == ACTION_NONE)
+      UnsetHover ();
+
+  EventLogic ();
+  EnsureAnimation ();
+}
+
+void Launcher::RecvMouseMove(int x, int y, int dx, int dy, unsigned long button_flags, unsigned long key_flags)
+{
+  _mouse_position = nux::Point2 (x, y);
+
+  // Every time the mouse moves, we check if it is inside an icon...
+  EventLogic ();
+}
+
+void Launcher::RecvMouseWheel(int x, int y, int wheel_delta, unsigned long button_flags, unsigned long key_flags)
+{
+}
+
+void Launcher::RecvQuicklistOpened (QuicklistView *quicklist)
+{
+  EventLogic ();
+  EnsureAnimation ();
+}
+
+void Launcher::RecvQuicklistClosed (QuicklistView *quicklist)
+{
+  SetupAutohideTimer ();
+
+  EventLogic ();
+  EnsureAnimation ();
+}
+
+void Launcher::EventLogic ()
+{
+  if (_launcher_action_state != ACTION_NONE)
+    return;
+
+  LauncherIcon* launcher_icon = 0;
+
+  if (_mouse_inside_launcher)
+    launcher_icon = MouseIconIntersection (_mouse_position.x, _mouse_position.y);
+
+  if (_icon_under_mouse && (_icon_under_mouse != launcher_icon))
+  {
+    _icon_under_mouse->MouseLeave.emit ();
+    _icon_under_mouse->_mouse_inside = false;
+    _icon_under_mouse = 0;
+  }
+
+  if (launcher_icon && (_icon_under_mouse != launcher_icon))
+  {
+    launcher_icon->MouseEnter.emit ();
+    launcher_icon->_mouse_inside = true;
+    _icon_under_mouse = launcher_icon;
+  }
+}
+
+void Launcher::MouseDownLogic (int x, int y, unsigned long button_flags, unsigned long key_flags)
+{
+  LauncherIcon* launcher_icon = 0;
+  launcher_icon = MouseIconIntersection (_mouse_position.x, _mouse_position.y);
+
+  if (launcher_icon)
+  {
+    _icon_mouse_down = launcher_icon;
+    launcher_icon->MouseDown.emit (nux::GetEventButton (button_flags));
+  }
+}
+
+void Launcher::MouseUpLogic (int x, int y, unsigned long button_flags, unsigned long key_flags)
+{
+  LauncherIcon* launcher_icon = 0;
+  launcher_icon = MouseIconIntersection (_mouse_position.x, _mouse_position.y);
+
+  if (_icon_mouse_down && (_icon_mouse_down == launcher_icon))
+  {
+    _icon_mouse_down->MouseUp.emit (nux::GetEventButton (button_flags));
+
+    if (_launcher_action_state == ACTION_NONE)
+      _icon_mouse_down->MouseClick.emit (nux::GetEventButton (button_flags));
+  }
+
+  if (launcher_icon && (_icon_mouse_down != launcher_icon))
+  {
+    launcher_icon->MouseUp.emit (nux::GetEventButton (button_flags));
+  }
+
+  if (_launcher_action_state == ACTION_DRAG_LAUNCHER)
+  {
+    SetTimeStruct (&_drag_end_time);
+  }
+
+  _icon_mouse_down = 0;
+}
+
+LauncherIcon* Launcher::MouseIconIntersection (int x, int y)
+{
+  LauncherModel::iterator it;
+  LauncherModel::reverse_iterator rev_it;
+  // We are looking for the icon at screen coordinates x, y;
+  nux::Point2 mouse_position(x, y);
+  int inside = 0;
+
+  // Because of the way icons fold and stack on one another, we must proceed in 2 steps.
+  for (rev_it = _model->rbegin (); rev_it != _model->rend (); rev_it++)
+  {
+    if ((*rev_it)->_folding_angle < 0.0f || !(*rev_it)->GetQuirk (LAUNCHER_ICON_QUIRK_VISIBLE))
+      continue;
+
+    nux::Point2 screen_coord [4];
+    for (int i = 0; i < 4; i++)
+    {
+      screen_coord [i].x = (*rev_it)->_xform_coords["HitArea"] [i].x;
+      screen_coord [i].y = (*rev_it)->_xform_coords["HitArea"] [i].y;
+    }
+    inside = PointInside2DPolygon (screen_coord, 4, mouse_position, 1);
+    if (inside)
+      return (*rev_it);
+  }
+
+  for (it = _model->begin(); it != _model->end (); it++)
+  {
+    if ((*it)->_folding_angle >= 0.0f || !(*it)->GetQuirk (LAUNCHER_ICON_QUIRK_VISIBLE))
+      continue;
+
+    nux::Point2 screen_coord [4];
+    for (int i = 0; i < 4; i++)
+    {
+      screen_coord [i].x = (*it)->_xform_coords["HitArea"] [i].x;
+      screen_coord [i].y = (*it)->_xform_coords["HitArea"] [i].y;
+    }
+    inside = PointInside2DPolygon (screen_coord, 4, mouse_position, 1);
+    if (inside)
+      return (*it);
+  }
+
+  return 0;
+}
+
+void Launcher::SetIconXForm (LauncherIcon *icon, nux::Matrix4 ViewProjectionMatrix, nux::Geometry geo,
+                             float x, float y, float w, float h, float z, std::string name)
+{
+  nux::Vector4 v0 = nux::Vector4(x,   y,    z, 1.0f);
+  nux::Vector4 v1 = nux::Vector4(x,   y+h,  z, 1.0f);
+  nux::Vector4 v2 = nux::Vector4(x+w, y+h,  z, 1.0f);
+  nux::Vector4 v3 = nux::Vector4(x+w, y,    z, 1.0f);
+
+  v0 = ViewProjectionMatrix * v0;
+  v1 = ViewProjectionMatrix * v1;
+  v2 = ViewProjectionMatrix * v2;
+  v3 = ViewProjectionMatrix * v3;
+
+  v0.divide_xyz_by_w();
+  v1.divide_xyz_by_w();
+  v2.divide_xyz_by_w();
+  v3.divide_xyz_by_w();
+
+  // normalize to the viewport coordinates and translate to the correct location
+  v0.x =  geo.width *(v0.x + 1.0f)/2.0f - geo.width/2.0f + x + w/2.0f;
+  v0.y = -geo.height*(v0.y - 1.0f)/2.0f - geo.height/2.0f + y + h/2.0f;
+  v1.x =  geo.width *(v1.x + 1.0f)/2.0f - geo.width/2.0f + x + w/2.0f;;
+  v1.y = -geo.height*(v1.y - 1.0f)/2.0f - geo.height/2.0f + y + h/2.0f;
+  v2.x =  geo.width *(v2.x + 1.0f)/2.0f - geo.width/2.0f + x + w/2.0f;
+  v2.y = -geo.height*(v2.y - 1.0f)/2.0f - geo.height/2.0f + y + h/2.0f;
+  v3.x =  geo.width *(v3.x + 1.0f)/2.0f - geo.width/2.0f + x + w/2.0f;
+  v3.y = -geo.height*(v3.y - 1.0f)/2.0f - geo.height/2.0f + y + h/2.0f;
+
+
+  nux::Vector4* vectors = icon->_xform_coords[name];
+
+  vectors[0].x = v0.x;
+  vectors[0].y = v0.y;
+  vectors[0].z = v0.z;
+  vectors[0].w = v0.w;
+  vectors[1].x = v1.x;
+  vectors[1].y = v1.y;
+  vectors[1].z = v1.z;
+  vectors[1].w = v1.w;
+  vectors[2].x = v2.x;
+  vectors[2].y = v2.y;
+  vectors[2].z = v2.z;
+  vectors[2].w = v2.w;
+  vectors[3].x = v3.x;
+  vectors[3].y = v3.y;
+  vectors[3].z = v3.z;
+  vectors[3].w = v3.w;
+}
+
+void Launcher::UpdateIconXForm (std::list<Launcher::RenderArg> &args)
+{
+  nux::Geometry geo = GetGeometry ();
+  nux::Matrix4 ObjectMatrix;
+  nux::Matrix4 ViewMatrix;
+  nux::Matrix4 ProjectionMatrix;
+  nux::Matrix4 ViewProjectionMatrix;
+
+  GetInverseScreenPerspectiveMatrix(ViewMatrix, ProjectionMatrix, geo.width, geo.height, 0.1f, 1000.0f, DEGTORAD(90));
+
+  //LauncherModel::iterator it;
+  std::list<Launcher::RenderArg>::iterator it;
+  for(it = args.begin(); it != args.end(); it++)
+  {
+
+    LauncherIcon* launcher_icon = (*it).icon;
+
+    // We to store the icon angle in the icons itself. Makes one thing easier afterward.
+    launcher_icon->_folding_angle = (*it).folding_rads;
+
+    float w = _icon_size;
+    float h = _icon_size;
+    float x = (*it).center.x - w/2.0f; // x: top left corner
+    float y = (*it).center.y - h/2.0f; // y: top left corner
+    float z = (*it).center.z;
+
+    if ((*it).skip)
+    {
+      w = 1;
+      h = 1;
+      x = -100;
+      y = -100;
+    }
+    
+    ObjectMatrix = nux::Matrix4::TRANSLATE(geo.width/2.0f, geo.height/2.0f, z) * // Translate the icon to the center of the viewport
+      nux::Matrix4::ROTATEX((*it).folding_rads) *              // rotate the icon
+      nux::Matrix4::TRANSLATE(-x - w/2.0f, -y - h/2.0f, -z);    // Put the center the icon to (0, 0)
+
+    ViewProjectionMatrix = ProjectionMatrix*ViewMatrix*ObjectMatrix;
+
+    SetIconXForm (launcher_icon, ViewProjectionMatrix, geo, x, y, w, h, z, "Tile");
+
+    w = _icon_image_size;
+    h = _icon_image_size;
+    x = (*it).center.x - _icon_size/2.0f + _icon_image_size_delta/2.0f;
+    y = (*it).center.y - _icon_size/2.0f + _icon_image_size_delta/2.0f;
+    z = (*it).center.z;
+
+    SetIconXForm (launcher_icon, ViewProjectionMatrix, geo, x, y, w, h, z, "Image");
+
+    w = _icon_glow_size;
+    h = _icon_glow_size;
+    x = (*it).center.x - _icon_glow_size/2.0f;
+    y = (*it).center.y - _icon_glow_size/2.0f;
+    z = (*it).center.z;
+
+    SetIconXForm (launcher_icon, ViewProjectionMatrix, geo, x, y, w, h, z, "Glow");
+
+    w = geo.width + 2;
+    h = _icon_size + _space_between_icons;
+    x = (*it).center.x - w/2.0f;
+    y = (*it).center.y - h/2.0f;
+    z = (*it).center.z;
+
+    SetIconXForm (launcher_icon, ViewProjectionMatrix, geo, x, y, w, h, z, "HitArea");
+  }
+}
+
+void GetInverseScreenPerspectiveMatrix(nux::Matrix4& ViewMatrix, nux::Matrix4& PerspectiveMatrix,
+                                       int ViewportWidth,
+                                       int ViewportHeight,
+                                       float NearClipPlane,
+                                       float FarClipPlane,
+                                       float Fovy)
+{
+/*
+  Objective:
+  Given a perspective matrix defined by (Fovy, AspectRatio, NearPlane, FarPlane), we want to compute
+  the ModelView matrix that transform a quad defined by its top-left coord (0, 0) and its
+  bottom-right coord (WindowWidth, WindowHeight) into a full screen quad that covers the entire viewport (one to one).
+  Any quad that is facing the camera and whose 4 points are on the 4 guiding line of the view frustum (pyramid)
+  will always cover the entire viewport one to one (when projected on the screen).
+  So all we have to do is to define a quad with x:[-x_cs, x_cs] and y:[-y_cs, y_cs] and find the z distance in eye space (z_cs) so that
+  the quad touches the 4 guiding lines of the view frustum.
+  We consider a well centered projection view (no skewing, no oblique clipping plane, ...) and derive the following equations:
+     x_cs = AspectRatio*y_cs
+     y_cs/z_cs = tanf(Fovy/2) ==> z_cs = y_cs*1/tanf(Fovy/2) (this is the absolute value the quad depth value will be -z_cs since we are using OpenGL right hand coord system).
+
+  The quad (in camera space) facing the camera and centered around the camera view axis is defined by the points (-x_cs, y_cs) (top-left)
+  and the point (x_cs, -y_cs) (bottom-right). If we move that quad along the camera view axis and place it at a distance z_cs of the camera,
+  then its 4 corners are each on the 4 lines of the view frustum.
+
+    (-x_cs, y_cs)          Camera Space
+                 ^
+       __________|__________
+      |          |          |
+      |          |          |
+      |          |(0, 0)    |
+      |----------|----------|->
+      |          |          |
+      |          |          |
+      |__________|__________|
+                         (x_cs, -y_cs)
+
+  The full-screen quad (in screen space) is defined by the point (0, 0) (top-left) and (WindowWidth, WindowHeight) (bottom-right).
+  We can choose and arbitrary value y_cs and compute the z_cs position in camera space that will produce a quad in camera space that projects into
+  the full-screen space.
+
+    (0, 0)            Screen Space
+       _____________________->
+      |          |          |
+      |          |          |