WINGs/userdefaults.c

   1
   2 #include <stdlib.h>
   3 #include <string.h>
   4 #include <stdio.h>
   5 #include <assert.h>
   6
   7
   8 #include "../src/config.h"
   9
  10 #include "WUtil.h"
  11
  12 #include <proplist.h>
  13
  14
  15 typedef struct W_UserDefaults {
  16     proplist_t defaults;
  17
  18     proplist_t appDomain;
  19
  20     proplist_t searchListArray;
  21     proplist_t *searchList;            /* cache for searchListArray */
  22
  23     char dirty;
  24
  25     char *path;                        /* where is db located */
  26
  27     struct W_UserDefaults *next;
  28
  29 } UserDefaults;
  30
  31
  32 static UserDefaults *sharedUserDefaults = NULL;
  33
  34 static Bool registeredSaveOnExit = False;
  35
  36
  37
  38 extern char *WMGetApplicationName();
  39
  40 #define DEFAULTS_DIR "/Defaults"
  41
  42
  43 char*
  44 wusergnusteppath()
  45 {
  46     static char *path = NULL;
  47     char *gspath;
  48     int pathlen;
  49
  50     if (!path) {
  51         gspath = getenv("GNUSTEP_USER_ROOT");
  52         if (gspath) {
  53             gspath = wexpandpath(gspath);
  54             pathlen = strlen(gspath) + 4;
  55             path = wmalloc(pathlen);
  56             strcpy(path, gspath);
  57             free(gspath);
  58         } else {
  59             pathlen = strlen(wgethomedir()) + 10;
  60             path = wmalloc(pathlen);
  61             strcpy(path, wgethomedir());
  62             strcat(path, "/GNUstep");
  63         }
  64     }
  65
  66     return path;
  67 }
  68
  69
  70 char*
  71 wdefaultspathfordomain(char *domain)
  72 {
  73     char *path;
  74     char *gspath;
  75
  76     gspath = wusergnusteppath();
  77     path = wmalloc(strlen(gspath)+strlen(DEFAULTS_DIR)+strlen(domain)+4);
  78     strcpy(path, gspath);
  79     strcat(path, DEFAULTS_DIR);
  80     strcat(path, "/");
  81     strcat(path, domain);
  82
  83     return path;
  84 }
  85
  86
  87 static void
  88 #ifndef HAVE_ATEXIT
  89 saveDefaultsChanges(int foo, void *bar)
  90 #else
  91 saveDefaultsChanges(void)
  92 #endif
  93 {
  94     /* save the user defaults databases */
  95     if (sharedUserDefaults) {
  96         UserDefaults *tmp = sharedUserDefaults;
  97
  98         while (tmp) {
  99             if (tmp->appDomain && tmp->dirty)
 100                 PLShallowSynchronize(tmp->appDomain);
 101             tmp = tmp->next;
 102         }
 103     }
 104 }
 105
 106
 107 /* set to save changes in defaults when program is exited */
 108 static void
 109 registerSaveOnExit(void)
 110 {
 111     if (!registeredSaveOnExit) {
 112 #ifndef HAVE_ATEXIT
 113         on_exit(saveDefaultsChanges, (void*)NULL);
 114 #else
 115         atexit(saveDefaultsChanges);
 116 #endif
 117         registeredSaveOnExit = True;
 118     }
 119 }
 120
 121
 122 void
 123 WMSynchronizeUserDefaults(WMUserDefaults *database)
 124 {
 125     /* TODO: check what it should really do */
 126     PLShallowSynchronize(database->appDomain);
 127 }
 128
 129
 130 void
 131 WMSaveUserDefaults(WMUserDefaults *database)
 132 {
 133     PLSave(database->appDomain, YES);
 134 }
 135
 136
 137 WMUserDefaults*
 138 WMGetStandardUserDefaults(void)
 139 {
 140     WMUserDefaults *defaults;
 141     proplist_t domain;
 142     proplist_t key;
 143     char *path;
 144     int i;
 145
 146     if (sharedUserDefaults) {
 147         defaults = sharedUserDefaults;
 148         while (defaults) {
 149             /* Trick, path == NULL only for StandardUserDefaults db */
 150             if (defaults->path == NULL)
 151                 return defaults;
 152             defaults = defaults->next;
 153         }
 154     }
 155
 156     /* we didn't found the database we are looking for. Go read it. */
 157     defaults = wmalloc(sizeof(WMUserDefaults));
 158     memset(defaults, 0, sizeof(WMUserDefaults));
 159
 160     defaults->defaults = PLMakeDictionaryFromEntries(NULL, NULL, NULL);
 161
 162     defaults->searchList = wmalloc(sizeof(proplist_t)*3);
 163
 164     /* application domain */
 165     key = PLMakeString(WMGetApplicationName());
 166     defaults->searchList[0] = key;
 167
 168     /* temporary kluge */
 169     if (strcmp(WMGetApplicationName(), "WindowMaker")==0) {
 170         domain = NULL;
 171         path = NULL;
 172     } else {
 173         path = wdefaultspathfordomain(PLGetString(key));
 174
 175         domain = PLGetProplistWithPath(path);
 176     }
 177     if (!domain) {
 178         proplist_t p;
 179
 180         domain = PLMakeDictionaryFromEntries(NULL, NULL, NULL);
 181         if (path) {
 182             p = PLMakeString(path);
 183             PLSetFilename(domain, p);
 184             PLRelease(p);
 185         }
 186     }
 187     if (path)
 188         free(path);
 189
 190     defaults->appDomain = domain;
 191
 192     if (domain)
 193         PLInsertDictionaryEntry(defaults->defaults, key, domain);
 194
 195     PLRelease(key);
 196
 197     /* global domain */
 198     key = PLMakeString("WMGLOBAL");
 199     defaults->searchList[1] = key;
 200
 201     path = wdefaultspathfordomain(PLGetString(key));
 202
 203     domain = PLGetProplistWithPath(path);
 204
 205     free(path);
 206
 207     if (!domain)
 208         domain = PLMakeDictionaryFromEntries(NULL, NULL, NULL);
 209
 210     if (domain)
 211         PLInsertDictionaryEntry(defaults->defaults, key, domain);
 212
 213     PLRelease(key);
 214
 215     /* terminate list */
 216     defaults->searchList[2] = NULL;
 217
 218     defaults->searchListArray=PLMakeArrayFromElements(NULL,NULL);
 219
 220
 221     i = 0;
 222     while (defaults->searchList[i]) {
 223         PLAppendArrayElement(defaults->searchListArray,
 224                              defaults->searchList[i]);
 225         i++;
 226     }
 227
 228     if (sharedUserDefaults)
 229         defaults->next = sharedUserDefaults;
 230     sharedUserDefaults = defaults;
 231
 232     registerSaveOnExit();
 233
 234     return defaults;
 235 }
 236
 237
 238 WMUserDefaults*
 239 WMGetDefaultsFromPath(char *path)
 240 {
 241     WMUserDefaults *defaults;
 242     proplist_t domain;
 243     proplist_t key;
 244     char *name;
 245     int i;
 246
 247     assert(path != NULL);
 248
 249     if (sharedUserDefaults) {
 250         defaults = sharedUserDefaults;
 251         while (defaults) {
 252             if (defaults->path && strcmp(defaults->path, path) == 0)
 253                 return defaults;
 254             defaults = defaults->next;
 255         }
 256     }
 257
 258     /* we didn't found the database we are looking for. Go read it. */
 259     defaults = wmalloc(sizeof(WMUserDefaults));
 260     memset(defaults, 0, sizeof(WMUserDefaults));
 261
 262     defaults->defaults = PLMakeDictionaryFromEntries(NULL, NULL, NULL);
 263
 264     defaults->searchList = wmalloc(sizeof(proplist_t)*2);
 265
 266     /* the domain we want, go in the first position */
 267     name = strrchr(path, '/');
 268     if (!name)
 269         name = path;
 270     else
 271         name++;
 272
 273     key = PLMakeString(name);
 274     defaults->searchList[0] = key;
 275
 276     domain = PLGetProplistWithPath(path);
 277
 278     if (!domain) {
 279         proplist_t p;
 280
 281         domain = PLMakeDictionaryFromEntries(NULL, NULL, NULL);
 282         p = PLMakeString(path);
 283         PLSetFilename(domain, p);
 284         PLRelease(p);
 285     }
 286
 287     defaults->path = wstrdup(path);
 288
 289     defaults->appDomain = domain;
 290
 291     if (domain)
 292         PLInsertDictionaryEntry(defaults->defaults, key, domain);
 293
 294     PLRelease(key);
 295
 296     /* terminate list */
 297     defaults->searchList[1] = NULL;
 298
 299     defaults->searchListArray=PLMakeArrayFromElements(NULL,NULL);
 300
 301     i = 0;
 302     while (defaults->searchList[i]) {
 303         PLAppendArrayElement(defaults->searchListArray,
 304                              defaults->searchList[i]);
 305         i++;
 306     }
 307
 308     if (sharedUserDefaults)
 309         defaults->next = sharedUserDefaults;
 310     sharedUserDefaults = defaults;
 311
 312     registerSaveOnExit();
 313
 314     return defaults;
 315 }
 316
 317
 318 proplist_t
 319 WMGetUDObjectForKey(WMUserDefaults *database, char *defaultName)
 320 {
 321     proplist_t domainName, domain;
 322     proplist_t object = NULL;
 323     proplist_t key = PLMakeString(defaultName);
 324     int i = 0;
 325
 326     while (database->searchList[i] && !object) {
 327         domainName = database->searchList[i];
 328         domain = PLGetDictionaryEntry(database->defaults, domainName);
 329         if (domain) {
 330             object = PLGetDictionaryEntry(domain, key);
 331         }
 332         i++;
 333     }
 334     PLRelease(key);
 335
 336     return object;
 337 }
 338
 339
 340 void
 341 WMSetUDObjectForKey(WMUserDefaults *database, proplist_t object,
 342                     char *defaultName)
 343 {
 344     proplist_t key = PLMakeString(defaultName);
 345
 346     database->dirty = 1;
 347
 348     PLInsertDictionaryEntry(database->appDomain, key, object);
 349     PLRelease(key);
 350 }
 351
 352
 353 void
 354 WMRemoveUDObjectForKey(WMUserDefaults *database, char *defaultName)
 355 {
 356     proplist_t key = PLMakeString(defaultName);
 357
 358     database->dirty = 1;
 359
 360     PLRemoveDictionaryEntry(database->appDomain, key);
 361
 362     PLRelease(key);
 363 }
 364
 365
 366 char*
 367 WMGetUDStringForKey(WMUserDefaults *database, char *defaultName)
 368 {
 369     proplist_t val;
 370
 371     val = WMGetUDObjectForKey(database, defaultName);
 372
 373     if (!val)
 374         return NULL;
 375
 376     if (!PLIsString(val))
 377         return NULL;
 378
 379     return PLGetString(val);
 380 }
 381
 382
 383 int
 384 WMGetUDIntegerForKey(WMUserDefaults *database, char *defaultName)
 385 {
 386     proplist_t val;
 387     char *str;
 388     int value;
 389
 390     val = WMGetUDObjectForKey(database, defaultName);
 391
 392     if (!val)
 393         return 0;
 394
 395     if (!PLIsString(val))
 396         return 0;
 397
 398     str = PLGetString(val);
 399     if (!str)
 400         return 0;
 401
 402     if (sscanf(str, "%i", &value)!=1)
 403         return 0;
 404
 405     return value;
 406 }
 407
 408
 409
 410 float
 411 WMGetUDFloatForKey(WMUserDefaults *database, char *defaultName)
 412 {
 413     proplist_t val;
 414     char *str;
 415     float value;
 416
 417     val = WMGetUDObjectForKey(database, defaultName);
 418
 419     if (!val || !PLIsString(val))
 420         return 0.0;
 421
 422     if (!(str = PLGetString(val)))
 423         return 0.0;
 424
 425     if (sscanf(str, "%f", &value)!=1)
 426         return 0.0;
 427
 428     return value;
 429 }
 430
 431
 432
 433 Bool
 434 WMGetUDBoolForKey(WMUserDefaults *database, char *defaultName)
 435 {
 436     proplist_t val;
 437     int value;
 438     char *str;
 439
 440     val = WMGetUDObjectForKey(database, defaultName);
 441
 442     if (!val)
 443         return False;
 444
 445     if (!PLIsString(val))
 446         return False;
 447
 448     str = PLGetString(val);
 449     if (!str)
 450         return False;
 451
 452     if (sscanf(str, "%i", &value)==1 && value!=0)
 453         return True;
 454
 455     if (strcasecmp(str, "YES")==0)
 456         return True;
 457
 458     if (strcasecmp(str, "Y")==0)
 459         return True;
 460
 461     return False;
 462 }
 463
 464
 465 void
 466 WMSetUDIntegerForKey(WMUserDefaults *database, int value, char *defaultName)
 467 {
 468     proplist_t object;
 469     char buffer[128];
 470
 471     sprintf(buffer, "%i", value);
 472     object = PLMakeString(buffer);
 473
 474     WMSetUDObjectForKey(database, object, defaultName);
 475     PLRelease(object);
 476 }
 477
 478
 479
 480
 481 void
 482 WMSetUDStringForKey(WMUserDefaults *database, char *value, char *defaultName)
 483 {
 484     proplist_t object;
 485
 486     object = PLMakeString(value);
 487
 488     WMSetUDObjectForKey(database, object, defaultName);
 489     PLRelease(object);
 490 }
 491
 492
 493
 494 void
 495 WMSetUDFloatForKey(WMUserDefaults *database, float value, char *defaultName)
 496 {
 497     proplist_t object;
 498     char buffer[128];
 499
 500     sprintf(buffer, "%f", value);
 501     object = PLMakeString(buffer);
 502
 503     WMSetUDObjectForKey(database, object, defaultName);
 504     PLRelease(object);
 505 }
 506
 507
 508
 509 void
 510 WMSetUDBoolForKey(WMUserDefaults *database, Bool value, char *defaultName)
 511 {
 512     static proplist_t yes = NULL, no = NULL;
 513
 514     if (!yes) {
 515         yes = PLMakeString("YES");
 516         no = PLMakeString("NO");
 517     }
 518
 519     WMSetUDObjectForKey(database, value ? yes : no, defaultName);
 520 }
 521
 522
 523 proplist_t
 524 WMGetUDSearchList(WMUserDefaults *database)
 525 {
 526     return database->searchListArray;
 527 }
 528
 529
 530 void
 531 WMSetUDSearchList(WMUserDefaults *database, proplist_t list)
 532 {
 533     int i, c;
 534
 535     if (database->searchList) {
 536         i = 0;
 537         while (database->searchList[i]) {
 538             PLRelease(database->searchList[i]);
 539             i++;
 540         }
 541         free(database->searchList);
 542     }
 543     if (database->searchListArray) {
 544         PLRelease(database->searchListArray);
 545     }
 546
 547     c = PLGetNumberOfElements(list);
 548     database->searchList = wmalloc(sizeof(proplist_t)*(c+1));
 549
 550     for (i=0; i<c; i++) {
 551         database->searchList[i] = PLGetArrayElement(list, i);
 552     }
 553
 554     database->searchListArray = PLDeepCopy(list);
 555 }
 556
 557