//

//  GrowlDisplayWindowController.m

//  Display Plugins

//

//  Created by Mac-arena the Bored Zo on 2005-06-03.

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

//

#import "GrowlDisplayWindowController.h"

#import "GrowlPathUtilities.h"

#import "GrowlDefines.h"

#import "GrowlWindowTransition.h"

#import "GrowlPositionController.h"

#import "NSViewAdditions.h"

#import "GrowlNotificationDisplayBridge.h"

#import "GrowlApplicationNotification.h"

#import "GrowlNotificationView.h"

#include "GrowlLog.h"

#define DEFAULT_TRANSITION_DURATION	0.75

static NSMutableDictionary *existingInstances;

@interface GrowlDisplayWindowController (PRIVATE)

- (void)cancelDisplayDelayedPerforms;

- (BOOL)supportsStickyNotifications;

@end

@interface NSWindow (LeopardMethods)

- (void)setCollectionBehavior:(int)collectionBehavior;

@end

@implementation GrowlDisplayWindowController

#pragma mark -

#pragma mark Caching

+ (void) registerInstance:(id)instance withIdentifier:(NSString *)ident {

	if (!existingInstances)

		existingInstances = [[NSMutableDictionary alloc] init];

	NSDictionary *classInstances = [existingInstances objectForKey:self];

	if (!classInstances) {

		classInstances = [[NSMutableDictionary alloc] init];

		[existingInstances setObject:classInstances forKey:self];

		[classInstances release];

	}

	[classInstances setValue:instance forKey:ident];

}

+ (id) instanceWithIdentifier:(NSString *)ident {

	NSMutableDictionary *classInstances = [existingInstances objectForKey:self];

	if (classInstances)

		return [classInstances objectForKey:ident];

	else

		return nil;

}

+ (void) unregisterInstanceWithIdentifier:(NSString *)ident {

	NSMutableDictionary *classInstances = [existingInstances objectForKey:self];

	if (classInstances)

		[classInstances removeObjectForKey:ident];

}

#pragma mark -

- (id) initWithWindowNibName:(NSString *)windowNibName bridge:(GrowlNotificationDisplayBridge *)displayBridge {

	// NOTE: for completeness we ought to offer the other nib related init methods with the plugin as a param

	if ((self = [self initWithWindowNibName:windowNibName owner:displayBridge])) {

		[self setBridge:displayBridge]; // weak reference

	}

	return self;

}

- (id) initWithBridge:(GrowlNotificationDisplayBridge *)displayBridge {

	/* Subclasses using this method should call initWithWindowNibName: from init */

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

		[self setBridge:displayBridge]; // weak reference

	}

	return self;

}

- (id) initWithWindow:(NSWindow *)window {

	if ((self = [super initWithWindow:window])) {

		windowTransitions = [[NSMutableDictionary alloc] init];

		ignoresOtherNotifications = NO;

		bridge = nil;

		startTimes = NSCreateMapTable(NSObjectMapKeyCallBacks, NSIntMapValueCallBacks, 0U);

		endTimes = NSCreateMapTable(NSObjectMapKeyCallBacks, NSIntMapValueCallBacks, 0U);

		transitionDuration = DEFAULT_TRANSITION_DURATION;

		//Show notifications on all Spaces

		if ([window respondsToSelector:@selector(setCollectionBehavior:)]) {

#define NSWindowCollectionBehaviorCanJoinAllSpaces 1 << 0

			[window setCollectionBehavior:NSWindowCollectionBehaviorCanJoinAllSpaces];

		}

		//Respond to 'close all notifications' by closing

		[[NSNotificationCenter defaultCenter] addObserver:self

												 selector:@selector(stopDisplay)

													 name:GROWL_CLOSE_ALL_NOTIFICATIONS

												   object:nil];

	}

	return self;

}

- (void) dealloc {

	[self setDelegate:nil];

	[[self bridge] removeObserver:self forKeyPath:@"notification"];

	[[NSNotificationCenter defaultCenter] removeObserver:self];

	[self stopAllTransitions];

	NSFreeMapTable(startTimes);

	NSFreeMapTable(endTimes);

	[bridge				 release];

	[target              release];

	[clickContext        release];

	[clickHandlerEnabled release];

	[appName             release];

	[appPid              release];

	[windowTransitions   release];

	[notification        release];

	[super dealloc];

}

