← Back to branch summary

~ubuntu-branches/ubuntu/oneiric/gnome-panel/oneiric

« back to all changes in this revision

Viewing changes to gnome-panel/panel-lockdown.c

  • Committer: Bazaar Package Importer
  • Author(s): Sebastien Bacher, Sebastien Bacher, Jeremy Bicha
  • Date: 2011-05-30 11:04:49 UTC
  • mfrom: (1.13.10 upstream) (2.2.5 experimental)
  • Revision ID: james.westby@ubuntu.com-20110530110449-hinl17kxkcefjw6x
Tags: 1:3.0.2-0ubuntu1
[ Sebastien Bacher ]
* New upstream version
* debian/control.in:
  - the new libgweather version is in oneiric, use it
  - drop the python and python-gconf depends, 
    they were added for gnome-panel-add which is still using gconf and buggy
* debian/gnome-panel-data.install:
  - don't install the apport hook, it's only getting gconf datas which 
    doesn't work since gnome-panel uses gsettings
* debian/patches/90_build_fixes.patch:
  - restore build fix from git not applied in the new serie
* debian/patches/01_panel_submenus.patch:
  - don't take that Debian diff, the .menus use the upstream naming in Ubuntu
* debian/patches/06_no_resize_grip.patch:
  - dropped, the issue is fixed in the new version
* debian/patches/50_fix-potfiles.patch:
  - dropped, the issue is fixed in the new version
* debian/watch:
  - track unstable series as well

Drop those delta, since gnome-panel is not the default Ubuntu session now we
can go back to an experience closer to the upstream one: 
* debian/control.in:
  - drop the indicators recommends, unity-2d is the ubuntu fallback session
    so we can get back to use an upstream config for gnome-panel and reduce
    the delta we carry
* debian/patches/04_default_panel_config.patch:
  - don't modify the upstream layout
* debian/patches/05_no_session_delay.patch:
  - no need to tweak the upstream session to optimize it
* debian/patches/16_compiz_workspace_switcher.patch:
  - go back to the upstream switcher behaviour    
* debian/patches/25_dynamic_fusa_detection.patch:
  - not needed since we use the upstream layout, could be ported if someone
    is wanting to do the work though
* debian/patches/30_disable-initial-animation.patch, debian/rules:
  - drop the --disable-initial-animation, that was some login optimization
    but since it's not the default desktop you should go back to the 
    upstream behaviour

[ Jeremy Bicha ]   
* New upstream version
* Merge from Debian experimental, remaining Ubuntu changes:
* debian/control:
  - Recommends gnome-settings-daemon which has the timezone polkit service
* debian/rules:
  - Update translations template.
* debian/gnome-panel-data.install:
  - Install apport hook
  - Install the "About Ubuntu" menu item.
* debian/patches/01_layout.patch:
  - Disabled, Help & About Ubuntu don't fit as well in Gnome Panel 3
* debian/patches/01_panel_submenus.patch.
  - Dropped
* debian/patches/03_dnd_places_link.patch:
  - Disabled, when using Drag'n'Drop from Places menu, install a link launcher
    (.desktop file) instead of copying the entire directory.
* debian/patches/17_about-ubuntu-translation.patch:
  - List ubuntu-about.desktop for translation.
* debian/patches/40_unset_menuproxy.patch:
  - Make sure gnome-panel and the applets don't pick up menu proxies.
* debian/patches/50_fix-potfiles.patch
  - Fix i18n
* debian/patches/85_disable_shutdown_on_ltsp.patch:
  - Suppress the shutdown option in the panel if LTSP_CLIENT is set.
* debian/patches/71_change_bookmark_submenu_limit_value.patch
  - Dropped, picked up by Debian
* debian/patches/18_lockdown_lock_editor.patch:
* debian/patches/90_git_wnck_show_realize.patch:
* debian/patches/90_fix_linking_DSO_link.patch:
* debian/patches/91_gir_annotations.patch
* debian/patches/92_git_calendar_day.patch
* debian/patches/92_git_fix_applets_in_multiscreen.patch:
  - Dropped, applied upstream
* debian/watch:
  - watch unstable versions

Show diffs side-by-side

added added

removed removed

Lines of Context:
gnome-panel/panel-lockdown.c
1
 
/* -*- Mode: C; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 8 -*- */
 
1
/* vim: set sw=8 et: */
2
2
/*
3
 
 * Copyright (C) 2004 Sun Microsystems, Inc.
 
3
 * panel-lockdown.c: a lockdown tracker.
 
4
 *
 
5
 * Copyright (C) 2011 Novell, Inc.
4
6
 *
5
7
 * This program is free software; you can redistribute it and/or
6
8
 * modify it under the terms of the GNU General Public License as
18
20
 * 02111-1307, USA.
19
21
 *
20
22
 * Authors:
21
 
 *      Matt Keenan  <matt.keenan@sun.com>
22
 
 *      Mark McLoughlin  <mark@skynet.ie>
 
23
 *      Vincent Untz <vuntz@gnome.org>
23
24
 */
24
25
 
25
 
#include <config.h>
 
26
#include <libpanel-util/panel-cleanup.h>
 
27
 
 
28
#include "panel-schemas.h"
26
29
 
27
30
#include "panel-lockdown.h"
28
31
 
29
 
#include <string.h>
30
 
#include "panel-gconf.h"
31
 
 
32
 
#define N_LISTENERS 6
33
 
 
34
 
#define PANEL_GLOBAL_LOCKDOWN_DIR    "/apps/panel/global"
35
 
