WINGs/userdefaults.c

   1
   2 #include <stdlib.h>
   3 #include <string.h>
   4 #include <stdio.h>
   5 #include <assert.h>
   6 #include <unistd.h>
   7 #include <sys/stat.h>
   8
   9
  10 #include "wconfig.h"
  11
  12 #include "WINGs.h"
  13
  14
  15
  16 typedef struct W_UserDefaults {
  17     WMPropList *defaults;
  18
  19     WMPropList *appDomain;
  20
  21     WMPropList *searchListArray;
  22     WMPropList **searchList;           /* cache for searchListArray */
  23
  24     char dirty;
  25
  26     char dontSync;
  27
  28     char *path;                        /* where is db located */
  29
  30     time_t timestamp;                  /* last modification time */
  31
  32     struct W_UserDefaults *next;
  33
  34 } UserDefaults;
  35
  36
  37 static UserDefaults *sharedUserDefaults = NULL;
  38
  39 char *WMUserDefaultsDidChangeNotification = "WMUserDefaultsDidChangeNotification";
  40
  41
  42 static void synchronizeUserDefaults(void *foo);
  43
  44 extern char *WMGetApplicationName();
  45
  46 #define DEFAULTS_DIR "/Defaults"
  47
  48 #define UD_SYNC_INTERVAL  2000
  49
  50
  51
  52 char*
  53 wusergnusteppath()
  54 {
  55     static char *path = NULL;
  56     char *gspath;
  57     int pathlen;
  58
  59     if (!path) {
  60         gspath = getenv("GNUSTEP_USER_ROOT");
  61         if (gspath) {
  62             gspath = wexpandpath(gspath);
  63             pathlen = strlen(gspath) + 4;
  64             path = wmalloc(pathlen);
  65             strcpy(path, gspath);
  66             wfree(gspath);
  67         } else {
  68             pathlen = strlen(wgethomedir()) + 10;
  69             path = wmalloc(pathlen);
  70             strcpy(path, wgethomedir());
  71             strcat(path, "/GNUstep");
  72         }
  73     }
  74
  75     return path;
  76 }
  77
  78
  79 char*
  80 wdefaultspathfordomain(char *domain)
  81 {
  82     char *path;
  83     char *gspath;
  84
  85     gspath = wusergnusteppath();
  86     path = wmalloc(strlen(gspath)+strlen(DEFAULTS_DIR)+strlen(domain)+4);
  87     strcpy(path, gspath);
  88     strcat(path, DEFAULTS_DIR);
  89     strcat(path, "/");
  90     strcat(path, domain);
  91
  92     return path;
  93 }
  94
  95
  96 static void
  97 #ifdef HAVE_ATEXIT
  98 saveDefaultsChanges(void)
  99 #else
 100 saveDefaultsChanges(int foo, void *bar)
 101 #endif
 102 {
 103     /* save the user defaults databases */
 104     synchronizeUserDefaults(NULL);
 105 }
 106
 107
 108 /* set to save changes in defaults when program is exited */
 109 static void
 110 registerSaveOnExit(void)
 111 {
 112     static Bool registeredSaveOnExit = False;
 113
 114     if (!registeredSaveOnExit) {
 115 #ifdef HAVE_ATEXIT
 116         atexit(saveDefaultsChanges);
 117 #else
 118         on_exit(saveDefaultsChanges, (void*)NULL);
 119 #endif
 120         registeredSaveOnExit = True;
 121     }
 122 }
 123
 124
 125 static void
 126 synchronizeUserDefaults(void *foo)
 127 {
 128     UserDefaults *database = sharedUserDefaults;
 129
 130     while (database) {
 131         if (!database->dontSync)
 132             WMSynchronizeUserDefaults(database);
 133         database = database->next;
 134     }
 135 }
 136
 137
 138 static void
 139 addSynchronizeTimerHandler(void)
 140 {
 141     static Bool initialized = False;
 142
 143     if (!initialized) {
 144         WMAddPersistentTimerHandler(UD_SYNC_INTERVAL, synchronizeUserDefaults,
 145                                     NULL);
 146         initialized = True;
 147     }
 148 }
 149
 150
 151 void
 152 WMEnableUDPeriodicSynchronization(WMUserDefaults *database, Bool enable)
 153 {
 154     database->dontSync = !enable;
 155 }
 156
 157
 158 void
 159 WMSynchronizeUserDefaults(WMUserDefaults *database)
 160 {
 161     Bool fileIsNewer = False, release = False, notify = False;
 162     WMPropList *plF, *key;
 163     char *path;
 164     struct stat stbuf;
 165
 166     if (!database->path) {
 167         path = wdefaultspathfordomain(WMGetApplicationName());
 168         release = True;
 169     } else {
 170         path = database->path;
 171     }
 172
 173     if (stat(path, &stbuf) >= 0 && stbuf.st_mtime > database->timestamp)
 174         fileIsNewer = True;
 175
 176     if (database->appDomain && (database->dirty || fileIsNewer)) {
 177         if (database->dirty && fileIsNewer) {
 178             plF = WMReadPropListFromFile(path);
 179             if (plF) {
 180                 plF = WMMergePLDictionaries(plF, database->appDomain, False);
 181                 WMReleasePropList(database->appDomain);
 182                 database->appDomain = plF;
 183                 key = database->searchList[0];
 184                 WMPutInPLDictionary(database->defaults, key, plF);
 185                 notify = True;
 186             } else {
 187                 /* something happened with the file. just overwrite it */
 188                 wwarning(_("cannot read domain from file '%s' when syncing"),
 189                          path);
 190                 WMWritePropListToFile(database->appDomain, path, True);
 191             }
 192         } else if (database->dirty) {
 193             WMWritePropListToFile(database->appDomain, path, True);
 194         } else if (fileIsNewer) {
 195             plF = WMReadPropListFromFile(path);
 196             if (plF) {
 197                 WMReleasePropList(database->appDomain);
 198                 database->appDomain = plF;
 199                 key = database->searchList[0];
 200                 WMPutInPLDictionary(database->defaults, key, plF);
 201                 notify = True;
 202             } else {
 203                 /* something happened with the file. just overwrite it */
 204                 wwarning(_("cannot read domain from file '%s' when syncing"),
 205                          path);
 206                 WMWritePropListToFile(database->appDomain, path, True);
 207             }
 208         }
 209
 210         database->dirty = 0;
 211
 212         if (stat(path, &stbuf) >= 0)
 213             database->timestamp = stbuf.st_mtime;
 214
 215         if (notify) {
 216             WMPostNotificationName(WMUserDefaultsDidChangeNotification,
 217                                    database, NULL);
 218         }
 219     }
 220
 221     if (release)
 222         wfree(path);
 223
 224 }
 225
 226
 227 void
 228 WMSaveUserDefaults(WMUserDefaults *database)
 229 {
 230     if (database->appDomain) {
 231         struct stat stbuf;
 232         char *path;
 233         Bool release = False;
 234
 235         if (!database->path) {
 236             path = wdefaultspathfordomain(WMGetApplicationName());
 237             release = True;
 238         } else {
 239             path = database->path;
 240         }
 241         WMWritePropListToFile(database->appDomain, path, True);
 242         database->dirty = 0;
 243         if (stat(path, &stbuf) >= 0)
 244             database->timestamp = stbuf.st_mtime;
 245         if (release)
 246             wfree(path);
 247     }
 248 }
 249
 250
 251 WMUserDefaults*
 252 WMGetStandardUserDefaults(void)
 253 {
 254     WMUserDefaults *defaults;
 255     WMPropList *domain;
 256     WMPropList *key;
 257     struct stat stbuf;
 258     char *path;
 259     int i;
 260
 261     if (sharedUserDefaults) {
 262         defaults = sharedUserDefaults;
 263         while (defaults) {
 264             /* path == NULL only for StandardUserDefaults db */
 265             if (defaults->path == NULL)
 266                 return defaults;
 267             defaults = defaults->next;
 268         }
 269     }
 270
 271     /* we didn't found the database we are looking for. Go read it. */
 272     defaults = wmalloc(sizeof(WMUserDefaults));
 273     memset(defaults, 0, sizeof(WMUserDefaults));
 274
 275     defaults->defaults = WMCreatePLDictionary(NULL, NULL);
 276
 277     defaults->searchList = wmalloc(sizeof(WMPropList*)*3);
 278
 279     /* application domain */
 280     key = WMCreatePLString(WMGetApplicationName());
 281     defaults->searchList[0] = key;
 282
 283     /* temporary kluge. wmaker handles synchronization itself */
 284     if (strcmp(WMGetApplicationName(), "WindowMaker")==0) {
 285         defaults->dontSync = 1;
 286     }
 287
 288     path = wdefaultspathfordomain(WMGetFromPLString(key));
 289
 290     if (stat(path, &stbuf) >= 0)
 291         defaults->timestamp = stbuf.st_mtime;
 292
 293     domain = WMReadPropListFromFile(path);
 294
 295     if (!domain)
 296         domain = WMCreatePLDictionary(NULL, NULL);
 297
 298     if (path)
 299         wfree(path);
 300
 301     defaults->appDomain = domain;
 302
 303     if (domain)
 304         WMPutInPLDictionary(defaults->defaults, key, domain);
 305
 306     /* global domain */
 307     key = WMCreatePLString("WMGLOBAL");
 308     defaults->searchList[1] = key;
 309
 310     path = wdefaultspathfordomain(WMGetFromPLString(key));
 311
 312     domain = WMReadPropListFromFile(path);
 313
 314     wfree(path);
 315
 316     if (!domain)
 317         domain = WMCreatePLDictionary(NULL, NULL);
 318
 319     if (domain)
 320         WMPutInPLDictionary(defaults->defaults, key, domain);
 321
 322     /* terminate list */
 323     defaults->searchList[2] = NULL;
 324
 325     defaults->searchListArray = WMCreatePLArray(NULL,NULL);
 326
 327     i = 0;
 328     while (defaults->searchList[i]) {
 329         WMAddToPLArray(defaults->searchListArray,
 330                        defaults->searchList[i]);
 331         i++;
 332     }
 333
 334     if (sharedUserDefaults)
 335         defaults->next = sharedUserDefaults;
 336     sharedUserDefaults = defaults;
 337
 338     addSynchronizeTimerHandler();
 339     registerSaveOnExit();
 340
 341     return defaults;
 342 }
 343
 344
 345 WMUserDefaults*
 346 WMGetDefaultsFromPath(char *path)
 347 {
 348     WMUserDefaults *defaults;
 349     WMPropList *domain;
 350     WMPropList *key;
 351     struct stat stbuf;
 352     char *name;
 353     int i;
 354
 355     assert(path != NULL);
 356
 357     if (sharedUserDefaults) {
 358         defaults = sharedUserDefaults;
 359         while (defaults) {
 360             if (defaults->path && strcmp(defaults->path, path) == 0)
 361                 return defaults;
 362             defaults = defaults->next;
 363         }
 364     }
 365
 366     /* we didn't found the database we are looking for. Go read it. */
 367     defaults = wmalloc(sizeof(WMUserDefaults));
 368     memset(defaults, 0, sizeof(WMUserDefaults));
 369
 370     defaults->defaults = WMCreatePLDictionary(NULL, NULL);
 371
 372     defaults->searchList = wmalloc(sizeof(WMPropList*)*2);
 373
 374     /* the domain we want, go in the first position */
 375     name = strrchr(path, '/');
 376     if (!name)
 377         name = path;
 378     else
 379         name++;
 380
 381     key = WMCreatePLString(name);
 382     defaults->searchList[0] = key;
 383
 384     if (stat(path, &stbuf) >= 0)
 385         defaults->timestamp = stbuf.st_mtime;
 386
 387     domain = WMReadPropListFromFile(path);
 388
 389     if (!domain)
 390         domain = WMCreatePLDictionary(NULL, NULL);
 391
 392     defaults->path = wstrdup(path);
 393
 394     defaults->appDomain = domain;
 395
 396     if (domain)
 397         WMPutInPLDictionary(defaults->defaults, key, domain);
 398
 399     /* terminate list */
 400     defaults->searchList[1] = NULL;
 401
 402     defaults->searchListArray = WMCreatePLArray(NULL,NULL);
 403
 404     i = 0;
 405     while (defaults->searchList[i]) {
 406         WMAddToPLArray(defaults->searchListArray,
 407                        defaults->searchList[i]);
 408         i++;
 409     }
 410
 411     if (sharedUserDefaults)
 412         defaults->next = sharedUserDefaults;
 413     sharedUserDefaults = defaults;
 414
 415     addSynchronizeTimerHandler();
 416     registerSaveOnExit();
 417
 418     return defaults;
 419 }
 420
 421
 422 /* Returns a WMPropList array with all keys in the user defaults database.
 423  * Free the array with WMReleasePropList() when no longer needed,
 424  * but do not free the elements of the array! They're just references. */
 425 WMPropList*
 426 WMGetUDKeys(WMUserDefaults *database)
 427 {
 428     return WMGetPLDictionaryKeys(database->appDomain);
 429 }
 430
 431
 432 WMPropList*
 433 WMGetUDObjectForKey(WMUserDefaults *database, char *defaultName)
 434 {
 435     WMPropList *domainName, *domain;
 436     WMPropList *object = NULL;
 437     WMPropList *key = WMCreatePLString(defaultName);
 438     int i = 0;
 439
 440     while (database->searchList[i] && !object) {
 441         domainName = database->searchList[i];
 442         domain = WMGetFromPLDictionary(database->defaults, domainName);
 443         if (domain) {
 444             object = WMGetFromPLDictionary(domain, key);
 445         }
 446         i++;
 447     }
 448     WMReleasePropList(key);
 449
 450     return object;
 451 }
 452
 453
 454 void
 455 WMSetUDObjectForKey(WMUserDefaults *database, WMPropList *object,
 456                     char *defaultName)
 457 {
 458     WMPropList *key = WMCreatePLString(defaultName);
 459
 460     database->dirty = 1;
 461
 462     WMPutInPLDictionary(database->appDomain, key, object);
 463     WMReleasePropList(key);
 464 }
 465
 466
 467 void
 468 WMRemoveUDObjectForKey(WMUserDefaults *database, char *defaultName)
 469 {
 470     WMPropList *key = WMCreatePLString(defaultName);
 471
 472     database->dirty = 1;
 473
 474     WMRemoveFromPLDictionary(database->appDomain, key);
 475
 476     WMReleasePropList(key);
 477 }
 478
 479
 480 char*
 481 WMGetUDStringForKey(WMUserDefaults *database, char *defaultName)
 482 {
 483     WMPropList *val;
 484
 485     val = WMGetUDObjectForKey(database, defaultName);
 486
 487     if (!val)
 488         return NULL;
 489
 490     if (!WMIsPLString(val))
 491         return NULL;
 492
 493     return WMGetFromPLString(val);
 494 }
 495
 496
 497 int
 498 WMGetUDIntegerForKey(WMUserDefaults *database, char *defaultName)
 499 {
 500     WMPropList *val;
 501     char *str;
 502     int value;
 503
 504     val = WMGetUDObjectForKey(database, defaultName);
 505
 506     if (!val)
 507         return 0;
 508
 509     if (!WMIsPLString(val))
 510         return 0;
 511
 512     str = WMGetFromPLString(val);
 513     if (!str)
 514         return 0;
 515
 516     if (sscanf(str, "%i", &value)!=1)
 517         return 0;
 518
 519     return value;
 520 }
 521
 522
 523
 524 float
 525 WMGetUDFloatForKey(WMUserDefaults *database, char *defaultName)
 526 {
 527     WMPropList *val;
 528     char *str;
 529     float value;
 530
 531     val = WMGetUDObjectForKey(database, defaultName);
 532
 533     if (!val || !WMIsPLString(val))
 534         return 0.0;
 535
 536     if (!(str = WMGetFromPLString(val)))
 537         return 0.0;
 538
 539     if (sscanf(str, "%f", &value)!=1)
 540         return 0.0;
 541
 542     return value;
 543 }
 544
 545
 546
 547 Bool
 548 WMGetUDBoolForKey(WMUserDefaults *database, char *defaultName)
 549 {
 550     WMPropList *val;
 551     int value;
 552     char *str;
 553
 554     val = WMGetUDObjectForKey(database, defaultName);
 555
 556     if (!val)
 557         return False;
 558
 559     if (!WMIsPLString(val))
 560         return False;
 561
 562     str = WMGetFromPLString(val);
 563     if (!str)
 564         return False;
 565
 566     if (sscanf(str, "%i", &value)==1 && value!=0)
 567         return True;
 568
 569     if (strcasecmp(str, "YES")==0)
 570         return True;
 571
 572     if (strcasecmp(str, "Y")==0)
 573         return True;
 574
 575     return False;
 576 }
 577
 578
 579 void
 580 WMSetUDIntegerForKey(WMUserDefaults *database, int value, char *defaultName)
 581 {
 582     WMPropList *object;
 583     char buffer[128];
 584
 585     sprintf(buffer, "%i", value);
 586     object = WMCreatePLString(buffer);
 587
 588     WMSetUDObjectForKey(database, object, defaultName);
 589     WMReleasePropList(object);
 590 }
 591
 592
 593
 594
 595 void
 596 WMSetUDStringForKey(WMUserDefaults *database, char *value, char *defaultName)
 597 {
 598     WMPropList *object;
 599
 600     object = WMCreatePLString(value);
 601
 602     WMSetUDObjectForKey(database, object, defaultName);
 603     WMReleasePropList(object);
 604 }
 605
 606
 607
 608 void
 609 WMSetUDFloatForKey(WMUserDefaults *database, float value, char *defaultName)
 610 {
 611     WMPropList *object;
 612     char buffer[128];
 613
 614     sprintf(buffer, "%f", value);
 615     object = WMCreatePLString(buffer);
 616
 617     WMSetUDObjectForKey(database, object, defaultName);
 618     WMReleasePropList(object);
 619 }
 620
 621
 622
 623 void
 624 WMSetUDBoolForKey(WMUserDefaults *database, Bool value, char *defaultName)
 625 {
 626     static WMPropList *yes = NULL, *no = NULL;
 627
 628     if (!yes) {
 629         yes = WMCreatePLString("YES");
 630         no = WMCreatePLString("NO");
 631     }
 632
 633     WMSetUDObjectForKey(database, value ? yes : no, defaultName);
 634 }
 635
 636
 637 WMPropList*
 638 WMGetUDSearchList(WMUserDefaults *database)
 639 {
 640     return database->searchListArray;
 641 }
 642
 643
 644 void
 645 WMSetUDSearchList(WMUserDefaults *database, WMPropList *list)
 646 {
 647     int i, c;
 648
 649     if (database->searchList) {
 650         i = 0;
 651         while (database->searchList[i]) {
 652             WMReleasePropList(database->searchList[i]);
 653             i++;
 654         }
 655         wfree(database->searchList);
 656     }
 657     if (database->searchListArray) {
 658         WMReleasePropList(database->searchListArray);
 659     }
 660
 661     c = WMGetPropListItemCount(list);
 662     database->searchList = wmalloc(sizeof(WMPropList*)*(c+1));
 663
 664     for (i=0; i<c; i++) {
 665         database->searchList[i] = WMGetFromPLArray(list, i);
 666     }
 667     database->searchList[c] = NULL;
 668
 669     database->searchListArray = WMDeepCopyPropList(list);
 670 }
 671
 672