//

 //  AILogViewerWindowController.m

 //  Adium

 //

 //  Created by Evan Schoenberg on 3/24/06.

 //

 #import "AILogViewerWindowController.h"

 #import "AIChatLog.h"

 #import "AILogFromGroup.h"

 #import "AILogToGroup.h"

 #import "AILoggerPlugin.h"

 #import "ESRankingCell.h" 

 #import "AIXMLChatlogConverter.h"

 #import "AILogDateFormatter.h"

 #import <Adium/AIAccountControllerProtocol.h>

 #import <Adium/AIChatControllerProtocol.h>

 #import <Adium/AIContactControllerProtocol.h>

 #import <Adium/AIContentControllerProtocol.h>

 #import <Adium/AIMenuControllerProtocol.h>

 #import <Adium/AIHTMLDecoder.h>

 #import <Adium/AIInterfaceControllerProtocol.h>

 #import <Adium/AIListContact.h>

 #import <Adium/AIMetaContact.h>

 #import <Adium/AIService.h>

 #import <Adium/AIServiceIcons.h>

 #import <Adium/AIUserIcons.h>

 #import <Adium/KNShelfSplitView.h>

 #import <AIUtilities/AIArrayAdditions.h>

 #import <AIUtilities/AIAttributedStringAdditions.h>

 #import <AIUtilities/AIDateFormatterAdditions.h>

 #import <AIUtilities/AIFileManagerAdditions.h>

 #import <AIUtilities/AIImageAdditions.h>

 #import <AIUtilities/AIImageTextCell.h>

 #import <AIUtilities/AIOutlineViewAdditions.h>

 #import <AIUtilities/AISplitView.h>

 #import <AIUtilities/AIStringAdditions.h>

 #import <AIUtilities/AITableViewAdditions.h>

 #import <AIUtilities/AITextAttributes.h>

 #import <AIUtilities/AIToolbarUtilities.h>

 #import <AIUtilities/AIApplicationAdditions.h>

 #import <AIUtilities/AIDividedAlternatingRowOutlineView.h>

 #define KEY_LOG_VIEWER_WINDOW_FRAME		@"Log Viewer Frame"

 #define KEY_LOG_VIEWER_GROUP_STATE		@"Log Viewer Group State"	//Expand/Collapse state of groups

 #define TOOLBAR_LOG_VIEWER				@"Log Viewer Toolbar"

 #define MAX_LOGS_TO_SORT_WHILE_SEARCHING	10000	//Max number of logs we will live sort while searching

 #define LOG_SEARCH_STATUS_INTERVAL			20	//1/60ths of a second to wait before refreshing search status

 #define SEARCH_MENU						AILocalizedString(@"Search Menu",nil)

 #define FROM							AILocalizedString(@"From",nil)

 #define TO								AILocalizedString(@"To",nil)

 #define DATE							AILocalizedString(@"Date",nil)

 #define CONTENT							AILocalizedString(@"Content",nil)

 #define DELETE							AILocalizedString(@"Delete",nil)

 #define DELETEALL						AILocalizedString(@"Delete All",nil)

 #define SEARCH							AILocalizedString(@"Search",nil)

 #define HIDE_EMOTICONS					AILocalizedString(@"Hide Emoticons",nil)

 #define SHOW_EMOTICONS					AILocalizedString(@"Show Emoticons",nil)

 #define HIDE_TIMESTAMPS					AILocalizedString(@"Hide Timestamps",nil)

 #define SHOW_TIMESTAMPS					AILocalizedString(@"Show Timestamps",nil)

 #define IMAGE_EMOTICONS_OFF				@"emoticon32"

 #define IMAGE_EMOTICONS_ON				@"emoticon32_transparent"

 #define IMAGE_TIMESTAMPS_OFF			@"timestamp32"

 #define IMAGE_TIMESTAMPS_ON				@"timestamp32_transparent"

 #define	REFRESH_RESULTS_INTERVAL		1.0 //Interval between results refreshes while searching

 @interface AILogViewerWindowController ()

 - (id)initWithWindowNibName:(NSString *)windowNibName plugin:(id)inPlugin;

 - (void)initLogFiltering;

 - (void)displayLog:(AIChatLog *)log;

 - (void)hilightOccurrencesOfString:(NSString *)littleString inString:(NSMutableAttributedString *)bigString firstOccurrence:(NSRange *)outRange;

 - (void)sortCurrentSearchResultsForTableColumn:(NSTableColumn *)tableColumn direction:(BOOL)direction;

 - (void)startSearchingClearingCurrentResults:(BOOL)clearCurrentResults;

 - (void)buildSearchMenu;

 - (NSMenuItem *)_menuItemWithTitle:(NSString *)title forSearchMode:(LogSearchMode)mode;

 - (void)_logFilter:(NSString *)searchString searchID:(NSInteger)searchID mode:(LogSearchMode)mode;

 - (void)installToolbar;

 - (void)updateRankColumnVisibility;

 - (void)openLogAtPath:(NSString *)inPath;

 - (void)rebuildContactsList;

 - (void)filterForContact:(AIListContact *)inContact;

 - (void)filterForChatName:(NSString *)chatName withAccount:(AIAccount *)account;

 - (void)selectCachedIndex;

 - (void)tableViewSelectionDidChangeDelayed;

 - (NSAlert *)alertForDeletionOfLogCount:(NSUInteger)logCount;

 - (void)_willOpenForContact;

 - (void)_didOpenForContact;

 - (void)deleteSelection:(id)sender;

 @end

 @implementation AILogViewerWindowController

 static AILogViewerWindowController	*sharedLogViewerInstance = nil;

 static NSInteger toArraySort(id itemA, id itemB, void *context);

 + (NSString *)nibName

 {

 	return @"LogViewer";	

 }

 + (id)openForPlugin:(id)inPlugin

 {

     if (!sharedLogViewerInstance) {

 		sharedLogViewerInstance = [[self alloc] initWithWindowNibName:[self nibName] plugin:inPlugin];

 	}

     [sharedLogViewerInstance showWindow:nil];

 	return sharedLogViewerInstance;

 }

 + (id)openLogAtPath:(NSString *)inPath plugin:(id)inPlugin

 {

 	[self openForPlugin:inPlugin];

 	[sharedLogViewerInstance openLogAtPath:inPath];

 	return sharedLogViewerInstance;

 }

 //Open the log viewer window to a specific contact's logs

 + (id)openForContact:(AIListContact *)inContact plugin:(id)inPlugin

 {

     if (!sharedLogViewerInstance) {

 		sharedLogViewerInstance = [[self alloc] initWithWindowNibName:[self nibName] plugin:inPlugin];

 	}

 	[sharedLogViewerInstance _willOpenForContact];

 	[sharedLogViewerInstance showWindow:nil];

 	[sharedLogViewerInstance filterForContact:inContact];

 	[sharedLogViewerInstance _didOpenForContact];

     return sharedLogViewerInstance;

 }

 + (id)openForChatName:(NSString *)inChatName withAccount:(AIAccount *)inAccount plugin:(id)inPlugin

 {

 	if (!sharedLogViewerInstance) {

 		sharedLogViewerInstance = [[self alloc] initWithWindowNibName:[self nibName] plugin:inPlugin];

 	}

 	[sharedLogViewerInstance _willOpenForContact];

 	[sharedLogViewerInstance showWindow:nil];

 	[sharedLogViewerInstance filterForChatName:inChatName withAccount:inAccount];

 	[sharedLogViewerInstance _didOpenForContact];

     return sharedLogViewerInstance;

 }

 //Returns the window controller if one exists

 + (id)existingWindowController

 {

     return sharedLogViewerInstance;

 }

 //Close the log viewer window

 + (void)closeSharedInstance

 {

     if (sharedLogViewerInstance) {

         [sharedLogViewerInstance closeWindow:nil];

     }

 }

 //init

 - (id)initWithWindowNibName:(NSString *)windowNibName plugin:(id)inPlugin

 {

 	if((self = [super initWithWindowNibName:windowNibName])) {

 		plugin = inPlugin;

 		selectedColumn = nil;

 		activeSearchID = 0;

 		searching = NO;

 		automaticSearch = YES;

 		showEmoticons = NO;

 		showTimestamps = YES;

 		activeSearchString = nil;

 		displayedLogArray = nil;

 		windowIsClosing = NO;

 		desiredContactsSourceListDeltaX = 0;

 		blankImage = [[NSImage alloc] initWithSize:NSMakeSize(16,16)];

 		sortDirection = YES;

 		searchMode = LOG_SEARCH_CONTENT;

 		headerDateFormatter = [[NSDateFormatter localizedDateFormatter] retain];

 		currentSearchResults = [[NSMutableArray alloc] init];

 		fromArray = [[NSMutableArray alloc] init];

 		fromServiceArray = [[NSMutableArray alloc] init];

 		logFromGroupDict = [[NSMutableDictionary alloc] init];

 		toArray = [[NSMutableArray alloc] init];

 		toServiceArray = [[NSMutableArray alloc] init];

 		logToGroupDict = [[NSMutableDictionary alloc] init];

 		resultsLock = [[NSRecursiveLock alloc] init];

 		searchingLock = [[NSLock alloc] init];

 		[searchingLock setName:@"LogSearchingLock"];

 		contactIDsToFilter = [[NSMutableSet alloc] initWithCapacity:1];

 		allContactsIdentifier = [[NSNumber numberWithInteger:-1] retain];

 		undoManager = [[NSUndoManager alloc] init];

 		currentSearchLock = [[NSLock alloc] init];

 		[currentSearchLock setName:@"CurrentLogSearchLock"];

 	}

 	return self;

 }

 //dealloc

 - (void)dealloc

 {

 	[filterDate release]; filterDate = nil;

 	[currentSearchLock release]; currentSearchLock = nil;

 	[resultsLock release];

 	[searchingLock release];

 	[fromArray release];

 	[fromServiceArray release];

 	[toArray release];

 	[toServiceArray release];

 	[currentSearchResults release];

 	[selectedColumn release];

 	[headerDateFormatter release];

 	[displayedLogArray release];

 	[blankImage release];

 	[activeSearchString release];

 	[contactIDsToFilter release];

 	[logFromGroupDict release]; logFromGroupDict = nil;

 	[logToGroupDict release]; logToGroupDict = nil;

 	[filterForAccountName release]; filterForAccountName = nil;

 	[horizontalRule release]; horizontalRule = nil;

 	[adiumIcon release]; adiumIcon = nil;

 	[adiumIconHighlighted release]; adiumIconHighlighted = nil;

 	//We loaded	view_DatePicker from a nib manually, so we must release it

 	[view_DatePicker release]; view_DatePicker = nil;

 	[allContactsIdentifier release];

 	[undoManager release]; undoManager = nil;

 	[super dealloc];

 }

 //Init our log filtering tree

 - (void)initLogFiltering

 {

     NSMutableDictionary		*toDict = [NSMutableDictionary dictionary];

     NSString				*basePath = [AILoggerPlugin logBasePath];

     NSString				*fromUID, *serviceClass;

     //Process each account folder (/Logs/SERVICE.ACCOUNT_NAME/) - sorting by compare: will result in an ordered list

 	//first by service, then by account name.

     for (NSString *folderName in [[[NSFileManager defaultManager] contentsOfDirectoryAtPath:basePath error:NULL] sortedArrayUsingSelector:@selector(compare:)]) {

 		if (![folderName isEqualToString:@".DS_Store"]) { // avoid the directory info

 			AILogFromGroup  *logFromGroup;

 			NSMutableSet	*toSetForThisService;

 			NSArray         *serviceAndFromUIDArray;

 			/* Determine the service and fromUID - should be SERVICE.ACCOUNT_NAME

 			 * Check against count to guard in case of old, malformed or otherwise odd folders & whatnot sitting in log base

 			 */

 			serviceAndFromUIDArray = [folderName componentsSeparatedByString:@"."];

 			if ([serviceAndFromUIDArray count] >= 2) {

 				serviceClass = [serviceAndFromUIDArray objectAtIndex:0];

 				//Use substringFromIndex so we include the rest of the string in the case of a UID with a . in it

 				fromUID = [folderName substringFromIndex:([serviceClass length] + 1)]; //One off for the '.'

 			} else {

 				//Fallback: blank non-nil serviceClass; folderName as the fromUID

 				serviceClass = @"";

 				fromUID = folderName;

 			}

 			logFromGroup = [[AILogFromGroup alloc] initWithPath:folderName fromUID:fromUID serviceClass:serviceClass];

 			//Store logFromGroup on a key in the form "SERVICE.ACCOUNT_NAME"

 			[logFromGroupDict setObject:logFromGroup forKey:folderName];

 			//To processing

 			if (!(toSetForThisService = [toDict objectForKey:serviceClass])) {

 				toSetForThisService = [NSMutableSet set];

 				[toDict setObject:toSetForThisService

 						   forKey:serviceClass];

 			}

 			//Add the 'to' for each grouping on this account

 			for (AILogToGroup *currentToGroup in [logFromGroup toGroupArray]) {

 				NSString	*currentTo;

 				if ((currentTo = [currentToGroup to])) {

 					//Store currentToGroup on a key in the form "SERVICE.ACCOUNT_NAME/TARGET_CONTACT"

 					[logToGroupDict setObject:currentToGroup forKey:[currentToGroup relativePath]];

 				}

 			}

 			[logFromGroup release];

 		}

 	}

 	[self rebuildContactsList];

 }

 - (void)rebuildContactsList

 {

 	NSInteger	oldCount = toArray.count;

 	[toArray release]; toArray = [[NSMutableArray alloc] initWithCapacity:(oldCount ? oldCount : 20)];

 	for (AILogFromGroup *logFromGroup in [logFromGroupDict objectEnumerator]) {

 		//Add the 'to' for each grouping on this account

 		for (AILogToGroup *currentToGroup in [logFromGroup toGroupArray]) {

 			NSString	*currentTo;

 			if ((currentTo = [currentToGroup to])) {

 				NSString *serviceClass = [currentToGroup serviceClass];

 				AIListObject *listObject = ((serviceClass && currentTo) ?

 											[adium.contactController existingListObjectWithUniqueID:[AIListObject internalObjectIDForServiceID:serviceClass

 																																			 UID:currentTo]] :

 											nil);

 				if (listObject && [listObject isKindOfClass:[AIListContact class]]) {

 					AIListContact *parentContact = [(AIListContact *)listObject parentContact];

 					if (![toArray containsObjectIdenticalTo:parentContact]) {

 						[toArray addObject:parentContact];

 					}

 				} else {

 					if (![toArray containsObject:currentToGroup]) {

 						[toArray addObject:currentToGroup];

 					}

 				}

 			}

 		}		

 	}

 	[toArray sortUsingFunction:toArraySort context:NULL];

 	[outlineView_contacts reloadData];

 	if (!isOpeningForContact) {

 		//If we're opening for a contact, the outline view selection will be changed in a moment anyways

 		[self outlineViewSelectionDidChange:nil];

 	}

 }

 - (NSString *)adiumFrameAutosaveName

 {

 	return KEY_LOG_VIEWER_WINDOW_FRAME;

 }

 //Setup the window before it is displayed

 - (void)windowDidLoad

 {

 	suppressSearchRequests = YES;

 	[super windowDidLoad];

 	[plugin pauseIndexing];

 	[[self window] setTitle:AILocalizedString(@"Chat Transcript Viewer",nil)];

     [textField_progress setStringValue:@""];

 	//Autosave doesn't do anything yet

 	[shelf_splitView setAutosaveName:@"LogViewer:Shelf"];

 	[shelf_splitView setFrame:[[[self window] contentView] frame]];

 	// Pull our main article/display split view out of the nib and position it in the shelf view

 	[containingView_results retain];

 	[containingView_results removeFromSuperview];

 	[shelf_splitView setContentView:containingView_results];

 	[containingView_results release];

 	[tableView_results accessibilitySetOverrideValue:AILocalizedString(@"Transcripts", nil)

 										forAttribute:NSAccessibilityRoleDescriptionAttribute];

 	// Pull our source view out of the nib and position it in the shelf view

 	[containingView_contactsSourceList retain];

 	[containingView_contactsSourceList removeFromSuperview];

 	[shelf_splitView setShelfView:containingView_contactsSourceList];

 	[outlineView_contacts accessibilitySetOverrideValue:AILocalizedString(@"Contacts", nil)

 										forAttribute:NSAccessibilityRoleDescriptionAttribute];

 	[containingView_contactsSourceList release];

 	//Set emoticon filtering

 	showEmoticons = [[adium.preferenceController preferenceForKey:KEY_LOG_VIEWER_EMOTICONS

 															  group:PREF_GROUP_LOGGING] boolValue];

 	[[toolbarItems objectForKey:@"toggleemoticons"] setLabel:(showEmoticons ? HIDE_EMOTICONS : SHOW_EMOTICONS)];

 	[[toolbarItems objectForKey:@"toggleemoticons"] setImage:[NSImage imageNamed:(showEmoticons ? IMAGE_EMOTICONS_ON : IMAGE_EMOTICONS_OFF) forClass:[self class]]];

 	// Set timestamp filtering

 	showTimestamps = [[adium.preferenceController preferenceForKey:KEY_LOG_VIEWER_TIMESTAMPS

 															   group:PREF_GROUP_LOGGING] boolValue];

 	[[toolbarItems objectForKey:@"toggletimestamps"] setLabel:(showTimestamps ? HIDE_TIMESTAMPS : SHOW_TIMESTAMPS)];

 	[[toolbarItems objectForKey:@"toggletimestamps"] setImage:[NSImage imageNamed:(showTimestamps ? IMAGE_TIMESTAMPS_ON : IMAGE_TIMESTAMPS_OFF) forClass:[self class]]];

 	//Toolbar

 	[self installToolbar];	

 	[outlineView_contacts setSelectionHighlightStyle:NSTableViewSelectionHighlightStyleSourceList];

 	AIImageTextCell	*dataCell = [[AIImageTextCell alloc] init];

 	NSTableColumn	*tableColumn = [[outlineView_contacts tableColumns] objectAtIndex:0];

 	[tableColumn setDataCell:dataCell];

 	[tableColumn setEditable:NO];

 	[dataCell setFont:[NSFont systemFontOfSize:[NSFont smallSystemFontSize]]];

 	[dataCell release];

 	// Set the selector for doubleAction

 	[outlineView_contacts setDoubleAction:@selector(openChatOnDoubleAction:)];

 	//Localize tableView_results column headers

 	[[[tableView_results tableColumnWithIdentifier:@"To"] headerCell] setStringValue:TO];

 	[[[tableView_results tableColumnWithIdentifier:@"From"] headerCell] setStringValue:FROM];

 	[[[tableView_results tableColumnWithIdentifier:@"Date"] headerCell] setStringValue:DATE];

 	[self tableViewColumnDidResize:nil];

 	[tableView_results sizeLastColumnToFit];

 	//Prepare the search controls

 	[self buildSearchMenu];

 	if ([textView_content respondsToSelector:@selector(setUsesFindPanel:)]) {

 		[textView_content setUsesFindPanel:YES];

 	}

     //Sort by preference, defaulting to sorting by date

 	NSString	*selectedTableColumnPref;

 	if ((selectedTableColumnPref = [adium.preferenceController preferenceForKey:KEY_LOG_VIEWER_SELECTED_COLUMN

 																		   group:PREF_GROUP_LOGGING])) {

 		selectedColumn = [[tableView_results tableColumnWithIdentifier:selectedTableColumnPref] retain];

 	}

 	if (!selectedColumn) {

 		selectedColumn = [[tableView_results tableColumnWithIdentifier:@"Date"] retain];

 	}

 	[self sortCurrentSearchResultsForTableColumn:selectedColumn direction:YES];

     //Prepare indexing and filter searching

 	[plugin prepareLogContentSearching];

     [self initLogFiltering];

     //Begin our initial search

 	if (!isOpeningForContact)

 		[self setSearchMode:LOG_SEARCH_TO];

     [searchField_logs setStringValue:(activeSearchString ? activeSearchString : @"")];

 	suppressSearchRequests = NO;

 	if (!isOpeningForContact) {

 		//If we're opening for a contact, we'll select it and then begin searching

 		[self startSearchingClearingCurrentResults:YES];

 	}

 	[tableView_results setAutosaveName:@"LogViewerResults"];

 	[tableView_results setAutosaveTableColumns:YES];

 	[plugin resumeIndexing];

 }

 -(void)rebuildIndices

 {

     //Rebuild the 'global' log indexes

     [logFromGroupDict release]; logFromGroupDict = [[NSMutableDictionary alloc] init];

     [toArray removeAllObjects]; //note: even if there are no logs, the name will remain [bug or feature?]

     [toServiceArray removeAllObjects];

     [fromArray removeAllObjects];

     [fromServiceArray removeAllObjects];

     [self initLogFiltering];

     [tableView_results reloadData];

     [self selectDisplayedLog];

 }

 //Called as the window closes

 - (void)windowWillClose:(id)sender

 {

 	[super windowWillClose:sender];

 	//Set preference for emoticon filtering

 	[adium.preferenceController setPreference:[NSNumber numberWithBool:showEmoticons]

 										 forKey:KEY_LOG_VIEWER_EMOTICONS

 										  group:PREF_GROUP_LOGGING];

 	// Set preference for timestamp filtering

 	[adium.preferenceController setPreference:[NSNumber numberWithBool:showTimestamps]

 																			 forKey:KEY_LOG_VIEWER_TIMESTAMPS

 																				group:PREF_GROUP_LOGGING];

 	//Set preference for selected column

 	[adium.preferenceController setPreference:[selectedColumn identifier]

 										 forKey:KEY_LOG_VIEWER_SELECTED_COLUMN

 										  group:PREF_GROUP_LOGGING];

     /* Disable the search field.  If we don't disable the search field, it will often try to call its target action

      * after the window has closed (and we are gone).  I'm not sure why this happens, but disabling the field

      * before we close the window down seems to prevent the crash.

 	 */

     [searchField_logs setEnabled:NO];

 	/* Note that the window is closing so we don't take behaviors which could cause messages to the window after

 	 * it was gone, like responding to a logIndexUpdated message

 	 */

 	windowIsClosing = YES;

     //Abort any in-progress searching and indexing, and wait for their completion

     [self stopSearching];

     [plugin cleanUpLogContentSearching];

 	//Reset our column widths if needed

 	[activeSearchString release]; activeSearchString = nil;

 	[self updateRankColumnVisibility];

 	[sharedLogViewerInstance autorelease]; sharedLogViewerInstance = nil;

 	[toolbarItems autorelease]; toolbarItems = nil;

 }

 //Display --------------------------------------------------------------------------------------------------------------

 #pragma mark Display

 //Update log viewer progress string to reflect current status

 - (void)updateProgressDisplay

 {

     NSMutableString     *progress = nil;

     NSUInteger					indexNumber, indexTotal;

     BOOL				indexing;

     //We always convey the number of logs being displayed

     [resultsLock lock];

 	NSUInteger count = [currentSearchResults count];

     if (activeSearchString && [activeSearchString length]) {

 		[shelf_splitView setResizeThumbStringValue:[NSString stringWithFormat:((count != 1) ? 

 																			   AILocalizedString(@"%lu matching transcripts",nil) :

 																			   AILocalizedString(@"1 matching transcript",nil)),count]];

     } else {

 		[shelf_splitView setResizeThumbStringValue:[NSString stringWithFormat:((count != 1) ? 

 																			   AILocalizedString(@"%lu transcripts",nil) :

 																			   AILocalizedString(@"1 transcript",nil)),count]];

 		//We are searching, but there is no active search  string. This indicates we're still opening logs.

 		if (searching) {

 			progress = [[AILocalizedString(@"Opening transcripts",nil) mutableCopy] autorelease];			

 		}

     }

     [resultsLock unlock];

 	indexing = [plugin getIndexingProgress:&indexNumber outOf:&indexTotal];

     //Append search progress

     if (activeSearchString && [activeSearchString length]) {

 		if (progress) {

 			[progress appendString:@" - "];

 		} else {

 			progress = [NSMutableString string];

 		}

 		if (searching || indexing) {

 			[progress appendString:[NSString stringWithFormat:AILocalizedString(@"Searching for '%@'",nil),activeSearchString]];

 		} else {

 			[progress appendString:[NSString stringWithFormat:AILocalizedString(@"Search for '%@' complete.",nil),activeSearchString]];			

 		}

 	}

     //Append indexing progress

     if (indexing) {

 		if (progress) {

 			[progress appendString:@" - "];

 		} else {

 			progress = [NSMutableString string];

 		}

 		[progress appendString:[NSString stringWithFormat:AILocalizedString(@"Indexing %lu of %lu transcripts",nil), indexNumber, indexTotal]];

     }

 	if (progress && (searching || indexing || !(activeSearchString && [activeSearchString length]))) {

 		[progress appendString:[NSString ellipsis]];	

 	}

     //Enable/disable the searching animation

     if (searching || indexing) {

 		[progressIndicator startAnimation:nil];

     } else {

 		[progressIndicator stopAnimation:nil];

     }

     [textField_progress setStringValue:(progress ? progress : @"")];

 }

 //The plugin is informing us that the log indexing changed

 - (void)logIndexingProgressUpdate

 {

 	//Don't do anything if the window is already closing

 	if (!windowIsClosing) {

 		[self updateProgressDisplay];

 		//If we are searching by content, we should re-search without clearing our current results so the

 		//the newly-indexed logs can be added without blanking the current table contents.

 		if (searchMode == LOG_SEARCH_CONTENT && (activeSearchString && [activeSearchString length])) {

 			if (searching) {

 				//We're already searching; reattempt when done

 				searchIDToReattemptWhenComplete = activeSearchID;

 			} else {

 				//We're not searching - restart the search immediately every 10 updates to utilize the newly indexed logs

 				indexingUpdatesReceivedWhileSearching++;

 				if ((indexingUpdatesReceivedWhileSearching % 10) == 0)

 					[self startSearchingClearingCurrentResults:NO];

 			}

 		}

 	}

 }

 //Refresh the results table

 - (void)refreshResults

 {

 	[self updateProgressDisplay];

 	[self refreshResultsSearchIsComplete:NO];

 }

 - (void)refreshResultsSearchIsComplete:(BOOL)searchIsComplete

 {

     [resultsLock lock];

     NSInteger count = [currentSearchResults count];

     [resultsLock unlock];

 	AILog(@"refreshResultsSearchIsComplete: %i (count is %i)",searchIsComplete,count);

 	if (searchIsComplete &&

 		((activeSearchID == searchIDToReattemptWhenComplete) && !windowIsClosing)) {

 		searchIDToReattemptWhenComplete = -1;

 		[self startSearchingClearingCurrentResults:NO];

 	}

     if (!searching || count <= MAX_LOGS_TO_SORT_WHILE_SEARCHING) {

 		//Sort the logs correctly which will also reload the table

 		[self resortLogs];

 		if (searchIsComplete && automaticSearch) {

 			//If search is complete, select the first log if requested and possible

 			[self selectFirstLog];

 		} else {

 			BOOL oldAutomaticSearch = automaticSearch;

 			//We don't want the above re-selection to change our automaticSearch tracking

 			//(The only reason automaticSearch should change is in response to user action)

 			automaticSearch = oldAutomaticSearch;

 		}

     }

 	if(deleteOccurred)

 		[self selectCachedIndex];

     //Update status

     [self updateProgressDisplay];

 }

 - (void)searchComplete

 {

 	[refreshResultsTimer invalidate]; [refreshResultsTimer release]; refreshResultsTimer = nil;

 	[self refreshResultsSearchIsComplete:YES];

 }

 // Called on doubleAction to open a chat

 -(void)openChatOnDoubleAction:(id)sender

 {

 	id item = [outlineView_contacts firstSelectedItem];

 	if ([item isKindOfClass:[AIListContact class]]) {

 		//Open a new message with the contact

 		[adium.interfaceController setActiveChat:[adium.chatController openChatWithContact:(AIListContact *)item onPreferredAccount:YES]];

 	}

 }

 //Displays the contents of the specified log in our window

 - (void)displayLogs:(NSArray *)logArray;

 {	

     NSMutableAttributedString	*displayText = nil;

 	NSAttributedString			*finalDisplayText = nil;

 	NSRange						scrollRange = NSMakeRange(0,0);

 	BOOL						appendedFirstLog = NO;

     if (![logArray isEqualToArray:displayedLogArray]) {

 		[displayedLogArray release];

 		displayedLogArray = [logArray copy];

 	}

 	if ([logArray count] > 1) {

 		displayText = [[NSMutableAttributedString alloc] init];

 	}

 	AIChatLog	 *theLog;

 	NSString	 *logBasePath = [AILoggerPlugin logBasePath];

 	AILog(@"Displaying %@",logArray);

 	for (theLog in logArray) {

 		NSAutoreleasePool *pool = [[NSAutoreleasePool alloc] init];

 		if (displayText) {

 			if (!horizontalRule) {

 				#define HORIZONTAL_BAR			0x2013

 				#define HORIZONTAL_RULE_LENGTH	18

 				const unichar separatorUTF16[HORIZONTAL_RULE_LENGTH] = {

 					HORIZONTAL_BAR, HORIZONTAL_BAR, HORIZONTAL_BAR, HORIZONTAL_BAR, HORIZONTAL_BAR, HORIZONTAL_BAR,

 					HORIZONTAL_BAR, HORIZONTAL_BAR, HORIZONTAL_BAR, HORIZONTAL_BAR, HORIZONTAL_BAR, HORIZONTAL_BAR,

 					HORIZONTAL_BAR, HORIZONTAL_BAR, HORIZONTAL_BAR, HORIZONTAL_BAR, HORIZONTAL_BAR, HORIZONTAL_BAR

 				};

 				horizontalRule = [[NSString alloc] initWithCharacters:separatorUTF16 length:HORIZONTAL_RULE_LENGTH];

 			}	

 			[displayText appendString:[NSString stringWithFormat:@"%@%@\n%@ - %@\n%@\n\n",

 				(appendedFirstLog ? @"\n" : @""),

 				horizontalRule,

 				[headerDateFormatter stringFromDate:[theLog date]],

 				[theLog to],

 				horizontalRule]

 					   withAttributes:[[AITextAttributes textAttributesWithFontFamily:@"Helvetica" traits:NSBoldFontMask size:12] dictionary]];

 		}

 		if ([[theLog relativePath] hasSuffix:@".AdiumHTMLLog"] || [[theLog relativePath] hasSuffix:@".html"] || [[theLog relativePath] hasSuffix:@".html.bak"]) {

 			//HTML log

 			NSURL *logURL = [NSURL fileURLWithPath:[logBasePath stringByAppendingPathComponent:[theLog relativePath]]];

 			NSString *logFileText = [NSString stringWithContentsOfURL:logURL encoding:NSUTF8StringEncoding error:NULL];

 			NSAttributedString *attributedLogFileText = [AIHTMLDecoder decodeHTML:logFileText];

 			if (showEmoticons) {

 				attributedLogFileText = [adium.contentController filterAttributedString:attributedLogFileText

 																		  usingFilterType:AIFilterMessageDisplay

 																				direction:AIFilterOutgoing

 																				  context:nil];						

 			}			

 			if (displayText) {

 				[displayText appendAttributedString:attributedLogFileText];

 			} else {

 				displayText = [attributedLogFileText mutableCopy];

 			}

 		} else if ([[theLog relativePath] hasSuffix:@".chatlog"]){

 			//XML log

 			NSString *logFullPath = [logBasePath stringByAppendingPathComponent:[theLog relativePath]];

 			BOOL isDir;

 			if ([[NSFileManager defaultManager] fileExistsAtPath:logFullPath isDirectory:&isDir]) {

 				/* If we have a chatLog bundle, we want to get the text content for the xml file inside */

 				if (isDir) logFullPath = [logFullPath stringByAppendingPathComponent:

 										 [[[logFullPath lastPathComponent] stringByDeletingPathExtension] stringByAppendingPathExtension:@"xml"]];

 			}

 			NSDictionary *options = [NSDictionary dictionaryWithObjectsAndKeys:

 									 [NSNumber numberWithBool:showTimestamps], @"showTimestamps",

 									 [NSNumber numberWithBool:showEmoticons], @"showEmoticons", 

 									 nil];

 			NSAttributedString *attributedLogFileText = [AIXMLChatlogConverter readFile:logFullPath withOptions:options];

 			if (attributedLogFileText) {

 				if (displayText)

 					[displayText appendAttributedString:attributedLogFileText];

 				else

 					displayText = [attributedLogFileText mutableCopy];

 			}

 		} else {

 			//Fallback: Plain text log

 			NSURL *logURL = [NSURL fileURLWithPath:[logBasePath stringByAppendingPathComponent:[theLog relativePath]]];

 			NSString *logFileText = [NSString stringWithContentsOfURL:logURL encoding:NSUTF8StringEncoding error:NULL];

 			if (logFileText) {

 				AITextAttributes *textAttributes = [AITextAttributes textAttributesWithFontFamily:@"Helvetica" traits:0 size:12];

 				NSAttributedString *attributedLogFileText = [[[NSAttributedString alloc] initWithString:logFileText 

 																							 attributes:[textAttributes dictionary]] autorelease];

 				if (showEmoticons) {

 					attributedLogFileText = [adium.contentController filterAttributedString:attributedLogFileText

 																			  usingFilterType:AIFilterMessageDisplay

 																					direction:AIFilterOutgoing

 																					  context:nil];						

 				}

 				if (displayText) {

 					[displayText appendAttributedString:attributedLogFileText];

 				} else {

 					displayText = [attributedLogFileText mutableCopy];

 				}

 			}

 		}

 		appendedFirstLog = YES;

 		[pool release];

 	}

 	if (displayText && [displayText length]) {

 		//Add pretty formatting to links

 		[displayText addFormattingForLinks];

 		//If we are searching by content, highlight the search results

 		if ((searchMode == LOG_SEARCH_CONTENT) && [activeSearchString length]) {

 			NSString					*searchWord;

 			NSMutableArray				*searchWordsArray = [[activeSearchString componentsSeparatedByString:@" "] mutableCopy];

 			NSScanner					*scanner = [NSScanner scannerWithString:activeSearchString];

 			//Look for an initial quote

 			NSAutoreleasePool *pool = nil;

 			while (![scanner isAtEnd]) {

 				[pool release];

 				pool = [[NSAutoreleasePool alloc] init];

 				[scanner scanUpToString:@"\"" intoString:NULL];

 				//Scan past the quote

 				if (![scanner scanString:@"\"" intoString:NULL]) {

 					[pool release]; pool = nil;

 					continue;

 				}

 				NSString *quotedString;

 				//And a closing one

 				if (![scanner isAtEnd] &&

 					[scanner scanUpToString:@"\"" intoString:&quotedString]) {

 					//Scan past the quote

 					[scanner scanString:@"\"" intoString:NULL];

 					/* If a string within quotes is found, remove the words from the quoted string and add the full string

 					 * to what we'll be highlighting.

 					 *

 					 * We'll use indexOfObject: and removeObjectAtIndex: so we only remove _one_ instance. Otherwise, this string:

 					 * "killer attack ninja kittens" OR ninja

 					 * wouldn't highlight the word ninja by itself.

 					 */

 					NSArray *quotedWords = [quotedString componentsSeparatedByString:@" "];

 					NSInteger quotedWordsCount = [quotedWords count];

 					for (NSInteger i = 0; i < quotedWordsCount; i++) {

 						NSString	*quotedWord = [quotedWords objectAtIndex:i];

 						if (i == 0) {

 							//Originally started with a quote, so put it back on

 							quotedWord = [@"\"" stringByAppendingString:quotedWord];

 						}

 						if (i == quotedWordsCount - 1) {

 							//Originally ended with a quote, so put it back on

 							quotedWord = [quotedWord stringByAppendingString:@"\""];

 						}

 						NSInteger searchWordsIndex = [searchWordsArray indexOfObject:quotedWord];

 						if (searchWordsIndex != NSNotFound) {

 							[searchWordsArray removeObjectAtIndex:searchWordsIndex];

 						} else {

 							NSLog(@"displayLog: Couldn't find %@ in %@", quotedWord, searchWordsArray);

 						}

 					}

 					//Add the full quoted string

 					[searchWordsArray addObject:quotedString];

 				}

 			}

 			BOOL shouldScrollToWord = NO;

 			scrollRange = NSMakeRange([displayText length],0);

 			for (searchWord in searchWordsArray) {

 				NSRange     occurrence;

 				//Check against and/or.  We don't just remove it from the array because then we couldn't check case insensitively.

 				if (([searchWord caseInsensitiveCompare:@"and"] != NSOrderedSame) &&

 					([searchWord caseInsensitiveCompare:@"or"] != NSOrderedSame)) {

 					[self hilightOccurrencesOfString:searchWord inString:displayText firstOccurrence:&occurrence];

 					//We'll want to scroll to the first occurrance of any matching word or words

 					if (occurrence.location < scrollRange.location) {

 						scrollRange = occurrence;

 						shouldScrollToWord = YES;

 					}

 				}

 			}

 			//If we shouldn't be scrolling to a new range, we want to scroll to the top

 			if (!shouldScrollToWord) scrollRange = NSMakeRange(0, 0);

 			[searchWordsArray release];

 		}

 		finalDisplayText = displayText;

 	}

 	if (finalDisplayText) {

 		[[textView_content textStorage] setAttributedString:finalDisplayText];

 		//Set this string and scroll to the top/bottom/occurrence

 		if ((searchMode == LOG_SEARCH_CONTENT) || automaticSearch) {

 			[textView_content scrollRangeToVisible:scrollRange];

 		} else {

 			[textView_content scrollRangeToVisible:NSMakeRange(0,0)];

 		}

 	} else {

 		//No log selected, empty the view

 		[textView_content setString:@""];

 	}

 	[displayText release];

 }

 - (void)displayLog:(AIChatLog *)theLog

 {

 	[self displayLogs:(theLog ? [NSArray arrayWithObject:theLog] : nil)];

 }

 //Reselect the displayed log (Or another log if not possible)

 - (void)selectDisplayedLog

 {

     NSInteger     firstIndex = NSNotFound;

     /* Is the log we had selected still in the table?

 	 * (When performing an automatic search, we ignore the previous selection.  This ensures that we always

      * end up with the newest log selected, even when a search takes multiple passes/refreshes to complete).

 	 */

 	if (!automaticSearch) {

 		[resultsLock lock];

 		[tableView_results selectItemsInArray:displayedLogArray usingSourceArray:currentSearchResults];

 		[resultsLock unlock];

 		firstIndex = [[tableView_results selectedRowIndexes] firstIndex];

 	}

 	if (firstIndex != NSNotFound) {

 		[tableView_results scrollRowToVisible:[[tableView_results selectedRowIndexes] firstIndex]];

     } else {

         if (useSame == YES && sameSelection > 0) {

             [tableView_results selectRowIndexes:[NSIndexSet indexSetWithIndex:sameSelection] byExtendingSelection:NO];

         } else {

             [self selectFirstLog];

         }

     }

     useSame = NO;

 }

 - (void)selectFirstLog