#define DESKTOP_GNOME_LOCKDOWN_DIR   "/desktop/gnome/lockdown"
36
 
#define PANEL_GLOBAL_LOCKED_DOWN_KEY PANEL_GLOBAL_LOCKDOWN_DIR  "/locked_down"
37
 
#define DISABLE_COMMAND_LINE_KEY     DESKTOP_GNOME_LOCKDOWN_DIR "/disable_command_line"
38
 
#define DISABLE_LOCK_SCREEN_KEY      DESKTOP_GNOME_LOCKDOWN_DIR  "/disable_lock_screen"
39
 
#define DISABLE_LOG_OUT_KEY          PANEL_GLOBAL_LOCKDOWN_DIR  "/disable_log_out"
40
 
#define DISABLE_FORCE_QUIT_KEY       PANEL_GLOBAL_LOCKDOWN_DIR  "/disable_force_quit"
41
 
#define DISABLED_APPLETS_KEY         PANEL_GLOBAL_LOCKDOWN_DIR  "/disabled_applets"
42
 
 
43
 
typedef struct {
44
 
        guint   initialized : 1;
45
 
 
46
 
        guint   locked_down : 1;
47
 
        guint   disable_command_line : 1;
48
 
        guint   disable_lock_screen : 1;
49
 
        guint   disable_log_out : 1;
50
 
        guint   disable_force_quit : 1;
51
 
 
52
 
        GSList *disabled_applets;
53
 
 
54
 
        guint   listeners [N_LISTENERS];
55
 
 
56
 
        GSList *closures;
57
 
} PanelLockdown;
58
 
 
59
 
static PanelLockdown panel_lockdown = { 0, };
60
 
 
61
 
 
62
 
static inline void
63
 
panel_lockdown_invoke_closures (PanelLockdown *lockdown)
64
 
{
65
 
        GSList *l;
66
 
 
67
 
        for (l = lockdown->closures; l; l = l->next)
68
 
                g_closure_invoke (l->data, NULL, 0, NULL, NULL);
69
 
}
70
 
 
71
 
static void
72
 
locked_down_notify (GConfClient   *client,
73
 
                    guint          cnxn_id,
74
 
                    GConfEntry    *entry,
75
 
                    PanelLockdown *lockdown)
76
 
{
77
 
        if (!entry->value || entry->value->type != GCONF_VALUE_BOOL)
78
 
                return;
79
 
 
80
 
        lockdown->locked_down = gconf_value_get_bool (entry->value);
81
 
 
82
 
        panel_lockdown_invoke_closures (lockdown);
83
 
}
84
 
 
85
 
static void
86
 
disable_command_line_notify (GConfClient   *client,
87
 
                             guint          cnxn_id,
88
 
                             GConfEntry    *entry,
89
 
                             PanelLockdown *lockdown)
90
 
{
91
 
        if (!entry->value || entry->value->type != GCONF_VALUE_BOOL)
92
 
                return;
93
 
 
94
 
        lockdown->disable_command_line = gconf_value_get_bool (entry->value);
95
 
 
96
 
        panel_lockdown_invoke_closures (lockdown);
97
 
}
98
 
 
99
 
static void
100
 
disable_lock_screen_notify (GConfClient   *client,
101
 
                            guint          cnxn_id,
102
 
                            GConfEntry    *entry,
103
 
                            PanelLockdown *lockdown)
104
 
{
105
 
        if (!entry->value || entry->value->type != GCONF_VALUE_BOOL)
106
 
                return;
107
 
 
108
 
        lockdown->disable_lock_screen = gconf_value_get_bool (entry->value);
109
 
 
110
 
        panel_lockdown_invoke_closures (lockdown);
111
 
}
112
 
 
113
 
static void
114
 
disable_log_out_notify (GConfClient   *client,
115
 
                        guint          cnxn_id,
116
 
                        GConfEntry    *entry,
117
 
                        PanelLockdown *lockdown)
118
 
{
119
 
        if (!entry->value || entry->value->type != GCONF_VALUE_BOOL)
120
 
                return;
121
 
 
122
 
        lockdown->disable_log_out = gconf_value_get_bool (entry->value);
123
 
 
124
 
        panel_lockdown_invoke_closures (lockdown);
125
 
}
126
 
 
127
 
static void
128
 
disable_force_quit_notify (GConfClient   *client,
129
 
                           guint          cnxn_id,
130
 
                           GConfEntry    *entry,
131
 
                           PanelLockdown *lockdown)
132
 
{
133
 
        if (!entry->value || entry->value->type != GCONF_VALUE_BOOL)
134
 
                return;
135
 
 
136
 
        lockdown->disable_force_quit = gconf_value_get_bool (entry->value);
137
 
 
138
 
        panel_lockdown_invoke_closures (lockdown);
139
 
}
140
 
 
141
 
static void
142
 
disabled_applets_notify (GConfClient   *client,
143
 
                         guint          cnxn_id,
144
 
                         GConfEntry    *entry,
145
 
                         PanelLockdown *lockdown)
146
 
