← Back to branch summary

~ubuntu-branches/ubuntu/oneiric/indicator-session/oneiric-proposed

« back to all changes in this revision

Viewing changes to src/device-menu-mgr.c

  • Committer: Bazaar Package Importer
  • Author(s): Ken VanDine
  • Date: 2011-08-25 08:58:56 UTC
  • mfrom: (1.1.34 upstream)
  • Revision ID: james.westby@ubuntu.com-20110825085856-qtuta6vqal1iw7mt
Tags: 0.3.3-0ubuntu1
https://launchpad.net/bugs/831758
https://launchpad.net/bugs/825111
https://launchpad.net/bugs/552048
https://launchpad.net/bugs/557608
https://launchpad.net/bugs/656323
* New upstream release.
  - User menu should still show even if there is only 1 user (LP: #831758)
  - Bluetooth item in menu not needed (LP: #825111)
  - Newly created users are not added to the menu until next 
    login (LP: #552048)
  - Users list in shutdown menu is not updated on user 
    deletion (LP: #557608)
  - should use gsettings rather than gconf (LP: #656323)
* debian/control
  - Bump dbusmenu build dep to >= 0.4.92

Show diffs side-by-side

added added

removed removed

Lines of Context:
src/device-menu-mgr.c
21
21
#include <libdbusmenu-gtk3/menuitem.h>
22
22
 
23
23
#include "device-menu-mgr.h"
24
 
#include "gconf-helper.h"
 
24
#include "settings-helper.h"
25
25
#include "dbus-shared-names.h"
26
26
#include "dbusmenu-shared.h"
27
27
#include "lock-helper.h"
44
44
  UdevMgr* udev_mgr;
45
45
};
46
46
 
47
 
static GConfClient       *gconf_client  = NULL;
 
47
static GSettings         *lockdown_settings  = NULL;
 
48
static GSettings         *keybinding_settings  = NULL;
48
49
static DbusmenuMenuitem  *lock_menuitem = NULL;
49
50
static DbusmenuMenuitem  *system_settings_menuitem = NULL;
50
51
static DbusmenuMenuitem  *display_settings_menuitem = NULL;
51
 
static DbusmenuMenuitem  *bluetooth_settings_menuitem = NULL;
52
52
static DbusmenuMenuitem  *login_settings_menuitem = NULL;
53
53
static DbusmenuMenuitem  *software_updates_menuitem = NULL;
54
54
static DbusmenuMenuitem  *printers_menuitem = NULL;
72
72
static DBusGProxy * up_main_proxy = NULL;
73
73
static DBusGProxy * up_prop_proxy = NULL;
74
74
 
75
 
static void device_menu_mgr_ensure_gconf_client (DeviceMenuMgr* self);
 
75
static void device_menu_mgr_ensure_settings_client (DeviceMenuMgr* self);
76
76
static void setup_restart_watch (DeviceMenuMgr* self);
77
77
static void setup_up (DeviceMenuMgr* self);
78
78
static void device_menu_mgr_rebuild_items (DeviceMenuMgr *self);
128
128
// TODO
129
129
// Is this needed anymore
130
130
static void
131
 
lockdown_changed (GConfClient *client,
132
 
                  guint        cnxd_id,
133
 
                  GConfEntry  *entry,
 
131
lockdown_changed (GSettings * settings,
 
132
                  const gchar * key,
134
133
                  gpointer     user_data)
135
134
{
136
 
  DeviceMenuMgr* self = DEVICE_MENU_MGR (user_data);
137
 
        GConfValue  *value = gconf_entry_get_value (entry);
138
 
        const gchar *key   = gconf_entry_get_key (entry);
 
135
        DeviceMenuMgr* self = DEVICE_MENU_MGR (user_data);
139
136
 
140
 
        if (value == NULL || key == NULL) {
 
137
        if (key == NULL) {
141
138
                return;
142
139
        }
143
140
 
144
141
        if (g_strcmp0 (key, LOCKDOWN_KEY_USER) == 0 ||
145
 
      g_strcmp0 (key, LOCKDOWN_KEY_SCREENSAVER) == 0) {
 
142
              g_strcmp0 (key, LOCKDOWN_KEY_SCREENSAVER) == 0) {
146
143
                device_menu_mgr_rebuild_items(self);
147
144
        }
148
145
 
150
147
}
151
148
 
152
149
static void
153
 
keybinding_changed (GConfClient *client,
154
 
                    guint        cnxd_id,
155
 
                    GConfEntry  *entry,
 
150
keybinding_changed (GSettings   *settings,
 
151
                    const gchar *key,
156
152
                    gpointer     user_data)
157
153
{
158
 
        GConfValue  *value = gconf_entry_get_value (entry);
159
 
        const gchar *key   = gconf_entry_get_key (entry);
160
 
 
161
 
        if (value == NULL || key == NULL) {
 
154
        if (key == NULL) {
162
155
                return;
163
156
        }
164
157
 
165
158
        if (g_strcmp0 (key, KEY_LOCK_SCREEN) == 0) {
166
 
                g_debug("Keybinding changed to: %s", gconf_value_get_string(value));
 
159
                g_debug("Keybinding changed to: %s", g_settings_get_string(settings, key));
167
160
                if (lock_menuitem != NULL) {
168
161
                        dbusmenu_menuitem_property_set_shortcut_string (lock_menuitem,
169
 
                                                      gconf_value_get_string(value));
 
162
                                                      g_settings_get_string(settings, key));
170
163
                }
171
164
        }
172
165
        return;
176
169
   locking the screen.  If not, lock it. */
177
170
static void
178
171
lock_if_possible (DeviceMenuMgr* self) {
179
 
        device_menu_mgr_ensure_gconf_client (self);
 
172
        device_menu_mgr_ensure_settings_client (self);
180
173
 
181
 
        if (!gconf_client_get_bool (gconf_client, LOCKDOWN_KEY_SCREENSAVER, NULL)) {
 
174
        if (!g_settings_get_boolean (lockdown_settings, LOCKDOWN_KEY_SCREENSAVER)) {
182
175
                lock_screen (NULL, 0, NULL);
183
176
        }
184
177
        return;
541
534
  dbusmenu_menuitem_child_add_position(self->root_item,
542
535
                                       display_settings_menuitem,
543
536
                                       1);
544
 
  bluetooth_settings_menuitem = dbusmenu_menuitem_new();
545
 
  dbusmenu_menuitem_property_set (bluetooth_settings_menuitem,
546
 
                                  DBUSMENU_MENUITEM_PROP_LABEL,
547
 
                                  _("Bluetooth…"));
548
 
  g_signal_connect (G_OBJECT(bluetooth_settings_menuitem),
549
 
                    DBUSMENU_MENUITEM_SIGNAL_ITEM_ACTIVATED,
550
 
                    G_CALLBACK(show_system_settings_with_context), "bluetooth");
551
 
  dbusmenu_menuitem_child_add_position(self->root_item,
552
 
                                       bluetooth_settings_menuitem,
553
 
                                       2);
554
 
 
555
537
  login_settings_menuitem = dbusmenu_menuitem_new();
556
538
  dbusmenu_menuitem_property_set (login_settings_menuitem,
557
539
                                  DBUSMENU_MENUITEM_PROP_LABEL,
562
544
                    "login");
563
545
  dbusmenu_menuitem_child_add_position(self->root_item,
564
546
                                       login_settings_menuitem,                                  
565
 
                                       3);
 
547
                                       2);
566
548
  software_updates_menuitem = dbusmenu_menuitem_new();
567
549
  dbusmenu_menuitem_property_set (software_updates_menuitem,
568
550
                                  DBUSMENU_MENUITEM_PROP_LABEL,
569
551
                                  _("Software Up to Date"));
570
552
  dbusmenu_menuitem_child_add_position(self->root_item,
571
553
                                       software_updates_menuitem,
572
 
                                       4);
 
554
                                       3);
573
555
 
574
556
  DbusmenuMenuitem * separator1 = dbusmenu_menuitem_new();
575
557
  dbusmenu_menuitem_property_set (separator1,
576
558
                                  DBUSMENU_MENUITEM_PROP_TYPE,
577
559
                                  DBUSMENU_CLIENT_TYPES_SEPARATOR);
578
 
  dbusmenu_menuitem_child_add_position (self->root_item, separator1, 5);
 
560
  dbusmenu_menuitem_child_add_position (self->root_item, separator1, 4);
579
561
}
580
562
 
581
563
static void
590
572
                                       FALSE);
591
573
  dbusmenu_menuitem_child_add_position (self->root_item,
592
574
                                        device_heading,
593
 
                                        6);
 
575
                                        5);
594
576
 
595
577
  printers_menuitem = dbusmenu_menuitem_new();
596
578
  dbusmenu_menuitem_property_set (printers_menuitem,
602
584
                    "printers");
603
585
  dbusmenu_menuitem_child_add_position(self->root_item,
604
586
                                       printers_menuitem,
605
 
                                       7);
 
587
                                       6);
606
588
  scanners_menuitem = dbusmenu_menuitem_new();
607
589
  dbusmenu_menuitem_property_set (scanners_menuitem,
608
590
                                  DBUSMENU_MENUITEM_PROP_LABEL,
613
595
                    NULL);
614
596
  dbusmenu_menuitem_child_add_position (self->root_item,
615
597
                                        scanners_menuitem,
616
 
                                        8);
 
598
                                        7);
617
599
  dbusmenu_menuitem_property_set_bool (scanners_menuitem,
618
600
                                       DBUSMENU_MENUITEM_PROP_VISIBLE,
619
601
                                       FALSE);
628
610
                    NULL);
629
611
  dbusmenu_menuitem_child_add_position (self->root_item,
630
612
                                        webcam_menuitem,
631
 
                                        10);
 
613
                                        8);
632
614
  dbusmenu_menuitem_property_set_bool (webcam_menuitem,
633
615
                                       DBUSMENU_MENUITEM_PROP_VISIBLE,
634
616
                                       FALSE);
637
619
  dbusmenu_menuitem_property_set (separator3,
638
620
                                  DBUSMENU_MENUITEM_PROP_TYPE,
639
621
                                  DBUSMENU_CLIENT_TYPES_SEPARATOR);
640
 
  dbusmenu_menuitem_child_add_position (self->root_item, separator3, 11);
 
622
  dbusmenu_menuitem_child_add_position (self->root_item, separator3, 9);
641
623
}
642
624
 
