Synnefo » Pithos MacOS Client

//

//  PithosBrowserController.m

//  pithos-macos

//

// Copyright 2011-2013 GRNET S.A. All rights reserved.

//

// Redistribution and use in source and binary forms, with or

// without modification, are permitted provided that the following

// conditions are met:

// 

//   1. Redistributions of source code must retain the above

//      copyright notice, this list of conditions and the following

//      disclaimer.

// 

//   2. Redistributions in binary form must reproduce the above

//      copyright notice, this list of conditions and the following

//      disclaimer in the documentation and/or other materials

//      provided with the distribution.

// 

// THIS SOFTWARE IS PROVIDED BY GRNET S.A. ``AS IS'' AND ANY EXPRESS

// OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED

// WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR

// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL GRNET S.A OR

// CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,

// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT

// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF

// USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED

// AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT

// LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN

// ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE

// POSSIBILITY OF SUCH DAMAGE.

// 

// The views and conclusions contained in the software and

// documentation are those of the authors and should not be

// interpreted as representing official policies, either expressed

// or implied, of GRNET S.A.

#import "PithosBrowserController.h"

#import "PithosNode.h"

#import "PithosAccountNode.h"

#import "PithosContainerNode.h"

#import "PithosSubdirNode.h"

#import "PithosObjectNode.h"

#import "PithosSharingAccountsNode.h"

#import "PithosEmptyNode.h"

#import "ImageAndTextCell.h"

#import "FileSystemBrowserCell.h"

#import "ASINetworkQueue.h"

#import "ASIPithosRequest.h"

#import "ASIPithos.h"

#import "ASIPithosContainerRequest.h"

#import "ASIPithosObjectRequest.h"

#import "ASIPithosAccount.h"

#import "ASIPithosContainer.h"

#import "ASIPithosObject.h"

#import "PithosUtilities.h"

#import "PithosAccount.h"

#import "UsingSizeTransformer.h"

#define REFRESH_TIMER_INTERVAL 5

@interface PithosBrowserCell : FileSystemBrowserCell {}

@end

@implementation PithosBrowserCell

- (id)init {

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

        [self setLineBreakMode:NSLineBreakByTruncatingMiddle];

        [self setEditable:YES];

    }

    return self;

}

- (void)setObjectValue:(id)object {

    if ([object isKindOfClass:[PithosNode class]]) {

        PithosNode *node = (PithosNode *)object;

        [self setStringValue:node.displayName];

        [self setImage:node.icon];

    } else {

        [super setObjectValue:object];

    }

}

@end

@interface PithosOutlineViewCell : ImageAndTextCell {}

@end

@implementation PithosOutlineViewCell

- (void)setObjectValue:(id)object {

    if ([object isKindOfClass:[PithosNode class]]) {

        PithosNode *node = (PithosNode *)object;

        [self setStringValue:node.displayName];

        [self setImage:node.icon];

        [self setEditable:NO];

    } else {

        [super setObjectValue:object];

    }

}

@end

@interface PithosBrowserController (Private)

- (BOOL)uploadFiles:(NSArray *)filenames toNode:(PithosNode *)destinationNode;

- (BOOL)moveNodes:(NSArray *)nodes toNode:(PithosNode *)destinationNode;

- (BOOL)cpyNodes:(NSArray *)nodes toNode:(PithosNode *)destinationNode;

@end

@implementation PithosBrowserController

@synthesize pithosAccountManager, accountNode;

@synthesize draggedNodes, draggedParentNode;

@synthesize clipboardNodes, clipboardParentNode, clipboardCopy;

#pragma mark -

#pragma Object Lifecycle

- (id)init {

    return [super initWithWindowNibName:@"PithosBrowserController"];

}

- (void)windowDidLoad {

    [super windowDidLoad];

    if (browser && !browserInitialized) {

        browserInitialized = YES;

        [self initBrowser];

    }

}

