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