WINGs/userdefaults.c

   1
   2 #include <stdlib.h>
   3 #include <strings.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                 PLSave(tmp->appDomain, YES);
 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     PLSave(database->appDomain, YES);
 127 }
 128
 129
 130 WMUserDefaults*
 131 WMGetStandardUserDefaults(void)
 132 {
 133     WMUserDefaults *defaults;
 134     proplist_t domain;
 135     proplist_t key;
 136     char *path;
 137     int i;
 138
 139     if (sharedUserDefaults) {
 140         defaults = sharedUserDefaults;
 141         while (defaults) {
 142             /* Trick, path == NULL only for StandardUserDefaults db */
 143             if (defaults->path == NULL)
 144                 return defaults;
 145             defaults = defaults->next;
 146         }
 147     }
 148
 149     /* we didn't found the database we are looking for. Go read it. */
 150     defaults = wmalloc(sizeof(WMUserDefaults));
 151     memset(defaults, 0, sizeof(WMUserDefaults));
 152
 153     defaults->defaults = PLMakeDictionaryFromEntries(NULL, NULL, NULL);
 154
 155     defaults->searchList = wmalloc(sizeof(proplist_t)*3);
 156
 157     /* application domain */
 158     key = PLMakeString(WMGetApplicationName());
 159     defaults->searchList[0] = key;
 160
 161     /* temporary kluge */
 162     if (strcmp(WMGetApplicationName(), "WindowMaker")==0) {
 163         domain = NULL;
 164         path = NULL;
 165     } else {
 166         path = wdefaultspathfordomain(PLGetString(key));
 167
 168         domain = PLGetProplistWithPath(path);
 169     }
 170     if (!domain) {
 171         proplist_t p;
 172
 173         domain = PLMakeDictionaryFromEntries(NULL, NULL, NULL);
 174         if (path) {
 175             p = PLMakeString(path);
 176             PLSetFilename(domain, p);
 177             PLRelease(p);
 178         }
 179     }
 180     if (path)
 181         free(path);
 182
 183     defaults->appDomain = domain;
 184
 185     if (domain)
 186         PLInsertDictionaryEntry(defaults->defaults, key, domain);
 187
 188     PLRelease(key);
 189
 190     /* global domain */
 191     key = PLMakeString("WMGLOBAL");
 192     defaults->searchList[1] = key;
 193
 194     path = wdefaultspathfordomain(PLGetString(key));
 195
 196     domain = PLGetProplistWithPath(path);
 197
 198     free(path);
 199
 200     if (!domain)
 201         domain = PLMakeDictionaryFromEntries(NULL, NULL, NULL);
 202
 203     if (domain)
 204         PLInsertDictionaryEntry(defaults->defaults, key, domain);
 205
 206     PLRelease(key);
 207
 208     /* terminate list */
 209     defaults->searchList[2] = NULL;
 210
 211     defaults->searchListArray=PLMakeArrayFromElements(NULL,NULL);
 212
 213
 214     i = 0;
 215     while (defaults->searchList[i]) {
 216         PLAppendArrayElement(defaults->searchListArray,
 217                              defaults->searchList[i]);
 218         i++;
 219     }
 220
 221     if (sharedUserDefaults)
 222         defaults->next = sharedUserDefaults;
 223     sharedUserDefaults = defaults;
 224
 225     registerSaveOnExit();
 226
 227     return defaults;
 228 }
 229
 230
 231 WMUserDefaults*
 232 WMGetDefaultsFromPath(char *path)
 233 {
 234     WMUserDefaults *defaults;
 235     proplist_t domain;
 236     proplist_t key;
 237     char *name;
 238     int i;
 239
 240     assert(path != NULL);
 241
 242     if (sharedUserDefaults) {
 243         defaults = sharedUserDefaults;
 244         while (defaults) {
 245             if (defaults->path && strcmp(defaults->path, path) == 0)
 246                 return defaults;
 247             defaults = defaults->next;
 248         }
 249     }
 250
 251     /* we didn't found the database we are looking for. Go read it. */
 252     defaults = wmalloc(sizeof(WMUserDefaults));
 253     memset(defaults, 0, sizeof(WMUserDefaults));
 254
 255     defaults->defaults = PLMakeDictionaryFromEntries(NULL, NULL, NULL);
 256
 257     defaults->searchList = wmalloc(sizeof(proplist_t)*2);
 258
 259     /* the domain we want, go in the first position */
 260     name = strrchr(path, '/');
 261     if (!name)
 262         name = path;
 263     else
 264         name++;
 265
 266     key = PLMakeString(name);
 267     defaults->searchList[0] = key;
 268
 269     domain = PLGetProplistWithPath(path);
 270
 271     if (!domain) {
 272         proplist_t p;
 273
 274         domain = PLMakeDictionaryFromEntries(NULL, NULL, NULL);
 275         p = PLMakeString(path);
 276         PLSetFilename(domain, p);
 277         PLRelease(p);
 278     }
 279
 280     defaults->path = wstrdup(path);
 281
 282     defaults->appDomain = domain;
 283
 284     if (domain)
 285         PLInsertDictionaryEntry(defaults->defaults, key, domain);
 286
 287     PLRelease(key);
 288
 289     /* terminate list */
 290     defaults->searchList[1] = NULL;
 291
 292     defaults->searchListArray=PLMakeArrayFromElements(NULL,NULL);
 293
 294     i = 0;
 295     while (defaults->searchList[i]) {
 296         PLAppendArrayElement(defaults->searchListArray,
 297                              defaults->searchList[i]);
 298         i++;
 299     }
 300
 301     if (sharedUserDefaults)
 302         defaults->next = sharedUserDefaults;
 303     sharedUserDefaults = defaults;
 304
 305     registerSaveOnExit();
 306
 307     return defaults;
 308 }
 309
 310
 311 proplist_t
 312 WMGetUDObjectForKey(WMUserDefaults *database, char *defaultName)
 313 {
 314     proplist_t domainName, domain;
 315     proplist_t object = NULL;
 316     proplist_t key = PLMakeString(defaultName);
 317     int i = 0;
 318
 319     while (database->searchList[i] && !object) {
 320         domainName = database->searchList[i];
 321         domain = PLGetDictionaryEntry(database->defaults, domainName);
 322         if (domain) {
 323             object = PLGetDictionaryEntry(domain, key);
 324         }
 325         i++;
 326     }
 327     PLRelease(key);
 328
 329     return object;
 330 }
 331
 332
 333 void
 334 WMSetUDObjectForKey(WMUserDefaults *database, proplist_t object,
 335                     char *defaultName)
 336 {
 337     proplist_t key = PLMakeString(defaultName);
 338
 339     database->dirty = 1;
 340
 341     PLInsertDictionaryEntry(database->appDomain, key, object);
 342     PLRelease(key);
 343 }
 344
 345
 346 void
 347 WMRemoveUDObjectForKey(WMUserDefaults *database, char *defaultName)
 348 {
 349     proplist_t key = PLMakeString(defaultName);
 350
 351     database->dirty = 1;
 352
 353     PLRemoveDictionaryEntry(database->appDomain, key);
 354
 355     PLRelease(key);
 356 }
 357
 358
 359 char*
 360 WMGetUDStringForKey(WMUserDefaults *database, char *defaultName)
 361 {
 362     proplist_t val;
 363
 364     val = WMGetUDObjectForKey(database, defaultName);
 365
 366     if (!val)
 367         return NULL;
 368
 369     if (!PLIsString(val))
 370         return NULL;
 371
 372     return wstrdup(PLGetString(val));
 373 }
 374
 375
 376 int
 377 WMGetUDIntegerForKey(WMUserDefaults *database, char *defaultName)
 378 {
 379     proplist_t val;
 380     char *str;
 381     int value;
 382
 383     val = WMGetUDObjectForKey(database, defaultName);
 384
 385     if (!val)
 386         return 0;
 387
 388     if (!PLIsString(val))
 389         return 0;
 390
 391     str = PLGetString(val);
 392     if (!str)
 393         return 0;
 394
 395     if (sscanf(str, "%i", &value)!=1)
 396         return 0;
 397
 398     return value;
 399 }
 400
 401
 402
 403 float
 404 WMGetUDFloatForKey(WMUserDefaults *database, char *defaultName)
 405 {
 406     proplist_t val;
 407     char *str;
 408     float value;
 409
 410     val = WMGetUDObjectForKey(database, defaultName);
 411
 412     if (!val || !PLIsString(val))
 413         return 0.0;
 414
 415     if (!(str = PLGetString(val)))
 416         return 0.0;
 417
 418     if (sscanf(str, "%f", &value)!=1)
 419         return 0.0;
 420
 421     return value;
 422 }
 423
 424
 425
 426 Bool
 427 WMGetUDBoolForKey(WMUserDefaults *database, char *defaultName)
 428 {
 429     proplist_t val;
 430     int value;
 431     char *str;
 432
 433     val = WMGetUDObjectForKey(database, defaultName);
 434
 435     if (!val)
 436         return False;
 437
 438     if (!PLIsString(val))
 439         return False;
 440
 441     str = PLGetString(val);
 442     if (!str)
 443         return False;
 444
 445     if (sscanf(str, "%i", &value)==1 && value!=0)
 446         return True;
 447
 448     if (strcasecmp(str, "YES")==0)
 449         return True;
 450
 451     if (strcasecmp(str, "Y")==0)
 452         return True;
 453
 454     return False;
 455 }
 456
 457
 458 void
 459 WMSetUDIntegerForKey(WMUserDefaults *database, int value, char *defaultName)
 460 {
 461     proplist_t object;
 462     char buffer[128];
 463
 464     sprintf(buffer, "%i", value);
 465     object = PLMakeString(buffer);
 466
 467     WMSetUDObjectForKey(database, object, defaultName);
 468     PLRelease(object);
 469 }
 470
 471
 472
 473
 474 void
 475 WMSetUDStringForKey(WMUserDefaults *database, char *value, char *defaultName)
 476 {
 477     proplist_t object;
 478
 479     object = PLMakeString(value);
 480
 481     WMSetUDObjectForKey(database, object, defaultName);
 482     PLRelease(object);
 483 }
 484
 485
 486
 487 void
 488 WMSetUDFloatForKey(WMUserDefaults *database, float value, char *defaultName)
 489 {
 490     proplist_t object;
 491     char buffer[128];
 492
 493     sprintf(buffer, "%f", value);
 494     object = PLMakeString(buffer);
 495
 496     WMSetUDObjectForKey(database, object, defaultName);
 497     PLRelease(object);
 498 }
 499
 500
 501
 502 void
 503 WMSetUDBoolForKey(WMUserDefaults *database, Bool value, char *defaultName)
 504 {
 505     static proplist_t yes = NULL, no = NULL;
 506
 507     if (!yes) {
 508         yes = PLMakeString("YES");
 509         no = PLMakeString("NO");
 510     }
 511
 512     WMSetUDObjectForKey(database, value ? yes : no, defaultName);
 513 }
 514
 515
 516 proplist_t
 517 WMGetUDSearchList(WMUserDefaults *database)
 518 {
 519     return database->searchListArray;
 520 }
 521
 522
 523 void
 524 WMSetUDSearchList(WMUserDefaults *database, proplist_t list)
 525 {
 526     int i, c;
 527
 528     if (database->searchList) {
 529         i = 0;
 530         while (database->searchList[i]) {
 531             PLRelease(database->searchList[i]);
 532             i++;
 533         }
 534         free(database->searchList);
 535     }
 536     if (database->searchListArray) {
 537         PLRelease(database->searchListArray);
 538     }
 539
 540     c = PLGetNumberOfElements(list);
 541     database->searchList = wmalloc(sizeof(proplist_t)*(c+1));
 542
 543     for (i=0; i<c; i++) {
 544         database->searchList[i] = PLGetArrayElement(list, i);
 545     }
 546
 547     database->searchListArray = PLDeepCopy(list);
 548 }
 549
 550