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