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