643
625
static void
659
641
 
660
642
    /* Make sure we have a valid GConf client, and build one
661
643
       if needed */
662
 
    device_menu_mgr_ensure_gconf_client (self);
663
 
    can_lockscreen = !gconf_client_get_bool ( gconf_client,
664
 
                                              LOCKDOWN_KEY_SCREENSAVER,
665
 
                                              NULL);
 
644
    device_menu_mgr_ensure_settings_client (self);
 
645
    can_lockscreen = !g_settings_get_boolean (lockdown_settings,
 
646
                                              LOCKDOWN_KEY_SCREENSAVER);
666
647
    /* Lock screen item */
667
648
    if (can_lockscreen) {
668
649
      lock_menuitem = dbusmenu_menuitem_new();
670
651
                                      DBUSMENU_MENUITEM_PROP_LABEL,
671
652
                                      _("Lock Screen"));
672
653
 
673
 
      gchar * shortcut = gconf_client_get_string(gconf_client, KEY_LOCK_SCREEN, NULL);
 
654
      gchar * shortcut = g_settings_get_string(keybinding_settings, KEY_LOCK_SCREEN);
674
655
      if (shortcut != NULL) {
675
656
        g_debug("Lock screen shortcut: %s", shortcut);
676
657
        dbusmenu_menuitem_property_set_shortcut_string(lock_menuitem, shortcut);
759
740
  self->udev_mgr = udev_mgr_new (scanners_menuitem, webcam_menuitem);   
760
741
}
761
742
 
