path: root/macosx/HBQueueTableViewController.m

/*  HBQueueTableViewController.m $

 This file is part of the HandBrake source code.
 Homepage: <http://handbrake.fr/>.
 It may be used under the terms of the GNU General Public License. */

#import "HBQueueTableViewController.h"

#import "HBQueue.h"
#import "HBTableView.h"
#import "HBQueueItemView.h"
#import "HBQueueItemWorkingView.h"
#import "NSArray+HBAdditions.h"

// Pasteboard type for or drag operations
#define HBQueueDragDropPboardType @"HBQueueCustomTableViewPboardType"

@interface HBQueueTableViewController () <NSTableViewDataSource, NSTableViewDelegate, HBQueueItemViewDelegate>

@property (nonatomic, weak, readonly) HBQueue *queue;
@property (nonatomic) NSArray<id<HBQueueItem>> *dragNodesArray;

@property (nonatomic, strong) id<HBQueueTableViewControllerDelegate> delegate;

@property (nonatomic, weak) IBOutlet HBTableView *tableView;

@end

@implementation HBQueueTableViewController

- (instancetype)initWithQueue:(HBQueue *)state delegate:(id<HBQueueTableViewControllerDelegate>)delegate
{
    self = [super init];
    if (self)
    {
        _queue = state;
        _delegate = delegate;
    }
    return self;
}

- (NSString *)nibName
{
    return @"HBQueueTableViewController";
}

- (void)viewDidLoad {
    [super viewDidLoad];

    // lets setup our queue list table view for drag and drop here
    [self.tableView registerForDraggedTypes:@[HBQueueDragDropPboardType]];
    [self.tableView setDraggingSourceOperationMask:NSDragOperationEvery forLocal:YES];
    [self.tableView setVerticalMotionCanBeginDrag:YES];

    [NSNotificationCenter.defaultCenter addObserverForName:HBQueueDidAddItemNotification object:_queue queue:NSOperationQueue.mainQueue usingBlock:^(NSNotification * _Nonnull note) {
        NSIndexSet *indexes = note.userInfo[HBQueueItemNotificationIndexesKey];
        [self.tableView insertRowsAtIndexes:indexes withAnimation:NSTableViewAnimationSlideDown];
    }];

    [NSNotificationCenter.defaultCenter addObserverForName:HBQueueDidRemoveItemNotification object:_queue queue:NSOperationQueue.mainQueue usingBlock:^(NSNotification * _Nonnull note) {
        NSIndexSet *indexes = note.userInfo[HBQueueItemNotificationIndexesKey];
        [self.tableView removeRowsAtIndexes:indexes withAnimation:NSTableViewAnimationSlideUp];
        [self.tableView selectRowIndexes:[NSIndexSet indexSetWithIndex:indexes.firstIndex] byExtendingSelection:NO];
    }];

    [NSNotificationCenter.defaultCenter addObserverForName:HBQueueDidMoveItemNotification object:_queue queue:NSOperationQueue.mainQueue usingBlock:^(NSNotification * _Nonnull note) {
        NSArray<NSNumber *> *source = note.userInfo[HBQueueItemNotificationSourceIndexesKey];
        NSArray<NSNumber *> *target = note.userInfo[HBQueueItemNotificationTargetIndexesKey];

        [self.tableView beginUpdates];
        for (NSInteger idx = 0; idx < source.count; idx++)
        {
            [self.tableView moveRowAtIndex:source[idx].integerValue toIndex:target[idx].integerValue];
        }
        [self.tableView endUpdates];
    }];

    [NSNotificationCenter.defaultCenter addObserverForName:HBQueueDidChangeItemNotification object:_queue queue:NSOperationQueue.mainQueue usingBlock:^(NSNotification * _Nonnull note) {
        NSIndexSet *indexes = note.userInfo[HBQueueItemNotificationIndexesKey];
        NSIndexSet *columnIndexes = [NSIndexSet indexSetWithIndex:0];
        [self.tableView reloadDataForRowIndexes:indexes columnIndexes:columnIndexes];
    }];

    typedef void (^HBUpdateHeight)(NSNotification *note);
    HBUpdateHeight updateHeight = ^void(NSNotification *note) {
        HBQueueJobItem *item = note.userInfo[HBQueueItemNotificationItemKey];
        NSUInteger index = [self.queue.items indexOfObject:item];
        if (index != NSNotFound)
        {
            NSIndexSet *indexes = [NSIndexSet indexSetWithIndex:index];
            NSIndexSet *columnIndexes = [NSIndexSet indexSetWithIndex:0];
            [self.tableView reloadDataForRowIndexes:indexes columnIndexes:columnIndexes];
            [self.tableView noteHeightOfRowsWithIndexesChanged:indexes];
        }
    };

    [NSNotificationCenter.defaultCenter addObserverForName:HBQueueDidStartItemNotification object:_queue queue:NSOperationQueue.mainQueue usingBlock:updateHeight];
    [NSNotificationCenter.defaultCenter addObserverForName:HBQueueDidCompleteItemNotification object:_queue queue:NSOperationQueue.mainQueue usingBlock:updateHeight];
}

