Merge lp:~rcryderman/awn/multi-panel-intellihide into lp:awn/0.4

[moonbeam]

Not perfect but I'd like to get this into trunk so it gets some testing.

[Michal Hruby (mhr3)]

Few comments:
Please get rid of 304, and also the other occurrences of priv->source.
96: Will cause lots of criticals because panel has properties which PanelConnector doesn't.
664: Make sure you remove the notification on panel removed signal.

review: Needs Fixing

[lp:~rcryderman/awn/multi-panel-intellihide]

769. By moonbeam on 2010-10-25

* applets/taskmanager/task-manager-panel-connector.c:
* applets/taskmanager/task-manager.c:
 Fixes. removed source, removed a notify

770. By moonbeam on 2010-10-25

* applets/taskmanager/task-manager-panel-connector.c:
 Suppress debug's due to panel connector not recognizing all the
 exported properties of panel.

[moonbeam (rcryderman)]

> Few comments:
> Please get rid of 304, and also the other occurrences of priv->source.
> 96: Will cause lots of criticals because panel has properties which
> PanelConnector doesn't.
> 664: Make sure you remove the notification on panel removed signal.

Done.

[Michal Hruby (mhr3)]

review: Approve

Unmerged revisions

=== modified file 'applets/taskmanager/Makefile.am'
--- applets/taskmanager/Makefile.am	2010-09-09 23:55:56 +0000
+++ applets/taskmanager/Makefile.am	2010-10-25 13:06:06 +0000
@@ -67,6 +67,8 @@
 	task-manager-api-wrapper.c \
 	task-manager-api-wrapper.h \
 	task-manager-api-wrapper-glue.h \
+	task-manager-panel-connector.c \
+	task-manager-panel-connector.h \
 	task-settings.c \
 	task-settings.h \
 	task-window.c \

=== modified file 'applets/taskmanager/awn-applet-taskmanager.schema-ini.in'
--- applets/taskmanager/awn-applet-taskmanager.schema-ini.in	2010-10-22 18:33:54 +0000
+++ applets/taskmanager/awn-applet-taskmanager.schema-ini.in	2010-10-25 13:06:06 +0000
@@ -63,16 +63,6 @@
 default = false
 _description= Allow grouping of windows together that have different WM_CLIENT_NAME values.
 
-[DEFAULT/intellihide]
-type = boolean
-default = true
-_description=Intellihide if hide is enabled for the panel.  This will inhibit autohide of the panel if there are no intersecting windows in the relevant window list (see intellihide_mode).
-
-[DEFAULT/intellihide_mode]
-type = integer
-default = 1
-_description=How to generate the list of windows tested for intersection when Intellihide is active.  0.. use windows on active workspace, 1.. use windows of currently focused app.
-
 [DEFAULT/launcher_paths]
 type = list-string
 default = /usr/share/applications/firefox.desktop;