- (void)initBrowser {

    [browser registerForDraggedTypes:[NSArray arrayWithObjects:NSFilenamesPboardType, NSFilesPromisePboardType, nil]];

    [browser setDraggingSourceOperationMask:(NSDragOperationCopy|NSDragOperationMove) forLocal:YES];

    [browser setDraggingSourceOperationMask:NSDragOperationCopy forLocal:NO];

    [outlineView registerForDraggedTypes:[NSArray arrayWithObjects:NSFilenamesPboardType, NSFilesPromisePboardType, nil]];

    [outlineView setDraggingSourceOperationMask:(NSDragOperationCopy|NSDragOperationMove) forLocal:YES];

    [outlineView setDraggingSourceOperationMask:NSDragOperationCopy forLocal:NO];

    [browser setCellClass:[PithosBrowserCell class]];

    [browser setAllowsBranchSelection:YES];

    [browser setAllowsMultipleSelection:YES];

    [browser setAllowsEmptySelection:YES];

    [browser setAllowsTypeSelect:YES];

    [browser setDoubleAction:@selector(browserDoubleAction:)];

    moveNetworkQueue = [[ASINetworkQueue alloc] init];

    moveNetworkQueue.shouldCancelAllRequestsOnFailure = NO;

//    moveNetworkQueue.maxConcurrentOperationCount = 1;

    copyNetworkQueue = [[ASINetworkQueue alloc] init];

    copyNetworkQueue.shouldCancelAllRequestsOnFailure = NO;

//    copyNetworkQueue.maxConcurrentOperationCount = 1;

    deleteNetworkQueue = [[ASINetworkQueue alloc] init];

    deleteNetworkQueue.shouldCancelAllRequestsOnFailure = NO;

//    deleteNetworkQueue.maxConcurrentOperationCount = 1;

    uploadNetworkQueue = [[ASINetworkQueue alloc] init];

    uploadNetworkQueue.showAccurateProgress = YES;

    uploadNetworkQueue.shouldCancelAllRequestsOnFailure = NO;

//    uploadNetworkQueue.maxConcurrentOperationCount = 1;

    downloadNetworkQueue = [[ASINetworkQueue alloc] init];

    downloadNetworkQueue.showAccurateProgress = YES;

    downloadNetworkQueue.shouldCancelAllRequestsOnFailure = NO;

//    downloadNetworkQueue.maxConcurrentOperationCount = 1;

    moveQueue = [[NSOperationQueue alloc] init];

    [moveQueue setSuspended:YES];

    moveQueue.name = @"gr.grnet.pithos.MoveQueue";

//    moveQueue.maxConcurrentOperationCount = 1;

    copyQueue = [[NSOperationQueue alloc] init];

    [copyQueue setSuspended:YES];

    copyQueue.name = @"gr.grnet.pithos.CopyQueue";

//    copyQueue.maxConcurrentOperationCount = 1;

    deleteQueue = [[NSOperationQueue alloc] init];

    [deleteQueue setSuspended:YES];

    deleteQueue.name = @"gr.grnet.pithos.DeleteQueue";

//    deleteQueue.maxConcurrentOperationCount = 1;

    uploadQueue = [[NSOperationQueue alloc] init];

    [uploadQueue setSuspended:YES];

    uploadQueue.name = @"gr.grnet.pithos.UploadQueue";

//    uploadQueue.maxConcurrentOperationCount = 1;

    downloadQueue = [[NSOperationQueue alloc] init];

    [downloadQueue setSuspended:YES];

    downloadQueue.name = @"gr.grnet.pithos.DownloadQueue";

//    downloadQueue.maxConcurrentOperationCount = 1;

    moveCallbackQueue = [[NSOperationQueue alloc] init];

    [moveCallbackQueue setSuspended:YES];

    moveCallbackQueue.name = @"gr.grnet.pithos.MoveCallbackQueue";

//    moveCallbackQueue.maxConcurrentOperationCount = 1;

    copyCallbackQueue = [[NSOperationQueue alloc] init];

    [copyCallbackQueue setSuspended:YES];

    copyCallbackQueue.name = @"gr.grnet.pithos.CopyCallbackQueue";

//    copyCallbackQueue.maxConcurrentOperationCount = 1;

    deleteCallbackQueue = [[NSOperationQueue alloc] init];

    [deleteCallbackQueue setSuspended:YES];

    deleteCallbackQueue.name = @"gr.grnet.pithos.DeleteCallbackQueue";

//    deleteCallbackQueue.maxConcurrentOperationCount = 1;

    uploadCallbackQueue = [[NSOperationQueue alloc] init];

    [uploadCallbackQueue setSuspended:YES];

    uploadCallbackQueue.name = @"gr.grnet.pithos.UploadCallbackQueue";

//    uploadCallbackQueue.maxConcurrentOperationCount = 1;

    downloadCallbackQueue = [[NSOperationQueue alloc] init];

    [downloadCallbackQueue setSuspended:YES];

    downloadCallbackQueue.name = @"gr.grnet.pithos.DownloadCallbackQueue";

//    downloadCallbackQueue.maxConcurrentOperationCount = 1;

    [activityProgressIndicator setUsesThreadedAnimation:YES];

    [activityProgressIndicator setMinValue:0.0];

    [activityProgressIndicator setMaxValue:1.0];

    activityFacility = [PithosActivityFacility defaultPithosActivityFacility];

    self.accountNode = [[PithosAccountNode alloc] initWithPithosAccountManager:pithosAccountManager];

    containersNode = [[PithosEmptyNode alloc] initWithDisplayName:@"CONTAINERS" icon:nil];

    containersNodeChildren = [[NSMutableArray alloc] init];

    sharedNode = [[PithosEmptyNode alloc] initWithDisplayName:@"SHARED" icon:nil];

    mySharedNode = [[PithosAccountNode alloc] initWithPithosAccountManager:pithosAccountManager];

    mySharedNode.displayName = @"shared by me";

    mySharedNode.shared = YES;

    mySharedNode.icon = [[NSWorkspace sharedWorkspace] iconForFileType:NSFileTypeForHFSTypeCode(kUserIcon)];

    othersSharedNode = [[PithosSharingAccountsNode alloc] initWithPithosAccountManager:pithosAccountManager];

    othersSharedNode.displayName = @"shared with me";

    othersSharedNode.icon = [[NSWorkspace sharedWorkspace] iconForFileType:NSFileTypeForHFSTypeCode(kGroupIcon)];

    [[[outlineView tableColumns] objectAtIndex:0] setDataCell:[[PithosOutlineViewCell alloc] init]];

    // Register for updates

    // PithosAccountNode accountNode updates outlineView container nodes 

    [[NSNotificationCenter defaultCenter] addObserver:self 

                                             selector:@selector(pithosAccountNodeChildrenUpdated:) 

                                                 name:@"PithosNodeChildrenUpdated" 

                                               object:accountNode];

    // PithosNode updates browser nodes

    [[NSNotificationCenter defaultCenter] addObserver:self 

                                             selector:@selector(pithosNodeChildrenUpdated:) 

                                                 name:@"PithosNodeChildrenUpdated" 

                                               object:nil];

    // Request for browser refresh 

    [[NSNotificationCenter defaultCenter] addObserver:self 

                                             selector:@selector(pithosBrowserRefreshNeeded:) 

                                                 name:@"PithosBrowserRefreshNeeded" 

                                               object:nil];

}

