Initial commit.

1 files changed, 1345 insertions, 0 deletions

diff --git a/Liaison/FileTableDelegate.m b/Liaison/FileTableDelegate.m
new file mode 100644
index 0000000..cd8591a
--- /dev/null
+++ b/Liaison/FileTableDelegate.m
@@ -0,0 +1,1345 @@
+#import "FileTableDelegate.h"
+
+#import "InspectorController.h"
+#import "ImageAndTextCell.h"
+#import "LoadPanelController.h"
+#import "NIBConnector.h"
+#import "PluginManager.h"
+
+#include <dirent.h>
+#include <sys/types.h>
+
+// XXX - should use SEL instead of NSString.
+struct SortContext {
+    BOOL ascending;
+    SEL compareMethod, getMethod;
+};
+
+int contextSorter(id file1, id file2, void *someContext)
+{
+    struct SortContext *context;
+    id leftVal, rightVal;
+
+    context = (struct SortContext *)someContext;
+    if (context->ascending) {
+        leftVal = [file1 performSelector: context->getMethod];
+        rightVal = [file2 performSelector: context->getMethod];
+    } else {
+        leftVal = [file2 performSelector: context->getMethod];
+        rightVal = [file1 performSelector: context->getMethod];
+    }
+
+    if (rightVal == nil) {
+        if (leftVal == nil)
+            return 0;
+        else
+            return -1;
+    } else if (leftVal == nil)
+        return 1;
+
+    return (int)[leftVal performSelector: context->compareMethod
+                              withObject: rightVal];
+}
+
+static NSString *
+myLocalizedString(NSString *aString)
+{
+    return NSLocalizedStringFromTable(aString, @"WindowElements", @"");
+}
+
+static void
+logRect(NSString *desc, NSRect aRect)
+{
+    [LiLog logAsDebug: @"%@, (%f, %f, %f, %f)", desc, aRect.origin.x, aRect.origin.y, aRect.size.width, aRect.size.height];
+}
+
+@interface LiFileHandle (GUIStuff)
+- (void)revealInFinder;
+@end
+
+@implementation LiFileStore (BatchPathAdditions)
+- (BOOL)isValidPath: (NSString *)aPath
+{
+    NSString *filename;
+
+    filename = [aPath lastPathComponent];
+    if ([filename hasPrefix: @"."] ||
+        [filename isEqualToString: @"Icon\r"])
+        return NO;
+
+    return YES;
+}
+
+- (BOOL)addURLs: (NSArray *)aURLList toGroup: (NSString *)aGroup
+{
+    NSURL *fileURL;
+    int i, numFiles;
+
+    if ([aURLList count] == 0)
+        return YES;
+
+    numFiles = [aURLList count];
+
+    i = 0;
+    for (fileURL in aURLList) {
+        LiFileHandle *tmpFile;
+
+        NS_DURING
+            tmpFile = [self addURL: fileURL];
+
+            if (aGroup != nil) {
+                [tmpFile addToGroup: aGroup];
+            }
+        NS_HANDLER
+                [LiLog logAsWarning: @"Couldn't add file: %@ - %@", [localException name], [localException reason]];
+        NS_ENDHANDLER
+
+        i++;
+    }
+
+    return YES;
+}
+
+- (NSArray *)makeURLsFromPaths: (NSArray *)aFileList toGroup: (NSString *)aGroup
+{
+    LoadPanelController *loadPanelController;
+    NSMutableArray *myFileList;
+    NSString *path;
+    int i, fileCount;
+
+    loadPanelController = [[NIBConnector connector] loadPanelController];
+    [loadPanelController setStatus: myLocalizedString(@"LiLoadingDirectory")];
+    [loadPanelController setProgress: 100.0];
+    [loadPanelController setIndeterminantProgress: YES];
+    [loadPanelController update];
+    fileCount = [aFileList count];
+    i = 0;
+
+    myFileList = [NSMutableArray array];
+    for (path in aFileList) {
+        if ((i % 10) == 0) {
+            [loadPanelController setPath: [path lastPathComponent]];
+            [loadPanelController update];
+        }
+
+        if ([self isValidPath: path]) {
+            NSFileManager *defaultManager;
+            BOOL isBundle;
+            BOOL isDirectory;
+
+            isDirectory = NO;
+            defaultManager = [NSFileManager defaultManager];
+            [defaultManager fileExistsAtPath: path isDirectory: &isDirectory];
+            if ([path hasSuffix: @".app"] ||
+                [[NSWorkspace sharedWorkspace] isFilePackageAtPath: path])
+                isBundle = YES;
+            else
+                isBundle = NO;
+
+            if (isDirectory && !isBundle) {
+                struct dirent *dirp;
+                DIR *directory;
+                NSAutoreleasePool *rp;
+                NSMutableArray *dirContents;
+                int j;
+
+                [LiLog logAsDebug: @"Recursing into: %@", path];
+                [LiLog indentDebugLog];
+
+                // Let people know we're working in a subdirectory.
+                j = 0;
+
+                dirContents = [[NSMutableArray alloc] init];
+                directory = opendir([path UTF8String]);
+                while ((dirp = readdir(directory)) != NULL) {
+                    NSString *subPath;
+
+                    subPath = [NSString stringWithUTF8String: dirp->d_name];
+                    if ([self isValidPath: subPath] == YES) {
+                        NSString *fullPath;
+
+                        if ((j % 10) == 0) {
+                            [loadPanelController update];
+                        }
+
+                        fullPath = [path stringByAppendingPathComponent: subPath];
+                        [dirContents addObject: fullPath];
+                    }
+                    j++;
+                }
+                closedir(directory);
+
+                rp = [[NSAutoreleasePool alloc] init];
+                [self addURLs: [self makeURLsFromPaths: dirContents toGroup: aGroup]
+                      toGroup: aGroup];
+                [rp release];
+                [dirContents release];
+
+                [LiLog unindentDebugLog];
+            } else {
+                [LiLog logAsDebug: @"Adding %@ to file list", path];
+                [loadPanelController setPath: [path lastPathComponent]];
+                [myFileList addObject: [NSURL fileURLWithPath: path]];
+            }
+        }
+        i++;
+    }
+
+    return myFileList;
+}
+
+- (NSArray *)addPaths: (NSArray *)aPathList toGroup: (NSString *)aGroup
+{
+    if ([aPathList count] > 0) {
+        LoadPanelController *loadPanelController;
+        NSArray *fileList;
+
+        loadPanelController = [[NIBConnector connector] loadPanelController];
+        [loadPanelController show];
+        fileList = [self makeURLsFromPaths: aPathList toGroup: aGroup];
+        [self addURLs: fileList toGroup: aGroup];
+        [loadPanelController hide];
+        [self synchronize];
+    }
+
+    return nil;
+}
+@end
+
+@implementation FileTableDelegate (LiTableViewDelegate)
+- (void)tableViewDidBecomeFirstResponder: (NSTableView *)aTableView
+{
+    [LiLog logAsDebug: @"[FileTableDelegate becameFirstResponder]"];
+    [LiLog indentDebugLog];
+    if ([tableView numberOfSelectedRows] == 1) {
+        LiFileHandle *theRecord;
+
+        theRecord = [self fileAtIndex: [tableView selectedRow]];
+        // Auto-update a clicked file.
+        [theRecord update];
+        [[theRecord fileStore] synchronize];
+        [inspectorController setFile: theRecord];
+    }
+    [LiLog unindentDebugLog];
+}
+
+- (void)deleteSelectedRowsInTableView: (NSTableView *)aTableView
+{
+    NSEnumerator *rowEnum;
+    NSString *myGroup;
+    NSMutableArray *selectedFiles;
+    NSNumber *row;
+
+    rowEnum = [aTableView selectedRowEnumerator];
+    selectedFiles = [NSMutableArray array];
+    while ((row = [rowEnum nextObject]) != nil) {
+        LiFileHandle *record;
+
+        record = [self fileAtIndex: [row intValue]];
+        [selectedFiles addObject: record];
+    }
+
+    [aTableView deselectAll: self];
+
+    myGroup = [self group];
+    if (myGroup == nil) {
+        LiFileHandle *file;
+
+        for (file in selectedFiles) {
+            [[self fileStore] removeFileHandle: file];
+        }
+    } else {
+        LiFileHandle *file;
+
+        for (file in selectedFiles) {
+            [LiLog logAsDebug: @"Removing %@ from %@", [file filename], myGroup];
+            [LiLog logAsDebug: @"old groups: %@", [[file groups] description]];
+            [file removeFromGroup: myGroup];
+            [LiLog logAsDebug: @"new groups: %@", [[file groups] description]];
+        }
+    }
+    [[self fileStore] synchronize];
+}
+@end
+
+@implementation FileTableDelegate (TableViewDataSource)
+- (int)numberOfRowsInTableView:(NSTableView *)aTableView
+{
+    return [[self sortedList] count];
+}
+
+- (id)tableView: (NSTableView *)aTableView
+objectValueForTableColumn: (NSTableColumn *)aTableColumn
+            row: (int)rowIndex
+{
+    LiFileHandle *record;
+    LiBrowserColumn *col;
+
+    col = [self columnForIdentifier: [aTableColumn identifier]];
+    record = [self fileAtIndex: rowIndex];
+    return [col objectForRecord: record];
+}
+
+- (void)tableView:(NSTableView *)aTableView setObjectValue:(id)anObject forTableColumn:(NSTableColumn *)aTableColumn row:(int)rowIndex
+{
+    LiFileHandle *record;
+    LiBrowserColumn *col;
+
+    if (rowIndex < 0 || rowIndex >= (int)[[self sortedList] count])
+        return;
+
+    col = [self columnForIdentifier: [aTableColumn identifier]];
+    record = [self fileAtIndex: rowIndex];
+    [col setObject: anObject forRecord: record];
+
+    [[record fileStore] synchronize];
+}
+
+- (NSDragOperation)tableView: (NSTableView *)aTableView
+                validateDrop: (id <NSDraggingInfo>)sender
+                 proposedRow: (int)index
+       proposedDropOperation: (NSDragOperation)operation;
+{
+    NSDragOperation dragOp;
+
+    dragOp = NSDragOperationNone;
+    if ([sender draggingSource] != tableView &&
+        [[self fileStore] isEditable] == YES) {
+        NSPasteboard *pboard;
+
+        pboard = [sender draggingPasteboard];
+        if ([pboard availableTypeFromArray:
+            [NSArray arrayWithObjects: NSFilenamesPboardType, NSFilesPromisePboardType, nil]]) {
+            [aTableView setDropRow: -1 dropOperation: NSTableViewDropOn];
+            dragOp = NSDragOperationCopy;
+        }
+    }
+
+    return dragOp;
+}
+
+- (BOOL)tableView: (NSTableView *)aTableView
+       acceptDrop: (id <NSDraggingInfo>)aSender
+              row: (int)anIndex
+    dropOperation: (NSTableViewDropOperation)anOperation
+{
+    NSArray *pathList;
+    NSPasteboard *pboard;
+
+    pboard = [aSender draggingPasteboard];
+
+    pathList = nil;
+    if ([pboard availableTypeFromArray:
+        [NSArray arrayWithObject: NSFilenamesPboardType]]) {
+        pathList = [pboard propertyListForType: NSFilenamesPboardType];
+    }
+
+    // Handle promised files.
+    if ([[pboard types] containsObject: NSFilesPromisePboardType]) {
+        NSEnumerator *pathEnum;
+        NSMutableArray *promisedPaths;
+        NSString *path;
+        NSURL *dropLocation;
+
+        dropLocation = [NSURL fileURLWithPath:
+            [[Preferences sharedPreferences] downloadDirectory]];
+        pathEnum = [[aSender namesOfPromisedFilesDroppedAtDestination: dropLocation] objectEnumerator];
+        promisedPaths = [NSMutableArray array];
+        while ((path = [pathEnum nextObject]) != nil) {
+            [promisedPaths addObject: [[dropLocation path] stringByAppendingPathComponent: path]];
+        }
+        pathList = promisedPaths;
+    }
+
+    if ([pathList count] > 0) {
+        [[self fileStore] addPaths: pathList toGroup: [self group]];
+        return YES;
+    }
+
+    // XXX - should select the added songs now.
+
+    return NO;
+
+}
+
+- (BOOL)tableView: (NSTableView *)aTableView
+        writeRows: (NSArray *)someRows
+     toPasteboard: (NSPasteboard *)aPboard
+{
+    NSMutableArray *liaisonPboard, *filenamePboard, *promisePboard;
+    NSMutableArray *typeList;
+    NSNumber *row;
+
+    liaisonPboard = [NSMutableArray array];
+    filenamePboard = [NSMutableArray array];
+    promisePboard = [NSMutableArray array];
+
+    for (row in someRows) {
+        LiFileHandle *file;
+        NSURL *url;
+
+        file = [self fileAtIndex: [row intValue]];
+        [liaisonPboard addObject: file];
+        url = [file url];
+        if ([url isFileURL] == YES) {
+            [filenamePboard addObject: [url path]];
+        }
+    }
+
+    typeList = [NSMutableArray array];
+    if ([liaisonPboard count] > 0)
+        [typeList addObject: LiaisonPboardType];
+    if ([filenamePboard count] > 0)
+        [typeList addObject: NSFilenamesPboardType];
+    // Make an HFS promise.
+
+    if ([typeList count] > 0) {
+        [aPboard declareTypes: typeList owner: self];
+
+        if ([liaisonPboard count] > 0) {
+            NSData *liaisonPboardData;
+
+            liaisonPboardData = [NSKeyedArchiver archivedDataWithRootObject:
+                liaisonPboard];
+            if ([aPboard setData: liaisonPboardData
+                         forType: LiaisonPboardType] == NO)
+                return NO;
+        }
+
+        if ([filenamePboard count] > 0) {
+            if ([aPboard setPropertyList: filenamePboard
+                                 forType: NSFilenamesPboardType] == NO)
+                return NO;
+        }
+        return YES;
+    }
+    return NO;
+}
+@end
+
+@implementation FileTableDelegate (TableViewDelegate)
+- (void)tableView: (NSTableView*)aTableView
+didClickTableColumn: (NSTableColumn *)aTableColumn
+{
+    LiBrowserColumn *col;
+
+    col = [self columnForIdentifier: [aTableColumn identifier]];
+    if ([col compareMethod]) {
+        struct SortContext context;
+
+        if ([self selectedColumn] && [self selectedColumn] == aTableColumn) {
+            if (isAscending)
+                isAscending = NO;
+            else
+                aTableColumn = nil; // XXX, but it works.
+        } else
+            isAscending = YES;
+        
+        context.ascending = isAscending;
+        context.getMethod = [col getMethod];
+        context.compareMethod = [col compareMethod];
+        [self saveSelectionOfTableView: tableView];
+        [self setSelectedColumn: aTableColumn withContext: &context];
+        [self redisplay];
+        [self restoreSelectionToTableView: tableView refresh: YES];
+    }
+}
+
+- (BOOL)tableView: (NSTableView *)theTable shouldSelectRow: (int)theRow
+{
+    if (theRow < 0 || (int)[[self sortedList] count] <= theRow)
+        return NO;
+    return YES;
+}
+
+- (BOOL)tableView: (NSTableView *)aTableView
+shouldEditTableColumn: (NSTableColumn *)aTableColumn
+              row: (int)rowIndex
+{
+    LiFileHandle *record;
+
+    record = [self fileAtIndex: rowIndex];
+    return [record isEditable];
+}
+
+- (void)tableView: (NSTableView *)aTableView
+          copyRow: (int)aRow
+{
+    [LiLog logAsDebug: @"[tableView copyRow]"];
+}
+
+- (void)tableViewSelectionDidChange: (NSNotification *)aNotification
+{
+    [LiLog logAsDebug: @"[FileTableDelegate tableViewSelectionDidChange: (notification)]"];
+    [LiLog indentDebugLog];
+    if ([tableView numberOfSelectedRows] == 1) {
+        LiFileHandle *theRecord;
+
+        theRecord = [self fileAtIndex: [tableView selectedRow]];
+        // Auto-update a clicked file.
+        [theRecord update];
+        [[theRecord fileStore] synchronize];
+        [inspectorController setFile: theRecord];
+    }
+    [LiLog unindentDebugLog];
+}
+
+- (void)doDoubleClickInTable: (NSTableView *)aTable;
+{
+    NSEnumerator *rowEnum;
+    NSNumber *selectedRow;
+
+    rowEnum = [aTable selectedRowEnumerator];
+    while ((selectedRow = [rowEnum nextObject]) != nil) {
+        LiFileHandle *file;
+
+        file = [self fileAtIndex: [selectedRow intValue]];
+        [file open];
+    }
+}
+
+- (void)tableViewColumnDidMove: (NSNotification *)aNotification
+{
+    NSEnumerator *colEnum;
+    NSMutableArray *colOrder;
+    NSMutableDictionary *listPrefs;
+    NSTableColumn *column;
+
+    listPrefs = [self listPrefs];
+    colOrder = [NSMutableArray array];
+    colEnum = [[[self tableView] tableColumns] objectEnumerator];
+    while ((column = [colEnum nextObject]) != nil) {
+        [colOrder addObject: [column identifier]];
+    }
+
+    [listPrefs setObject: colOrder forKey: @"columnOrder"];
+    [self setListPrefs: listPrefs];
+}
+
+- (void)tableViewColumnDidResize: (NSNotification *)aNotification
+{
+    NSMutableDictionary *colPrefs;
+    NSNumber *colSize;
+    NSTableColumn *column;
+
+    column = [[aNotification userInfo] objectForKey: @"NSTableColumn"];
+    if (column != nil) {
+        colPrefs = [self columnPrefsForIdentifier: [column identifier]];
+        colSize = [NSNumber numberWithFloat: [column width]];
+        [colPrefs setObject: colSize forKey: @"width"];
+        [self setColumnPrefs: colPrefs forIdentifier: [column identifier]];
+    }
+}
+@end
+
+@implementation FileTableDelegate
+- (void)openPanelDidEnd: (NSOpenPanel *)openPanel
+             returnCode: (int)returnCode
+            contextInfo: (void *)context
+{
+    [openPanel close];
+    if (returnCode == NSOKButton) {
+        [[self fileStore] addPaths: [openPanel filenames] toGroup: [self group]];
+    }
+}
+
+- (IBAction)addFiles: (id)sender
+{
+    NSOpenPanel *openPanel;
+
+    if ([[self fileStore] isEditable]) {
+        openPanel = [NSOpenPanel openPanel];
+        [openPanel setTitle: myLocalizedString(@"LiLoadPanelTitle")];
+        [openPanel setAllowsMultipleSelection: YES];
+        [openPanel setCanChooseDirectories: YES];
+        [openPanel setCanChooseFiles: YES];
+
+        [openPanel beginSheetForDirectory: nil file: nil types: nil
+                           modalForWindow: [NSApp mainWindow] modalDelegate: self
+                           didEndSelector: @selector(openPanelDidEnd:returnCode:contextInfo:)
+                              contextInfo: nil];
+    }
+}
+
+- (IBAction)openSelectedFiles: (id)sender
+{
+    NSEnumerator *selectionEnum;
+    NSNumber *row;
+
+    selectionEnum = [tableView selectedRowEnumerator];
+    while ((row = [selectionEnum nextObject]) != nil) {
+        LiFileHandle *fileHandle;
+
+        fileHandle = [self fileAtIndex: [row intValue]];
+        [fileHandle open];
+    }
+}
+
+- (IBAction)revealInFinder: (id)sender
+{
+    NSEnumerator *rowEnum;
+    NSNumber *row;
+
+    rowEnum = [tableView selectedRowEnumerator];
+    while ((row = [rowEnum nextObject]) != nil) {
+        LiFileHandle *tmpFile;
+
+        tmpFile = [self fileAtIndex: [row intValue]];
+        [tmpFile revealInFinder];
+    }
+}
+
+- (NSDictionary *)browserColumns
+{
+    NSEnumerator *pluginEnum;
+    NSMutableDictionary *browserColumns;
+    NSObject <LiBrowserPlugin> *plugin;
+
+    browserColumns = [NSMutableDictionary dictionary];
+    pluginEnum = [[[PluginManager defaultManager] browserPlugins] objectEnumerator];
+    while ((plugin = [pluginEnum nextObject]) != nil) {
+        LiBrowserColumn *col;
+        NSEnumerator *colEnum;
+
+        colEnum = [[plugin columns] objectEnumerator];
+        while ((col = [colEnum nextObject]) != nil) {
+            NSString *identifier;
+
+            identifier = [NSString stringWithFormat: @"%@:%@",
+                NSStringFromClass([plugin class]), [col identifier]];
+            [browserColumns setObject: col forKey: identifier];
+        }
+    }
+
+    return browserColumns;
+}
+
+- (LiBrowserColumn *)columnForIdentifier: (NSString *)anIdentifier
+{
+    return [theTableColumns objectForKey: anIdentifier];
+}
+
+- (void)showColumnWithIdentifier: (NSString *)anIdentifier
+{
+    LiBrowserColumn *col;
+    NSMutableDictionary *shownColumns;
+
+    shownColumns = [self shownColumns];
+    if (shownColumns == nil) {
+        shownColumns = [NSMutableDictionary dictionary];
+        [self setShownColumns: shownColumns];
+    }
+    
+    col = [self columnForIdentifier: anIdentifier];
+    if (col && [shownColumns objectForKey: anIdentifier] == nil) {
+        NSDictionary *colPrefs;
+        NSTableColumn *tableColumn;
+
+        colPrefs = [self columnPrefsForIdentifier: anIdentifier];
+        tableColumn = [[[NSTableColumn alloc] initWithIdentifier: anIdentifier] autorelease];
+        [tableColumn setEditable: [col editable]];
+        [tableColumn setDataCell: [col cell]];
+        [tableColumn setResizable: [col resizable]];
+        if ([col resizable]) {
+            NSNumber *colWidth;
+
+            colWidth = [colPrefs objectForKey: @"width"];
+            if (colWidth != nil)
+                [col setWidth: colWidth];
+        }
+        
+        if ([col showsHeader])
+            [[tableColumn headerCell] setStringValue: [col name]];
+        else
+            [[tableColumn headerCell] setStringValue: @""];
+
+        if ([col width])
+            [tableColumn setWidth: [[col width] floatValue]];
+
+        [shownColumns setObject: tableColumn forKey: anIdentifier];
+        
+        [tableView addTableColumn: tableColumn];
+    }
+}
+
+- (void)removeColumnWithIdentifier: (NSString *)anIdentifier
+{
+    NSTableColumn *col;
+
+    col = [[self shownColumns] objectForKey: anIdentifier];
+    if (col != nil) {
+        [[self shownColumns] removeObjectForKey: anIdentifier];
+        [tableView removeTableColumn: col];
+    }
+}
+
+- (id)init
+{
+    self = [super init];
+
+    theTableColumns = [[NSMutableDictionary alloc] init];
+    
+    return self;
+}
+
+- (void)dealloc
+{
+    NSNotificationCenter *defaultCenter;
+
+    defaultCenter = [NSNotificationCenter defaultCenter];
+    [defaultCenter removeObserver: self];
+
+    [ascendingSortingImage release];
+    [descendingSortingImage release];
+    [self setActiveList: nil];
+    [self setFileStore: nil];
+    [self setFilter: nil];
+    [self setSearchString: nil];
+
+    [theTableColumns release];
+    
+    [super dealloc];
+}
+
+- (void)awakeFromNib
+{
+    NSArray *shownColumns;
+    NSDictionary *listPrefs;
+    NSEnumerator *columnEnum;
+    NSString *columnID;
+
+    [LiLog logAsDebug: @"[FileTableDelegate awakeFromNib]"];
+    [LiLog indentDebugLog];
+
+    ascendingSortingImage = [[NSImage imageNamed: @"SortAscending.gif"] retain];
+    descendingSortingImage = [[NSImage imageNamed: @"SortDescending.gif"] retain];
+
+    [tableView setTarget: self];
+    [tableView setDoubleAction: @selector(doDoubleClickInTable:)];
+
+    // XXX
+    theTableColumns = (NSMutableDictionary *)[self browserColumns];
+    [theTableColumns retain];
+    
+    listPrefs = [self listPrefs];
+    shownColumns = [listPrefs objectForKey: @"columnOrder"];
+    for (columnID in shownColumns) {
+        [self showColumnWithIdentifier: columnID];
+    }
+
+    if ([[[self tableView] tableColumns] count] == 0) {
+        columnEnum = [theTableColumns keyEnumerator];
+        while ((columnID = [columnEnum nextObject]) != nil) {
+            [LiLog logAsDebug: @"showCol: %@", columnID];
+            [self showColumnWithIdentifier: columnID];
+        }
+    }
+    
+    /* Register for Drag-and-Drop operation. */
+    [tableView registerForDraggedTypes:
+        [NSArray arrayWithObjects: NSFilenamesPboardType, NSFilesPromisePboardType, NSHTMLPboardType, NSTIFFPboardType, NSPICTPboardType, NSURLPboardType, NSFileContentsPboardType, nil]];
+    
+    [statusLine setStringValue: @""];
+
+    [LiLog unindentDebugLog];
+}
+
+- (void)respondToFileChanged: (NSNotification *)aNotification
+{
+    LiFileHandle *file;
+    NSArray *addedFileList, *changedFileList, *removedFileList;
+    NSDictionary *fileDict;
+    NSEnumerator *fileEnum;
+    BOOL needsRedisplay;
+
+    needsRedisplay = NO;
+
+    addedFileList = [[aNotification userInfo] objectForKey: LiFilesAdded];
+    changedFileList = [[aNotification userInfo] objectForKey: LiFilesChanged];
+    removedFileList = [[aNotification userInfo] objectForKey: LiFilesRemoved];
+
+    fileEnum = [addedFileList objectEnumerator];
+    while (needsRedisplay == NO &&
+           (file = [fileEnum nextObject]) != nil) {
+        if ([file matchesFilter: [self filter]])
+            needsRedisplay = YES;
+    }
+
+    fileEnum = [changedFileList objectEnumerator];
+    while (needsRedisplay == NO &&
+           (fileDict = [fileEnum nextObject]) != nil) {
+        LiFileHandle *tmpHandle;
+        NSDictionary *oldAttributes;
+        
+        tmpHandle = [fileDict objectForKey: @"LiFileHandleAttribute"];
+        oldAttributes = [fileDict objectForKey: LiFileOldAttributes];
+        if ([[self fileStore] attributes: oldAttributes matchFilter: [self filter]] ||
+            [tmpHandle matchesFilter: [self filter]])
+            needsRedisplay = YES;
+    }
+
+    fileEnum = [removedFileList objectEnumerator];
+    while (needsRedisplay == NO &&
+           (fileDict = [fileEnum nextObject]) != nil) {
+        if ([[self fileStore] attributes: [fileDict objectForKey: LiFileOldAttributes]
+                             matchFilter: [self filter]]) {
+            needsRedisplay = YES;
+        }
+    }
+
+    if (needsRedisplay) {
+        [self saveSelectionOfTableView: tableView];
+        [self redisplay];
+        [self restoreSelectionToTableView: tableView refresh: YES];
+    }
+}
+
+- (int)numberOfFiles
+{
+    return [[self sortedList] count];
+}
+
+- (LiFileHandle *)fileAtIndex: (int)index
+{
+    return [[self sortedList] objectAtIndex: index];
+}
+
+- (void)addAttributeFilter: (LiFilter *)aFilter
+{
+    [LiLog logAsDebug: @"[FileTableDelegate addAttributeFilter: %@]", [aFilter description]];
+    [LiLog indentDebugLog];
+
+    [self setFilter: aFilter];
+    
+#if 0
+    filters = [self attributeFilters];
+    attrEnum = [someFilters keyEnumerator];
+    while ((attribute = [attrEnum nextObject]) != nil)
+        [filters setObject: [someFilters objectForKey: attribute]
+                    forKey: attribute];
+
+    [LiLog unindentDebugLog];
+#endif
+}
+
+#if 0
+- (id)filterForAttribute: (NSString *)anAttribute
+{
+    [LiLog logAsDebug: @"[FileTableDelegate filterForAttribute: %@]", anAttribute];
+    [[LiLog indentDebugLog] logAsDebug: @"filters: %@", [[self attributeFilters] description]];
+    [LiLog unindentDebugLog];
+    return [[self attributeFilters] objectForKey: anAttribute];
+}
+#endif
+
+- (void)removeAttributeFilter: (LiFilter *)aFilter
+{
+    [LiLog logAsDebug: @"[FileTableDelegate removeAttributeFilter: %@]", [aFilter description]];
+    [self setFilter: nil];
+    
+#if 0
+    filters = [self attributeFilters];
+    attrEnum = [someFilters keyEnumerator];
+    while ((attribute = [attrEnum nextObject]) != nil)
+        [filters removeObjectForKey: attribute];
+#endif
+}
+
+- (void)saveSelectionOfTableView: (NSTableView *)aTableView
+{
+    NSEnumerator *theEnum;
+    NSMutableSet *savedSelection;
+    NSNumber *rowNum;
+
+    savedSelection = [self savedSelection];
+    if (savedSelection == nil) {
+        savedSelection = [[NSMutableSet alloc] init];
+        theEnum = [aTableView selectedRowEnumerator];
+        while ((rowNum = [theEnum nextObject]) != nil) {
+            id item;
+
+            item = [[self sortedList] objectAtIndex: [rowNum intValue]];
+            [savedSelection addObject: item];
+        }
+        [self setSavedSelection: savedSelection];
+    }
+}
+
+- (void)restoreSelectionToTableView: (NSTableView *)aTableView
+                            refresh: (BOOL)inRefresh
+{
+    NSMutableSet *savedSelection;
+    id item;
+    int savedLastRow;
+
+    [aTableView deselectAll: self];
+    
+    savedLastRow = -1;
+    savedSelection = [self savedSelection];
+    if (savedSelection != nil) {
+        for (item in savedSelection) {
+            int row;
+
+            row = [[self sortedList] indexOfObject: item];
+            if (row != NSNotFound) {
+                [aTableView selectRow: row byExtendingSelection: YES];
+                savedLastRow = row;
+            }
+        }
+
+        [self setSavedSelection: nil];
+
+        if (inRefresh && savedLastRow > -1)
+            [aTableView scrollRowToVisible: savedLastRow];
+    }
+}
+
+- (NSSize)minSize
+{
+    NSArray *tableColumns;
+    NSRect headerRect;
+    NSTableColumn *column;
+    float minHeight, minWidth, rowHeight, scrollHeight, scrollWidth;
+    int numRows;
+
+    [LiLog logAsDebug: @"[FileTableDelegate minSize]"];
+    [LiLog indentDebugLog];
+
+    headerRect = [[[self tableView] headerView] frame];
+    logRect(@"headerRect", headerRect);
+
+    rowHeight = [[self tableView] rowHeight];
+    [LiLog logAsDebug: @"row height: %f", rowHeight];
+    numRows = [self numberOfRowsInTableView: [self tableView]];
+    [LiLog logAsDebug: @"number of rows: %d", numRows];
+    
+    scrollWidth = 17.0;
+    scrollHeight = 34.0;
+
+    tableColumns = [[self tableView] tableColumns];
+    minWidth = scrollWidth;
+    [LiLog indentDebugLog];
+    for (column in tableColumns) {
+        float colWidth;
+
+        colWidth = [column width];
+        [LiLog logAsDebug: @"colWidth: %f", colWidth];
+        minWidth += colWidth;
+    }
+    [LiLog unindentDebugLog];
+    [LiLog logAsDebug: @"minWidth: %f", minWidth];
+    
+    minHeight = headerRect.size.height + rowHeight * numRows + scrollHeight;
+    [LiLog logAsDebug: @"minHeight: %f", minHeight];
+
+    [LiLog unindentDebugLog];
+    return NSMakeSize(minWidth, minHeight);
+}
+
+
+- (BOOL)validateAction: (SEL)anAction
+{
+    //[LiLog logAsDebug: @"[FileTableDelegate validateAction: %@]", NSStringFromSelector(anAction)];
+    if (anAction == @selector(addFiles:)) {
+        return [[self fileStore] isEditable];
+    } else if (anAction == @selector(delete:)) {
+        return ([[self fileStore] isEditable] &&
+                [tableView numberOfSelectedRows] > 0);
+    } else if (anAction == @selector(revealInFinder:)) {
+        return ([[self fileStore] isEditable] &&
+                [tableView numberOfSelectedRows] > 0);
+    } else if (anAction == @selector(openSelectedFiles:)) {
+        return ([[self fileStore] isEditable] &&
+                [tableView numberOfSelectedRows] > 0);
+    } else
+        return YES;
+}
+
+- (BOOL)validateMenuItem: (NSMenuItem *)anItem
+{
+    return [self validateAction: [anItem action]];
+}
+
+- (void)redisplay
+{
+    NSString *filePlural;
+    unsigned long numRecords;
+
+    [self setSearchString: [self searchString]];
+    [self setSelectedColumn: [self selectedColumn]];
+
+    numRecords = [[self sortedList] count];
+    if (numRecords == 1) {
+        filePlural = myLocalizedString(@"LiFileSingular");
+    } else {
+        filePlural = myLocalizedString(@"LiFilePlural");
+    }
+    [statusLine setStringValue:
+        [NSString stringWithFormat: @"(%d %@)", numRecords, filePlural]];
+
+    [tableView reloadData];
+}
+@synthesize statusLine;
+@synthesize theTableColumns;
+@synthesize theFileStore;
+@synthesize theListPrefs;
+@synthesize isAscending;
+@synthesize tableView;
+@synthesize theContextMenu;
+@synthesize theFilter;
+@synthesize theSavedSelection;
+@synthesize theShownColumns;
+@synthesize theSelectedColumn;
+@synthesize inspectorController;
+@synthesize theSearchString;
+@end
+
+@implementation FileTableDelegate (CommonAccessors)
+#if 0
+- (NSString *)group
+{
+    return [self filterForAttribute: LiGroupsAttribute];
+}
+
+- (void)setGroup: (NSString *)aGroupName
+{
+    if (aGroupName == nil) {
+        if ([self group] != nil) {
+            NSDictionary *filter;
+
+            filter = [NSDictionary dictionaryWithObject: [self group]
+                                                 forKey: LiGroupsAttribute];
+            [self removeAttributeFilters: filter];
+        }
+    } else {
+        NSDictionary *filter;
+
+        filter = [NSDictionary dictionaryWithObject: aGroupName
+                                             forKey: LiGroupsAttribute];
+        [self addAttributeFilters: filter];
+    }
+    // We're re-filtering.
+    [self setActiveList: nil];
+
+    [self redisplay];
+}
+#endif
+
+- (NSString *)group
+{
+    return [[self filter] value];
+}
+
+- (void)setGroup: (NSString *)aGroup
+{
+    LiFilter *filter;
+
+    if (aGroup != nil)
+        filter = [LiFilter filterWithAttribute: LiGroupsAttribute
+                               compareSelector: @selector(isEqual:)
+                                         value: aGroup];
+    else
+        filter = nil;
+    [self setFilter: filter];
+}
+@end
+
+@implementation FileTableDelegate (Accessors)
+- (LiFileStore *)fileStore
+{
+    return theFileStore;
+}
+
+- (void)setFileStore: (LiFileStore *)aFileStore
+{
+    [LiLog logAsDebug: @"[FileTableDelegate setFileStore: %@]", aFileStore];
+
+    if (aFileStore != theFileStore) {
+        NSNotificationCenter *defaultCenter;
+        
+        defaultCenter = [NSNotificationCenter defaultCenter];
+        if (theFileStore != nil) {
+            [defaultCenter removeObserver: self
+                                     name: LiFileChangedNotification
+                                   object: theFileStore];
+            [theFileStore release];
+        }
+        if (aFileStore != nil) {
+            [defaultCenter addObserver: self
+                              selector: @selector(respondToFileChanged:)
+                                  name: LiFileChangedNotification
+                                object: aFileStore];
+            theFileStore = [aFileStore retain];
+        }
+    }
+}
+
+#if 0
+- (NSMutableDictionary *)attributeFilters
+{
+    return theFilters;
+}
+
+- (void)setAttributeFilters: (NSMutableDictionary *)someFilters
+{
+    if (someFilters != theFilters) {
+        [someFilters retain];
+        [theFilters release];
+        theFilters = someFilters;
+    }
+}
+#endif
+
+- (LiFilter *)filter
+{
+    return theFilter;
+}
+
+- (void)setFilter: (LiFilter *)aFilter
+{
+    [aFilter retain];
+    [theFilter retain];
+    theFilter = aFilter;
+}
+
+- (NSMutableDictionary *)shownColumns
+{
+    return theShownColumns;
+}
+
+- (void)setShownColumns: (NSMutableDictionary *)someColumns
+{
+    [someColumns retain];
+    [theShownColumns release];
+    theShownColumns = someColumns;
+}
+
+- (NSArray *)sortedList
+{
+    if (theSortedList == nil)
+        return [self activeList];
+    else
+        return theSortedList;
+}
+
+- (void)setSortedList: (NSArray *)aFileList
+{
+    [aFileList retain];
+    [theSortedList release];
+    theSortedList = aFileList;
+}
+
+- (NSArray *)activeList
+{
+    if (theActiveList == nil)
+        return [self fileList];
+    else
+        return theActiveList;
+}
+
+- (void)setActiveList: (NSArray *)aFileList
+{
+    if (aFileList != theActiveList) {
+        [aFileList retain];
+        [theActiveList release];
+        theActiveList = aFileList;
+
+        [self setSortedList: nil];
+    }
+}
+
+- (NSArray *)fileList
+{
+    return [[self fileStore] filesMatchingFilter: [self filter]];
+}
+
+- (NSString *)searchString
+{
+    return theSearchString;
+}
+
+- (NSArray *)filter: (NSArray *)aFileList
+           byString: (NSString *)aSearchString
+{
+    LiFileHandle *record;
+    NSMutableArray *subset;
+
+    if ([aSearchString length] == 0)
+        return aFileList;
+
+    subset = [NSMutableArray array];
+    for (record in aFileList) {
+        NSString *filename;
+        NSRange range;
+
+        filename = [[record filename] lowercaseString];
+        range = [filename rangeOfString: aSearchString];
+        if (range.location != NSNotFound)
+            [subset addObject: record];
+    }
+
+    return subset;
+}
+
+- (void)setSearchString: (NSString *)aSearchString
+{
+    NSArray *tmpList;
+
+    if (aSearchString == nil) {
+        aSearchString = @"";
+        tmpList = [self fileList];
+    } else if ([aSearchString rangeOfString: theSearchString options: NSCaseInsensitiveSearch].location != NSNotFound) {
+        // Optimized filter - only need to select off the active list.
+        tmpList = [self filter: [self activeList] byString: aSearchString];
+    } else {
+        tmpList = [self filter: [self fileList] byString: aSearchString];
+    }
+
+    [aSearchString retain];
+    [theSearchString release];
+    theSearchString = aSearchString;
+
+    [self setActiveList: tmpList];
+}
+
+- (NSTableColumn *)selectedColumn
+{
+    return theSelectedColumn;
+}
+
+- (void)setSelectedColumn: (NSTableColumn *)aColumn
+{
+    LiBrowserColumn *col;
+    struct SortContext context;
+
+    col = [self columnForIdentifier: [aColumn identifier]];
+    
+    context.ascending = isAscending;
+    context.getMethod = [col getMethod];
+    context.compareMethod = [col compareMethod];
+    [self setSelectedColumn: aColumn withContext: &context];
+}
+
+- (void)setSelectedColumn: (NSTableColumn *)aColumn
+              withContext: (void *)someContext
+{
+    struct SortContext *context;
+    NSArray *sortedList;
+
+    [aColumn retain];
+    [theSelectedColumn release];
+    theSelectedColumn = aColumn;
+
+    context = (struct SortContext *)someContext;
+
+    if ([tableView highlightedTableColumn] != theSelectedColumn) {
+        [tableView setIndicatorImage: nil
+                       inTableColumn: [tableView highlightedTableColumn]];
+    }
+
+    [tableView setHighlightedTableColumn: theSelectedColumn];
+    if (theSelectedColumn != nil) {
+        if (context->ascending)
+            [tableView setIndicatorImage: ascendingSortingImage
+                           inTableColumn: theSelectedColumn];
+        else
+            [tableView setIndicatorImage: descendingSortingImage
+                           inTableColumn: theSelectedColumn];
+
+        sortedList = [[self activeList] sortedArrayUsingFunction: contextSorter
+                                                         context: someContext];
+
+        [self setSortedList: sortedList];
+    } else {
+        [self setSortedList: nil];
+    }
+}
+
+- (NSMutableSet *)savedSelection
+{
+    return theSavedSelection;
+}
+
+- (void)setSavedSelection: (NSMutableSet *)aSelection
+{
+    [aSelection retain];
+    [theSavedSelection release];
+    theSavedSelection = aSelection;
+}
+
+- (NSMutableDictionary *)listPrefs
+{
+    if (theListPrefs == nil) {
+        NSDictionary *listPrefs;
+        
+        listPrefs = [[Preferences sharedPreferences] fileListPrefs];
+        if (listPrefs != nil) {
+            theListPrefs = [[NSMutableDictionary alloc] initWithDictionary: listPrefs];
+        } else
+            theListPrefs = [[NSMutableDictionary alloc] init];
+    }
+    return theListPrefs;
+}
+
+- (void)setListPrefs: (NSMutableDictionary *)listPrefs
+{
+    [listPrefs retain];
+    [theListPrefs release];
+    theListPrefs = listPrefs;
+
+    [[Preferences sharedPreferences] setFileListPrefs: theListPrefs];
+}
+
+- (NSMutableDictionary *)columnPrefsForIdentifier: (NSString *)anIdentifier
+{
+    NSMutableDictionary *colPrefs, *retVal;
+
+    colPrefs = [[self listPrefs] objectForKey: @"columns"];
+    if (colPrefs == nil) {
+        colPrefs = [NSMutableDictionary dictionary];
+        [[self listPrefs] setObject: colPrefs forKey: @"columns"];
+    }
+
+    retVal = [colPrefs objectForKey: anIdentifier];
+    if (retVal == nil) {
+        retVal = [NSMutableDictionary dictionary];
+        [colPrefs setObject: retVal forKey: anIdentifier];
+    }
+
+    return retVal;
+}
+
+- (void)setColumnPrefs: (NSMutableDictionary *)columnPrefs
+         forIdentifier: (NSString *)anIdentifier
+{
+    NSMutableDictionary *colPrefs;
+
+    colPrefs = [[self listPrefs] objectForKey: @"columns"];
+    if (colPrefs == nil) {
+        colPrefs = [NSMutableDictionary dictionary];
+        [[self listPrefs] setObject: colPrefs forKey: @"columns"];
+    }
+
+    [colPrefs setObject: columnPrefs forKey: anIdentifier];
+
+    [[Preferences sharedPreferences] setFileListPrefs: theListPrefs];
+}
+
+- (NSTableView *)tableView
+{
+    return tableView;
+}
+@end
+
+@implementation LiFileHandle (GUIStuff)
+- (void)revealInFinder
+{
+    NSURL *fileURL;
+
+    fileURL = [self url];
+    if ([fileURL isFileURL]) {
+        [[NSWorkspace sharedWorkspace] selectFile:
+          [fileURL path] inFileViewerRootedAtPath: @""];
+    }
+}
+@end
\ No newline at end of file