/* 

  * Adium is the legal property of its developers, whose names are listed in the copyright file included

  * with this source distribution.

  * 

  * This program is free software; you can redistribute it and/or modify it under the terms of the GNU

  * General Public License as published by the Free Software Foundation; either version 2 of the License,

  * or (at your option) any later version.

  * 

  * This program is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even

  * the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General

  * Public License for more details.

  * 

  * You should have received a copy of the GNU General Public License along with this program; if not,

  * write to the Free Software Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.

  */

 // $Id$

 #import "AIInterfaceController.h"

 #import <Adium/AIAccountControllerProtocol.h>

 #import <Adium/AIContactControllerProtocol.h>

 #import <Adium/AIChatControllerProtocol.h>

 #import <Adium/AIContentControllerProtocol.h>

 #import <Adium/AIMenuControllerProtocol.h>

 #import <Adium/AIAuthorizationRequestsWindowController.h>

 #import <AIUtilities/AIAttributedStringAdditions.h>

 #import <AIUtilities/AIColorAdditions.h>

 #import <AIUtilities/AIFontAdditions.h>

 #import <AIUtilities/AIImageDrawingAdditions.h>

 #import <AIUtilities/AIMenuAdditions.h>

 #import <AIUtilities/AIStringAdditions.h>

 #import <AIUtilities/AITooltipUtilities.h>

 #import <AIUtilities/AIWindowAdditions.h>

 #import <AIUtilities/AITextAttributes.h>

 #import <AIUtilities/AIWindowControllerAdditions.h>

 #import <Adium/AIChat.h>

 #import <Adium/AIListContact.h>

 #import <Adium/AIListGroup.h>

 #import <Adium/AIListObject.h>

 #import <Adium/AIMetaContact.h>

 #import <Adium/AIService.h>

 #import <Adium/AIServiceIcons.h>

 #import <Adium/AISortController.h>

 #import "AIMessageTabViewItem.h"

 #import "KNShelfSplitview.h"

 #import <Adium/AIContactList.h>

 #import "AIMessageViewController.h"

 #define ERROR_MESSAGE_WINDOW_TITLE		AILocalizedString(@"Adium : Error","Error message window title")

 #define LABEL_ENTRY_SPACING				4.0

 #define DISPLAY_IMAGE_ON_RIGHT			NO

 #define PREF_GROUP_FORMATTING			@"Formatting"

 #define KEY_FORMATTING_FONT				@"Default Font"

 #define MESSAGES_WINDOW_MENU_TITLE		AILocalizedString(@"Chats","Title for the messages window menu item")

 //#define	LOG_RESPONDER_CHAIN

 @interface AIInterfaceController ()

 - (void)_resetOpenChatsCache;

 - (void)_addItemToMainMenuAndDock:(NSMenuItem *)item;

 - (NSAttributedString *)_tooltipTitleForObject:(AIListObject *)object;

 - (NSAttributedString *)_tooltipBodyForObject:(AIListObject *)object;

 - (void)_pasteWithPreferredSelector:(SEL)preferredSelector sender:(id)sender;

 - (void)updateCloseMenuKeys;

 - (void)saveContainers;

 - (void)restoreSavedContainers;

 //Window Menu

 - (void)updateActiveWindowMenuItem;

 - (void)buildWindowMenu;

 - (AIChat *)mostRecentActiveChat;

 @end

 /*!

  * @class AIInterfaceController

  * @brief Interface controller

  *

  * Chat window related requests, such as opening and closing chats, are routed through the interface controller

  * to the appropriate component. The interface controller keeps track of the most recently active chat, handles chat

  * cycling (switching between chats), chat sorting, and so on.  The interface controller also handles switching to

  * an appropriate window or chat when the dock icon is clicked for a 'reopen' event.

  *

  * Contact list window requests, such as toggling window visibilty are routed to the contact list controller component.

  *

  * Error messages are routed through the interface controller.

  *

  * Tooltips, such as seen on hover in the contact list are generated and displayed here.  Tooltip display components and

  * plugins register with the interface controller to be queried for contact information when a tooltip is displayed.

  *

  * When displays in Adium flash, such as in the dock or the contact list for unviewed content, the interface controller

  * manages keeping the flashing synchronized.

  *

  * Finally, the interface controller manages many menu items, providing better menu item validation and target routing

  * than the responder chain alone would do.

  */

 @implementation AIInterfaceController

 - (id)init

 {

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

 		contactListViewArray = [[NSMutableArray alloc] init];

 		messageViewArray = [[NSMutableArray alloc] init];

 		contactListTooltipEntryArray = [[NSMutableArray alloc] init];

 		contactListTooltipSecondaryEntryArray = [[NSMutableArray alloc] init];

 		closeMenuConfiguredForChat = NO;

 		_cachedOpenChats = nil;

 		mostRecentActiveChat = nil;

 		activeChat = nil;

 		tooltipListObject = nil;

 		tooltipTitle = nil;

 		tooltipBody = nil;

 		tooltipImage = nil;

 		flashObserverArray = nil;

 		flashTimer = nil;

 		flashState = 0;

 		windowMenuArray = nil;

 #ifdef LOG_RESPONDER_CHAIN

 		[NSTimer scheduledTimerWithTimeInterval:2.0 target:self selector:@selector(reportResponderChain:) userInfo:nil repeats:YES];

 #endif

 	}

 	return self;

 }

 #ifdef LOG_RESPONDER_CHAIN

 //Can be called by a timer to periodically log the responder chain

 //[NSTimer scheduledTimerWithTimeInterval:2.0 target:self selector:@selector(reportResponderChain:) userInfo:nil repeats:YES];

 - (void)reportResponderChain:(NSTimer *)inTimer

 {

 	NSMutableString	*responderChain = [NSMutableString string];

 	NSWindow	*keyWindow = [[NSApplication sharedApplication] keyWindow];

 #warning 64BIT: Check formatting arguments

 	[responderChain appendFormat:@"%@ (%i): ",keyWindow,[keyWindow respondsToSelector:@selector(print:)]];

 	NSResponder	*responder = [keyWindow firstResponder];

 	//First, walk down the responder chain looking for a responder which can handle the preferred selector

 	while (responder) {

 #warning 64BIT: Check formatting arguments

 		[responderChain appendFormat:@"%@ (%i)",responder,[responder respondsToSelector:@selector(print:)]];

 		responder = [responder nextResponder];

 		if (responder) [responderChain appendString:@" -> "];

 	}

 	NSLog(responderChain);

 }

 #endif

 - (void)controllerDidLoad

 {

     //Load the interface

     [interfacePlugin openInterface];

 	//Open the contact list window

     [self showContactList:nil];

 	//Userlist show/hide item

 	menuItem_toggleUserlist = [[NSMenuItem allocWithZone:[NSMenu menuZone]] initWithTitle:AILocalizedString(@"Toggle User List", nil)

 																							 target:self

 																							 action:@selector(toggleUserlist:)

 																					  keyEquivalent:@"/"];

 	[menuItem_toggleUserlist setKeyEquivalentModifierMask:(NSCommandKeyMask | NSAlternateKeyMask)];

 	[adium.menuController addMenuItem:menuItem_toggleUserlist toLocation:LOC_Display_General];

 	menuItem_toggleUserlistSide = [[NSMenuItem allocWithZone:[NSMenu menuZone]] initWithTitle:AILocalizedString(@"Toggle User List Side", nil)

 																				   target:self

 																				   action:@selector(toggleUserlistSide:)

 																			keyEquivalent:@""];

 	[adium.menuController addMenuItem:menuItem_toggleUserlistSide toLocation:LOC_Display_General];

 	NSMenuItem *menuItem = [[[NSMenuItem allocWithZone:[NSMenu menuZone]] initWithTitle:AILocalizedString(@"Toggle User List", nil)

 																				target:self

 																				action:@selector(toggleUserlist:)

 																		 keyEquivalent:@""] autorelease];

 	[adium.menuController addContextualMenuItem:menuItem toLocation:Context_GroupChat_Action];

 	// Clear display

 	menuItem_clearDisplay = [[NSMenuItem allocWithZone:[NSMenu menuZone]] initWithTitle:AILocalizedString(@"Clear Display", nil)

 																				 target:self

 																				 action:@selector(clearDisplay:)

 																		  keyEquivalent:@""];

 	[adium.menuController addMenuItem:menuItem_clearDisplay toLocation:LOC_Display_MessageControl];

 	//Contact list menu item

 	menuItem = [[NSMenuItem allocWithZone:[NSMenu menuZone]] initWithTitle:AILocalizedString(@"Contact List","Name of the window which lists contacts")

 																				target:self

 																				action:@selector(toggleContactList:)

 																		 keyEquivalent:@"/"];

 	[adium.menuController addMenuItem:menuItem toLocation:LOC_Window_Fixed];

 	[adium.menuController addMenuItem:[[menuItem copy] autorelease] toLocation:LOC_Dock_Status];

 	[menuItem release];

 	menuItem = [[NSMenuItem allocWithZone:[NSMenu menuZone]] initWithTitle:AILocalizedString(@"Close Chat","Title for the close chat menu item")

 																	target:self

 																	action:@selector(closeContextualChat:)

 															 keyEquivalent:@""];

 	[adium.menuController addContextualMenuItem:menuItem toLocation:Context_Tab_Action];

 	[menuItem release];

 	// Authorization requests menu item

 	menuItem = [[NSMenuItem alloc] initWithTitle:AILocalizedStringFromTableInBundle(@"Authorization Requests",nil, [NSBundle bundleForClass:[AIAuthorizationRequestsWindowController class]], nil)

 										  target:self

 										  action:@selector(openAuthorizationWindow:)

 								   keyEquivalent:@""];

 	[adium.menuController addMenuItem:menuItem toLocation:LOC_Window_Auxiliary];

 	[menuItem release];

     //Observe content so we can open chats as necessary

     [[NSNotificationCenter defaultCenter] addObserver:self selector:@selector(didReceiveContent:) 

 									   name:CONTENT_MESSAGE_RECEIVED object:nil];

     [[NSNotificationCenter defaultCenter] addObserver:self selector:@selector(didReceiveContent:) 

 									   name:CONTENT_MESSAGE_RECEIVED_GROUP object:nil];

 	//Observe Adium finishing loading so we can do things which may require other components or plugins

 	[[NSNotificationCenter defaultCenter] addObserver:self

 								   selector:@selector(adiumDidFinishLoading:)

 									   name:AIApplicationDidFinishLoadingNotification

 									 object:nil];

 	//Observe quits so we can save containers.

 	[[NSNotificationCenter defaultCenter] addObserver:self

 								   selector:@selector(saveContainersOnQuit:)

 									   name:AIAppWillTerminateNotification

 									 object:nil];

 }

 - (void)controllerWillClose

 {

     [contactListPlugin closeContactList];

     [interfacePlugin closeInterface];

 }

 // Dealloc

 - (void)dealloc

 {

     [contactListViewArray release]; contactListViewArray = nil;

     [messageViewArray release]; messageViewArray = nil;

     [interfaceArray release]; interfaceArray = nil;

     [tooltipListObject release]; tooltipListObject = nil;

 	[tooltipTitle release]; tooltipTitle = nil;

 	[tooltipBody release]; tooltipBody = nil;

 	[tooltipImage release]; tooltipImage = nil;

 	[[NSNotificationCenter defaultCenter] removeObserver:self];

 	[adium.preferenceController unregisterPreferenceObserver:self];

     [super dealloc];

 }

 - (void)adiumDidFinishLoading:(NSNotification *)inNotification

 {

 	//Observe preference changes. This will also restore saved containers if appropriate.

 	[adium.preferenceController registerPreferenceObserver:self forGroup:PREF_GROUP_INTERFACE];

 	[[NSNotificationCenter defaultCenter] removeObserver:self

 										  name:AIApplicationDidFinishLoadingNotification

 										object:nil];

 }

 //Registers code to handle the interface

 - (void)registerInterfaceController:(id <AIInterfaceComponent>)inController

 {

 	if (!interfacePlugin) interfacePlugin = [inController retain];

 }

 //Register code to handle the contact list

 - (void)registerContactListController:(id <AIContactListComponent>)inController

 {

 	if (!contactListPlugin) contactListPlugin = [inController retain];

 }

 //Preferences changed

 - (void)preferencesChangedForGroup:(NSString *)group key:(NSString *)key

 							object:(AIListObject *)object preferenceDict:(NSDictionary *)prefDict firstTime:(BOOL)firstTime

 {

 	if (!object) {

 		//Update prefs

 		tabbedChatting = [[prefDict objectForKey:KEY_TABBED_CHATTING] boolValue];

 		groupChatsByContactGroup = [[prefDict objectForKey:KEY_GROUP_CHATS_BY_GROUP] boolValue];

 		saveContainers = [[prefDict objectForKey:KEY_SAVE_CONTAINERS] boolValue];

 		if (firstTime) {

 			if (saveContainers) {

 				//Restore saved containers

 				[self restoreSavedContainers];	

 			} else if ([prefDict objectForKey:KEY_CONTAINERS]) {

 				/* We've loaded without wanting to save containers; clear any saved

 				 * from a previous session.

 				 */

 				[adium.preferenceController setPreference:nil

 													 forKey:KEY_CONTAINERS

 													  group:PREF_GROUP_INTERFACE];

 			}

 		}

 	}

 }

 //Handle a reopen/dock icon click

 - (BOOL)handleReopenWithVisibleWindows:(BOOL)visibleWindows

 {

 	if (![self contactListIsVisibleAndMain] && [[interfacePlugin openContainerIDs] count] == 0) {

 		//The contact list is not visible, and there are no chat windows. Make the contact list visible.

 		[self showContactList:nil];

 	} else {

 		AIChat	*mostRecentUnviewedChat;

 		//If windows are open, try switching to a chat with unviewed content

 		if ((mostRecentUnviewedChat = [adium.chatController mostRecentUnviewedChat])) {

 			if ([mostRecentActiveChat unviewedContentCount]) {

 				//If the most recently active chat has unviewed content, ensure it is in the front

 				[self setActiveChat:mostRecentActiveChat];

 			} else {

 				//Otherwise, switch to the chat which most recently received content

 				[self setActiveChat:mostRecentUnviewedChat];

 			}

 		} else {

 			NSWindow *targetWindow = nil;

 			BOOL	 unMinimizedWindows = 0;

 			//If there was no unviewed content, ensure that atleast one of Adium's windows is unminimized

 			for (NSWindow *window in [NSApp windows]) {

 				//Check stylemask to rule out the system menu's window (Which reports itself as visible like a real window)

 				if (([window styleMask] & (NSTitledWindowMask | NSClosableWindowMask | NSMiniaturizableWindowMask))) {

 					if (!targetWindow) targetWindow = window;

 					if (![window isMiniaturized]) unMinimizedWindows++;

 				}

 			}

 			//If there are no unminimized windows, unminimize the last one

 			if (unMinimizedWindows == 0 && targetWindow) {

 				[targetWindow deminiaturize:nil];

 			}

 		}

 	}

 	return YES; 

 }

 //Contact List ---------------------------------------------------------------------------------------------------------

 #pragma mark Contact list

 /*!

  * @brief Toggles contact list between visible and hiden

  */

 - (IBAction)toggleContactList:(id)sender

 {

     if ([self contactListIsVisibleAndMain]) {

 		[self closeContactList:nil];

     } else {

 		[[NSApplication sharedApplication] activateIgnoringOtherApps:YES];

 		[self showContactList:nil];

     } 

 }

 /*!

  * @brief Brings contact list to the front

  */

 - (IBAction)showContactList:(id)sender

 {

 	[contactListPlugin showContactListAndBringToFront:YES];

 }

 /*!

  * @brief Show the contact list window and bring Adium to the front

  */

 - (IBAction)showContactListAndBringToFront:(id)sender

 {

 	[contactListPlugin showContactListAndBringToFront:YES];

 	[[NSApplication sharedApplication] activateIgnoringOtherApps:YES];

 }

 /*!

  * @brief Close the contact list window

  */

 - (IBAction)closeContactList:(id)sender

 {

 	[contactListPlugin closeContactList];

 }

 /*!

  * @returns YES if contact list is visible and selected, otherwise NO

  */

 - (BOOL)contactListIsVisibleAndMain

 {

 	return [contactListPlugin contactListIsVisibleAndMain];

 }

 /*!

 * @returns YES if contact list is visible, otherwise NO

  */

 - (BOOL)contactListIsVisible

 {

 	return [contactListPlugin contactListIsVisible];

 }

 //Detachable Contact List ----------------------------------------------------------------------------------------------

 #pragma mark Detachable Contact List

 /*!

  * @returns Created contact list controller for detached contact list

  */

 - (AIListWindowController *)detachContactList:(AIContactList *)aContactList

 {

 	return [contactListPlugin detachContactList:aContactList];

 }

 #pragma mark Container Saving

 /*!

  * @brief Restores containers saved from a previous session

  */

 - (void)restoreSavedContainers

 {

 	NSData				*savedData = [adium.preferenceController preferenceForKey:KEY_CONTAINERS

 																	group:PREF_GROUP_INTERFACE];

 	// If there's no data, we can't restore anything.

 	if (!savedData)

 		return;

 	for (NSDictionary *dict in [NSKeyedUnarchiver unarchiveObjectWithData:savedData]) {

 		AIMessageWindowController *windowController = [self openContainerWithID:[dict objectForKey:@"ID"]

 																 name:[dict objectForKey:@"Name"]];

 		AIChat *containerActiveChat = nil;

 		// Position the container where it was last saved (using -savedFrameFromString: to prevent going offscreen)

 		[[windowController window] setFrame:[windowController savedFrameFromString:[dict objectForKey:@"Frame"]] display:YES];

 		for (NSDictionary *chatDict in [dict objectForKey:@"Content"]) {

 			AIChat			*chat = nil;

 			AIService		*service = [adium.accountController firstServiceWithServiceID:[chatDict objectForKey:@"serviceID"]];

 			AIAccount		*account = [adium.accountController accountWithInternalObjectID:[chatDict objectForKey:@"AccountID"]];

 			if ([[chatDict objectForKey:@"IsGroupChat"] boolValue]) {

 				chat = [adium.chatController chatWithName:[chatDict objectForKey:@"Name"]

 												 identifier:nil

 												  onAccount:account

 										   chatCreationInfo:[chatDict objectForKey:@"ChatCreationInfo"]];

 			} else {

 				AIListContact		*contact = [adium.contactController contactWithService:service

 																					account:account

 																						UID:[chatDict objectForKey:@"UID"]];

 				chat = [adium.chatController chatWithContact:contact];

 			}

 			// Tag the chat as restored.

 			[chat setValue:[NSNumber numberWithBool:YES]

 			   forProperty:@"Restored Chat"

 					notify:NotifyNow];

 			if ([[chatDict objectForKey:@"ActiveChat"] boolValue]) {

 				containerActiveChat = chat;

 			}

 			// Open the chat into the container we've created above.

 			[self openChat:chat inContainerWithID:[dict objectForKey:@"ID"] atIndex:-1];

 		}

 		if (containerActiveChat)

 			[self setActiveChat:containerActiveChat];

 	}

 }

 /*!

  * @brief Saves open container information with their content when Adium quits

  */

 - (void)saveContainersOnQuit:(NSNotification *)notification

 {

 	[self saveContainers];

 }

 /*!

  * @brief Save opened containers and windows

  *

  * @param withContent Save the current buffer of the window to restore at a later point

  */

 - (void)saveContainers

 {

 	if (!saveContainers) {

 		// Don't save anything if we're not set to.

 		return;

 	}

 	// Save active containers.

 	NSMutableArray		*savedContainers = [NSMutableArray array];

 	for (NSDictionary *dict in [interfacePlugin openContainersAndChats]) {

 		NSMutableArray		*containerContents = [NSMutableArray array];

 		for (AIChat *chat in [dict objectForKey:@"Content"]) {

 			NSMutableDictionary		*newContainerDict = [NSMutableDictionary dictionary];

 			[newContainerDict setObject:chat.account.internalObjectID forKey:@"AccountID"];

 			// Save chat-specific information.

 			if (chat.isGroupChat) {

 				// -chatCreationDictionary may be nil, so put it last.

 				[newContainerDict addEntriesFromDictionary:[NSDictionary dictionaryWithObjectsAndKeys:

 															[NSNumber numberWithBool:YES], @"IsGroupChat",

 															[NSNumber numberWithBool:([dict objectForKey:@"ActiveChat"] == chat)], @"ActiveChat",

 															chat.name, @"Name",

 															[chat chatCreationDictionary], @"ChatCreationInfo",nil]];

 			} else {

 				[newContainerDict addEntriesFromDictionary:[NSDictionary dictionaryWithObjectsAndKeys:

 															[NSNumber numberWithBool:([dict objectForKey:@"ActiveChat"] == chat)], @"ActiveChat",

 															chat.listObject.UID, @"UID",

 															chat.account.service.serviceID, @"serviceID",

 															chat.account.internalObjectID, @"AccountID",nil]];

 			}

 			[containerContents addObject:newContainerDict];

 		}

 		// Replace the "Content" key in -openContainersAndChats with our version of the content.

 		// Remove the ActiveChat reference

 		// We use the same keys otherwise that -openContainersAndChats provides (Name, ID, Frame)

 		NSMutableDictionary *saveDict = [[dict mutableCopy] autorelease];

 		[saveDict removeObjectForKey:@"ActiveChat"];

 		[saveDict setObject:containerContents

 					 forKey:@"Content"];

 		[savedContainers addObject:saveDict];

 	}

 	[adium.preferenceController setPreference:[NSKeyedArchiver archivedDataWithRootObject:savedContainers]

 										 forKey:KEY_CONTAINERS

 										  group:PREF_GROUP_INTERFACE];

 }

 //Messaging ------------------------------------------------------------------------------------------------------------

 //Methods for instructing the interface to provide a representation of chats, and to determine which chat has user focus

 #pragma mark Messaging

 /*!

  * @brief Opens window for chat

  */

 - (void)openChat:(AIChat *)inChat

 {

 	NSArray		*containerIDs = [interfacePlugin openContainerIDs];

 	NSString	*containerID = nil;

 	NSString	*containerName = nil;

 	//Determine the correct container for this chat

 	if (!tabbedChatting) {

 		//We're not using tabs; each chat starts in its own container, based on the destination object or the chat name

 		if ([inChat listObject]) {

 			containerID = inChat.listObject.internalObjectID;

 		} else {

 			containerID = inChat.name;

 		}

 	} else if (groupChatsByContactGroup) {

 		if (inChat.isGroupChat) {

 			containerID = AILocalizedString(@"Group Chats",nil);

 		} else {

 			//XXX multiple containers: this is "correct" but maybe not desirable, as it is non-deterministic

 			AIListGroup	*group = inChat.listObject.parentContact.groups.anyObject;

 			//If the contact is in the contact list root, we don't have a group

 			if (group && ![group isKindOfClass:[AIContactList class]]) {

 				containerID = group.displayName;

 			}

 		}

 		containerName = containerID;

 	}

 	if (!containerID) {

 		//Open new chats into the first container (if not available, create a new one)

 		if ([containerIDs count] > 0) {

 			containerID = [containerIDs objectAtIndex:0];

 		} else {

 			containerID = nil;

 		}

 	}

 	//Determine the correct placement for this chat within the container

 	[interfacePlugin openChat:inChat inContainerWithID:containerID withName:containerName atIndex:-1];

 	if (![inChat isOpen]) {

 		[inChat setIsOpen:YES];

 		//Post the notification last, so observers receive a chat whose isOpen flag is yes.

 		[[NSNotificationCenter defaultCenter] postNotificationName:Chat_DidOpen object:inChat userInfo:nil];

 	}

 }

 - (id)openChat:(AIChat *)inChat inContainerWithID:(NSString *)containerID atIndex:(NSUInteger)index

 {	

 	NSArray		*openContainerIDs = [interfacePlugin openContainerIDs];

 	if (!containerID) {

 		//Open new chats into the first container (if not available, create a new one)

 		if ([openContainerIDs count] > 0) {

 			containerID = [openContainerIDs objectAtIndex:0];

 		} else {

 			containerID = AILocalizedString(@"Chats",nil);

 		}

 	}

 	//Determine the correct placement for this chat within the container

 	id tabViewItem = [interfacePlugin openChat:inChat inContainerWithID:containerID withName:nil atIndex:index];

 	if (![inChat isOpen]) {

 		[inChat setIsOpen:YES];

 		//Post the notification last, so observers receive a chat whose isOpen flag is yes.

 		[[NSNotificationCenter defaultCenter] postNotificationName:Chat_DidOpen object:inChat userInfo:nil];

 	}

 	return tabViewItem;

 }

 /**

  * @brief Opens a container with a specific ID

  *

  * Asks the interfacePlugin to openContainerWithID:

  */

 - (AIMessageWindowController *)openContainerWithID:(NSString *)containerID name:(NSString *)containerName

 {

 	return [interfacePlugin openContainerWithID:containerID name:containerName];

 }

 /*!

  * @brief Close the interface for a chat

  *

  * Tell the interface plugin to close the chat.

  */

 - (void)closeChat:(AIChat *)inChat

 {

 	if (inChat) {

 		if ([adium.chatController closeChat:inChat]) {

 			[interfacePlugin closeChat:inChat];

 		}

 	}

 }

 /*!

  * @brief Consolidate chats into a single container

  */

 - (void)consolidateChats

 {

 	//We work with copies of these arrays, since moving chats may change their contents

 	NSArray			*openContainerIDs = [[interfacePlugin openContainerIDs] copy];

 	NSEnumerator	*containerEnumerator = [openContainerIDs objectEnumerator];

 	NSString		*firstContainerID = [containerEnumerator nextObject];

 	NSString		*containerID;

 	//For all containers but the first, move the chats they contain to the first container

 	while ((containerID = [containerEnumerator nextObject])) {

 		NSArray			*openChats = [[interfacePlugin openChatsInContainerWithID:containerID] copy];

 		NSEnumerator	*chatEnumerator = [openChats objectEnumerator];

 		AIChat			*chat;

 		//Move all the chats, providing a target index if chat sorting is enabled

 		while ((chat = [chatEnumerator nextObject])) {

 			[interfacePlugin moveChat:chat

 					toContainerWithID:firstContainerID

 								index:-1];

 		}

 		[openChats release];

 	}

 	[self chatOrderDidChange];

 	[openContainerIDs release];

 }

 - (void)moveChatToNewContainer:(AIChat *)inChat

 {

 	[interfacePlugin moveChatToNewContainer:inChat];

 }

 /*!

  * @returns Active chat

  */

 - (AIChat *)activeChat

 {

 	return activeChat;

 }

 /*!

  * @brief Set the active chat window

  */

 - (void)setActiveChat:(AIChat *)inChat

 {

 	[interfacePlugin setActiveChat:inChat];

 }

 /*!

  * @returns Last chat to be active, nil if not chat is open

  */

 - (AIChat *)mostRecentActiveChat

 {

 	return mostRecentActiveChat;

 }

 /*!

  * @brief Sets active chat window based on chat

  */

 - (void)setMostRecentActiveChat:(AIChat *)inChat

 {

 	[self setActiveChat:inChat];

 }

 /*!

  * @returns Array of open chats (cached, so call as frequently as desired)

  */

 - (NSArray *)openChats

 {

 	if (!_cachedOpenChats) {

 		_cachedOpenChats = [[interfacePlugin openChats] retain];

 	}

 	return _cachedOpenChats;

 }

 - (NSArray *)openContainerIDs

 {

 	return [interfacePlugin openContainerIDs];

 }

 /*!

  * @param containerID ID for chat window

  *

  * @returns Array of all chats in chat window

  */

 - (NSArray *)openChatsInContainerWithID:(NSString *)containerID

 {

 	return [interfacePlugin openChatsInContainerWithID:containerID];

 }

 /*!

  * @brief Resets the cache of open chats

  */

 - (void)_resetOpenChatsCache

 {

 	[_cachedOpenChats release]; _cachedOpenChats = nil;

 }

 //Interface plugin callbacks -------------------------------------------------------------------------------------------

 //These methods are called by the interface to let us know what's going on.  We're informed of chats opening, closing,

 //changing order, etc.

 #pragma mark Interface plugin callbacks

 /*!

  * @brief A chat window did open: rebuild our window menu to show the new chat

  *

  * This should be called by the interface plugin (e.g. AIDualWindowInterfacePlugin) after a chat opens

  *

  * @param inChat Newly created chat 

  */

 - (void)chatDidOpen:(AIChat *)inChat

 {

 	[self _resetOpenChatsCache];

 	[self buildWindowMenu];

 	[self saveContainers];

 }

 /*!

  * @brief A chat has become active: update our chat closing keys and flag this chat as selected in the window menu

  *

  * @param inChat Chat which has become active

  */

 - (void)chatDidBecomeActive:(AIChat *)inChat

 {

 	AIChat	*previouslyActiveChat = activeChat;

 	activeChat = [inChat retain];

 	[self updateCloseMenuKeys];

 	[self updateActiveWindowMenuItem];

 	if (inChat && (inChat != mostRecentActiveChat)) {

 		[mostRecentActiveChat release]; mostRecentActiveChat = nil;

 		mostRecentActiveChat = [inChat retain];

 	}

 	[[NSNotificationCenter defaultCenter] postNotificationName:Chat_BecameActive

 											  object:inChat 

 											userInfo:(previouslyActiveChat ?

 													  [NSDictionary dictionaryWithObject:previouslyActiveChat

 																				  forKey:@"PreviouslyActiveChat"] :

 													  nil)];

 	if (inChat) {

 		/* Clear the unviewed content on the next event loop so other methods have a chance to react to the chat becoming

 		* active. Specifically, this lets the handleReopenWithVisibleWindows: method have a chance to know that this chat

 		* had unviewed content.

 		*/

 		[inChat performSelector:@selector(clearUnviewedContentCount)

 					 withObject:nil

 					 afterDelay:0];

 	}

 	[previouslyActiveChat release];	

 }

 /*!

  * @brief A chat has become visible: send out a notification for components and plugins to take action

  *

  * @param inChat Chat that has become active

  * @param nWindow Containing chat window

  */

 - (void)chatDidBecomeVisible:(AIChat *)inChat inWindow:(NSWindow *)inWindow

 {

 	[[NSNotificationCenter defaultCenter] postNotificationName:@"AIChatDidBecomeVisible"

 											  object:inChat

 											userInfo:[NSDictionary dictionaryWithObject:inWindow

 																				 forKey:@"NSWindow"]];

 }

 /*!

  * @brief Find the window currently displaying a chat

  *

  * @returns Window for chat otherwise if the chat is not in any window, or is not visible in any window, returns nil

  */

 - (NSWindow *)windowForChat:(AIChat *)inChat

 {

 	return [interfacePlugin windowForChat:inChat];

 }

 /*!

  * @brief Find the chat active in a window

  *

  * If the window does not have an active chat, nil is returned

  */

 - (AIChat *)activeChatInWindow:(NSWindow *)window

 {

 	return [interfacePlugin activeChatInWindow:window];

 }

 /*!

  * @brief A chat window did close: rebuild our window menu to remove the chat

  * 

  * @param inChat Chat that closed

  */

 - (void)chatDidClose:(AIChat *)inChat

 {

 	[self _resetOpenChatsCache];

 	[inChat clearUnviewedContentCount];

 	[self buildWindowMenu];

 	if (!adium.isQuitting) {

 		// Don't save containers when the chats are closed while quitting

 		[self saveContainers];

 	}

 	if (inChat == activeChat) {

 		[activeChat release]; activeChat = nil;

 	}

 	if (inChat == mostRecentActiveChat) {

 		[mostRecentActiveChat release]; mostRecentActiveChat = nil;

 	}

 }

 /*!

  * @brief The order of chats has changed: rebuild our window menu to reflect the new order

  */

 - (void)chatOrderDidChange

 {

 	[self _resetOpenChatsCache];

 	[self buildWindowMenu];

 	if (!adium.isQuitting) {

 		// Don't save containers when the chats are closed while quitting

 		[self saveContainers];

 	}

 	[[NSNotificationCenter defaultCenter] postNotificationName:Chat_OrderDidChange object:nil userInfo:nil];

 }

 #pragma mark Unviewed content

 /*!

  * @breif Content was received, increase the unviewed content count of the chat (if it's not currently active)

  */

 - (void)didReceiveContent:(NSNotification *)notification

 {

 	AIChat		*chat = [[notification userInfo] objectForKey:@"AIChat"];

 	if (chat != activeChat) {

 		[chat incrementUnviewedContentCount];

 	}

 }

 //Chat close menus -----------------------------------------------------------------------------------------------------

 #pragma mark Chat close menus

 /*!

  * @brief Closes currently active window

  */

 - (IBAction)closeMenu:(id)sender

 {

     [[[NSApplication sharedApplication] keyWindow] performClose:nil];

 }

 /*!

  * @brief Closes currently active chat (if there is an active chat)

  */

 - (IBAction)closeChatMenu:(id)sender

 {

 	if (activeChat) [self closeChat:activeChat];

 }

 /*!

  * @brief Closes currently selected chat based on current chat contextual menu

  */

 - (IBAction)closeContextualChat:(id)sender

 {

 	[self closeChat:[adium.menuController currentContextMenuChat]];

 }

 /*!

  * @brief Loop through open chats and close them

  */

 - (IBAction)closeAllChats:(id)sender

 {

 	for (AIChat *chatToClose in [[interfacePlugin.openChats copy] autorelease]) {

 		[self closeChat:chatToClose];

 	}

 }

 /*!

  * @brief Updates the key equivalents on 'close' and 'close chat' (dynamically changed to make cmd-w less destructive)

  */

 - (void)updateCloseMenuKeys

 {

 	if (activeChat && !closeMenuConfiguredForChat) {

         [menuItem_close setKeyEquivalent:@"W"];