=== added file 'applets/taskmanager/task-manager-panel-connector.c'
--- applets/taskmanager/task-manager-panel-connector.c	1970-01-01 00:00:00 +0000
+++ applets/taskmanager/task-manager-panel-connector.c	2010-10-25 13:06:06 +0000
@@ -0,0 +1,358 @@
+/* task-manager-panel-connector.c */
+
+#include <dbus/dbus-glib.h>
+#include <dbus/dbus-glib-bindings.h>
+#include <unistd.h>
+#include <stdlib.h>
+#include <string.h>
+#include <glib/gstdio.h>
+#include <glib/gi18n.h>
+#include <X11/Xlib.h>
+#include <math.h>
+
+#include "libawn/awn-defines.h"
+#include "libawn/libawn-marshal.h"
+
+#include "task-manager-panel-connector.h"
+
+#ifdef HAVE_CONFIG_H
+#include <config.h>
+#endif
+
+
+G_DEFINE_TYPE (TaskManagerPanelConnector, task_manager_panel_connector, G_TYPE_OBJECT)
+
+#define GET_PRIVATE(o) \
+  (G_TYPE_INSTANCE_GET_PRIVATE ((o), TASK_MANAGER_TYPE_PANEL_CONNECTOR, TaskManagerPanelConnectorPrivate))
+
+typedef struct _TaskManagerPanelConnectorPrivate TaskManagerPanelConnectorPrivate;
+
+struct _TaskManagerPanelConnectorPrivate 
+{
+  gint panel_id;
+  gint64 panel_xid;
+  
+  DBusGConnection *connection;
+  DBusGProxy      *proxy;
+};
+
+
+enum
+{
+  PROP_0,
+  PROP_PANEL_ID,
+  PROP_PANEL_XID,
+};
+
+
+
+static void
+on_prop_changed (DBusGProxy *proxy, const gchar *prop_name,
+                 GValue *value, TaskManagerPanelConnector * conn)
+{
+  TaskManagerPanelConnectorPrivate * priv;
+  g_return_if_fail (TASK_MANAGER_IS_PANEL_CONNECTOR (conn));
+  priv = GET_PRIVATE(conn);
+
+  g_object_set_property (G_OBJECT (conn), prop_name, value);
+}
+
+
+static void
+task_manager_panel_connector_get_property (GObject *object, guint property_id,
+                              GValue *value, GParamSpec *pspec)
+{
+  TaskManagerPanelConnectorPrivate * priv = GET_PRIVATE(object);
+  switch (property_id)
+  {
+    case PROP_PANEL_ID:
+      g_value_set_int (value, priv->panel_id);
+      break;
+
+    case PROP_PANEL_XID:
+      g_value_set_int64 (value, priv->panel_xid);
+      break;
+    default:
+      G_OBJECT_WARN_INVALID_PROPERTY_ID (object, property_id, pspec);      
+  }
+}
+
+static void
+task_manager_panel_connector_set_property (GObject *object, guint property_id,
+                              const GValue *value, GParamSpec *pspec)
+{
+  TaskManagerPanelConnectorPrivate * priv = GET_PRIVATE(object);  
+  switch (property_id)
+  {
+    case PROP_PANEL_ID:
+      priv->panel_id = g_value_get_int (value);
+      break;
+#ifdef DEBUG
+     /*Debug'd out.  Remove this if TaskManagerPanelConnector ever becomes a generic object that
+       supports all the props in panel*/
+    default:
+      G_OBJECT_WARN_INVALID_PROPERTY_ID (object, property_id, pspec);
+#endif
+  }
+}
+
+static void
+task_manager_panel_connector_dispose (GObject *object)
+{
+  G_OBJECT_CLASS (task_manager_panel_connector_parent_class)->dispose (object);
+}
+
+static void
+task_manager_panel_connector_finalize (GObject *object)
+{
+  TaskManagerPanelConnectorPrivate * priv = GET_PRIVATE(object);
+  if (priv->connection)
+  {
+    if (priv->proxy) 
+    {
+      g_object_unref (priv->proxy);
+    }
+    dbus_g_connection_unref (priv->connection);
+    priv->connection = NULL;
+    priv->proxy = NULL;
+  }
+  
+  G_OBJECT_CLASS (task_manager_panel_connector_parent_class)->finalize (object);
+}
+
+static void
+task_manager_panel_connector_init (TaskManagerPanelConnector *self)
+{
+  TaskManagerPanelConnectorPrivate * priv = GET_PRIVATE(self);
+  GError         *error = NULL;
+  
+  priv->connection = dbus_g_bus_get(DBUS_BUS_SESSION, &error);
+  priv->proxy = NULL;
+  priv->panel_xid = 0;
+  
+  if (error)
+  {
+    g_warning ("%s", error->message);
+    g_error_free(error);
+  }
+}
+
+static gboolean
+task_manager_panel_connector_do_connect_dbus (GObject * conn)
+{
+  TaskManagerPanelConnectorPrivate * priv = GET_PRIVATE(conn);
+
+  gchar *object_path = g_strdup_printf ("/org/awnproject/Awn/Panel%d",
+                                        priv->panel_id);
+  if (!priv->proxy)
+  {
+    priv->proxy = dbus_g_proxy_new_for_name (priv->connection,
+                                           "org.awnproject.Awn",
+                                           object_path,
+                                           "org.awnproject.Awn.Panel");
+  }
+  if (!priv->proxy)
+  {
+    g_warning("Could not connect to mothership! Bailing\n");
+    return TRUE;
+  }
+
+  dbus_g_object_register_marshaller (
+    libawn_marshal_VOID__STRING_BOXED,
+    G_TYPE_NONE, G_TYPE_STRING, G_TYPE_VALUE,
+    G_TYPE_INVALID
+  );
+
+  dbus_g_proxy_add_signal (priv->proxy, "PropertyChanged",
+                           G_TYPE_STRING, G_TYPE_VALUE, G_TYPE_INVALID);
+  dbus_g_proxy_connect_signal (priv->proxy, "PropertyChanged",
+                               G_CALLBACK (on_prop_changed), conn,
+                               NULL);
+  // get prop values from Panel
+  DBusGProxy *prop_proxy = dbus_g_proxy_new_from_proxy (
+    priv->proxy, "org.freedesktop.DBus.Properties", NULL
+  );
+
+  if (!prop_proxy)
+  {
+    g_warning("Could not get property values! Bailing\n");
+  }
+
+  GError *error = NULL;
+
+#if HAVE_DBUS_GLIB_080
+  GHashTable *all_props = NULL;
+
+  // doing GetAll reduces DBus lag significantly
+  dbus_g_proxy_call (prop_proxy, "GetAll", &error,
+                     G_TYPE_STRING, "org.awnproject.Awn.Panel",
+                     G_TYPE_INVALID,
+                     dbus_g_type_get_map ("GHashTable", G_TYPE_STRING, 
+                                          G_TYPE_VALUE), &all_props,
+                     G_TYPE_INVALID);
+
+  if (error) goto crap_out;
+
+  GHashTableIter iter;
+  gpointer key, value;
+
+  g_hash_table_iter_init (&iter, all_props);
+  while (g_hash_table_iter_next (&iter, &key, &value))
+  {
+    if (strcmp (key, "PanelXid") == 0)
+    {
+      priv->panel_xid = g_value_get_int64 (value);
+    }
+  }
+
+#else
+  GValue panel_xid = {0,};
+  
+  dbus_g_proxy_call (prop_proxy, "Get", &error,
+                     G_TYPE_STRING, "org.awnproject.Awn.Panel",
+                     G_TYPE_STRING, "PanelXid",
+                     G_TYPE_INVALID,
+                     G_TYPE_VALUE, &panel_xid,
+                     G_TYPE_INVALID);
+
+  if (error) goto crap_out;
+
+  if (G_VALUE_HOLDS_INT64 (&panel_xid))
+  {
+    priv->panel_xid = g_value_get_int64 (&panel_xid);
+  }
+
+  g_value_unset (&panel_xid);
+#endif
+  if (prop_proxy) g_object_unref (prop_proxy);
+
+  g_free (object_path);
+  return FALSE;
+
+  crap_out:
+
+  g_warning ("%s", error->message);
+  g_error_free (error);
+  g_free (object_path);
+  if (prop_proxy) 
+  {
+    g_object_unref (prop_proxy);
+  }
+  return TRUE;
+}
+
+static void
+task_manager_panel_connector_constructed (GObject *obj)
+{
+  TaskManagerPanelConnector *conn = TASK_MANAGER_PANEL_CONNECTOR(obj);
+  TaskManagerPanelConnectorPrivate *priv = GET_PRIVATE(conn);
+
+  if (priv->panel_id > 0)
+  {
+    task_manager_panel_connector_do_connect_dbus (obj);
+  }
+}
+
+static void
+task_manager_panel_connector_class_init (TaskManagerPanelConnectorClass *klass)
+{
+  GObjectClass *object_class = G_OBJECT_CLASS (klass);
+
+  object_class->get_property = task_manager_panel_connector_get_property;
+  object_class->set_property = task_manager_panel_connector_set_property;
+  object_class->dispose = task_manager_panel_connector_dispose;
+  object_class->finalize = task_manager_panel_connector_finalize;
+  object_class->constructed = task_manager_panel_connector_constructed;
+
+  g_object_class_install_property (object_class,
+    PROP_PANEL_ID,
+    g_param_spec_int ("panel-id",
+                      "Panel ID",
+                      "The id of AwnPanel this connector connects to",
+                      0, G_MAXINT, 0,
+                      G_PARAM_CONSTRUCT_ONLY | G_PARAM_READWRITE |
+                      G_PARAM_STATIC_STRINGS));
+
+  g_object_class_install_property ( object_class,
+    PROP_PANEL_XID,
+    g_param_spec_int64 ("panel-xid",
+                        "Panel XID",
+                        "The XID of AwnPanel this connector is connected to",
+                        G_MININT64, G_MAXINT64, 0,
+                        G_PARAM_READABLE | G_PARAM_STATIC_STRINGS));
+
+  g_type_class_add_private (klass, sizeof (TaskManagerPanelConnectorPrivate));
+}
+
+TaskManagerPanelConnector*
+task_manager_panel_connector_new (gint id)
+{
+  return g_object_new (TASK_MANAGER_TYPE_PANEL_CONNECTOR, 
+                       "panel_id",id,
+                       NULL);
+}
+
+guint
+task_manager_panel_connector_inhibit_autohide (TaskManagerPanelConnector *conn, const gchar *reason)
+{
+  TaskManagerPanelConnectorPrivate *priv;
+  GError *error = NULL;
+  guint ret = 0;
+  
+  g_return_val_if_fail (TASK_MANAGER_IS_PANEL_CONNECTOR (conn), 0);
+  priv = GET_PRIVATE(conn);
+
+  if (!priv->proxy)
+  {
+    return 0;
+  }
+
+  gchar *app_name = g_strdup_printf ("%s:%d", g_get_prgname(), getpid());
+
+  dbus_g_proxy_call (priv->proxy, "InhibitAutohide",
+                     &error,
+                     G_TYPE_STRING, app_name,
+                     G_TYPE_STRING, reason,
+                     G_TYPE_INVALID, 
+                     G_TYPE_UINT, &ret,
+                     G_TYPE_INVALID);
+
+  if (app_name) g_free (app_name);
+
+  if (error)
+  {
+    g_warning ("%s", error->message);
+    g_error_free (error);
+  }
+
+  return ret;
+}
+
+void
+task_manager_panel_connector_uninhibit_autohide (TaskManagerPanelConnector *conn, guint cookie)
+{
+  TaskManagerPanelConnectorPrivate *priv;
+  GError *error = NULL;
+  
+  g_return_if_fail (TASK_MANAGER_IS_PANEL_CONNECTOR (conn));
+  priv = GET_PRIVATE(conn);
+
+  if (!priv->proxy)
+  {
+    return;
+  }
+
+  dbus_g_proxy_call (priv->proxy, "UninhibitAutohide",
+                     &error,
+                     G_TYPE_UINT, cookie,
+                     G_TYPE_INVALID,
+                     G_TYPE_INVALID);
+
+  if (error)
+  {
+    g_warning ("%s", error->message);
+    g_error_free (error);
+  }
+}
+
+