#pragma mark -

#pragma mark Screenshot mode

- (void) takeScreenshot {

	NSView *view = [[self window] contentView];

	NSString *path = [[[GrowlPathUtilities screenshotsDirectory] stringByAppendingPathComponent:[GrowlPathUtilities nextScreenshotName]] stringByAppendingPathExtension:@"png"];

	[[view dataWithPNGInsideRect:[view frame]] writeToFile:path atomically:NO];

}

#pragma mark -

#pragma mark Display control

- (BOOL)reposition_startingDisplay:(BOOL)shouldStartDisplay

{

	NSWindow *window = [self window];

	//Make sure we don't cover any other notification (or not)

	BOOL foundSpace = NO;

	GrowlPositionController *pc = [GrowlPositionController sharedInstance];

	if ([self respondsToSelector:@selector(idealOriginInRect:)])

		foundSpace = [pc positionDisplay:self];

	else

		foundSpace = (ignoresOtherNotifications || [pc reserveRect:[window frame] forDisplayController:self]);

	if (foundSpace) {

		if (shouldStartDisplay) {

			[self cancelDisplayDelayedPerforms];

			[self willDisplayNotification];

			[window orderFront:nil];

			if ([self startAllTransitions]) {

				[self performSelector:@selector(didFinishTransitionsBeforeDisplay)

						   withObject:nil

						   afterDelay:transitionDuration];

			} else {

				[self didFinishTransitionsBeforeDisplay];

			}

			[self didDisplayNotification];

		}

	} else {

		[[NSNotificationCenter defaultCenter] postNotificationName:GrowlDisplayWindowControllerNotificationBlockedNotification

															object:self];

		//Try again in 10 seconds

		if (!shouldStartDisplay) {

			//If we're restarting, get this display off-screen while we wait

			//XXX This should be more fluid

			[window orderOut:nil];

			[[GrowlPositionController sharedInstance] clearReservedRectForDisplayController:self];

		}

		[self performSelector:@selector(startDisplay) withObject:nil afterDelay:5];

	}

	return foundSpace;		

}

- (BOOL) startDisplay {

	return [self reposition_startingDisplay:YES];

}

- (void) stopDisplay {	

	id contentView = [[self window] contentView];

	if ([contentView respondsToSelector:@selector(mouseOver)] &&

		[contentView mouseOver] &&

		!userRequestedClose) {

		//The mouse is currently within the view; close when it exits

		[contentView setCloseOnMouseExit:YES];

	} else {

		//If we're already transitioning out, just keep doing our thing

		if (displayStatus != GrowlDisplayTransitioningOutStatus) {

			[self cancelDisplayDelayedPerforms];

			[self willTakeDownNotification];

			if ([self startAllTransitions]) {

				[self performSelector:@selector(didFinishTransitionsAfterDisplay) 

						   withObject:nil

						   afterDelay:transitionDuration];

			} else {

				[self didFinishTransitionsAfterDisplay];

			}

		}

	}

}

- (void) clickedClose {

	userRequestedClose = YES;

	[self stopDisplay];

}

#pragma mark -

#pragma mark Display stages

- (void)cancelDisplayDelayedPerforms

{

	[[self class] cancelPreviousPerformRequestsWithTarget:self

												 selector:@selector(didFinishTransitionsBeforeDisplay) 

												   object:nil];

	[[self class] cancelPreviousPerformRequestsWithTarget:self

												 selector:@selector(didFinishTransitionsAfterDisplay) 

												   object:nil];

	[[self class] cancelPreviousPerformRequestsWithTarget:self

												 selector:@selector(stopDisplay) 

												   object:nil];	

}

- (void) willDisplayNotification {

	displayStatus = GrowlDisplayTransitioningInStatus;

	[[NSNotificationCenter defaultCenter] postNotificationName:GrowlDisplayWindowControllerWillDisplayWindowNotification

														object:self];

}