- (void)resetBrowser {

    @synchronized(self) {

        if (!browserActive)

            return;

    }

    [refreshTimer invalidate];

    [moveNetworkQueue reset];

    [copyNetworkQueue reset];

    [deleteNetworkQueue reset];

    [uploadNetworkQueue reset];

    [downloadNetworkQueue reset];

    [moveQueue cancelAllOperations];

    [moveQueue setSuspended:YES];

    [copyQueue cancelAllOperations];

    [copyQueue setSuspended:YES];

    [deleteQueue cancelAllOperations];

    [deleteQueue setSuspended:YES];

    [uploadQueue cancelAllOperations];

    [uploadQueue setSuspended:YES];

    [downloadQueue cancelAllOperations];

    [downloadQueue setSuspended:YES];

    [moveCallbackQueue cancelAllOperations];

    [moveCallbackQueue setSuspended:YES];

    [copyCallbackQueue cancelAllOperations];

    [copyCallbackQueue setSuspended:YES];

    [deleteCallbackQueue cancelAllOperations];

    [deleteCallbackQueue setSuspended:YES];

    [uploadCallbackQueue cancelAllOperations];

    [uploadCallbackQueue setSuspended:YES];

    [downloadCallbackQueue cancelAllOperations];

    [downloadCallbackQueue setSuspended:YES];

    [accountNode pithosNodeWillBeRemoved];

    [mySharedNode pithosNodeWillBeRemoved];

    [othersSharedNode pithosNodeWillBeRemoved];

    rootNode = nil;

    [browser loadColumnZero];

    [containersNodeChildren removeAllObjects];

    [outlineView reloadData];

    // Expand the folder outline view

    [outlineView expandItem:nil expandChildren:YES];

    [outlineView selectRowIndexes:[NSIndexSet indexSetWithIndex:1] byExtendingSelection:NO];

    activityFacility.delegate = nil;

    [activityProgressIndicator setDoubleValue:1.0];

    [activityProgressIndicator stopAnimation:self];

    @synchronized(self) {

        browserActive = NO;

    }

}

- (void)startBrowser {

    @synchronized(self) {

        if (browserActive)

            return;

    }

    // In the improbable case of leftover operations

    [moveNetworkQueue reset];

    [copyNetworkQueue reset];

    [deleteNetworkQueue reset];

    [uploadNetworkQueue reset];

    [downloadNetworkQueue reset];

    [moveQueue cancelAllOperations];

    [copyQueue cancelAllOperations];

    [deleteQueue cancelAllOperations];

    [uploadQueue cancelAllOperations];

    [downloadQueue cancelAllOperations];

    [moveCallbackQueue cancelAllOperations];

    [copyCallbackQueue cancelAllOperations];

    [deleteCallbackQueue cancelAllOperations];

    [uploadCallbackQueue cancelAllOperations];

    [downloadCallbackQueue cancelAllOperations];

    [moveNetworkQueue go];

    [copyNetworkQueue go];

    [deleteNetworkQueue go];

    [uploadNetworkQueue go];

    [downloadNetworkQueue go];

    [moveQueue setSuspended:NO];

    [copyQueue setSuspended:NO];

    [deleteQueue setSuspended:NO];

    [uploadQueue setSuspended:NO];

    [downloadQueue setSuspended:NO];

    [moveCallbackQueue setSuspended:NO];

    [copyCallbackQueue setSuspended:NO];

    [deleteCallbackQueue setSuspended:NO];

    [uploadCallbackQueue setSuspended:NO];

    [downloadCallbackQueue setSuspended:NO];

    accountNode.pithosAccountManager = pithosAccountManager;

    [accountNode reset];

    mySharedNode.pithosAccountManager = pithosAccountManager;

    [mySharedNode reset];

    othersSharedNode.pithosAccountManager = pithosAccountManager;

    [othersSharedNode reset];

//    [activityFacility reset];

    activityFacility.delegate = self;

    refreshTimer = [NSTimer scheduledTimerWithTimeInterval:REFRESH_TIMER_INTERVAL 

                                                     target:self 

                                                   selector:@selector(forceRefresh:) 

                                                   userInfo:self 

                                                    repeats:YES];

    @synchronized(self) {

        browserActive = YES;

    }

}

- (BOOL)operationsPending {

    return ([moveNetworkQueue operationCount] || 

            [copyNetworkQueue operationCount] || 

            [deleteNetworkQueue operationCount] || 

            [uploadNetworkQueue operationCount] || 

            [downloadNetworkQueue operationCount] || 

            [moveQueue operationCount] || 

            [copyQueue operationCount] || 

            [deleteQueue operationCount] || 

            [uploadQueue operationCount] || 

            [downloadQueue operationCount] || 

            [moveCallbackQueue operationCount] || 

            [copyCallbackQueue operationCount] || 

            [deleteCallbackQueue operationCount] || 

            [uploadCallbackQueue operationCount] || 

            [downloadCallbackQueue operationCount]);

}

- (void)dealloc {

    [[NSNotificationCenter defaultCenter] removeObserver:self];

    [self resetBrowser];

}

- (void)setPithosAccountManager:(PithosAccount *)aPithosAccountManager {

    if (aPithosAccountManager && (aPithosAccountManager != pithosAccountManager)) {

        [self resetBrowser];

        if (pithosAccountManager)

            [[NSNotificationCenter defaultCenter] removeObserver:self name:@"PithosAccountPithosChanged" object:pithosAccountManager];

        pithosAccountManager = aPithosAccountManager;

        [[NSNotificationCenter defaultCenter] addObserver:self

                                                 selector:@selector(pithosAccountManagerPithosChanged:)

                                                     name:@"PithosAccountPithosChanged"

                                                   object:pithosAccountManager];

        [self startBrowser];

    }

}

#pragma mark -

#pragma mark Observers

