git.sesse.net Git - vlc/blob - modules/gui/macosx/playlist.m

   1 /*****************************************************************************
   2  * playlist.m: MacOS X interface module
   3  *****************************************************************************
   4 * Copyright (C) 2002-2008 the VideoLAN team
   5  * $Id$
   6  *
   7  * Authors: Jon Lech Johansen <jon-vl@nanocrew.net>
   8  *          Derk-Jan Hartman <hartman at videola/n dot org>
   9  *          Benjamin Pracht <bigben at videolab dot org>
  10  *
  11  * This program is free software; you can redistribute it and/or modify
  12  * it under the terms of the GNU General Public License as published by
  13  * the Free Software Foundation; either version 2 of the License, or
  14  * (at your option) any later version.
  15  *
  16  * This program is distributed in the hope that it will be useful,
  17  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  18  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  19  * GNU General Public License for more details.
  20  *
  21  * You should have received a copy of the GNU General Public License
  22  * along with this program; if not, write to the Free Software
  23  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston MA 02110-1301, USA.
  24  *****************************************************************************/
  25
  26 /* TODO
  27  * add 'icons' for different types of nodes? (http://www.cocoadev.com/index.pl?IconAndTextInTableCell)
  28  * reimplement enable/disable item
  29  * create a new 'tool' button (see the gear button in the Finder window) for 'actions'
  30    (adding service discovery, other views, new node/playlist, save node/playlist) stuff like that
  31  */
  32
  33
  34 /*****************************************************************************
  35  * Preamble
  36  *****************************************************************************/
  37 #include <stdlib.h>                                      /* malloc(), free() */
  38 #include <sys/param.h>                                    /* for MAXPATHLEN */
  39 #include <string.h>
  40 #include <math.h>
  41 #include <sys/mount.h>
  42 #include <vlc_keys.h>
  43
  44 #import "intf.h"
  45 #import "wizard.h"
  46 #import "bookmarks.h"
  47 #import "playlistinfo.h"
  48 #import "playlist.h"
  49 #import "controls.h"
  50 #import "vlc_osd.h"
  51 #import "misc.h"
  52 #import <vlc_interface.h>
  53 #import <vlc_services_discovery.h>
  54
  55 /*****************************************************************************
  56  * VLCPlaylistView implementation
  57  *****************************************************************************/
  58 @implementation VLCPlaylistView
  59
  60 - (NSMenu *)menuForEvent:(NSEvent *)o_event
  61 {
  62     return( [[self delegate] menuForEvent: o_event] );
  63 }
  64
  65 - (void)keyDown:(NSEvent *)o_event
  66 {
  67     unichar key = 0;
  68
  69     if( [[o_event characters] length] )
  70     {
  71         key = [[o_event characters] characterAtIndex: 0];
  72     }
  73
  74     switch( key )
  75     {
  76         case NSDeleteCharacter:
  77         case NSDeleteFunctionKey:
  78         case NSDeleteCharFunctionKey:
  79         case NSBackspaceCharacter:
  80             [[self delegate] deleteItem:self];
  81             break;
  82
  83         case NSEnterCharacter:
  84         case NSCarriageReturnCharacter:
  85             [(VLCPlaylist *)[[VLCMain sharedInstance] getPlaylist] playItem:self];
  86             break;
  87
  88         default:
  89             [super keyDown: o_event];
  90             break;
  91     }
  92 }
  93
  94 @end
  95
  96 /*****************************************************************************
  97  * VLCPlaylistCommon implementation
  98  *
  99  * This class the superclass of the VLCPlaylist and VLCPlaylistWizard.
 100  * It contains the common methods and elements of these 2 entities.
 101  *****************************************************************************/
 102 @implementation VLCPlaylistCommon
 103
 104 - (id)init
 105 {
 106     self = [super init];
 107     if ( self != nil )
 108     {
 109         o_outline_dict = [[NSMutableDictionary alloc] init];
 110     }
 111     return self;
 112 }
 113 - (void)awakeFromNib
 114 {
 115     playlist_t * p_playlist = pl_Hold( VLCIntf );
 116     [o_outline_view setTarget: self];
 117     [o_outline_view setDelegate: self];
 118     [o_outline_view setDataSource: self];
 119     [o_outline_view setAllowsEmptySelection: NO];
 120     [o_outline_view expandItem: [o_outline_view itemAtRow:0]];
 121
 122     pl_Release( VLCIntf );
 123     [self initStrings];
 124 }
 125
 126 - (void)initStrings
 127 {
 128     [[o_tc_name headerCell] setStringValue:_NS("Name")];
 129     [[o_tc_author headerCell] setStringValue:_NS("Author")];
 130     [[o_tc_duration headerCell] setStringValue:_NS("Duration")];
 131 }
 132
 133 - (NSOutlineView *)outlineView
 134 {
 135     return o_outline_view;
 136 }
 137
 138 - (playlist_item_t *)selectedPlaylistItem
 139 {
 140     return [[o_outline_view itemAtRow: [o_outline_view selectedRow]]
 141                                                                 pointerValue];
 142 }
 143
 144 @end
 145
 146 @implementation VLCPlaylistCommon (NSOutlineViewDataSource)
 147
 148 /* return the number of children for Obj-C pointer item */ /* DONE */
 149 - (NSInteger)outlineView:(NSOutlineView *)outlineView numberOfChildrenOfItem:(id)item
 150 {
 151     int i_return = 0;
 152     playlist_item_t *p_item = NULL;
 153     playlist_t * p_playlist = pl_Hold( VLCIntf );
 154     assert( outlineView == o_outline_view );
 155
 156     if( !item )
 157         p_item = p_playlist->p_root_category;
 158     else
 159         p_item = (playlist_item_t *)[item pointerValue];
 160
 161     if( p_item )
 162         i_return = p_item->i_children;
 163
 164     pl_Release( VLCIntf );
 165
 166     return i_return > 0 ? i_return : 0;
 167 }
 168
 169 /* return the child at index for the Obj-C pointer item */ /* DONE */
 170 - (id)outlineView:(NSOutlineView *)outlineView child:(NSInteger)index ofItem:(id)item
 171 {
 172     playlist_item_t *p_return = NULL, *p_item = NULL;
 173     NSValue *o_value;
 174     playlist_t * p_playlist = pl_Hold( VLCIntf );
 175
 176     PL_LOCK;
 177     if( item == nil )
 178     {
 179         /* root object */
 180         p_item = p_playlist->p_root_category;
 181     }
 182     else
 183     {
 184         p_item = (playlist_item_t *)[item pointerValue];
 185     }
 186     if( p_item && index < p_item->i_children && index >= 0 )
 187         p_return = p_item->pp_children[index];
 188     PL_UNLOCK;
 189
 190     pl_Release( VLCIntf );
 191
 192     o_value = [o_outline_dict objectForKey:[NSString stringWithFormat: @"%p", p_return]];
 193
 194     if( o_value == nil )
 195     {
 196         /* Why is there a warning if that happens all the time and seems
 197          * to be normal? Add an assert and fix it.
 198          * msg_Warn( VLCIntf, "playlist item misses pointer value, adding one" ); */
 199         o_value = [[NSValue valueWithPointer: p_return] retain];
 200     }
 201     return o_value;
 202 }
 203
 204 /* is the item expandable */
 205 - (BOOL)outlineView:(NSOutlineView *)outlineView isItemExpandable:(id)item
 206 {
 207     int i_return = 0;
 208     playlist_t *p_playlist = pl_Hold( VLCIntf );
 209
 210     if( item == nil )
 211     {
 212         /* root object */
 213         if( p_playlist->p_root_category )
 214         {
 215             i_return = p_playlist->p_root_category->i_children;
 216         }
 217     }
 218     else
 219     {
 220         playlist_item_t *p_item = (playlist_item_t *)[item pointerValue];
 221         if( p_item )
 222             i_return = p_item->i_children;
 223     }
 224     pl_Release( VLCIntf );
 225
 226     return (i_return >= 0);
 227 }
 228
 229 /* retrieve the string values for the cells */
 230 - (id)outlineView:(NSOutlineView *)outlineView objectValueForTableColumn:(NSTableColumn *)o_tc byItem:(id)item
 231 {
 232     id o_value = nil;
 233     playlist_item_t *p_item;
 234
 235     /* For error handling */
 236     static BOOL attempted_reload = NO;
 237
 238     if( item == nil || ![item isKindOfClass: [NSValue class]] )
 239     {
 240         /* Attempt to fix the error by asking for a data redisplay
 241          * This might cause infinite loop, so add a small check */
 242         if( !attempted_reload )
 243         {
 244             attempted_reload = YES;
 245             [outlineView reloadData];
 246         }
 247         return @"error" ;
 248     }
 249
 250     p_item = (playlist_item_t *)[item pointerValue];
 251     if( !p_item || !p_item->p_input )
 252     {
 253         /* Attempt to fix the error by asking for a data redisplay
 254          * This might cause infinite loop, so add a small check */
 255         if( !attempted_reload )
 256         {
 257             attempted_reload = YES;
 258             [outlineView reloadData];
 259         }
 260         return @"error";
 261     }
 262
 263     attempted_reload = NO;
 264
 265     if( [[o_tc identifier] isEqualToString:@"name"] )
 266     {
 267         /* sanity check to prevent the NSString class from crashing */
 268         char *psz_title =  input_item_GetTitle( p_item->p_input );
 269         if( !EMPTY_STR( psz_title ) )
 270         {
 271             o_value = [NSString stringWithUTF8String: psz_title];
 272         }
 273         else
 274         {
 275             char *psz_name = input_item_GetName( p_item->p_input );
 276             if( psz_name )
 277                 o_value = [NSString stringWithUTF8String: psz_name];
 278             free( psz_name );
 279         }
 280         free( psz_title );
 281     }
 282     else if( [[o_tc identifier] isEqualToString:@"artist"] )
 283     {
 284         char *psz_artist = input_item_GetArtist( p_item->p_input );
 285         if( psz_artist )
 286             o_value = [NSString stringWithUTF8String: psz_artist];
 287         free( psz_artist );
 288     }
 289     else if( [[o_tc identifier] isEqualToString:@"duration"] )
 290     {
 291         char psz_duration[MSTRTIME_MAX_SIZE];
 292         mtime_t dur = input_item_GetDuration( p_item->p_input );
 293         if( dur != -1 )
 294         {
 295             secstotimestr( psz_duration, dur/1000000 );
 296             o_value = [NSString stringWithUTF8String: psz_duration];
 297         }
 298         else
 299             o_value = @"--:--";
 300     }
 301     else if( [[o_tc identifier] isEqualToString:@"status"] )
 302     {
 303         if( input_item_HasErrorWhenReading( p_item->p_input ) )
 304         {
 305             o_value = [NSImage imageWithWarningIcon];
 306         }
 307     }
 308     return o_value;
 309 }
 310
 311 @end
 312
 313 /*****************************************************************************
 314  * VLCPlaylistWizard implementation
 315  *****************************************************************************/
 316 @implementation VLCPlaylistWizard
 317
 318 - (IBAction)reloadOutlineView
 319 {
 320     /* Only reload the outlineview if the wizard window is open since this can
 321        be quite long on big playlists */
 322     if( [[o_outline_view window] isVisible] )
 323     {
 324         [o_outline_view reloadData];
 325     }
 326 }
 327
 328 @end
 329
 330 /*****************************************************************************
 331  * extension to NSOutlineView's interface to fix compilation warnings
 332  * and let us access these 2 functions properly
 333  * this uses a private Apple-API, but works fine on all current OSX releases
 334  * keep checking for compatiblity with future releases though
 335  *****************************************************************************/
 336
 337 @interface NSOutlineView (UndocumentedSortImages)
 338 + (NSImage *)_defaultTableHeaderSortImage;
 339 + (NSImage *)_defaultTableHeaderReverseSortImage;
 340 @end
 341
 342
 343 /*****************************************************************************
 344  * VLCPlaylist implementation
 345  *****************************************************************************/
 346 @implementation VLCPlaylist
 347
 348 - (id)init
 349 {
 350     self = [super init];
 351     if ( self != nil )
 352     {
 353         o_nodes_array = [[NSMutableArray alloc] init];
 354         o_items_array = [[NSMutableArray alloc] init];
 355     }
 356     return self;
 357 }
 358
 359 - (void)dealloc
 360 {
 361     [o_nodes_array release];
 362     [o_items_array release];
 363     [super dealloc];
 364 }
 365
 366 - (void)awakeFromNib
 367 {
 368     playlist_t * p_playlist = pl_Hold( VLCIntf );
 369
 370     int i;
 371
 372     [super awakeFromNib];
 373
 374     [o_outline_view setDoubleAction: @selector(playItem:)];
 375
 376     [o_outline_view registerForDraggedTypes:
 377         [NSArray arrayWithObjects: NSFilenamesPboardType,
 378         @"VLCPlaylistItemPboardType", nil]];
 379     [o_outline_view setIntercellSpacing: NSMakeSize (0.0, 1.0)];
 380
 381     /* This uses private Apple API which works fine until 10.5.
 382      * We need to keep checking in the future!
 383      * These methods are being added artificially to NSOutlineView's interface above */
 384     o_ascendingSortingImage = [[NSOutlineView class] _defaultTableHeaderSortImage];
 385     o_descendingSortingImage = [[NSOutlineView class] _defaultTableHeaderReverseSortImage];
 386
 387     o_tc_sortColumn = nil;
 388
 389     char ** ppsz_name;
 390     char ** ppsz_services = vlc_sd_GetNames( &ppsz_name );
 391     if( !ppsz_services )
 392     {
 393         pl_Release( VLCIntf );
 394         return;
 395     }
 396
 397     for( i = 0; ppsz_services[i]; i++ )
 398     {
 399         bool  b_enabled;
 400         NSMenuItem  *o_lmi;
 401
 402         char * name = ppsz_name[i] ? ppsz_name[i] : ppsz_services[i];
 403         /* Check whether to enable these menuitems */
 404         b_enabled = playlist_IsServicesDiscoveryLoaded( p_playlist, ppsz_services[i] );
 405
 406         /* Create the menu entries used in the playlist menu */
 407         o_lmi = [[o_mi_services submenu] addItemWithTitle:
 408                  [NSString stringWithUTF8String: name]
 409                                          action: @selector(servicesChange:)
 410                                          keyEquivalent: @""];
 411         [o_lmi setTarget: self];
 412         [o_lmi setRepresentedObject: [NSString stringWithUTF8String: ppsz_services[i]]];
 413         if( b_enabled ) [o_lmi setState: NSOnState];
 414
 415         /* Create the menu entries for the main menu */
 416         o_lmi = [[o_mm_mi_services submenu] addItemWithTitle:
 417                  [NSString stringWithUTF8String: name]
 418                                          action: @selector(servicesChange:)
 419                                          keyEquivalent: @""];
 420         [o_lmi setTarget: self];
 421         [o_lmi setRepresentedObject: [NSString stringWithUTF8String: ppsz_services[i]]];
 422         if( b_enabled ) [o_lmi setState: NSOnState];
 423
 424         free( ppsz_services[i] );
 425         free( ppsz_name[i] );
 426     }
 427     free( ppsz_services );
 428     free( ppsz_name );
 429
 430     pl_Release( VLCIntf );
 431 }
 432
 433 - (void)searchfieldChanged:(NSNotification *)o_notification
 434 {
 435     [o_search_field setStringValue:[[o_notification object] stringValue]];
 436 }
 437
 438 - (void)initStrings
 439 {
 440     [super initStrings];
 441
 442     [o_mi_save_playlist setTitle: _NS("Save Playlist...")];
 443     [o_mi_play setTitle: _NS("Play")];
 444     [o_mi_delete setTitle: _NS("Delete")];
 445     [o_mi_recursive_expand setTitle: _NS("Expand Node")];
 446     [o_mi_selectall setTitle: _NS("Select All")];
 447     [o_mi_info setTitle: _NS("Media Information...")];
 448     [o_mi_dl_cover_art setTitle: _NS("Download Cover Art")];
 449     [o_mi_preparse setTitle: _NS("Fetch Meta Data")];
 450     [o_mi_revealInFinder setTitle: _NS("Reveal in Finder")];
 451     [o_mm_mi_revealInFinder setTitle: _NS("Reveal in Finder")];
 452     [[o_mm_mi_revealInFinder menu] setAutoenablesItems: NO];
 453     [o_mi_sort_name setTitle: _NS("Sort Node by Name")];
 454     [o_mi_sort_author setTitle: _NS("Sort Node by Author")];
 455     [o_mi_services setTitle: _NS("Services discovery")];
 456     [o_mm_mi_services setTitle: _NS("Services discovery")];
 457     [o_status_field setStringValue: _NS("No items in the playlist")];
 458
 459     [o_search_field setToolTip: _NS("Search in Playlist")];
 460     [o_mi_addNode setTitle: _NS("Add Folder to Playlist")];
 461
 462     [o_save_accessory_text setStringValue: _NS("File Format:")];
 463     [[o_save_accessory_popup itemAtIndex:0] setTitle: _NS("Extended M3U")];
 464     [[o_save_accessory_popup itemAtIndex:1] setTitle: _NS("XML Shareable Playlist Format (XSPF)")];
 465 }
 466
 467 - (void)playlistUpdated
 468 {
 469     /* Clear indications of any existing column sorting */
 470     for( unsigned int i = 0 ; i < [[o_outline_view tableColumns] count] ; i++ )
 471     {
 472         [o_outline_view setIndicatorImage:nil inTableColumn:
 473                             [[o_outline_view tableColumns] objectAtIndex:i]];
 474     }
 475
 476     [o_outline_view setHighlightedTableColumn:nil];
 477     o_tc_sortColumn = nil;
 478     // TODO Find a way to keep the dict size to a minimum
 479     //[o_outline_dict removeAllObjects];
 480     [o_outline_view reloadData];
 481     [[[[VLCMain sharedInstance] getWizard] getPlaylistWizard] reloadOutlineView];
 482     [[[[VLCMain sharedInstance] getBookmarks] getDataTable] reloadData];
 483
 484     playlist_t *p_playlist = pl_Hold( VLCIntf );
 485
 486     PL_LOCK;
 487     if( playlist_CurrentSize( p_playlist ) >= 2 )
 488     {
 489         [o_status_field setStringValue: [NSString stringWithFormat:
 490                     _NS("%i items"),
 491                 playlist_CurrentSize( p_playlist )]];
 492     }
 493     else
 494     {
 495         if( playlist_IsEmpty( p_playlist ) )
 496             [o_status_field setStringValue: _NS("No items in the playlist")];
 497         else
 498             [o_status_field setStringValue: _NS("1 item")];
 499     }
 500     PL_UNLOCK;
 501     pl_Release( VLCIntf );
 502
 503     [self outlineViewSelectionDidChange: nil];
 504 }
 505
 506 - (void)playModeUpdated
 507 {
 508     playlist_t *p_playlist = pl_Hold( VLCIntf );
 509
 510     bool loop = var_GetBool( p_playlist, "loop" );
 511     bool repeat = var_GetBool( p_playlist, "repeat" );
 512     if( repeat )
 513         [[[VLCMain sharedInstance] getControls] repeatOne];
 514     else if( loop )
 515         [[[VLCMain sharedInstance] getControls] repeatAll];
 516     else
 517         [[[VLCMain sharedInstance] getControls] repeatOff];
 518
 519     [[[VLCMain sharedInstance] getControls] shuffle];
 520
 521     pl_Release( VLCIntf );
 522 }
 523
 524 - (void)outlineViewSelectionDidChange:(NSNotification *)notification
 525 {
 526     // FIXME: unsafe
 527     playlist_item_t * p_item = [[o_outline_view itemAtRow:[o_outline_view selectedRow]] pointerValue];
 528
 529     if( p_item )
 530     {
 531         /* update the state of our Reveal-in-Finder menu items */
 532         NSMutableString *o_mrl;
 533         char *psz_uri = input_item_GetURI( p_item->p_input );
 534         if( psz_uri )
 535         {
 536             o_mrl = [NSMutableString stringWithUTF8String: psz_uri];
 537
 538             /* perform some checks whether it is a file and if it is local at all... */
 539             NSRange prefix_range = [o_mrl rangeOfString: @"file:"];
 540             if( prefix_range.location != NSNotFound )
 541                 [o_mrl deleteCharactersInRange: prefix_range];
 542
 543             if( [o_mrl characterAtIndex:0] == '/' )
 544             {
 545                 [o_mi_revealInFinder setEnabled: YES];
 546                 [o_mm_mi_revealInFinder setEnabled: YES];
 547                 return;
 548             }
 549         }
 550         [o_mi_revealInFinder setEnabled: NO];
 551         [o_mm_mi_revealInFinder setEnabled: NO];
 552
 553         if( [[VLCMain sharedInstance] isPlaylistCollapsed] == NO )
 554         {
 555             /* update our info-panel to reflect the new item, if we aren't collapsed */
 556             [[[VLCMain sharedInstance] getInfo] updatePanelWithItem:p_item->p_input];
 557         }
 558     }
 559 }
 560
 561 - (BOOL)isSelectionEmpty
 562 {
 563     return [o_outline_view selectedRow] == -1;
 564 }
 565
 566 - (void)updateRowSelection
 567 {
 568     int i_row;
 569     unsigned int j;
 570
 571     // FIXME: unsafe
 572     playlist_t *p_playlist = pl_Hold( VLCIntf );
 573     playlist_item_t *p_item, *p_temp_item;
 574     NSMutableArray *o_array = [NSMutableArray array];
 575
 576     PL_LOCK;
 577     p_item = playlist_CurrentPlayingItem( p_playlist );
 578     if( p_item == NULL )
 579     {
 580         PL_UNLOCK;
 581         pl_Release( VLCIntf );
 582         return;
 583     }
 584
 585     p_temp_item = p_item;
 586     while( p_temp_item->p_parent )
 587     {
 588         [o_array insertObject: [NSValue valueWithPointer: p_temp_item] atIndex: 0];
 589         p_temp_item = p_temp_item->p_parent;
 590     }
 591
 592     for( j = 0; j < [o_array count] - 1; j++ )
 593     {
 594         id o_item;
 595         if( ( o_item = [o_outline_dict objectForKey:
 596                             [NSString stringWithFormat: @"%p",
 597                             [[o_array objectAtIndex:j] pointerValue]]] ) != nil )
 598         {
 599             [o_outline_view expandItem: o_item];
 600         }
 601
 602     }
 603
 604     PL_UNLOCK;
 605     pl_Release( VLCIntf );
 606 }
 607
 608 /* Check if p_item is a child of p_node recursively. We need to check the item
 609    existence first since OSX sometimes tries to redraw items that have been
 610    deleted. We don't do it when not required since this verification takes
 611    quite a long time on big playlists (yes, pretty hacky). */
 612
 613 - (BOOL)isItem: (playlist_item_t *)p_item
 614                     inNode: (playlist_item_t *)p_node
 615                     checkItemExistence:(BOOL)b_check
 616                     locked:(BOOL)b_locked
 617
 618 {
 619     playlist_t * p_playlist = pl_Hold( VLCIntf );
 620     playlist_item_t *p_temp_item = p_item;
 621
 622     if( p_node == p_item )
 623     {
 624         pl_Release( VLCIntf );
 625         return YES;
 626     }
 627
 628     if( p_node->i_children < 1)
 629     {
 630         pl_Release( VLCIntf );
 631         return NO;
 632     }
 633
 634     if ( p_temp_item )
 635     {
 636         int i;
 637         if(!b_locked) PL_LOCK;
 638
 639         if( b_check )
 640         {
 641         /* Since outlineView: willDisplayCell:... may call this function with
 642            p_items that don't exist anymore, first check if the item is still
 643            in the playlist. Any cleaner solution welcomed. */
 644             for( i = 0; i < p_playlist->all_items.i_size; i++ )
 645             {
 646                 if( ARRAY_VAL( p_playlist->all_items, i) == p_item ) break;
 647                 else if ( i == p_playlist->all_items.i_size - 1 )
 648                 {
 649                     if(!b_locked) PL_UNLOCK;
 650                     pl_Release( VLCIntf );
 651                     return NO;
 652                 }
 653             }
 654         }
 655
 656         while( p_temp_item )
 657         {
 658             p_temp_item = p_temp_item->p_parent;
 659             if( p_temp_item == p_node )
 660             {
 661                 if(!b_locked) PL_UNLOCK;
 662                 pl_Release( VLCIntf );
 663                 return YES;
 664             }
 665         }
 666         if(!b_locked) PL_UNLOCK;
 667     }
 668
 669     pl_Release( VLCIntf );
 670     return NO;
 671 }
 672
 673 - (BOOL)isItem: (playlist_item_t *)p_item
 674                     inNode: (playlist_item_t *)p_node
 675                     checkItemExistence:(BOOL)b_check
 676 {
 677     [self isItem:p_item inNode:p_node checkItemExistence:b_check locked:NO];
 678 }
 679
 680 /* This method is usefull for instance to remove the selected children of an
 681    already selected node */
 682 - (void)removeItemsFrom:(id)o_items ifChildrenOf:(id)o_nodes
 683 {
 684     unsigned int i, j;
 685     for( i = 0 ; i < [o_items count] ; i++ )
 686     {
 687         for ( j = 0 ; j < [o_nodes count] ; j++ )
 688         {
 689             if( o_items == o_nodes)
 690             {
 691                 if( j == i ) continue;
 692             }
 693             if( [self isItem: [[o_items objectAtIndex:i] pointerValue]
 694                     inNode: [[o_nodes objectAtIndex:j] pointerValue]
 695                     checkItemExistence: NO locked:NO] )
 696             {
 697                 [o_items removeObjectAtIndex:i];
 698                 /* We need to execute the next iteration with the same index
 699                    since the current item has been deleted */
 700                 i--;
 701                 break;
 702             }
 703         }
 704     }
 705 }
 706
 707 - (IBAction)savePlaylist:(id)sender
 708 {
 709     playlist_t * p_playlist = pl_Hold( VLCIntf );
 710
 711     NSSavePanel *o_save_panel = [NSSavePanel savePanel];
 712     NSString * o_name = [NSString stringWithFormat: @"%@", _NS("Untitled")];
 713
 714     //[o_save_panel setAllowedFileTypes: [NSArray arrayWithObjects: @"m3u", @"xpf", nil] ];
 715     [o_save_panel setTitle: _NS("Save Playlist")];
 716     [o_save_panel setPrompt: _NS("Save")];
 717     [o_save_panel setAccessoryView: o_save_accessory_view];
 718
 719     if( [o_save_panel runModalForDirectory: nil
 720             file: o_name] == NSOKButton )
 721     {
 722         NSString *o_filename = [o_save_panel filename];
 723
 724         if( [o_save_accessory_popup indexOfSelectedItem] == 1 )
 725         {
 726             NSString * o_real_filename;
 727             NSRange range;
 728             range.location = [o_filename length] - [@".xspf" length];
 729             range.length = [@".xspf" length];
 730
 731             if( [o_filename compare:@".xspf" options: NSCaseInsensitiveSearch
 732                                              range: range] != NSOrderedSame )
 733             {
 734                 o_real_filename = [NSString stringWithFormat: @"%@.xspf", o_filename];
 735             }
 736             else
 737             {
 738                 o_real_filename = o_filename;
 739             }
 740             playlist_Export( p_playlist,
 741                 [o_real_filename fileSystemRepresentation],
 742                 p_playlist->p_local_category, "export-xspf" );
 743         }
 744         else
 745         {
 746             NSString * o_real_filename;
 747             NSRange range;
 748             range.location = [o_filename length] - [@".m3u" length];
 749             range.length = [@".m3u" length];
 750
 751             if( [o_filename compare:@".m3u" options: NSCaseInsensitiveSearch
 752                                              range: range] != NSOrderedSame )
 753             {
 754                 o_real_filename = [NSString stringWithFormat: @"%@.m3u", o_filename];
 755             }
 756             else
 757             {
 758                 o_real_filename = o_filename;
 759             }
 760             playlist_Export( p_playlist,
 761                 [o_real_filename fileSystemRepresentation],
 762                 p_playlist->p_local_category, "export-m3u" );
 763         }
 764     }
 765     pl_Release( VLCIntf );
 766 }
 767
 768 /* When called retrieves the selected outlineview row and plays that node or item */
 769 - (IBAction)playItem:(id)sender
 770 {
 771     intf_thread_t * p_intf = VLCIntf;
 772     playlist_t * p_playlist = pl_Hold( p_intf );
 773
 774     playlist_item_t *p_item;
 775     playlist_item_t *p_node = NULL;
 776
 777     p_item = [[o_outline_view itemAtRow:[o_outline_view selectedRow]] pointerValue];
 778
 779     if( p_item )
 780     {
 781         if( p_item->i_children == -1 )
 782         {
 783             p_node = p_item->p_parent;
 784
 785         }
 786         else
 787         {
 788             p_node = p_item;
 789             if( p_node->i_children > 0 && p_node->pp_children[0]->i_children == -1 )
 790             {
 791                 p_item = p_node->pp_children[0];
 792             }
 793             else
 794             {
 795                 p_item = NULL;
 796             }
 797         }
 798         playlist_Control( p_playlist, PLAYLIST_VIEWPLAY, pl_Unlocked, p_node, p_item );
 799     }
 800     pl_Release( p_intf );
 801 }
 802
 803 - (IBAction)revealItemInFinder:(id)sender
 804 {
 805     playlist_item_t * p_item = [[o_outline_view itemAtRow:[o_outline_view selectedRow]] pointerValue];
 806     NSMutableString * o_mrl = nil;
 807
 808     if(! p_item || !p_item->p_input )
 809         return;
 810
 811     char *psz_uri = input_item_GetURI( p_item->p_input );
 812     if( psz_uri )
 813         o_mrl = [NSMutableString stringWithUTF8String: psz_uri];
 814
 815     /* perform some checks whether it is a file and if it is local at all... */
 816     NSRange prefix_range = [o_mrl rangeOfString: @"file:"];
 817     if( prefix_range.location != NSNotFound )
 818         [o_mrl deleteCharactersInRange: prefix_range];
 819
 820     if( [o_mrl characterAtIndex:0] == '/' )
 821         [[NSWorkspace sharedWorkspace] selectFile: o_mrl inFileViewerRootedAtPath: o_mrl];
 822 }
 823
 824 /* When called retrieves the selected outlineview row and plays that node or item */
 825 - (IBAction)preparseItem:(id)sender
 826 {
 827     int i_count;
 828     NSMutableArray *o_to_preparse;
 829     intf_thread_t * p_intf = VLCIntf;
 830     playlist_t * p_playlist = pl_Hold( p_intf );
 831
 832     o_to_preparse = [NSMutableArray arrayWithArray:[[o_outline_view selectedRowEnumerator] allObjects]];
 833     i_count = [o_to_preparse count];
 834
 835     int i, i_row;
 836     NSNumber *o_number;
 837     playlist_item_t *p_item = NULL;
 838
 839     for( i = 0; i < i_count; i++ )
 840     {
 841         o_number = [o_to_preparse lastObject];
 842         i_row = [o_number intValue];
 843         p_item = [[o_outline_view itemAtRow:i_row] pointerValue];
 844         [o_to_preparse removeObject: o_number];
 845         [o_outline_view deselectRow: i_row];
 846
 847         if( p_item )
 848         {
 849             if( p_item->i_children == -1 )
 850             {
 851                 playlist_PreparseEnqueue( p_playlist, p_item->p_input, pl_Unlocked );
 852             }
 853             else
 854             {
 855                 msg_Dbg( p_intf, "preparsing nodes not implemented" );
 856             }
 857         }
 858     }
 859     pl_Release( p_intf );
 860     [self playlistUpdated];
 861 }
 862
 863 - (IBAction)downloadCoverArt:(id)sender
 864 {
 865     int i_count;
 866     NSMutableArray *o_to_preparse;
 867     intf_thread_t * p_intf = VLCIntf;
 868     playlist_t * p_playlist = pl_Hold( p_intf );
 869
 870     o_to_preparse = [NSMutableArray arrayWithArray:[[o_outline_view selectedRowEnumerator] allObjects]];
 871     i_count = [o_to_preparse count];
 872
 873     int i, i_row;
 874     NSNumber *o_number;
 875     playlist_item_t *p_item = NULL;
 876
 877     for( i = 0; i < i_count; i++ )
 878     {
 879         o_number = [o_to_preparse lastObject];
 880         i_row = [o_number intValue];
 881         p_item = [[o_outline_view itemAtRow:i_row] pointerValue];
 882         [o_to_preparse removeObject: o_number];
 883         [o_outline_view deselectRow: i_row];
 884
 885         if( p_item && p_item->i_children == -1 )
 886         {
 887             playlist_AskForArtEnqueue( p_playlist, p_item->p_input, pl_Unlocked );
 888         }
 889     }
 890     pl_Release( p_intf );
 891     [self playlistUpdated];
 892 }
 893
 894 - (IBAction)servicesChange:(id)sender
 895 {
 896     NSMenuItem *o_mi = (NSMenuItem *)sender;
 897     NSString *o_string = [o_mi representedObject];
 898     playlist_t * p_playlist = pl_Hold( VLCIntf );
 899     if( !playlist_IsServicesDiscoveryLoaded( p_playlist, [o_string UTF8String] ) )
 900         playlist_ServicesDiscoveryAdd( p_playlist, [o_string UTF8String] );
 901     else
 902         playlist_ServicesDiscoveryRemove( p_playlist, [o_string UTF8String] );
 903
 904     [o_mi setState: playlist_IsServicesDiscoveryLoaded( p_playlist,
 905                                           [o_string UTF8String] ) ? YES : NO];
 906
 907     pl_Release( VLCIntf );
 908     [self playlistUpdated];
 909     return;
 910 }
 911
 912 - (IBAction)selectAll:(id)sender
 913 {
 914     [o_outline_view selectAll: nil];
 915 }
 916
 917 - (IBAction)deleteItem:(id)sender
 918 {
 919     int i_count, i_row;
 920     NSMutableArray *o_to_delete;
 921     NSNumber *o_number;
 922
 923     playlist_t * p_playlist;
 924     intf_thread_t * p_intf = VLCIntf;
 925
 926     o_to_delete = [NSMutableArray arrayWithArray:[[o_outline_view selectedRowEnumerator] allObjects]];
 927     i_count = [o_to_delete count];
 928
 929     p_playlist = pl_Hold( p_intf );
 930
 931     PL_LOCK;
 932     for( int i = 0; i < i_count; i++ )
 933     {
 934         o_number = [o_to_delete lastObject];
 935         i_row = [o_number intValue];
 936         id o_item = [o_outline_view itemAtRow: i_row];
 937         playlist_item_t *p_item = [o_item pointerValue];
 938 #ifndef NDEBUG
 939         msg_Dbg( p_intf, "deleting item %i (of %i) with id \"%i\", pointerValue \"%p\" and %i children", i+1, i_count,
 940                 p_item->p_input->i_id, [o_item pointerValue], p_item->i_children +1 );
 941 #endif
 942         [o_to_delete removeObject: o_number];
 943         [o_outline_view deselectRow: i_row];
 944
 945         if( p_item->i_children != -1 )
 946         //is a node and not an item
 947         {
 948             if( playlist_Status( p_playlist ) != PLAYLIST_STOPPED &&
 949                 [self isItem: playlist_CurrentPlayingItem( p_playlist ) inNode:
 950                         ((playlist_item_t *)[o_item pointerValue])
 951                         checkItemExistence: NO locked:YES] == YES )
 952                 // if current item is in selected node and is playing then stop playlist
 953                 playlist_Control(p_playlist, PLAYLIST_STOP, pl_Locked );
 954
 955             playlist_NodeDelete( p_playlist, p_item, true, false );
 956         }
 957         else
 958             playlist_DeleteFromInput( p_playlist, p_item->p_input->i_id, pl_Locked );
 959     }
 960     PL_UNLOCK;
 961
 962     [self playlistUpdated];
 963     pl_Release( p_intf );
 964 }
 965
 966 - (IBAction)sortNodeByName:(id)sender
 967 {
 968     [self sortNode: SORT_TITLE];
 969 }
 970
 971 - (IBAction)sortNodeByAuthor:(id)sender
 972 {
 973     [self sortNode: SORT_ARTIST];
 974 }
 975
 976 - (void)sortNode:(int)i_mode
 977 {
 978     playlist_t * p_playlist = pl_Hold( VLCIntf );
 979     playlist_item_t * p_item;
 980
 981     if( [o_outline_view selectedRow] > -1 )
 982     {
 983         p_item = [[o_outline_view itemAtRow: [o_outline_view selectedRow]] pointerValue];
 984     }
 985     else
 986     /*If no item is selected, sort the whole playlist*/
 987     {
 988         p_item = p_playlist->p_root_category;
 989     }
 990
 991     if( p_item->i_children > -1 ) // the item is a node
 992     {
 993         PL_LOCK;
 994         playlist_RecursiveNodeSort( p_playlist, p_item, i_mode, ORDER_NORMAL );
 995         PL_UNLOCK;
 996     }
 997     else
 998     {
 999         PL_LOCK;
1000         playlist_RecursiveNodeSort( p_playlist,
1001                 p_item->p_parent, i_mode, ORDER_NORMAL );
1002         PL_UNLOCK;
1003     }
1004     pl_Release( VLCIntf );
1005     [self playlistUpdated];
1006 }
1007
1008 - (input_item_t *)createItem:(NSDictionary *)o_one_item
1009 {
1010     intf_thread_t * p_intf = VLCIntf;
1011     playlist_t * p_playlist = pl_Hold( p_intf );
1012
1013     input_item_t *p_input;
1014     int i;
1015     BOOL b_rem = FALSE, b_dir = FALSE;
1016     NSString *o_uri, *o_name;
1017     NSArray *o_options;
1018     NSURL *o_true_file;
1019
1020     /* Get the item */
1021     o_uri = (NSString *)[o_one_item objectForKey: @"ITEM_URL"];
1022     o_name = (NSString *)[o_one_item objectForKey: @"ITEM_NAME"];
1023     o_options = (NSArray *)[o_one_item objectForKey: @"ITEM_OPTIONS"];
1024
1025     /* Find the name for a disc entry (i know, can you believe the trouble?) */
1026     if( ( !o_name || [o_name isEqualToString:@""] ) && [o_uri rangeOfString: @"/dev/"].location != NSNotFound )
1027     {
1028         int i_count, i_index;
1029         struct statfs *mounts = NULL;
1030
1031         i_count = getmntinfo (&mounts, MNT_NOWAIT);
1032         /* getmntinfo returns a pointer to static data. Do not free. */
1033         for( i_index = 0 ; i_index < i_count; i_index++ )
1034         {
1035             NSMutableString *o_temp, *o_temp2;
1036             o_temp = [NSMutableString stringWithString: o_uri];
1037             o_temp2 = [NSMutableString stringWithUTF8String: mounts[i_index].f_mntfromname];
1038             [o_temp replaceOccurrencesOfString: @"/dev/rdisk" withString: @"/dev/disk" options:NSLiteralSearch range:NSMakeRange(0, [o_temp length]) ];
1039             [o_temp2 replaceOccurrencesOfString: @"s0" withString: @"" options:NSLiteralSearch range:NSMakeRange(0, [o_temp2 length]) ];
1040             [o_temp2 replaceOccurrencesOfString: @"s1" withString: @"" options:NSLiteralSearch range:NSMakeRange(0, [o_temp2 length]) ];
1041
1042             if( strstr( [o_temp fileSystemRepresentation], [o_temp2 fileSystemRepresentation] ) != NULL )
1043             {
1044                 o_name = [[NSFileManager defaultManager] displayNameAtPath: [NSString stringWithUTF8String:mounts[i_index].f_mntonname]];
1045             }
1046         }
1047     }
1048     /* If no name, then make a guess */
1049     if( !o_name) o_name = [[NSFileManager defaultManager] displayNameAtPath: o_uri];
1050
1051     if( [[NSFileManager defaultManager] fileExistsAtPath:o_uri isDirectory:&b_dir] && b_dir &&
1052         [[NSWorkspace sharedWorkspace] getFileSystemInfoForPath: o_uri isRemovable: &b_rem
1053                 isWritable:NULL isUnmountable:NULL description:NULL type:NULL] && b_rem   )
1054     {
1055         /* All of this is to make sure CD's play when you D&D them on VLC */
1056         /* Converts mountpoint to a /dev file */
1057         struct statfs *buf;
1058         char *psz_dev;
1059         NSMutableString *o_temp;
1060
1061         buf = (struct statfs *) malloc (sizeof(struct statfs));
1062         statfs( [o_uri fileSystemRepresentation], buf );
1063         psz_dev = strdup(buf->f_mntfromname);
1064         o_temp = [NSMutableString stringWithUTF8String: psz_dev ];
1065         [o_temp replaceOccurrencesOfString: @"/dev/disk" withString: @"/dev/rdisk" options:NSLiteralSearch range:NSMakeRange(0, [o_temp length]) ];
1066         [o_temp replaceOccurrencesOfString: @"s0" withString: @"" options:NSLiteralSearch range:NSMakeRange(0, [o_temp length]) ];
1067         [o_temp replaceOccurrencesOfString: @"s1" withString: @"" options:NSLiteralSearch range:NSMakeRange(0, [o_temp length]) ];
1068         o_uri = o_temp;
1069     }
1070
1071     p_input = input_item_New( p_playlist, [o_uri fileSystemRepresentation], [o_name UTF8String] );
1072     if( !p_input )
1073     {
1074         pl_Release( p_intf );
1075         return NULL;
1076     }
1077
1078     if( o_options )
1079     {
1080         for( i = 0; i < (int)[o_options count]; i++ )
1081         {
1082             input_item_AddOption( p_input, strdup( [[o_options objectAtIndex:i] UTF8String] ),
1083                                   VLC_INPUT_OPTION_TRUSTED );
1084         }
1085     }
1086
1087     /* Recent documents menu */
1088     o_true_file = [NSURL fileURLWithPath: o_uri];
1089     if( o_true_file != nil && (BOOL)config_GetInt( p_playlist, "macosx-recentitems" ) == YES )
1090     {
1091         [[NSDocumentController sharedDocumentController]
1092             noteNewRecentDocumentURL: o_true_file];
1093     }
1094
1095     pl_Release( p_intf );
1096     return p_input;
1097 }
1098
1099 - (void)appendArray:(NSArray*)o_array atPos:(int)i_position enqueue:(BOOL)b_enqueue
1100 {
1101     int i_item;
1102     playlist_t * p_playlist = pl_Hold( VLCIntf );
1103
1104     PL_LOCK;
1105     for( i_item = 0; i_item < (int)[o_array count]; i_item++ )
1106     {
1107         input_item_t *p_input;
1108         NSDictionary *o_one_item;
1109
1110         /* Get the item */
1111         o_one_item = [o_array objectAtIndex: i_item];
1112         p_input = [self createItem: o_one_item];
1113         if( !p_input )
1114         {
1115             continue;
1116         }
1117
1118         /* Add the item */
1119         /* FIXME: playlist_AddInput() can fail */
1120
1121         playlist_AddInput( p_playlist, p_input, PLAYLIST_INSERT,
1122              i_position == -1 ? PLAYLIST_END : i_position + i_item, true,
1123          pl_Locked );
1124
1125         if( i_item == 0 && !b_enqueue )
1126         {
1127             playlist_item_t *p_item = NULL;
1128             playlist_item_t *p_node = NULL;
1129             p_item = playlist_ItemGetByInput( p_playlist, p_input );
1130             if( p_item )
1131             {
1132                 if( p_item->i_children == -1 )
1133                     p_node = p_item->p_parent;
1134                 else
1135                 {
1136                     p_node = p_item;
1137                     if( p_node->i_children > 0 && p_node->pp_children[0]->i_children == -1 )
1138                         p_item = p_node->pp_children[0];
1139                     else
1140                         p_item = NULL;
1141                 }
1142                 playlist_Control( p_playlist, PLAYLIST_VIEWPLAY, pl_Locked, p_node, p_item );
1143             }
1144         }
1145         vlc_gc_decref( p_input );
1146     }
1147     PL_UNLOCK;
1148
1149     [self playlistUpdated];
1150     pl_Release( VLCIntf );
1151 }
1152
1153 - (void)appendNodeArray:(NSArray*)o_array inNode:(playlist_item_t *)p_node atPos:(int)i_position enqueue:(BOOL)b_enqueue
1154 {
1155     int i_item;
1156     playlist_t * p_playlist = pl_Hold( VLCIntf );
1157
1158     for( i_item = 0; i_item < (int)[o_array count]; i_item++ )
1159     {
1160         input_item_t *p_input;
1161         NSDictionary *o_one_item;
1162
1163         /* Get the item */
1164         o_one_item = [o_array objectAtIndex: i_item];
1165         p_input = [self createItem: o_one_item];
1166
1167         if( !p_input ) continue;
1168
1169         /* Add the item */
1170         /* FIXME: playlist_BothAddInput() can fail */
1171         PL_LOCK;
1172         playlist_BothAddInput( p_playlist, p_input, p_node,
1173                                       PLAYLIST_INSERT,
1174                                       i_position == -1 ?
1175                                       PLAYLIST_END : i_position + i_item,
1176                                       NULL, NULL, pl_Locked );
1177
1178
1179         if( i_item == 0 && !b_enqueue )
1180         {
1181             playlist_item_t *p_item;
1182             p_item = playlist_ItemGetByInput( p_playlist, p_input );
1183             playlist_Control( p_playlist, PLAYLIST_VIEWPLAY, pl_Locked, p_node, p_item );
1184         }
1185         PL_UNLOCK;
1186         vlc_gc_decref( p_input );
1187     }
1188     [self playlistUpdated];
1189     pl_Release( VLCIntf );
1190 }
1191
1192 - (NSMutableArray *)subSearchItem:(playlist_item_t *)p_item
1193 {
1194     playlist_t *p_playlist = pl_Hold( VLCIntf );
1195     playlist_item_t *p_selected_item;
1196     int i_current, i_selected_row;
1197
1198     i_selected_row = [o_outline_view selectedRow];
1199     if (i_selected_row < 0)
1200         i_selected_row = 0;
1201
1202     p_selected_item = (playlist_item_t *)[[o_outline_view itemAtRow:
1203                                             i_selected_row] pointerValue];
1204
1205     for( i_current = 0; i_current < p_item->i_children ; i_current++ )
1206     {
1207         char *psz_temp;
1208         NSString *o_current_name, *o_current_author;
1209
1210         PL_LOCK;
1211         o_current_name = [NSString stringWithUTF8String:
1212             p_item->pp_children[i_current]->p_input->psz_name];
1213         psz_temp = input_item_GetInfo( p_item->p_input ,
1214                    _("Meta-information"),_("Artist") );
1215         o_current_author = [NSString stringWithUTF8String: psz_temp];
1216         free( psz_temp);
1217         PL_UNLOCK;
1218
1219         if( p_selected_item == p_item->pp_children[i_current] &&
1220                     b_selected_item_met == NO )
1221         {
1222             b_selected_item_met = YES;
1223         }
1224         else if( p_selected_item == p_item->pp_children[i_current] &&
1225                     b_selected_item_met == YES )
1226         {
1227             pl_Release( VLCIntf );
1228             return NULL;
1229         }
1230         else if( b_selected_item_met == YES &&
1231                     ( [o_current_name rangeOfString:[o_search_field
1232                         stringValue] options:NSCaseInsensitiveSearch].length ||
1233                       [o_current_author rangeOfString:[o_search_field
1234                         stringValue] options:NSCaseInsensitiveSearch].length ) )
1235         {
1236             pl_Release( VLCIntf );
1237             /*Adds the parent items in the result array as well, so that we can
1238             expand the tree*/
1239             return [NSMutableArray arrayWithObject: [NSValue
1240                             valueWithPointer: p_item->pp_children[i_current]]];
1241         }
1242         if( p_item->pp_children[i_current]->i_children > 0 )
1243         {
1244             id o_result = [self subSearchItem:
1245                                             p_item->pp_children[i_current]];
1246             if( o_result != NULL )
1247             {
1248                 pl_Release( VLCIntf );
1249                 [o_result insertObject: [NSValue valueWithPointer:
1250                                 p_item->pp_children[i_current]] atIndex:0];
1251                 return o_result;
1252             }
1253         }
1254     }
1255     pl_Release( VLCIntf );
1256     return NULL;
1257 }
1258
1259 - (IBAction)searchItem:(id)sender
1260 {
1261     playlist_t * p_playlist = pl_Hold( VLCIntf );
1262     id o_result;
1263
1264     unsigned int i;
1265     int i_row = -1;
1266
1267     b_selected_item_met = NO;
1268
1269         /*First, only search after the selected item:*
1270          *(b_selected_item_met = NO)                 */
1271     o_result = [self subSearchItem:p_playlist->p_root_category];
1272     if( o_result == NULL )
1273     {
1274         /* If the first search failed, search again from the beginning */
1275         o_result = [self subSearchItem:p_playlist->p_root_category];
1276     }
1277     if( o_result != NULL )
1278     {
1279         int i_start;
1280         if( [[o_result objectAtIndex: 0] pointerValue] ==
1281                                                     p_playlist->p_local_category )
1282         i_start = 1;
1283         else
1284         i_start = 0;
1285
1286         for( i = i_start ; i < [o_result count] - 1 ; i++ )
1287         {
1288             [o_outline_view expandItem: [o_outline_dict objectForKey:
1289                         [NSString stringWithFormat: @"%p",
1290                         [[o_result objectAtIndex: i] pointerValue]]]];
1291         }
1292         i_row = [o_outline_view rowForItem: [o_outline_dict objectForKey:
1293                         [NSString stringWithFormat: @"%p",
1294                         [[o_result objectAtIndex: [o_result count] - 1 ]
1295                         pointerValue]]]];
1296     }
1297     if( i_row > -1 )
1298     {
1299         [o_outline_view selectRow:i_row byExtendingSelection: NO];
1300         [o_outline_view scrollRowToVisible: i_row];
1301     }
1302     pl_Release( VLCIntf );
1303 }
1304
1305 - (IBAction)recursiveExpandNode:(id)sender
1306 {
1307     id o_item = [o_outline_view itemAtRow: [o_outline_view selectedRow]];
1308     playlist_item_t *p_item = (playlist_item_t *)[o_item pointerValue];
1309
1310     if( ![[o_outline_view dataSource] outlineView: o_outline_view
1311                                                     isItemExpandable: o_item] )
1312     {
1313         o_item = [o_outline_dict objectForKey: [NSString
1314                    stringWithFormat: @"%p", p_item->p_parent]];
1315     }
1316
1317     /* We need to collapse the node first, since OSX refuses to recursively
1318        expand an already expanded node, even if children nodes are collapsed. */
1319     [o_outline_view collapseItem: o_item collapseChildren: YES];
1320     [o_outline_view expandItem: o_item expandChildren: YES];
1321 }
1322
1323 - (NSMenu *)menuForEvent:(NSEvent *)o_event
1324 {
1325     NSPoint pt;
1326     bool b_rows;
1327     bool b_item_sel;
1328
1329     pt = [o_outline_view convertPoint: [o_event locationInWindow]
1330                                                  fromView: nil];
1331     int row = [o_outline_view rowAtPoint:pt];
1332     if( row != -1 )
1333         [o_outline_view selectRowIndexes:[NSIndexSet indexSetWithIndex:row] byExtendingSelection:NO];
1334
1335     b_item_sel = ( row != -1 && [o_outline_view selectedRow] != -1 );
1336     b_rows = [o_outline_view numberOfRows] != 0;
1337
1338     [o_mi_play setEnabled: b_item_sel];
1339     [o_mi_delete setEnabled: b_item_sel];
1340     [o_mi_selectall setEnabled: b_rows];
1341     [o_mi_info setEnabled: b_item_sel];
1342     [o_mi_preparse setEnabled: b_item_sel];
1343     [o_mi_recursive_expand setEnabled: b_item_sel];
1344     [o_mi_sort_name setEnabled: b_item_sel];
1345     [o_mi_sort_author setEnabled: b_item_sel];
1346
1347     return( o_ctx_menu );
1348 }
1349
1350 - (void)outlineView: (NSOutlineView *)o_tv
1351                   didClickTableColumn:(NSTableColumn *)o_tc
1352 {
1353     int i_mode, i_type = 0;
1354     intf_thread_t *p_intf = VLCIntf;
1355
1356     playlist_t *p_playlist = pl_Hold( p_intf );
1357
1358     /* Check whether the selected table column header corresponds to a
1359        sortable table column*/
1360     if( !( o_tc == o_tc_name || o_tc == o_tc_author ) )
1361     {
1362         pl_Release( p_intf );
1363         return;
1364     }
1365
1366     if( o_tc_sortColumn == o_tc )
1367     {
1368         b_isSortDescending = !b_isSortDescending;
1369     }
1370     else
1371     {
1372         b_isSortDescending = false;
1373     }
1374
1375     if( o_tc == o_tc_name )
1376     {
1377         i_mode = SORT_TITLE;
1378     }
1379     else if( o_tc == o_tc_author )
1380     {
1381         i_mode = SORT_ARTIST;
1382     }
1383
1384     if( b_isSortDescending )
1385     {
1386         i_type = ORDER_REVERSE;
1387     }
1388     else
1389     {
1390         i_type = ORDER_NORMAL;
1391     }
1392
1393     PL_LOCK;
1394     playlist_RecursiveNodeSort( p_playlist, p_playlist->p_root_category, i_mode, i_type );
1395     PL_UNLOCK;
1396
1397     pl_Release( p_intf );
1398     [self playlistUpdated];
1399
1400     o_tc_sortColumn = o_tc;
1401     [o_outline_view setHighlightedTableColumn:o_tc];
1402
1403     if( b_isSortDescending )
1404     {
1405         [o_outline_view setIndicatorImage:o_descendingSortingImage
1406                                                         inTableColumn:o_tc];
1407     }
1408     else
1409     {
1410         [o_outline_view setIndicatorImage:o_ascendingSortingImage
1411                                                         inTableColumn:o_tc];
1412     }
1413 }
1414
1415
1416 - (void)outlineView:(NSOutlineView *)outlineView
1417                                 willDisplayCell:(id)cell
1418                                 forTableColumn:(NSTableColumn *)tableColumn
1419                                 item:(id)item
1420 {
1421     playlist_t *p_playlist = pl_Hold( VLCIntf );
1422
1423     id o_playing_item;
1424
1425     PL_LOCK;
1426     o_playing_item = [o_outline_dict objectForKey:
1427                 [NSString stringWithFormat:@"%p",  playlist_CurrentPlayingItem( p_playlist )]];
1428     PL_UNLOCK;
1429
1430     if( [self isItem: [o_playing_item pointerValue] inNode:
1431                         [item pointerValue] checkItemExistence: YES]
1432                         || [o_playing_item isEqual: item] )
1433     {
1434         [cell setFont: [[NSFontManager sharedFontManager] convertFont:[cell font] toHaveTrait:NSBoldFontMask]];
1435     }
1436     else
1437     {
1438         [cell setFont: [[NSFontManager sharedFontManager] convertFont:[cell font] toNotHaveTrait:NSBoldFontMask]];
1439     }
1440     pl_Release( VLCIntf );
1441 }
1442
1443 - (IBAction)addNode:(id)sender
1444 {
1445     playlist_t * p_playlist = pl_Hold( VLCIntf );
1446     vlc_thread_set_priority( p_playlist, VLC_THREAD_PRIORITY_LOW );
1447
1448     PL_LOCK;
1449     playlist_NodeCreate( p_playlist, _("Empty Folder"),
1450                                       p_playlist->p_local_category, 0, NULL );
1451     PL_UNLOCK;
1452
1453     pl_Release( VLCIntf );
1454
1455     [self playlistUpdated];
1456 }
1457 @end
1458
1459 @implementation VLCPlaylist (NSOutlineViewDataSource)
1460
1461 - (id)outlineView:(NSOutlineView *)outlineView child:(NSInteger)index ofItem:(id)item
1462 {
1463     id o_value = [super outlineView: outlineView child: index ofItem: item];
1464     playlist_t *p_playlist = pl_Hold( VLCIntf );
1465
1466     PL_LOCK;
1467     if( playlist_CurrentSize( p_playlist )  >= 2 )
1468     {
1469         [o_status_field setStringValue: [NSString stringWithFormat:
1470                     _NS("%i items"),
1471              playlist_CurrentSize( p_playlist )]];
1472     }
1473     else
1474     {
1475         if( playlist_IsEmpty( p_playlist ) )
1476         {
1477             [o_status_field setStringValue: _NS("No items in the playlist")];
1478         }
1479         else
1480         {
1481             [o_status_field setStringValue: _NS("1 item")];
1482         }
1483     }
1484     PL_UNLOCK;
1485
1486     pl_Release( VLCIntf );
1487
1488     [o_outline_dict setObject:o_value forKey:[NSString stringWithFormat:@"%p",
1489                                                     [o_value pointerValue]]];
1490     return o_value;
1491
1492 }
1493
1494 /* Required for drag & drop and reordering */
1495 - (BOOL)outlineView:(NSOutlineView *)outlineView writeItems:(NSArray *)items toPasteboard:(NSPasteboard *)pboard
1496 {
1497     unsigned int i;
1498     playlist_t *p_playlist = pl_Hold( VLCIntf );
1499
1500     /* First remove the items that were moved during the last drag & drop
1501        operation */
1502     [o_items_array removeAllObjects];
1503     [o_nodes_array removeAllObjects];
1504
1505     for( i = 0 ; i < [items count] ; i++ )
1506     {
1507         id o_item = [items objectAtIndex: i];
1508
1509         /* Refuse to move items that are not in the General Node
1510            (Service Discovery) */
1511         if( ![self isItem: [o_item pointerValue] inNode:
1512                         p_playlist->p_local_category checkItemExistence: NO] &&
1513             var_CreateGetBool( p_playlist, "media-library" ) &&
1514             ![self isItem: [o_item pointerValue] inNode:
1515                         p_playlist->p_ml_category checkItemExistence: NO] ||
1516             [o_item pointerValue] == p_playlist->p_local_category ||
1517             [o_item pointerValue] == p_playlist->p_ml_category )
1518         {
1519             pl_Release( VLCIntf );
1520             return NO;
1521         }
1522         /* Fill the items and nodes to move in 2 different arrays */
1523         if( ((playlist_item_t *)[o_item pointerValue])->i_children > 0 )
1524             [o_nodes_array addObject: o_item];
1525         else
1526             [o_items_array addObject: o_item];
1527     }
1528
1529     /* Now we need to check if there are selected items that are in already
1530        selected nodes. In that case, we only want to move the nodes */
1531     [self removeItemsFrom: o_nodes_array ifChildrenOf: o_nodes_array];
1532     [self removeItemsFrom: o_items_array ifChildrenOf: o_nodes_array];
1533
1534     /* We add the "VLCPlaylistItemPboardType" type to be able to recognize
1535        a Drop operation coming from the playlist. */
1536
1537     [pboard declareTypes: [NSArray arrayWithObjects:
1538         @"VLCPlaylistItemPboardType", nil] owner: self];
1539     [pboard setData:[NSData data] forType:@"VLCPlaylistItemPboardType"];
1540
1541     pl_Release( VLCIntf );
1542     return YES;
1543 }
1544
1545 - (NSDragOperation)outlineView:(NSOutlineView *)outlineView validateDrop:(id <NSDraggingInfo>)info proposedItem:(id)item proposedChildIndex:(NSInteger)index
1546 {
1547     playlist_t *p_playlist = pl_Hold( VLCIntf );
1548     NSPasteboard *o_pasteboard = [info draggingPasteboard];
1549
1550     if( !p_playlist ) return NSDragOperationNone;
1551
1552     /* Dropping ON items is not allowed if item is not a node */
1553     if( item )
1554     {
1555         if( index == NSOutlineViewDropOnItemIndex &&
1556                 ((playlist_item_t *)[item pointerValue])->i_children == -1 )
1557         {
1558             pl_Release( VLCIntf );
1559             return NSDragOperationNone;
1560         }
1561     }
1562
1563     /* Don't allow on drop on playlist root element's child */
1564     if( !item && index != NSOutlineViewDropOnItemIndex)
1565     {
1566         pl_Release( VLCIntf );
1567         return NSDragOperationNone;
1568     }
1569
1570     /* We refuse to drop an item in anything else than a child of the General
1571        Node. We still accept items that would be root nodes of the outlineview
1572        however, to allow drop in an empty playlist. */
1573     if( !( ([self isItem: [item pointerValue] inNode: p_playlist->p_local_category checkItemExistence: NO] ||
1574         ( var_CreateGetBool( p_playlist, "media-library" ) && [self isItem: [item pointerValue] inNode: p_playlist->p_ml_category checkItemExistence: NO] ) ) || item == nil ) )
1575     {
1576         pl_Release( VLCIntf );
1577         return NSDragOperationNone;
1578     }
1579
1580     /* Drop from the Playlist */
1581     if( [[o_pasteboard types] containsObject: @"VLCPlaylistItemPboardType"] )
1582     {
1583         unsigned int i;
1584         for( i = 0 ; i < [o_nodes_array count] ; i++ )
1585         {
1586             /* We refuse to Drop in a child of an item we are moving */
1587             if( [self isItem: [item pointerValue] inNode:
1588                     [[o_nodes_array objectAtIndex: i] pointerValue]
1589                     checkItemExistence: NO] )
1590             {
1591                 pl_Release( VLCIntf );
1592                 return NSDragOperationNone;
1593             }
1594         }
1595         pl_Release( VLCIntf );
1596         return NSDragOperationMove;
1597     }
1598
1599     /* Drop from the Finder */
1600     else if( [[o_pasteboard types] containsObject: NSFilenamesPboardType] )
1601     {
1602         pl_Release( VLCIntf );
1603         return NSDragOperationGeneric;
1604     }
1605     pl_Release( VLCIntf );
1606     return NSDragOperationNone;
1607 }
1608
1609 - (BOOL)outlineView:(NSOutlineView *)outlineView acceptDrop:(id <NSDraggingInfo>)info item:(id)item childIndex:(NSInteger)index
1610 {
1611     playlist_t * p_playlist =  pl_Hold( VLCIntf );
1612     NSPasteboard *o_pasteboard = [info draggingPasteboard];
1613
1614     /* Drag & Drop inside the playlist */
1615     if( [[o_pasteboard types] containsObject: @"VLCPlaylistItemPboardType"] )
1616     {
1617         int i_row, i_removed_from_node = 0;
1618         unsigned int i;
1619         playlist_item_t *p_new_parent, *p_item = NULL;
1620         NSArray *o_all_items = [o_nodes_array arrayByAddingObjectsFromArray:
1621                                                                 o_items_array];
1622         /* If the item is to be dropped as root item of the outline, make it a
1623            child of the General node.
1624            Else, choose the proposed parent as parent. */
1625         if( item == nil ) p_new_parent = p_playlist->p_local_category;
1626         else p_new_parent = [item pointerValue];
1627
1628         /* Make sure the proposed parent is a node.
1629            (This should never be true) */
1630         if( p_new_parent->i_children < 0 )
1631         {
1632             pl_Release( VLCIntf );
1633             return NO;
1634         }
1635
1636         for( i = 0; i < [o_all_items count]; i++ )
1637         {
1638             playlist_item_t *p_old_parent = NULL;
1639             int i_old_index = 0;
1640
1641             p_item = [[o_all_items objectAtIndex:i] pointerValue];
1642             p_old_parent = p_item->p_parent;
1643             if( !p_old_parent )
1644             continue;
1645             /* We may need the old index later */
1646             if( p_new_parent == p_old_parent )
1647             {
1648                 int j;
1649                 for( j = 0; j < p_old_parent->i_children; j++ )
1650                 {
1651                     if( p_old_parent->pp_children[j] == p_item )
1652                     {
1653                         i_old_index = j;
1654                         break;
1655                     }
1656                 }
1657             }
1658
1659             PL_LOCK;
1660             // Actually detach the item from the old position
1661             if( playlist_NodeRemoveItem( p_playlist, p_item, p_old_parent ) ==
1662                 VLC_SUCCESS )
1663             {
1664                 int i_new_index;
1665                 /* Calculate the new index */
1666                 if( index == -1 )
1667                 i_new_index = -1;
1668                 /* If we move the item in the same node, we need to take into
1669                    account that one item will be deleted */
1670                 else
1671                 {
1672                     if ((p_new_parent == p_old_parent &&
1673                                    i_old_index < index + (int)i) )
1674                     {
1675                         i_removed_from_node++;
1676                     }
1677                     i_new_index = index + i - i_removed_from_node;
1678                 }
1679                 // Reattach the item to the new position
1680                 playlist_NodeInsert( p_playlist, p_item, p_new_parent, i_new_index );
1681             }
1682             PL_UNLOCK;
1683         }
1684         [self playlistUpdated];
1685         i_row = [o_outline_view rowForItem:[o_outline_dict
1686             objectForKey:[NSString stringWithFormat: @"%p",
1687             [[o_all_items objectAtIndex: 0] pointerValue]]]];
1688
1689         if( i_row == -1 )
1690         {
1691             i_row = [o_outline_view rowForItem:[o_outline_dict
1692             objectForKey:[NSString stringWithFormat: @"%p", p_new_parent]]];
1693         }
1694
1695         [o_outline_view deselectAll: self];
1696         [o_outline_view selectRow: i_row byExtendingSelection: NO];
1697         [o_outline_view scrollRowToVisible: i_row];
1698
1699         pl_Release( VLCIntf );
1700         return YES;
1701     }
1702
1703     else if( [[o_pasteboard types] containsObject: NSFilenamesPboardType] )
1704     {
1705         int i;
1706         playlist_item_t *p_node = [item pointerValue];
1707
1708         NSArray *o_array = [NSArray array];
1709         NSArray *o_values = [[o_pasteboard propertyListForType:
1710                                         NSFilenamesPboardType]
1711                                 sortedArrayUsingSelector:
1712                                         @selector(caseInsensitiveCompare:)];
1713
1714         for( i = 0; i < (int)[o_values count]; i++)
1715         {
1716             NSDictionary *o_dic;
1717             o_dic = [NSDictionary dictionaryWithObject:[o_values
1718                         objectAtIndex:i] forKey:@"ITEM_URL"];
1719             o_array = [o_array arrayByAddingObject: o_dic];
1720         }
1721
1722         if ( item == nil )
1723         {
1724             [self appendArray:o_array atPos:index enqueue: YES];
1725         }
1726         else
1727         {
1728             assert( p_node->i_children != -1 );
1729             [self appendNodeArray:o_array inNode: p_node
1730                 atPos:index enqueue:YES];
1731         }
1732         pl_Release( VLCIntf );
1733         return YES;
1734     }
1735     pl_Release( VLCIntf );
1736     return NO;
1737 }
1738 @end
1739
1740