~ubuntu-branches/ubuntu/precise/indicator-session/precise

« back to all changes in this revision

Viewing changes to .pc/01-remove-dead-gss-handling.patch/src/lock-helper.c

  • Committer: Package Import Robot
  • Author(s): Marc Deslauriers
  • Date: 2012-01-28 16:56:41 UTC
  • Revision ID: package-import@ubuntu.com-20120128165641-045olyystq887flg
Tags: 0.3.7.1-1ubuntu2
debian/patches/01-remove-dead-gss-handling.patch: Remove dead GSS
throttling code. Let gnome-settings-daemon handle locking the screen
when UPower requests it.

Show diffs side-by-side

added added

removed removed

Lines of Context:
 
1
/*
 
2
A small helper for locking the screen.
 
3
 
 
4
Copyright 2009 Canonical Ltd.
 
5
 
 
6
Authors:
 
7
    Ted Gould <ted@canonical.com>
 
8
 
 
9
This program is free software: you can redistribute it and/or modify it 
 
10
under the terms of the GNU General Public License version 3, as published 
 
11
by the Free Software Foundation.
 
12
 
 
13
This program is distributed in the hope that it will be useful, but 
 
14
WITHOUT ANY WARRANTY; without even the implied warranties of 
 
15
MERCHANTABILITY, SATISFACTORY QUALITY, or FITNESS FOR A PARTICULAR 
 
16
PURPOSE.  See the GNU General Public License for more details.
 
17
 
 
18
You should have received a copy of the GNU General Public License along 
 
19
with this program.  If not, see <http://www.gnu.org/licenses/>.
 
20
*/
 
21
 
 
22
#include <glib/gi18n.h>
 
23
#include <gio/gio.h>
 
24
#include <dbus/dbus-glib.h>
 
25
#include "lock-helper.h"
 
26
 
 
27
#define SCREENSAVER_SCHEMA            "org.gnome.desktop.screensaver"
 
28
#define SCREENSAVER_LOCK_ENABLED_KEY  "lock-enabled"
 
29
 
 
30
static DBusGProxy * gss_proxy = NULL;
 
31
static GMainLoop * gss_mainloop = NULL;
 
32
static guint cookie = 0;
 
33
static DBusGProxyCall * cookie_call = NULL;
 
34
 
 
35
static gboolean is_guest = FALSE;
 
36
 
 
37
static GSettings * settings = NULL;
 
38
 
 
39
void build_gss_proxy (void);
 
40
 
 
41
/* Checks to see if there is an error and reports
 
42
   it.  Not much else we can do. */
 
43
static void
 
44
unthrottle_return (DBusGProxy * proxy, DBusGProxyCall * call, gpointer data)
 
45
{
 
46
        GError * error = NULL;
 
47
        dbus_g_proxy_end_call(proxy, call, &error,
 
48
                              G_TYPE_INVALID);
 
49
 
 
50
        if (error != NULL) {
 
51
                g_warning("Unable to unthrottle: %s", error->message);
 
52
        }
 
53
        return;
 
54
}
 
55
 
 
56
/* Sends an unthrottle if we're throttled. */
 
57
void
 
58
screensaver_unthrottle (void)
 
59
{
 
60
        g_return_if_fail(cookie != 0);
 
61
 
 
62
        build_gss_proxy();
 
63
        g_return_if_fail(gss_proxy != NULL);
 
64
 
 
65
        dbus_g_proxy_begin_call(gss_proxy, "UnThrottle",
 
66
                                unthrottle_return, NULL,
 
67
                                NULL,
 
68
                                G_TYPE_UINT, cookie,
 
69
                                G_TYPE_INVALID);
 
70
 
 
71
        cookie = 0;
 
72
        return;
 
73
}
 
74
 
 
75
/* Gets there return cookie from the throttle command
 
76
   and sets things valid */
 
77
static void
 
78
throttle_return (DBusGProxy * proxy, DBusGProxyCall * call, gpointer data)
 
79
{
 
80
        GError * error = NULL;
 
81
        cookie_call = NULL;
 
82
 
 
83
        dbus_g_proxy_end_call(proxy, call, &error,
 
84
                              G_TYPE_UINT, &cookie,
 
85
                              G_TYPE_INVALID);
 
86
 
 
87
        if (error != NULL) {
 
88
                g_warning("Unable to throttle the screensaver: %s", error->message);
 
89
                return;
 
90
        }
 
91
 
 
92
 
 
93
        if (cookie == 0) {
 
94
                g_warning("We didn't get a throttle cookie!");
 
95
        }
 
96
 
 
97
        return;
 
98
}
 
99
 
 
100
/* Throttling the screensaver by using the screen saver
 
101
   command. */
 
102
void
 
103
screensaver_throttle (gchar * reason)
 
