From d3a98cf6cbc3bd0b9efc570f58e8812c03931c18 Mon Sep 17 00:00:00 2001 From: Simon Rettberg Date: Tue, 16 Oct 2018 10:08:48 +0200 Subject: Original 5.40 --- OSX/PrefsReader.m | 608 ++++++++++++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 608 insertions(+) create mode 100644 OSX/PrefsReader.m (limited to 'OSX/PrefsReader.m') diff --git a/OSX/PrefsReader.m b/OSX/PrefsReader.m new file mode 100644 index 0000000..a1c4ed4 --- /dev/null +++ b/OSX/PrefsReader.m @@ -0,0 +1,608 @@ +/* xscreensaver, Copyright (c) 2006-2015 Jamie Zawinski + * + * Permission to use, copy, modify, distribute, and sell this software and its + * documentation for any purpose is hereby granted without fee, provided that + * the above copyright notice appear in all copies and that both that + * copyright notice and this permission notice appear in supporting + * documentation. No representations are made about the suitability of this + * software for any purpose. It is provided "as is" without express or + * implied warranty. + */ + +/* This implements the substrate of the xscreensaver preferences code: + It does this by writing defaults to, and reading values from, the + NSUserDefaultsController (and ScreenSaverDefaults/NSUserDefaults) + and thereby reading the preferences that may have been edited by + the UI (XScreenSaverConfigSheet). + */ + +#ifndef USE_IPHONE +# import +#endif + +#import "PrefsReader.h" +#import "Updater.h" +#import "screenhackI.h" + +#ifndef USE_IPHONE + +#include + +/* GlobalDefaults is an NSUserDefaults implementation that writes into + the preferences key we provide, instead of whatever the default would + be for this app. We do this by invoking the Core Foundation preferences + routines directly, while presenting the same API as NSUserDefaults. + + We need this so that global prefs will go into the file + Library/Preferences/org.jwz.xscreensaver.updater.plist instead of into + Library/Preferences/ByHost/org.jwz.xscreensaver.Maze.XXXXX.plist + with the per-saver prefs. + + The ScreenSaverDefaults class *almost* does this, but it always writes + into the ByHost subdirectory, which means it's not readable by an app + that tries to access it with a plain old +standardUserDefaults. + */ +@interface GlobalDefaults : NSUserDefaults +{ + NSString *domain; + NSDictionary *defaults; +} +@end + +@implementation GlobalDefaults +- (id) initWithDomain:(NSString *)_domain module:(NSString *)_module +{ + // Key-Value Observing tries to create an Objective-C class named + // NSKVONotifying_GlobalDefaults when the configuration page is shown. But if + // this is the second XScreenSaver .saver running in the same process, class + // creation fails because that class name was already used by the first + // .saver, and it refers to the GlobalDefaults from the other .saver. + + // This gives the class a unique name, sidestepping the above issue. + + // It really just needs to be unique for this .saver and this instance. + // Using the pointer to the .saver's mach_header and the full path to the + // .saver would be preferable, but this should be good enough. + char class_name[128]; + sprintf(class_name, "GlobalDefaults_%s_%p_%u", + strrchr(_module.UTF8String, '.') + 1, self, random()); + Class c = objc_allocateClassPair([GlobalDefaults class], class_name, 0); + if (!c) + return nil; + objc_registerClassPair(c); + + self = [super init]; + object_setClass(self, c); + domain = [_domain retain]; + return self; +} + +- (void) dealloc +{ + Class c = object_getClass(self); + + [domain release]; + [defaults release]; + [super dealloc]; + + objc_disposeClassPair(c); +} + +- (void)registerDefaults:(NSDictionary *)dict +{ + defaults = [dict retain]; +} + +- (id)objectForKey:(NSString *)key +{ + NSObject *obj = (NSObject *) + CFPreferencesCopyAppValue ((CFStringRef) key, (CFStringRef) domain); + if (obj) + [obj autorelease]; + else if (defaults) + obj = [defaults objectForKey:key]; + return obj; +} + +- (void)setObject:(id)value forKey:(NSString *)key +{ + if (value && defaults) { + // If the value is the default, then remove it instead. + NSObject *def = [defaults objectForKey:key]; + if (def && [def isEqual:value]) + value = NULL; + } + CFPreferencesSetAppValue ((CFStringRef) key, + (CFPropertyListRef) value, + (CFStringRef) domain); +} + + +- (BOOL)synchronize +{ + return CFPreferencesAppSynchronize ((CFStringRef) domain); +} + + +// Make sure these all call our objectForKey. +// Might not be necessary, but safe. + +- (NSString *)stringForKey:(NSString *)key +{ + return [[self objectForKey:key] stringValue]; +} + +- (NSArray *)arrayForKey:(NSString *)key +{ + return (NSArray *) [self objectForKey:key]; +} + +- (NSDictionary *)dictionaryForKey:(NSString *)key +{ + return (NSDictionary *) [self objectForKey:key]; +} + +- (NSData *)dataForKey:(NSString *)key +{ + return (NSData *) [self objectForKey:key]; +} + +- (NSArray *)stringArrayForKey:(NSString *)key +{ + return (NSArray *) [self objectForKey:key]; +} + +- (NSInteger)integerForKey:(NSString *)key +{ + return [[self objectForKey:key] integerValue]; +} + +- (float)floatForKey:(NSString *)key +{ + return [[self objectForKey:key] floatValue]; +} + +- (double)doubleForKey:(NSString *)key +{ + return [[self objectForKey:key] doubleValue]; +} + +- (BOOL)boolForKey:(NSString *)key +{ + return [[self objectForKey:key] integerValue]; +} + +// Make sure these all call our setObject. +// Might not be necessary, but safe. + +- (void)removeObjectForKey:(NSString *)key +{ + [self setObject:NULL forKey:key]; +} + +- (void)setInteger:(NSInteger)value forKey:(NSString *)key +{ + [self setObject:[NSNumber numberWithInteger:value] forKey:key]; +} + +- (void)setFloat:(float)value forKey:(NSString *)key +{ + [self setObject:[NSNumber numberWithFloat:value] forKey:key]; +} + +- (void)setDouble:(double)value forKey:(NSString *)key +{ + [self setObject:[NSNumber numberWithDouble:value] forKey:key]; +} + +- (void)setBool:(BOOL)value forKey:(NSString *)key +{ + [self setObject:[NSNumber numberWithBool:value] forKey:key]; +} +@end + + +#endif // !USE_IPHONE + + +@implementation PrefsReader + +/* Normally we read resources by looking up "KEY" in the database + "org.jwz.xscreensaver.SAVERNAME". But in the all-in-one iPhone + app, everything is stored in the database "org.jwz.xscreensaver" + instead, so transform keys to "SAVERNAME.KEY". + + NOTE: This is duplicated in XScreenSaverConfigSheet.m, cause I suck. + */ +- (NSString *) makeKey:(NSString *)key +{ +# ifdef USE_IPHONE + NSString *prefix = [saver_name stringByAppendingString:@"."]; + if (! [key hasPrefix:prefix]) // Don't double up! + key = [prefix stringByAppendingString:key]; +# endif + return key; +} + +- (NSString *) makeCKey:(const char *)key +{ + return [self makeKey:[NSString stringWithCString:key + encoding:NSUTF8StringEncoding]]; +} + + +/* Converts an array of "key:value" strings to an NSDictionary. + */ +- (NSDictionary *) defaultsToDict: (const char * const *) defs +{ + NSDictionary *dict = [NSMutableDictionary dictionaryWithCapacity:20]; + while (*defs) { + char *line = strdup (*defs); + char *key, *val; + key = line; + while (*key == '.' || *key == '*' || *key == ' ' || *key == '\t') + key++; + val = key; + while (*val && *val != ':') + val++; + if (*val != ':') abort(); + *val++ = 0; + while (*val == ' ' || *val == '\t') + val++; + + unsigned long L = strlen(val); + while (L > 0 && (val[L-1] == ' ' || val[L-1] == '\t')) + val[--L] = 0; + + // When storing into preferences, look at the default string and + // decide whether it's a boolean, int, float, or string, and store + // an object of the appropriate type in the prefs. + // + NSString *nskey = [self makeCKey:key]; + NSObject *nsval; + int dd; + double ff; + char cc; + if (!strcasecmp (val, "true") || !strcasecmp (val, "yes")) + nsval = [NSNumber numberWithBool:YES]; + else if (!strcasecmp (val, "false") || !strcasecmp (val, "no")) + nsval = [NSNumber numberWithBool:NO]; + else if (1 == sscanf (val, " %d %c", &dd, &cc)) + nsval = [NSNumber numberWithInt:dd]; + else if (1 == sscanf (val, " %lf %c", &ff, &cc)) + nsval = [NSNumber numberWithDouble:ff]; + else + nsval = [NSString stringWithCString:val encoding:NSUTF8StringEncoding]; + +// NSLog (@"default: \"%@\" = \"%@\" [%@]", nskey, nsval, [nsval class]); + [dict setValue:nsval forKey:nskey]; + free (line); + defs++; + } + return dict; +} + + +/* Initialize the Cocoa preferences database: + - sets the default preferences values from the 'defaults' array; + - binds 'self' to each preference as an observer; + - ensures that nothing is mentioned in 'options' and not in 'defaults'; + - ensures that nothing is mentioned in 'defaults' and not in 'options'. + */ +- (void) registerXrmKeys: (const XrmOptionDescRec *) opts + defaults: (const char * const *) defs +{ + // Store the contents of 'defaults' into the real preferences database. + NSDictionary *defsdict = [self defaultsToDict:defs]; + [userDefaults registerDefaults:defsdict]; + [globalDefaults registerDefaults:UPDATER_DEFAULTS]; + + // Save a copy of the default options, since iOS doesn't have + // [userDefaultsController initialValues]. + // + if (defaultOptions) + [defaultOptions release]; + defaultOptions = [[NSMutableDictionary dictionaryWithCapacity:20] + retain]; + for (NSString *key in defsdict) { + [defaultOptions setValue:[defsdict objectForKey:key] forKey:key]; + } + +# ifndef USE_IPHONE + userDefaultsController = + [[NSUserDefaultsController alloc] initWithDefaults:userDefaults + initialValues:defsdict]; + globalDefaultsController = + [[NSUserDefaultsController alloc] initWithDefaults:globalDefaults + initialValues:UPDATER_DEFAULTS]; +# else // USE_IPHONE + userDefaultsController = [userDefaults retain]; + globalDefaultsController = [userDefaults retain]; +# endif // USE_IPHONE + + NSDictionary *optsdict = [NSMutableDictionary dictionaryWithCapacity:20]; + + while (opts[0].option) { + //const char *option = opts->option; + const char *resource = opts->specifier; + + while (*resource == '.' || *resource == '*') + resource++; + NSString *nsresource = [self makeCKey:resource]; + + // make sure there's no resource mentioned in options and not defaults. + if (![defsdict objectForKey:nsresource]) { + if (! (!strcmp(resource, "font") || // don't warn about these + !strcmp(resource, "foreground") || + !strcmp(resource, "textLiteral") || + !strcmp(resource, "textFile") || + !strcmp(resource, "textURL") || + !strcmp(resource, "textProgram") || + !strcmp(resource, "imageDirectory"))) + NSLog (@"warning: \"%s\" is in options but not defaults", resource); + } + [optsdict setValue:nsresource forKey:nsresource]; + + opts++; + } + +#if 0 + // make sure there's no resource mentioned in defaults and not options. + for (NSString *key in defsdict) { + if (! [optsdict objectForKey:key]) + if (! ([key isEqualToString:@"foreground"] || // don't warn about these + [key isEqualToString:@"background"] || + [key isEqualToString:@"Background"] || + [key isEqualToString:@"geometry"] || + [key isEqualToString:@"font"] || + [key isEqualToString:@"dontClearRoot"] || + + // fps.c settings + [key isEqualToString:@"fpsSolid"] || + [key isEqualToString:@"fpsTop"] || + [key isEqualToString:@"titleFont"] || + + // analogtv.c settings + [key isEqualToString:@"TVBrightness"] || + [key isEqualToString:@"TVColor"] || + [key isEqualToString:@"TVContrast"] || + [key isEqualToString:@"TVTint"] + )) + NSLog (@"warning: \"%@\" is in defaults but not options", key); + } +#endif /* 0 */ + +#if 0 + // Dump the entire resource database. + NSLog(@"userDefaults:"); + NSDictionary *d = [userDefaults dictionaryRepresentation]; + for (NSObject *key in [[d allKeys] + sortedArrayUsingSelector:@selector(compare:)]) { + NSObject *val = [d objectForKey:key]; + NSLog (@"%@ = %@", key, val); + } + NSLog(@"globalDefaults:"); + d = [globalDefaults dictionaryRepresentation]; + for (NSObject *key in [[d allKeys] + sortedArrayUsingSelector:@selector(compare:)]) { + NSObject *val = [d objectForKey:key]; + NSLog (@"%@ = %@", key, val); + } +#endif + +} + +- (NSUserDefaultsController *) userDefaultsController +{ + NSAssert(userDefaultsController, @"userDefaultsController uninitialized"); + return userDefaultsController; +} + +- (NSUserDefaultsController *) globalDefaultsController +{ + NSAssert(globalDefaultsController, @"globalDefaultsController uninitialized"); + return globalDefaultsController; +} + +- (NSDictionary *) defaultOptions +{ + NSAssert(defaultOptions, @"defaultOptions uninitialized"); + return defaultOptions; +} + + +- (NSObject *) getObjectResource: (const char *) name +{ + // Only look in globalDefaults for updater preferences. + + static NSDictionary *updaterDefaults; + if (!updaterDefaults) { + updaterDefaults = UPDATER_DEFAULTS; + [updaterDefaults retain]; + } + + NSUserDefaults *defaults = + [updaterDefaults objectForKey:[NSString stringWithUTF8String:name]] ? + globalDefaults : + userDefaults; + + const char *name2 = name; + while (1) { + NSString *key = [self makeCKey:name2]; + NSObject *obj = [defaults objectForKey:key]; + if (obj) + return obj; + + // If key is "foo.bar.baz", check "foo.bar.baz", "bar.baz", and "baz". + // + const char *dot = strchr (name2, '.'); + if (dot && dot[1]) + name2 = dot + 1; + else + break; + } + return NULL; +} + + +- (char *) getStringResource: (const char *) name +{ + NSObject *o = [self getObjectResource:name]; + //NSLog(@"%s = %@",name,o); + if (o == nil) { + if (! (!strcmp(name, "eraseMode") || // erase.c + // xlockmore.c reads all of these whether used or not... + !strcmp(name, "right3d") || + !strcmp(name, "left3d") || + !strcmp(name, "both3d") || + !strcmp(name, "none3d") || + !strcmp(name, "font") || + !strcmp(name, "labelFont") || // grabclient.c + !strcmp(name, "titleFont") || + !strcmp(name, "fpsFont") || // fps.c + !strcmp(name, "foreground") || // fps.c + !strcmp(name, "background") || + !strcmp(name, "textLiteral") + )) + NSLog(@"warning: no preference \"%s\" [string]", name); + return NULL; + } + if (! [o isKindOfClass:[NSString class]]) { + NSLog(@"asked for %s as a string, but it is a %@", name, [o class]); + o = [(NSNumber *) o stringValue]; + } + + NSString *os = (NSString *) o; + char *result = strdup ([os cStringUsingEncoding:NSUTF8StringEncoding]); + + // Kludge: if the string is surrounded with single-quotes, remove them. + // This happens when the .xml file says things like arg="-foo 'bar baz'" + if (result[0] == '\'' && result[strlen(result)-1] == '\'') { + result[strlen(result)-1] = 0; + strcpy (result, result+1); + } + + // Kludge: assume that any string that begins with "~" and has a "/" + // anywhere in it should be expanded as if it is a pathname. + if (result[0] == '~' && strchr (result, '/')) { + os = [NSString stringWithCString:result encoding:NSUTF8StringEncoding]; + free (result); + result = strdup ([[os stringByExpandingTildeInPath] + cStringUsingEncoding:NSUTF8StringEncoding]); + } + + return result; +} + + +- (double) getFloatResource: (const char *) name +{ + NSObject *o = [self getObjectResource:name]; + if (o == nil) { + // xlockmore.c reads all of these whether used or not... + if (! (!strcmp(name, "cycles") || + !strcmp(name, "size") || + !strcmp(name, "use3d") || + !strcmp(name, "delta3d") || + !strcmp(name, "wireframe") || + !strcmp(name, "showFPS") || + !strcmp(name, "fpsSolid") || + !strcmp(name, "fpsTop") || + !strcmp(name, "mono") || + !strcmp(name, "count") || + !strcmp(name, "ncolors") || + !strcmp(name, "doFPS") || // fps.c + !strcmp(name, "eraseSeconds") // erase.c + )) + NSLog(@"warning: no preference \"%s\" [float]", name); + return 0.0; + } + if ([o isKindOfClass:[NSString class]]) { + return [(NSString *) o doubleValue]; + } else if ([o isKindOfClass:[NSNumber class]]) { + return [(NSNumber *) o doubleValue]; + } else { + NSAssert2(0, @"%s = \"%@\" but should have been an NSNumber", name, o); + abort(); + } +} + + +- (int) getIntegerResource: (const char *) name +{ + // Sliders might store float values for integral resources; round them. + float v = [self getFloatResource:name]; + int i = (int) (v + (v < 0 ? -0.5 : 0.5)); // ignore sign or -1 rounds to 0 + // if (i != v) NSLog(@"%s: rounded %.3f to %d", name, v, i); + return i; +} + + +- (BOOL) getBooleanResource: (const char *) name +{ + NSObject *o = [self getObjectResource:name]; + if (! o) { + return NO; + } else if ([o isKindOfClass:[NSNumber class]]) { + double n = [(NSNumber *) o doubleValue]; + if (n == 0) return NO; + else if (n == 1) return YES; + else goto FAIL; + } else if ([o isKindOfClass:[NSString class]]) { + NSString *s = [((NSString *) o) lowercaseString]; + if ([s isEqualToString:@"true"] || + [s isEqualToString:@"yes"] || + [s isEqualToString:@"1"]) + return YES; + else if ([s isEqualToString:@"false"] || + [s isEqualToString:@"no"] || + [s isEqualToString:@"0"] || + [s isEqualToString:@""]) + return NO; + else + goto FAIL; + } else { + FAIL: + NSAssert2(0, @"%s = \"%@\" but should have been a boolean", name, o); + abort(); + } +} + + +- (id) initWithName: (NSString *) name + xrmKeys: (const XrmOptionDescRec *) opts + defaults: (const char * const *) defs +{ + self = [self init]; + if (!self) return nil; + +# ifndef USE_IPHONE + userDefaults = [ScreenSaverDefaults defaultsForModuleWithName:name]; + globalDefaults = [[GlobalDefaults alloc] initWithDomain:@UPDATER_DOMAIN + module:name]; +# else // USE_IPHONE + userDefaults = [NSUserDefaults standardUserDefaults]; + globalDefaults = [userDefaults retain]; +# endif // USE_IPHONE + + // Convert "org.jwz.xscreensaver.NAME" to just "NAME". + NSRange r = [name rangeOfString:@"." options:NSBackwardsSearch]; + if (r.length) + name = [name substringFromIndex:r.location+1]; + name = [name stringByReplacingOccurrencesOfString:@" " withString:@""]; + saver_name = [name retain]; + + [self registerXrmKeys:opts defaults:defs]; + return self; +} + +- (void) dealloc +{ + [saver_name release]; + [userDefaultsController release]; + [globalDefaultsController release]; + [globalDefaults release]; + [super dealloc]; +} + +@end -- cgit v1.2.3-55-g7522