{
147
 
        GSList *l;
148
 
 
149
 
        if (!entry->value || entry->value->type != GCONF_VALUE_LIST ||
150
 
            gconf_value_get_list_type (entry->value) != GCONF_VALUE_STRING)
151
 
                return;
152
 
 
153
 
        for (l = lockdown->disabled_applets; l; l = l->next)
154
 
                g_free (l->data);
155
 
        g_slist_free (lockdown->disabled_applets);
156
 
        lockdown->disabled_applets = NULL;
157
 
 
158
 
        for (l = gconf_value_get_list (entry->value); l; l = l->next) {
159
 
                const char *iid = gconf_value_get_string (l->data);
160
 
 
161
 
                lockdown->disabled_applets =
162
 
                        g_slist_prepend (lockdown->disabled_applets,
163
 
                                         g_strdup (iid));
164
 
        }
165
 
 
166
 
        panel_lockdown_invoke_closures (lockdown);
167
 
}
168
 
 
169
 
static gboolean
170
 
panel_lockdown_load_bool (PanelLockdown         *lockdown,
171
 
                          GConfClient           *client,
172
 
                          const char            *key,
173
 
                          GConfClientNotifyFunc  notify_func,
174
 
                          int                    listener)
175
 
{
176
 
        GError   *error = NULL;
177
 
        gboolean  retval;
178
 
 
179
 
        retval = gconf_client_get_bool (client, key, &error);
180
 
        if (error) {
181
 
                g_warning ("Error getting value of '%s': %s\n",
182
 
                           key, error->message);
183
 
                retval = FALSE;
184
 
        }
185
 
 
186
 
        lockdown->listeners [listener] =
187
 
                gconf_client_notify_add (client,
188
 
                                         key,
189
 
                                         notify_func,
190
 
                                         lockdown,
191
 
                                         NULL, NULL);
192
 
 
193
 
        return retval;
194
 
}
195
 
 
196
 
static GSList *
197
 
panel_lockdown_load_disabled_applets (PanelLockdown *lockdown,
198
 
                                      GConfClient   *client,
199
 
                                      int            listener)
200
 
{
201
 
        GSList *retval;
202
 
 
203
 
        retval = gconf_client_get_list (client,
204
 
                                        DISABLED_APPLETS_KEY,
205
 
                                        GCONF_VALUE_STRING,
206
 
                                        NULL);
207
 
 
208
 
        lockdown->listeners [listener] =
209
 
                gconf_client_notify_add (client,
210
 
                                         DISABLED_APPLETS_KEY,
211
 
                                         (GConfClientNotifyFunc) disabled_applets_notify,
212
 
                                         lockdown,
213
 
                                         NULL, NULL);
214
 
 
215
 
        return retval;
216
 
}
217
 
 
218
 
void
219
 
panel_lockdown_init (void)
220
 
{
221
 
        GConfClient *client;
222
 
        int          i = 0;
223
 
 
224
 
        client = panel_gconf_get_client ();
225
 
 
226
 
        gconf_client_add_dir (client,
227
 
                              DESKTOP_GNOME_LOCKDOWN_DIR,
228
 
                              GCONF_CLIENT_PRELOAD_ONELEVEL,
229
 
                              NULL);
230
 
 
231
 
        gconf_client_add_dir (client,
232
 
                              PANEL_GLOBAL_LOCKDOWN_DIR,
233
 
                              GCONF_CLIENT_PRELOAD_ONELEVEL,
234
 
                              NULL);
235
 
 
236
 
        panel_lockdown.locked_down =
237
 
                panel_lockdown_load_bool (&panel_lockdown,
238
 
                                          client,
239
 
                                          PANEL_GLOBAL_LOCKED_DOWN_KEY,
240
 
                                          (GConfClientNotifyFunc) locked_down_notify,
241
 
                                          i++);
242
 
 
243
 
        panel_lockdown.disable_command_line =
244
 
                panel_lockdown_load_bool (&panel_lockdown,
245
 
                                          client,
246
 
                                          DISABLE_COMMAND_LINE_KEY,
247
 
                                          (GConfClientNotifyFunc) disable_command_line_notify,
248
 
                                          i++);
249
 
        
250
 
        panel_lockdown.disable_lock_screen =
251
 
                panel_lockdown_load_bool (&panel_lockdown,
252
 
                                          client,
253
 
                                          DISABLE_LOCK_SCREEN_KEY,
254
 
                                          (GConfClientNotifyFunc) disable_lock_screen_notify,
255
 
                                          i++);
256
 
 
257
 
        panel_lockdown.disable_log_out =
258
 
                panel_lockdown_load_bool (&panel_lockdown,
259
 
                                          client,
260
 
                                          DISABLE_LOG_OUT_KEY,
261
 
                                          (GConfClientNotifyFunc) disable_log_out_notify,
262
 
                                          i++);
263
 
 
264
 
        panel_lockdown.disable_force_quit =
265
 
                panel_lockdown_load_bool (&panel_lockdown,
266
 
                                          client,
267
 
                                          DISABLE_FORCE_QUIT_KEY,
268
 
                                          (GConfClientNotifyFunc) disable_force_quit_notify,
269
 
                                          i++);
270
 
 
271
 
        panel_lockdown.disabled_applets =
272
 
                panel_lockdown_load_disabled_applets (&panel_lockdown,
273
 
                                                      client,
274
 
                                                      i++);
275
 
 
276
 
        g_assert (i == N_LISTENERS);
277
 
 
278
 
        panel_lockdown.initialized = TRUE;
279
 
}
280
 
 
281
 
void
282
 
panel_lockdown_finalize (void)
283
 