=== added file 'applets/taskmanager/task-manager-panel-connector.h'
--- applets/taskmanager/task-manager-panel-connector.h	1970-01-01 00:00:00 +0000
+++ applets/taskmanager/task-manager-panel-connector.h	2010-10-25 13:06:06 +0000
@@ -0,0 +1,44 @@
+/* task-manager-panel-connector.h */
+
+#ifndef _TASK_MANAGER_PANEL_CONNECTOR
+#define _TASK_MANAGER_PANEL_CONNECTOR
+
+#include <glib-object.h>
+
+G_BEGIN_DECLS
+
+#define TASK_MANAGER_TYPE_PANEL_CONNECTOR task_manager_panel_connector_get_type()
+
+#define TASK_MANAGER_PANEL_CONNECTOR(obj) \
+  (G_TYPE_CHECK_INSTANCE_CAST ((obj), TASK_MANAGER_TYPE_PANEL_CONNECTOR, TaskManagerPanelConnector))
+
+#define TASK_MANAGER_PANEL_CONNECTOR_CLASS(klass) \
+  (G_TYPE_CHECK_CLASS_CAST ((klass), TASK_MANAGER_TYPE_PANEL_CONNECTOR, TaskManagerPanelConnectorClass))
+
+#define TASK_MANAGER_IS_PANEL_CONNECTOR(obj) \
+  (G_TYPE_CHECK_INSTANCE_TYPE ((obj), TASK_MANAGER_TYPE_PANEL_CONNECTOR))
+
+#define TASK_MANAGER_IS_PANEL_CONNECTOR_CLASS(klass) \
+  (G_TYPE_CHECK_CLASS_TYPE ((klass), TASK_MANAGER_TYPE_PANEL_CONNECTOR))
+
+#define TASK_MANAGER_PANEL_CONNECTOR_GET_CLASS(obj) \
+  (G_TYPE_INSTANCE_GET_CLASS ((obj), TASK_MANAGER_TYPE_PANEL_CONNECTOR, TaskManagerPanelConnectorClass))
+
+typedef struct {
+  GObject parent;
+} TaskManagerPanelConnector;
+
+typedef struct {
+  GObjectClass parent_class;
+} TaskManagerPanelConnectorClass;
+
+GType task_manager_panel_connector_get_type (void);
+
+guint task_manager_panel_connector_inhibit_autohide (TaskManagerPanelConnector *conn, const gchar *reason);
+void task_manager_panel_connector_uninhibit_autohide (TaskManagerPanelConnector *conn, guint cookie);
+
+TaskManagerPanelConnector* task_manager_panel_connector_new (gint id);
+
+G_END_DECLS
+
+#endif /* _TASK_MANAGER_PANEL_CONNECTOR */

