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