Branch data Line data Source code
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 [ + + + - : 168 : G_DEFINE_TYPE_WITH_PRIVATE (GDelayedSettingsBackend,
+ + ]
41 : : g_delayed_settings_backend,
42 : : G_TYPE_SETTINGS_BACKEND)
43 : :
44 : : static gboolean
45 : 32 : invoke_notify_unapplied (gpointer data)
46 : : {
47 : 32 : g_object_notify (data, "has-unapplied");
48 : 32 : g_object_unref (data);
49 : :
50 : 32 : return FALSE;
51 : : }
52 : :
53 : : static void
54 : 32 : g_delayed_settings_backend_notify_unapplied (GDelayedSettingsBackend *delayed)
55 : : {
56 : : GMainContext *target_context;
57 : : GObject *target;
58 : :
59 : 32 : g_mutex_lock (&delayed->priv->lock);
60 [ + - ]: 32 : if (delayed->priv->owner)
61 : : {
62 : 32 : target_context = delayed->priv->owner_context;
63 : 32 : target = g_object_ref (delayed->priv->owner);
64 : : }
65 : : else
66 : : {
67 : 0 : target_context = NULL;
68 : 0 : target = NULL;
69 : : }
70 : 32 : g_mutex_unlock (&delayed->priv->lock);
71 : :
72 [ + - ]: 32 : if (target != NULL)
73 : 32 : g_main_context_invoke (target_context, invoke_notify_unapplied, target);
74 : 32 : }
75 : :
76 : :
77 : : static GVariant *
78 : 14 : g_delayed_settings_backend_read (GSettingsBackend *backend,
79 : : const gchar *key,
80 : : const GVariantType *expected_type,
81 : : gboolean default_value)
82 : : {
83 : 14 : GDelayedSettingsBackend *delayed = G_DELAYED_SETTINGS_BACKEND (backend);
84 : 14 : gpointer result = NULL;
85 : :
86 [ + - ]: 14 : if (!default_value)
87 : : {
88 : 14 : g_mutex_lock (&delayed->priv->lock);
89 [ + + ]: 14 : 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 [ + + ]: 4 : if (result != NULL)
93 : 3 : g_variant_ref (result);
94 : : else
95 : 1 : default_value = TRUE;
96 : : }
97 : 14 : g_mutex_unlock (&delayed->priv->lock);
98 : : }
99 : :
100 [ + + ]: 14 : if (result == NULL)
101 : 11 : result = g_settings_backend_read (delayed->priv->backend, key,
102 : : expected_type, default_value);
103 : :
104 : 14 : return result;
105 : : }
106 : :
107 : : static GVariant *
108 : 1 : g_delayed_settings_backend_read_user_value (GSettingsBackend *backend,
109 : : const gchar *key,
110 : : const GVariantType *expected_type)
111 : : {
112 : 1 : GDelayedSettingsBackend *delayed = G_DELAYED_SETTINGS_BACKEND (backend);
113 : 1 : gboolean value_found = FALSE;
114 : 1 : 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 : 1 : g_mutex_lock (&delayed->priv->lock);
122 : 1 : value_found = g_tree_lookup_extended (delayed->priv->delayed, key, NULL, &result);
123 [ + - ]: 1 : if (result)
124 : 1 : g_variant_ref (result);
125 : 1 : g_mutex_unlock (&delayed->priv->lock);
126 : :
127 [ + - ]: 1 : if (value_found)
128 : 1 : return result;
129 : :
130 : 0 : return g_settings_backend_read_user_value (delayed->priv->backend, key, expected_type);
131 : : }
132 : :
133 : : static gboolean
134 : 13 : g_delayed_settings_backend_write (GSettingsBackend *backend,
135 : : const gchar *key,
136 : : GVariant *value,
137 : : gpointer origin_tag)
138 : : {
139 : 13 : GDelayedSettingsBackend *delayed = G_DELAYED_SETTINGS_BACKEND (backend);
140 : : gboolean was_empty;
141 : :
142 : 13 : g_mutex_lock (&delayed->priv->lock);
143 : 13 : was_empty = g_tree_nnodes (delayed->priv->delayed) == 0;
144 : 13 : g_tree_insert (delayed->priv->delayed, g_strdup (key),
145 : 13 : g_variant_ref_sink (value));
146 : 13 : g_mutex_unlock (&delayed->priv->lock);
147 : :
148 : 13 : g_settings_backend_changed (backend, key, origin_tag);
149 : :
150 [ + + ]: 13 : if (was_empty)
151 : 11 : g_delayed_settings_backend_notify_unapplied (delayed);
152 : :
153 : 13 : return TRUE;
154 : : }
155 : :
156 : : static gboolean
157 : 0 : 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 [ # # ]: 0 : g_tree_insert (user_data, g_strdup (key), (value != NULL) ? g_variant_ref (value) : NULL);
163 : 0 : return FALSE;
164 : : }
165 : :
166 : : static gboolean
167 : 0 : g_delayed_settings_backend_write_tree (GSettingsBackend *backend,
168 : : GTree *tree,
169 : : gpointer origin_tag)
170 : : {
171 : 0 : GDelayedSettingsBackend *delayed = G_DELAYED_SETTINGS_BACKEND (backend);
172 : : gboolean was_empty;
173 : :
174 : 0 : g_mutex_lock (&delayed->priv->lock);
175 : 0 : was_empty = g_tree_nnodes (delayed->priv->delayed) == 0;
176 : :
177 : 0 : g_tree_foreach (tree, add_to_tree, delayed->priv->delayed);
178 : 0 : g_mutex_unlock (&delayed->priv->lock);
179 : :
180 : 0 : g_settings_backend_changed_tree (backend, tree, origin_tag);
181 : :
182 [ # # ]: 0 : if (was_empty)
183 : 0 : g_delayed_settings_backend_notify_unapplied (delayed);
184 : :
185 : 0 : return TRUE;
186 : : }
187 : :
188 : : static gboolean
189 : 13 : g_delayed_settings_backend_get_writable (GSettingsBackend *backend,
190 : : const gchar *name)
191 : : {
192 : 13 : GDelayedSettingsBackend *delayed = G_DELAYED_SETTINGS_BACKEND (backend);
193 : :
194 : 13 : return g_settings_backend_get_writable (delayed->priv->backend, name);
195 : : }
196 : :
197 : : static void
198 : 7 : g_delayed_settings_backend_reset (GSettingsBackend *backend,
199 : : const gchar *key,
200 : : gpointer origin_tag)
201 : : {
202 : 7 : GDelayedSettingsBackend *delayed = G_DELAYED_SETTINGS_BACKEND (backend);
203 : : gboolean was_empty;
204 : :
205 : 7 : g_mutex_lock (&delayed->priv->lock);
206 : 7 : was_empty = g_tree_nnodes (delayed->priv->delayed) == 0;
207 : 7 : g_tree_insert (delayed->priv->delayed, g_strdup (key), NULL);
208 : 7 : g_mutex_unlock (&delayed->priv->lock);
209 : :
210 : 7 : g_settings_backend_changed (backend, key, origin_tag);
211 : :
212 [ + + ]: 7 : if (was_empty)
213 : 5 : g_delayed_settings_backend_notify_unapplied (delayed);
214 : 7 : }
215 : :
216 : : static void
217 : 1 : g_delayed_settings_backend_subscribe (GSettingsBackend *backend,
218 : : const char *name)
219 : : {
220 : 1 : GDelayedSettingsBackend *delayed = G_DELAYED_SETTINGS_BACKEND (backend);
221 : :
222 : 1 : g_settings_backend_subscribe (delayed->priv->backend, name);
223 : 1 : }
224 : :
225 : : static void
226 : 11 : g_delayed_settings_backend_unsubscribe (GSettingsBackend *backend,
227 : : const char *name)
228 : : {
229 : 11 : GDelayedSettingsBackend *delayed = G_DELAYED_SETTINGS_BACKEND (backend);
230 : :
231 : 11 : g_settings_backend_unsubscribe (delayed->priv->backend, name);
232 : 11 : }
233 : :
234 : : static GPermission *
235 : 0 : g_delayed_settings_backend_get_permission (GSettingsBackend *backend,
236 : : const gchar *path)
237 : : {
238 : 0 : GDelayedSettingsBackend *delayed = G_DELAYED_SETTINGS_BACKEND (backend);
239 : :
240 : 0 : return g_settings_backend_get_permission (delayed->priv->backend, path);
241 : : }
242 : :
243 : :
244 : : /* method calls */
245 : : gboolean
246 : 7 : g_delayed_settings_backend_get_has_unapplied (GDelayedSettingsBackend *delayed)
247 : : {
248 : : /* we don't need to lock for this... */
249 : :
250 : 7 : return g_tree_nnodes (delayed->priv->delayed) > 0;
251 : : }
252 : :
253 : : void
254 : 14 : g_delayed_settings_backend_apply (GDelayedSettingsBackend *delayed)
255 : : {
256 [ + - ]: 14 : if (g_tree_nnodes (delayed->priv->delayed) > 0)
257 : : {
258 : : gboolean success;
259 : : GTree *tmp;
260 : :
261 : 14 : g_mutex_lock (&delayed->priv->lock);
262 : 14 : tmp = delayed->priv->delayed;
263 : 14 : delayed->priv->delayed = g_settings_backend_create_tree ();
264 : 14 : success = g_settings_backend_write_tree (delayed->priv->backend,
265 : 14 : tmp, delayed->priv);
266 : 14 : g_mutex_unlock (&delayed->priv->lock);
267 : :
268 [ + + ]: 14 : if (!success)
269 : 1 : g_settings_backend_changed_tree (G_SETTINGS_BACKEND (delayed),
270 : : tmp, NULL);
271 : :
272 : 14 : g_tree_unref (tmp);
273 : :
274 : 14 : g_delayed_settings_backend_notify_unapplied (delayed);
275 : : }
276 : 14 : }
277 : :
278 : : void
279 : 1 : g_delayed_settings_backend_revert (GDelayedSettingsBackend *delayed)
280 : : {
281 [ + - ]: 1 : if (g_tree_nnodes (delayed->priv->delayed) > 0)
282 : : {
283 : : GTree *tmp;
284 : :
285 : 1 : g_mutex_lock (&delayed->priv->lock);
286 : 1 : tmp = delayed->priv->delayed;
287 : 1 : delayed->priv->delayed = g_settings_backend_create_tree ();
288 : 1 : g_mutex_unlock (&delayed->priv->lock);
289 : 1 : g_settings_backend_changed_tree (G_SETTINGS_BACKEND (delayed), tmp, NULL);
290 : 1 : g_tree_unref (tmp);
291 : :
292 : 1 : g_delayed_settings_backend_notify_unapplied (delayed);
293 : : }
294 : 1 : }
295 : :
296 : : /* change notification */
297 : : static void
298 : 0 : delayed_backend_changed (GObject *target,
299 : : GSettingsBackend *backend,
300 : : const gchar *key,
301 : : gpointer origin_tag)
302 : : {
303 : 0 : GDelayedSettingsBackend *delayed = G_DELAYED_SETTINGS_BACKEND (target);
304 : :
305 [ # # ]: 0 : if (origin_tag != delayed->priv)
306 : 0 : g_settings_backend_changed (G_SETTINGS_BACKEND (delayed),
307 : : key, origin_tag);
308 : 0 : }
309 : :
310 : : static void
311 : 15 : delayed_backend_keys_changed (GObject *target,
312 : : GSettingsBackend *backend,
313 : : const gchar *path,
314 : : gpointer origin_tag,
315 : : const gchar * const *items)
316 : : {
317 : 15 : GDelayedSettingsBackend *delayed = G_DELAYED_SETTINGS_BACKEND (target);
318 : :
319 [ + + ]: 15 : if (origin_tag != delayed->priv)
320 : 2 : g_settings_backend_keys_changed (G_SETTINGS_BACKEND (delayed),
321 : : path, items, origin_tag);
322 : 15 : }
323 : :
324 : : static void
325 : 0 : delayed_backend_path_changed (GObject *target,
326 : : GSettingsBackend *backend,
327 : : const gchar *path,
328 : : gpointer origin_tag)
329 : : {
330 : 0 : GDelayedSettingsBackend *delayed = G_DELAYED_SETTINGS_BACKEND (target);
331 : :
332 [ # # ]: 0 : if (origin_tag != delayed->priv)
333 : 0 : g_settings_backend_path_changed (G_SETTINGS_BACKEND (delayed),
334 : : path, origin_tag);
335 : 0 : }
336 : :
337 : : static void
338 : 0 : delayed_backend_writable_changed (GObject *target,
339 : : GSettingsBackend *backend,
340 : : const gchar *key)
341 : : {
342 : 0 : GDelayedSettingsBackend *delayed = G_DELAYED_SETTINGS_BACKEND (target);
343 : 0 : gboolean last_one = FALSE;
344 : :
345 : 0 : g_mutex_lock (&delayed->priv->lock);
346 : :
347 [ # # # # ]: 0 : if (g_tree_lookup (delayed->priv->delayed, key) != NULL &&
348 : 0 : !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 : 0 : g_tree_remove (delayed->priv->delayed, key);
359 : :
360 : : /* if that was the only key... */
361 : 0 : last_one = g_tree_nnodes (delayed->priv->delayed) == 0;
362 : : }
363 : :
364 : 0 : g_mutex_unlock (&delayed->priv->lock);
365 : :
366 [ # # ]: 0 : if (last_one)
367 : 0 : g_delayed_settings_backend_notify_unapplied (delayed);
368 : :
369 : 0 : g_settings_backend_writable_changed (G_SETTINGS_BACKEND (delayed), key);
370 : 0 : }
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 : 1 : check_prefix (gpointer key,
383 : : gpointer value,
384 : : gpointer data)
385 : : {
386 : 1 : CheckPrefixState *state = data;
387 : :
388 [ + - ]: 1 : if (g_str_has_prefix (key, state->path))
389 : 1 : state->keys[state->index++] = key;
390 : :
391 : 1 : return FALSE;
392 : : }
393 : :
394 : : static void
395 : 1 : delayed_backend_path_writable_changed (GObject *target,
396 : : GSettingsBackend *backend,
397 : : const gchar *path)
398 : : {
399 : 1 : GDelayedSettingsBackend *delayed = G_DELAYED_SETTINGS_BACKEND (target);
400 : 1 : gboolean last_one = FALSE;
401 : : gsize n_keys;
402 : :
403 : 1 : g_mutex_lock (&delayed->priv->lock);
404 : :
405 : 1 : n_keys = g_tree_nnodes (delayed->priv->delayed);
406 : :
407 [ + - ]: 1 : if (n_keys > 0)
408 : : {
409 : 1 : 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 : 1 : 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 [ + + ]: 2 : for (i = 0; i < state.index; i++)
419 [ + - + - ]: 2 : if (g_tree_lookup (delayed->priv->delayed, state.keys[i]) != NULL &&
420 : 1 : !g_settings_backend_get_writable (delayed->priv->backend,
421 : 1 : state.keys[i]))
422 : 1 : g_tree_remove (delayed->priv->delayed, state.keys[i]);
423 : :
424 : 1 : g_free (state.keys);
425 : :
426 : 1 : last_one = g_tree_nnodes (delayed->priv->delayed) == 0;
427 : : }
428 : :
429 : 1 : g_mutex_unlock (&delayed->priv->lock);
430 : :
431 [ + - ]: 1 : if (last_one)
432 : 1 : g_delayed_settings_backend_notify_unapplied (delayed);
433 : :
434 : 1 : g_settings_backend_path_writable_changed (G_SETTINGS_BACKEND (delayed),
435 : : path);
436 : 1 : }
437 : :
438 : : static void
439 : 10 : g_delayed_settings_backend_finalize (GObject *object)
440 : : {
441 : 10 : GDelayedSettingsBackend *delayed = G_DELAYED_SETTINGS_BACKEND (object);
442 : :
443 : 10 : g_mutex_clear (&delayed->priv->lock);
444 : 10 : g_object_unref (delayed->priv->backend);
445 : 10 : g_tree_unref (delayed->priv->delayed);
446 : :
447 : : /* if our owner is still alive, why are we finalizing? */
448 : 10 : g_assert (delayed->priv->owner == NULL);
449 : :
450 : 10 : G_OBJECT_CLASS (g_delayed_settings_backend_parent_class)
451 : 10 : ->finalize (object);
452 : 10 : }
453 : :
454 : : static void
455 : 1 : g_delayed_settings_backend_class_init (GDelayedSettingsBackendClass *class)
456 : : {
457 : 1 : GSettingsBackendClass *backend_class = G_SETTINGS_BACKEND_CLASS (class);
458 : 1 : GObjectClass *object_class = G_OBJECT_CLASS (class);
459 : :
460 : 1 : backend_class->read = g_delayed_settings_backend_read;
461 : 1 : backend_class->read_user_value = g_delayed_settings_backend_read_user_value;
462 : 1 : backend_class->write = g_delayed_settings_backend_write;
463 : 1 : backend_class->write_tree = g_delayed_settings_backend_write_tree;
464 : 1 : backend_class->reset = g_delayed_settings_backend_reset;
465 : 1 : backend_class->get_writable = g_delayed_settings_backend_get_writable;
466 : 1 : backend_class->subscribe = g_delayed_settings_backend_subscribe;
467 : 1 : backend_class->unsubscribe = g_delayed_settings_backend_unsubscribe;
468 : 1 : backend_class->get_permission = g_delayed_settings_backend_get_permission;
469 : :
470 : 1 : object_class->finalize = g_delayed_settings_backend_finalize;
471 : 1 : }
472 : :
473 : : static void
474 : 10 : g_delayed_settings_backend_init (GDelayedSettingsBackend *delayed)
475 : : {
476 : 10 : delayed->priv = g_delayed_settings_backend_get_instance_private (delayed);
477 : 10 : delayed->priv->delayed = g_settings_backend_create_tree ();
478 : 10 : g_mutex_init (&delayed->priv->lock);
479 : 10 : }
480 : :
481 : : static void
482 : 10 : g_delayed_settings_backend_disown (gpointer data,
483 : : GObject *where_the_object_was)
484 : : {
485 : 10 : GDelayedSettingsBackend *delayed = data;
486 : :
487 : 10 : g_mutex_lock (&delayed->priv->lock);
488 : 10 : delayed->priv->owner_context = NULL;
489 : 10 : delayed->priv->owner = NULL;
490 : 10 : g_mutex_unlock (&delayed->priv->lock);
491 : 10 : }
492 : :
493 : : GDelayedSettingsBackend *
494 : 10 : 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 : 10 : delayed = g_object_new (G_TYPE_DELAYED_SETTINGS_BACKEND, NULL);
508 : 10 : delayed->priv->backend = g_object_ref (backend);
509 : 10 : delayed->priv->owner_context = owner_context;
510 : 10 : delayed->priv->owner = owner;
511 : :
512 : 10 : g_object_weak_ref (owner, g_delayed_settings_backend_disown, delayed);
513 : :
514 : 10 : g_settings_backend_watch (delayed->priv->backend,
515 : 10 : &vtable, G_OBJECT (delayed), NULL);
516 : :
517 : 10 : return delayed;
518 : : }
|
