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 } UserDefaults;
  26
  27
  28 static UserDefaults *sharedUserDefaults = NULL;
  29
  30 extern char *WMGetApplicationName();
  31
  32 #define DEFAULTS_DIR "/Defaults"
  33
  34
  35 char*
  36 wusergnusteppath()
  37 {
  38     char *path;
  39     char *gspath;
  40     int pathlen;
  41
  42     gspath = getenv("GNUSTEP_USER_ROOT");
  43     if (gspath) {
  44         gspath = wexpandpath(gspath);
  45         pathlen = strlen(gspath) + 4;
  46         path = wmalloc(pathlen);
  47         strcpy(path, gspath);
  48         free(gspath);
  49     } else {
  50         pathlen = strlen(wgethomedir()) + 10;
  51         path = wmalloc(pathlen);
  52         strcpy(path, wgethomedir());
  53         strcat(path, "/GNUstep");
  54     }
  55
  56     return path;
  57 }
  58
  59
  60 char*
  61 wdefaultspathfordomain(char *domain)
  62 {
  63     char *path;
  64     char *gspath;
  65
  66     gspath = wusergnusteppath();
  67     path = wmalloc(strlen(gspath)+strlen(DEFAULTS_DIR)+strlen(domain)+4);
  68     strcpy(path, gspath);
  69     free(gspath);
  70     strcat(path, DEFAULTS_DIR);
  71     strcat(path, "/");
  72     strcat(path, domain);
  73
  74     return path;
  75 }
  76
  77
  78 static void
  79 #ifndef HAVE_ATEXIT
  80 saveDefaultsChanges(int foo, void *bar)
  81 #else
  82 saveDefaultsChanges(void)
  83 #endif
  84 {
  85     if (sharedUserDefaults && sharedUserDefaults->dirty) {
  86         PLSave(sharedUserDefaults->appDomain, YES);
  87     }
  88 }
  89
  90
  91 WMUserDefaults*
  92 WMGetStandardUserDefaults(void)
  93 {
  94     if (!sharedUserDefaults) {
  95         WMUserDefaults *defaults;
  96
  97         proplist_t domain;
  98         proplist_t key;
  99         char *path;
 100         int i;
 101
 102         defaults = wmalloc(sizeof(WMUserDefaults));
 103         memset(defaults, 0, sizeof(WMUserDefaults));
 104
 105         defaults->defaults = PLMakeDictionaryFromEntries(NULL, NULL, NULL);
 106
 107         defaults->searchList = wmalloc(sizeof(proplist_t)*3);
 108
 109         /* application domain */
 110         key = PLMakeString(WMGetApplicationName());
 111         defaults->searchList[0] = key;
 112
 113         /* temporary kluge */
 114         if (strcmp(WMGetApplicationName(), "WindowMaker")==0) {
 115             domain = NULL;
 116             path = NULL;
 117         } else {
 118             path = wdefaultspathfordomain(PLGetString(key));
 119
 120             domain = PLGetProplistWithPath(path);
 121         }
 122         if (!domain) {
 123             proplist_t p;
 124
 125             domain = PLMakeDictionaryFromEntries(NULL, NULL, NULL);
 126             if (path) {
 127                 p = PLMakeString(path);
 128                 PLSetFilename(domain, p);
 129                 PLRelease(p);
 130             }
 131         }
 132         if (path)
 133             free(path);
 134
 135         defaults->appDomain = domain;
 136
 137         if (domain)
 138             PLInsertDictionaryEntry(defaults->defaults, key, domain);
 139
 140         PLRelease(key);
 141
 142         /* global domain */
 143         key = PLMakeString("WMGLOBAL");
 144         defaults->searchList[1] = key;
 145
 146         path = wdefaultspathfordomain(PLGetString(key));
 147
 148         domain = PLGetProplistWithPath(path);
 149
 150         free(path);
 151
 152         if (!domain)
 153             domain = PLMakeDictionaryFromEntries(NULL, NULL, NULL);
 154
 155         if (domain)
 156             PLInsertDictionaryEntry(defaults->defaults, key, domain);
 157
 158         PLRelease(key);
 159
 160         /* terminate list */
 161         defaults->searchList[2] = NULL;
 162
 163         defaults->searchListArray=PLMakeArrayFromElements(NULL,NULL);
 164
 165
 166         i = 0;
 167         while (defaults->searchList[i]) {
 168             PLAppendArrayElement(defaults->searchListArray,
 169                                  defaults->searchList[i]);
 170             i++;
 171         }
 172
 173         sharedUserDefaults = defaults;
 174
 175         /* set to save changes in defaults when program is exited */
 176
 177
 178 #ifndef HAVE_ATEXIT
 179         on_exit(saveDefaultsChanges, (void*)NULL);
 180 #else
 181         atexit(saveDefaultsChanges);
 182 #endif
 183     }
 184
 185     return sharedUserDefaults;
 186 }
 187
 188
 189
 190 proplist_t
 191 WMGetUDObjectForKey(WMUserDefaults *database, char *defaultName)
 192 {
 193     proplist_t domainName, domain;
 194     proplist_t object = NULL;
 195     proplist_t key = PLMakeString(defaultName);
 196     int i = 0;
 197
 198     while (database->searchList[i] && !object) {
 199         domainName = database->searchList[i];
 200         domain = PLGetDictionaryEntry(database->defaults, domainName);
 201         if (domain) {
 202             object = PLGetDictionaryEntry(domain, key);
 203         }
 204         i++;
 205     }
 206     PLRelease(key);
 207
 208     return object;
 209 }
 210
 211
 212 void
 213 WMSetUDObjectForKey(WMUserDefaults *database, proplist_t object,
 214                     char *defaultName)
 215 {
 216     proplist_t key = PLMakeString(defaultName);
 217
 218     database->dirty = 1;
 219
 220     PLInsertDictionaryEntry(database->appDomain, key, object);
 221     PLRelease(key);
 222 }
 223
 224
 225 void
 226 WMRemoveUDObjectForKey(WMUserDefaults *database, char *defaultName)
 227 {
 228     proplist_t key = PLMakeString(defaultName);
 229
 230     database->dirty = 1;
 231
 232     PLRemoveDictionaryEntry(database->appDomain, key);
 233
 234     PLRelease(key);
 235 }
 236
 237
 238 char*
 239 WMGetUDStringForKey(WMUserDefaults *database, char *defaultName)
 240 {
 241     proplist_t val;
 242
 243     val = WMGetUDObjectForKey(database, defaultName);
 244
 245     if (!val)
 246         return NULL;
 247
 248     if (!PLIsString(val))
 249         return NULL;
 250
 251     return wstrdup(PLGetString(val));
 252 }
 253
 254
 255 int
 256 WMGetUDIntegerForKey(WMUserDefaults *database, char *defaultName)
 257 {
 258     proplist_t val;
 259     char *str;
 260     int value;
 261
 262     val = WMGetUDObjectForKey(database, defaultName);
 263
 264     if (!val)
 265         return 0;
 266
 267     if (!PLIsString(val))
 268         return 0;
 269
 270     str = PLGetString(val);
 271     if (!str)
 272         return 0;
 273
 274     if (sscanf(str, "%i", &value)!=1)
 275         return 0;
 276
 277     return value;
 278 }
 279
 280
 281
 282 int
 283 WMGetUDFloatForKey(WMUserDefaults *database, char *defaultName)
 284 {
 285     proplist_t val;
 286     char *str;
 287     float value;
 288
 289     val = WMGetUDObjectForKey(database, defaultName);
 290
 291     if (!val)
 292         return 0.0;
 293
 294     if (!PLIsString(val))
 295         return 0.0;
 296
 297     str = PLGetString(val);
 298     if (!str)
 299         return 0.0;
 300
 301     if (sscanf(str, "%f", &value)!=1)
 302         return 0.0;
 303
 304     return value;
 305 }
 306
 307
 308
 309 Bool
 310 WMGetUDBoolForKey(WMUserDefaults *database, char *defaultName)
 311 {
 312     proplist_t val;
 313     int value;
 314     char *str;
 315
 316     val = WMGetUDObjectForKey(database, defaultName);
 317
 318     if (!val)
 319         return False;
 320
 321     if (!PLIsString(val))
 322         return False;
 323
 324     str = PLGetString(val);
 325     if (!str)
 326         return False;
 327
 328     if (sscanf(str, "%i", &value)==1 && value!=0)
 329         return True;
 330
 331     if (strcasecmp(str, "YES")==0)
 332         return True;
 333
 334     if (strcasecmp(str, "Y")==0)
 335         return True;
 336
 337     return False;
 338 }
 339
 340
 341 void
 342 WMSetUDIntegerForKey(WMUserDefaults *database, int value, char *defaultName)
 343 {
 344     proplist_t object;
 345     char buffer[128];
 346
 347     sprintf(buffer, "%i", value);
 348     object = PLMakeString(buffer);
 349
 350     WMSetUDObjectForKey(database, object, defaultName);
 351     PLRelease(object);
 352 }
 353
 354
 355
 356
 357 void
 358 WMSetUDStringForKey(WMUserDefaults *database, char *value, char *defaultName)
 359 {
 360     proplist_t object;
 361
 362     object = PLMakeString(value);
 363
 364     WMSetUDObjectForKey(database, object, defaultName);
 365     PLRelease(object);
 366 }
 367
 368
 369
 370 void
 371 WMSetUDFloatForKey(WMUserDefaults *database, float value, char *defaultName)
 372 {
 373     proplist_t object;
 374     char buffer[128];
 375
 376     sprintf(buffer, "%f", value);
 377     object = PLMakeString(buffer);
 378
 379     WMSetUDObjectForKey(database, object, defaultName);
 380     PLRelease(object);
 381 }
 382
 383
 384
 385 void
 386 WMSetUDBoolForKey(WMUserDefaults *database, Bool value, char *defaultName)
 387 {
 388     static proplist_t yes = NULL, no = NULL;
 389
 390     if (!yes) {
 391         yes = PLMakeString("YES");
 392         no = PLMakeString("NO");
 393     }
 394
 395     WMSetUDObjectForKey(database, value ? yes : no, defaultName);
 396 }
 397
 398
 399 proplist_t
 400 WMGetUDSearchList(WMUserDefaults *database)
 401 {
 402     return database->searchListArray;
 403 }
 404
 405
 406 void
 407 WMSetUDSearchList(WMUserDefaults *database, proplist_t list)
 408 {
 409     int i, c;
 410
 411     if (database->searchList) {
 412         i = 0;
 413         while (database->searchList[i]) {
 414             PLRelease(database->searchList[i]);
 415             i++;
 416         }
 417         free(database->searchList);
 418     }
 419     if (database->searchListArray) {
 420         PLRelease(database->searchListArray);
 421     }
 422
 423     c = PLGetNumberOfElements(list);
 424     database->searchList = wmalloc(sizeof(proplist_t)*(c+1));
 425
 426     for (i=0; i<c; i++) {
 427         database->searchList[i] = PLGetArrayElement(list, i);
 428     }
 429
 430     database->searchListArray = PLDeepCopy(list);
 431 }
 432
 433