#pragma mark - UI Actions

/**
 * Delete encodes from the queue window and accompanying array
 * Also handling first cancelling the encode if in fact its currently encoding.
 */
- (IBAction)removeSelectedQueueItem:(id)sender
{
    NSIndexSet *targetedRows = self.tableView.targetedRowIndexes;
    [self.delegate tableViewRemoveItemsAtIndexes:targetedRows];
}

/**
 * Show the finished encode in the finder
 */
- (IBAction)revealSelectedQueueItems:(id)sender
{
    NSIndexSet *targetedRows = self.tableView.targetedRowIndexes;
    NSMutableArray<NSURL *> *urls = [[NSMutableArray alloc] init];

    NSUInteger currentIndex = targetedRows.firstIndex;
    while (currentIndex != NSNotFound) {
        id<HBQueueItem> item = [self.queue.items objectAtIndex:currentIndex];
        if ([item isKindOfClass:[HBQueueJobItem class]])
        {
            NSURL *url = [(HBQueueJobItem *)item completeOutputURL];
            [urls addObject:url];
        }
        currentIndex = [targetedRows indexGreaterThanIndex:currentIndex];
    }

    if (urls.count)
    {
        [NSWorkspace.sharedWorkspace activateFileViewerSelectingURLs:urls];
    }
}

- (IBAction)revealSelectedQueueItemsSources:(id)sender
{
    NSIndexSet *targetedRows = self.tableView.targetedRowIndexes;
    NSMutableArray<NSURL *> *urls = [[NSMutableArray alloc] init];

    NSUInteger currentIndex = targetedRows.firstIndex;
    while (currentIndex != NSNotFound) {
        id<HBQueueItem> item = [self.queue.items objectAtIndex:currentIndex];
        if ([item isKindOfClass:[HBQueueJobItem class]])
        {
            NSURL *url = [(HBQueueJobItem *)item fileURL];
            [urls addObject:url];
        }
        currentIndex = [targetedRows indexGreaterThanIndex:currentIndex];
    }

    if (urls.count)
    {
        [NSWorkspace.sharedWorkspace activateFileViewerSelectingURLs:urls];
    }
}

- (IBAction)revealSelectedQueueItemsActivityLogs:(id)sender
{
    NSIndexSet *targetedRows = self.tableView.targetedRowIndexes;
    NSMutableArray<NSURL *> *urls = [[NSMutableArray alloc] init];

    NSUInteger currentIndex = targetedRows.firstIndex;
    while (currentIndex != NSNotFound) {
        id<HBQueueItem> item = [self.queue.items objectAtIndex:currentIndex];
        if ([item isKindOfClass:[HBQueueJobItem class]])
        {
            NSURL *url = [(HBQueueJobItem *)item activityLogURL];
            if (url)
            {
                [urls addObject:url];
            }
        }
        currentIndex = [targetedRows indexGreaterThanIndex:currentIndex];
    }

    if (urls.count)
    {
        [NSWorkspace.sharedWorkspace activateFileViewerSelectingURLs:urls];
    }
}

/**
 *  Resets the item state to ready.
 */
- (IBAction)resetJobState:(id)sender
{
    NSIndexSet *targetedRows = self.tableView.targetedRowIndexes;
    if (targetedRows.count)
    {
        [self.delegate tableViewResetItemsAtIndexes:targetedRows];
    }
}

/**
 * Send the selected queue item back to the main window for rescan and possible edit.
 */
- (IBAction)editSelectedQueueItem:(id)sender
{
    NSInteger row = self.tableView.clickedRow;
    HBQueueJobItem *item = [self.queue.items objectAtIndex:row];
    if (item)
    {
        [self.delegate tableViewEditItem:item];
    }
}

- (IBAction)removeAll:(id)sender
{
    [self.queue removeNotWorkingItems];
}

- (IBAction)removeCompleted:(id)sender
{
    [self.queue removeCompletedItems];
}

#pragma mark - UI Validation

