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 saveDefaultsChanges(void)
  80 {
  81     if (sharedUserDefaults && sharedUserDefaults->dirty) {
  82         PLSave(sharedUserDefaults->appDomain, YES);
  83     }
  84 }
  85
  86
  87 WMUserDefaults*
  88 WMGetStandardUserDefaults(void)
  89 {
  90     if (!sharedUserDefaults) {
  91         WMUserDefaults *defaults;
  92
  93         proplist_t domain;
  94         proplist_t key;
  95         char *path;
  96         int i;
  97
  98         defaults = wmalloc(sizeof(WMUserDefaults));
  99         memset(defaults, 0, sizeof(WMUserDefaults));
 100
 101         defaults->defaults = PLMakeDictionaryFromEntries(NULL, NULL, NULL);
 102
 103         defaults->searchList = wmalloc(sizeof(proplist_t)*3);
 104
 105         /* application domain */
 106         key = PLMakeString(WMGetApplicationName());
 107         defaults->searchList[0] = key;
 108
 109         /* temporary kluge */
 110         if (strcmp(WMGetApplicationName(), "WindowMaker")==0) {
 111             domain = NULL;
 112             path = NULL;
 113         } else {
 114             path = wdefaultspathfordomain(PLGetString(key));
 115
 116             domain = PLGetProplistWithPath(path);
 117         }
 118         if (!domain) {
 119             proplist_t p;
 120
 121             domain = PLMakeDictionaryFromEntries(NULL, NULL, NULL);
 122             if (path) {
 123                 p = PLMakeString(path);
 124                 PLSetFilename(domain, p);
 125                 PLRelease(p);
 126             }
 127         }
 128         if (path)
 129             free(path);
 130
 131         defaults->appDomain = domain;
 132
 133         if (domain)
 134             PLInsertDictionaryEntry(defaults->defaults, key, domain);
 135
 136         PLRelease(key);
 137
 138         /* global domain */
 139         key = PLMakeString("WMGLOBAL");
 140         defaults->searchList[1] = key;
 141
 142         path = wdefaultspathfordomain(PLGetString(key));
 143
 144         domain = PLGetProplistWithPath(path);
 145
 146         free(path);
 147
 148         if (!domain)
 149             domain = PLMakeDictionaryFromEntries(NULL, NULL, NULL);
 150
 151         if (domain)
 152             PLInsertDictionaryEntry(defaults->defaults, key, domain);
 153
 154         PLRelease(key);
 155
 156         /* terminate list */
 157         defaults->searchList[2] = NULL;
 158
 159         defaults->searchListArray=PLMakeArrayFromElements(NULL,NULL);
 160
 161
 162         i = 0;
 163         while (defaults->searchList[i]) {
 164             PLAppendArrayElement(defaults->searchListArray,
 165                                  defaults->searchList[i]);
 166             i++;
 167         }
 168
 169         sharedUserDefaults = defaults;
 170
 171         /* set to save changes in defaults when program is exited */
 172
 173
 174 #ifndef HAVE_ATEXIT
 175         on_exit(saveDefaultsChanges,0);
 176 #else
 177         atexit(saveDefaultsChanges);
 178 #endif
 179     }
 180
 181     return sharedUserDefaults;
 182 }
 183
 184
 185
 186 proplist_t
 187 WMGetUDObjectForKey(WMUserDefaults *database, char *defaultName)
 188 {
 189     proplist_t domainName, domain;
 190     proplist_t object = NULL;
 191     proplist_t key = PLMakeString(defaultName);
 192     int i = 0;
 193
 194     while (database->searchList[i] && !object) {
 195         domainName = database->searchList[i];
 196         domain = PLGetDictionaryEntry(database->defaults, domainName);
 197         if (domain) {
 198             object = PLGetDictionaryEntry(domain, key);
 199         }
 200         i++;
 201     }
 202     PLRelease(key);
 203
 204     return object;
 205 }
 206
 207
 208 void
 209 WMSetUDObjectForKey(WMUserDefaults *database, proplist_t object,
 210                     char *defaultName)
 211 {
 212     proplist_t key = PLMakeString(defaultName);
 213
 214     database->dirty = 1;
 215
 216     PLInsertDictionaryEntry(database->appDomain, key, object);
 217     PLRelease(key);
 218 }
 219
 220
 221 void
 222 WMRemoveUDObjectForKey(WMUserDefaults *database, char *defaultName)
 223 {
 224     proplist_t key = PLMakeString(defaultName);
 225
 226     database->dirty = 1;
 227
 228     PLRemoveDictionaryEntry(database->appDomain, key);
 229
 230     PLRelease(key);
 231 }
 232
 233
 234 char*
 235 WMGetUDStringForKey(WMUserDefaults *database, char *defaultName)
 236 {
 237     proplist_t val;
 238
 239     val = WMGetUDObjectForKey(database, defaultName);
 240
 241     if (!val)
 242         return NULL;
 243
 244     if (!PLIsString(val))
 245         return NULL;
 246
 247     return wstrdup(PLGetString(val));
 248 }
 249
 250
 251 int
 252 WMGetUDIntegerForKey(WMUserDefaults *database, char *defaultName)
 253 {
 254     proplist_t val;
 255     char *str;
 256     int value;
 257
 258     val = WMGetUDObjectForKey(database, defaultName);
 259
 260     if (!val)
 261         return 0;
 262
 263     if (!PLIsString(val))
 264         return 0;
 265
 266     str = PLGetString(val);
 267     if (!str)
 268         return 0;
 269
 270     if (sscanf(str, "%i", &value)!=1)
 271         return 0;
 272
 273     return value;
 274 }
 275
 276
 277
 278 int
 279 WMGetUDFloatForKey(WMUserDefaults *database, char *defaultName)
 280 {
 281     proplist_t val;
 282     char *str;
 283     float value;
 284
 285     val = WMGetUDObjectForKey(database, defaultName);
 286
 287     if (!val)
 288         return 0.0;
 289
 290     if (!PLIsString(val))
 291         return 0.0;
 292
 293     str = PLGetString(val);
 294     if (!str)
 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