WINGs/userdefaults.c

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