- (BOOL)validateMenuItem:(NSMenuItem *)menuItem
{
    SEL action = menuItem.action;

    if (action == @selector(editSelectedQueueItem:)) {
        NSIndexSet *indexes = self.tableView.targetedRowIndexes;
        return indexes.count == 1 && self.queue.items[indexes.firstIndex].hasFileRepresentation;
    }

    if (action == @selector(removeSelectedQueueItem:))
    {
        return self.tableView.targetedRowIndexes.count > 0;
    }

    if (action == @selector(revealSelectedQueueItemsSources:))
    {
        NSIndexSet *indexes = self.tableView.targetedRowIndexes;
        if (indexes.count == 0) { return NO; }
        NSArray<id<HBQueueItem>> *items = [self.queue.items objectsAtIndexes:indexes];

        return [items HB_containsWhere:^BOOL(id<HBQueueItem> _Nonnull object) {
            return object.hasFileRepresentation;
        }];
    }

    if (action == @selector(revealSelectedQueueItemsActivityLogs:) ||
        action == @selector(revealSelectedQueueItems:))
    {
        NSIndexSet *indexes = self.tableView.targetedRowIndexes;
        if (indexes.count == 0) { return NO; }
        NSArray<id<HBQueueItem>> *items = [self.queue.items objectsAtIndexes:indexes];

        return [items HB_containsWhere:^BOOL(id<HBQueueItem> _Nonnull object) {
            return object.hasFileRepresentation &&
                (object.state == HBQueueItemStateWorking || object.state == HBQueueItemStateFailed ||
                 object.state == HBQueueItemStateCanceled || object.state == HBQueueItemStateCompleted);
        }];
    }

    if (action == @selector(resetJobState:))
    {
        NSIndexSet *indexes = self.tableView.targetedRowIndexes;
        if (indexes.count == 0) { return NO; }
        NSArray<id<HBQueueItem>> *items = [self.queue.items objectsAtIndexes:indexes];

        return [items HB_containsWhere:^BOOL(id<HBQueueItem> _Nonnull object) {
            return object.hasFileRepresentation &&
                (object.state == HBQueueItemStateFailed || object.state == HBQueueItemStateCanceled ||
                 object.state == HBQueueItemStateCompleted);
        }];
    }

    if (action == @selector(removeAll:))
    {
        return self.queue.items.count > 0;
    }

    if (action == @selector(removeCompleted:))
    {
        return self.queue.completedItemsCount > 0;
    }

    return YES;
}

#pragma mark - NSTableView data source

- (NSView *)tableView:(NSTableView *)tableView
   viewForTableColumn:(NSTableColumn *)tableColumn
                  row:(NSInteger)row
{

    id<HBQueueItem> item = self.queue.items[row];
    HBQueueItemView *view = nil;

    if (item.state == HBQueueItemStateWorking)
    {
        HBQueueItemWorkingView *workingView = [tableView makeViewWithIdentifier:@"MainWorkingCell" owner:self];
        HBQueueWorker *worker = [self.queue workerForItem:item];
        workingView.item = item;
        workingView.worker = worker;
        view = workingView;
    }
    else
    {
        view = [tableView makeViewWithIdentifier:@"MainCell" owner:self];
        view.item = item;
    }

    view.delegate = self;

    return view;
}

- (NSInteger)numberOfRowsInTableView:(NSTableView *)tableView
{
    return self.queue.items.count;
}

- (CGFloat)tableView:(NSTableView *)tableView heightOfRow:(NSInteger)row
{
    id<HBQueueItem> item = self.queue.items[row];
    return item.state == HBQueueItemStateWorking ? 58 : 22;
}

#pragma mark NSQueueItemView delegate

- (void)removeQueueItem:(nonnull id<HBQueueItem>)item
{
    NSUInteger index = [self.queue.items indexOfObject:item];
    [self.delegate tableViewRemoveItemsAtIndexes:[NSIndexSet indexSetWithIndex:index]];
}

- (void)revealQueueItem:(nonnull id<HBQueueItem>)item
{
    if ([item isKindOfClass:[HBQueueJobItem class]])
    {
        [NSWorkspace.sharedWorkspace activateFileViewerSelectingURLs:@[[(HBQueueJobItem *)item completeOutputURL]]];
    }
}

#pragma mark NSTableView delegate

- (void)tableViewSelectionDidChange:(NSNotification *)notification
{
    NSIndexSet *indexes = self.tableView.selectedRowIndexes;
    [self.delegate tableViewDidSelectItemsAtIndexes:indexes];
}

- (void)HB_deleteSelectionFromTableView:(NSTableView *)tableView
{
    [self removeSelectedQueueItem:tableView];
}

- (BOOL)tableView:(NSTableView *)tableView writeRowsWithIndexes:(NSIndexSet *)rowIndexes toPasteboard:(NSPasteboard *)pboard
{
    NSArray<id<HBQueueItem>> *items = [self.queue.items objectsAtIndexes:rowIndexes];
    // Dragging is only allowed of the pending items.
    if (items[0].state != HBQueueItemStateReady)
    {
        return NO;
    }

    self.dragNodesArray = items;

    // Provide data for our custom type, and simple NSStrings.
    [pboard declareTypes:@[HBQueueDragDropPboardType] owner:self];

    // the actual data doesn't matter since DragDropSimplePboardType drags aren't recognized by anyone but us!.
    [pboard setData:[NSData data] forType:HBQueueDragDropPboardType];

    return YES;
}

- (NSDragOperation)tableView:(NSTableView *)tableView validateDrop:(id<NSDraggingInfo>)info proposedRow:(NSInteger)row proposedDropOperation:(NSTableViewDropOperation)dropOperation
{
    // Don't allow dropping ONTO an item since they can't really contain any children.
    BOOL isOnDropTypeProposal = dropOperation == NSTableViewDropOn;
    if (isOnDropTypeProposal)
    {
        return NSDragOperationNone;
    }

    return NSDragOperationMove;
}

- (BOOL)tableView:(NSTableView *)tableView acceptDrop:(id<NSDraggingInfo>)info row:(NSInteger)row dropOperation:(NSTableViewDropOperation)dropOperation
{
    [self.queue moveItems:self.dragNodesArray toIndex:row];
    return YES;
}

@end