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         atexit(saveDefaultsChanges);
 170     }
 171
 172     return sharedUserDefaults;
 173 }
 174
 175
 176
 177 proplist_t
 178 WMGetUDObjectForKey(WMUserDefaults *database, char *defaultName)
 179 {
 180     proplist_t domainName, domain;
 181     proplist_t object = NULL;
 182     proplist_t key = PLMakeString(defaultName);
 183     int i = 0;
 184
 185     while (database->searchList[i] && !object) {
 186         domainName = database->searchList[i];
 187         domain = PLGetDictionaryEntry(database->defaults, domainName);
 188         if (domain) {
 189             object = PLGetDictionaryEntry(domain, key);
 190         }
 191         i++;
 192     }
 193     PLRelease(key);
 194
 195     return object;
 196 }
 197
 198
 199 void
 200 WMSetUDObjectForKey(WMUserDefaults *database, proplist_t object,
 201                     char *defaultName)
 202 {
 203     proplist_t key = PLMakeString(defaultName);
 204
 205     database->dirty = 1;
 206
 207     PLInsertDictionaryEntry(database->appDomain, key, object);
 208     PLRelease(key);
 209 }
 210
 211
 212 void
 213 WMRemoveUDObjectForKey(WMUserDefaults *database, char *defaultName)
 214 {
 215     proplist_t key = PLMakeString(defaultName);
 216
 217     database->dirty = 1;
 218
 219     PLRemoveDictionaryEntry(database->appDomain, key);
 220
 221     PLRelease(key);
 222 }
 223
 224
 225 char*
 226 WMGetUDStringForKey(WMUserDefaults *database, char *defaultName)
 227 {
 228     proplist_t val;
 229
 230     val = WMGetUDObjectForKey(database, defaultName);
 231
 232     if (!val)
 233         return NULL;
 234
 235     if (!PLIsString(val))
 236         return NULL;
 237
 238     return wstrdup(PLGetString(val));
 239 }
 240
 241
 242 int
 243 WMGetUDIntegerForKey(WMUserDefaults *database, char *defaultName)
 244 {
 245     proplist_t val;
 246     char *str;
 247     int value;
 248
 249     val = WMGetUDObjectForKey(database, defaultName);
 250
 251     if (!val)
 252         return 0;
 253
 254     if (!PLIsString(val))
 255         return 0;
 256
 257     str = PLGetString(val);
 258     if (!str)
 259         return 0;
 260
 261     if (sscanf(str, "%i", &value)!=1)
 262         return 0;
 263
 264     return value;
 265 }
 266
 267
 268
 269 int
 270 WMGetUDFloatForKey(WMUserDefaults *database, char *defaultName)
 271 {
 272     proplist_t val;
 273     char *str;
 274     float value;
 275
 276     val = WMGetUDObjectForKey(database, defaultName);
 277
 278     if (!val)
 279         return 0.0;
 280
 281     if (!PLIsString(val))
 282         return 0.0;
 283
 284     str = PLGetString(val);
 285     if (!str)
 286         return 0.0;
 287
 288     if (sscanf(str, "%f", &value)!=1)
 289         return 0.0;
 290
 291     return value;
 292 }
 293
 294
 295
 296 Bool
 297 WMGetUDBoolForKey(WMUserDefaults *database, char *defaultName)
 298 {
 299     proplist_t val;
 300     int value;
 301     char *str;
 302
 303     val = WMGetUDObjectForKey(database, defaultName);
 304
 305     if (!val)
 306         return False;
 307
 308     if (!PLIsString(val))
 309         return False;
 310
 311     str = PLGetString(val);
 312     if (!str)
 313         return False;
 314
 315     if (sscanf(str, "%i", &value)==1 && value!=0)
 316         return True;
 317
 318     if (strcasecmp(str, "YES")==0)
 319         return True;
 320
 321     if (strcasecmp(str, "Y")==0)
 322         return True;
 323
 324     return False;
 325 }
 326
 327
 328 void
 329 WMSetUDIntegerForKey(WMUserDefaults *database, int value, char *defaultName)
 330 {
 331     proplist_t object;
 332     char buffer[128];
 333
 334     sprintf(buffer, "%i", value);
 335     object = PLMakeString(buffer);
 336
 337     WMSetUDObjectForKey(database, object, defaultName);
 338     PLRelease(object);
 339 }
 340
 341
 342
 343
 344 void
 345 WMSetUDStringForKey(WMUserDefaults *database, char *value, char *defaultName)
 346 {
 347     proplist_t object;
 348
 349     object = PLMakeString(value);
 350
 351     WMSetUDObjectForKey(database, object, defaultName);
 352     PLRelease(object);
 353 }
 354
 355
 356
 357 void
 358 WMSetUDFloatForKey(WMUserDefaults *database, float value, char *defaultName)
 359 {
 360     proplist_t object;
 361     char buffer[128];
 362
 363     sprintf(buffer, "%f", value);
 364     object = PLMakeString(buffer);
 365
 366     WMSetUDObjectForKey(database, object, defaultName);
 367     PLRelease(object);
 368 }
 369
 370
 371
 372 void
 373 WMSetUDBoolForKey(WMUserDefaults *database, Bool value, char *defaultName)
 374 {
 375     static proplist_t yes = NULL, no = NULL;
 376
 377     if (!yes) {
 378         yes = PLMakeString("YES");
 379         no = PLMakeString("NO");
 380     }
 381
 382     WMSetUDObjectForKey(database, value ? yes : no, defaultName);
 383 }
 384
 385
 386 proplist_t
 387 WMGetUDSearchList(WMUserDefaults *database)
 388 {
 389     return database->searchListArray;
 390 }
 391
 392
 393 void
 394 WMSetUDSearchList(WMUserDefaults *database, proplist_t list)
 395 {
 396     int i, c;
 397
 398     if (database->searchList) {
 399         i = 0;
 400         while (database->searchList[i]) {
 401             PLRelease(database->searchList[i]);
 402             i++;
 403         }
 404         free(database->searchList);
 405     }
 406     if (database->searchListArray) {
 407         PLRelease(database->searchListArray);
 408     }
 409
 410     c = PLGetNumberOfElements(list);
 411     database->searchList = wmalloc(sizeof(proplist_t)*(c+1));
 412
 413     for (i=0; i<c; i++) {
 414         database->searchList[i] = PLGetArrayElement(list, i);
 415     }
 416
 417     database->searchListArray = PLDeepCopy(list);
 418 }
 419
 420