-(void)pithosAccountManagerPithosChanged:(NSNotification *)notification {

    if (![NSThread isMainThread]) {

        [self performSelectorOnMainThread:@selector(pithosAccountManagerPithosChanged:) withObject:notification waitUntilDone:NO];

        return;

    }

    [self resetBrowser];

    [self startBrowser];

}

- (void)pithosNodeChildrenUpdated:(NSNotification *)notification {

    if (![NSThread isMainThread]) {

        [self performSelectorOnMainThread:@selector(pithosNodeChildrenUpdated:) withObject:notification waitUntilDone:NO];

        return;

    }

    PithosNode *node = (PithosNode *)[notification object];

    if ((node == accountNode) || (node.pithosAccountManager != pithosAccountManager))

        return;

    DLog(@"pithosNodeChildrenUpdated:%@", node.url);

    NSInteger lastColumn = [browser lastColumn];

    for (NSInteger column = lastColumn; column >= 0; column--) {

        if ([[browser parentForItemsInColumn:column] isEqualTo:node]) {

            [browser reloadColumn:column];

            return;

        }

    }

}

- (void)pithosAccountNodeChildrenUpdated:(NSNotification *)notification {

    if (![NSThread isMainThread]) {

        [self performSelectorOnMainThread:@selector(pithosAccountNodeChildrenUpdated:) withObject:notification waitUntilDone:NO];

        return;

    }

    BOOL containerPithosFound = NO;

    BOOL containerTrashFound = NO;

    NSMutableIndexSet *removedContainersNodeChildren = [NSMutableIndexSet indexSet];

    for (NSUInteger i = 0 ; i < [containersNodeChildren count] ; i++) {

        if (![accountNode.children containsObject:[containersNodeChildren objectAtIndex:i]])

            [removedContainersNodeChildren addIndex:i];

    }

    [containersNodeChildren removeObjectsAtIndexes:removedContainersNodeChildren];

    for (PithosContainerNode *containerNode in accountNode.children) {

        if ([containerNode.pithosContainer.name isEqualToString:@"pithos"]) {

            if (![containersNodeChildren containsObject:containerNode])

                [containersNodeChildren insertObject:containerNode atIndex:0];

            containerPithosFound = YES;

        } else if ([containerNode.pithosContainer.name isEqualToString:@"trash"]) {

            NSUInteger insertIndex = 1;

            if (!containerPithosFound)

                insertIndex = 0;

            if (![containersNodeChildren containsObject:containerNode])

                [containersNodeChildren insertObject:containerNode atIndex:insertIndex];

            containerTrashFound = YES;

        } else if (![containersNodeChildren containsObject:containerNode]) {

            [containersNodeChildren addObject:containerNode];

        }

    }

    BOOL refreshAccountNode = NO;

    if (!containerPithosFound) {

        // Create pithos node

        ASIPithosContainerRequest *containerRequest = [ASIPithosContainerRequest createOrUpdateContainerRequestWithPithos:pithosAccountManager.pithos

                                                                                                            containerName:@"pithos"];

        [PithosUtilities startAndWaitForRequest:containerRequest];

        if ([containerRequest error]) {

            [PithosUtilities httpRequestErrorAlertWithRequest:containerRequest];

        } else {

            refreshAccountNode = YES;

        }

    }

    if (!containerTrashFound) {

        // Create trash node

        ASIPithosContainerRequest *containerRequest = [ASIPithosContainerRequest createOrUpdateContainerRequestWithPithos:pithosAccountManager.pithos 

                                                                                                            containerName:@"trash"];

        [PithosUtilities startAndWaitForRequest:containerRequest];

        if ([containerRequest error]) {

            [PithosUtilities httpRequestErrorAlertWithRequest:containerRequest];

        } else {

            refreshAccountNode = YES;

        }

    }

    if (refreshAccountNode)

        [accountNode refresh];

    [outlineView reloadData];

    // Expand the folder outline view

    [outlineView expandItem:nil expandChildren:YES];

    if (((rootNode == nil) || (rootNode == containersNode) || (rootNode == sharedNode)) && [containersNodeChildren count]) {

        rootNode = [containersNodeChildren objectAtIndex:0];

        [browser loadColumnZero];

    }

    if (notification)

        [self refresh:nil];

}

- (void)pithosBrowserRefreshNeeded:(NSNotification *)notification {

    [self refresh:nil];

}

#pragma mark -

#pragma mark Actions

- (IBAction)forceRefresh:(id)sender {

    if (![NSThread isMainThread]) {

        [self performSelectorOnMainThread:@selector(forceRefresh:) withObject:sender waitUntilDone:NO];

        return;

    }

    if (editingItem)

        return;

    if (sender)

        [accountNode forceRefresh];

    for (NSInteger column = [browser lastColumn]; column >= 0; column--) {

        PithosNode *node = (PithosNode *)[browser parentForItemsInColumn:column];

        node.forcedRefresh = YES;

        [(PithosNode *)[browser parentForItemsInColumn:column] invalidateChildren];                      

    }

    [browser validateVisibleColumns];

}

- (IBAction)refresh:(id)sender {

    if (![NSThread isMainThread]) {

        [self performSelectorOnMainThread:@selector(refresh:) withObject:sender waitUntilDone:NO];

        return;

    }

    if (editingItem)

        return;

    if ([[NSApp currentEvent] modifierFlags] & NSShiftKeyMask) {

        [self forceRefresh:sender];

    } else {

        if (sender)

            [accountNode refresh];

        for (NSInteger column = [browser lastColumn]; column >= 0; column--) {

            [(PithosNode *)[browser parentForItemsInColumn:column] invalidateChildren];

        }

        [browser validateVisibleColumns];

    }

}

#pragma mark -

#pragma mark NSBrowserDelegate

- (id)rootItemForBrowser:(NSBrowser *)browser {

    return rootNode;    

}

