← Back to branch summary

~ubuntu-branches/ubuntu/oneiric/avant-window-navigator/oneiric

« back to all changes in this revision

Viewing changes to src/awn-task-manager.c

  • Committer: Bazaar Package Importer
  • Author(s): Julien Lavergne
  • Date: 2009-01-19 19:35:52 UTC
  • mfrom: (1.1.3 upstream)
  • Revision ID: james.westby@ubuntu.com-20090119193552-6briat37meu8bar8
Tags: 0.3.2-0ubuntu1
https://launchpad.net/bugs/327443
http://bugs.debian.org/493640
https://launchpad.net/bugs/260987
https://launchpad.net/bugs/276734
https://launchpad.net/bugs/335785
* New upstream release (Closes : #514681) (LP: #327443)
 - Add a script to delay the start of awn when using the autostart. 
   (Closes: #493640)
 - Fix awn-manager permission when trying to edit some desktop file 
  (LP: #260987)
 - Update position on screen resolution changes (LP: #276734)
* debian/awn.wrapper
 - A script to update applets path using awn-applets-migration script.
* debian/*.install: 
 - Add the themes directory to avant-window-navigator-data.install.
 - Add awn-autostart to avant-window-navigator.install.
 - Add awn-applets-migration to awn-manager.install.
 - Remove usr/bin/avant-window-navigator, handle by debian/rules.
 - Install python bindings in *-packages instead of site-packages only, 
   needed for the python migration in squeeze (LP: #335785).
* debian/control:
 - Add missing ${misc:Depends}.
 - Bump Build-Depends and Depends for vala to (>= 0.5.4).
 - Set awn-manager as Depends rather than Recommends, needed by the 
   awn-applets-migration script.
 - Remove unnecessary "Section: gnome"
 - Note that the libawn0-dbg contains debuggins symbols.
 - Set Build-Depends on python (>= 2.5) instead of hardcoding the python 
   version.
* debian/awn-autostart.1 & debian/awn-applets-migrations:
 - Add new man pages.
* debian/avant-window-navigator.links
 - Symlink awn.1 with avant-window-navigator.1
* debian/rules:
 - Move avant-window-navigator to awn, and copy awn.wrapper to 
   avant-window-navigator
 - Add new man pages.
* debian/patches/
 - 00-wm-behavior.patch : Don't bring the windows to the current workspace 
   when the icon of the bar is clicked. Keep the same behavior that the 
   gnome-panel applet.
 - 01-tasks-have-arrow.patch: Set the option "Tasks have arrow" by default.
 - 03-python-import.path : Update.
* debian/copyright
 - Replace (C) by ©.

Show diffs side-by-side

added added

removed removed

Lines of Context:
src/awn-task-manager.c
26
26
 
27
27
#include <dbus/dbus-glib.h>
28
28
#include <dbus/dbus-glib-bindings.h>
 
29
#include <unistd.h>
29
30
 
30
31
#include "config.h"
31
32
 
76
77
static void _task_manager_check_item_clicked (AwnTask *task, guint id, gboolean active, AwnTaskManager *task_manager);
77
78
static void _task_manager_check_width (AwnTaskManager *task_manager);
78
79
 
 
80
static void
 
81
on_height_changed (DBusGProxy *proxy, gint height, AwnTaskManager *manager);
 
82
 
 
83
 
79
84
/* STRUCTS & ENUMS */
80
85
 
81
86
typedef struct _AwnTaskManagerPrivate AwnTaskManagerPrivate;
95
100
        GList *tasks;
96
101
 
97
102
        GtkWidget *eb;
98
 
        
99
 
        gboolean ignore_gconf;
 
103
 
 
104
        DBusGConnection *applet_man_connection;
 
105
        DBusGProxy *applet_man_proxy;
 
106
 
 
107
        gulong signal_handlers[6];
 
108
 
 
109
        gboolean got_viewport;
 
110
        gint activate_behavior;
100
111
};
101
112
 
102
113
enum
110
121
 
111
122
/* GLOBALS */
112
123
 
 
124
static int TASKMAN_OWN_PID = -1;
113
125
 
114
126
static void
115
127
_load_launchers_func (const char *uri, AwnTaskManager *task_manager)
380
392
        }
381
393
        /* if not launcher & no starter, create new task */
382
394
        if (task == NULL) {
 
395
                // LP bug #258960 - always skip awn itself
 
396
                if (wnck_window_get_pid(window) == TASKMAN_OWN_PID) return;
 
397
 
383
398
                task = awn_task_new(task_manager, priv->settings);
384
399
                if (awn_task_set_window (AWN_TASK (task), window))
385
400
                        ;//g_print("Created for %s\n", wnck_window_get_name(window));
417
432
 
418
433
        if (new_task) {
419
434
                if (awn_task_set_window (AWN_TASK (new_task), window)) {
420
 
                        //awn_task_set_window (task, NULL);
421
435
                        awn_task_close(task);
422
436
                        awn_task_manager_remove_task (task_manager, task);
423
437
                        awn_task_refresh_icon_geometry(new_task);
558
572
        }
559
573
 
560
574
        AwnTaskManagerPrivate *priv;
561
 
        GtkWidget *task = NULL;
562
 
        AwnDesktopItem *item = NULL;
563
575
        GString *uri;
564
576
        AwnSettings *settings;
565
577
 
578
590
                uri = g_string_truncate(uri, res+1);
579
591
 
580
592
 
581
 
  g_print("Desktop file: %s\n", uri->str);
582
 
        item = awn_desktop_item_new (uri->str);
583
 
 
584
 
        if (item == NULL) {
585
 
                g_print("Error : Could not load the desktop file!");
586
 
                return;
587
 
 
588
 
        }
589
 
 
590
 
        task = awn_task_new(task_manager, priv->settings);
591
 
        awn_task_set_title (AWN_TASK(task), AWN_TITLE(priv->title_window));
592
 
        if (awn_task_set_launcher (AWN_TASK (task), item)) {
593
 
 
594
 
                g_signal_connect (G_OBJECT(task), "drag-data-received",
595
 
                                  G_CALLBACK(_task_manager_drag_data_recieved), (gpointer)task_manager);
596
 
                g_signal_connect (G_OBJECT(task), "menu_item_clicked",
597
 
                          G_CALLBACK(_task_manager_menu_item_clicked), (gpointer)
598
 
                          task_manager);
599
 
                g_signal_connect (G_OBJECT(task), "check_item_clicked",
600
 
                          G_CALLBACK(_task_manager_check_item_clicked), (gpointer)
601
 
                          task_manager);
602
 
 
603
 
                priv->launchers = g_list_append(priv->launchers, (gpointer)task);
604
 
                gtk_box_pack_start(GTK_BOX(priv->launcher_box), task, FALSE, FALSE, 0);
605
 
                gtk_widget_show(task);
606
 
                _refresh_box (task_manager);
607
 
                g_print("LOADED : %s\n", _sdata);
608
 
 
609
 
                /******* Add to config *********/
610
 
                priv->ignore_gconf = TRUE;
611
 
                settings = priv->settings;
612
 
                settings->launchers = g_slist_append(settings->launchers, g_strdup(uri->str));
613
 
                
614
 
                AwnConfigClient *client = awn_config_client_new ();
615
 
                awn_config_client_set_list(client, "window_manager", "launchers",
616
 
                                           AWN_CONFIG_CLIENT_LIST_TYPE_STRING,
617
 
                                           settings->launchers, NULL);
618
 
                awn_task_manager_update_separator_position (task_manager);
619
 
        } else {
620
 
                gtk_widget_destroy(task);
621
 
                awn_desktop_item_free (item);
622
 
                g_print("FAILED : %s\n", _sdata);
623
 
 
624
 
        }
 
593
        g_print("Desktop file: %s\n", uri->str);
 
594
 
 
595
        /******* Add to config *********/
 
596
        settings = priv->settings;
 
597
        // careful shallow copy
 
598
        GSList *launchers = g_slist_copy(settings->launchers);
 
599
        launchers = g_slist_append(launchers, uri->str);
 
600
 
 
601
        AwnConfigClient *client = awn_config_client_new ();
 
602
        awn_config_client_set_list(client, "window_manager", "launchers",
 
603
                                   AWN_CONFIG_CLIENT_LIST_TYPE_STRING,
 
604
                                   launchers, NULL);
 
605
 
 
606
        g_slist_free (launchers);
625
607
 
626
608
        g_string_free(uri, TRUE);
627
 
        //awn_task_manager_update_separator_position (task_manager);
628
 
        _refresh_box(task_manager);
629
609
        gtk_drag_finish (context, dnd_success, delete_selection_data, time);
630
610
}
631
611
 
825
805
                } while (x + num * width + 50 < settings->monitor_width);
826
806
        }
827
807
 
828
 
        if (width < settings->task_width) {
 
808
        if (width < settings->task_width && width >= AWN_MIN_BAR_HEIGHT) {
829
809
                settings->task_width = width;
830
810
                g_list_foreach(priv->launchers, (GFunc)_task_resize, GINT_TO_POINTER (settings->task_width));
831
811
                g_list_foreach(priv->tasks, (GFunc)_task_resize, GINT_TO_POINTER (settings->task_width));
1400
1380
#include "awn-dbus-glue.h"
1401
1381
 
1402
1382
static void
 
1383
awn_task_manager_dispose (GObject *object)
 
1384
{
 
1385
        AwnTaskManagerPrivate *priv;
 
1386
        priv = AWN_TASK_MANAGER_GET_PRIVATE (object);
 
1387
 
 
1388
        if (priv->applet_man_proxy) {
 
1389
                dbus_g_proxy_disconnect_signal (priv->applet_man_proxy,
 
1390
                                               "HeightChanged",
 
1391
                                               G_CALLBACK (on_height_changed),
 
1392
                                               (gpointer)object);
 
1393
                priv->applet_man_proxy = NULL;
 
1394
        }
 
1395
        if (priv->applet_man_connection) {
 
1396
                dbus_g_connection_unref (priv->applet_man_connection);
 
1397
                priv->applet_man_connection = NULL;
 
1398
        }
 
1399
 
 
1400
        // oh yea, this one is disgusting, but it basically only
 
1401
        //  disconnects a few signals
 
1402
        if (priv->signal_handlers[0]) {
 
1403
                gint i;
 
1404
                for (i = 0; i < G_N_ELEMENTS(priv->signal_handlers); i++) {
 
1405
                        gpointer instance = i <= 3 ? (priv->screen) : 
 
1406
                        (i == 4 ? priv->settings->window : (gpointer)gtk_icon_theme_get_default ());
 
1407
                        if (priv->signal_handlers[i]) {
 
1408
                                g_signal_handler_disconnect(instance,
 
1409
                                        priv->signal_handlers[i]);
 
1410
                                priv->signal_handlers[i] = 0;
 
1411
                        }
 
1412
                }
 
1413
        }
 
1414
 
 
1415
        // hide the separator
 
1416
        awn_bar_set_draw_separator (priv->settings->bar, 0);
 
1417
 
 
1418
        G_OBJECT_CLASS (awn_task_manager_parent_class)->dispose (object);
 
1419
}
 
1420
 
 
1421
static void
1403
1422
awn_task_manager_class_init (AwnTaskManagerClass *class)
1404
1423
{
1405
1424
        GObjectClass *obj_class;
1406
1425
        GtkWidgetClass *widget_class;
1407
1426
 
1408
1427
        obj_class = G_OBJECT_CLASS (class);
 
1428
        obj_class->dispose = awn_task_manager_dispose;
1409
1429
        widget_class = GTK_WIDGET_CLASS (class);
1410
1430
 
1411
1431
        g_type_class_add_private (obj_class, sizeof (AwnTaskManagerPrivate));
1443
1463
        AwnTaskManagerPrivate *priv;
1444
1464
        GSList *list, *l;
1445
1465
        GList *t;
1446
 
        GSList *launchers = NULL;
1447
 
        
1448
 
        
 
1466
        GSList *launchers = NULL, *old_launchers;
 
1467
 
 
1468
        g_return_if_fail (AWN_IS_TASK_MANAGER (task_manager));
1449
1469
        priv = AWN_TASK_MANAGER_GET_PRIVATE (task_manager);
1450
 
        
1451
 
        if (priv->ignore_gconf) {
1452
 
                priv->ignore_gconf = FALSE;
1453
 
                return;
1454
 
        }
1455
 
        
 
1470
 
1456
1471
        list = entry->value.list_val;
1457
 
        
 
1472
 
1458
1473
        for (l = list; l != NULL; l = l->next) {
1459
1474
                gchar *string = g_strdup ((gchar*) (l->data));
1460
1475
                launchers = g_slist_append (launchers, string);
1461
1476
        }
1462
1477
        
1463
 
        g_slist_free (priv->settings->launchers);
 
1478
        old_launchers = priv->settings->launchers;
1464
1479
        priv->settings->launchers = launchers;
1465
1480
        
1466
1481
        gint i = 0;
1467
1482
        for (l = launchers; l != NULL; l = l->next) {
1468
1483
                AwnTask *task = NULL;
1469
1484
                for (t = priv->launchers; t != NULL; t = t->next) {
 
1485
                        AwnDesktopItem *item, *old_item;
 
1486
                        item = awn_task_get_item (AWN_TASK (t->data));
 
1487
                        gchar *file = awn_desktop_item_get_filename (item);
 
1488
                        if (strcmp (file, l->data) == 0) {
 
1489
                                task = AWN_TASK (t->data);
 
1490
                                g_free (file);
 
1491
                                // refresh the desktop item
 
1492
                                old_item = item;
 
1493
                                item = awn_desktop_item_new ((gchar*)l->data);
 
1494
                                if (item) {
 
1495
                                        awn_task_set_launcher(task, item);
 
1496
                                        awn_desktop_item_free(old_item);
 
1497
                                }
 
1498
                                break;
 
1499
                        }
 
1500
                        g_free (file);
 
1501
                }
 
1502
                if (task) {
 
1503
                        gtk_box_reorder_child (GTK_BOX (priv->launcher_box),
 
1504
                                               GTK_WIDGET (task),
 
1505
                                               i++);
 
1506
                } else {
 
1507
                        // added launcher
 
1508
                        GtkWidget *task;
 
1509
                        AwnDesktopItem *item = awn_desktop_item_new (l->data);
 
1510
 
 
1511
                        if (item == NULL) {
 
1512
                                g_print("Error : Could not load the desktop file!");
 
1513
                                continue;
 
1514
                        }
 
1515
                        g_print("LOADED : %s\n", (char*)l->data);
 
1516
 
 
1517
                        task = awn_task_new(task_manager, priv->settings);
 
1518
                        awn_task_set_title (AWN_TASK(task), AWN_TITLE(priv->title_window));
 
1519
                        if (awn_task_set_launcher (AWN_TASK (task), item)) {
 
1520
 
 
1521
                                g_signal_connect (G_OBJECT(task), "drag-data-received",
 
1522
                                                  G_CALLBACK(_task_manager_drag_data_recieved), (gpointer)task_manager);
 
1523
                                g_signal_connect (G_OBJECT(task), "menu_item_clicked",
 
1524
                                                  G_CALLBACK(_task_manager_menu_item_clicked), (gpointer)
 
1525
                                                  task_manager);
 
1526
                                g_signal_connect (G_OBJECT(task), "check_item_clicked",
 
1527
                                                  G_CALLBACK(_task_manager_check_item_clicked), (gpointer)
 
1528
                                                  task_manager);
 
1529
 
 
1530
                                priv->launchers = g_list_append(priv->launchers, (gpointer)task);
 
1531
                                gtk_box_pack_start(GTK_BOX(priv->launcher_box), task, FALSE, FALSE, 0);
 
1532
                                gtk_box_reorder_child (GTK_BOX (priv->launcher_box),
 
1533
                                                       task,
 
1534
                                                       i++);
 
1535
                                gtk_widget_show(task);
 
1536
                        } else {
 
1537
                                gtk_widget_destroy(task);
 
1538
                                awn_desktop_item_free (item);
 
1539
                                g_print("FAILED : %s\n", (char*)l->data);
 
1540
                        }
 
1541
                }
 
1542
        }
 
1543
 
 
1544
        // make a list of removed launchers
 
1545
        l = old_launchers;
 
1546
        while (l) {
 
1547
                gboolean found = FALSE;
 
1548
                for (list = launchers; list; list = list->next) {
 
1549
                        if (strcmp(list->data, l->data) == 0) {
 
1550
                                found = TRUE;
 
1551
                                break;
 
1552
                        }
 
1553
                }
 
1554
                if (found) {
 
1555
                        old_launchers = g_slist_delete_link(old_launchers, l);
 
1556
                        l = old_launchers;
 
1557
                } else {
 
1558
                        l = l->next;
 
1559
                }
 
1560
        }
 
1561
        // old_launchers now contains list of removed paths
 
1562
        for (l = old_launchers; l; l = l->next) {
 
1563
                AwnTask *task = NULL;
 
1564
                for (t = priv->launchers; t != NULL; t = t->next) {
1470
1565
                        AwnDesktopItem *item;
1471
1566
                        item = awn_task_get_item (AWN_TASK (t->data));
1472
 
                                                gchar *file = awn_desktop_item_get_filename (item);
 
1567
                        gchar *file = awn_desktop_item_get_filename (item);
1473
1568
                        if (strcmp (file, l->data) == 0) {
1474
1569
                                task = AWN_TASK (t->data);
1475
1570
                        }
1477
1572
                        
1478
1573
                }
1479
1574
                if (task) {
1480
 
                        gtk_box_reorder_child (GTK_BOX (priv->launcher_box),
1481
 
                                               GTK_WIDGET (task),
1482
 
                                               i);
1483
 
                        i++;
 
1575
                        // remove from launchers
 
1576
                        g_print("REMOVED : %s\n", (char*)l->data);
 
1577
                        if (awn_task_get_window (task)) {
 
1578
                                // move to tasks
 
1579
                                GtkWidget *w = GTK_WIDGET (task);
 
1580
                                awn_task_manager_remove_launcher (task_manager, task);
 
1581
                                awn_task_set_launcher (task, NULL);
 
1582
                                priv->tasks = g_list_append(priv->tasks, (gpointer)task);
 
1583
                                gtk_widget_ref(w);
 
1584
                                gtk_container_remove(GTK_CONTAINER(priv->launcher_box), w);
 
1585
                                gtk_box_pack_start(GTK_BOX(priv->tasks_box), w, FALSE, FALSE, 0);
 
1586
                                gtk_widget_unref(w);
 
1587
                        } else {
 
1588
                                // destroy completely
 
1589
                                awn_task_manager_remove_launcher (task_manager,
 
1590
                                                                  task);
 
1591
                                awn_task_remove (task);
 
1592
                        }
1484
1593
                }
1485
 
        }    
 
1594
        }
 
1595
 
 
1596
        g_slist_free (old_launchers);
 
1597
        
 
1598
        awn_task_manager_update_separator_position (task_manager);
 
1599
        _refresh_box(task_manager);
 
1600
}
 
1601
 
 
1602
gboolean
 
1603
awn_task_manager_screen_has_viewports (AwnTaskManager *task_manager)
 
1604
{
 
1605
        AwnTaskManagerPrivate *priv;
 
1606
 
 
1607
        g_return_val_if_fail (AWN_IS_TASK_MANAGER (task_manager), FALSE);
 
1608
        priv = AWN_TASK_MANAGER_GET_PRIVATE (task_manager);
 
1609
 
 
1610
        return priv->got_viewport;
 
1611
}
 
1612
 
 
1613
static void 
 
1614
awn_task_manager_update_activate_behavior (AwnConfigClientNotifyEntry *entry,
 
1615
                                   AwnTaskManager *task_manager)
 
1616
{
 
1617
        AwnTaskManagerPrivate *priv;
 
1618
 
 
1619
        g_return_if_fail (AWN_IS_TASK_MANAGER (task_manager));
 
1620
        priv = AWN_TASK_MANAGER_GET_PRIVATE (task_manager);
 
1621
 
 
1622
        priv->activate_behavior = entry->value.int_val;
 
1623
}
 
1624
 
 
1625
gint
 
1626
awn_task_manager_get_activate_behavior (AwnTaskManager *task_manager)
 
1627
{
 
1628
        AwnTaskManagerPrivate *priv;
 
1629
 
 
1630
        g_return_val_if_fail (AWN_IS_TASK_MANAGER (task_manager), 0);
 
1631
        priv = AWN_TASK_MANAGER_GET_PRIVATE (task_manager);
 
1632
 
 
1633
        return priv->activate_behavior;
1486
1634
}
1487
1635
 
1488
1636
static void
1521
1669
        priv->title_window = NULL;
1522
1670
        priv->launchers = NULL;
1523
1671
        priv->tasks = NULL;
1524
 
        priv->ignore_gconf = FALSE;
1525
1672
        
1526
1673
        /* Setup GConf to notify us if the launchers list changes */
1527
1674
        awn_config_client_notify_add (client, "window_manager", "launchers", 
1528
1675
                (AwnConfigClientNotifyFunc)awn_task_manager_refresh_launchers, 
1529
1676
                task_manager);
1530
1677
 
 
1678
        priv->activate_behavior = awn_config_client_get_int (client,
 
1679
                "window_manager", "activate_behavior", NULL);
 
1680
        awn_config_client_notify_add (client,
 
1681
                "window_manager", "activate_behavior",
 
1682
                (AwnConfigClientNotifyFunc)
 
1683
                awn_task_manager_update_activate_behavior, task_manager);
 
1684
 
1531
1685
        connection = dbus_g_bus_get (DBUS_BUS_SESSION, &error);
1532
1686
        if (!connection) {
1533
1687
                if (error) {
1537
1691
                }
1538
1692
                return;
1539
1693
        }
 
1694
        priv->applet_man_connection = connection;
1540
1695
 
1541
1696
        proxy = dbus_g_proxy_new_for_name (connection,
1542
1697
                                          "com.google.code.Awn.AppletManager",
1546
1701
                g_warning ("Cannot connect to applet manager\n");
1547
1702
                return;
1548
1703
        }
 
1704
        priv->applet_man_proxy = proxy;
1549
1705
        dbus_g_proxy_add_signal (proxy, "HeightChanged", G_TYPE_INT, G_TYPE_INVALID);
1550
1706
        dbus_g_proxy_connect_signal (proxy, 
1551
1707
                                     "HeightChanged",
1552
1708
                                     G_CALLBACK (on_height_changed),
1553
1709
                                     (gpointer)task_manager, 
1554
1710
                                     NULL);
1555
 
             
 
1711
}
 
1712
 
 
1713
static gboolean
 
1714
awn_task_manager_realized (gpointer data)
 
1715
{
 
1716
        AwnTaskManager *task_manager = AWN_TASK_MANAGER(data);
 
1717
        AwnTaskManagerPrivate *priv = AWN_TASK_MANAGER_GET_PRIVATE (data);
 
1718
 
 
1719
        GList *l;
 
1720
        GList *list = wnck_screen_get_windows (priv->screen);
 
1721
        for (l = list; l != NULL; l = l->next) {
 
1722
                _task_manager_window_opened (priv->screen,
 
1723
                                             (WnckWindow*)l->data,
 
1724
                                             task_manager);
 
1725
        }
 
1726
        // fix the height
 
1727
        on_height_changed (NULL, priv->settings->bar_height, task_manager);
 
1728
 
 
1729
        return FALSE;
1556
1730
}
1557
1731
 
1558
1732
GtkWidget *
1559
1733
awn_task_manager_new (AwnSettings *settings)
1560
1734
{
 
1735
        TASKMAN_OWN_PID = getpid();
 
1736
 
1561
1737
        GtkWidget *task_manager;
1562
1738
        AwnTaskManagerPrivate *priv;
1563
1739
 
1567
1743
                             NULL);
1568
1744
        priv = AWN_TASK_MANAGER_GET_PRIVATE (task_manager);
1569
1745
 
 
1746
        // this must be here, so get_active_workspace doesn't return NULL
 
1747
        // but it makes us loose the window-opened signals, so we use
 
1748
        // g_idle_add to enumerate the windows
 
1749
        wnck_screen_force_update(priv->screen);
 
1750
        WnckWorkspace *wrksp = wnck_screen_get_active_workspace(priv->screen);
 
1751
        if (wrksp) priv->got_viewport = wnck_workspace_is_virtual(wrksp);
 
1752
 
 
1753
#ifdef HAVE_LIBWNCK_220
 
1754
        if (!priv->got_viewport &&
 
1755
                wnck_screen_get_window_manager_name(priv->screen))
 
1756
        {
 
1757
                if (strcmp(wnck_screen_get_window_manager_name(priv->screen), "compiz") == 0)
 
1758
                priv->got_viewport = TRUE;
 
1759
        }
 
1760
#endif
 
1761
 
 
1762
        // wnck hack -> we want the window-opened signal
 
1763
        g_idle_add (awn_task_manager_realized, task_manager);
 
1764
 
1570
1765
        priv->settings = settings;
1571
1766
        priv->launcher_box = gtk_hbox_new(FALSE, 0);
1572
1767
        priv->tasks_box = gtk_hbox_new(FALSE, 0);
1587
1782
        _task_manager_load_launchers(AWN_TASK_MANAGER (task_manager));
1588
1783
 
1589
1784
        /* LIBWNCK SIGNALS */
1590
 
        g_signal_connect (G_OBJECT(priv->screen), "window-opened",
1591
 
                          G_CALLBACK (_task_manager_window_opened),
1592
 
                          (gpointer)task_manager);
1593
 
 
1594
 
        g_signal_connect (G_OBJECT(priv->screen), "window-closed",
1595
 
                          G_CALLBACK(_task_manager_window_closed),
1596
 
                          (gpointer)task_manager);
1597
 
 
1598
 
        g_signal_connect (G_OBJECT(priv->screen), "active-window-changed",
1599
 
                          G_CALLBACK(_task_manager_window_activate),
1600
 
                          (gpointer)task_manager);
 
1785
        priv->signal_handlers[0] =
 
1786
            g_signal_connect (G_OBJECT(priv->screen), "window-opened",
 
1787
                              G_CALLBACK (_task_manager_window_opened),
 
1788
                              (gpointer)task_manager);
 
1789
 
 
1790
        priv->signal_handlers[1] =
 
1791
            g_signal_connect (G_OBJECT(priv->screen), "window-closed",
 
1792
                              G_CALLBACK(_task_manager_window_closed),
 
1793
                              (gpointer)task_manager);
 
1794
 
 
1795
        priv->signal_handlers[2] =
 
1796
            g_signal_connect (G_OBJECT(priv->screen), "active-window-changed",
 
1797
                              G_CALLBACK(_task_manager_window_activate),
 
1798
                              (gpointer)task_manager);
1601
1799
 
1602
1800
#ifdef HAVE_LIBWNCK_220
1603
 
        g_signal_connect (G_OBJECT(priv->screen), "viewports-changed",
1604
 
                          G_CALLBACK(_task_manager_viewports_changed),
1605
 
                          (gpointer)task_manager);
 
1801
        priv->signal_handlers[3] =
 
1802
            g_signal_connect (G_OBJECT(priv->screen), "viewports-changed",
 
1803
                              G_CALLBACK(_task_manager_viewports_changed),
 
1804
                              (gpointer)task_manager);
 
1805
#else
 
1806
        priv->signal_handlers[3] = 0;
1606
1807
#endif
1607
1808
 
1608
1809
        /* CONNECT D&D CODE */
1609
1810
 
1610
 
        g_signal_connect (G_OBJECT(settings->window), "drag-data-received",
1611
 
                          G_CALLBACK(_task_manager_drag_data_recieved), (gpointer)task_manager);
 
1811
        priv->signal_handlers[4] =
 
1812
            g_signal_connect (G_OBJECT(settings->window), "drag-data-received",
 
1813
                              G_CALLBACK(_task_manager_drag_data_recieved), (gpointer)task_manager);
1612
1814
 
1613
1815
        /* THEME CHANGED CODE */
1614
1816
        GtkIconTheme *theme = gtk_icon_theme_get_default ();
1615
1817
 
1616
 
        g_signal_connect (G_OBJECT(theme), "changed",
1617
 
                          G_CALLBACK(_task_manager_icon_theme_changed), (gpointer)task_manager);
 
1818
        priv->signal_handlers[5] =
 
1819
            g_signal_connect (G_OBJECT(theme), "changed",
 
1820
                              G_CALLBACK(_task_manager_icon_theme_changed), (gpointer)task_manager);
1618
1821
 
1619
1822
        /* SEP EXPOSE EVENT */
1620
1823
 
1621
1824
        g_signal_connect (G_OBJECT(priv->eb), "expose-event",
1622
1825
                          G_CALLBACK(awn_bar_separator_expose_event), (gpointer)settings->bar);                   
1623
1826
 
 
1827
        #define A_NAMESPACE "com.google.code.Awn"
 
1828
        #define A_OBJECT_PATH "/com/google/code/Awn"
 
1829
        DBusGConnection *connection;
 
1830
        DBusGProxy *proxy;
 
1831
        GError *error = NULL;
 
1832
        guint32 ret;
 
1833
 
 
1834
        /* Get the connection and ensure the name is not used yet */
 
1835
        connection = dbus_g_bus_get (DBUS_BUS_SESSION, &error);
 
1836
        if (connection == NULL) {
 
1837
                g_warning ("Failed to make connection to session bus: %s",
 
1838
                           error->message);
 
1839
                g_error_free (error);
 
1840
                return task_manager;
 
1841
        }
 
1842
 
 
1843
        proxy = dbus_g_proxy_new_for_name (connection, DBUS_SERVICE_DBUS,
 
1844
                                           DBUS_PATH_DBUS, DBUS_INTERFACE_DBUS);
 
1845
        if (!org_freedesktop_DBus_request_name (proxy, A_NAMESPACE,
 
1846
                                                0, &ret, &error)) {
 
1847
                g_warning ("There was an error requesting the name: %s",
 
1848
                           error->message);
 
1849
                g_error_free (error);
 
1850
                return task_manager;
 
1851
        }
 
1852
        if (ret != DBUS_REQUEST_NAME_REPLY_PRIMARY_OWNER) {
 
1853
                /* Someone else registered the name before us */
 
1854
                return task_manager;
 
1855
        }
 
1856
        /* Register the task manager on the bus */
 
1857
        dbus_g_connection_register_g_object (connection,
 
1858
                                             A_OBJECT_PATH,
 
1859
                                             G_OBJECT (task_manager));
 
1860
 
1624
1861
 
1625
1862
        return task_manager;
1626
1863
}
1627
1864
 
1628
 
 
1629
 
 
1630
 
 
1631
 
 
1632
 
 
1633
 
 
1634
 
 
1635
 
 
1636
 
 
1637