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