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     vlc_object_release( p_playlist );
 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     vlc_object_release( p_playlist );
 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         vlc_object_release( p_playlist );
 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     vlc_object_release( p_playlist );
 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     vlc_object_release( p_playlist );
 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     vlc_object_release( p_playlist );
 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     PL_UNLOCK;
 579     if( p_item == NULL )
 580     {
 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_Release( VLCIntf );
 605 }
 606
 607 /* Check if p_item is a child of p_node recursively. We need to check the item
 608    existence first since OSX sometimes tries to redraw items that have been
 609    deleted. We don't do it when not required since this verification takes
 610    quite a long time on big playlists (yes, pretty hacky). */
 611
 612 - (BOOL)isItem: (playlist_item_t *)p_item
 613                     inNode: (playlist_item_t *)p_node
 614                     checkItemExistence:(BOOL)b_check
 615                     locked:(BOOL)b_locked
 616
 617 {
 618     playlist_t * p_playlist = pl_Hold( VLCIntf );
 619     playlist_item_t *p_temp_item = p_item;
 620
 621     if( p_node == p_item )
 622     {
 623         vlc_object_release(p_playlist);
 624         return YES;
 625     }
 626
 627     if( p_node->i_children < 1)
 628     {
 629         vlc_object_release(p_playlist);
 630         return NO;
 631     }
 632
 633     if ( p_temp_item )
 634     {
 635         int i;
 636         if(!b_locked) PL_LOCK;
 637
 638         if( b_check )
 639         {
 640         /* Since outlineView: willDisplayCell:... may call this function with
 641            p_items that don't exist anymore, first check if the item is still
 642            in the playlist. Any cleaner solution welcomed. */
 643             for( i = 0; i < p_playlist->all_items.i_size; i++ )
 644             {
 645                 if( ARRAY_VAL( p_playlist->all_items, i) == p_item ) break;
 646                 else if ( i == p_playlist->all_items.i_size - 1 )
 647                 {
 648                     if(!b_locked) PL_UNLOCK;
 649                     vlc_object_release( p_playlist );
 650                     return NO;
 651                 }
 652             }
 653         }
 654
 655         while( p_temp_item )
 656         {
 657             p_temp_item = p_temp_item->p_parent;
 658             if( p_temp_item == p_node )
 659             {
 660                 if(!b_locked) PL_UNLOCK;
 661                 vlc_object_release( p_playlist );
 662                 return YES;
 663             }
 664         }
 665         if(!b_locked) PL_UNLOCK;
 666     }
 667
 668     vlc_object_release( p_playlist );
 669     return NO;
 670 }
 671
 672 - (BOOL)isItem: (playlist_item_t *)p_item
 673                     inNode: (playlist_item_t *)p_node
 674                     checkItemExistence:(BOOL)b_check
 675 {
 676     [self isItem:p_item inNode:p_node checkItemExistence:b_check locked:NO];
 677 }
 678
 679 /* This method is usefull for instance to remove the selected children of an
 680    already selected node */
 681 - (void)removeItemsFrom:(id)o_items ifChildrenOf:(id)o_nodes
 682 {
 683     unsigned int i, j;
 684     for( i = 0 ; i < [o_items count] ; i++ )
 685     {
 686         for ( j = 0 ; j < [o_nodes count] ; j++ )
 687         {
 688             if( o_items == o_nodes)
 689             {
 690                 if( j == i ) continue;
 691             }
 692             if( [self isItem: [[o_items objectAtIndex:i] pointerValue]
 693                     inNode: [[o_nodes objectAtIndex:j] pointerValue]
 694                     checkItemExistence: NO locked:NO] )
 695             {
 696                 [o_items removeObjectAtIndex:i];
 697                 /* We need to execute the next iteration with the same index
 698                    since the current item has been deleted */
 699                 i--;
 700                 break;
 701             }
 702         }
 703     }
 704 }
 705
 706 - (IBAction)savePlaylist:(id)sender
 707 {
 708     playlist_t * p_playlist = pl_Hold( VLCIntf );
 709
 710     NSSavePanel *o_save_panel = [NSSavePanel savePanel];
 711     NSString * o_name = [NSString stringWithFormat: @"%@", _NS("Untitled")];
 712
 713     //[o_save_panel setAllowedFileTypes: [NSArray arrayWithObjects: @"m3u", @"xpf", nil] ];
 714     [o_save_panel setTitle: _NS("Save Playlist")];
 715     [o_save_panel setPrompt: _NS("Save")];
 716     [o_save_panel setAccessoryView: o_save_accessory_view];
 717
 718     if( [o_save_panel runModalForDirectory: nil
 719             file: o_name] == NSOKButton )
 720     {
 721         NSString *o_filename = [o_save_panel filename];
 722
 723         if( [o_save_accessory_popup indexOfSelectedItem] == 1 )
 724         {
 725             NSString * o_real_filename;
 726             NSRange range;
 727             range.location = [o_filename length] - [@".xspf" length];
 728             range.length = [@".xspf" length];
 729
 730             if( [o_filename compare:@".xspf" options: NSCaseInsensitiveSearch
 731                                              range: range] != NSOrderedSame )
 732             {
 733                 o_real_filename = [NSString stringWithFormat: @"%@.xspf", o_filename];
 734             }
 735             else
 736             {
 737                 o_real_filename = o_filename;
 738             }
 739             playlist_Export( p_playlist,
 740                 [o_real_filename fileSystemRepresentation],
 741                 p_playlist->p_local_category, "export-xspf" );
 742         }
 743         else
 744         {
 745             NSString * o_real_filename;
 746             NSRange range;
 747             range.location = [o_filename length] - [@".m3u" length];
 748             range.length = [@".m3u" length];
 749
 750             if( [o_filename compare:@".m3u" options: NSCaseInsensitiveSearch
 751                                              range: range] != NSOrderedSame )
 752             {
 753                 o_real_filename = [NSString stringWithFormat: @"%@.m3u", o_filename];
 754             }
 755             else
 756             {
 757                 o_real_filename = o_filename;
 758             }
 759             playlist_Export( p_playlist,
 760                 [o_real_filename fileSystemRepresentation],
 761                 p_playlist->p_local_category, "export-m3u" );
 762         }
 763     }
 764     vlc_object_release( p_playlist );
 765 }
 766
 767 /* When called retrieves the selected outlineview row and plays that node or item */
 768 - (IBAction)playItem:(id)sender
 769 {
 770     intf_thread_t * p_intf = VLCIntf;
 771     playlist_t * p_playlist = pl_Hold( p_intf );
 772
 773     playlist_item_t *p_item;
 774     playlist_item_t *p_node = NULL;
 775
 776     p_item = [[o_outline_view itemAtRow:[o_outline_view selectedRow]] pointerValue];
 777
 778     if( p_item )
 779     {
 780         if( p_item->i_children == -1 )
 781         {
 782             p_node = p_item->p_parent;
 783
 784         }
 785         else
 786         {
 787             p_node = p_item;
 788             if( p_node->i_children > 0 && p_node->pp_children[0]->i_children == -1 )
 789             {
 790                 p_item = p_node->pp_children[0];
 791             }
 792             else
 793             {
 794                 p_item = NULL;
 795             }
 796         }
 797         playlist_Control( p_playlist, PLAYLIST_VIEWPLAY, pl_Unlocked, p_node, p_item );
 798     }
 799     vlc_object_release( p_playlist );
 800 }
 801
 802 - (IBAction)revealItemInFinder:(id)sender
 803 {
 804     playlist_item_t * p_item = [[o_outline_view itemAtRow:[o_outline_view selectedRow]] pointerValue];
 805     NSMutableString * o_mrl = nil;
 806
 807     if(! p_item || !p_item->p_input )
 808         return;
 809
 810     char *psz_uri = input_item_GetURI( p_item->p_input );
 811     if( psz_uri )
 812         o_mrl = [NSMutableString stringWithUTF8String: psz_uri];
 813
 814     /* perform some checks whether it is a file and if it is local at all... */
 815     NSRange prefix_range = [o_mrl rangeOfString: @"file:"];
 816     if( prefix_range.location != NSNotFound )
 817         [o_mrl deleteCharactersInRange: prefix_range];
 818
 819     if( [o_mrl characterAtIndex:0] == '/' )
 820         [[NSWorkspace sharedWorkspace] selectFile: o_mrl inFileViewerRootedAtPath: o_mrl];
 821 }
 822
 823 /* When called retrieves the selected outlineview row and plays that node or item */
 824 - (IBAction)preparseItem:(id)sender
 825 {
 826     int i_count;
 827     NSMutableArray *o_to_preparse;
 828     intf_thread_t * p_intf = VLCIntf;
 829     playlist_t * p_playlist = pl_Hold( p_intf );
 830
 831     o_to_preparse = [NSMutableArray arrayWithArray:[[o_outline_view selectedRowEnumerator] allObjects]];
 832     i_count = [o_to_preparse count];
 833
 834     int i, i_row;
 835     NSNumber *o_number;
 836     playlist_item_t *p_item = NULL;
 837
 838     for( i = 0; i < i_count; i++ )
 839     {
 840         o_number = [o_to_preparse lastObject];
 841         i_row = [o_number intValue];
 842         p_item = [[o_outline_view itemAtRow:i_row] pointerValue];
 843         [o_to_preparse removeObject: o_number];
 844         [o_outline_view deselectRow: i_row];
 845
 846         if( p_item )
 847         {
 848             if( p_item->i_children == -1 )
 849             {
 850                 playlist_PreparseEnqueue( p_playlist, p_item->p_input, pl_Unlocked );
 851             }
 852             else
 853             {
 854                 msg_Dbg( p_intf, "preparsing nodes not implemented" );
 855             }
 856         }
 857     }
 858     vlc_object_release( p_playlist );
 859     [self playlistUpdated];
 860 }
 861
 862 - (IBAction)downloadCoverArt:(id)sender
 863 {
 864     int i_count;
 865     NSMutableArray *o_to_preparse;
 866     intf_thread_t * p_intf = VLCIntf;
 867     playlist_t * p_playlist = pl_Hold( p_intf );
 868
 869     o_to_preparse = [NSMutableArray arrayWithArray:[[o_outline_view selectedRowEnumerator] allObjects]];
 870     i_count = [o_to_preparse count];
 871
 872     int i, i_row;
 873     NSNumber *o_number;
 874     playlist_item_t *p_item = NULL;
 875
 876     for( i = 0; i < i_count; i++ )
 877     {
 878         o_number = [o_to_preparse lastObject];
 879         i_row = [o_number intValue];
 880         p_item = [[o_outline_view itemAtRow:i_row] pointerValue];
 881         [o_to_preparse removeObject: o_number];
 882         [o_outline_view deselectRow: i_row];
 883
 884         if( p_item && p_item->i_children == -1 )
 885         {
 886             playlist_AskForArtEnqueue( p_playlist, p_item->p_input, pl_Unlocked );
 887         }
 888     }
 889     vlc_object_release( p_playlist );
 890     [self playlistUpdated];
 891 }
 892
 893 - (IBAction)servicesChange:(id)sender
 894 {
 895     NSMenuItem *o_mi = (NSMenuItem *)sender;
 896     NSString *o_string = [o_mi representedObject];
 897     playlist_t * p_playlist = pl_Hold( VLCIntf );
 898     if( !playlist_IsServicesDiscoveryLoaded( p_playlist, [o_string UTF8String] ) )
 899         playlist_ServicesDiscoveryAdd( p_playlist, [o_string UTF8String] );
 900     else
 901         playlist_ServicesDiscoveryRemove( p_playlist, [o_string UTF8String] );
 902
 903     [o_mi setState: playlist_IsServicesDiscoveryLoaded( p_playlist,
 904                                           [o_string UTF8String] ) ? YES : NO];
 905
 906     vlc_object_release( p_playlist );
 907     [self playlistUpdated];
 908     return;
 909 }
 910
 911 - (IBAction)selectAll:(id)sender
 912 {
 913     [o_outline_view selectAll: nil];
 914 }
 915
 916 - (IBAction)deleteItem:(id)sender
 917 {
 918     int i_count, i_row;
 919     NSMutableArray *o_to_delete;
 920     NSNumber *o_number;
 921
 922     playlist_t * p_playlist;
 923     intf_thread_t * p_intf = VLCIntf;
 924
 925     o_to_delete = [NSMutableArray arrayWithArray:[[o_outline_view selectedRowEnumerator] allObjects]];
 926     i_count = [o_to_delete count];
 927
 928     p_playlist = pl_Hold( p_intf );
 929
 930     PL_LOCK;
 931     for( int i = 0; i < i_count; i++ )
 932     {
 933         o_number = [o_to_delete lastObject];
 934         i_row = [o_number intValue];
 935         id o_item = [o_outline_view itemAtRow: i_row];
 936         playlist_item_t *p_item = [o_item pointerValue];
 937 #ifndef NDEBUG
 938         msg_Dbg( p_intf, "deleting item %i (of %i) with id \"%i\", pointerValue \"%p\" and %i children", i+1, i_count,
 939                 p_item->p_input->i_id, [o_item pointerValue], p_item->i_children +1 );
 940 #endif
 941         [o_to_delete removeObject: o_number];
 942         [o_outline_view deselectRow: i_row];
 943
 944         if( p_item->i_children != -1 )
 945         //is a node and not an item
 946         {
 947             if( playlist_Status( p_playlist ) != PLAYLIST_STOPPED &&
 948                 [self isItem: playlist_CurrentPlayingItem( p_playlist ) inNode:
 949                         ((playlist_item_t *)[o_item pointerValue])
 950                         checkItemExistence: NO locked:YES] == YES )
 951                 // if current item is in selected node and is playing then stop playlist
 952                 playlist_Control(p_playlist, PLAYLIST_STOP, pl_Locked );
 953
 954             playlist_NodeDelete( p_playlist, p_item, true, false );
 955         }
 956         else
 957             playlist_DeleteFromInput( p_playlist, p_item->p_input->i_id, pl_Locked );
 958     }
 959     PL_UNLOCK;
 960
 961     [self playlistUpdated];
 962     vlc_object_release( p_playlist );
 963 }
 964
 965 - (IBAction)sortNodeByName:(id)sender
 966 {
 967     [self sortNode: SORT_TITLE];
 968 }
 969
 970 - (IBAction)sortNodeByAuthor:(id)sender
 971 {
 972     [self sortNode: SORT_ARTIST];
 973 }
 974
 975 - (void)sortNode:(int)i_mode
 976 {
 977     playlist_t * p_playlist = pl_Hold( VLCIntf );
 978     playlist_item_t * p_item;
 979
 980     if( [o_outline_view selectedRow] > -1 )
 981     {
 982         p_item = [[o_outline_view itemAtRow: [o_outline_view selectedRow]] pointerValue];
 983     }
 984     else
 985     /*If no item is selected, sort the whole playlist*/
 986     {
 987         p_item = p_playlist->p_root_category;
 988     }
 989
 990     if( p_item->i_children > -1 ) // the item is a node
 991     {
 992         PL_LOCK;
 993         playlist_RecursiveNodeSort( p_playlist, p_item, i_mode, ORDER_NORMAL );
 994         PL_UNLOCK;
 995     }
 996     else
 997     {
 998         PL_LOCK;
 999         playlist_RecursiveNodeSort( p_playlist,
1000                 p_item->p_parent, i_mode, ORDER_NORMAL );
1001         PL_UNLOCK;
1002     }
1003     vlc_object_release( p_playlist );
1004     [self playlistUpdated];
1005 }
1006
1007 - (input_item_t *)createItem:(NSDictionary *)o_one_item
1008 {
1009     intf_thread_t * p_intf = VLCIntf;
1010     playlist_t * p_playlist = pl_Hold( p_intf );
1011
1012     input_item_t *p_input;
1013     int i;
1014     BOOL b_rem = FALSE, b_dir = FALSE;
1015     NSString *o_uri, *o_name;
1016     NSArray *o_options;
1017     NSURL *o_true_file;
1018
1019     /* Get the item */
1020     o_uri = (NSString *)[o_one_item objectForKey: @"ITEM_URL"];
1021     o_name = (NSString *)[o_one_item objectForKey: @"ITEM_NAME"];
1022     o_options = (NSArray *)[o_one_item objectForKey: @"ITEM_OPTIONS"];
1023
1024     /* Find the name for a disc entry (i know, can you believe the trouble?) */
1025     if( ( !o_name || [o_name isEqualToString:@""] ) && [o_uri rangeOfString: @"/dev/"].location != NSNotFound )
1026     {
1027         int i_count, i_index;
1028         struct statfs *mounts = NULL;
1029
1030         i_count = getmntinfo (&mounts, MNT_NOWAIT);
1031         /* getmntinfo returns a pointer to static data. Do not free. */
1032         for( i_index = 0 ; i_index < i_count; i_index++ )
1033         {
1034             NSMutableString *o_temp, *o_temp2;
1035             o_temp = [NSMutableString stringWithString: o_uri];
1036             o_temp2 = [NSMutableString stringWithUTF8String: mounts[i_index].f_mntfromname];
1037             [o_temp replaceOccurrencesOfString: @"/dev/rdisk" withString: @"/dev/disk" options:NSLiteralSearch range:NSMakeRange(0, [o_temp length]) ];
1038             [o_temp2 replaceOccurrencesOfString: @"s0" withString: @"" options:NSLiteralSearch range:NSMakeRange(0, [o_temp2 length]) ];
1039             [o_temp2 replaceOccurrencesOfString: @"s1" withString: @"" options:NSLiteralSearch range:NSMakeRange(0, [o_temp2 length]) ];
1040
1041             if( strstr( [o_temp fileSystemRepresentation], [o_temp2 fileSystemRepresentation] ) != NULL )
1042             {
1043                 o_name = [[NSFileManager defaultManager] displayNameAtPath: [NSString stringWithUTF8String:mounts[i_index].f_mntonname]];
1044             }
1045         }
1046     }
1047     /* If no name, then make a guess */
1048     if( !o_name) o_name = [[NSFileManager defaultManager] displayNameAtPath: o_uri];
1049
1050     if( [[NSFileManager defaultManager] fileExistsAtPath:o_uri isDirectory:&b_dir] && b_dir &&
1051         [[NSWorkspace sharedWorkspace] getFileSystemInfoForPath: o_uri isRemovable: &b_rem
1052                 isWritable:NULL isUnmountable:NULL description:NULL type:NULL] && b_rem   )
1053     {
1054         /* All of this is to make sure CD's play when you D&D them on VLC */
1055         /* Converts mountpoint to a /dev file */
1056         struct statfs *buf;
1057         char *psz_dev;
1058         NSMutableString *o_temp;
1059
1060         buf = (struct statfs *) malloc (sizeof(struct statfs));
1061         statfs( [o_uri fileSystemRepresentation], buf );
1062         psz_dev = strdup(buf->f_mntfromname);
1063         o_temp = [NSMutableString stringWithUTF8String: psz_dev ];
1064         [o_temp replaceOccurrencesOfString: @"/dev/disk" withString: @"/dev/rdisk" options:NSLiteralSearch range:NSMakeRange(0, [o_temp length]) ];
1065         [o_temp replaceOccurrencesOfString: @"s0" withString: @"" options:NSLiteralSearch range:NSMakeRange(0, [o_temp length]) ];
1066         [o_temp replaceOccurrencesOfString: @"s1" withString: @"" options:NSLiteralSearch range:NSMakeRange(0, [o_temp length]) ];
1067         o_uri = o_temp;
1068     }
1069
1070     p_input = input_item_New( p_playlist, [o_uri fileSystemRepresentation], [o_name UTF8String] );
1071     if( !p_input )
1072        return NULL;
1073
1074     if( o_options )
1075     {
1076         for( i = 0; i < (int)[o_options count]; i++ )
1077         {
1078             input_item_AddOption( p_input, strdup( [[o_options objectAtIndex:i] UTF8String] ),
1079                                   VLC_INPUT_OPTION_TRUSTED );
1080         }
1081     }
1082
1083     /* Recent documents menu */
1084     o_true_file = [NSURL fileURLWithPath: o_uri];
1085     if( o_true_file != nil && (BOOL)config_GetInt( p_playlist, "macosx-recentitems" ) == YES )
1086     {
1087         [[NSDocumentController sharedDocumentController]
1088             noteNewRecentDocumentURL: o_true_file];
1089     }
1090
1091     vlc_object_release( p_playlist );
1092     return p_input;
1093 }
1094
1095 - (void)appendArray:(NSArray*)o_array atPos:(int)i_position enqueue:(BOOL)b_enqueue
1096 {
1097     int i_item;
1098     playlist_t * p_playlist = pl_Hold( VLCIntf );
1099
1100     PL_LOCK;
1101     for( i_item = 0; i_item < (int)[o_array count]; i_item++ )
1102     {
1103         input_item_t *p_input;
1104         NSDictionary *o_one_item;
1105
1106         /* Get the item */
1107         o_one_item = [o_array objectAtIndex: i_item];
1108         p_input = [self createItem: o_one_item];
1109         if( !p_input )
1110         {
1111             continue;
1112         }
1113
1114         /* Add the item */
1115         /* FIXME: playlist_AddInput() can fail */
1116
1117         playlist_AddInput( p_playlist, p_input, PLAYLIST_INSERT,
1118              i_position == -1 ? PLAYLIST_END : i_position + i_item, true,
1119          pl_Locked );
1120
1121         if( i_item == 0 && !b_enqueue )
1122         {
1123             playlist_item_t *p_item = NULL;
1124             playlist_item_t *p_node = NULL;
1125             p_item = playlist_ItemGetByInput( p_playlist, p_input );
1126             if( p_item )
1127             {
1128                 if( p_item->i_children == -1 )
1129                     p_node = p_item->p_parent;
1130                 else
1131                 {
1132                     p_node = p_item;
1133                     if( p_node->i_children > 0 && p_node->pp_children[0]->i_children == -1 )
1134                         p_item = p_node->pp_children[0];
1135                     else
1136                         p_item = NULL;
1137                 }
1138                 playlist_Control( p_playlist, PLAYLIST_VIEWPLAY, pl_Locked, p_node, p_item );
1139             }
1140         }
1141         vlc_gc_decref( p_input );
1142     }
1143     PL_UNLOCK;
1144
1145     [self playlistUpdated];
1146     vlc_object_release( p_playlist );
1147 }
1148
1149 - (void)appendNodeArray:(NSArray*)o_array inNode:(playlist_item_t *)p_node atPos:(int)i_position enqueue:(BOOL)b_enqueue
1150 {
1151     int i_item;
1152     playlist_t * p_playlist = pl_Hold( VLCIntf );
1153
1154     for( i_item = 0; i_item < (int)[o_array count]; i_item++ )
1155     {
1156         input_item_t *p_input;
1157         NSDictionary *o_one_item;
1158
1159         /* Get the item */
1160         o_one_item = [o_array objectAtIndex: i_item];
1161         p_input = [self createItem: o_one_item];
1162
1163         if( !p_input ) continue;
1164
1165         /* Add the item */
1166         /* FIXME: playlist_BothAddInput() can fail */
1167         PL_LOCK;
1168         playlist_BothAddInput( p_playlist, p_input, p_node,
1169                                       PLAYLIST_INSERT,
1170                                       i_position == -1 ?
1171                                       PLAYLIST_END : i_position + i_item,
1172                                       NULL, NULL, pl_Locked );
1173
1174
1175         if( i_item == 0 && !b_enqueue )
1176         {
1177             playlist_item_t *p_item;
1178             p_item = playlist_ItemGetByInput( p_playlist, p_input );
1179             playlist_Control( p_playlist, PLAYLIST_VIEWPLAY, pl_Locked, p_node, p_item );
1180         }
1181         PL_UNLOCK;
1182         vlc_gc_decref( p_input );
1183     }
1184     [self playlistUpdated];
1185     vlc_object_release( p_playlist );
1186 }
1187
1188 - (NSMutableArray *)subSearchItem:(playlist_item_t *)p_item
1189 {
1190     playlist_t *p_playlist = pl_Hold( VLCIntf );
1191     playlist_item_t *p_selected_item;
1192     int i_current, i_selected_row;
1193
1194     i_selected_row = [o_outline_view selectedRow];
1195     if (i_selected_row < 0)
1196         i_selected_row = 0;
1197
1198     p_selected_item = (playlist_item_t *)[[o_outline_view itemAtRow:
1199                                             i_selected_row] pointerValue];
1200
1201     for( i_current = 0; i_current < p_item->i_children ; i_current++ )
1202     {
1203         char *psz_temp;
1204         NSString *o_current_name, *o_current_author;
1205
1206         PL_LOCK;
1207         o_current_name = [NSString stringWithUTF8String:
1208             p_item->pp_children[i_current]->p_input->psz_name];
1209         psz_temp = input_item_GetInfo( p_item->p_input ,
1210                    _("Meta-information"),_("Artist") );
1211         o_current_author = [NSString stringWithUTF8String: psz_temp];
1212         free( psz_temp);
1213         PL_UNLOCK;
1214
1215         if( p_selected_item == p_item->pp_children[i_current] &&
1216                     b_selected_item_met == NO )
1217         {
1218             b_selected_item_met = YES;
1219         }
1220         else if( p_selected_item == p_item->pp_children[i_current] &&
1221                     b_selected_item_met == YES )
1222         {
1223             vlc_object_release( p_playlist );
1224             return NULL;
1225         }
1226         else if( b_selected_item_met == YES &&
1227                     ( [o_current_name rangeOfString:[o_search_field
1228                         stringValue] options:NSCaseInsensitiveSearch].length ||
1229                       [o_current_author rangeOfString:[o_search_field
1230                         stringValue] options:NSCaseInsensitiveSearch].length ) )
1231         {
1232             vlc_object_release( p_playlist );
1233             /*Adds the parent items in the result array as well, so that we can
1234             expand the tree*/
1235             return [NSMutableArray arrayWithObject: [NSValue
1236                             valueWithPointer: p_item->pp_children[i_current]]];
1237         }
1238         if( p_item->pp_children[i_current]->i_children > 0 )
1239         {
1240             id o_result = [self subSearchItem:
1241                                             p_item->pp_children[i_current]];
1242             if( o_result != NULL )
1243             {
1244                 vlc_object_release( p_playlist );
1245                 [o_result insertObject: [NSValue valueWithPointer:
1246                                 p_item->pp_children[i_current]] atIndex:0];
1247                 return o_result;
1248             }
1249         }
1250     }
1251     vlc_object_release( p_playlist );
1252     return NULL;
1253 }
1254
1255 - (IBAction)searchItem:(id)sender
1256 {
1257     playlist_t * p_playlist = pl_Hold( VLCIntf );
1258     id o_result;
1259
1260     unsigned int i;
1261     int i_row = -1;
1262
1263     b_selected_item_met = NO;
1264
1265         /*First, only search after the selected item:*
1266          *(b_selected_item_met = NO)                 */
1267     o_result = [self subSearchItem:p_playlist->p_root_category];
1268     if( o_result == NULL )
1269     {
1270         /* If the first search failed, search again from the beginning */
1271         o_result = [self subSearchItem:p_playlist->p_root_category];
1272     }
1273     if( o_result != NULL )
1274     {
1275         int i_start;
1276         if( [[o_result objectAtIndex: 0] pointerValue] ==
1277                                                     p_playlist->p_local_category )
1278         i_start = 1;
1279         else
1280         i_start = 0;
1281
1282         for( i = i_start ; i < [o_result count] - 1 ; i++ )
1283         {
1284             [o_outline_view expandItem: [o_outline_dict objectForKey:
1285                         [NSString stringWithFormat: @"%p",
1286                         [[o_result objectAtIndex: i] pointerValue]]]];
1287         }
1288         i_row = [o_outline_view rowForItem: [o_outline_dict objectForKey:
1289                         [NSString stringWithFormat: @"%p",
1290                         [[o_result objectAtIndex: [o_result count] - 1 ]
1291                         pointerValue]]]];
1292     }
1293     if( i_row > -1 )
1294     {
1295         [o_outline_view selectRow:i_row byExtendingSelection: NO];
1296         [o_outline_view scrollRowToVisible: i_row];
1297     }
1298     vlc_object_release( p_playlist );
1299 }
1300
1301 - (IBAction)recursiveExpandNode:(id)sender
1302 {
1303     id o_item = [o_outline_view itemAtRow: [o_outline_view selectedRow]];
1304     playlist_item_t *p_item = (playlist_item_t *)[o_item pointerValue];
1305
1306     if( ![[o_outline_view dataSource] outlineView: o_outline_view
1307                                                     isItemExpandable: o_item] )
1308     {
1309         o_item = [o_outline_dict objectForKey: [NSString
1310                    stringWithFormat: @"%p", p_item->p_parent]];
1311     }
1312
1313     /* We need to collapse the node first, since OSX refuses to recursively
1314        expand an already expanded node, even if children nodes are collapsed. */
1315     [o_outline_view collapseItem: o_item collapseChildren: YES];
1316     [o_outline_view expandItem: o_item expandChildren: YES];
1317 }
1318
1319 - (NSMenu *)menuForEvent:(NSEvent *)o_event
1320 {
1321     NSPoint pt;
1322     bool b_rows;
1323     bool b_item_sel;
1324
1325     pt = [o_outline_view convertPoint: [o_event locationInWindow]
1326                                                  fromView: nil];
1327     int row = [o_outline_view rowAtPoint:pt];
1328     if( row != -1 )
1329         [o_outline_view selectRowIndexes:[NSIndexSet indexSetWithIndex:row] byExtendingSelection:NO];
1330
1331     b_item_sel = ( row != -1 && [o_outline_view selectedRow] != -1 );
1332     b_rows = [o_outline_view numberOfRows] != 0;
1333
1334     [o_mi_play setEnabled: b_item_sel];
1335     [o_mi_delete setEnabled: b_item_sel];
1336     [o_mi_selectall setEnabled: b_rows];
1337     [o_mi_info setEnabled: b_item_sel];
1338     [o_mi_preparse setEnabled: b_item_sel];
1339     [o_mi_recursive_expand setEnabled: b_item_sel];
1340     [o_mi_sort_name setEnabled: b_item_sel];
1341     [o_mi_sort_author setEnabled: b_item_sel];
1342
1343     return( o_ctx_menu );
1344 }
1345
1346 - (void)outlineView: (NSOutlineView *)o_tv
1347                   didClickTableColumn:(NSTableColumn *)o_tc
1348 {
1349     int i_mode, i_type = 0;
1350     intf_thread_t *p_intf = VLCIntf;
1351
1352     playlist_t *p_playlist = pl_Hold( p_intf );
1353
1354     /* Check whether the selected table column header corresponds to a
1355        sortable table column*/
1356     if( !( o_tc == o_tc_name || o_tc == o_tc_author ) )
1357     {
1358         vlc_object_release( p_playlist );
1359         return;
1360     }
1361
1362     if( o_tc_sortColumn == o_tc )
1363     {
1364         b_isSortDescending = !b_isSortDescending;
1365     }
1366     else
1367     {
1368         b_isSortDescending = false;
1369     }
1370
1371     if( o_tc == o_tc_name )
1372     {
1373         i_mode = SORT_TITLE;
1374     }
1375     else if( o_tc == o_tc_author )
1376     {
1377         i_mode = SORT_ARTIST;
1378     }
1379
1380     if( b_isSortDescending )
1381     {
1382         i_type = ORDER_REVERSE;
1383     }
1384     else
1385     {
1386         i_type = ORDER_NORMAL;
1387     }
1388
1389     PL_LOCK;
1390     playlist_RecursiveNodeSort( p_playlist, p_playlist->p_root_category, i_mode, i_type );
1391     PL_UNLOCK;
1392
1393     vlc_object_release( p_playlist );
1394     [self playlistUpdated];
1395
1396     o_tc_sortColumn = o_tc;
1397     [o_outline_view setHighlightedTableColumn:o_tc];
1398
1399     if( b_isSortDescending )
1400     {
1401         [o_outline_view setIndicatorImage:o_descendingSortingImage
1402                                                         inTableColumn:o_tc];
1403     }
1404     else
1405     {
1406         [o_outline_view setIndicatorImage:o_ascendingSortingImage
1407                                                         inTableColumn:o_tc];
1408     }
1409 }
1410
1411
1412 - (void)outlineView:(NSOutlineView *)outlineView
1413                                 willDisplayCell:(id)cell
1414                                 forTableColumn:(NSTableColumn *)tableColumn
1415                                 item:(id)item
1416 {
1417     playlist_t *p_playlist = pl_Hold( VLCIntf );
1418
1419     id o_playing_item;
1420
1421     PL_LOCK;
1422     o_playing_item = [o_outline_dict objectForKey:
1423                 [NSString stringWithFormat:@"%p",  playlist_CurrentPlayingItem( p_playlist )]];
1424     PL_UNLOCK;
1425
1426     if( [self isItem: [o_playing_item pointerValue] inNode:
1427                         [item pointerValue] checkItemExistence: YES]
1428                         || [o_playing_item isEqual: item] )
1429     {
1430         [cell setFont: [[NSFontManager sharedFontManager] convertFont:[cell font] toHaveTrait:NSBoldFontMask]];
1431     }
1432     else
1433     {
1434         [cell setFont: [[NSFontManager sharedFontManager] convertFont:[cell font] toNotHaveTrait:NSBoldFontMask]];
1435     }
1436     vlc_object_release( p_playlist );
1437 }
1438
1439 - (IBAction)addNode:(id)sender
1440 {
1441     /* we have to create a new thread here because otherwise we would block the
1442      * interface since the interaction-stuff and this code would run in the same
1443      * thread */
1444     [NSThread detachNewThreadSelector: @selector(addNodeThreadedly)
1445         toTarget: self withObject:nil];
1446     [self playlistUpdated];
1447 }
1448
1449 - (void)addNodeThreadedly
1450 {
1451     NSAutoreleasePool * ourPool = [[NSAutoreleasePool alloc] init];
1452
1453     /* simply adds a new node to the end of the playlist */
1454     playlist_t * p_playlist = pl_Hold( VLCIntf );
1455     vlc_thread_set_priority( p_playlist, VLC_THREAD_PRIORITY_LOW );
1456
1457     int ret_v;
1458     char *psz_name = NULL;
1459     ret_v = intf_UserStringInput( p_playlist, _("New Node"),
1460         _("Please enter a name for the new node."), &psz_name );
1461
1462     PL_LOCK;
1463     if( ret_v != DIALOG_CANCELLED && psz_name )
1464     {
1465         playlist_NodeCreate( p_playlist, psz_name,
1466                                       p_playlist->p_local_category, 0, NULL );
1467     }
1468     else if(! config_GetInt( p_playlist, "interact" ) )
1469     {
1470         /* in case that the interaction is disabled, just give it a bogus name */
1471         playlist_NodeCreate( p_playlist, _("Empty Folder"),
1472                                       p_playlist->p_local_category, 0, NULL );
1473     }
1474     PL_UNLOCK;
1475
1476     free( psz_name );
1477     pl_Release( VLCIntf );
1478     [ourPool release];
1479 }
1480
1481 @end
1482
1483 @implementation VLCPlaylist (NSOutlineViewDataSource)
1484
1485 - (id)outlineView:(NSOutlineView *)outlineView child:(NSInteger)index ofItem:(id)item
1486 {
1487     id o_value = [super outlineView: outlineView child: index ofItem: item];
1488     playlist_t *p_playlist = pl_Hold( VLCIntf );
1489
1490     PL_LOCK;
1491     if( playlist_CurrentSize( p_playlist )  >= 2 )
1492     {
1493         [o_status_field setStringValue: [NSString stringWithFormat:
1494                     _NS("%i items"),
1495              playlist_CurrentSize( p_playlist )]];
1496     }
1497     else
1498     {
1499         if( playlist_IsEmpty( p_playlist ) )
1500         {
1501             [o_status_field setStringValue: _NS("No items in the playlist")];
1502         }
1503         else
1504         {
1505             [o_status_field setStringValue: _NS("1 item")];
1506         }
1507     }
1508     PL_UNLOCK;
1509
1510     vlc_object_release( p_playlist );
1511
1512     [o_outline_dict setObject:o_value forKey:[NSString stringWithFormat:@"%p",
1513                                                     [o_value pointerValue]]];
1514     return o_value;
1515
1516 }
1517
1518 /* Required for drag & drop and reordering */
1519 - (BOOL)outlineView:(NSOutlineView *)outlineView writeItems:(NSArray *)items toPasteboard:(NSPasteboard *)pboard
1520 {
1521     unsigned int i;
1522     playlist_t *p_playlist = pl_Hold( VLCIntf );
1523
1524     /* First remove the items that were moved during the last drag & drop
1525        operation */
1526     [o_items_array removeAllObjects];
1527     [o_nodes_array removeAllObjects];
1528
1529     for( i = 0 ; i < [items count] ; i++ )
1530     {
1531         id o_item = [items objectAtIndex: i];
1532
1533         /* Refuse to move items that are not in the General Node
1534            (Service Discovery) */
1535         if( ![self isItem: [o_item pointerValue] inNode:
1536                         p_playlist->p_local_category checkItemExistence: NO] &&
1537             var_CreateGetBool( p_playlist, "media-library" ) &&
1538             ![self isItem: [o_item pointerValue] inNode:
1539                         p_playlist->p_ml_category checkItemExistence: NO] ||
1540             [o_item pointerValue] == p_playlist->p_local_category ||
1541             [o_item pointerValue] == p_playlist->p_ml_category )
1542         {
1543             vlc_object_release(p_playlist);
1544             return NO;
1545         }
1546         /* Fill the items and nodes to move in 2 different arrays */
1547         if( ((playlist_item_t *)[o_item pointerValue])->i_children > 0 )
1548             [o_nodes_array addObject: o_item];
1549         else
1550             [o_items_array addObject: o_item];
1551     }
1552
1553     /* Now we need to check if there are selected items that are in already
1554        selected nodes. In that case, we only want to move the nodes */
1555     [self removeItemsFrom: o_nodes_array ifChildrenOf: o_nodes_array];
1556     [self removeItemsFrom: o_items_array ifChildrenOf: o_nodes_array];
1557
1558     /* We add the "VLCPlaylistItemPboardType" type to be able to recognize
1559        a Drop operation coming from the playlist. */
1560
1561     [pboard declareTypes: [NSArray arrayWithObjects:
1562         @"VLCPlaylistItemPboardType", nil] owner: self];
1563     [pboard setData:[NSData data] forType:@"VLCPlaylistItemPboardType"];
1564
1565     vlc_object_release(p_playlist);
1566     return YES;
1567 }
1568
1569 - (NSDragOperation)outlineView:(NSOutlineView *)outlineView validateDrop:(id <NSDraggingInfo>)info proposedItem:(id)item proposedChildIndex:(NSInteger)index
1570 {
1571     playlist_t *p_playlist = pl_Hold( VLCIntf );
1572     NSPasteboard *o_pasteboard = [info draggingPasteboard];
1573
1574     if( !p_playlist ) return NSDragOperationNone;
1575
1576     /* Dropping ON items is not allowed if item is not a node */
1577     if( item )
1578     {
1579         if( index == NSOutlineViewDropOnItemIndex &&
1580                 ((playlist_item_t *)[item pointerValue])->i_children == -1 )
1581         {
1582             vlc_object_release( p_playlist );
1583             return NSDragOperationNone;
1584         }
1585     }
1586
1587     /* Don't allow on drop on playlist root element's child */
1588     if( !item && index != NSOutlineViewDropOnItemIndex)
1589     {
1590         vlc_object_release( p_playlist );
1591         return NSDragOperationNone;
1592     }
1593
1594     /* We refuse to drop an item in anything else than a child of the General
1595        Node. We still accept items that would be root nodes of the outlineview
1596        however, to allow drop in an empty playlist. */
1597     if( !( ([self isItem: [item pointerValue] inNode: p_playlist->p_local_category checkItemExistence: NO] ||
1598         ( var_CreateGetBool( p_playlist, "media-library" ) && [self isItem: [item pointerValue] inNode: p_playlist->p_ml_category checkItemExistence: NO] ) ) || item == nil ) )
1599     {
1600         vlc_object_release( p_playlist );
1601         return NSDragOperationNone;
1602     }
1603
1604     /* Drop from the Playlist */
1605     if( [[o_pasteboard types] containsObject: @"VLCPlaylistItemPboardType"] )
1606     {
1607         unsigned int i;
1608         for( i = 0 ; i < [o_nodes_array count] ; i++ )
1609         {
1610             /* We refuse to Drop in a child of an item we are moving */
1611             if( [self isItem: [item pointerValue] inNode:
1612                     [[o_nodes_array objectAtIndex: i] pointerValue]
1613                     checkItemExistence: NO] )
1614             {
1615                 vlc_object_release( p_playlist );
1616                 return NSDragOperationNone;
1617             }
1618         }
1619         vlc_object_release( p_playlist );
1620         return NSDragOperationMove;
1621     }
1622
1623     /* Drop from the Finder */
1624     else if( [[o_pasteboard types] containsObject: NSFilenamesPboardType] )
1625     {
1626         vlc_object_release( p_playlist );
1627         return NSDragOperationGeneric;
1628     }
1629     vlc_object_release( p_playlist );
1630     return NSDragOperationNone;
1631 }
1632
1633 - (BOOL)outlineView:(NSOutlineView *)outlineView acceptDrop:(id <NSDraggingInfo>)info item:(id)item childIndex:(NSInteger)index
1634 {
1635     playlist_t * p_playlist =  pl_Hold( VLCIntf );
1636     NSPasteboard *o_pasteboard = [info draggingPasteboard];
1637
1638     /* Drag & Drop inside the playlist */
1639     if( [[o_pasteboard types] containsObject: @"VLCPlaylistItemPboardType"] )
1640     {
1641         int i_row, i_removed_from_node = 0;
1642         unsigned int i;
1643         playlist_item_t *p_new_parent, *p_item = NULL;
1644         NSArray *o_all_items = [o_nodes_array arrayByAddingObjectsFromArray:
1645                                                                 o_items_array];
1646         /* If the item is to be dropped as root item of the outline, make it a
1647            child of the General node.
1648            Else, choose the proposed parent as parent. */
1649         if( item == nil ) p_new_parent = p_playlist->p_local_category;
1650         else p_new_parent = [item pointerValue];
1651
1652         /* Make sure the proposed parent is a node.
1653            (This should never be true) */
1654         if( p_new_parent->i_children < 0 )
1655         {
1656             vlc_object_release( p_playlist );
1657             return NO;
1658         }
1659
1660         for( i = 0; i < [o_all_items count]; i++ )
1661         {
1662             playlist_item_t *p_old_parent = NULL;
1663             int i_old_index = 0;
1664
1665             p_item = [[o_all_items objectAtIndex:i] pointerValue];
1666             p_old_parent = p_item->p_parent;
1667             if( !p_old_parent )
1668             continue;
1669             /* We may need the old index later */
1670             if( p_new_parent == p_old_parent )
1671             {
1672                 int j;
1673                 for( j = 0; j < p_old_parent->i_children; j++ )
1674                 {
1675                     if( p_old_parent->pp_children[j] == p_item )
1676                     {
1677                         i_old_index = j;
1678                         break;
1679                     }
1680                 }
1681             }
1682
1683             PL_LOCK;
1684             // Actually detach the item from the old position
1685             if( playlist_NodeRemoveItem( p_playlist, p_item, p_old_parent ) ==
1686                 VLC_SUCCESS )
1687             {
1688                 int i_new_index;
1689                 /* Calculate the new index */
1690                 if( index == -1 )
1691                 i_new_index = -1;
1692                 /* If we move the item in the same node, we need to take into
1693                    account that one item will be deleted */
1694                 else
1695                 {
1696                     if ((p_new_parent == p_old_parent &&
1697                                    i_old_index < index + (int)i) )
1698                     {
1699                         i_removed_from_node++;
1700                     }
1701                     i_new_index = index + i - i_removed_from_node;
1702                 }
1703                 // Reattach the item to the new position
1704                 playlist_NodeInsert( p_playlist, p_item, p_new_parent, i_new_index );
1705             }
1706             PL_UNLOCK;
1707         }
1708         [self playlistUpdated];
1709         i_row = [o_outline_view rowForItem:[o_outline_dict
1710             objectForKey:[NSString stringWithFormat: @"%p",
1711             [[o_all_items objectAtIndex: 0] pointerValue]]]];
1712
1713         if( i_row == -1 )
1714         {
1715             i_row = [o_outline_view rowForItem:[o_outline_dict
1716             objectForKey:[NSString stringWithFormat: @"%p", p_new_parent]]];
1717         }
1718
1719         [o_outline_view deselectAll: self];
1720         [o_outline_view selectRow: i_row byExtendingSelection: NO];
1721         [o_outline_view scrollRowToVisible: i_row];
1722
1723         vlc_object_release( p_playlist );
1724         return YES;
1725     }
1726
1727     else if( [[o_pasteboard types] containsObject: NSFilenamesPboardType] )
1728     {
1729         int i;
1730         playlist_item_t *p_node = [item pointerValue];
1731
1732         NSArray *o_array = [NSArray array];
1733         NSArray *o_values = [[o_pasteboard propertyListForType:
1734                                         NSFilenamesPboardType]
1735                                 sortedArrayUsingSelector:
1736                                         @selector(caseInsensitiveCompare:)];
1737
1738         for( i = 0; i < (int)[o_values count]; i++)
1739         {
1740             NSDictionary *o_dic;
1741             o_dic = [NSDictionary dictionaryWithObject:[o_values
1742                         objectAtIndex:i] forKey:@"ITEM_URL"];
1743             o_array = [o_array arrayByAddingObject: o_dic];
1744         }
1745
1746         if ( item == nil )
1747         {
1748             [self appendArray:o_array atPos:index enqueue: YES];
1749         }
1750         else
1751         {
1752             assert( p_node->i_children != -1 );
1753             [self appendNodeArray:o_array inNode: p_node
1754                 atPos:index enqueue:YES];
1755         }
1756         vlc_object_release( p_playlist );
1757         return YES;
1758     }
1759     vlc_object_release( p_playlist );
1760     return NO;
1761 }
1762 @end
1763
1764