- (NSInteger)browser:(NSBrowser *)browser numberOfChildrenOfItem:(id)item {

    PithosNode *node = (PithosNode *)item;

    return node.children.count;

}

- (id)browser:(NSBrowser *)browser child:(NSInteger)index ofItem:(id)item {

    PithosNode *node = (PithosNode *)item;

    return [node.children objectAtIndex:index];

}

- (BOOL)browser:(NSBrowser *)browser isLeafItem:(id)item {

    PithosNode *node = (PithosNode *)item;

    return node.isLeafItem;

}

- (id)browser:(NSBrowser *)browser objectValueForItem:(id)item {

    PithosNode *node = (PithosNode *)item;

    return node;

}

- (NSViewController *)browser:(NSBrowser *)browser previewViewControllerForLeafItem:(id)item {

    if (sharedPreviewController == nil)

        sharedPreviewController = [[NSViewController alloc] initWithNibName:@"PithosBrowserPreviewController" bundle:[NSBundle bundleForClass:[self class]]];

    return sharedPreviewController;

}

//- (CGFloat)browser:(NSBrowser *)browser shouldSizeColumn:(NSInteger)columnIndex forUserResize:(BOOL)forUserResize toWidth:(CGFloat)suggestedWidth  {

//    if (!forUserResize) {

//        id item = [browser parentForItemsInColumn:columnIndex]; 

//        if ([self browser:browser isLeafItem:item]) {

//            suggestedWidth = 200; 

//        }

//    }

//    return suggestedWidth;

//}

- (BOOL)browser:(NSBrowser *)sender isColumnValid:(NSInteger)column {

    return NO;

}

#pragma mark Editing

- (BOOL)browser:(NSBrowser *)browser shouldEditItem:(id)item {

    PithosNode *node = (PithosNode *)item;

    if (node.shared || node.sharingAccount || 

        ([node class] == [PithosContainerNode class]) || ([node class] == [PithosAccountNode class]))

        return NO;

    editingItem = YES;

    return YES;

}

