1 /* -*- Mode: C; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 8 -*-
2 *
3 * Copyright (C) 2004-2006 William Jon McCann <mccann@jhu.edu>
4 * Copyright (C) 2012-2021 MATE Developers
5 *
6 * This program is free software; you can redistribute it and/or modify
7 * it under the terms of the GNU General Public License as published by
8 * the Free Software Foundation; either version 2 of the License, or
9 * (at your option) any later version.
10 *
11 * This program is distributed in the hope that it will be useful,
12 * but WITHOUT ANY WARRANTY; without even the implied warranty of
13 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14 * GNU General Public License for more details.
15 *
16 * You should have received a copy of the GNU General Public License
17 * along with this program; if not, write to the Free Software
18 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA.
19 *
20 * Authors: William Jon McCann <mccann@jhu.edu>
21 *
22 */
23
24 #include "config.h"
25
26 #include <string.h>
27
28 #include <glib.h>
29 #include <glib-object.h>
30 #include <gio/gio.h>
31
32 #include "gs-prefs.h"
33
34 static void gs_prefs_finalize (GObject *object);
35
36 #define LOCKDOWN_SETTINGS_SCHEMA "org.mate.lockdown"
37 #define KEY_LOCK_DISABLE "disable-lock-screen"
38 #define KEY_USER_SWITCH_DISABLE "disable-user-switching"
39
40 #define SESSION_SETTINGS_SCHEMA "org.mate.session"
41 #define KEY_IDLE_DELAY "idle-delay"
42
43 #define GSETTINGS_SCHEMA "org.mate.screensaver"
44 #define KEY_IDLE_ACTIVATION_ENABLED "idle-activation-enabled"
45 #define KEY_LOCK_ENABLED "lock-enabled"
46 #define KEY_MODE "mode"
47 #define KEY_POWER_DELAY "power-management-delay"
48 #define KEY_LOCK_DELAY "lock-delay"
49 #define KEY_CYCLE_DELAY "cycle-delay"
50 #define KEY_THEMES "themes"
51 #define KEY_USER_SWITCH_ENABLED "user-switch-enabled"
52 #define KEY_LOGOUT_ENABLED "logout-enabled"
53 #define KEY_LOGOUT_DELAY "logout-delay"
54 #define KEY_LOGOUT_COMMAND "logout-command"
55 #define KEY_KEYBOARD_ENABLED "embedded-keyboard-enabled"
56 #define KEY_KEYBOARD_COMMAND "embedded-keyboard-command"
57 #define KEY_STATUS_MESSAGE_ENABLED "status-message-enabled"
58
59 struct GSPrefsPrivate
60 {
61 GSettings *settings;
62 GSettings *lockdown_settings;
63 GSettings *session_settings;
64 };
65
66 enum
67 {
68 CHANGED,
69 LAST_SIGNAL
70 };
71
72 enum
73 {
74 PROP_0
75 };
76
77 static guint signals [LAST_SIGNAL] = { 0, };
78
G_DEFINE_TYPE_WITH_PRIVATE(GSPrefs,gs_prefs,G_TYPE_OBJECT)79 G_DEFINE_TYPE_WITH_PRIVATE (GSPrefs, gs_prefs, G_TYPE_OBJECT)
80
81 static void
82 gs_prefs_set_property (GObject *object,
83 guint prop_id,
84 const GValue *value,
85 GParamSpec *pspec)
86 {
87 switch (prop_id)
88 {
89 default:
90 G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
91 break;
92 }
93 }
94
95 static void
gs_prefs_get_property(GObject * object,guint prop_id,GValue * value,GParamSpec * pspec)96 gs_prefs_get_property (GObject *object,
97 guint prop_id,
98 GValue *value,
99 GParamSpec *pspec)
100 {
101 switch (prop_id)
102 {
103 default:
104 G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
105 break;
106 }
107 }
108
109 static void
gs_prefs_class_init(GSPrefsClass * klass)110 gs_prefs_class_init (GSPrefsClass *klass)
111 {
112 GObjectClass *object_class = G_OBJECT_CLASS (klass);
113
114 object_class->finalize = gs_prefs_finalize;
115 object_class->get_property = gs_prefs_get_property;
116 object_class->set_property = gs_prefs_set_property;
117
118
119 signals [CHANGED] =
120 g_signal_new ("changed",
121 G_TYPE_FROM_CLASS (object_class),
122 G_SIGNAL_RUN_LAST,
123 G_STRUCT_OFFSET (GSPrefsClass, changed),
124 NULL,
125 NULL,
126 g_cclosure_marshal_VOID__VOID,
127 G_TYPE_NONE,
128 0);
129 }
130
131 static void
_gs_prefs_set_timeout(GSPrefs * prefs,int value)132 _gs_prefs_set_timeout (GSPrefs *prefs,
133 int value)
134 {
135 if (value < 1)
136 value = 10;
137
138 /* pick a reasonable large number for the
139 upper bound */
140 if (value > 480)
141 value = 480;
142
143 prefs->timeout = value * 60000;
144 }
145
146 static void
_gs_prefs_set_power_timeout(GSPrefs * prefs,int value)147 _gs_prefs_set_power_timeout (GSPrefs *prefs,
148 int value)
149 {
150 if (value < 1)
151 value = 60;
152
153 /* pick a reasonable large number for the
154 upper bound */
155 if (value > 480)
156 value = 480;
157
158 /* this value is in seconds - others are in minutes */
159 prefs->power_timeout = value * 1000;
160 }
161
162 static void
_gs_prefs_set_lock_timeout(GSPrefs * prefs,int value)163 _gs_prefs_set_lock_timeout (GSPrefs *prefs,
164 int value)
165 {
166 if (value < 0)
167 value = 0;
168
169 /* pick a reasonable large number for the
170 upper bound */
171 if (value > 480)
172 value = 480;
173
174 prefs->lock_timeout = value * 60000;
175 }
176
177 static void
_gs_prefs_set_cycle_timeout(GSPrefs * prefs,int value)178 _gs_prefs_set_cycle_timeout (GSPrefs *prefs,
179 int value)
180 {
181 if (value < 1)
182 value = 1;
183
184 /* pick a reasonable large number for the
185 upper bound */
186 if (value > 480)
187 value = 480;
188
189 prefs->cycle = value * 60000;
190 }
191
192 static void
_gs_prefs_set_mode(GSPrefs * prefs,gint mode)193 _gs_prefs_set_mode (GSPrefs *prefs,
194 gint mode)
195 {
196 prefs->mode = mode;
197 }
198
199 static void
_gs_prefs_set_themes(GSPrefs * prefs,gchar ** values)200 _gs_prefs_set_themes (GSPrefs *prefs,
201 gchar **values)
202 {
203 guint i;
204 if (prefs->themes)
205 {
206 g_slist_free_full (prefs->themes, g_free);
207 }
208
209 /* take ownership of the list */
210 prefs->themes = NULL;
211 for (i=0; values[i] != NULL; i++)
212 prefs->themes = g_slist_append (prefs->themes, g_strdup (values[i]));
213 }
214
215 static void
_gs_prefs_set_idle_activation_enabled(GSPrefs * prefs,gboolean value)216 _gs_prefs_set_idle_activation_enabled (GSPrefs *prefs,
217 gboolean value)
218 {
219 prefs->idle_activation_enabled = value;
220 }
221
222 static void
_gs_prefs_set_lock_enabled(GSPrefs * prefs,gboolean value)223 _gs_prefs_set_lock_enabled (GSPrefs *prefs,
224 gboolean value)
225 {
226 prefs->lock_enabled = value;
227 }
228
229 static void
_gs_prefs_set_lock_disabled(GSPrefs * prefs,gboolean value)230 _gs_prefs_set_lock_disabled (GSPrefs *prefs,
231 gboolean value)
232 {
233 prefs->lock_disabled = value;
234 }
235
236 static void
_gs_prefs_set_user_switch_disabled(GSPrefs * prefs,gboolean value)237 _gs_prefs_set_user_switch_disabled (GSPrefs *prefs,
238 gboolean value)
239 {
240 prefs->user_switch_disabled = value;
241 }
242
243 static void
_gs_prefs_set_keyboard_enabled(GSPrefs * prefs,gboolean value)244 _gs_prefs_set_keyboard_enabled (GSPrefs *prefs,
245 gboolean value)
246 {
247 prefs->keyboard_enabled = value;
248 }
249
250 static void
_gs_prefs_set_keyboard_command(GSPrefs * prefs,const char * value)251 _gs_prefs_set_keyboard_command (GSPrefs *prefs,
252 const char *value)
253 {
254 g_free (prefs->keyboard_command);
255 prefs->keyboard_command = NULL;
256
257 if (value)
258 {
259 /* FIXME: check command */
260
261 prefs->keyboard_command = g_strdup (value);
262 }
263 }
264
265 static void
_gs_prefs_set_status_message_enabled(GSPrefs * prefs,gboolean enabled)266 _gs_prefs_set_status_message_enabled (GSPrefs *prefs,
267 gboolean enabled)
268 {
269 prefs->status_message_enabled = enabled;
270 }
271
272 static void
_gs_prefs_set_logout_enabled(GSPrefs * prefs,gboolean value)273 _gs_prefs_set_logout_enabled (GSPrefs *prefs,
274 gboolean value)
275 {
276 prefs->logout_enabled = value;
277 }
278
279 static void
_gs_prefs_set_logout_command(GSPrefs * prefs,const char * value)280 _gs_prefs_set_logout_command (GSPrefs *prefs,
281 const char *value)
282 {
283 g_free (prefs->logout_command);
284 prefs->logout_command = NULL;
285
286 if (value)
287 {
288 /* FIXME: check command */
289
290 prefs->logout_command = g_strdup (value);
291 }
292 }
293
294 static void
_gs_prefs_set_logout_timeout(GSPrefs * prefs,int value)295 _gs_prefs_set_logout_timeout (GSPrefs *prefs,
296 int value)
297 {
298 if (value < 0)
299 value = 0;
300
301 /* pick a reasonable large number for the
302 upper bound */
303 if (value > 480)
304 value = 480;
305
306 prefs->logout_timeout = value * 60000;
307 }
308
309 static void
_gs_prefs_set_user_switch_enabled(GSPrefs * prefs,gboolean value)310 _gs_prefs_set_user_switch_enabled (GSPrefs *prefs,
311 gboolean value)
312 {
313 prefs->user_switch_enabled = value;
314 }
315
316 static void
gs_prefs_load_from_settings(GSPrefs * prefs)317 gs_prefs_load_from_settings (GSPrefs *prefs)
318 {
319 glong value;
320 gboolean bvalue;
321 char *string;
322 gchar **strv;
323 gint mode;
324
325 bvalue = g_settings_get_boolean (prefs->priv->settings, KEY_IDLE_ACTIVATION_ENABLED);
326 _gs_prefs_set_idle_activation_enabled (prefs, bvalue);
327
328 bvalue = g_settings_get_boolean (prefs->priv->settings, KEY_LOCK_ENABLED);
329 _gs_prefs_set_lock_enabled (prefs, bvalue);
330
331 bvalue = g_settings_get_boolean (prefs->priv->lockdown_settings, KEY_LOCK_DISABLE);
332 _gs_prefs_set_lock_disabled (prefs, bvalue);
333
334 bvalue = g_settings_get_boolean (prefs->priv->lockdown_settings, KEY_USER_SWITCH_DISABLE);
335 _gs_prefs_set_user_switch_disabled (prefs, bvalue);
336
337 value = g_settings_get_int (prefs->priv->session_settings, KEY_IDLE_DELAY);
338 _gs_prefs_set_timeout (prefs, value);
339
340 value = g_settings_get_int (prefs->priv->settings, KEY_POWER_DELAY);
341 _gs_prefs_set_power_timeout (prefs, value);
342
343 value = g_settings_get_int (prefs->priv->settings, KEY_LOCK_DELAY);
344 _gs_prefs_set_lock_timeout (prefs, value);
345
346 value = g_settings_get_int (prefs->priv->settings, KEY_CYCLE_DELAY);
347 _gs_prefs_set_cycle_timeout (prefs, value);
348
349 mode = g_settings_get_enum (prefs->priv->settings, KEY_MODE);
350 _gs_prefs_set_mode (prefs, mode);
351
352 strv = g_settings_get_strv (prefs->priv->settings, KEY_THEMES);
353 _gs_prefs_set_themes (prefs, strv);
354 g_strfreev (strv);
355
356 /* Embedded keyboard options */
357
358 bvalue = g_settings_get_boolean (prefs->priv->settings, KEY_KEYBOARD_ENABLED);
359 _gs_prefs_set_keyboard_enabled (prefs, bvalue);
360
361 string = g_settings_get_string (prefs->priv->settings, KEY_KEYBOARD_COMMAND);
362 _gs_prefs_set_keyboard_command (prefs, string);
363 g_free (string);
364
365 bvalue = g_settings_get_boolean (prefs->priv->settings, KEY_STATUS_MESSAGE_ENABLED);
366 _gs_prefs_set_status_message_enabled (prefs, bvalue);
367
368 /* Logout options */
369
370 bvalue = g_settings_get_boolean (prefs->priv->settings, KEY_LOGOUT_ENABLED);
371 _gs_prefs_set_logout_enabled (prefs, bvalue);
372
373 string = g_settings_get_string (prefs->priv->settings, KEY_LOGOUT_COMMAND);
374 _gs_prefs_set_logout_command (prefs, string);
375 g_free (string);
376
377 value = g_settings_get_int (prefs->priv->settings, KEY_LOGOUT_DELAY);
378 _gs_prefs_set_logout_timeout (prefs, value);
379
380 /* User switching options */
381
382 bvalue = g_settings_get_boolean (prefs->priv->settings, KEY_USER_SWITCH_ENABLED);
383 _gs_prefs_set_user_switch_enabled (prefs, bvalue);
384 }
385
386 static void
key_changed_cb(GSettings * settings,gchar * key,GSPrefs * prefs)387 key_changed_cb (GSettings *settings,
388 gchar *key,
389 GSPrefs *prefs)
390 {
391 if (strcmp (key, KEY_MODE) == 0)
392 {
393 gint mode;
394
395 mode = g_settings_get_enum (settings, key);
396 _gs_prefs_set_mode (prefs, mode);
397
398 }
399 else if (strcmp (key, KEY_THEMES) == 0)
400 {
401 gchar **strv = NULL;
402
403 strv = g_settings_get_strv (settings, key);
404 _gs_prefs_set_themes (prefs, strv);
405 g_strfreev (strv);
406
407 }
408 else if (strcmp (key, KEY_IDLE_DELAY) == 0)
409 {
410 int delay;
411
412 delay = g_settings_get_int (settings, key);
413 _gs_prefs_set_timeout (prefs, delay);
414
415 }
416 else if (strcmp (key, KEY_POWER_DELAY) == 0)
417 {
418 int delay;
419
420 delay = g_settings_get_int (settings, key);
421 _gs_prefs_set_power_timeout (prefs, delay);
422
423 }
424 else if (strcmp (key, KEY_LOCK_DELAY) == 0)
425 {
426 int delay;
427
428 delay = g_settings_get_int (settings, key);
429 _gs_prefs_set_lock_timeout (prefs, delay);
430 }
431 else if (strcmp (key, KEY_IDLE_ACTIVATION_ENABLED) == 0)
432 {
433 gboolean enabled;
434
435 enabled = g_settings_get_boolean (settings, key);
436 _gs_prefs_set_idle_activation_enabled (prefs, enabled);
437
438 }
439 else if (strcmp (key, KEY_LOCK_ENABLED) == 0)
440 {
441 gboolean enabled;
442
443 enabled = g_settings_get_boolean (settings, key);
444 _gs_prefs_set_lock_enabled (prefs, enabled);
445
446 }
447 else if (strcmp (key, KEY_LOCK_DISABLE) == 0)
448 {
449 gboolean disabled;
450
451 disabled = g_settings_get_boolean (settings, key);
452 _gs_prefs_set_lock_disabled (prefs, disabled);
453
454 }
455 else if (strcmp (key, KEY_USER_SWITCH_DISABLE) == 0)
456 {
457 gboolean disabled;
458
459 disabled = g_settings_get_boolean (settings, key);
460 _gs_prefs_set_user_switch_disabled (prefs, disabled);
461
462 }
463 else if (strcmp (key, KEY_CYCLE_DELAY) == 0)
464 {
465 int delay;
466
467 delay = g_settings_get_int (settings, key);
468 _gs_prefs_set_cycle_timeout (prefs, delay);
469
470 }
471 else if (strcmp (key, KEY_KEYBOARD_ENABLED) == 0)
472 {
473 gboolean enabled;
474
475 enabled = g_settings_get_boolean (settings, key);
476 _gs_prefs_set_keyboard_enabled (prefs, enabled);
477
478 }
479 else if (strcmp (key, KEY_KEYBOARD_COMMAND) == 0)
480 {
481 char *command;
482
483 command = g_settings_get_string (settings, key);
484 _gs_prefs_set_keyboard_command (prefs, command);
485 g_free (command);
486
487 }
488 else if (strcmp (key, KEY_STATUS_MESSAGE_ENABLED) == 0)
489 {
490 gboolean enabled;
491
492 enabled = g_settings_get_boolean (settings, key);
493 _gs_prefs_set_status_message_enabled (prefs, enabled);
494
495 }
496 else if (strcmp (key, KEY_LOGOUT_ENABLED) == 0)
497 {
498 gboolean enabled;
499
500 enabled = g_settings_get_boolean (settings, key);
501 _gs_prefs_set_logout_enabled (prefs, enabled);
502
503 }
504 else if (strcmp (key, KEY_LOGOUT_DELAY) == 0)
505 {
506 int delay;
507
508 delay = g_settings_get_int (settings, key);
509 _gs_prefs_set_logout_timeout (prefs, delay);
510
511 }
512 else if (strcmp (key, KEY_LOGOUT_COMMAND) == 0)
513 {
514 char *command;
515 command = g_settings_get_string (settings, key);
516 _gs_prefs_set_logout_command (prefs, command);
517 g_free (command);
518 }
519 else if (strcmp (key, KEY_USER_SWITCH_ENABLED) == 0)
520 {
521 gboolean enabled;
522
523 enabled = g_settings_get_boolean (settings, key);
524 _gs_prefs_set_user_switch_enabled (prefs, enabled);
525
526 }
527 else
528 {
529 g_warning ("Config key not handled: %s", key);
530 }
531
532 g_signal_emit (prefs, signals [CHANGED], 0);
533 }
534
535 static void
gs_prefs_init(GSPrefs * prefs)536 gs_prefs_init (GSPrefs *prefs)
537 {
538 prefs->priv = gs_prefs_get_instance_private (prefs);
539
540 prefs->priv->settings = g_settings_new (GSETTINGS_SCHEMA);
541 g_signal_connect (prefs->priv->settings,
542 "changed",
543 G_CALLBACK (key_changed_cb),
544 prefs);
545 prefs->priv->lockdown_settings = g_settings_new (LOCKDOWN_SETTINGS_SCHEMA);
546 g_signal_connect (prefs->priv->lockdown_settings,
547 "changed",
548 G_CALLBACK (key_changed_cb),
549 prefs);
550 prefs->priv->session_settings = g_settings_new (SESSION_SETTINGS_SCHEMA);
551 g_signal_connect (prefs->priv->session_settings,
552 "changed::" KEY_IDLE_DELAY,
553 G_CALLBACK (key_changed_cb),
554 prefs);
555
556 prefs->idle_activation_enabled = TRUE;
557 prefs->lock_enabled = TRUE;
558 prefs->lock_disabled = FALSE;
559 prefs->logout_enabled = FALSE;
560 prefs->user_switch_enabled = FALSE;
561
562 prefs->timeout = 600000;
563 prefs->power_timeout = 60000;
564 prefs->lock_timeout = 0;
565 prefs->logout_timeout = 14400000;
566 prefs->cycle = 600000;
567
568 prefs->mode = GS_MODE_SINGLE;
569
570 gs_prefs_load_from_settings (prefs);
571 }
572
573 static void
gs_prefs_finalize(GObject * object)574 gs_prefs_finalize (GObject *object)
575 {
576 GSPrefs *prefs;
577
578 g_return_if_fail (object != NULL);
579 g_return_if_fail (GS_IS_PREFS (object));
580
581 prefs = GS_PREFS (object);
582
583 g_return_if_fail (prefs->priv != NULL);
584
585 if (prefs->priv->settings)
586 {
587 g_object_unref (prefs->priv->settings);
588 prefs->priv->settings = NULL;
589 }
590
591 if (prefs->priv->lockdown_settings) {
592 g_object_unref (prefs->priv->lockdown_settings);
593 prefs->priv->lockdown_settings = NULL;
594 }
595
596 if (prefs->priv->session_settings) {
597 g_object_unref (prefs->priv->session_settings);
598 prefs->priv->session_settings = NULL;
599 }
600
601 if (prefs->themes)
602 {
603 g_slist_free_full (prefs->themes, g_free);
604 }
605
606 g_free (prefs->logout_command);
607 g_free (prefs->keyboard_command);
608
609 G_OBJECT_CLASS (gs_prefs_parent_class)->finalize (object);
610 }
611
612 GSPrefs *
gs_prefs_new(void)613 gs_prefs_new (void)
614 {
615 GObject *prefs;
616
617 prefs = g_object_new (GS_TYPE_PREFS, NULL);
618
619 return GS_PREFS (prefs);
620 }
621