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 float
 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 || !PLIsString(val))
 292         return 0.0;
 293
 294     if (!(str = PLGetString(val)))
 295         return 0.0;
 296
 297     if (sscanf(str, "%f", &value)!=1)
 298         return 0.0;
 299
 300     return value;
 301 }
 302
 303
 304
 305 Bool
 306 WMGetUDBoolForKey(WMUserDefaults *database, char *defaultName)
 307 {
 308     proplist_t val;
 309     int value;
 310     char *str;
 311
 312     val = WMGetUDObjectForKey(database, defaultName);
 313
 314     if (!val)
 315         return False;
 316
 317     if (!PLIsString(val))
 318         return False;
 319
 320     str = PLGetString(val);
 321     if (!str)
 322         return False;
 323
 324     if (sscanf(str, "%i", &value)==1 && value!=0)
 325         return True;
 326
 327     if (strcasecmp(str, "YES")==0)
 328         return True;
 329
 330     if (strcasecmp(str, "Y")==0)
 331         return True;
 332
 333     return False;
 334 }
 335
 336
 337 void
 338 WMSetUDIntegerForKey(WMUserDefaults *database, int value, char *defaultName)
 339 {
 340     proplist_t object;
 341     char buffer[128];
 342
 343     sprintf(buffer, "%i", value);
 344     object = PLMakeString(buffer);
 345
 346     WMSetUDObjectForKey(database, object, defaultName);
 347     PLRelease(object);
 348 }
 349
 350
 351
 352
 353 void
 354 WMSetUDStringForKey(WMUserDefaults *database, char *value, char *defaultName)
 355 {
 356     proplist_t object;
 357
 358     object = PLMakeString(value);
 359
 360     WMSetUDObjectForKey(database, object, defaultName);
 361     PLRelease(object);
 362 }
 363
 364
 365
 366 void
 367 WMSetUDFloatForKey(WMUserDefaults *database, float value, char *defaultName)
 368 {
 369     proplist_t object;
 370     char buffer[128];
 371
 372     sprintf(buffer, "%f", value);
 373     object = PLMakeString(buffer);
 374
 375     WMSetUDObjectForKey(database, object, defaultName);
 376     PLRelease(object);
 377 }
 378
 379
 380
 381 void
 382 WMSetUDBoolForKey(WMUserDefaults *database, Bool value, char *defaultName)
 383 {
 384     static proplist_t yes = NULL, no = NULL;
 385
 386     if (!yes) {
 387         yes = PLMakeString("YES");
 388         no = PLMakeString("NO");
 389     }
 390
 391     WMSetUDObjectForKey(database, value ? yes : no, defaultName);
 392 }
 393
 394
 395 proplist_t
 396 WMGetUDSearchList(WMUserDefaults *database)
 397 {
 398     return database->searchListArray;
 399 }
 400
 401
 402 void
 403 WMSetUDSearchList(WMUserDefaults *database, proplist_t list)
 404 {
 405     int i, c;
 406
 407     if (database->searchList) {
 408         i = 0;
 409         while (database->searchList[i]) {
 410             PLRelease(database->searchList[i]);
 411             i++;
 412         }
 413         free(database->searchList);
 414     }
 415     if (database->searchListArray) {
 416         PLRelease(database->searchListArray);
 417     }
 418
 419     c = PLGetNumberOfElements(list);
 420     database->searchList = wmalloc(sizeof(proplist_t)*(c+1));
 421
 422     for (i=0; i<c; i++) {
 423         database->searchList[i] = PLGetArrayElement(list, i);
 424     }
 425
 426     database->searchListArray = PLDeepCopy(list);
 427 }
 428
 429