gio/gnextstepsettingsbackend.c

   1 /*
   2  * Copyright © 2011 William Hua
   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: William Hua <william@attente.ca>
  20  */
  21
  22
  23
  24 #include "gsettingsbackendinternal.h"
  25 #include "gsimplepermission.h"
  26 #include "giomodule.h"
  27
  28
  29
  30 #import <Foundation/Foundation.h>
  31
  32
  33
  34 #define G_NEXTSTEP_SETTINGS_BACKEND(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), g_nextstep_settings_backend_get_type (), GNextstepSettingsBackend))
  35
  36
  37
  38 typedef struct _GNextstepSettingsBackend GNextstepSettingsBackend;
  39 typedef GSettingsBackendClass            GNextstepSettingsBackendClass;
  40
  41
  42
  43 struct _GNextstepSettingsBackend
  44 {
  45   GSettingsBackend  parent_instance;
  46
  47   /*< private >*/
  48   NSUserDefaults   *user_defaults;
  49   GMutex            mutex;
  50 };
  51
  52
  53
  54 G_DEFINE_TYPE_WITH_CODE (GNextstepSettingsBackend,
  55                          g_nextstep_settings_backend,
  56                          G_TYPE_SETTINGS_BACKEND,
  57                          g_io_extension_point_implement (G_SETTINGS_BACKEND_EXTENSION_POINT_NAME,
  58                                                          g_define_type_id, "nextstep", 90));
  59
  60
  61
  62 static void          g_nextstep_settings_backend_finalize       (GObject            *backend);
  63
  64 static GVariant *    g_nextstep_settings_backend_read           (GSettingsBackend   *backend,
  65                                                                  const gchar        *key,
  66                                                                  const GVariantType *expected_type,
  67                                                                  gboolean            default_value);
  68
  69 static gboolean      g_nextstep_settings_backend_get_writable   (GSettingsBackend   *backend,
  70                                                                  const gchar        *key);
  71
  72 static gboolean      g_nextstep_settings_backend_write          (GSettingsBackend   *backend,
  73                                                                  const gchar        *key,
  74                                                                  GVariant           *value,
  75                                                                  gpointer            origin_tag);
  76
  77 static gboolean      g_nextstep_settings_backend_write_tree     (GSettingsBackend   *backend,
  78                                                                  GTree              *tree,
  79                                                                  gpointer            origin_tag);
  80
  81 static void          g_nextstep_settings_backend_reset          (GSettingsBackend   *backend,
  82                                                                  const gchar        *key,
  83                                                                  gpointer            origin_tag);
  84
  85 static void          g_nextstep_settings_backend_subscribe      (GSettingsBackend   *backend,
  86                                                                  const gchar        *name);
  87
  88 static void          g_nextstep_settings_backend_unsubscribe    (GSettingsBackend   *backend,
  89                                                                  const gchar        *name);
  90
  91 static void          g_nextstep_settings_backend_sync           (GSettingsBackend   *backend);
  92
  93 static GPermission * g_nextstep_settings_backend_get_permission (GSettingsBackend   *backend,
  94                                                                  const gchar        *path);
  95
  96 static gboolean      g_nextstep_settings_backend_write_pair     (gpointer            name,
  97                                                                  gpointer            value,
  98                                                                  gpointer            data);
  99
 100 static GVariant *    g_nextstep_settings_backend_get_g_variant  (id                  object,
 101                                                                  const GVariantType *type);
 102
 103 static id            g_nextstep_settings_backend_get_ns_object  (GVariant           *variant);
 104
 105
 106
 107 static void
 108 g_nextstep_settings_backend_class_init (GNextstepSettingsBackendClass *class)
 109 {
 110   G_OBJECT_CLASS (class)->finalize = g_nextstep_settings_backend_finalize;
 111   class->read                      = g_nextstep_settings_backend_read;
 112   class->get_writable              = g_nextstep_settings_backend_get_writable;
 113   class->write                     = g_nextstep_settings_backend_write;
 114   class->write_tree                = g_nextstep_settings_backend_write_tree;
 115   class->reset                     = g_nextstep_settings_backend_reset;
 116   class->subscribe                 = g_nextstep_settings_backend_subscribe;
 117   class->unsubscribe               = g_nextstep_settings_backend_unsubscribe;
 118   class->sync                      = g_nextstep_settings_backend_sync;
 119   class->get_permission            = g_nextstep_settings_backend_get_permission;
 120 }
 121
 122
 123
 124 static void
 125 g_nextstep_settings_backend_init (GNextstepSettingsBackend *self)
 126 {
 127   NSAutoreleasePool *pool;
 128
 129   pool = [[NSAutoreleasePool alloc] init];
 130
 131   self->user_defaults = [[NSUserDefaults standardUserDefaults] retain];
 132
 133   g_mutex_init (&self->mutex);
 134
 135   [pool drain];
 136 }
 137
 138
 139
 140 static void
 141 g_nextstep_settings_backend_finalize (GObject *self)
 142 {
 143   GNextstepSettingsBackend *backend = G_NEXTSTEP_SETTINGS_BACKEND (self);
 144   NSAutoreleasePool *pool;
 145
 146   pool = [[NSAutoreleasePool alloc] init];
 147
 148   g_mutex_clear (&backend->mutex);
 149
 150   [backend->user_defaults release];
 151
 152   [pool drain];
 153
 154   G_OBJECT_CLASS (g_nextstep_settings_backend_parent_class)->finalize (self);
 155 }
 156
 157
 158
 159 static GVariant *
 160 g_nextstep_settings_backend_read (GSettingsBackend   *backend,
 161                                   const gchar        *key,
 162                                   const GVariantType *expected_type,
 163                                   gboolean            default_value)
 164 {
 165   GNextstepSettingsBackend *self = G_NEXTSTEP_SETTINGS_BACKEND (backend);
 166   NSAutoreleasePool *pool;
 167   NSString          *name;
 168   id                 value;
 169   GVariant          *variant;
 170
 171   if (default_value)
 172     return NULL;
 173
 174   pool    = [[NSAutoreleasePool alloc] init];
 175   name    = [NSString stringWithUTF8String:key];
 176
 177   g_mutex_lock (&self->mutex);
 178   value = [self->user_defaults objectForKey:name];
 179   g_mutex_unlock (&self->mutex);
 180
 181   variant = g_nextstep_settings_backend_get_g_variant (value, expected_type);
 182
 183   [pool drain];
 184
 185   return variant;
 186 }
 187
 188
 189
 190 static gboolean
 191 g_nextstep_settings_backend_get_writable (GSettingsBackend *backend,
 192                                           const gchar      *key)
 193 {
 194   return TRUE;
 195 }
 196
 197
 198
 199 static gboolean
 200 g_nextstep_settings_backend_write (GSettingsBackend *backend,
 201                                    const gchar      *key,
 202                                    GVariant         *value,
 203                                    gpointer          origin_tag)
 204 {
 205   GNextstepSettingsBackend *self = G_NEXTSTEP_SETTINGS_BACKEND (backend);
 206   NSAutoreleasePool *pool;
 207
 208   pool = [[NSAutoreleasePool alloc] init];
 209
 210   g_mutex_lock (&self->mutex);
 211   g_nextstep_settings_backend_write_pair ((gpointer) key, value, self);
 212   g_mutex_unlock (&self->mutex);
 213
 214   g_settings_backend_changed (backend, key, origin_tag);
 215
 216   [pool drain];
 217
 218   return TRUE;
 219 }
 220
 221
 222
 223 static gboolean
 224 g_nextstep_settings_backend_write_tree (GSettingsBackend *backend,
 225                                         GTree            *tree,
 226                                         gpointer          origin_tag)
 227 {
 228   GNextstepSettingsBackend *self = G_NEXTSTEP_SETTINGS_BACKEND (backend);
 229   NSAutoreleasePool *pool;
 230
 231   pool = [[NSAutoreleasePool alloc] init];
 232
 233   g_mutex_lock (&self->mutex);
 234   g_tree_foreach (tree, g_nextstep_settings_backend_write_pair, self);
 235   g_mutex_unlock (&self->mutex);
 236   g_settings_backend_changed_tree (backend, tree, origin_tag);
 237
 238   [pool drain];
 239
 240   return TRUE;
 241 }
 242
 243
 244
 245 static void
 246 g_nextstep_settings_backend_reset (GSettingsBackend *backend,
 247                                    const gchar      *key,
 248                                    gpointer          origin_tag)
 249 {
 250   GNextstepSettingsBackend *self = G_NEXTSTEP_SETTINGS_BACKEND (backend);
 251   NSAutoreleasePool *pool;
 252   NSString          *name;
 253
 254   pool          = [[NSAutoreleasePool alloc] init];
 255   name          = [NSString stringWithUTF8String:key];
 256
 257   g_mutex_lock (&self->mutex);
 258   [self->user_defaults removeObjectForKey:name];
 259   g_mutex_unlock (&self->mutex);
 260
 261   g_settings_backend_changed (backend, key, origin_tag);
 262
 263   [pool drain];
 264 }
 265
 266
 267
 268 static void
 269 g_nextstep_settings_backend_subscribe (GSettingsBackend *backend,
 270                                        const gchar      *name)
 271 {
 272 }
 273
 274
 275
 276 static void
 277 g_nextstep_settings_backend_unsubscribe (GSettingsBackend *backend,
 278                                          const gchar      *name)
 279 {
 280 }
 281
 282
 283
 284 static void
 285 g_nextstep_settings_backend_sync (GSettingsBackend *backend)
 286 {
 287   GNextstepSettingsBackend *self = G_NEXTSTEP_SETTINGS_BACKEND (backend);
 288   NSAutoreleasePool *pool;
 289
 290   pool = [[NSAutoreleasePool alloc] init];
 291
 292   g_mutex_lock (&self->mutex);
 293   [self->user_defaults synchronize];
 294   g_mutex_unlock (&self->mutex);
 295
 296   [pool drain];
 297 }
 298
 299
 300
 301 static GPermission *
 302 g_nextstep_settings_backend_get_permission (GSettingsBackend *backend,
 303                                             const gchar      *path)
 304 {
 305   return g_simple_permission_new (TRUE);
 306 }
 307
 308
 309
 310 static gboolean
 311 g_nextstep_settings_backend_write_pair (gpointer name,
 312                                         gpointer value,
 313                                         gpointer data)
 314 {
 315   GNextstepSettingsBackend *backend = G_NEXTSTEP_SETTINGS_BACKEND (data);
 316   NSString                 *key;
 317   id                        object;
 318
 319   key     = [NSString stringWithUTF8String:name];
 320   object  = g_nextstep_settings_backend_get_ns_object (value);
 321
 322   [backend->user_defaults setObject:object forKey:key];
 323
 324   return FALSE;
 325 }
 326
 327
 328
 329 static GVariant *
 330 g_nextstep_settings_backend_get_g_variant (id                  object,
 331                                            const GVariantType *type)
 332 {
 333   if ([object isKindOfClass:[NSData class]])
 334     return g_variant_parse (type, [[[[NSString alloc] initWithData:object encoding:NSUTF8StringEncoding] autorelease] UTF8String], NULL, NULL, NULL);
 335   else if ([object isKindOfClass:[NSNumber class]])
 336     {
 337       if (g_variant_type_equal (type, G_VARIANT_TYPE_BOOLEAN))
 338         return g_variant_new_boolean ([object boolValue]);
 339       else if (g_variant_type_equal (type, G_VARIANT_TYPE_BYTE))
 340         return g_variant_new_byte ([object unsignedCharValue]);
 341       else if (g_variant_type_equal (type, G_VARIANT_TYPE_INT16))
 342         return g_variant_new_int16 ([object shortValue]);
 343       else if (g_variant_type_equal (type, G_VARIANT_TYPE_UINT16))
 344         return g_variant_new_uint16 ([object unsignedShortValue]);
 345       else if (g_variant_type_equal (type, G_VARIANT_TYPE_INT32))
 346         return g_variant_new_int32 ([object longValue]);
 347       else if (g_variant_type_equal (type, G_VARIANT_TYPE_UINT32))
 348         return g_variant_new_uint32 ([object unsignedLongValue]);
 349       else if (g_variant_type_equal (type, G_VARIANT_TYPE_INT64))
 350         return g_variant_new_int64 ([object longLongValue]);
 351       else if (g_variant_type_equal (type, G_VARIANT_TYPE_UINT64))
 352         return g_variant_new_uint64 ([object unsignedLongLongValue]);
 353       else if (g_variant_type_equal (type, G_VARIANT_TYPE_HANDLE))
 354         return g_variant_new_handle ([object longValue]);
 355       else if (g_variant_type_equal (type, G_VARIANT_TYPE_DOUBLE))
 356         return g_variant_new_double ([object doubleValue]);
 357     }
 358   else if ([object isKindOfClass:[NSString class]])
 359     {
 360       const char *string;
 361
 362       string = [object UTF8String];
 363
 364       if (g_variant_type_equal (type, G_VARIANT_TYPE_STRING))
 365         return g_variant_new_string (string);
 366       else if (g_variant_type_equal (type, G_VARIANT_TYPE_OBJECT_PATH))
 367         return g_variant_is_object_path  (string) ?
 368                g_variant_new_object_path (string) : NULL;
 369       else if (g_variant_type_equal (type, G_VARIANT_TYPE_SIGNATURE))
 370         return g_variant_is_signature  (string) ?
 371                g_variant_new_signature (string) : NULL;
 372     }
 373   else if ([object isKindOfClass:[NSDictionary class]])
 374     {
 375       if (g_variant_type_is_subtype_of (type, G_VARIANT_TYPE ("a{s*}")))
 376         {
 377           const GVariantType *value_type;
 378           GVariantBuilder     builder;
 379           NSString           *key;
 380
 381           value_type = g_variant_type_value (g_variant_type_element (type));
 382
 383           g_variant_builder_init (&builder, type);
 384
 385           for (key in object)
 386             {
 387               GVariant *name;
 388               id        value;
 389               GVariant *variant;
 390               GVariant *entry;
 391
 392               name    = g_variant_new_string ([key UTF8String]);
 393               value   = [object objectForKey:key];
 394               variant = g_nextstep_settings_backend_get_g_variant (value, value_type);
 395
 396               if (variant == NULL)
 397                 {
 398                   g_variant_builder_clear (&builder);
 399
 400                   return NULL;
 401                 }
 402
 403               entry = g_variant_new_dict_entry (name, variant);
 404               g_variant_builder_add_value (&builder, entry);
 405             }
 406
 407           return g_variant_builder_end (&builder);
 408         }
 409     }
 410   else if ([object isKindOfClass:[NSArray class]])
 411     {
 412       if (g_variant_type_is_subtype_of (type, G_VARIANT_TYPE_ARRAY))
 413         {
 414           const GVariantType *value_type;
 415           GVariantBuilder     builder;
 416           id                  value;
 417
 418           value_type = g_variant_type_element (type);
 419           g_variant_builder_init (&builder, type);
 420
 421           for (value in object)
 422             {
 423               GVariant *variant = g_nextstep_settings_backend_get_g_variant (value, value_type);
 424
 425               if (variant == NULL)
 426                 {
 427                   g_variant_builder_clear (&builder);
 428
 429                   return NULL;
 430                 }
 431
 432               g_variant_builder_add_value (&builder, variant);
 433             }
 434
 435           return g_variant_builder_end (&builder);
 436         }
 437     }
 438
 439   return NULL;
 440 }
 441
 442
 443
 444 static id
 445 g_nextstep_settings_backend_get_ns_object (GVariant *variant)
 446 {
 447   if (variant == NULL)
 448     return nil;
 449   else if (g_variant_is_of_type (variant, G_VARIANT_TYPE_BOOLEAN))
 450     return [NSNumber numberWithBool:g_variant_get_boolean (variant)];
 451   else if (g_variant_is_of_type (variant, G_VARIANT_TYPE_BYTE))
 452     return [NSNumber numberWithUnsignedChar:g_variant_get_byte (variant)];
 453   else if (g_variant_is_of_type (variant, G_VARIANT_TYPE_INT16))
 454     return [NSNumber numberWithShort:g_variant_get_int16 (variant)];
 455   else if (g_variant_is_of_type (variant, G_VARIANT_TYPE_UINT16))
 456     return [NSNumber numberWithUnsignedShort:g_variant_get_uint16 (variant)];
 457   else if (g_variant_is_of_type (variant, G_VARIANT_TYPE_INT32))
 458     return [NSNumber numberWithLong:g_variant_get_int32 (variant)];
 459   else if (g_variant_is_of_type (variant, G_VARIANT_TYPE_UINT32))
 460     return [NSNumber numberWithUnsignedLong:g_variant_get_uint32 (variant)];
 461   else if (g_variant_is_of_type (variant, G_VARIANT_TYPE_INT64))
 462     return [NSNumber numberWithLongLong:g_variant_get_int64 (variant)];
 463   else if (g_variant_is_of_type (variant, G_VARIANT_TYPE_UINT64))
 464     return [NSNumber numberWithUnsignedLongLong:g_variant_get_uint64 (variant)];
 465   else if (g_variant_is_of_type (variant, G_VARIANT_TYPE_HANDLE))
 466     return [NSNumber numberWithLong:g_variant_get_handle (variant)];
 467   else if (g_variant_is_of_type (variant, G_VARIANT_TYPE_DOUBLE))
 468     return [NSNumber numberWithDouble:g_variant_get_double (variant)];
 469   else if (g_variant_is_of_type (variant, G_VARIANT_TYPE_STRING))
 470     return [NSString stringWithUTF8String:g_variant_get_string (variant, NULL)];
 471   else if (g_variant_is_of_type (variant, G_VARIANT_TYPE_OBJECT_PATH))
 472     return [NSString stringWithUTF8String:g_variant_get_string (variant, NULL)];
 473   else if (g_variant_is_of_type (variant, G_VARIANT_TYPE_SIGNATURE))
 474     return [NSString stringWithUTF8String:g_variant_get_string (variant, NULL)];
 475   else if (g_variant_is_of_type (variant, G_VARIANT_TYPE ("a{s*}")))
 476     {
 477       NSMutableDictionary *dictionary;
 478       GVariantIter         iter;
 479       GVariant            *name;
 480       GVariant            *value;
 481
 482       dictionary = [NSMutableDictionary dictionaryWithCapacity:g_variant_iter_init (&iter, variant)];
 483
 484       while (g_variant_iter_loop (&iter, "{s*}", &name, &value))
 485         {
 486           NSString *key;
 487           id        object;
 488
 489           key    = [NSString stringWithUTF8String:g_variant_get_string (name, NULL)];
 490           object = g_nextstep_settings_backend_get_ns_object (value);
 491
 492           [dictionary setObject:object forKey:key];
 493         }
 494
 495       return dictionary;
 496     }
 497   else if (g_variant_is_of_type (variant, G_VARIANT_TYPE_ARRAY))
 498     {
 499       NSMutableArray *array;
 500       GVariantIter    iter;
 501       GVariant       *value;
 502
 503       array = [NSMutableArray arrayWithCapacity:g_variant_iter_init (&iter, variant)];
 504
 505       while ((value = g_variant_iter_next_value (&iter)) != NULL)
 506         [array addObject:g_nextstep_settings_backend_get_ns_object (value)];
 507
 508       return array;
 509     }
 510   else
 511     return [[NSString stringWithUTF8String:g_variant_print (variant, TRUE)] dataUsingEncoding:NSUTF8StringEncoding];
 512 }