762
 
 
763
743
static void
764
744
device_menu_mgr_rebuild_items (DeviceMenuMgr* self)
765
745
{
830
810
/* Ensures that we have a GConf client and if we build one
831
811
   set up the signal handler. */
832
812
static void
833
 
device_menu_mgr_ensure_gconf_client (DeviceMenuMgr* self)
 
813
device_menu_mgr_ensure_settings_client (DeviceMenuMgr* self)
834
814
{
835
 
        if (!gconf_client) {
836
 
                gconf_client = gconf_client_get_default ();
837
 
                gconf_client_add_dir(gconf_client, LOCKDOWN_DIR, GCONF_CLIENT_PRELOAD_ONELEVEL, NULL);
838
 
                gconf_client_notify_add (gconf_client,
839
 
                             LOCKDOWN_DIR,
840
 
                             lockdown_changed,
841
 
                             self,
842
 
                             NULL,
843
 
                             NULL);
844
 
 
845
 
                gconf_client_add_dir(gconf_client, KEYBINDING_DIR, GCONF_CLIENT_PRELOAD_ONELEVEL, NULL);
846
 
                gconf_client_notify_add (gconf_client,
847
 
                             KEYBINDING_DIR,
848
 
                             keybinding_changed,
849
 
                             self,
850
 
                             NULL,
851
 
                             NULL);
852
 
        }
 
815
        if (!lockdown_settings) {
 
816
                lockdown_settings = g_settings_new (LOCKDOWN_SCHEMA);
 
817
                g_signal_connect(lockdown_settings, "changed", G_CALLBACK(lockdown_changed), self);
 
818
        }
 
819
        if (!keybinding_settings) {
 
820
                keybinding_settings = g_settings_new (KEYBINDING_SCHEMA);
 
821
                g_signal_connect(lockdown_settings, "changed::" KEY_LOCK_SCREEN, G_CALLBACK(keybinding_changed), self);
 
822
        }
 
823
        return;
853
824
}
854
825
 
855
826
DbusmenuMenuitem*