gio/gdelayedsettingsbackend.c

   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 of the licence, 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, write to the
  16  * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
  17  * Boston, MA 02111-1307, USA.
  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 #include "gioalias.h"
  30
  31 struct _GDelayedSettingsBackendPrivate
  32 {
  33   GSettingsBackend *backend;
  34   GStaticMutex lock;
  35   GTree *delayed;
  36
  37   GMainContext *owner_context;
  38   gpointer owner;
  39 };
  40
  41 G_DEFINE_TYPE (GDelayedSettingsBackend,
  42                g_delayed_settings_backend,
  43                G_TYPE_SETTINGS_BACKEND)
  44
  45 static gboolean
  46 invoke_notify_unapplied (gpointer data)
  47 {
  48   g_object_notify (data, "has-unapplied");
  49   g_object_unref (data);
  50
  51   return FALSE;
  52 }
  53
  54 static void
  55 g_delayed_settings_backend_notify_unapplied (GDelayedSettingsBackend *delayed)
  56 {
  57   GMainContext *target_context;
  58   GObject *target;
  59
  60   g_static_mutex_lock (&delayed->priv->lock);
  61   if (delayed->priv->owner)
  62     {
  63       target_context = delayed->priv->owner_context;
  64       target = g_object_ref (delayed->priv->owner);
  65     }
  66   else
  67     {
  68       target_context = NULL;
  69       target = NULL;
  70     }
  71   g_static_mutex_unlock (&delayed->priv->lock);
  72
  73   if (target != NULL)
  74     {
  75       if (g_settings_backend_get_active_context () != target_context)
  76         {
  77           GSource *source;
  78
  79           source = g_idle_source_new ();
  80           g_source_set_priority (source, G_PRIORITY_DEFAULT);
  81           g_source_set_callback (source, invoke_notify_unapplied,
  82                                  target, g_object_unref);
  83           g_source_attach (source, target_context);
  84           g_source_unref (source);
  85         }
  86       else
  87         invoke_notify_unapplied (target);
  88     }
  89 }
  90
  91
  92 static GVariant *
  93 g_delayed_settings_backend_read (GSettingsBackend   *backend,
  94                                  const gchar        *key,
  95                                  const GVariantType *expected_type,
  96                                  gboolean            default_value)
  97 {
  98   GDelayedSettingsBackend *delayed = G_DELAYED_SETTINGS_BACKEND (backend);
  99   GVariant *result;
 100
 101   if (!default_value &&
 102       (result = g_tree_lookup (delayed->priv->delayed, key)))
 103     return g_variant_ref (result);
 104
 105   return g_settings_backend_read (delayed->priv->backend,
 106                                   key, expected_type, default_value);
 107 }
 108 static gboolean
 109 g_delayed_settings_backend_write (GSettingsBackend *backend,
 110                                   const gchar      *key,
 111                                   GVariant         *value,
 112                                   gpointer          origin_tag)
 113 {
 114   GDelayedSettingsBackend *delayed = G_DELAYED_SETTINGS_BACKEND (backend);
 115   gboolean was_empty;
 116
 117   g_static_mutex_lock (&delayed->priv->lock);
 118   was_empty = g_tree_nnodes (delayed->priv->delayed) == 0;
 119   g_tree_insert (delayed->priv->delayed, g_strdup (key),
 120                  g_variant_ref_sink (value));
 121   g_static_mutex_unlock (&delayed->priv->lock);
 122
 123   g_settings_backend_changed (backend, key, origin_tag);
 124
 125   if (was_empty)
 126     g_delayed_settings_backend_notify_unapplied (delayed);
 127
 128   return TRUE;
 129 }
 130
 131 static gboolean
 132 add_to_tree (gpointer key,
 133              gpointer value,
 134              gpointer user_data)
 135 {
 136   g_tree_insert (user_data, g_strdup (key), g_variant_ref (value));
 137   return FALSE;
 138 }
 139
 140 static gboolean
 141 g_delayed_settings_backend_write_keys (GSettingsBackend *backend,
 142                                        GTree            *tree,
 143                                        gpointer          origin_tag)
 144 {
 145   GDelayedSettingsBackend *delayed = G_DELAYED_SETTINGS_BACKEND (backend);
 146   gboolean was_empty;
 147
 148   g_static_mutex_lock (&delayed->priv->lock);
 149   was_empty = g_tree_nnodes (delayed->priv->delayed) == 0;
 150
 151   g_tree_foreach (tree, add_to_tree, delayed->priv->delayed);
 152   g_static_mutex_unlock (&delayed->priv->lock);
 153
 154   g_settings_backend_changed_tree (backend, tree, origin_tag);
 155
 156   if (was_empty)
 157     g_delayed_settings_backend_notify_unapplied (delayed);
 158
 159   return TRUE;
 160 }
 161
 162 static gboolean
 163 g_delayed_settings_backend_get_writable (GSettingsBackend *backend,
 164                                          const gchar      *name)
 165 {
 166   GDelayedSettingsBackend *delayed = G_DELAYED_SETTINGS_BACKEND (backend);
 167
 168   return g_settings_backend_get_writable (delayed->priv->backend, name);
 169 }
 170
 171 static void
 172 g_delayed_settings_backend_reset (GSettingsBackend *backend,
 173                                   const gchar      *key,
 174                                   gpointer          origin_tag)
 175 {
 176   /* deal with this... */
 177 }
 178
 179 static void
 180 g_delayed_settings_backend_reset_path (GSettingsBackend *backend,
 181                                        const gchar      *path,
 182                                        gpointer          origin_tag)
 183 {
 184   /* deal with this... */
 185 }
 186
 187 static void
 188 g_delayed_settings_backend_subscribe (GSettingsBackend *backend,
 189                                       const char       *name)
 190 {
 191   GDelayedSettingsBackend *delayed = G_DELAYED_SETTINGS_BACKEND (backend);
 192
 193   g_settings_backend_subscribe (delayed->priv->backend, name);
 194 }
 195
 196 static void
 197 g_delayed_settings_backend_unsubscribe (GSettingsBackend *backend,
 198                                         const char       *name)
 199 {
 200   GDelayedSettingsBackend *delayed = G_DELAYED_SETTINGS_BACKEND (backend);
 201
 202   g_settings_backend_unsubscribe (delayed->priv->backend, name);
 203 }
 204
 205 /* method calls */
 206 gboolean
 207 g_delayed_settings_backend_get_has_unapplied (GDelayedSettingsBackend *delayed)
 208 {
 209   /* we don't need to lock for this... */
 210
 211   return g_tree_nnodes (delayed->priv->delayed) > 0;
 212 }
 213
 214 void
 215 g_delayed_settings_backend_apply (GDelayedSettingsBackend *delayed)
 216 {
 217   if (g_tree_nnodes (delayed->priv->delayed) > 0)
 218     {
 219       gboolean success;
 220       GTree *tmp;
 221
 222       g_static_mutex_lock (&delayed->priv->lock);
 223       tmp = delayed->priv->delayed;
 224       delayed->priv->delayed = g_settings_backend_create_tree ();
 225       success = g_settings_backend_write_keys (delayed->priv->backend,
 226                                                tmp, delayed->priv);
 227       g_static_mutex_unlock (&delayed->priv->lock);
 228
 229       if (!success)
 230         g_settings_backend_changed_tree (G_SETTINGS_BACKEND (delayed),
 231                                          tmp, NULL);
 232
 233       g_tree_unref (tmp);
 234
 235       g_delayed_settings_backend_notify_unapplied (delayed);
 236     }
 237 }
 238
 239 void
 240 g_delayed_settings_backend_revert (GDelayedSettingsBackend *delayed)
 241 {
 242   if (g_tree_nnodes (delayed->priv->delayed) > 0)
 243     {
 244       GTree *tmp;
 245
 246       g_static_mutex_lock (&delayed->priv->lock);
 247       tmp = delayed->priv->delayed;
 248       delayed->priv->delayed = g_settings_backend_create_tree ();
 249       g_static_mutex_unlock (&delayed->priv->lock);
 250       g_settings_backend_changed_tree (G_SETTINGS_BACKEND (delayed), tmp, NULL);
 251       g_tree_unref (tmp);
 252
 253       g_delayed_settings_backend_notify_unapplied (delayed);
 254     }
 255 }
 256
 257 /* change notification */
 258 static void
 259 delayed_backend_changed (GSettingsBackend *backend,
 260                          GObject          *target,
 261                          const gchar      *key,
 262                          gpointer          origin_tag)
 263 {
 264   GDelayedSettingsBackend *delayed = G_DELAYED_SETTINGS_BACKEND (target);
 265
 266   if (origin_tag != delayed->priv)
 267     g_settings_backend_changed (G_SETTINGS_BACKEND (delayed),
 268                                 key, origin_tag);
 269 }
 270
 271 static void
 272 delayed_backend_keys_changed (GSettingsBackend    *backend,
 273                               GObject             *target,
 274                               const gchar         *path,
 275                               const gchar * const *items,
 276                               gpointer             origin_tag)
 277 {
 278   GDelayedSettingsBackend *delayed = G_DELAYED_SETTINGS_BACKEND (target);
 279
 280   if (origin_tag != delayed->priv)
 281     g_settings_backend_keys_changed (G_SETTINGS_BACKEND (delayed),
 282                                      path, items, origin_tag);
 283 }
 284
 285 static void
 286 delayed_backend_path_changed (GSettingsBackend *backend,
 287                               GObject          *target,
 288                               const gchar      *path,
 289                               gpointer          origin_tag)
 290 {
 291   GDelayedSettingsBackend *delayed = G_DELAYED_SETTINGS_BACKEND (target);
 292
 293   if (origin_tag != delayed->priv)
 294     g_settings_backend_path_changed (G_SETTINGS_BACKEND (delayed),
 295                                      path, origin_tag);
 296 }
 297
 298 static void
 299 delayed_backend_writable_changed (GSettingsBackend *backend,
 300                                   GObject          *target,
 301                                   const gchar      *key)
 302 {
 303   GDelayedSettingsBackend *delayed = G_DELAYED_SETTINGS_BACKEND (target);
 304   gboolean last_one = FALSE;
 305
 306   g_static_mutex_lock (&delayed->priv->lock);
 307
 308   if (g_tree_lookup (delayed->priv->delayed, key) &&
 309       !g_settings_backend_get_writable (delayed->priv->backend, key))
 310     {
 311       /* drop the key from our changeset if it just became read-only.
 312        * no need to signal since the writable change below implies it.
 313        */
 314       g_tree_remove (delayed->priv->delayed, key);
 315
 316       /* if that was the only key... */
 317       last_one = g_tree_nnodes (delayed->priv->delayed) == 0;
 318     }
 319
 320   g_static_mutex_unlock (&delayed->priv->lock);
 321
 322   if (last_one)
 323     g_delayed_settings_backend_notify_unapplied (delayed);
 324
 325   g_settings_backend_writable_changed (G_SETTINGS_BACKEND (delayed), key);
 326 }
 327
 328 /* slow method until we get foreach-with-remove in GTree
 329  */
 330 typedef struct
 331 {
 332   const gchar *path;
 333   const gchar **keys;
 334   gsize index;
 335 } CheckPrefixState;
 336
 337 static gboolean
 338 check_prefix (gpointer key,
 339               gpointer value,
 340               gpointer data)
 341 {
 342   CheckPrefixState *state = data;
 343
 344   if (g_str_has_prefix (key, state->path))
 345     state->keys[state->index++] = key;
 346
 347   return FALSE;
 348 }
 349
 350 static void
 351 delayed_backend_path_writable_changed (GSettingsBackend *backend,
 352                                        GObject          *target,
 353                                        const gchar      *path)
 354 {
 355   GDelayedSettingsBackend *delayed = G_DELAYED_SETTINGS_BACKEND (target);
 356   gboolean last_one = FALSE;
 357   gsize n_keys;
 358
 359   g_static_mutex_lock (&delayed->priv->lock);
 360
 361   n_keys = g_tree_nnodes (delayed->priv->delayed);
 362
 363   if (n_keys > 0)
 364     {
 365       CheckPrefixState state = { path, g_new (const gchar *, n_keys) };
 366       gsize i;
 367
 368       /* collect a list of possibly-affected keys (ie: matching the path) */
 369       g_tree_foreach (delayed->priv->delayed, check_prefix, &state);
 370
 371       /* drop the keys that have been affected */
 372       for (i = 0; i < state.index; i++)
 373         if (!g_settings_backend_get_writable (delayed->priv->backend,
 374                                               state.keys[i]))
 375           g_tree_remove (delayed->priv->delayed, state.keys[i]);
 376
 377       g_free (state.keys);
 378
 379       last_one = g_tree_nnodes (delayed->priv->delayed) == 0;
 380     }
 381
 382   g_static_mutex_unlock (&delayed->priv->lock);
 383
 384   if (last_one)
 385     g_delayed_settings_backend_notify_unapplied (delayed);
 386
 387   g_settings_backend_path_writable_changed (G_SETTINGS_BACKEND (delayed),
 388                                             path);
 389 }
 390
 391 static void
 392 g_delayed_settings_backend_finalize (GObject *object)
 393 {
 394   GDelayedSettingsBackend *delayed = G_DELAYED_SETTINGS_BACKEND (object);
 395
 396   g_static_mutex_free (&delayed->priv->lock);
 397   g_object_unref (delayed->priv->backend);
 398
 399   /* if our owner is still alive, why are we finalizing? */
 400   g_assert (delayed->priv->owner == NULL);
 401
 402   G_OBJECT_CLASS (g_delayed_settings_backend_parent_class)
 403     ->finalize (object);
 404 }
 405
 406 static void
 407 g_delayed_settings_backend_class_init (GDelayedSettingsBackendClass *class)
 408 {
 409   GSettingsBackendClass *backend_class = G_SETTINGS_BACKEND_CLASS (class);
 410   GObjectClass *object_class = G_OBJECT_CLASS (class);
 411
 412   g_type_class_add_private (class, sizeof (GDelayedSettingsBackendPrivate));
 413
 414   backend_class->read = g_delayed_settings_backend_read;
 415   backend_class->write = g_delayed_settings_backend_write;
 416   backend_class->write_keys = g_delayed_settings_backend_write_keys;
 417   backend_class->reset = g_delayed_settings_backend_reset;
 418   backend_class->reset_path = g_delayed_settings_backend_reset_path;
 419   backend_class->get_writable = g_delayed_settings_backend_get_writable;
 420   backend_class->subscribe = g_delayed_settings_backend_subscribe;
 421   backend_class->unsubscribe = g_delayed_settings_backend_unsubscribe;
 422
 423   object_class->finalize = g_delayed_settings_backend_finalize;
 424 }
 425
 426 static void
 427 g_delayed_settings_backend_init (GDelayedSettingsBackend *delayed)
 428 {
 429   delayed->priv =
 430     G_TYPE_INSTANCE_GET_PRIVATE (delayed, G_TYPE_DELAYED_SETTINGS_BACKEND,
 431                                  GDelayedSettingsBackendPrivate);
 432
 433   delayed->priv->delayed = g_settings_backend_create_tree ();
 434   g_static_mutex_init (&delayed->priv->lock);
 435 }
 436
 437 static void
 438 g_delayed_settings_backend_disown (gpointer  data,
 439                                    GObject  *where_the_object_was)
 440 {
 441   GDelayedSettingsBackend *delayed = data;
 442
 443   g_static_mutex_lock (&delayed->priv->lock);
 444   delayed->priv->owner_context = NULL;
 445   delayed->priv->owner = NULL;
 446   g_static_mutex_unlock (&delayed->priv->lock);
 447 }
 448
 449 GDelayedSettingsBackend *
 450 g_delayed_settings_backend_new (GSettingsBackend *backend,
 451                                 gpointer          owner,
 452                                 GMainContext     *owner_context)
 453 {
 454   GDelayedSettingsBackend *delayed;
 455
 456   delayed = g_object_new (G_TYPE_DELAYED_SETTINGS_BACKEND, NULL);
 457   delayed->priv->backend = g_object_ref (backend);
 458   delayed->priv->owner_context = owner_context;
 459   delayed->priv->owner = owner;
 460
 461   g_object_weak_ref (owner, g_delayed_settings_backend_disown, delayed);
 462
 463   g_settings_backend_watch (delayed->priv->backend, G_OBJECT (delayed), NULL,
 464                             delayed_backend_changed,
 465                             delayed_backend_path_changed,
 466                             delayed_backend_keys_changed,
 467                             delayed_backend_writable_changed,
 468                             delayed_backend_path_writable_changed);
 469
 470   return delayed;
 471 }