- (void)browser:(NSBrowser *)browser setObjectValue:(id)object forItem:(id)item {

    editingItem = NO;

    PithosNode *node = (PithosNode *)item;

    NSString *newName = (NSString *)object;

    NSUInteger newNameLength = [newName length];

    NSRange firstSlashRange = [newName rangeOfString:@"/"];

    if ((newNameLength == 0) || 

        ((firstSlashRange.length == 1) && (firstSlashRange.location != (newNameLength - 1))) || 

        ([newName isEqualToString:node.displayName])) {

        return;

    }

    if (([node class] == [PithosObjectNode class]) || 

        (([node class] == [PithosSubdirNode class]) && !node.pithosObject.subdir && [node.pithosObject.name hasSuffix:@"/"])) {

        // Operation: Rename (move) an object or subdir/ node

        __block NSOperation *operation = [NSBlockOperation blockOperationWithBlock:^{

            @autoreleasepool {

                if (operation.isCancelled)

                    return;

                NSString *destinationObjectName = [[node.pithosObject.name stringByDeletingLastPathComponent] stringByAppendingPathComponent:newName];

                if ([newName hasSuffix:@"/"])

                    destinationObjectName = [destinationObjectName stringByAppendingString:@"/"];

                NSError *error = nil;

                BOOL isDirectory;

                if ([PithosUtilities objectExistsAtPithos:pithosAccountManager.pithos

                                            containerName:node.pithosContainer.name 

                                               objectName:destinationObjectName 

                                                    error:&error 

                                              isDirectory:&isDirectory 

                                           sharingAccount:nil]) {

                    dispatch_async(dispatch_get_main_queue(), ^{

                        NSAlert *alert = [[NSAlert alloc] init];

                        [alert setMessageText:@"Name Taken"];

                        [alert setInformativeText:[NSString stringWithFormat:@"The name '%@' is already taken. Please choose a different name", newName]];

                        [alert addButtonWithTitle:@"OK"];

                        [alert runModal];

                    });

                    return;

                } else if (error) {

                    return;

                }

                if (operation.isCancelled)

                    return;

                ASIPithosObjectRequest *objectRequest = [PithosUtilities moveObjectRequestWithPithos:pithosAccountManager.pithos

                                                                                       containerName:node.pithosContainer.name 

                                                                                          objectName:node.pithosObject.name 

                                                                            destinationContainerName:node.pithosContainer.name 

                                                                               destinationObjectName:destinationObjectName 

                                                                                       checkIfExists:NO];

                if (!operation.isCancelled && objectRequest) {

                    objectRequest.delegate = self;

                    objectRequest.didFinishSelector = @selector(performRequestFinishedDelegateInBackground:);

                    objectRequest.didFailSelector = @selector(performRequestFailedDelegateInBackground:);

                    NSString *messagePrefix = [NSString stringWithFormat:@"Moving '%@/%@' to '%@/%@'", 

                                               [objectRequest.userInfo objectForKey:@"sourceContainerName"], 

                                               [objectRequest.userInfo objectForKey:@"sourceObjectName"], 

                                               [objectRequest.userInfo objectForKey:@"destinationContainerName"], 

                                               [objectRequest.userInfo objectForKey:@"destinationObjectName"]];

                    PithosActivity *activity = [activityFacility startActivityWithType:PithosActivityMove 

                                                                               message:messagePrefix];

                    [(NSMutableDictionary *)(objectRequest.userInfo) addEntriesFromDictionary:

                     [NSDictionary dictionaryWithObjectsAndKeys:

                      [NSArray arrayWithObject:node.parent], @"forceRefreshNodes", 

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

                      activity, @"activity", 

                      [messagePrefix stringByAppendingString:@" (stopped)"], @"stoppedActivityMessage", 

                      [messagePrefix stringByAppendingString:@" (failed)"], @"failedActivityMessage", 

                      [messagePrefix stringByAppendingString:@" (finished)"], @"finishedActivityMessage", 

                      [NSNumber numberWithInteger:NSOperationQueuePriorityHigh], @"priority", 

                      [NSNumber numberWithUnsignedInteger:10], @"retries", 

                      NSStringFromSelector(@selector(moveFinished:)), @"didFinishSelector", 

                      NSStringFromSelector(@selector(requestFailed:)), @"didFailSelector", 

                      moveNetworkQueue, @"networkQueue", 

                      @"move", @"operationType", 

                      nil]];

                    [moveNetworkQueue addOperation:[PithosUtilities prepareRequest:objectRequest priority:NSOperationQueuePriorityHigh]];

                }

            }

        }];

        [moveQueue addOperation:operation];

    } else if ([node class] == [PithosSubdirNode class]) {

        if (firstSlashRange.length == 1)

            return;

        // Operation: Rename (move) a subdir node and its descendants

        // The resulting ASIPithosObjectRequests are chained through dependencies

        __block NSOperation *operation = [NSBlockOperation blockOperationWithBlock:^{

            @autoreleasepool {

                if (operation.isCancelled)

                    return;

                NSString *destinationObjectName = [[node.pithosObject.name stringByDeletingLastPathComponent] stringByAppendingPathComponent:newName];

                NSError *error = nil;

                BOOL isDirectory;

                if ([PithosUtilities objectExistsAtPithos:pithosAccountManager.pithos

                                            containerName:node.pithosContainer.name 

                                               objectName:destinationObjectName 

                                                    error:&error 

                                              isDirectory:&isDirectory 

                                           sharingAccount:nil]) {

                    dispatch_async(dispatch_get_main_queue(), ^{

                        NSAlert *alert = [[NSAlert alloc] init];

                        [alert setMessageText:@"Name Taken"];

                        [alert setInformativeText:[NSString stringWithFormat:@"The name '%@' is already taken. Please choose a different name", newName]];

                        [alert addButtonWithTitle:@"OK"];

                        [alert runModal];

                    });

                    return;

                } else if (error) {

                    return;

                }

                if (operation.isCancelled)

                    return;

                if (node.pithosObject.subdir)

                    destinationObjectName = [destinationObjectName stringByAppendingString:@"/"];

                NSArray *objectRequests = [PithosUtilities moveObjectRequestsForSubdirWithPithos:pithosAccountManager.pithos

                                                                                   containerName:node.pithosContainer.name 

                                                                                      objectName:node.pithosObject.name 

                                                                        destinationContainerName:node.pithosContainer.name 

                                                                           destinationObjectName:destinationObjectName 

                                                                                   checkIfExists:NO];

                if (!operation.isCancelled && objectRequests) {

                    ASIPithosObjectRequest *previousObjectRequest = nil;

                    for (ASIPithosObjectRequest *objectRequest in objectRequests) {

                        if (operation.isCancelled)

                            return;

                        objectRequest.delegate = self;

                        objectRequest.didFinishSelector = @selector(performRequestFinishedDelegateInBackground:);

                        objectRequest.didFailSelector = @selector(performRequestFailedDelegateInBackground:);

                        NSString *messagePrefix = [NSString stringWithFormat:@"Moving '%@/%@' to '%@/%@'", 

                                                   [objectRequest.userInfo objectForKey:@"sourceContainerName"], 

                                                   [objectRequest.userInfo objectForKey:@"sourceObjectName"], 

                                                   [objectRequest.userInfo objectForKey:@"destinationContainerName"], 

                                                   [objectRequest.userInfo objectForKey:@"destinationObjectName"]];

                        PithosActivity *activity = [activityFacility startActivityWithType:PithosActivityMove 

                                                                                   message:messagePrefix];

                        [(NSMutableDictionary *)(objectRequest.userInfo) addEntriesFromDictionary:

                         [NSDictionary dictionaryWithObjectsAndKeys:

                          [NSArray arrayWithObject:node.parent], @"forceRefreshNodes", 

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

                          activity, @"activity", 

                          [messagePrefix stringByAppendingString:@" (stopped)"], @"stoppedActivityMessage", 

                          [messagePrefix stringByAppendingString:@" (failed)"], @"failedActivityMessage", 

                          [messagePrefix stringByAppendingString:@" (finished)"], @"finishedActivityMessage", 

                          [NSNumber numberWithInteger:NSOperationQueuePriorityHigh], @"priority", 

                          [NSNumber numberWithUnsignedInteger:10], @"retries", 

                          NSStringFromSelector(@selector(moveFinished:)), @"didFinishSelector", 

                          NSStringFromSelector(@selector(requestFailed:)), @"didFailSelector", 

                          moveNetworkQueue, @"networkQueue", 

                          @"move", @"operationType", 

                          nil]];

                        if (previousObjectRequest)

                            [objectRequest addDependency:previousObjectRequest];

                        previousObjectRequest = objectRequest;

                        [moveNetworkQueue addOperation:[PithosUtilities prepareRequest:objectRequest priority:NSOperationQueuePriorityHigh]];

                    }

                }

            }

        }];

        [moveQueue addOperation:operation];

    }

}

#pragma mark Drag and Drop source

- (BOOL)browser:(NSBrowser *)aBrowser canDragRowsWithIndexes:(NSIndexSet *)rowIndexes inColumn:(NSInteger)column 

      withEvent:(NSEvent *)event {

    NSIndexPath *baseIndexPath = [browser indexPathForColumn:column];

    __block BOOL result = YES;

    [rowIndexes enumerateIndexesUsingBlock:^(NSUInteger idx, BOOL *stop){

        PithosNode *node = [browser itemAtIndexPath:[baseIndexPath indexPathByAddingIndex:idx]];

        if (([node class] == [PithosContainerNode class]) || ([node class] == [PithosAccountNode class])) {

            result = NO;

            *stop = YES;

        }

    }];

    return result;

}