104
{
 
105
        g_return_if_fail(cookie_call == NULL);
 
106
        g_return_if_fail(will_lock_screen());
 
107
 
 
108
        if (cookie != 0) {
 
109
                screensaver_unthrottle();
 
110
        }
 
111
 
 
112
        build_gss_proxy();
 
113
        g_return_if_fail(gss_proxy != NULL);
 
114
 
 
115
        cookie_call = dbus_g_proxy_begin_call(gss_proxy, "Throttle",
 
116
                                              throttle_return, NULL,
 
117
                                              NULL,
 
118
                                              G_TYPE_STRING, "Session Menu",
 
119
                                              G_TYPE_STRING, reason,
 
120
                                              G_TYPE_INVALID);
 
121
 
 
122
        return;
 
123
}
 
124
 
 
125
/* This is our logic on whether the screen should be locked
 
126
   or not.  It effects everything else. */
 
127
gboolean
 
128
will_lock_screen (void)
 
129
{
 
130
        if (is_guest) {
 
131
                return FALSE;
 
132
        }
 
133
 
 
134
        if (settings == NULL) {
 
135
                settings = g_settings_new (SCREENSAVER_SCHEMA);
 
136
        }
 
137
 
 
138
        return g_settings_get_boolean (settings, SCREENSAVER_LOCK_ENABLED_KEY);
 
139
}
 
140
 
 
141
/* When the screensave go active, if we've got a mainloop
 
142
   running we should quit it. */
 
143
static void
 
144
gss_active_changed (DBusGProxy * proxy, gboolean active, gpointer data)
 
145
{
 
146
        if (active && gss_mainloop != NULL) {
 
147
                g_main_loop_quit(gss_mainloop);
 
148
        }
 
149
 
 
150
        return;
 
151
}
 
152
 
 
153
static gboolean
 
154
get_greeter_mode (void)
 
155
{
 
156
        const gchar *var;
 
157
        var = g_getenv("INDICATOR_GREETER_MODE");
 
158
        return (g_strcmp0(var, "1") == 0);
 
159
}
 
160
 
 
161
/* Build the gss proxy and set up it's signals */
 
162
void
 
163
build_gss_proxy (void)
 
164
{
 
165
        if (gss_proxy == NULL) {
 
166
                if (get_greeter_mode ())
 
167
                        return; /* Don't start/lock the screensaver from the login screen */
 
168
 
 
169
                DBusGConnection * session_bus = dbus_g_bus_get(DBUS_BUS_SESSION, NULL);
 
170
                g_return_if_fail(session_bus != NULL);
 
171
 
 
172
                gss_proxy = dbus_g_proxy_new_for_name(session_bus,
 
173
                                                      "org.gnome.ScreenSaver",
 
174
                                                      "/",
 
175
                                                      "org.gnome.ScreenSaver");
 
176
                g_return_if_fail(gss_proxy != NULL);
 
177
 
 
178
                dbus_g_proxy_add_signal(gss_proxy, "ActiveChanged", G_TYPE_BOOLEAN, G_TYPE_INVALID);
 
179
                dbus_g_proxy_connect_signal(gss_proxy, "ActiveChanged", G_CALLBACK(gss_active_changed), NULL, NULL);
 
180
        }
 
181
 
 
182
        return;
 
183
}
 
184
 
 
185
/* This is a timeout, we only want to wait for the screen to
 
186
   lock for a little bit, but not forever. */
 
187
static gboolean
 
188
activate_timeout (gpointer data)
 
189
{
 
190
        /* Clear the ID for the timeout */
 
191
        guint * address = (guint *)data;
 
192
        *address = 0;
 
193
 
 
194
        /* Quit the mainloop */
 
195
        if (gss_mainloop != NULL) {
 
196
                g_main_loop_quit(gss_mainloop);
 
197
        }
 
198
        
 
199
        return FALSE;
 
200
}
 
201
 
 
202
/* A fun little function to actually lock the screen.  If,
 
203
   that's what you want, let's do it! */
 
204
void
 
205
lock_screen (DbusmenuMenuitem * mi, guint timestamp, gpointer data)
 
206
{
 
207
        g_debug("Lock Screen");
 
208
 
 
209
        build_gss_proxy();
 
210
        g_return_if_fail(gss_proxy != NULL);
 
211
 
 
212
        dbus_g_proxy_call_no_reply(gss_proxy,
 
213
                                   "Lock",
 
214
                                   G_TYPE_INVALID,
 
215
                                   G_TYPE_INVALID);
 
216
 
 
217
        if (gss_mainloop == NULL) {
 
218
                gss_mainloop = g_main_loop_new(NULL, FALSE);
 
219
        }
 
220
 
 
221
        guint timer = g_timeout_add_seconds(1, activate_timeout, &timer);
 
222
 
 
223
        g_main_loop_run(gss_mainloop);
 
224
 
 
225
        if (timer != 0) {
 
226
                g_source_remove(timer);
 
227
        }
 
228
 
 
229
        return;
 
230
}
 
231
 
 
232
/* Do what it takes to make the lock screen function work
 
233
   and be happy. */
 
234
gboolean
 
235
lock_screen_setup (gpointer data)
 
236
{
 
237
        if (!g_strcmp0(g_get_user_name(), "guest")) {
 
238
                is_guest = TRUE;
 
239
        }
 
240
 
 
241
        return FALSE;
 
242
}
 
243