- (void) didFinishTransitionsBeforeDisplay {

	[self cancelDisplayDelayedPerforms];

	if (![[[notification auxiliaryDictionary] objectForKey:GROWL_NOTIFICATION_STICKY] boolValue] ||

		![self supportsStickyNotifications]) {

		[self performSelector:@selector(stopDisplay)

				   withObject:nil

				   afterDelay:(displayDuration+transitionDuration)];		

	}

	displayStatus = GrowlDisplayOnScreenStatus;

}

- (void) didFinishTransitionsAfterDisplay {

	[self cancelDisplayDelayedPerforms];

	//Clear the rect we reserved...

	NSWindow *window = [self window];

	[window orderOut:nil];

	//Release all window transitions immediately; they may have retained our window.

	[self stopAllTransitions];

	[windowTransitions release]; windowTransitions = nil;

	[[GrowlPositionController sharedInstance] clearReservedRectForDisplayController:self];

	[self didTakeDownNotification];

	if ((bridge) && ([bridge respondsToSelector:@selector(display)]))

		[[bridge display] displayWindowControllerDidTakeDownWindow:self];

	else {

		NSLog(@"%@ bridge does not respond to display",bridge);

	}

}

- (void) didDisplayNotification {

	if (screenshotMode)

		[self takeScreenshot];

	[[NSNotificationCenter defaultCenter] postNotificationName:GrowlDisplayWindowControllerDidDisplayWindowNotification

														object:self];

}

- (void) willTakeDownNotification {

	[[NSNotificationCenter defaultCenter] postNotificationName:GrowlDisplayWindowControllerWillTakeWindowDownNotification

														object:self];

	displayStatus = GrowlDisplayTransitioningOutStatus;

}

- (void) didTakeDownNotification {

	NSNotificationCenter *nc = [NSNotificationCenter defaultCenter];

	if (clickContext) {

		NSMutableDictionary *userInfo = [[NSMutableDictionary alloc] initWithCapacity:2U];

		[userInfo setValue:clickContext forKey:GROWL_KEY_CLICKED_CONTEXT];

		if (appPid)

			[userInfo setValue:appPid forKey:GROWL_APP_PID];

		[nc postNotificationName:GROWL_NOTIFICATION_TIMED_OUT object:appName userInfo:userInfo];

		[userInfo release];

		//Avoid duplicate click messages by immediately clearing the clickContext

		clickContext = nil;

	}

	[nc postNotificationName:GrowlDisplayWindowControllerDidTakeWindowDownNotification object:self];

}

#pragma mark -

#pragma mark Click feedback

- (void) notificationClicked:(id)sender {

#pragma unused(sender)

	if (clickContext) {

		NSMutableDictionary *userInfo = [[NSMutableDictionary alloc] initWithCapacity:3U];

		[userInfo setValue:clickHandlerEnabled forKey:@"ClickHandlerEnabled"];

		[userInfo setValue:clickContext forKey:GROWL_KEY_CLICKED_CONTEXT];

		if (appPid)

			[userInfo setValue:appPid forKey:GROWL_APP_PID];

		[[NSNotificationCenter defaultCenter] postNotificationName:GROWL_NOTIFICATION_CLICKED

															object:appName

														  userInfo:userInfo];

		[userInfo release];

		//Avoid duplicate click messages by immediately clearing the clickContext

		clickContext = nil;

	}

	if (target && action && [target respondsToSelector:action])

		[target performSelector:action withObject:self];

	//Now that we've notified the clickContext and target, it's as if the user just clicked the close button

	[self clickedClose];

}

#pragma mark -

#pragma mark Window Transitions

- (BOOL) addTransition:(GrowlWindowTransition *)transition {

	[transition setWindow:[self window]];

	[transition setDelegate:self];

	if (![windowTransitions objectForKey:[transition class]]) {

		[windowTransitions setObject:transition forKey:[transition class]];

		return TRUE;

	}

	return FALSE;

}

- (void) removeTransition:(GrowlWindowTransition *)transition {

	[transition setDelegate:nil];

	[transition setWindow:nil];

	[windowTransitions removeObjectForKey:[transition class]];

}