=== modified file 'applets/taskmanager/task-manager.c'
--- applets/taskmanager/task-manager.c	2010-07-19 22:28:12 +0000
+++ applets/taskmanager/task-manager.c	2010-10-25 13:06:06 +0000
@@ -47,6 +47,8 @@
 #include "libawn/awn-pixbuf-cache.h"
 #include "awn-desktop-lookup-cached.h"
 #include "task-manager.h"
+#include "task-manager-panel-connector.h"
+
 #include "dock-manager-api.h"
 
 #include "task-drag-indicator.h"
@@ -69,20 +71,26 @@
 
 static GQuark win_quark = 0;
 
+typedef struct
+{
+  DesktopAgnosticConfigClient *panel_instance_client;
+  GdkWindow * foreign_window;
+  GdkRegion * foreign_region;
+  TaskManagerPanelConnector * connector;
+  gint        intellihide_mode;
+  guint       autohide_cookie;
+} TaskManagerAwnPanelInfo;
+
 struct _TaskManagerPrivate
 {
   DesktopAgnosticConfigClient *client;
+
+  DBusGConnection *connection;
+  DBusGProxy      *proxy;
+  
   TaskSettings    *settings;
   WnckScreen      *screen;
 
-  /*Used by Intellihide*/
-  guint           autohide_cookie;
-  GdkWindow       *awn_gdk_window;
-  GdkRegion       * awn_gdk_region;
-  
-  guint           attention_cookie;
-  guint           attention_source;
-  
   /* Dragging properties */
   TaskIcon          *dragged_icon;
   TaskDragIndicator *drag_indicator;
@@ -97,19 +105,23 @@
   
   GHashTable *win_table;
   GHashTable *desktops_table;
+  GHashTable *intellihide_panel_instances;
+
   /*
    Used during grouping configuration changes for optimization purposes
    */
   GList *grouping_list;
   /* Properties */
   GValueArray *launcher_paths;
+
+  guint        attention_cookie;
+  guint        attention_source;
+
   gboolean     show_all_windows;
   gboolean     only_show_launchers;
   gboolean     drag_and_drop;
   gboolean     grouping;
-  gboolean     intellihide;
   gboolean     icon_grouping;
-  gint         intellihide_mode;
   gint         match_strength;
   gint         attention_autohide_timer;
   
@@ -128,6 +140,7 @@
 
 enum
 {
+  INTELLIHIDE_NONE,
   INTELLIHIDE_WORKSPACE,
   INTELLIHIDE_APP,
   INTELLIHIDE_GROUP  
@@ -144,11 +157,8 @@
   PROP_GROUPING,
   PROP_ICON_GROUPING,
   PROP_MATCH_STRENGTH,
-  PROP_INTELLIHIDE,
-  PROP_INTELLIHIDE_MODE,
   PROP_ATTENTION_AUTOHIDE_TIMER,
-  PROP_ATTENTION_REQUIRED_REMINDER,
-  PROP_ATTENTION_REQUIED_REMINDER_ID
+  PROP_ATTENTION_REQUIRED_REMINDER
 };
 
 
@@ -205,6 +215,10 @@
 static void task_manager_active_workspace_changed_cb (WnckScreen    *screen,
                                                       WnckWorkspace *previous_space,
                                                       TaskManager * manager);
+static void task_manager_check_for_intersection (TaskManager * manager,
+                                                  WnckWorkspace * space,
+                                                  WnckApplication * app);
+
 static void task_manager_win_geom_changed_cb (WnckWindow *window, 
                                               TaskManager * manager);
 static void task_manager_win_closed_cb (WnckScreen *screen,
@@ -219,6 +233,11 @@
 
 static gboolean _attention_required_reminder_cb (TaskManager * manager);
 
+static void task_manager_intellihide_change_cb (const char* group, 
+                                    const char* key, 
+                                    GValue* value, 
+                                    int * user_data);
+
 typedef enum 
 {
   TASK_MANAGER_ERROR_UNSUPPORTED_WINDOW_TYPE,
@@ -282,14 +301,6 @@
       g_value_set_boolean (value, manager->priv->icon_grouping);
       break;
 
-    case PROP_INTELLIHIDE:
-      g_value_set_boolean (value, manager->priv->intellihide);
-      break;
-
-    case PROP_INTELLIHIDE_MODE:
-      g_value_set_int (value, manager->priv->intellihide_mode);
-      break;
-
     case PROP_MATCH_STRENGTH:
       g_value_set_int (value, manager->priv->match_strength);
       break;
@@ -315,6 +326,8 @@
 {
   TaskManager *manager = TASK_MANAGER (object);
 
+  g_return_if_fail (TASK_IS_MANAGER (object));
+
   switch (prop_id)
   {
     case PROP_SHOW_ALL_WORKSPACES:
@@ -351,25 +364,7 @@
     case PROP_ICON_GROUPING:
       manager->priv->icon_grouping = g_value_get_boolean (value);
       break;
-      
-    case PROP_INTELLIHIDE:
-      /* TODO move into a function */
-      manager->priv->intellihide = g_value_get_boolean (value);
-      if (!manager->priv->intellihide && manager->priv->autohide_cookie)
-      {     
-        awn_applet_uninhibit_autohide (AWN_APPLET(manager), manager->priv->autohide_cookie);
-        manager->priv->autohide_cookie = 0;
-      }
-      if (manager->priv->intellihide && !manager->priv->autohide_cookie)
-      {     
-        manager->priv->autohide_cookie = awn_applet_inhibit_autohide (AWN_APPLET(manager),"Intellihide" );
-      }      
-      break;
-
-    case PROP_INTELLIHIDE_MODE:
-      manager->priv->intellihide_mode = g_value_get_int (value);
-      break;
-      
+            
     case PROP_ATTENTION_AUTOHIDE_TIMER:
       manager->priv->attention_autohide_timer = g_value_get_int (value);
       break;
@@ -395,16 +390,108 @@
 }
 
 static void
+_delete_panel_info_cb (TaskManagerAwnPanelInfo * panel_info)
+{
+  g_object_unref (panel_info->connector);
+  g_free (panel_info);
+}
+
+static void
+_on_panel_added (DBusGProxy *proxy,guint panel_id,TaskManager *applet)
+{
+  TaskManagerPrivate *priv = TASK_MANAGER_GET_PRIVATE (applet);
+  GError * error = NULL;
+  TaskManagerAwnPanelInfo * panel_info = NULL;
+  gchar * uid = g_strdup_printf("-999%d",panel_id);
+  
+  g_assert (!g_hash_table_lookup (priv->intellihide_panel_instances,GINT_TO_POINTER (panel_id)));
+  panel_info = g_malloc0 (sizeof (TaskManagerAwnPanelInfo) );
+  panel_info->connector = task_manager_panel_connector_new (panel_id);
+  g_free (uid);
+  panel_info->panel_instance_client = awn_config_get_default (panel_id, NULL);
+  panel_info->intellihide_mode = desktop_agnostic_config_client_get_int (
+                                             panel_info->panel_instance_client, 
+                                             "panel", 
+                                             "intellihide_mode", 
+                                              &error);
+  if (error)
+  {
+    g_debug ("%s: error accessing intellihide_mode. \"%s\"",__func__,error->message);
+    g_error_free (error);
+    error = NULL;
+  }
+  desktop_agnostic_config_client_notify_add (panel_info->panel_instance_client, 
+                                             "panel", 
+                                             "intellihide_mode", 
+                                             (DesktopAgnosticConfigNotifyFunc)task_manager_intellihide_change_cb, 
+                                             &panel_info->intellihide_mode, 
+                                             &error);
+  if (error)
+  {
+    g_debug ("%s: error binding intellihide_mode. \"%s\"",__func__,error->message);
+    g_error_free (error);
+    error = NULL;
+  }
+
+  if (!panel_info->intellihide_mode && panel_info->autohide_cookie)
+  {     
+    task_manager_panel_connector_uninhibit_autohide (panel_info->connector, panel_info->autohide_cookie);
+    panel_info->autohide_cookie = 0;
+  }
+  if (panel_info->intellihide_mode && !panel_info->autohide_cookie)
+  {     
+    panel_info->autohide_cookie = task_manager_panel_connector_inhibit_autohide (panel_info->connector,"Intellihide" );
+  }   
+
+  g_hash_table_insert (priv->intellihide_panel_instances,GINT_TO_POINTER(panel_id),panel_info);                                                                           
+}
+
+static void
+_on_panel_removed (DBusGProxy *proxy,guint panel_id,TaskManager * applet)
+{
+  TaskManagerPrivate *priv = TASK_MANAGER_GET_PRIVATE (applet);
+  TaskManagerAwnPanelInfo * panel_info = g_hash_table_lookup (priv->intellihide_panel_instances,GINT_TO_POINTER (panel_id));
+
+  desktop_agnostic_config_client_remove_instance (panel_info->panel_instance_client);
+  g_assert (g_hash_table_remove (priv->intellihide_panel_instances,GINT_TO_POINTER (panel_id)));
+}
+
+static void
 task_manager_constructed (GObject *object)
 {
   TaskManagerPrivate *priv;
   GtkWidget          *widget;
+  GError             *error=NULL;
+  GStrv              panel_paths;
   
   G_OBJECT_CLASS (task_manager_parent_class)->constructed (object);
   
   priv = TASK_MANAGER_GET_PRIVATE (object);
   widget = GTK_WIDGET (object);
 
+  priv->proxy = dbus_g_proxy_new_for_name (priv->connection,
+                                           "org.awnproject.Awn",
+                                            "/org/awnproject/Awn",
+                                           "org.awnproject.Awn.App");
+  if (!priv->proxy)
+  {
+    g_warning("%s: Could not connect to mothership!\n",__func__);
+  }
+  else
+  {
+    dbus_g_proxy_add_signal (priv->proxy, "PanelAdded",
+                             G_TYPE_INT, G_TYPE_INVALID);
+    dbus_g_proxy_add_signal (priv->proxy, "PanelRemoved",
+                             G_TYPE_INT, G_TYPE_INVALID);
+    dbus_g_proxy_connect_signal (priv->proxy, "PanelAdded",
+                                 G_CALLBACK (_on_panel_added), object, 
+                                 NULL);
+    dbus_g_proxy_connect_signal (priv->proxy, "PanelRemoved",
+                                 G_CALLBACK (_on_panel_removed), object, 
+                                 NULL);
+
+  }    
+  
   /*
    Set the cache size of our AwnPixbufCache to something a bit bigger.
 
@@ -415,9 +502,12 @@
                NULL);
 
   priv->desktops_table = g_hash_table_new_full (g_str_hash,g_str_equal,g_free,g_free);
+  priv->intellihide_panel_instances = g_hash_table_new_full (g_direct_hash,g_direct_equal,
+                                                             NULL,
+                                                             (GDestroyNotify)_delete_panel_info_cb);                                    
 
   priv->client = awn_config_get_default_for_applet (AWN_APPLET (object), NULL);
-
+  
   /* Connect up the important bits */
   desktop_agnostic_config_client_bind (priv->client,
                                        DESKTOP_AGNOSTIC_CONFIG_GROUP_DEFAULT,
@@ -454,21 +544,9 @@
                                        "icon_grouping",
                                        object, "icon_grouping", TRUE,
                                        DESKTOP_AGNOSTIC_CONFIG_BIND_METHOD_FALLBACK,
-                                       NULL);
-  desktop_agnostic_config_client_bind (priv->client,
-                                       DESKTOP_AGNOSTIC_CONFIG_GROUP_DEFAULT,
-                                       "intellihide",
-                                       object, "intellihide", TRUE,
-                                       DESKTOP_AGNOSTIC_CONFIG_BIND_METHOD_FALLBACK,
                                        NULL);  
   desktop_agnostic_config_client_bind (priv->client,
                                        DESKTOP_AGNOSTIC_CONFIG_GROUP_DEFAULT,
-                                       "intellihide_mode",
-                                       object, "intellihide_mode", TRUE,
-                                       DESKTOP_AGNOSTIC_CONFIG_BIND_METHOD_FALLBACK,
-                                       NULL);    
-  desktop_agnostic_config_client_bind (priv->client,
-                                       DESKTOP_AGNOSTIC_CONFIG_GROUP_DEFAULT,
                                        "match_strength",
                                        object, "match_strength", TRUE,
                                        DESKTOP_AGNOSTIC_CONFIG_BIND_METHOD_FALLBACK,
@@ -495,6 +573,32 @@
 
   /* DBus interface */
   priv->dbus_proxy = task_manager_dispatcher_new (TASK_MANAGER (object));
+
+  if (priv->proxy)
+  {
+    dbus_g_proxy_call (priv->proxy, "GetPanels",
+                     &error,
+                     G_TYPE_INVALID, 
+                     G_TYPE_STRV, &panel_paths,
+                     G_TYPE_INVALID);
+    if (error)
+    {
+      g_debug ("%s: %s",__func__,error->message);
+      g_error_free (error);
+      error = NULL;
+    }
+    else
+    {
+      for (gint i=0; panel_paths[i];i++)
+      {
+        //strlen is like this as a reminder.
+        _on_panel_added (priv->proxy,
+                         atoi(panel_paths[i] + strlen("/org/awnproject/Awn/Panel")),
+                         TASK_MANAGER(object));
+        
+      }
+    }    
+  }  
 }
 
 static void
@@ -555,22 +659,6 @@
                                 G_PARAM_CONSTRUCT | G_PARAM_READWRITE);
   g_object_class_install_property (obj_class, PROP_ICON_GROUPING, pspec);
 
-  pspec = g_param_spec_boolean ("intellihide",
-                                "intellihide",
-                                "Intellihide",
-                                TRUE,
-                                G_PARAM_READWRITE);
-  g_object_class_install_property (obj_class, PROP_INTELLIHIDE, pspec);
-
-  pspec = g_param_spec_int ("intellihide_mode",
-                                "intellihide mode",
-                                "Intellihide mode",
-                                0,
-                                2,
-                                1,
-                                G_PARAM_CONSTRUCT | G_PARAM_READWRITE);
-  g_object_class_install_property (obj_class, PROP_INTELLIHIDE_MODE, pspec);
-
   pspec = g_param_spec_int ("match_strength",
                             "match_strength",
                             "How radical matching is applied for grouping items",
@@ -619,9 +707,10 @@
 task_manager_init (TaskManager *manager)
 {
   TaskManagerPrivate *priv;
-  	
+  GError         *error = NULL;	
+
   priv = manager->priv = TASK_MANAGER_GET_PRIVATE (manager);
-
+  
   priv->screen = wnck_screen_get_default ();
   priv->launcher_paths = NULL;
   priv->hidden_list = NULL;
@@ -647,6 +736,14 @@
   priv->dragged_icon = NULL;
   priv->drag_timeout = 0;
 
+  priv->connection = dbus_g_bus_get(DBUS_BUS_SESSION, &error);
+  priv->proxy = NULL;  
+  if (error)
+  {
+    g_warning ("%s", error->message);
+    g_error_free(error);
+  }
+
   /* connect to the relevent WnckScreen signals */
   g_signal_connect (priv->screen, "window-opened", 
                     G_CALLBACK (on_window_opened), manager);
@@ -755,16 +852,25 @@
   desktop_agnostic_config_client_unbind_all_for_object (priv->client,
                                                         object,
                                                         NULL);
+  if (priv->connection)
+  {
+    if (priv->proxy) g_object_unref (priv->proxy);
+    dbus_g_connection_unref (priv->connection);
+    priv->connection = NULL;
+    priv->proxy = NULL;
+  }
+  
+  /*
   if (priv->autohide_cookie)
   {     
     awn_applet_uninhibit_autohide (AWN_APPLET(object), priv->autohide_cookie);
     priv->autohide_cookie = 0;
-  }
-  if (priv->awn_gdk_window)
+  }*/
+/*  if (priv->awn_gdk_window)
   {
     g_object_unref (priv->awn_gdk_window);
     priv->awn_gdk_window = NULL;
-  }
+  }*/
 
   G_OBJECT_CLASS (task_manager_parent_class)->dispose (object);
 }
@@ -1734,14 +1840,22 @@
   g_value_array_free (launcher_paths);
 }
 
+static void
+task_manager_intellihide_change_cb (const char* group, 
+                                    const char* key, 
+                                    GValue* value, 
+                                    int * user_data)
+{
+  *user_data = g_value_get_int (value);
+}
+
 /*
  * Checks when launchers got added/removed in the list in gconf/file.
  * It removes the launchers from the task-icons and add those
  * that aren't already on the bar.
  */
 static void
-task_manager_refresh_launcher_paths (TaskManager *manager,
-                                     GValueArray *list)
+task_manager_refresh_launcher_paths (TaskManager *manager, GValueArray *list)
 {
   TaskManagerPrivate *priv;
 
@@ -2434,14 +2548,9 @@
   return region;
 }
 
-/* 
- Governs the panel autohide when Intellihide is enabled.
- If a window in the relevant window list intersects with the awn panel then
- autohide will be uninhibited otherwise it will be inhibited.
- */
-
 static void
-task_manager_check_for_intersection (TaskManager * manager,
+task_manager_check_for_panel_instance_intersection (TaskManager * manager,
+                                     TaskManagerAwnPanelInfo * panel_info,
                                      WnckWorkspace * space,
                                      WnckApplication * app)
 {
@@ -2451,35 +2560,24 @@
   gboolean  intersect = FALSE;
   GdkRectangle awn_rect;
   gint depth;
-  gint64 xid; 
   GdkRegion * updated_region;
-  
   g_return_if_fail (TASK_IS_MANAGER (manager));
   priv = manager->priv;
 
-  /*
-   Generate a GdkRegion for the awn panel_size
-   */
-  if (!priv->awn_gdk_window)
-  {
-    g_object_get (manager, "panel-xid", &xid, NULL);    
-    priv->awn_gdk_window = gdk_window_foreign_new ( xid);
-  }
-  g_return_if_fail (priv->awn_gdk_window);
-  gdk_window_get_geometry (priv->awn_gdk_window,&awn_rect.x,
+  gdk_window_get_geometry (panel_info->foreign_window,&awn_rect.x,
                            &awn_rect.y,&awn_rect.width,
                            &awn_rect.height,&depth);  
   /*
    gdk_window_get_geometry gives us an x,y or 0,0
    Fix that using get root origin.
    */
-  gdk_window_get_root_origin (priv->awn_gdk_window,&awn_rect.x,&awn_rect.y);
+  gdk_window_get_root_origin (panel_info->foreign_window,&awn_rect.x,&awn_rect.y);
   /*
    We cache the region for reuse for situations where the input mask is an empty
    region when the panel is hidden.  In that case we reuse the last good 
    region.
    */
-  updated_region = xutils_get_input_shape (priv->awn_gdk_window);
+  updated_region = xutils_get_input_shape (panel_info->foreign_window);
   g_return_if_fail (updated_region);
   if (gdk_region_empty(updated_region))
   {
@@ -2487,18 +2585,18 @@
   }
   else
   {
-    if (priv->awn_gdk_region)
+    if (panel_info->foreign_region)
     {
-      gdk_region_destroy (priv->awn_gdk_region);
+      gdk_region_destroy (panel_info->foreign_region);
     }
-    priv->awn_gdk_region = updated_region; 
-    gdk_region_offset (priv->awn_gdk_region,awn_rect.x,awn_rect.y);    
+    panel_info->foreign_region = updated_region; 
+    gdk_region_offset (panel_info->foreign_region,awn_rect.x,awn_rect.y);    
   }
   
   /*
    Get the list of windows to check for intersection
    */
-  switch (priv->intellihide_mode)
+  switch (panel_info->intellihide_mode)
   {
     case INTELLIHIDE_WORKSPACE:
       windows = wnck_screen_get_windows (priv->screen);
@@ -2506,7 +2604,14 @@
     case INTELLIHIDE_GROUP:  /*TODO... Implement this for now same as app*/
     case INTELLIHIDE_APP:
     default:
-      windows = wnck_application_get_windows (app);
+      if (app)
+      {
+        windows = wnck_application_get_windows (app);
+      }
+      else
+      {
+        windows = wnck_screen_get_windows (priv->screen);
+      }
       break;
   }
   
@@ -2543,7 +2648,7 @@
                               &win_rect.y,&win_rect.width,
                               &win_rect.height);
 
-    if (gdk_region_rect_in (priv->awn_gdk_region, &win_rect) != 
+    if (gdk_region_rect_in (panel_info->foreign_region, &win_rect) != 
           GDK_OVERLAP_RECTANGLE_OUT)
     {
 #ifdef DEBUG
@@ -2558,28 +2663,94 @@
   /*
    Allow panel to hide (if necessary)
    */
-  if (intersect && priv->autohide_cookie)
+  if (intersect && panel_info->autohide_cookie)
   {     
-    awn_applet_uninhibit_autohide (AWN_APPLET(manager), priv->autohide_cookie);
+    task_manager_panel_connector_uninhibit_autohide (panel_info->connector, panel_info->autohide_cookie);
 #ifdef DEBUG
-    g_debug ("me eat cookie: %u",priv->autohide_cookie);
+    g_debug ("me eat cookie: %u",panel_info->autohide_cookie);
 #endif
-    priv->autohide_cookie = 0;
+    panel_info->autohide_cookie = 0;
   }
   
   /*
    Inhibit Hide if not already doing so
    */
-  if (!intersect && !priv->autohide_cookie)
+  if (!intersect && !panel_info->autohide_cookie)
   {
-    priv->autohide_cookie = awn_applet_inhibit_autohide (AWN_APPLET(manager), "Intellihide");
+    gchar * identifier = g_strdup_printf ("Intellihide:applet_conector=%p",panel_info->connector);
+    panel_info->autohide_cookie = task_manager_panel_connector_inhibit_autohide (panel_info->connector, identifier);
+    g_free (identifier);
 #ifdef DEBUG    
-    g_debug ("cookie is %u",priv->autohide_cookie);
+    g_debug ("cookie is %u",panel_info->autohide_cookie);
 #endif
   }
 
 }
 
+static gboolean
+_waiting_for_panel_dbus (TaskManager * manager)
+{
+  TaskManagerPrivate  *priv;
+  
+  g_return_val_if_fail (TASK_IS_MANAGER (manager),FALSE);
+  priv = manager->priv;
+  
+  task_manager_check_for_intersection (manager,
+                                       wnck_screen_get_active_workspace (priv->screen),
+                                       wnck_application_get (wnck_window_get_xid(wnck_screen_get_active_window (priv->screen))));
+  return FALSE;
+}
+/* 
+ Governs the panel autohide when Intellihide is enabled.
+ If a window in the relevant window list intersects with the awn panel then
+ autohide will be uninhibited otherwise it will be inhibited.
+ */
+
+static void
+task_manager_check_for_intersection (TaskManager * manager,
+                                     WnckWorkspace * space,
+                                     WnckApplication * app)
+{
+  TaskManagerPrivate  *priv;
+  gint64 xid;
+  GHashTableIter iter;
+  gpointer key,value;
+  
+  g_return_if_fail (TASK_IS_MANAGER (manager));
+  priv = manager->priv;
+
+  g_hash_table_iter_init (&iter, priv->intellihide_panel_instances);
+  while (g_hash_table_iter_next (&iter, &key, &value) )
+  {
+    TaskManagerAwnPanelInfo * panel_info = value;
+    g_object_get (panel_info->connector, "panel-xid", &xid, NULL);
+    if (!xid)
+    {
+      g_timeout_add (1000,(GSourceFunc)_waiting_for_panel_dbus,manager);
+    }
+    else
+    {
+      if (!panel_info->foreign_window)
+      {
+        panel_info->foreign_window = gdk_window_foreign_new ( xid);
+      }
+      if (panel_info->intellihide_mode)
+      {
+        task_manager_check_for_panel_instance_intersection(manager,
+                                                         panel_info,
+                                                         space,
+                                                         app);
+      }
+      else if ( !panel_info->intellihide_mode && panel_info->autohide_cookie)
+      {
+        task_manager_panel_connector_uninhibit_autohide (panel_info->connector, panel_info->autohide_cookie);
+        panel_info->autohide_cookie = 0;
+      }
+    }                                                           
+  }
+  return;
+}
+
 /*
   Active window has changed.  If intellhide is active we need to check for 
  window instersections
@@ -2596,12 +2767,6 @@
 
   g_return_if_fail (TASK_IS_MANAGER (manager));
   priv = manager->priv;
-
-  if (!priv->intellihide)
-  {
-/*    g_warning ("%s: Intellihide callback invoked with Intellihide off",__func__);*/
-    return;
-  }
   
   win = wnck_screen_get_active_window (screen);
   if (!win)
@@ -2612,13 +2777,17 @@
      we had intersection and the panel was hidden, it will continue hide.
      So inhibit the autohide if there is no active window.
      */
+    task_manager_check_for_intersection (manager,
+                                         wnck_screen_get_active_workspace(screen),
+                                         NULL);
+/*
     if (!priv->autohide_cookie)
     {
       priv->autohide_cookie = awn_applet_inhibit_autohide (AWN_APPLET(manager), "Intellihide");
 #ifdef DEBUG    
       g_debug ("%s: cookie is %u",__func__,priv->autohide_cookie);
 #endif
-    }
+    }*/
     return;
   }
   app = wnck_window_get_application (win);
@@ -2641,21 +2810,13 @@
 
   g_return_if_fail (TASK_IS_MANAGER (manager));
   priv = manager->priv;
-  if (!priv->intellihide)
-  {
-/*    g_warning ("%s: Intellihide callback invoked with Intellihide off",__func__);    */
-    return;
-  }
+
   win = wnck_screen_get_active_window (screen);
   if (!win)
   {
-    if (!priv->autohide_cookie)
-    {
-      priv->autohide_cookie = awn_applet_inhibit_autohide (AWN_APPLET(manager), "Intellihide");
-#ifdef DEBUG    
-      g_debug ("%s: cookie is %u",__func__,priv->autohide_cookie);
-#endif
-    }    
+    task_manager_check_for_intersection (manager,
+                                         wnck_screen_get_active_workspace(screen),
+                                         NULL);
     return;
   }
   
@@ -2671,13 +2832,9 @@
   WnckWindow          *win;
   WnckApplication     *app;
   WnckWorkspace       *space;
+  
   g_return_if_fail (TASK_IS_MANAGER (manager));
   priv = manager->priv;
-  if (!priv->intellihide)
-  {
-/*    g_warning ("%s: Intellihide callback invoked with Intellihide off",__func__);*/
-    return;
-  }
   win = wnck_screen_get_active_window (priv->screen);
   if (!win)
   {
@@ -2703,11 +2860,6 @@
   WnckWorkspace       *space;
   g_return_if_fail (TASK_IS_MANAGER (manager));
   priv = manager->priv;
-  if (!priv->intellihide)
-  {
-/*    g_warning ("%s: Intellihide callback invoked with Intellihide off",__func__);*/
-    return;
-  }
   win = wnck_screen_get_active_window (priv->screen);
   if (!win)
   {
@@ -2730,10 +2882,6 @@
   g_return_if_fail (TASK_IS_MANAGER (manager));
   priv = manager->priv;
    
-  if (!priv->intellihide)
-  {
-    return;
-  }
   win = wnck_screen_get_active_window (priv->screen);
   if (!win)
   {

=== modified file 'data/avant-window-navigator.schema-ini.in.in'
--- data/avant-window-navigator.schema-ini.in.in	2010-07-19 22:28:12 +0000
+++ data/avant-window-navigator.schema-ini.in.in	2010-10-25 13:06:06 +0000
@@ -86,6 +86,11 @@
 default = false
 _description=If true, the panel will expand to full monitor width/height.
 
+[panel/intellihide_mode]
+type = integer
+default = 2
+_description= Intellihide mode.  0.. Disabled,  1.. use windows on active workspace, 2.. use windows of currently focused app.
+
 [panel/monitor_align]
 type = float
 default = 0.5

=== modified file 'src/awn-app.vala'
--- src/awn-app.vala	2010-07-24 12:58:39 +0000
+++ src/awn-app.vala	2010-10-25 13:06:06 +0000
@@ -26,8 +26,10 @@
   [DBus (name="org.awnproject.Awn.App")]
   public interface AppDBusInterface: GLib.Object
   {
-    public abstract ObjectPath[] get_panels () throws DBus.Error;
+    public abstract string[] get_panels () throws DBus.Error;
     public abstract void remove_panel (int panel_id) throws DBus.Error;
+    public signal void panel_added (int panel_id);
+    public signal void panel_removed (int panel_id);
   }
 
   public class Application: GLib.Object, AppDBusInterface
@@ -107,6 +109,7 @@
           this.panels.insert ((owned)path, panel);
 
           panel.show ();
+          this.panel_added (panel_id);
         }
         else
         {
@@ -116,24 +119,25 @@
 
       foreach (unowned Panel p in untouched_panels)
       {
+        int panel_id = p.panel_id;
         string path = "/org/awnproject/Awn/Panel%d".printf (p.panel_id);
         this.panels.remove (path);
+        this.panel_removed (panel_id);
         p.destroy ();
       }
     }
 
-    public ObjectPath[] get_panels () throws DBus.Error
+    public string[] get_panels () throws DBus.Error
     {
       var keys = this.panels.get_keys ();
       keys.sort (strcmp);
 
-      ObjectPath[] paths = new ObjectPath[keys.length ()];
+      string[] paths = new string[keys.length ()];
       int i = 0;
       foreach (unowned string path in keys)
       {
-        paths[i++] = new ObjectPath (path);
+        paths[i++] = path;
       }
-
       return paths;
     }