//

 //  GrowlApplicationTicket.m

 //  Growl

 //

 //  Created by Karl Adam on Tue Apr 27 2004.

 //  Copyright 2004-2006 The Growl Project. All rights reserved.

 //

 // This file is under the BSD License, refer to License.txt for details

 #import "GrowlApplicationTicket.h"

 #import "GrowlNotificationTicket.h"

 #import "GrowlDefines.h"

 #import "GrowlDisplayPlugin.h"

 #import "NSWorkspaceAdditions.h"

 #import "GrowlPathUtilities.h"

 #include "CFGrowlAdditions.h"

 #include "CFURLAdditions.h"

 #include "CFDictionaryAdditions.h"

 #define UseDefaultsKey			@"useDefaults"

 #define TicketEnabledKey		@"ticketEnabled"

 #define ClickHandlersEnabledKey	@"clickHandlersEnabled"

 #define PositionTypeKey			@"positionType"

 #pragma mark -

 @implementation GrowlApplicationTicket

 //these are specifically for auto-discovery tickets, hence the requirement of GROWL_TICKET_VERSION.

 + (BOOL) isValidTicketDictionary:(NSDictionary *)dict {

 	if (!dict)

 		return NO;

 	NSNumber *versionNum = getObjectForKey(dict, GROWL_TICKET_VERSION);

 	if ([versionNum intValue] == 1) {

 		return getObjectForKey(dict, GROWL_NOTIFICATIONS_ALL)

 			&& getObjectForKey(dict, GROWL_APP_NAME);

 	} else {

 		return NO;

 	}

 }

 + (BOOL) isKnownTicketVersion:(NSDictionary *)dict {

 	id version = getObjectForKey(dict, GROWL_TICKET_VERSION);

 	return version && ([version intValue] == 1);

 }

 #pragma mark -

 + (id) ticketWithDictionary:(NSDictionary *)ticketDict {

 	return [[[GrowlApplicationTicket alloc] initWithDictionary:ticketDict] autorelease];

 }

 - (id) initWithDictionary:(NSDictionary *)ticketDict {

 	if (!ticketDict) {

 		[self release];

 		NSParameterAssert(ticketDict != nil);

 		return nil;

 	}

 	if ((self = [self init])) {

 		synchronizeOnChanges = NO;

 		appName = [getObjectForKey(ticketDict, GROWL_APP_NAME) retain];

 		appId = [getObjectForKey(ticketDict, GROWL_APP_ID) retain];

 		humanReadableNames = [[ticketDict objectForKey:GROWL_NOTIFICATIONS_HUMAN_READABLE_NAMES] retain];

 		notificationDescriptions = [[ticketDict objectForKey:GROWL_NOTIFICATIONS_DESCRIPTIONS] retain];

 		//Get all the notification names and the data about them

 		allNotificationNames = [ticketDict objectForKey:GROWL_NOTIFICATIONS_ALL];

 		NSAssert1(allNotificationNames, @"Ticket dictionaries must contain a list of all their notifications (application name: %@)", appName);

 		NSArray *inDefaults = [ticketDict objectForKey:GROWL_NOTIFICATIONS_DEFAULT];

 		if (!inDefaults) inDefaults = allNotificationNames;

 		NSEnumerator *notificationsEnum = [allNotificationNames objectEnumerator];

 		NSMutableDictionary *allNotificationsTemp = [[NSMutableDictionary alloc] initWithCapacity:[allNotificationNames count]];

 		NSMutableArray *allNamesTemp = [[NSMutableArray alloc] initWithCapacity:[allNotificationNames count]];

 		id obj;

 		while ((obj = [notificationsEnum nextObject])) {

 			NSString *name;

 			GrowlNotificationTicket *notification;

 			if ([obj isKindOfClass:[NSString class]]) {

 				name = obj;

 				notification = [[GrowlNotificationTicket alloc] initWithName:obj];

 			} else {

 				name = [obj objectForKey:@"Name"];

 				notification = [[GrowlNotificationTicket alloc] initWithDictionary:obj];

 			}

 			[allNamesTemp addObject:name];

 			[notification setTicket:self];

 			//Set the human readable name if we were supplied one

 			[notification setHumanReadableName:[humanReadableNames objectForKey:name]];

 			[notification setNotificationDescription:[notificationDescriptions objectForKey:name]];

 			[allNotificationsTemp setObject:notification forKey:name];

 			[notification release];

 		}

 		allNotifications = allNotificationsTemp;

 		allNotificationNames = allNamesTemp;

 		BOOL doLookup = YES;

 		NSString *fullPath = nil;

 		id location = getObjectForKey(ticketDict, GROWL_APP_LOCATION);

 		if (location) {

 			if ([location isKindOfClass:[NSDictionary class]]) {

 				NSDictionary *file_data = getObjectForKey((NSDictionary *)location, @"file-data");

 				CFURLRef url = (CFURLRef)createFileURLWithDockDescription(file_data);

 				if (url) {

 					fullPath = [(NSString *)CFURLCopyPath(url) autorelease];

 					CFRelease(url);

 				}

 			} else if ([location isKindOfClass:[NSString class]]) {

 				fullPath = location;

 				if (![[NSFileManager defaultManager] fileExistsAtPath:fullPath])

 					fullPath = nil;

 			} else if ([location isKindOfClass:[NSNumber class]]) {

 				doLookup = [location boolValue];

 			}

 		}

 		if (!fullPath && doLookup) {

 			if (appId) {

 				CFURLRef appURL = NULL;

 				OSStatus err = LSFindApplicationForInfo(kLSUnknownCreator,

 														(CFStringRef)appId,

 														/*inName*/ NULL,

 														/*outAppRef*/ NULL,

 														&appURL);

 				if (err == noErr) {

 					fullPath = [(NSString *)CFURLCopyPath(appURL) autorelease];

 					CFRelease(appURL);

 				}

 			}

 			if (!fullPath)

 				fullPath = [[NSWorkspace sharedWorkspace] fullPathForApplication:appName];

 		}

 		appPath = [fullPath retain];

 //		NSLog(@"got appPath: %@", appPath);

 		[self setIcon:getObjectForKey(ticketDict, GROWL_APP_ICON)];

 		id value = getObjectForKey(ticketDict, UseDefaultsKey);

 		if (value)

 			useDefaults = [value boolValue];

 		else

 			useDefaults = YES;

 		value = getObjectForKey(ticketDict, TicketEnabledKey);

 		if (value)

 			ticketEnabled = [value boolValue];

 		else

 			ticketEnabled = YES;

 		displayPluginName = [[ticketDict objectForKey:GrowlDisplayPluginKey] copy];

 		value = getObjectForKey(ticketDict, ClickHandlersEnabledKey);

 		if (value)

 			clickHandlersEnabled = [value boolValue];

 		else

 			clickHandlersEnabled = YES;

 		value = getObjectForKey(ticketDict, PositionTypeKey);

 		if (value)

 			positionType = [value intValue];

 		else

 			positionType = 0;	

 		value = getObjectForKey(ticketDict, GROWL_POSITION_PREFERENCE_KEY);

 		if (value)

 			selectedCustomPosition = [value intValue];

 		else

 			selectedCustomPosition = 0;				

 		[self setDefaultNotifications:inDefaults];

 		changed = YES;

 		synchronizeOnChanges = YES;

 	}

 	return self;

 }

 - (void) dealloc {

 	[appName                  release];

 	[appId                    release];

 	[appPath                  release];

 	[icon                     release];

 	[iconData                 release];

 	[allNotifications         release];

 	[defaultNotifications     release];

 	[humanReadableNames       release];

 	[notificationDescriptions release];

 	[allNotificationNames     release];

 	[displayPluginName        release];

 	[super dealloc];

 }

 #pragma mark -

 - (id) initTicketFromPath:(NSString *) ticketPath {

 	CFURLRef ticketURL = CFURLCreateWithFileSystemPath(kCFAllocatorDefault, (CFStringRef)ticketPath, kCFURLPOSIXPathStyle, false);

 	NSDictionary *ticketDict = (NSDictionary *)createPropertyListFromURL((NSURL *)ticketURL, kCFPropertyListImmutable, NULL, NULL);

 	CFRelease(ticketURL);

 	if (!ticketDict) {

 		NSLog(@"Tried to init a ticket from this file, but it isn't a ticket file: %@", ticketPath);

 		[self release];

 		return nil;

 	}

 	self = [self initWithDictionary:ticketDict];

 	[ticketDict release];

 	return self;

 }

 - (id) initTicketForApplication: (NSString *) inApp {

 	return [self initTicketFromPath:[[[[GrowlPathUtilities growlSupportDirectory]

 										stringByAppendingPathComponent:@"Tickets"]

 										stringByAppendingPathComponent:inApp]

 										stringByAppendingPathExtension:@"growlTicket"]];

 }

 - (NSString *) path {

 	NSString *destDir = [GrowlPathUtilities growlSupportDirectory];

 	destDir = [destDir stringByAppendingPathComponent:@"Tickets"];

 	destDir = [destDir stringByAppendingPathComponent:[appName stringByAppendingPathExtension:@"growlTicket"]];

 	return destDir;

 }

 - (void) saveTicket {

 	NSString *destDir = [GrowlPathUtilities growlSupportDirectory];

 	destDir = [destDir stringByAppendingPathComponent:@"Tickets"];

 	[self saveTicketToPath:destDir];

 }

 - (void) saveTicketToPath:(NSString *)destDir {

 	// Save a Plist file of this object to configure the prefs of apps that aren't running

 	// construct a dictionary of our state data then save that dictionary to a file.

 	NSString *savePath = [destDir stringByAppendingPathComponent:[appName stringByAppendingPathExtension:@"growlTicket"]];

 	NSMutableArray *saveNotifications = [[NSMutableArray alloc] initWithCapacity:[allNotifications count]];

 	NSEnumerator *notificationEnum = [allNotifications objectEnumerator];

 	GrowlNotificationTicket *obj;

 	while ((obj = [notificationEnum nextObject]))

 		[saveNotifications addObject:[obj dictionaryRepresentation]];

 	NSDictionary *file_data = nil;

 	if (appPath) {

 		NSURL *url = [[NSURL alloc] initFileURLWithPath:appPath];

 		file_data = createDockDescriptionWithURL(url);

 		[url release];

 	}

 	id location = file_data ? [NSDictionary dictionaryWithObject:file_data forKey:@"file-data"] : appPath;

 	if (!location)

 		location = [NSNumber numberWithBool:NO];

 	[file_data release];

 	NSNumber *useDefaultsValue = [[NSNumber alloc] initWithBool:useDefaults];

 	NSNumber *ticketEnabledValue = [[NSNumber alloc] initWithBool:ticketEnabled];

 	NSNumber *clickHandlersEnabledValue = [[NSNumber alloc] initWithBool:clickHandlersEnabled];

 	NSNumber *positionTypeValue = [[NSNumber alloc] initWithInt:positionType];

 	NSNumber *selectedCustomPositionValue = [[NSNumber alloc] initWithInt:selectedCustomPosition];

 	NSData *theIconData = iconData;

 	if (!theIconData) {

 		NSImage *theIcon = [self icon];

 		theIconData = theIcon ? [theIcon TIFFRepresentation] : [NSData data];

 	}

 	NSMutableDictionary *saveDict = [[NSMutableDictionary alloc] initWithObjectsAndKeys:

 		appName,						GROWL_APP_NAME,

 		saveNotifications,				GROWL_NOTIFICATIONS_ALL,

 		defaultNotifications,			GROWL_NOTIFICATIONS_DEFAULT,

 		theIconData,					GROWL_APP_ICON,

 		useDefaultsValue,				UseDefaultsKey,

 		ticketEnabledValue,				TicketEnabledKey,

 		clickHandlersEnabledValue,		ClickHandlersEnabledKey,

 		positionTypeValue,				PositionTypeKey,

 		selectedCustomPositionValue,	GROWL_POSITION_PREFERENCE_KEY,

 		location,						GROWL_APP_LOCATION,

 		nil];

 	[useDefaultsValue					release];

 	[ticketEnabledValue					release];

 	[clickHandlersEnabledValue			release];

 	[positionTypeValue					release];

 	[selectedCustomPositionValue		release];

 	[saveNotifications					release];

 	if (displayPluginName)

 		[saveDict setObject:displayPluginName forKey:GrowlDisplayPluginKey];

 	if (humanReadableNames)

 		[saveDict setObject:humanReadableNames forKey:GROWL_NOTIFICATIONS_HUMAN_READABLE_NAMES];

 	if (notificationDescriptions)

 		[saveDict setObject:notificationDescriptions forKey:GROWL_NOTIFICATIONS_DESCRIPTIONS];

 	if (appId)

 		[saveDict setObject:appId forKey:GROWL_APP_ID];

 	NSData *plistData;

 	NSString *error;

 	plistData = [NSPropertyListSerialization dataFromPropertyList:saveDict

 														   format:NSPropertyListBinaryFormat_v1_0

 												 errorDescription:&error];

 	if (plistData)

 		[plistData writeToFile:savePath atomically:YES];

 	else

 		NSLog(@"Error writing ticket for application %@: %@", appName, error);

 	[saveDict release];

 	changed = NO;

 }

 - (void) doSynchronize {

 	[self saveTicket];

 	NSNumber *pid = [[NSNumber alloc] initWithInt:[[NSProcessInfo processInfo] processIdentifier]];

 	NSDictionary *userInfo = [[NSDictionary alloc] initWithObjectsAndKeys:

 		appName, @"TicketName",

 		pid,     @"pid",

 		nil];

 	[pid release];

 	[[NSDistributedNotificationCenter defaultCenter] postNotificationName:GrowlPreferencesChanged

 																   object:@"GrowlTicketChanged"

 																 userInfo:userInfo];

 	[userInfo release];	

 }

 - (void) synchronize {

 	if (synchronizeOnChanges) {

 		//Coalesce a series of changes into a single message; this makes mass changes (such as registration) much faster.

 		[NSObject cancelPreviousPerformRequestsWithTarget:self

 												 selector:@selector(doSynchronize)

 												   object:nil];

 		[self performSelector:@selector(doSynchronize)

 				   withObject:nil

 				   afterDelay:0.5];

 	}

 }

 #pragma mark -

 - (NSImage *) icon {

 	if (icon)

 		return icon;

 	if (iconData) {

 		icon = [[NSImage alloc] initWithData:iconData];

 		[iconData release];

 		iconData = nil;

 	}

 	if (!icon && appPath)

 		icon = [[[NSWorkspace sharedWorkspace] iconForFile:appPath] retain];

 	if (!icon) {

 		icon = [[[NSWorkspace sharedWorkspace] iconForFileType:NSFileTypeForHFSTypeCode(kGenericApplicationIcon)] retain];

 		[icon setSize:NSMakeSize(128.0, 128.0)];

 	}

 	return icon;

 }

 - (void) setIcon:(NSImage *)inIcon {

 	if (icon != inIcon) {

 		if ([inIcon isEqual:icon] || [inIcon isEqual:iconData])

 			return;

 		changed = YES;

 		[icon     release];

 		[iconData release];

 		if (inIcon) {

 			if ([inIcon isKindOfClass:[NSImage class]]) {

 				icon = [inIcon copy];

 				iconData = nil;

 			} else {

 				icon = nil;

 				iconData = (NSData *)[inIcon retain];

 			}

 		} else {

 			icon = nil;

 			iconData = nil;

 		}

 	}

 }

 - (NSString *) applicationName {

 	return appName;

 }

 - (BOOL) ticketEnabled {

 	return ticketEnabled;

 }

 - (void) setTicketEnabled:(BOOL)inEnabled {

 	if (ticketEnabled != inEnabled) {

 		ticketEnabled = inEnabled;

 		[self synchronize];

 	}

 }

 - (BOOL) clickHandlersEnabled {

 	return clickHandlersEnabled;

 }

 - (void) setClickHandlersEnabled:(BOOL)inEnabled {

 	if (clickHandlersEnabled != inEnabled) {

 		clickHandlersEnabled = inEnabled;

 		[self synchronize];

 	}

 }

 - (int) positionType {

 	return positionType;

 }

 - (void) setPositionType:(int)inPositionType {

 	positionType = inPositionType;

 	[self synchronize];

 }

 - (int) selectedPosition {

 	return selectedCustomPosition;

 }

 - (void) setSelectedPosition:(int)inPosition {

 	selectedCustomPosition = inPosition;

 	[self synchronize];

 }

 - (BOOL) useDefaults {

 	return useDefaults;

 }

 - (void) setUseDefaults:(BOOL)flag {

 	useDefaults = flag;

 }

 - (BOOL) hasChanged {

 	return changed;

 }

 - (void) setHasChanged:(BOOL)flag {

 	changed = flag;

 }

 - (NSString *) displayPluginName {

 	return displayPluginName;

 }

 - (GrowlDisplayPlugin *) displayPlugin {

 	if (!displayPlugin && displayPluginName)

 		displayPlugin = (GrowlDisplayPlugin *)[[[GrowlPluginController sharedController] displayPluginDictionaryWithName:displayPluginName author:nil version:nil type:nil] pluginInstance];

 	return displayPlugin;

 }

 - (void) setDisplayPluginName: (NSString *)name {

 	if (![displayPluginName isEqualToString:name]) {

 		[displayPluginName release];

 		displayPluginName = [name copy];

 		displayPlugin = nil;

 		[self synchronize];

 	}

 }

 #pragma mark -

 - (NSString *) description {

 	return [NSString stringWithFormat:@"<GrowlApplicationTicket: %p>{\n\tApplicationName: \"%@\"\n\ticon: %@\n\tAll Notifications: %@\n\tDefault Notifications: %@\n\tAllowed Notifications: %@\n\tUse Defaults: %@\n}",

 		self, appName, icon, allNotifications, defaultNotifications, [self allowedNotifications], ( useDefaults ? @"YES" : @"NO" )];

 }

 #pragma mark -

 - (void) reregisterWithAllNotifications:(NSArray *)inAllNotes defaults:(id)inDefaults icon:(NSImage *)inIcon {

 	if (!useDefaults) {

 		/*We want to respect the user's preferences, but if the application has

 		 *	added new notifications since it last registered, we want to enable those

 		 *	if the application says to.

 		 */

 		NSEnumerator		*enumerator;

 		NSMutableDictionary *allNotesCopy = [allNotifications mutableCopy];

 		if ([inDefaults respondsToSelector:@selector(objectEnumerator)] ) {

 			enumerator = [inDefaults objectEnumerator];

 			Class NSNumberClass = [NSNumber class];

 			NSUInteger numAllNotifications = [inAllNotes count];

 			id obj;

 			while ((obj = [enumerator nextObject])) {

 				NSString *note;

 				if ([obj isKindOfClass:NSNumberClass]) {

 					//it's an index into the all-notifications list

 					unsigned notificationIndex = [obj unsignedIntValue];

 					if (notificationIndex >= numAllNotifications) {

 						NSLog(@"WARNING: application %@ tried to allow notification at index %u by default, but there is no such notification in its list of %u", appName, notificationIndex, numAllNotifications);

 						note = nil;

 					} else {

 						note = [inAllNotes objectAtIndex:notificationIndex];

 					}

 				} else {

 					//it's probably a notification name

 					note = obj;

 				}

 				if (note && ![allNotesCopy objectForKey:note]) {

 					GrowlNotificationTicket *ticket = [GrowlNotificationTicket notificationWithName:note];

 					[ticket setHumanReadableName:[humanReadableNames objectForKey:note]];

 					[ticket setNotificationDescription:[notificationDescriptions objectForKey:note]];

 					[allNotesCopy setObject:ticket forKey:note];

 				}

 			}

 		} else if ([inDefaults isKindOfClass:[NSIndexSet class]]) {

 			NSUInteger notificationIndex;

 			NSUInteger numAllNotifications = [inAllNotes count];

 			NSIndexSet *iset = (NSIndexSet *)inDefaults;

 			for (notificationIndex = [iset firstIndex]; notificationIndex != NSNotFound; notificationIndex = [iset indexGreaterThanIndex:notificationIndex]) {

 				if (notificationIndex >= numAllNotifications) {

 					NSLog(@"WARNING: application %@ tried to allow notification at index %u by default, but there is no such notification in its list of %u", appName, notificationIndex, numAllNotifications);

 					// index sets are sorted, so we can stop here

 					break;

 				} else {

 					NSString *note = [inAllNotes objectAtIndex:notificationIndex];

 					if (![allNotesCopy objectForKey:note]) {

 						GrowlNotificationTicket *ticket = [GrowlNotificationTicket notificationWithName:note];

 						[ticket setHumanReadableName:[humanReadableNames objectForKey:note]];

 						[ticket setNotificationDescription:[notificationDescriptions objectForKey:note]];

 						[allNotesCopy setObject:ticket forKey:note];

 					}

 				}

 			}

 		} else {

 			if (inDefaults)

 				NSLog(@"WARNING: application %@ passed an invalid object for the default notifications: %@.", appName, inDefaults);

 		}

 		if (![allNotifications isEqual:allNotesCopy]) {

 			[allNotifications release];

 			allNotifications = allNotesCopy;

 			changed = YES;

 		} else {

 			[allNotesCopy release];

 		}

 	}

 	//ALWAYS set all notifications list first, to enable handling of numeric indices in the default notifications list!

 	[self setAllNotifications:inAllNotes];

 	[self setDefaultNotifications:inDefaults];

 	[self setIcon:inIcon];

 }

 - (void) reregisterWithDictionary:(NSDictionary *)dict {

 	NSWorkspace *workspace = [NSWorkspace sharedWorkspace];

 	NSImage *appIcon = [dict objectForKey:GROWL_APP_ICON];

 	NSString *bundleId = [dict objectForKey:GROWL_APP_ID];

 	if (bundleId != appId && ![bundleId isEqualToString:appId]) {

 		[appId release];

 		appId = [bundleId retain];

 		changed = YES;

 	}

 	//XXX - should assimilate reregisterWithAllNotifications:defaults:icon: here

 	NSArray	*all      = [dict objectForKey:GROWL_NOTIFICATIONS_ALL];

 	NSArray	*defaults = [dict objectForKey:GROWL_NOTIFICATIONS_DEFAULT];

 	NSDictionary *newNames = [dict objectForKey:GROWL_NOTIFICATIONS_HUMAN_READABLE_NAMES];

 	if (newNames != humanReadableNames && ![newNames isEqual:humanReadableNames]) {

 		[humanReadableNames release];

 		humanReadableNames = [newNames retain];

 		changed = YES;

 	}

 	NSDictionary *newDescriptions = [dict objectForKey:GROWL_NOTIFICATIONS_DESCRIPTIONS];

 	if (newDescriptions != notificationDescriptions && ![newDescriptions isEqual:notificationDescriptions]) {

 		[notificationDescriptions release];

 		notificationDescriptions = [newDescriptions retain];

 		changed = YES;

 	}

 	if (!defaults) defaults = all;

 	[self reregisterWithAllNotifications:all

 								defaults:defaults

 									icon:appIcon];

 	NSString *fullPath = nil;

 	id location = [dict objectForKey:GROWL_APP_LOCATION];

 	if (location) {

 		if ([location isKindOfClass:[NSDictionary class]]) {

 			NSDictionary *file_data = [location objectForKey:@"file-data"];

 			CFURLRef url = (CFURLRef)createFileURLWithDockDescription(file_data);

 			if (url) {

 				fullPath = [(NSString *)CFURLCopyPath(url) autorelease];

 				if(fullPath)

 					CFMakeCollectable(fullPath);		

 				CFRelease(url);

 			}

 		} else if ([location isKindOfClass:[NSString class]]) {

 			fullPath = location;

 			if (![[NSFileManager defaultManager] fileExistsAtPath:fullPath])

 				fullPath = nil;

 		}

 		/* Don't handle the NSNumber case here, the app might have moved and we

 		 * use the re-registration to update our stored appPath.

 		*/

 	}

 	if (!fullPath) {

 		if (appId) {

 			CFURLRef appURL = NULL;

 			OSStatus err = LSFindApplicationForInfo(kLSUnknownCreator,

 													(CFStringRef)appId,

 													/*inName*/ NULL,

 													/*outAppRef*/ NULL,

 													&appURL);

 			if (err == noErr) {

 				fullPath = [(NSString *)CFURLCopyPath(appURL) autorelease];

 				if(fullPath)

 					CFMakeCollectable(fullPath);		

 				CFRelease(appURL);

 			}

 		}

 		if (!fullPath)

 			fullPath = [workspace fullPathForApplication:appName];

 	}

 	if (fullPath != appPath && ![fullPath isEqualToString:appPath]) {

 		[appPath release];

 		appPath = [fullPath retain];

 		changed = YES;

 	}

 }

 - (NSArray *) allNotifications {

 	return [[[allNotifications allKeys] retain] autorelease];

 }

 - (void) setAllNotifications:(NSArray *)inArray {

 	if (allNotificationNames != inArray) {

 		if ([inArray isEqualToArray:allNotificationNames])

 			return;

 		changed = YES;

 		[allNotificationNames release];

 		allNotificationNames = [inArray retain];

 		//We want to keep all of the old notification settings and create entries for the new ones

 		NSEnumerator *newEnum = [inArray objectEnumerator];

 		NSMutableDictionary *tmp = [[NSMutableDictionary alloc] initWithCapacity:[inArray count]];

 		id key, obj;

 		while ((key = [newEnum nextObject])) {

 			obj = [allNotifications objectForKey:key];

 			if (obj) {

 				[tmp setObject:obj forKey:key];

 			} else {

 				GrowlNotificationTicket *notification = [[GrowlNotificationTicket alloc] initWithName:key];

 				[notification setHumanReadableName:[humanReadableNames objectForKey:key]];

 				[notification setNotificationDescription:[notificationDescriptions objectForKey:key]];

 				[tmp setObject:notification forKey:key];

 				[notification release];

 			}

 		}

 		[allNotifications release];

 		allNotifications = tmp;

 		// And then make sure the list of default notifications also doesn't have any straglers...

 		NSMutableSet *cur = [[NSMutableSet alloc] initWithArray:defaultNotifications];

 		NSSet *new = [[NSSet alloc] initWithArray:allNotificationNames];

 		[cur intersectSet:new];

 		[defaultNotifications release];

 		defaultNotifications = [[cur allObjects] retain];

 		[cur release];

 		[new release];

 	}

 }

 - (NSArray *) defaultNotifications {

 	return [[defaultNotifications retain] autorelease];

 }

 - (void) setDefaultNotifications:(id)inObject {

 	if (!allNotifications) {

 		/*WARNING: if you try to pass an array containing numeric indices, and

 		 *	the all-notifications list has not been supplied yet, the indices

 		 *	WILL NOT be dereferenced. ALWAYS set the all-notifications list FIRST.

 		 */

 		if (![defaultNotifications isEqual:inObject]) {

 			[defaultNotifications release];

 			defaultNotifications = [inObject retain];

 			changed = YES;

 		}

 	} else if ([inObject respondsToSelector:@selector(objectEnumerator)] ) {

 		NSEnumerator *mightBeIndicesEnum = [inObject objectEnumerator];

 		NSNumber *num;

 		NSUInteger numDefaultNotifications;

 		NSUInteger numAllNotifications = [allNotificationNames count];

 		if ([inObject respondsToSelector:@selector(count)])

 			numDefaultNotifications = [inObject count];

 		else

 			numDefaultNotifications = numAllNotifications;

 		NSMutableArray *mDefaultNotifications = [[NSMutableArray alloc] initWithCapacity:numDefaultNotifications];

 		Class NSNumberClass = [NSNumber class];

 		while ((num = [mightBeIndicesEnum nextObject])) {

 			if ([num isKindOfClass:NSNumberClass]) {

 				//it's an index into the all-notifications list

 				unsigned notificationIndex = [num unsignedIntValue];

 				if (notificationIndex >= numAllNotifications)

 					NSLog(@"WARNING: application %@ tried to allow notification at index %u by default, but there is no such notification in its list of %u", appName, notificationIndex, numAllNotifications);

 				else

 					[mDefaultNotifications addObject:[allNotificationNames objectAtIndex:notificationIndex]];

 			} else {

 				//it's probably a notification name

 				[mDefaultNotifications addObject:num];

 			}

 		}

 		if (![defaultNotifications isEqualToArray:mDefaultNotifications]) {

 			[defaultNotifications release];

 			defaultNotifications = mDefaultNotifications;

 			changed = YES;

 		} else {

 			[mDefaultNotifications release];

 		}

 	} else if ([inObject isKindOfClass:[NSIndexSet class]]) {

 		NSUInteger notificationIndex;

 		NSUInteger numAllNotifications = [allNotificationNames count];

 		NSIndexSet *iset = (NSIndexSet *)inObject;

 		NSMutableArray *mDefaultNotifications = [[NSMutableArray alloc] initWithCapacity:[iset count]];

 		for (notificationIndex = [iset firstIndex]; notificationIndex != NSNotFound; notificationIndex = [iset indexGreaterThanIndex:notificationIndex]) {

 			if (notificationIndex >= numAllNotifications) {

 				NSLog(@"WARNING: application %@ tried to allow notification at index %u by default, but there is no such notification in its list of %u", appName, notificationIndex, numAllNotifications);

 				// index sets are sorted, so we can stop here

 				break;

 			} else {

 				[mDefaultNotifications addObject:[allNotificationNames objectAtIndex:notificationIndex]];

 			}

 		}

 		if (![defaultNotifications isEqualToArray:mDefaultNotifications]) {

 			[defaultNotifications release];

 			defaultNotifications = mDefaultNotifications;

 			changed = YES;

 		} else {

 			[mDefaultNotifications release];

 		}

 	} else {

 		if (inObject)

 			NSLog(@"WARNING: application %@ passed an invalid object for the default notifications: %@.", appName, inObject);

 		if (![defaultNotifications isEqualToArray:allNotificationNames]) {

 			[defaultNotifications release];

 			defaultNotifications = [allNotificationNames retain];

 			changed = YES;

 		}

 	}

 	if (useDefaults)

 		[self setAllowedNotificationsToDefault];

 }

 - (NSArray *) allowedNotifications {

 	NSMutableArray* allowed = [NSMutableArray array];

 	NSEnumerator *notificationEnum = [allNotifications objectEnumerator];

 	GrowlNotificationTicket *obj;

 	while ((obj = [notificationEnum nextObject]))

 		if ([obj enabled])

 			[allowed addObject:[obj name]];

 	return allowed;

 }

 - (void) setAllowedNotifications:(NSArray *) inArray {

 	NSSet *allowed = [[NSSet alloc] initWithArray:inArray];

 	NSEnumerator *notificationEnum = [allNotifications objectEnumerator];

 	GrowlNotificationTicket *obj;

 	while ((obj = [notificationEnum nextObject]))

 		[obj setEnabled:[allowed containsObject:[obj name]]];

 	[allowed release];

 	useDefaults = NO;

 }

 - (void) setAllowedNotificationsToDefault {

 	[self setAllowedNotifications:defaultNotifications];

 	useDefaults = YES;

 }

 - (BOOL) isNotificationAllowed:(NSString *) name {

 	return ticketEnabled && [[allNotifications objectForKey:name] enabled];

 }

 - (NSComparisonResult) caseInsensitiveCompare:(GrowlApplicationTicket *)aTicket {

 	return [appName caseInsensitiveCompare:[aTicket applicationName]];

 }

 #pragma mark Notification Accessors

 - (NSArray *) notifications {

 	return [allNotifications allValues];

 }

 - (GrowlNotificationTicket *) notificationTicketForName:(NSString *)name {

 	return [allNotifications objectForKey:name];

 }

 @end