- (void) setStartPercentage:(unsigned)start endPercentage:(unsigned)end forTransition:(GrowlWindowTransition *)transition {

	NSAssert1((start <= 100U || start < end),

			  @"The start parameter was invalid for the transition: %@",

			  transition);

	NSAssert1((end <= 100U || start < end),

			  @"The end parameter was invalid for the transition: %@",

			  transition);

	NSMapInsert(startTimes, transition, (void *)start);

	NSMapInsert(endTimes, transition, (void *)end);

}

#pragma mark-

- (NSArray *) allTransitions {

	return [windowTransitions allValues];

}

- (NSArray *) activeTransitions {

	int count = [windowTransitions count];

	NSMutableArray *result = [NSMutableArray arrayWithCapacity:count];

	NSArray *transitionArray = [windowTransitions allValues];

	int i;

	for (i=0; i<count; ++i) {

		GrowlWindowTransition *transition = [transitionArray objectAtIndex:i];

		if ([transition isAnimating])

			[result addObject:transition];

	}

	return result;

}

- (NSArray *) inactiveTransitions {

	int count = [windowTransitions count];

	NSMutableArray *result = [NSMutableArray arrayWithCapacity:count];

	NSArray *transitionArray = [windowTransitions allValues];

	int i;

	for (i=0; i<count; ++i) {

		GrowlWindowTransition *transition = [transitionArray objectAtIndex:i];

		if (![transition isAnimating])

			[result addObject:transition];

	}

	return result;

}

- (BOOL) startAllTransitions {

	BOOL result = NO;

	GrowlWindowTransition *transition;

	NSEnumerator *transitionEnum = [[windowTransitions allValues] objectEnumerator];

	while ((transition = [transitionEnum nextObject]))

		if ([self startTransition:transition])

			result = YES;

	return result;

}

- (BOOL) startTransition:(GrowlWindowTransition *)transition {

	int startPercentage = (int) NSMapGet(startTimes, transition);

	int endPercentage   = (int) NSMapGet(endTimes, transition);

	// If there were no times set up then the end time would be NULL (0)...

	if (endPercentage == 0)

		return NO;

	// Work out the start and the end times...

	CFTimeInterval startTime = (float)startPercentage * ((float)transitionDuration * 0.01);

	CFTimeInterval endTime = (float)endPercentage * ((float)transitionDuration * 0.01);

	// Set up this transition...

	[transition setDuration: (endTime - startTime)];

	[transition performSelector:@selector(startAnimation) 

					 withObject:nil

					 afterDelay:startTime];

	return YES;

}

- (BOOL) startTransitionOfKind:(Class)transitionClass {

	GrowlWindowTransition *transition = [windowTransitions objectForKey:transitionClass];

	if (transition)

		return [self startTransition:transition];

	return NO;

}

- (void) stopAllTransitions {

	GrowlWindowTransition *transition;

	NSEnumerator *transitionEnum = [[windowTransitions allValues] objectEnumerator];

	while (( transition = [transitionEnum nextObject] ))

		[self stopTransition:transition];

}

- (void) stopTransition:(GrowlWindowTransition *)transition {

	[transition stopAnimation];

	[self removeTransition:transition];

	[[self class] cancelPreviousPerformRequestsWithTarget:transition

												 selector:@selector(startAnimation)

												   object:nil];

}

- (void) stopTransitionOfKind:(Class)transitionClass {

	GrowlWindowTransition *transition = [windowTransitions objectForKey:transitionClass];

	if (transition)

		[self stopTransition:transition];

}

- (void) animationDidEnd:(NSAnimation *)animation

{

	if ([animation isKindOfClass:[GrowlWindowTransition class]] &&

		([(GrowlWindowTransition *)animation window] == [self window]) &&

		([(GrowlWindowTransition *)animation direction] == GrowlReverseTransition)) {

		//A fade out nonrepeating animation finished. We don't need to wait on our timeout; we know we finished displaying a notification.

		[self didFinishTransitionsAfterDisplay];

	}

}

- (void) reverseAllTransitions

{

	[[windowTransitions allValues] makeObjectsPerformSelector:@selector(reverse)];

}

#pragma mark -