{
284
 
        GConfClient *client;
285
 
        GSList      *l;
286
 
        int          i;
287
 
 
288
 
        g_assert (panel_lockdown.initialized != FALSE);
289
 
 
290
 
        client = panel_gconf_get_client ();
291
 
 
292
 
        for (l = panel_lockdown.disabled_applets; l; l = l->next)
293
 
                g_free (l->data);
294
 
        g_slist_free (panel_lockdown.disabled_applets);
295
 
        panel_lockdown.disabled_applets = NULL;
296
 
 
297
 
        for (i = 0; i < N_LISTENERS; i++) {
298
 
                if (panel_lockdown.listeners [i])
299
 
                        gconf_client_notify_remove (client,
300
 
                                                    panel_lockdown.listeners [i]);
301
 
                panel_lockdown.listeners [i] = 0;
302
 
        }
303
 
 
304
 
        gconf_client_remove_dir (client,
305
 
                                 PANEL_GLOBAL_LOCKDOWN_DIR,
306
 
                                 NULL);
307
 
 
308
 
        gconf_client_remove_dir (client,
309
 
                                 DESKTOP_GNOME_LOCKDOWN_DIR,
310
 
                                 NULL);
311
 
 
312
 
        for (l = panel_lockdown.closures; l; l = l->next)
313
 
                g_closure_unref (l->data);
314
 
        g_slist_free (panel_lockdown.closures);
315
 
        panel_lockdown.closures = NULL;
316
 
 
317
 
        panel_lockdown.initialized = FALSE;
318
 
}
319
 
 
320
 
gboolean
321
 
panel_lockdown_get_locked_down (void)
322
 
{
323
 
        g_assert (panel_lockdown.initialized != FALSE);
324
 
 
325
 
        return panel_lockdown.locked_down;
326
 
}
327
 
 
328
 
gboolean
329
 
panel_lockdown_get_disable_command_line (void)
330
 
{
331
 
        g_assert (panel_lockdown.initialized != FALSE);
332
 
 
333
 
        return panel_lockdown.disable_command_line;
334
 
}
335
 
 
336
 
gboolean
337
 
panel_lockdown_get_disable_lock_screen (void)
338
 
{
339
 
        g_assert (panel_lockdown.initialized != FALSE);
340
 
 
341
 
        return panel_lockdown.disable_lock_screen;
342
 
}
343
 
 
344
 
gboolean
345
 
panel_lockdown_get_disable_log_out (void)
346
 
{
347
 
        g_assert (panel_lockdown.initialized != FALSE);
348
 
 
349
 
        return panel_lockdown.disable_log_out;
350
 
}
351
 
 
352
 
gboolean
353
 
panel_lockdown_get_disable_force_quit (void)
354
 
{
355
 
        g_assert (panel_lockdown.initialized != FALSE);
356
 
 
357
 
        return panel_lockdown.disable_force_quit;
358
 
}
359
 
 
360
 
gboolean
361
 
panel_lockdown_is_applet_disabled (const char *iid)
362
 