- (BOOL)browser:(NSBrowser *)aBrowser writeRowsWithIndexes:(NSIndexSet *)rowIndexes inColumn:(NSInteger)column 

   toPasteboard:(NSPasteboard *)pasteboard {

    NSMutableArray *propertyList = [NSMutableArray arrayWithCapacity:[rowIndexes count]];

    NSMutableArray *nodes = [NSMutableArray arrayWithCapacity:[rowIndexes count]];

    NSIndexPath *baseIndexPath = [browser indexPathForColumn:column];

    [rowIndexes enumerateIndexesUsingBlock:^(NSUInteger idx, BOOL *stop){

        PithosNode *node = [browser itemAtIndexPath:[baseIndexPath indexPathByAddingIndex:idx]];

        [propertyList addObject:[node.pithosObject.name pathExtension]];

        [nodes addObject:node];

    }];

    [pasteboard declareTypes:[NSArray arrayWithObject:NSFilesPromisePboardType] owner:self];

    [pasteboard setPropertyList:propertyList forType:NSFilesPromisePboardType];

    self.draggedNodes = nodes;

    self.draggedParentNode = [browser parentForItemsInColumn:column];

    return YES;

}

- (NSArray *)browser:(NSBrowser *)aBrowser namesOfPromisedFilesDroppedAtDestination:(NSURL *)dropDestination 

forDraggedRowsWithIndexes:(NSIndexSet *)rowIndexes inColumn:(NSInteger)column {

    NSMutableArray *names = [NSMutableArray arrayWithCapacity:[draggedNodes count]];

    for (PithosNode *node in draggedNodes) {

        [names addObject:node.displayName];

        // If the node is a subdir ask if the whole tree should be downloaded

        if ([node class] == [PithosSubdirNode class]) {

            NSAlert *alert = [[NSAlert alloc] init];

            [alert setMessageText:@"Download directory"];

            [alert setInformativeText:[NSString stringWithFormat:@"'%@' is a directory, do you want to download its contents?", node.displayName]];

            [alert addButtonWithTitle:@"OK"];

            [alert addButtonWithTitle:@"Cancel"];

            NSInteger choice = [alert runModal];

            if (choice == NSAlertFirstButtonReturn)

                [self downloadNode:node toDirectory:[dropDestination path] withNewFileName:nil version:nil checkIfExists:YES];

        } else {

            [self downloadNode:node toDirectory:[dropDestination path] withNewFileName:nil version:nil checkIfExists:YES];

        }

    }

    return names;

}

#pragma mark Drag and Drop destination

- (NSDragOperation)browser:aBrowser 

              validateDrop:(id<NSDraggingInfo>)info 

               proposedRow:(NSInteger *)row 

                    column:(NSInteger *)column 

             dropOperation:(NSBrowserDropOperation *)dropOperation {

    NSDragOperation result = NSDragOperationNone;

    if ([[[info draggingPasteboard] types] containsObject:NSFilenamesPboardType]) {

        // For a drop above, the drop is redirected to the parent item

        if (*dropOperation == NSBrowserDropAbove)

            *row = -1;

        // Only allow dropping in folders

        if (*column != -1) {

            PithosNode *dropNode;

            if (*row != -1) {

                // Check if the node is not a folder and if so redirect to the parent item

                dropNode = [browser itemAtRow:*row inColumn:*column];

                if ([dropNode class] == [PithosObjectNode class])

                    *row = -1;

            }

            if (*row == -1)

                dropNode = [browser parentForItemsInColumn:*column];

            if (!dropNode.shared && 

                (!dropNode.sharingAccount || 

                 ([dropNode class] == [PithosSubdirNode class]) || 

                 ([dropNode class] == [PithosContainerNode class]))) {

                *dropOperation = NSBrowserDropOn;

                result = NSDragOperationCopy;

            }

        }

    } else if ([[[info draggingPasteboard] types] containsObject:NSFilesPromisePboardType]) {

        // For a drop above, the drop is redirected to the parent item

        if (*dropOperation == NSBrowserDropAbove) 

            *row = -1;

        // Only allow dropping in folders

        if (*column != -1) {

            PithosNode *dropNode;

            if (*row != -1) {

                // Check if the node is not a folder and if so redirect to the parent item

                dropNode = [browser itemAtRow:*row inColumn:*column];

                if ([dropNode class] == [PithosObjectNode class])

                    *row = -1;

            }

            if (*row == -1)

                dropNode = [browser parentForItemsInColumn:*column];

            if (!dropNode.shared && !dropNode.sharingAccount) {

                if ([info draggingSourceOperationMask] & NSDragOperationMove) {

                    // NSDragOperationCopy | NSDragOperationMove -> NSDragOperationMove

                    if ((([dropNode class] == [PithosContainerNode class]) || 

                         dropNode.pithosObject.subdir || 

                         ![dropNode.pithosObject.name hasSuffix:@"/"]) && 

                        ![dropNode isEqualTo:draggedParentNode]) { 

    //                    ![dropNode isEqualTo:draggedParentNode] && 

    //                    ![draggedNodes containsObject:dropNode]) {                

                        result = NSDragOperationMove;

                    }

                } else if ([info draggingSourceOperationMask] & NSDragOperationCopy) {

                    // NSDragOperationCopy (Option modifier) -> NSDragOperationCopy

                    if (([dropNode class] == [PithosContainerNode class]) || 

                        dropNode.pithosObject.subdir || 

                        ![dropNode.pithosObject.name hasSuffix:@"/"]) { 

                        result = NSDragOperationCopy;

                    }

                }

            }

        }

    }

    return result;

}