- (void) mouseEnteredNotificationView:(GrowlNotificationView *)notificationView

{

#pragma unused (notificationView)

	if (!userRequestedClose &&

		(displayStatus == GrowlDisplayTransitioningOutStatus)) {

		// We're transitioning out; we need to go back to transitioning in...

		[self willDisplayNotification];

		[self reverseAllTransitions];

		[self didFinishTransitionsBeforeDisplay];

		// ...but when the mouse leaves, transition out again

		[self stopDisplay];

	}

}

- (void) mouseExitedNotificationView:(GrowlNotificationView *)notificationView

{

#pragma unused (notificationView)

	// Notifies us that the mouse left the notification view.

}

#pragma mark -

#pragma mark Notifications

- (GrowlApplicationNotification *) notification {

	// Only here for binding conformance

    return notification;

}

- (void) setNotification:(GrowlApplicationNotification *)theNotification {

    if (notification != theNotification) {

		[notification release];

		notification = [theNotification retain];

	}

}

- (void) updateToNotification:(GrowlApplicationNotification *)theNotification {

	[self setNotification:theNotification];

	switch (displayStatus) {

		case GrowlDisplayUnknownStatus:

		case GrowlDisplayTransitioningInStatus:

			//Do nothing; we're still transitioning in

			break;

		case GrowlDisplayOnScreenStatus:

			//We're on screen; reset our timer for transitioning out

			[self didFinishTransitionsBeforeDisplay];

			break;

		case GrowlDisplayTransitioningOutStatus:

			//Reset userRequestedClose in case we were transitioning out via the user's request; we have new information!

			userRequestedClose = NO;

			[self willDisplayNotification];

			[self reverseAllTransitions];

			[self didFinishTransitionsBeforeDisplay];

			break;

	}

	[self reposition_startingDisplay:NO];

}

#pragma mark -

- (GrowlNotificationDisplayBridge *) bridge {

    return bridge;

}

- (void) setBridge:(GrowlNotificationDisplayBridge *)theBridge {

	if (bridge != theBridge) {

		if (bridge) {

			NSLog(@"*** This may be an error. %@ had its bridge reset", self);

			[bridge removeObserver:self forKeyPath:@"notification"];

		}

		bridge = [theBridge retain];

		[bridge addObserver:self forKeyPath:@"notification" options:NSKeyValueObservingOptionNew context:NULL];

		[self observeValueForKeyPath:@"notification" ofObject:bridge change:nil context:NULL];

	}

}

- (void)observeValueForKeyPath:(NSString *)keyPath ofObject:(id)object change:(NSDictionary *)change context:(void *)context

{

#pragma unused(change)

#pragma unused(context)

	if ((object == bridge) &&

		[keyPath isEqualToString:@"notification"]) {

		[self setNotification:[bridge notification]];

	}

}

#pragma mark -

- (CFTimeInterval) transitionDuration {

    return transitionDuration;

}

- (void) setTransitionDuration:(CFTimeInterval)theTransitionDuration{

    transitionDuration = theTransitionDuration;

}

#pragma mark -

- (CFTimeInterval) displayDuration {

	return displayDuration;

}

- (void) setDisplayDuration:(CFTimeInterval)newDuration {

	displayDuration = newDuration;

}

#pragma mark -

- (BOOL) screenshotModeEnabled {

	return screenshotMode;

}

- (void) setScreenshotModeEnabled:(BOOL)newScreenshotMode {

	screenshotMode = newScreenshotMode;

}

#pragma mark -

- (NSScreen *) screen {

	NSArray *screens = [NSScreen screens];

	if (screenNumber < [screens count])

		return [screens objectAtIndex:screenNumber];

	else

		return [NSScreen mainScreen];

}

- (void) setScreen:(NSScreen *)newScreen {

	unsigned newScreenNumber = [[NSScreen screens] indexOfObjectIdenticalTo:newScreen];

	if (newScreenNumber == NSNotFound)

		[NSException raise:NSInternalInconsistencyException format:@"Tried to set %@ %p to a screen %p that isn't in the screen list", [self class], self, newScreen];

	[self setScreenNumber:newScreenNumber];

}

