1 /*
2 * Copyright © 2009, 2010 Codethink Limited
3 *
4 * This library is free software; you can redistribute it and/or
5 * modify it under the terms of the GNU Lesser General Public
6 * License as published by the Free Software Foundation; either
7 * version 2.1 of the License, or (at your option) any later version.
8 *
9 * This library is distributed in the hope that it will be useful,
10 * but WITHOUT ANY WARRANTY; without even the implied warranty of
11 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
12 * Lesser General Public License for more details.
13 *
14 * You should have received a copy of the GNU Lesser General Public
15 * License along with this library; if not, see <http://www.gnu.org/licenses/>.
16 *
17 * Author: Ryan Lortie <desrt@desrt.ca>
18 */
19
20 #include "config.h"
21
22 #include "gdelayedsettingsbackend.h"
23 #include "gsettingsbackendinternal.h"
24
25 #include <string.h>
26
27
28 struct _GDelayedSettingsBackendPrivate
29 {
30 GSettingsBackend *backend;
31 GMutex lock;
32 GTree *delayed;
33
34 GMainContext *owner_context;
35 gpointer owner;
36 };
37
G_DEFINE_TYPE_WITH_PRIVATE(GDelayedSettingsBackend,g_delayed_settings_backend,G_TYPE_SETTINGS_BACKEND)38 G_DEFINE_TYPE_WITH_PRIVATE (GDelayedSettingsBackend,
39 g_delayed_settings_backend,
40 G_TYPE_SETTINGS_BACKEND)
41
42 static gboolean
43 invoke_notify_unapplied (gpointer data)
44 {
45 g_object_notify (data, "has-unapplied");
46 g_object_unref (data);
47
48 return FALSE;
49 }
50
51 static void
g_delayed_settings_backend_notify_unapplied(GDelayedSettingsBackend * delayed)52 g_delayed_settings_backend_notify_unapplied (GDelayedSettingsBackend *delayed)
53 {
54 GMainContext *target_context;
55 GObject *target;
56
57 g_mutex_lock (&delayed->priv->lock);
58 if (delayed->priv->owner)
59 {
60 target_context = delayed->priv->owner_context;
61 target = g_object_ref (delayed->priv->owner);
62 }
63 else
64 {
65 target_context = NULL;
66 target = NULL;
67 }
68 g_mutex_unlock (&delayed->priv->lock);
69
70 if (target != NULL)
71 g_main_context_invoke (target_context, invoke_notify_unapplied, target);
72 }
73
74
75 static GVariant *
g_delayed_settings_backend_read(GSettingsBackend * backend,const gchar * key,const GVariantType * expected_type,gboolean default_value)76 g_delayed_settings_backend_read (GSettingsBackend *backend,
77 const gchar *key,
78 const GVariantType *expected_type,
79 gboolean default_value)
80 {
81 GDelayedSettingsBackend *delayed = G_DELAYED_SETTINGS_BACKEND (backend);
82 gpointer result = NULL;
83
84 if (!default_value)
85 {
86 g_mutex_lock (&delayed->priv->lock);
87 if (g_tree_lookup_extended (delayed->priv->delayed, key, NULL, &result))
88 {
89 /* NULL in the tree means we should consult the default value */
90 if (result != NULL)
91 g_variant_ref (result);
92 else
93 default_value = TRUE;
94 }
95 g_mutex_unlock (&delayed->priv->lock);
96 }
97
98 if (result == NULL)
99 result = g_settings_backend_read (delayed->priv->backend, key,
100 expected_type, default_value);
101
102 return result;
103 }
104
105 static GVariant *
g_delayed_settings_backend_read_user_value(GSettingsBackend * backend,const gchar * key,const GVariantType * expected_type)106 g_delayed_settings_backend_read_user_value (GSettingsBackend *backend,
107 const gchar *key,
108 const GVariantType *expected_type)
109 {
110 GDelayedSettingsBackend *delayed = G_DELAYED_SETTINGS_BACKEND (backend);
111 gboolean value_found = FALSE;
112 gpointer result = NULL;
113
114 /* If we find an explicit NULL in our changeset then we want to return
115 * NULL (because the user value has been reset).
116 *
117 * Otherwise, chain up.
118 */
119 g_mutex_lock (&delayed->priv->lock);
120 value_found = g_tree_lookup_extended (delayed->priv->delayed, key, NULL, &result);
121 if (result)
122 g_variant_ref (result);
123 g_mutex_unlock (&delayed->priv->lock);
124
125 if (value_found)
126 return result;
127
128 return g_settings_backend_read_user_value (delayed->priv->backend, key, expected_type);
129 }
130
131 static gboolean
g_delayed_settings_backend_write(GSettingsBackend * backend,const gchar * key,GVariant * value,gpointer origin_tag)132 g_delayed_settings_backend_write (GSettingsBackend *backend,
133 const gchar *key,
134 GVariant *value,
135 gpointer origin_tag)
136 {
137 GDelayedSettingsBackend *delayed = G_DELAYED_SETTINGS_BACKEND (backend);
138 gboolean was_empty;
139
140 g_mutex_lock (&delayed->priv->lock);
141 was_empty = g_tree_nnodes (delayed->priv->delayed) == 0;
142 g_tree_insert (delayed->priv->delayed, g_strdup (key),
143 g_variant_ref_sink (value));
144 g_mutex_unlock (&delayed->priv->lock);
145
146 g_settings_backend_changed (backend, key, origin_tag);
147
148 if (was_empty)
149 g_delayed_settings_backend_notify_unapplied (delayed);
150
151 return TRUE;
152 }
153
154 static gboolean
add_to_tree(gpointer key,gpointer value,gpointer user_data)155 add_to_tree (gpointer key,
156 gpointer value,
157 gpointer user_data)
158 {
159 /* A value may be %NULL if its key has been reset */
160 g_tree_insert (user_data, g_strdup (key), (value != NULL) ? g_variant_ref (value) : NULL);
161 return FALSE;
162 }
163
164 static gboolean
g_delayed_settings_backend_write_tree(GSettingsBackend * backend,GTree * tree,gpointer origin_tag)165 g_delayed_settings_backend_write_tree (GSettingsBackend *backend,
166 GTree *tree,
167 gpointer origin_tag)
168 {
169 GDelayedSettingsBackend *delayed = G_DELAYED_SETTINGS_BACKEND (backend);
170 gboolean was_empty;
171
172 g_mutex_lock (&delayed->priv->lock);
173 was_empty = g_tree_nnodes (delayed->priv->delayed) == 0;
174
175 g_tree_foreach (tree, add_to_tree, delayed->priv->delayed);
176 g_mutex_unlock (&delayed->priv->lock);
177
178 g_settings_backend_changed_tree (backend, tree, origin_tag);
179
180 if (was_empty)
181 g_delayed_settings_backend_notify_unapplied (delayed);
182
183 return TRUE;
184 }
185
186 static gboolean
g_delayed_settings_backend_get_writable(GSettingsBackend * backend,const gchar * name)187 g_delayed_settings_backend_get_writable (GSettingsBackend *backend,
188 const gchar *name)
189 {
190 GDelayedSettingsBackend *delayed = G_DELAYED_SETTINGS_BACKEND (backend);
191
192 return g_settings_backend_get_writable (delayed->priv->backend, name);
193 }
194
195 static void
g_delayed_settings_backend_reset(GSettingsBackend * backend,const gchar * key,gpointer origin_tag)196 g_delayed_settings_backend_reset (GSettingsBackend *backend,
197 const gchar *key,
198 gpointer origin_tag)
199 {
200 GDelayedSettingsBackend *delayed = G_DELAYED_SETTINGS_BACKEND (backend);
201 gboolean was_empty;
202
203 g_mutex_lock (&delayed->priv->lock);
204 was_empty = g_tree_nnodes (delayed->priv->delayed) == 0;
205 g_tree_insert (delayed->priv->delayed, g_strdup (key), NULL);
206 g_mutex_unlock (&delayed->priv->lock);
207
208 g_settings_backend_changed (backend, key, origin_tag);
209
210 if (was_empty)
211 g_delayed_settings_backend_notify_unapplied (delayed);
212 }
213
214 static void
g_delayed_settings_backend_subscribe(GSettingsBackend * backend,const char * name)215 g_delayed_settings_backend_subscribe (GSettingsBackend *backend,
216 const char *name)
217 {
218 GDelayedSettingsBackend *delayed = G_DELAYED_SETTINGS_BACKEND (backend);
219
220 g_settings_backend_subscribe (delayed->priv->backend, name);
221 }
222
223 static void
g_delayed_settings_backend_unsubscribe(GSettingsBackend * backend,const char * name)224 g_delayed_settings_backend_unsubscribe (GSettingsBackend *backend,
225 const char *name)
226 {
227 GDelayedSettingsBackend *delayed = G_DELAYED_SETTINGS_BACKEND (backend);
228
229 g_settings_backend_unsubscribe (delayed->priv->backend, name);
230 }
231
232 static GPermission *
g_delayed_settings_backend_get_permission(GSettingsBackend * backend,const gchar * path)233 g_delayed_settings_backend_get_permission (GSettingsBackend *backend,
234 const gchar *path)
235 {
236 GDelayedSettingsBackend *delayed = G_DELAYED_SETTINGS_BACKEND (backend);
237
238 return g_settings_backend_get_permission (delayed->priv->backend, path);
239 }
240
241
242 /* method calls */
243 gboolean
g_delayed_settings_backend_get_has_unapplied(GDelayedSettingsBackend * delayed)244 g_delayed_settings_backend_get_has_unapplied (GDelayedSettingsBackend *delayed)
245 {
246 /* we don't need to lock for this... */
247
248 return g_tree_nnodes (delayed->priv->delayed) > 0;
249 }
250
251 void
g_delayed_settings_backend_apply(GDelayedSettingsBackend * delayed)252 g_delayed_settings_backend_apply (GDelayedSettingsBackend *delayed)
253 {
254 if (g_tree_nnodes (delayed->priv->delayed) > 0)
255 {
256 gboolean success;
257 GTree *tmp;
258
259 g_mutex_lock (&delayed->priv->lock);
260 tmp = delayed->priv->delayed;
261 delayed->priv->delayed = g_settings_backend_create_tree ();
262 success = g_settings_backend_write_tree (delayed->priv->backend,
263 tmp, delayed->priv);
264 g_mutex_unlock (&delayed->priv->lock);
265
266 if (!success)
267 g_settings_backend_changed_tree (G_SETTINGS_BACKEND (delayed),
268 tmp, NULL);
269
270 g_tree_unref (tmp);
271
272 g_delayed_settings_backend_notify_unapplied (delayed);
273 }
274 }
275
276 void
g_delayed_settings_backend_revert(GDelayedSettingsBackend * delayed)277 g_delayed_settings_backend_revert (GDelayedSettingsBackend *delayed)
278 {
279 if (g_tree_nnodes (delayed->priv->delayed) > 0)
280 {
281 GTree *tmp;
282
283 g_mutex_lock (&delayed->priv->lock);
284 tmp = delayed->priv->delayed;
285 delayed->priv->delayed = g_settings_backend_create_tree ();
286 g_mutex_unlock (&delayed->priv->lock);
287 g_settings_backend_changed_tree (G_SETTINGS_BACKEND (delayed), tmp, NULL);
288 g_tree_unref (tmp);
289
290 g_delayed_settings_backend_notify_unapplied (delayed);
291 }
292 }
293
294 /* change notification */
295 static void
delayed_backend_changed(GObject * target,GSettingsBackend * backend,const gchar * key,gpointer origin_tag)296 delayed_backend_changed (GObject *target,
297 GSettingsBackend *backend,
298 const gchar *key,
299 gpointer origin_tag)
300 {
301 GDelayedSettingsBackend *delayed = G_DELAYED_SETTINGS_BACKEND (target);
302
303 if (origin_tag != delayed->priv)
304 g_settings_backend_changed (G_SETTINGS_BACKEND (delayed),
305 key, origin_tag);
306 }
307
308 static void
delayed_backend_keys_changed(GObject * target,GSettingsBackend * backend,const gchar * path,gpointer origin_tag,const gchar * const * items)309 delayed_backend_keys_changed (GObject *target,
310 GSettingsBackend *backend,
311 const gchar *path,
312 gpointer origin_tag,
313 const gchar * const *items)
314 {
315 GDelayedSettingsBackend *delayed = G_DELAYED_SETTINGS_BACKEND (target);
316
317 if (origin_tag != delayed->priv)
318 g_settings_backend_keys_changed (G_SETTINGS_BACKEND (delayed),
319 path, items, origin_tag);
320 }
321
322 static void
delayed_backend_path_changed(GObject * target,GSettingsBackend * backend,const gchar * path,gpointer origin_tag)323 delayed_backend_path_changed (GObject *target,
324 GSettingsBackend *backend,
325 const gchar *path,
326 gpointer origin_tag)
327 {
328 GDelayedSettingsBackend *delayed = G_DELAYED_SETTINGS_BACKEND (target);
329
330 if (origin_tag != delayed->priv)
331 g_settings_backend_path_changed (G_SETTINGS_BACKEND (delayed),
332 path, origin_tag);
333 }
334
335 static void
delayed_backend_writable_changed(GObject * target,GSettingsBackend * backend,const gchar * key)336 delayed_backend_writable_changed (GObject *target,
337 GSettingsBackend *backend,
338 const gchar *key)
339 {
340 GDelayedSettingsBackend *delayed = G_DELAYED_SETTINGS_BACKEND (target);
341 gboolean last_one = FALSE;
342
343 g_mutex_lock (&delayed->priv->lock);
344
345 if (g_tree_lookup (delayed->priv->delayed, key) != NULL &&
346 !g_settings_backend_get_writable (delayed->priv->backend, key))
347 {
348 /* drop the key from our changeset if it just became read-only.
349 * no need to signal since the writable change below implies it.
350 *
351 * note that the item in the tree may very well be set to NULL in
352 * the case that the user stored a reset. we intentionally don't
353 * drop the key in this case since a reset will always succeed
354 * (even against a non-writable key).
355 */
356 g_tree_remove (delayed->priv->delayed, key);
357
358 /* if that was the only key... */
359 last_one = g_tree_nnodes (delayed->priv->delayed) == 0;
360 }
361
362 g_mutex_unlock (&delayed->priv->lock);
363
364 if (last_one)
365 g_delayed_settings_backend_notify_unapplied (delayed);
366
367 g_settings_backend_writable_changed (G_SETTINGS_BACKEND (delayed), key);
368 }
369
370 /* slow method until we get foreach-with-remove in GTree
371 */
372 typedef struct
373 {
374 const gchar *path;
375 const gchar **keys;
376 gsize index;
377 } CheckPrefixState;
378
379 static gboolean
check_prefix(gpointer key,gpointer value,gpointer data)380 check_prefix (gpointer key,
381 gpointer value,
382 gpointer data)
383 {
384 CheckPrefixState *state = data;
385
386 if (g_str_has_prefix (key, state->path))
387 state->keys[state->index++] = key;
388
389 return FALSE;
390 }
391
392 static void
delayed_backend_path_writable_changed(GObject * target,GSettingsBackend * backend,const gchar * path)393 delayed_backend_path_writable_changed (GObject *target,
394 GSettingsBackend *backend,
395 const gchar *path)
396 {
397 GDelayedSettingsBackend *delayed = G_DELAYED_SETTINGS_BACKEND (target);
398 gboolean last_one = FALSE;
399 gsize n_keys;
400
401 g_mutex_lock (&delayed->priv->lock);
402
403 n_keys = g_tree_nnodes (delayed->priv->delayed);
404
405 if (n_keys > 0)
406 {
407 CheckPrefixState state = { path, g_new (const gchar *, n_keys), 0 };
408 gsize i;
409
410 /* collect a list of possibly-affected keys (ie: matching the path) */
411 g_tree_foreach (delayed->priv->delayed, check_prefix, &state);
412
413 /* drop the keys that have been affected.
414 *
415 * don't drop 'reset' keys (see above) */
416 for (i = 0; i < state.index; i++)
417 if (g_tree_lookup (delayed->priv->delayed, state.keys[i]) != NULL &&
418 !g_settings_backend_get_writable (delayed->priv->backend,
419 state.keys[i]))
420 g_tree_remove (delayed->priv->delayed, state.keys[i]);
421
422 g_free (state.keys);
423
424 last_one = g_tree_nnodes (delayed->priv->delayed) == 0;
425 }
426
427 g_mutex_unlock (&delayed->priv->lock);
428
429 if (last_one)
430 g_delayed_settings_backend_notify_unapplied (delayed);
431
432 g_settings_backend_path_writable_changed (G_SETTINGS_BACKEND (delayed),
433 path);
434 }
435
436 static void
g_delayed_settings_backend_finalize(GObject * object)437 g_delayed_settings_backend_finalize (GObject *object)
438 {
439 GDelayedSettingsBackend *delayed = G_DELAYED_SETTINGS_BACKEND (object);
440
441 g_mutex_clear (&delayed->priv->lock);
442 g_object_unref (delayed->priv->backend);
443 g_tree_unref (delayed->priv->delayed);
444
445 /* if our owner is still alive, why are we finalizing? */
446 g_assert (delayed->priv->owner == NULL);
447
448 G_OBJECT_CLASS (g_delayed_settings_backend_parent_class)
449 ->finalize (object);
450 }
451
452 static void
g_delayed_settings_backend_class_init(GDelayedSettingsBackendClass * class)453 g_delayed_settings_backend_class_init (GDelayedSettingsBackendClass *class)
454 {
455 GSettingsBackendClass *backend_class = G_SETTINGS_BACKEND_CLASS (class);
456 GObjectClass *object_class = G_OBJECT_CLASS (class);
457
458 backend_class->read = g_delayed_settings_backend_read;
459 backend_class->read_user_value = g_delayed_settings_backend_read_user_value;
460 backend_class->write = g_delayed_settings_backend_write;
461 backend_class->write_tree = g_delayed_settings_backend_write_tree;
462 backend_class->reset = g_delayed_settings_backend_reset;
463 backend_class->get_writable = g_delayed_settings_backend_get_writable;
464 backend_class->subscribe = g_delayed_settings_backend_subscribe;
465 backend_class->unsubscribe = g_delayed_settings_backend_unsubscribe;
466 backend_class->get_permission = g_delayed_settings_backend_get_permission;
467
468 object_class->finalize = g_delayed_settings_backend_finalize;
469 }
470
471 static void
g_delayed_settings_backend_init(GDelayedSettingsBackend * delayed)472 g_delayed_settings_backend_init (GDelayedSettingsBackend *delayed)
473 {
474 delayed->priv = g_delayed_settings_backend_get_instance_private (delayed);
475 delayed->priv->delayed = g_settings_backend_create_tree ();
476 g_mutex_init (&delayed->priv->lock);
477 }
478
479 static void
g_delayed_settings_backend_disown(gpointer data,GObject * where_the_object_was)480 g_delayed_settings_backend_disown (gpointer data,
481 GObject *where_the_object_was)
482 {
483 GDelayedSettingsBackend *delayed = data;
484
485 g_mutex_lock (&delayed->priv->lock);
486 delayed->priv->owner_context = NULL;
487 delayed->priv->owner = NULL;
488 g_mutex_unlock (&delayed->priv->lock);
489 }
490
491 GDelayedSettingsBackend *
g_delayed_settings_backend_new(GSettingsBackend * backend,gpointer owner,GMainContext * owner_context)492 g_delayed_settings_backend_new (GSettingsBackend *backend,
493 gpointer owner,
494 GMainContext *owner_context)
495 {
496 static GSettingsListenerVTable vtable = {
497 delayed_backend_changed,
498 delayed_backend_path_changed,
499 delayed_backend_keys_changed,
500 delayed_backend_writable_changed,
501 delayed_backend_path_writable_changed
502 };
503 GDelayedSettingsBackend *delayed;
504
505 delayed = g_object_new (G_TYPE_DELAYED_SETTINGS_BACKEND, NULL);
506 delayed->priv->backend = g_object_ref (backend);
507 delayed->priv->owner_context = owner_context;
508 delayed->priv->owner = owner;
509
510 g_object_weak_ref (owner, g_delayed_settings_backend_disown, delayed);
511
512 g_settings_backend_watch (delayed->priv->backend,
513 &vtable, G_OBJECT (delayed), NULL);
514
515 return delayed;
516 }
517