- (BOOL)browser:(NSBrowser *)aBrowser 

     acceptDrop:(id<NSDraggingInfo>)info 

          atRow:(NSInteger)row 

         column:(NSInteger)column 

  dropOperation:(NSBrowserDropOperation)dropOperation {

    if ([[[info draggingPasteboard] types] containsObject:NSFilenamesPboardType]) {

        NSArray *filenames = [[info draggingPasteboard] propertyListForType:NSFilenamesPboardType];

        DLog(@"drag in operation: %lu filenames: %@", [info draggingSourceOperationMask], filenames);

        if ((column != -1) && (filenames != nil)) {

            PithosNode *node;

            if (row != -1)

                node = [browser itemAtRow:row inColumn:column];

            else

                node = [browser parentForItemsInColumn:column];

            DLog(@"drag in node: %@", node.url);

            return [self uploadFiles:filenames toNode:node];

        }

    } else if ([[[info draggingPasteboard] types] containsObject:NSFilesPromisePboardType]) {

        DLog(@"drag local operation: %lu nodes: %@", [info draggingSourceOperationMask], draggedNodes);

        if ((column != -1) && (draggedNodes != nil)) {

            PithosNode *node;

            if (row != -1)

                node = [browser itemAtRow:row inColumn:column];

            else

                node = [browser parentForItemsInColumn:column];

            DLog(@"drag local node: %@", node.url);

            if ([info draggingSourceOperationMask] & NSDragOperationMove)

                return [self moveNodes:draggedNodes toNode:node];

            else if ([info draggingSourceOperationMask] & NSDragOperationCopy)

                return [self cpyNodes:draggedNodes toNode:node];

        }

    }

    return NO;

}

#pragma mark -

#pragma mark NSBrowser Actions

- (void)browserDoubleAction:(id)sender {

    NSInteger column = [browser clickedColumn];

    NSInteger row = [browser clickedRow];

    if ((column == -1) || (row == -1))

        return;

    NSIndexPath *clickedNodeIndexPath = [[browser indexPathForColumn:column] indexPathByAddingIndex:row];

    NSArray *menuNodesIndexPaths = [browser selectionIndexPaths];

    NSMutableArray *menuNodes = [NSMutableArray arrayWithCapacity:[menuNodesIndexPaths count]];

    if ([menuNodesIndexPaths containsObject:clickedNodeIndexPath]) {

        for (NSIndexPath *nodeIndexPath in menuNodesIndexPaths) {

            [menuNodes addObject:[browser itemAtIndexPath:nodeIndexPath]];

        }

    } else {

        [menuNodes addObject:[browser itemAtIndexPath:clickedNodeIndexPath]];

    }

    NSMenuItem *menuItem = [[NSMenuItem alloc] init];

    menuItem.representedObject = menuNodes;

    [self menuDownload:menuItem];

}

#pragma mark -

#pragma mark Drag and Drop methods

- (void)downloadNode:(PithosNode *)node toDirectory:(NSString *)dirPath withNewFileName:(NSString *)newFileName 

             version:(NSString *)version checkIfExists:(BOOL)checkIfExists {

    if ([node class] == [PithosSubdirNode class]) {

        // XXX newFilename and version are ignored in the case of a subdir node for now

        // Operation: Download a subdir node and its descendants

        // The resulting ASIPithosObjectRequests are chained through dependencies

        __block NSOperation *operation = [NSBlockOperation blockOperationWithBlock:^{

            @autoreleasepool {

                if (operation.isCancelled)

                    return;

                NSArray *objectRequests = [PithosUtilities objectDataRequestsForSubdirWithPithos:pithosAccountManager.pithos

                                                                                   containerName:node.pithosContainer.name 

                                                                                      objectName:node.pithosObject.name 

                                                                                     toDirectory:dirPath 

                                                                                   checkIfExists:checkIfExists 

                                                                                  sharingAccount:node.sharingAccount];

                if (!operation.isCancelled && objectRequests) {

                    ASIPithosObjectRequest *previousObjectRequest = nil;

                    for (__block ASIPithosObjectRequest *objectRequest in objectRequests) {

                        if (operation.isCancelled)

                            return;

                        objectRequest.delegate = self;

                        objectRequest.didFinishSelector = @selector(performRequestFinishedDelegateInBackground:);

                        objectRequest.didFailSelector = @selector(performRequestFailedDelegateInBackground:);

                        NSString *messagePrefix = [NSString stringWithFormat:@"Downloading '%@'", [objectRequest.userInfo objectForKey:@"fileName"]];

                        PithosActivity *activity = [activityFacility startActivityWithType:PithosActivityDownload 

                                                                                   message:[messagePrefix stringByAppendingString:@" (0%)"]

                                                                                totalBytes:[[objectRequest.userInfo objectForKey:@"bytes"] unsignedIntegerValue] 

                                                                              currentBytes:0];

                        dispatch_async(dispatch_get_main_queue(), ^{

                            [activityFacility updateActivity:activity withMessage:activity.message];  

                        });

                        [(NSMutableDictionary *)objectRequest.userInfo addEntriesFromDictionary:

                         [NSDictionary dictionaryWithObjectsAndKeys:

                          activity, @"activity", 

                          [messagePrefix stringByAppendingString:@" (stopped)"], @"stoppedActivityMessage", 

                          [messagePrefix stringByAppendingString:@" (failed)"], @"failedActivityMessage", 

                          [messagePrefix stringByAppendingString:@" (100%)"], @"finishedActivityMessage", 

                          [NSNumber numberWithInteger:NSOperationQueuePriorityNormal], @"priority", 

                          [NSNumber numberWithUnsignedInteger:10], @"retries", 

                          NSStringFromSelector(@selector(downloadObjectFinished:)), @"didFinishSelector",