- (void) setScreenNumber:(unsigned)newScreenNumber {

	[self willChangeValueForKey:@"screenNumber"];

	screenNumber = newScreenNumber;

	[self  didChangeValueForKey:@"screenNumber"];

}

- (BOOL)supportsStickyNotifications

{

	return ![[self window] ignoresMouseEvents];

}

#pragma mark -

- (id) target {

	return target;

}

- (void) setTarget:(id)object {

	if (object != target) {

		[target release];

		target = [object retain];

	}

}

#pragma mark -

- (SEL) action {

	return action;

}

- (void) setAction:(SEL) selector {

	action = selector;

}

#pragma mark -

- (NSString *) notifyingApplicationName {

	return appName;

}

- (void) setNotifyingApplicationName:(NSString *)inAppName {

	if (inAppName != appName) {

		[appName release];

		appName = [inAppName copy];

	}

}

#pragma mark -

- (NSNumber *) notifyingApplicationProcessIdentifier {

	return appPid;

}

- (void) setNotifyingApplicationProcessIdentifier:(NSNumber *)inAppPid {

	if (inAppPid != appPid) {

		[appPid release];

		appPid = [inAppPid retain];

	}

}

#pragma mark -

- (id) clickContext {

	return clickContext;

}

- (void) setClickContext:(id)inClickContext {

	if (clickContext != inClickContext) {

		[clickContext release];

		clickContext = [inClickContext retain];

	}

}

#pragma mark -

- (BOOL) ignoresOtherNotifications {

	return ignoresOtherNotifications;

}

- (void) setIgnoresOtherNotifications:(BOOL)flag {

	ignoresOtherNotifications = flag;

}

#pragma mark -

- (id) delegate {

	return delegate;

}

- (void) setDelegate:(id)newDelegate {

	if (delegate)

		[self removeNotificationObserver:delegate];

	if (newDelegate)

		[self addNotificationObserver:newDelegate];

	delegate = newDelegate;

}

#pragma mark -

- (NSNumber *) clickHandlerEnabled {

	return clickHandlerEnabled;

}

- (void) setClickHandlerEnabled:(NSNumber *)flag {

	if (flag != clickHandlerEnabled) {

		[clickHandlerEnabled release];

		clickHandlerEnabled = [flag retain];

	}

}

#pragma mark -

- (void) addNotificationObserver:(id)observer {

	NSParameterAssert(observer != nil);

	NSNotificationCenter *nc = [NSNotificationCenter defaultCenter];

	if (observer) {

		//register the new delegate.

		if ([observer respondsToSelector:@selector(displayWindowControllerWillDisplayWindow:)])

			[nc addObserver:observer

				   selector:@selector(displayWindowControllerWillDisplayWindow:)

					   name:GrowlDisplayWindowControllerWillDisplayWindowNotification

					 object:self];

		if ([observer respondsToSelector:@selector(displayWindowControllerDidDisplayWindow:)])

			[nc addObserver:observer

				   selector:@selector(displayWindowControllerDidDisplayWindow:)

					   name:GrowlDisplayWindowControllerDidDisplayWindowNotification

					 object:self];

		if ([observer respondsToSelector:@selector(displayWindowControllerWillTakeDownWindow:)])

			[nc addObserver:observer

				   selector:@selector(displayWindowControllerWillTakeWindowDown:)

					   name:GrowlDisplayWindowControllerWillTakeWindowDownNotification

					 object:self];

		if ([observer respondsToSelector:@selector(displayWindowControllerDidTakeWindowDown:)])

			[nc addObserver:observer

				   selector:@selector(displayWindowControllerDidTakeWindowDown:)

					   name:GrowlDisplayWindowControllerDidTakeWindowDownNotification

					 object:self];

		if ([observer respondsToSelector:@selector(displayWindowControllerNotificationBlocked:)])

			[nc addObserver:observer

				   selector:@selector(displayWindowControllerNotificationBlocked:)

					   name:GrowlDisplayWindowControllerNotificationBlockedNotification

					 object:self];

	}

}

- (void) removeNotificationObserver:(id)observer {

	[[NSNotificationCenter defaultCenter] removeObserver:observer];

}

@end