{
363
 
        GSList *l;
364
 
 
365
 
        g_assert (panel_lockdown.initialized != FALSE);
366
 
 
367
 
        for (l = panel_lockdown.disabled_applets; l; l = l->next)
368
 
                if (!strcmp (l->data, iid))
 
32
struct _PanelLockdownPrivate {
 
33
        GSettings *desktop_settings;
 
34
        GSettings *panel_settings;
 
35
 
 
36
        /* desktop-wide */
 
37
        gboolean   disable_command_line;
 
38
        gboolean   disable_lock_screen;
 
39
        gboolean   disable_log_out;
 
40
        gboolean   disable_switch_user;
 
41
 
 
42
        /* panel-specific */
 
43
        gboolean   panels_locked_down;
 
44
        gboolean   disable_force_quit;
 
45
        char     **disabled_applets;
 
46
};
 
47
 
 
48
enum {
 
49
        PROP_0,
 
50
        PROP_DISABLE_COMMAND_LINE,
 
51
        PROP_DISABLE_LOCK_SCREEN,
 
52
        PROP_DISABLE_LOG_OUT,
 
53
        PROP_DISABLE_SWITCH_USER,
 
54
        PROP_PANELS_LOCKED_DOWN,
 
55
        PROP_DISABLE_FORCE_QUIT
 
56
};
 
57
 
 
58
G_DEFINE_TYPE (PanelLockdown, panel_lockdown, G_TYPE_OBJECT);
 
59
 
 
60
static void
 
61
_panel_lockdown_disabled_applets_changed (GSettings     *settings,
 
62
                                          char          *key,
 
63
                                          PanelLockdown *lockdown)
 
64
{
 
65
        if (lockdown->priv->disabled_applets)
 
66
                g_strfreev (lockdown->priv->disabled_applets);
 
67
        lockdown->priv->disabled_applets = g_settings_get_strv (lockdown->priv->panel_settings,
 
68
                                                                PANEL_LOCKDOWN_DISABLED_APPLETS_KEY);
 
69
}
 
70
 
 
71
static GObject *
 
72
panel_lockdown_constructor (GType                  type,
 
73
                            guint                  n_construct_properties,
 
74
                            GObjectConstructParam *construct_properties)
 
75
{
 
76
        GObject       *obj;
 
77
        PanelLockdown *lockdown;
 
78
 
 
79
        obj = G_OBJECT_CLASS (panel_lockdown_parent_class)->constructor (type,
 
80
                                                                         n_construct_properties,
 
81
                                                                         construct_properties);
 
82
 
 
83
        lockdown = PANEL_LOCKDOWN (obj);
 
84
 
 
85
        lockdown->priv->desktop_settings = g_settings_new (PANEL_DESKTOP_LOCKDOWN_SCHEMA);
 
86
        lockdown->priv->panel_settings = g_settings_new (PANEL_LOCKDOWN_SCHEMA);
 
87
 
 
88
        g_settings_bind (lockdown->priv->desktop_settings,
 
89
                         PANEL_DESKTOP_DISABLE_COMMAND_LINE_KEY,
 
90
                         lockdown,
 
91
                         "disable-command-line",
 
92
                         G_SETTINGS_BIND_GET);
 
93
 
 
94
        g_settings_bind (lockdown->priv->desktop_settings,
 
95
                         PANEL_DESKTOP_DISABLE_LOCK_SCREEN_KEY,
 
96
                         lockdown,
 
97
                         "disable-lock-screen",
 
98
                         G_SETTINGS_BIND_GET);
 
99
 
 
100
        g_settings_bind (lockdown->priv->desktop_settings,
 
101
                         PANEL_DESKTOP_DISABLE_LOG_OUT_KEY,
 
102
                         lockdown,
 
103
                         "disable-log-out",
 
104
                         G_SETTINGS_BIND_GET);
 
105
 
 
106
        g_settings_bind (lockdown->priv->desktop_settings,
 
107
                         PANEL_DESKTOP_DISABLE_SWITCH_USER_KEY,
 
108
                         lockdown,
 
109
                         "disable-switch-user",
 
110
                         G_SETTINGS_BIND_GET);
 
111
 
 
112
        g_settings_bind (lockdown->priv->panel_settings,
 
113
                         PANEL_LOCKDOWN_COMPLETE_LOCKDOWN_KEY,
 
114
                         lockdown,
 
115
                         "panels-locked-down",
 
116
                         G_SETTINGS_BIND_GET);
 
117
 
 
118
        g_settings_bind (lockdown->priv->panel_settings,
 
119
                         PANEL_LOCKDOWN_DISABLE_FORCE_QUIT_KEY,
 
120
                         lockdown,
 
121
                         "disable-force-quit",
 
122
                         G_SETTINGS_BIND_GET);
 
123
 
 
124
        g_signal_connect (lockdown->priv->panel_settings,
 
125
                          "changed::"PANEL_LOCKDOWN_DISABLED_APPLETS_KEY,
 
126
                          G_CALLBACK (_panel_lockdown_disabled_applets_changed),
 
127
                          lockdown);
 
128
 
 
129
        _panel_lockdown_disabled_applets_changed (lockdown->priv->panel_settings,
 
130
                                                  PANEL_LOCKDOWN_DISABLED_APPLETS_KEY,
 
131
                                                  lockdown);
 
132
 
 
133
        return obj;
 
134
}
 
135
 
 
136
static void
 
137
_panel_lockdown_set_property_helper (PanelLockdown *lockdown,
 
138
                                     gboolean      *field,
 
139
                                     const GValue  *value,
 
140
                                     const char    *property)
 
141
{
 
142
        gboolean new;
 
143
 
 
144
        new = g_value_get_boolean (value);
 
145
        if (new == *field)
 
146
                return;
 
147
 
 
148
        *field = new;
 
149
        g_object_notify (G_OBJECT (lockdown), property);
 
150
}
 
151
 
 
152
static void
 
153
panel_lockdown_set_property (GObject      *object,
 
154
                             guint         prop_id,
 
155
                             const GValue *value,
 
156
                             GParamSpec   *pspec)
 
157
{
 
158
        PanelLockdown *lockdown;
 
159
 
 
160
        g_return_if_fail (PANEL_IS_LOCKDOWN (object));
 
161
 
 
162
        lockdown = PANEL_LOCKDOWN (object);
 
163
 
 
164
        switch (prop_id) {
 
165
        case PROP_DISABLE_COMMAND_LINE:
 
166
                _panel_lockdown_set_property_helper (lockdown,
 
167
                                                     &lockdown->priv->disable_command_line,
 
168
                                                     value,
 
169
                                                     "disable-command-line");
 
170
                break;
 
171
        case PROP_DISABLE_LOCK_SCREEN:
 
172
                _panel_lockdown_set_property_helper (lockdown,
 
173
                                                     &lockdown->priv->disable_lock_screen,
 
174
                                                     value,
 
175
                                                     "disable-lock-screen");
 
176
                break;
 
177
        case PROP_DISABLE_LOG_OUT:
 
178
                _panel_lockdown_set_property_helper (lockdown,
 
179
                                                     &lockdown->priv->disable_log_out,
 
180
                                                     value,
 
181
                                                     "disable-log-out");
 
182
                break;
 
183
        case PROP_DISABLE_SWITCH_USER:
 
184
                _panel_lockdown_set_property_helper (lockdown,
 
185
                                                     &lockdown->priv->disable_switch_user,
 
186
                                                     value,
 
187
                                                     "disable-switch-user");
 
188
                break;
 
189
        case PROP_PANELS_LOCKED_DOWN:
 
190
                _panel_lockdown_set_property_helper (lockdown,
 
191
                                                     &lockdown->priv->panels_locked_down,
 
192
                                                     value,
 
193
                                                     "panels-locked-down");
 
194
                break;
 
195
        case PROP_DISABLE_FORCE_QUIT:
 
196
                _panel_lockdown_set_property_helper (lockdown,
 
197
                                                     &lockdown->priv->disable_force_quit,
 
198
                                                     value,
 
199
                                                     "disable-force-quit");
 
200
                break;
 
201
        default:
 
202
                G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
 
203
                break;
 
204
        }
 
205
}
 
206
 
 
207
static void
 
208
panel_lockdown_get_property (GObject    *object,
 
209
                             guint       prop_id,
 
210
                             GValue     *value,
 
211
                             GParamSpec *pspec)
 
212
{
 
213
        PanelLockdown *lockdown;
 
214
 
 
215
        g_return_if_fail (PANEL_IS_LOCKDOWN (object));
 
216
 
 
217
        lockdown = PANEL_LOCKDOWN (object);
 
218
 
 
219
        switch (prop_id) {
 
220
        case PROP_DISABLE_COMMAND_LINE:
 
221
                g_value_set_boolean (value, lockdown->priv->disable_command_line);
 
222
                break;
 
223
        case PROP_DISABLE_LOCK_SCREEN:
 
224
                g_value_set_boolean (value, lockdown->priv->disable_lock_screen);
 
225
                break;
 
226
        case PROP_DISABLE_LOG_OUT:
 
227
                g_value_set_boolean (value, lockdown->priv->disable_log_out);
 
228
                break;
 
229
        case PROP_DISABLE_SWITCH_USER:
 
230
                g_value_set_boolean (value, lockdown->priv->disable_switch_user);
 
231
                break;
 
232
        case PROP_PANELS_LOCKED_DOWN:
 
233
                g_value_set_boolean (value, lockdown->priv->panels_locked_down);
 
234
                break;
 
235
        case PROP_DISABLE_FORCE_QUIT:
 
236
                g_value_set_boolean (value, lockdown->priv->disable_force_quit);
 
237
                break;
 
238
        default:
 
239
                G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
 
240
                break;
 
241
        }
 
242
}
 
243
 
 
244
static void
 
245
panel_lockdown_dispose (GObject *object)
 
246
{
 
247
        PanelLockdown *lockdown;
 
248
 
 
249
        lockdown = PANEL_LOCKDOWN (object);
 
250
 
 
251
        if (lockdown->priv->desktop_settings)
 
252
                g_object_unref (lockdown->priv->desktop_settings);
 
253
        lockdown->priv->desktop_settings = NULL;
 
254
 
 
255
        if (lockdown->priv->panel_settings)
 
256
                g_object_unref (lockdown->priv->panel_settings);
 
257
        lockdown->priv->panel_settings = NULL;
 
258
 
 
259
        if (lockdown->priv->disabled_applets)
 
260
                g_strfreev (lockdown->priv->disabled_applets);
 
261
        lockdown->priv->disabled_applets = NULL;
 
262
 
 
263
        G_OBJECT_CLASS (panel_lockdown_parent_class)->dispose (object);
 
264
}
 
265
 
 
266
static void
 
267
panel_lockdown_init (PanelLockdown *lockdown)
 
268
{
 
269
        lockdown->priv = G_TYPE_INSTANCE_GET_PRIVATE (lockdown,
 
270
                                                      PANEL_TYPE_LOCKDOWN,
 
271
                                                      PanelLockdownPrivate);
 
272
}
 
273
 
 
274
static void
 
275
panel_lockdown_class_init (PanelLockdownClass *lockdown_class)
 
276
{
 
277
        GObjectClass *gobject_class;
 
278
 
 
279
        gobject_class = G_OBJECT_CLASS (lockdown_class);
 
280
 
 
281
        gobject_class->constructor  = panel_lockdown_constructor;
 
282
        gobject_class->set_property = panel_lockdown_set_property;
 
283
        gobject_class->get_property = panel_lockdown_get_property;
 
284
        gobject_class->dispose      = panel_lockdown_dispose;
 
285
 
 
286
        g_object_class_install_property (
 
287
                gobject_class,
 
288
                PROP_DISABLE_COMMAND_LINE,
 
289
                g_param_spec_boolean (
 
290
                        "disable-command-line",
 
291
                        "Disable command line",
 
292
                        "Whether command line is disabled or not",
 
293
                        TRUE,
 
294
                        G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));
 
295
 
 
296
        g_object_class_install_property (
 
297
                gobject_class,
 
298
                PROP_DISABLE_LOCK_SCREEN,
 
299
                g_param_spec_boolean (
 
300
                        "disable-lock-screen",
 
301
                        "Disable lock screen",
 
302
                        "Whether lock screen is disabled or not",
 
303
                        TRUE,
 
304
                        G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));
 
305
 
 
306
        g_object_class_install_property (
 
307
                gobject_class,
 
308
                PROP_DISABLE_LOG_OUT,
 
309
                g_param_spec_boolean (
 
310
                        "disable-log-out",
 
311
                        "Disable log out",
 
312
                        "Whether log out is disabled or not",
 
313
                        TRUE,
 
314
                        G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));
 
315
 
 
316
        g_object_class_install_property (
 
317
                gobject_class,
 
318
                PROP_DISABLE_SWITCH_USER,
 
319
                g_param_spec_boolean (
 
320
                        "disable-switch-user",
 
321
                        "Disable user switching",
 
322
                        "Whether user switching is disabled or not",
 
323
                        TRUE,
 
324
                        G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));
 
325
 
 
326
        g_object_class_install_property (
 
327
                gobject_class,
 
328
                PROP_PANELS_LOCKED_DOWN,
 
329
                g_param_spec_boolean (
 
330
                        "panels-locked-down",
 
331
                        "Full locked down of panels",
 
332
                        "Whether panels are fully locked down or not",
 
333
                        TRUE,
 
334
                        G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));
 
335
 
 
336
        g_object_class_install_property (
 
337
                gobject_class,
 
338
                PROP_DISABLE_FORCE_QUIT,
 
339
                g_param_spec_boolean (
 
340
                        "disable-force-quit",
 
341
                        "Disable force quit",
 
342
                        "Whether force quit is disabled or not",
 
343
                        TRUE,
 
344
                        G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));
 
345
 
 
346
        g_type_class_add_private (lockdown_class,
 
347
                                  sizeof (PanelLockdownPrivate));
 
348
}
 
349
 
 
350
gboolean
 
351
panel_lockdown_is_applet_disabled (PanelLockdown *lockdown,
 
352
                                   const char    *iid)
 
353
{
 
354
        int i;
 
355
 
 
356
        g_return_val_if_fail (PANEL_IS_LOCKDOWN (lockdown), TRUE);
 
357
 
 
358
        for (i = 0; lockdown->priv->disabled_applets[i] != NULL; i++)
 
359
                if (g_strcmp0 (lockdown->priv->disabled_applets[i], iid) == 0)
369
360
                        return TRUE;
370
361
 
371
362
        return FALSE;
372
363
}
373
364
 
374
 
static GClosure *
375
 
panel_lockdown_notify_find (GSList    *closures,
376
 
                            GCallback  callback_func,
377
 
                            gpointer   user_data)
378
 
{
379
 
        GSList *l;
380
 
 
381
 
        for (l = closures; l; l = l->next) {
382
 
                GCClosure *cclosure = l->data;
383
 
                GClosure  *closure  = l->data;
384
 
 
385
 
                if (closure->data == user_data &&
386
 
                    cclosure->callback == callback_func)
387
 
                        return closure;
 
365
gboolean
 
366
panel_lockdown_get_disable_command_line (PanelLockdown *lockdown)
 
367
{
 
368
        g_return_val_if_fail (PANEL_IS_LOCKDOWN (lockdown), TRUE);
 
369
 
 
370
        return lockdown->priv->disable_command_line;
 
371
}
 
372
 
 
373
gboolean
 
374
panel_lockdown_get_disable_lock_screen (PanelLockdown *lockdown)
 
375
{
 
376
        g_return_val_if_fail (PANEL_IS_LOCKDOWN (lockdown), TRUE);
 
377
 
 
378
        return lockdown->priv->disable_lock_screen;
 
379
}
 
380
 
 
381
gboolean
 
382
panel_lockdown_get_disable_log_out (PanelLockdown *lockdown)
 
383
{
 
384
        g_return_val_if_fail (PANEL_IS_LOCKDOWN (lockdown), TRUE);
 
385
 
 
386
        return lockdown->priv->disable_log_out;
 
387
}
 
388
 
 
389
gboolean
 
390
panel_lockdown_get_disable_switch_user (PanelLockdown *lockdown)
 
391
{
 
392
        g_return_val_if_fail (PANEL_IS_LOCKDOWN (lockdown), TRUE);
 
393
 
 
394
        return lockdown->priv->disable_switch_user;
 
395
}
 
396
 
 
397
gboolean
 
398
panel_lockdown_get_panels_locked_down (PanelLockdown *lockdown)
 
399
{
 
400
        g_return_val_if_fail (PANEL_IS_LOCKDOWN (lockdown), TRUE);
 
401
 
 
402
        return lockdown->priv->panels_locked_down;
 
403
}
 
404
 
 
405
gboolean
 
406
panel_lockdown_get_disable_force_quit (PanelLockdown *lockdown)
 
407
{
 
408
        g_return_val_if_fail (PANEL_IS_LOCKDOWN (lockdown), TRUE);
 
409
 
 
410
        return lockdown->priv->disable_force_quit;
 
411
}
 
412
 
 
413
typedef struct {
 
414
        PanelLockdown       *lockdown;
 
415
        PanelLockdownNotify  callback;
 
416
        gpointer             callback_data;
 
417
        guint                handler_id;
 
418
} PanelLockdownNotifyData;
 
419
 
 
420
static void
 
421
_panel_lockdown_notify_data_destroy (gpointer data)
 
422
{
 
423
        PanelLockdownNotifyData *notify_data = data;
 
424
 
 
425
        g_signal_handler_disconnect (notify_data->lockdown,
 
426
                                     notify_data->handler_id);
 
427
 
 
428
        g_slice_free (PanelLockdownNotifyData, notify_data);
 
429
}
 
430
 
 
431
static void
 
432
panel_lockdown_on_notify_notified (GObject    *gobject,
 
433
                                   GParamSpec *pspec,
 
434
                                   gpointer    user_data)
 
435
{
 
436
        PanelLockdownNotifyData *notify_data = user_data;
 
437
 
 
438
        g_assert (notify_data->callback != NULL);
 
439
        g_assert ((gpointer) notify_data->lockdown == (gpointer) gobject);
 
440
 
 
441
        notify_data->callback (notify_data->lockdown,
 
442
                               notify_data->callback_data);
 
443
}
 
444
 
 
445
/* An object can only call this once per property.
 
446
 * User NULL property to notify for all lockdown changes. (except disabled_applets) */
 
447
void
 
448
panel_lockdown_on_notify (PanelLockdown       *lockdown,
 
449
                          const char          *property,
 
450
                          GObject             *object_while_alive,
 
451
                          PanelLockdownNotify  callback,
 
452
                          gpointer             callback_data)
 
453
{
 
454
        PanelLockdownNotifyData *notify_data;
 
455
        char *key;
 
456
        char *signal_name;
 
457
 
 
458
        g_return_if_fail (PANEL_IS_LOCKDOWN (lockdown));
 
459
        g_return_if_fail (G_IS_OBJECT (object_while_alive));
 
460
        g_return_if_fail (callback != NULL);
 
461
 
 
462
        notify_data = g_slice_new0 (PanelLockdownNotifyData);
 
463
 
 
464
        notify_data->lockdown      = lockdown;
 
465
        notify_data->callback      = callback;
 
466
        notify_data->callback_data = callback_data;
 
467
        notify_data->handler_id    = 0;
 
468
 
 
469
        if (property)
 
470
                key = g_strdup_printf ("panel-lockdown-%s", property);
 
471
        else
 
472
                key = g_strdup_printf ("panel-lockdown");
 
473
        g_object_set_data_full (object_while_alive, key,
 
474
                                notify_data,
 
475
                                _panel_lockdown_notify_data_destroy);
 
476
        g_free (key);
 
477
 
 
478
        if (property)
 
479
                signal_name = g_strdup_printf ("notify::%s", property);
 
480
        else
 
481
                signal_name = g_strdup_printf ("notify");
 
482
        notify_data->handler_id = g_signal_connect (lockdown, signal_name,
 
483
                                                    G_CALLBACK (panel_lockdown_on_notify_notified),
 
484
                                                    notify_data);
 
485
        g_free (signal_name);
 
486
}
 
487
 
 
488
PanelLockdown *
 
489
panel_lockdown_get (void)
 
490
{
 
491
        static PanelLockdown *shared_lockdown = NULL;
 
492
 
 
493
        if (shared_lockdown == NULL) {
 
494
                shared_lockdown = g_object_new (PANEL_TYPE_LOCKDOWN, NULL);
 
495
                panel_cleanup_register (panel_cleanup_unref_and_nullify,
 
496
                                        &shared_lockdown);
388
497
        }
389
498
 
390
 
        return NULL;
391
 
}
392
 
 
393
 
static void
394
 
marshal_user_data (GClosure     *closure,
395
 
                   GValue       *return_value,
396
 
                   guint         n_param_values,
397
 
                   const GValue *param_values,
398
 
                   gpointer      invocation_hint,
399
 
                   gpointer      marshal_data)
400
 
{
401
 
        GCClosure *cclosure = (GCClosure*) closure;
402
 
 
403
 
        g_return_if_fail (cclosure->callback != NULL);
404
 
        g_return_if_fail (n_param_values == 0);
405
 
 
406
 
        ((void (*) (gpointer *))cclosure->callback) (closure->data);
407
 
}
408
 
 
409
 
void
410
 
panel_lockdown_notify_add (GCallback callback_func,
411
 
                           gpointer  user_data)
412
 
{
413
 
        GClosure *closure;
414
 
 
415
 
        g_assert (panel_lockdown_notify_find (panel_lockdown.closures,
416
 
                                              callback_func,
417
 
                                              user_data) == NULL);
418
 
 
419
 
        closure = g_cclosure_new (callback_func, user_data, NULL);
420
 
        g_closure_set_marshal (closure, marshal_user_data);
421
 
 
422
 
        panel_lockdown.closures = g_slist_append (panel_lockdown.closures,
423
 
                                                  closure);
424
 
}
425
 
 
426
 
void
427
 
panel_lockdown_notify_remove (GCallback callback_func,
428
 
                              gpointer  user_data)
429
 
{
430
 
        GClosure *closure;
431
 
 
432
 
        closure = panel_lockdown_notify_find (panel_lockdown.closures,
433
 
                                              callback_func,
434
 
                                              user_data);
435
 
 
436
 
        g_assert (closure != NULL);
437
 
 
438
 
        panel_lockdown.closures = g_slist_remove (panel_lockdown.closures,
439
 
                                                  closure);
440
 
 
441
 
        g_closure_unref (closure);
 
499
        return shared_lockdown;
 
500
}
 
501
 
 
502
gboolean
 
503
panel_lockdown_get_disable_command_line_s (void)
 
504
{
 
505
        return panel_lockdown_get_disable_command_line (panel_lockdown_get ());
 
506
}
 
507
 
 
508
gboolean
 
509
panel_lockdown_get_disable_lock_screen_s (void)
 
510
{
 
511
        return panel_lockdown_get_disable_lock_screen (panel_lockdown_get ());
 
512
}
 
513
 
 
514
gboolean
 
515
panel_lockdown_get_disable_log_out_s (void)
 
516
{
 
517
        return panel_lockdown_get_disable_log_out (panel_lockdown_get ());
 
518
}
 
519
 
 
520
gboolean
 
521
panel_lockdown_get_disable_switch_user_s (void)
 
522
{
 
523
        return panel_lockdown_get_disable_switch_user (panel_lockdown_get ());
 
524
}
 
525
 
 
526
gboolean
 
527
panel_lockdown_get_panels_locked_down_s (void)
 
528
{
 
529
        return panel_lockdown_get_panels_locked_down (panel_lockdown_get ());
 
530
}
 
531
 
 
532
gboolean
 
533
panel_lockdown_get_not_panels_locked_down_s (void)
 
534
{
 
535
        return !panel_lockdown_get_panels_locked_down (panel_lockdown_get ());
 
536
}
 
537
 
 
538
gboolean
 
539
panel_lockdown_get_disable_force_quit_s (void)
 
540
{
 
541
        return panel_lockdown_get_disable_force_quit (panel_lockdown_get ());
442
542
}