X-Git-Url: https://git.sesse.net/?a=blobdiff_plain;f=modules%2Fgui%2Fmacosx%2Fplaylist.m;h=07d8edc31978ad4d7332ffe07188ca53acbe08e8;hb=ed0b72e3714ad87cb4e10b9a7239e19b9ef0724e;hp=95a84a98e9cf33d8debdab6f09c078970cc4a28e;hpb=c8044b72f56b32c06fa282c4d180755d5cbab422;p=vlc

diff --git a/modules/gui/macosx/playlist.m b/modules/gui/macosx/playlist.m
index 95a84a98e9..07d8edc319 100644
--- a/modules/gui/macosx/playlist.m
+++ b/modules/gui/macosx/playlist.m
@@ -1,11 +1,11 @@
 /*****************************************************************************
  * playlist.m: MacOS X interface module
  *****************************************************************************
- * Copyright (C) 2002-2004 VideoLAN
+* Copyright (C) 2002-2006 the VideoLAN team
  * $Id$
  *
  * Authors: Jon Lech Johansen <jon-vl@nanocrew.net>
- *          Derk-Jan Hartman <hartman at videolan dot org>
+ *          Derk-Jan Hartman <hartman at videola/n dot org>
  *          Benjamin Pracht <bigben at videolab dot org>
  *
  * This program is free software; you can redistribute it and/or modify
@@ -20,22 +20,18 @@
  *
  * You should have received a copy of the GNU General Public License
  * along with this program; if not, write to the Free Software
- * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111, USA.
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston MA 02110-1301, USA.
  *****************************************************************************/
 
 /* TODO
  * add 'icons' for different types of nodes? (http://www.cocoadev.com/index.pl?IconAndTextInTableCell)
- * create a new 'playlist toggle' that hides the playlist and in effect give you the old controller
- * create a new search field build with pictures from the 'regular' search field, so it can be emulated on 10.2
  * create toggle buttons for the shuffle, repeat one, repeat all functions.
- * implement drag and drop and item reordering.
  * reimplement enable/disable item
  * create a new 'tool' button (see the gear button in the Finder window) for 'actions'
    (adding service discovery, other views, new node/playlist, save node/playlist) stuff like that
  */
 
 
-
 /*****************************************************************************
  * Preamble
  *****************************************************************************/
@@ -47,14 +43,14 @@
 #include <vlc_keys.h>
 
 #include "intf.h"
+#import "wizard.h"
+#import "bookmarks.h"
+#import "playlistinfo.h"
 #include "playlist.h"
 #include "controls.h"
-#include "osd.h"
+#include "vlc_osd.h"
 #include "misc.h"
 
-#define REF_HEIGHT 500
-#define REF_WIDTH 500
-
 /*****************************************************************************
  * VLCPlaylistView implementation 
  *****************************************************************************/
@@ -83,6 +79,12 @@
             [[self delegate] deleteItem:self];
             break;
 
+        case NSEnterCharacter:
+        case NSCarriageReturnCharacter:
+            [(VLCPlaylist *)[[VLCMain sharedInstance] getPlaylist]
+                                                            playItem:self];
+            break;
+
         default:
             [super keyDown: o_event];
             break;
@@ -91,31 +93,281 @@
 
 @end
 
+
 /*****************************************************************************
- * VLCPlaylist implementation 
+ * VLCPlaylistCommon implementation
+ *
+ * This class the superclass of the VLCPlaylist and VLCPlaylistWizard.
+ * It contains the common methods and elements of these 2 entities.
  *****************************************************************************/
-@implementation VLCPlaylist
+@implementation VLCPlaylistCommon
 
 - (id)init
 {
     self = [super init];
-    if ( self !=nil )
+    if ( self != nil )
     {
-        //i_moveRow = -1;
+        o_outline_dict = [[NSMutableDictionary alloc] init];
     }
     return self;
 }
-
 - (void)awakeFromNib
 {
+    playlist_t * p_playlist = vlc_object_find( VLCIntf, VLC_OBJECT_PLAYLIST,
+                                          FIND_ANYWHERE );
     [o_outline_view setTarget: self];
     [o_outline_view setDelegate: self];
     [o_outline_view setDataSource: self];
 
+    vlc_object_release( p_playlist );
+    [self initStrings];
+}
+
+- (void)initStrings
+{
+    [[o_tc_name headerCell] setStringValue:_NS("Name")];
+    [[o_tc_author headerCell] setStringValue:_NS("Author")];
+    [[o_tc_duration headerCell] setStringValue:_NS("Duration")];
+}
+
+- (NSOutlineView *)outlineView
+{
+    return o_outline_view;
+}
+
+- (playlist_item_t *)selectedPlaylistItem
+{
+    return [[o_outline_view itemAtRow: [o_outline_view selectedRow]]
+                                                                pointerValue];
+}
+
+@end
+
+@implementation VLCPlaylistCommon (NSOutlineViewDataSource)
+
+/* return the number of children for Obj-C pointer item */ /* DONE */
+- (int)outlineView:(NSOutlineView *)outlineView numberOfChildrenOfItem:(id)item
+{
+    int i_return = 0;
+    playlist_t * p_playlist = vlc_object_find( VLCIntf, VLC_OBJECT_PLAYLIST,
+                                                       FIND_ANYWHERE );
+    if( p_playlist == NULL )
+        return 0;
+    if( outlineView != o_outline_view )
+    {
+        vlc_object_release( p_playlist );
+        return 0;
+    }
+
+    if( item == nil )
+    {
+        /* root object */
+        if( p_playlist->p_root_category )
+        {
+            i_return = p_playlist->p_root_category->i_children;
+        }
+    }
+    else
+    {
+        playlist_item_t *p_item = (playlist_item_t *)[item pointerValue];
+        if( p_item )
+            i_return = p_item->i_children;
+    }
+    vlc_object_release( p_playlist );
+
+    if( i_return <= 0 )
+        i_return = 0;
+
+    return i_return;
+}
+
+/* return the child at index for the Obj-C pointer item */ /* DONE */
+- (id)outlineView:(NSOutlineView *)outlineView child:(int)index ofItem:(id)item
+{
+    playlist_item_t *p_return = NULL;
+    playlist_t * p_playlist = vlc_object_find( VLCIntf, VLC_OBJECT_PLAYLIST,
+                                                       FIND_ANYWHERE );
+    NSValue *o_value;
+
+    if( p_playlist == NULL )
+        return nil;
+
+    if( item == nil )
+    {
+        /* root object */
+        if( p_playlist->p_root_category )
+        {
+            p_return = p_playlist->p_root_category->pp_children[index];
+        }
+    }
+    else
+    {
+        playlist_item_t *p_item = (playlist_item_t *)[item pointerValue];
+        if( p_item && index < p_item->i_children && index >= 0 )
+            p_return = p_item->pp_children[index];
+    }
+
+    vlc_object_release( p_playlist );
+
+    o_value = [o_outline_dict objectForKey:[NSString stringWithFormat: @"%p", p_return]];
+    if( o_value == nil )
+    {
+        o_value = [[NSValue valueWithPointer: p_return] retain];
+    }
+    return o_value;
+}
+
+/* is the item expandable */
+- (BOOL)outlineView:(NSOutlineView *)outlineView isItemExpandable:(id)item
+{
+    int i_return = 0;
+    playlist_t * p_playlist = vlc_object_find( VLCIntf, VLC_OBJECT_PLAYLIST,
+                                                       FIND_ANYWHERE );
+    if( p_playlist == NULL )
+        return NO;
+
+    if( item == nil )
+    {
+        /* root object */
+        if( p_playlist->p_root_category )
+        {
+            i_return = p_playlist->p_root_category->i_children;
+        }
+    }
+    else
+    {
+        playlist_item_t *p_item = (playlist_item_t *)[item pointerValue];
+        if( p_item )
+            i_return = p_item->i_children;
+    }
+    vlc_object_release( p_playlist );
+
+    if( i_return <= 0 )
+        return NO;
+    else
+        return YES;
+}
+
+/* retrieve the string values for the cells */
+- (id)outlineView:(NSOutlineView *)outlineView objectValueForTableColumn:(NSTableColumn *)o_tc byItem:(id)item
+{
+    id o_value = nil;
+    intf_thread_t *p_intf = VLCIntf;
+    playlist_t *p_playlist;
+    playlist_item_t *p_item;
+    
+    if( item == nil || ![item isKindOfClass: [NSValue class]] ) return( @"error" );
+    
+    p_playlist = vlc_object_find( p_intf, VLC_OBJECT_PLAYLIST,
+                                               FIND_ANYWHERE );
+    if( p_playlist == NULL )
+    {
+        return( @"error" );
+    }
+
+    p_item = (playlist_item_t *)[item pointerValue];
+
+    if( p_item == NULL )
+    {
+        vlc_object_release( p_playlist );
+        return( @"error");
+    }
+
+    if( [[o_tc identifier] isEqualToString:@"1"] )
+    {
+        o_value = [NSString stringWithUTF8String:
+            p_item->p_input->psz_name];
+        if( o_value == NULL )
+            o_value = [NSString stringWithCString:
+                p_item->p_input->psz_name];
+    }
+    else if( [[o_tc identifier] isEqualToString:@"2"] )
+    {
+        char *psz_temp;
+        psz_temp = vlc_input_item_GetInfo( p_item->p_input ,_("Meta-information"),_("Artist") );
+
+        if( psz_temp == NULL )
+            o_value = @"";
+        else
+        {
+            o_value = [NSString stringWithUTF8String: psz_temp];
+            if( o_value == NULL )
+            {
+                o_value = [NSString stringWithCString: psz_temp];
+            }
+            free( psz_temp );
+        }
+    }
+    else if( [[o_tc identifier] isEqualToString:@"3"] )
+    {
+        char psz_duration[MSTRTIME_MAX_SIZE];
+        mtime_t dur = p_item->p_input->i_duration;
+        if( dur != -1 )
+        {
+            secstotimestr( psz_duration, dur/1000000 );
+            o_value = [NSString stringWithUTF8String: psz_duration];
+        }
+        else
+        {
+            o_value = @"-:--:--";
+        }
+    }
+    vlc_object_release( p_playlist );
+
+    return( o_value );
+}
+
+@end
+
+/*****************************************************************************
+ * VLCPlaylistWizard implementation
+ *****************************************************************************/
+@implementation VLCPlaylistWizard
+
+- (IBAction)reloadOutlineView
+{
+    /* Only reload the outlineview if the wizard window is open since this can
+       be quite long on big playlists */
+    if( [[o_outline_view window] isVisible] )
+    {
+        [o_outline_view reloadData];
+    }
+}
+
+@end
+
+/*****************************************************************************
+ * VLCPlaylist implementation
+ *****************************************************************************/
+@implementation VLCPlaylist
+
+- (id)init
+{
+    self = [super init];
+    if ( self != nil )
+    {
+        o_nodes_array = [[NSMutableArray alloc] init];
+        o_items_array = [[NSMutableArray alloc] init];
+    }
+    return self;
+}
+
+- (void)awakeFromNib
+{
+    playlist_t * p_playlist = vlc_object_find( VLCIntf, VLC_OBJECT_PLAYLIST,
+                                          FIND_ANYWHERE );
+    vlc_list_t *p_list = vlc_list_find( p_playlist, VLC_OBJECT_MODULE,
+                                        FIND_ANYWHERE );
+
+    int i_index;
+
+    [super awakeFromNib];
+
     [o_outline_view setDoubleAction: @selector(playItem:)];
 
-    [o_outline_view registerForDraggedTypes: 
-        [NSArray arrayWithObjects: NSFilenamesPboardType, nil]];
+    [o_outline_view registerForDraggedTypes:
+        [NSArray arrayWithObjects: NSFilenamesPboardType,
+        @"VLCPlaylistItemPboardType", nil]];
     [o_outline_view setIntercellSpacing: NSMakeSize (0.0, 1.0)];
 
 /* We need to check whether _defaultTableHeaderSortImage exists, since it 
@@ -139,163 +391,381 @@ belongs to an Apple hidden private API, and then can "disapear" at any time*/
         o_descendingSortingImage = nil;
     }
 
-    o_outline_dict = [[NSMutableDictionary alloc] init];
     o_tc_sortColumn = nil;
 
-    [self initStrings];
+    for( i_index = 0; i_index < p_list->i_count; i_index++ )
+    {
+        NSMenuItem * o_lmi;
+        module_t * p_parser = (module_t *)p_list->p_values[i_index].p_object ;
+
+        if( !strcmp( p_parser->psz_capability, "services_discovery" ) )
+        {
+            /* create the menu entries used in the playlist menu */
+            o_lmi = [[o_mi_services submenu] addItemWithTitle:
+                     [NSString stringWithUTF8String:
+                     p_parser->psz_longname ? p_parser->psz_longname :
+                     ( p_parser->psz_shortname ? p_parser->psz_shortname:
+                     p_parser->psz_object_name)]
+                                             action: @selector(servicesChange:)
+                                             keyEquivalent: @""];
+            [o_lmi setTarget: self];
+            [o_lmi setRepresentedObject:
+                   [NSString stringWithCString: p_parser->psz_object_name]];
+            if( playlist_IsServicesDiscoveryLoaded( p_playlist,
+                    p_parser->psz_object_name ) )
+                [o_lmi setState: NSOnState];
+                
+            /* create the menu entries for the main menu */
+            o_lmi = [[o_mm_mi_services submenu] addItemWithTitle:
+                     [NSString stringWithUTF8String:
+                     p_parser->psz_longname ? p_parser->psz_longname :
+                     ( p_parser->psz_shortname ? p_parser->psz_shortname:
+                     p_parser->psz_object_name)]
+                                             action: @selector(servicesChange:)
+                                             keyEquivalent: @""];
+            [o_lmi setTarget: self];
+            [o_lmi setRepresentedObject:
+                   [NSString stringWithCString: p_parser->psz_object_name]];
+            if( playlist_IsServicesDiscoveryLoaded( p_playlist,
+                    p_parser->psz_object_name ) )
+                [o_lmi setState: NSOnState];
+        }
+    }
+    vlc_list_release( p_list );
+    vlc_object_release( p_playlist );
+
     //[self playlistUpdated];
 }
 
+- (void)searchfieldChanged:(NSNotification *)o_notification
+{
+    [o_search_field setStringValue:[[o_notification object] stringValue]];
+}
+
 - (void)initStrings
 {
+    [super initStrings];
+
     [o_mi_save_playlist setTitle: _NS("Save Playlist...")];
     [o_mi_play setTitle: _NS("Play")];
     [o_mi_delete setTitle: _NS("Delete")];
+    [o_mi_recursive_expand setTitle: _NS("Expand Node")];
     [o_mi_selectall setTitle: _NS("Select All")];
-    [o_mi_info setTitle: _NS("Properties")];
+    [o_mi_info setTitle: _NS("Information")];
+    [o_mi_preparse setTitle: _NS("Get Stream Information")];
     [o_mi_sort_name setTitle: _NS("Sort Node by Name")];
     [o_mi_sort_author setTitle: _NS("Sort Node by Author")];
-    [[o_tc_name headerCell] setStringValue:_NS("Name")];
-    [[o_tc_author headerCell] setStringValue:_NS("Author")];
-    [[o_tc_duration headerCell] setStringValue:_NS("Duration")];
+    [o_mi_services setTitle: _NS("Services discovery")];
     [o_status_field setStringValue: [NSString stringWithFormat:
-                        _NS("0 items in playlist")]];
+                        _NS("No items in the playlist")]];
 
     [o_random_ckb setTitle: _NS("Random")];
 #if 0
     [o_search_button setTitle: _NS("Search")];
 #endif
-    [o_btn_playlist setToolTip: _NS("Playlist")];
+    [o_search_field setToolTip: _NS("Search in Playlist")];
     [[o_loop_popup itemAtIndex:0] setTitle: _NS("Standard Play")];
     [[o_loop_popup itemAtIndex:1] setTitle: _NS("Repeat One")];
     [[o_loop_popup itemAtIndex:2] setTitle: _NS("Repeat All")];
+    [o_mi_addNode setTitle: _NS("Add Folder to Playlist")];
+
+    [o_save_accessory_text setStringValue: _NS("File Format:")];
+    [[o_save_accessory_popup itemAtIndex:0] setTitle: _NS("Extended M3U")];
+    [[o_save_accessory_popup itemAtIndex:1] setTitle: _NS("XML Shareable Playlist Format (XSPF)")];
 }
 
-- (IBAction)toggleWindow:(id)sender
+- (void)playlistUpdated
 {
-    NSRect o_rect;
-    /*First, check if the playlist is visible*/
-    if ( [o_controller frame].size.height == [o_controller minSize].height )
+    unsigned int i;
+
+    /* Clear indications of any existing column sorting */
+    for( i = 0 ; i < [[o_outline_view tableColumns] count] ; i++ )
     {
-        /*Check if the stored heigth of the controller is usable (!= minSize)*/
-        if ([o_controller getSizeWithPlaylist].height !=
-                                        [o_controller minSize].height)
-        {
-            o_rect.size.height = [o_controller getSizeWithPlaylist].height;
-        }
-        else
-        {
-            /*If the stored height is not usable, use a reference one*/
-            o_rect.size.height = REF_HEIGHT;
-        }
+        [o_outline_view setIndicatorImage:nil inTableColumn:
+                            [[o_outline_view tableColumns] objectAtIndex:i]];
+    }
 
-        /*Check if the controller width is the minimum one*/
-        if ( [o_controller frame].size.width == [o_controller minSize].width)
+    [o_outline_view setHighlightedTableColumn:nil];
+    o_tc_sortColumn = nil;
+    // TODO Find a way to keep the dict size to a minimum
+    //[o_outline_dict removeAllObjects];
+    [o_outline_view reloadData];
+    [[[[VLCMain sharedInstance] getWizard] getPlaylistWizard] reloadOutlineView];
+    [[[[VLCMain sharedInstance] getBookmarks] getDataTable] reloadData];
+
+    playlist_t *p_playlist = vlc_object_find( VLCIntf, VLC_OBJECT_PLAYLIST,
+                                          FIND_ANYWHERE );
+    if(! p_playlist )
+        return;
+
+    if( p_playlist->i_size >= 2 )
+    {
+        [o_status_field setStringValue: [NSString stringWithFormat:
+                    _NS("%i items in the playlist"), p_playlist->i_size]];
+    }
+    else
+    {
+        if( p_playlist->i_size == 0 )
         {
-            /*If the controller width is minimum, check if the stored height
-              of the playlist makes it visible*/
-            if ([o_controller getSizeWithPlaylist].height !=
-                                               [o_controller minSize].height)
-            {
-                o_rect.size.width = [o_controller getSizeWithPlaylist].width;
-            }
-            else
-            {
-                /*If not, use a reference width*/
-                o_rect.size.width = REF_WIDTH;
-            }
+            [o_status_field setStringValue: _NS("No items in the playlist")];
         }
         else
         {
-            o_rect.size.width = [o_controller frame].size.width;
+            [o_status_field setStringValue: _NS("1 item in the playlist")];
         }
-        o_rect.origin.x = [o_controller frame].origin.x;
-        o_rect.origin.y = [o_controller frame].origin.y - o_rect.size.height +
-                                                [o_controller minSize].height;
+    }
+    vlc_object_release( p_playlist );
+}
+
+- (void)playModeUpdated
+{
+    playlist_t *p_playlist = vlc_object_find( VLCIntf, VLC_OBJECT_PLAYLIST,
+                                          FIND_ANYWHERE );
+    vlc_value_t val, val2;
 
-        [o_btn_playlist setState: YES];
+    if( p_playlist == NULL )
+    {
+        return;
+    }
+
+    var_Get( p_playlist, "loop", &val2 );
+    var_Get( p_playlist, "repeat", &val );
+    if( val.b_bool == VLC_TRUE )
+    {
+        [o_loop_popup selectItemAtIndex: 1];
+   }
+    else if( val2.b_bool == VLC_TRUE )
+    {
+        [o_loop_popup selectItemAtIndex: 2];
     }
     else
     {
-        o_rect.size = [o_controller minSize];
-        o_rect.origin.x = [o_controller frame].origin.x;
-        /*Calculate the position of the lower right corner after resize*/
-        o_rect.origin.y = [o_controller frame].origin.y +
-            [o_controller frame].size.height - [o_controller minSize].height;
-
-        [o_btn_playlist setState: NO];
+        [o_loop_popup selectItemAtIndex: 0];
     }
 
-    [o_controller setFrame: o_rect display:YES animate: YES];
+    var_Get( p_playlist, "random", &val );
+    [o_random_ckb setState: val.b_bool];
+
+    vlc_object_release( p_playlist );
 }
 
-- (void)playlistUpdated
+- (void)updateRowSelection
 {
-    unsigned int i;
+    int i_row;
+    unsigned int j;
 
-    /* Clear indications of any existing column sorting*/
-    for( i = 0 ; i < [[o_outline_view tableColumns] count] ; i++ )
+    playlist_t *p_playlist = vlc_object_find( VLCIntf, VLC_OBJECT_PLAYLIST,
+                                          FIND_ANYWHERE );
+    playlist_item_t *p_item, *p_temp_item;
+    NSMutableArray *o_array = [NSMutableArray array];
+
+    if( p_playlist == NULL )
+        return;
+
+    p_item = p_playlist->status.p_item;
+    if( p_item == NULL )
     {
-        [o_outline_view setIndicatorImage:nil inTableColumn:
-                            [[o_outline_view tableColumns] objectAtIndex:i]];
+        vlc_object_release(p_playlist);
+        return;
     }
 
-    [o_outline_view setHighlightedTableColumn:nil];
-    o_tc_sortColumn = nil;
-    [o_outline_dict removeAllObjects];
-    [o_outline_view reloadData];
-}
-
-- (void)updateTogglePlaylistState
-{
-    if ([o_controller getSizeWithPlaylist].height ==
-                                    [o_controller minSize].height)
+    p_temp_item = p_item;
+    while( p_temp_item->p_parent )
     {
-        [o_btn_playlist setState: NO];
+        [o_array insertObject: [NSValue valueWithPointer: p_temp_item] atIndex: 0];
+        p_temp_item = p_temp_item->p_parent;
+        /*for (i = 0 ; i < p_temp_item->i_parents ; i++)
+        {
+            if( p_temp_item->pp_parents[i]->i_view == i_current_view )
+            {
+                p_temp_item = p_temp_item->pp_parents[i]->p_parent;
+                break;
+            }
+        }*/
     }
-    else
+
+    for( j = 0; j < [o_array count] - 1; j++ )
     {
-        [o_btn_playlist setState: YES];
+        id o_item;
+        if( ( o_item = [o_outline_dict objectForKey:
+                            [NSString stringWithFormat: @"%p",
+                            [[o_array objectAtIndex:j] pointerValue]]] ) != nil )
+        {
+            msg_Err( p_playlist, "o_item: %p", o_item );
+            [o_outline_view expandItem: o_item];
+        }
+
     }
+
+    i_row = [o_outline_view rowForItem:[o_outline_dict
+            objectForKey:[NSString stringWithFormat: @"%p", p_item]]];
+
+    [o_outline_view selectRow: i_row byExtendingSelection: NO];
+    [o_outline_view scrollRowToVisible: i_row];
+
+    vlc_object_release(p_playlist);
+
+    /* update our info-panel to reflect the new item */
+    [[[VLCMain sharedInstance] getInfo] updatePanel];
 }
 
-- (bool)isItem:(playlist_item_t *)p_item inNode:(playlist_item_t *)p_node
+/* Check if p_item is a child of p_node recursively. We need to check the item
+   existence first since OSX sometimes tries to redraw items that have been
+   deleted. We don't do it when not required  since this verification takes
+   quite a long time on big playlists (yes, pretty hacky). */
+- (BOOL)isItem: (playlist_item_t *)p_item
+                    inNode: (playlist_item_t *)p_node
+                    checkItemExistence:(BOOL)b_check
+
 {
     playlist_t * p_playlist = vlc_object_find( VLCIntf, VLC_OBJECT_PLAYLIST,
                                           FIND_ANYWHERE );
-    playlist_item_t * p_temp_item = p_item;
+    playlist_item_t *p_temp_item = p_item;
 
-    if ( p_playlist == NULL )
+    if( p_playlist == NULL )
     {
         return NO;
     }
 
-    while ( p_temp_item->i_parents > 0 )
+    if( p_node == p_item )
+    {
+        vlc_object_release(p_playlist);
+        return YES;
+    }
+
+    if( p_node->i_children < 1)
+    {
+        vlc_object_release(p_playlist);
+        return NO;
+    }
+
+    if ( p_temp_item )
     {
         int i;
-        for (i = 0; i < p_temp_item->i_parents ; i++)
+        vlc_mutex_lock( &p_playlist->object_lock );
+
+        if( b_check )
         {
-            if (p_temp_item->pp_parents[i]->i_view == VIEW_SIMPLE)
+        /* Since outlineView: willDisplayCell:... may call this function with
+           p_items that don't exist anymore, first check if the item is still
+           in the playlist. Any cleaner solution welcomed. */
+            for( i = 0; i < p_playlist->i_all_size; i++ )
             {
-                if (p_temp_item->pp_parents[i]->p_parent == p_node)
+                if( p_playlist->pp_all_items[i] == p_item ) break;
+                else if ( i == p_playlist->i_all_size - 1 )
                 {
-                    vlc_object_release(p_playlist);
-                    return YES;
-                }
-                else
-                {
-                    p_temp_item = p_temp_item->pp_parents[i]->p_parent;
-                    break;
+                    vlc_object_release( p_playlist );
+                    vlc_mutex_unlock( &p_playlist->object_lock );
+                    return NO;
                 }
             }
         }
+
+        while( p_temp_item )
+        {
+            p_temp_item = p_temp_item->p_parent;
+            if( p_temp_item == p_node )
+            {
+                 vlc_mutex_unlock( &p_playlist->object_lock );
+                 vlc_object_release( p_playlist );
+                 return YES;
+            }
+        }
+        vlc_mutex_unlock( &p_playlist->object_lock );
     }
 
-    vlc_object_release(p_playlist);
+    vlc_object_release( p_playlist );
     return NO;
 }
 
+/* This method is usefull for instance to remove the selected children of an
+   already selected node */
+- (void)removeItemsFrom:(id)o_items ifChildrenOf:(id)o_nodes
+{
+    unsigned int i, j;
+    for( i = 0 ; i < [o_items count] ; i++ )
+    {
+        for ( j = 0 ; j < [o_nodes count] ; j++ )
+        {
+            if( o_items == o_nodes)
+            {
+                if( j == i ) continue;
+            }
+            if( [self isItem: [[o_items objectAtIndex:i] pointerValue]
+                    inNode: [[o_nodes objectAtIndex:j] pointerValue]
+                    checkItemExistence: NO] )
+            {
+                [o_items removeObjectAtIndex:i];
+                /* We need to execute the next iteration with the same index
+                   since the current item has been deleted */
+                i--;
+                break;
+            }
+        }
+    }
+
+}
+
+- (IBAction)savePlaylist:(id)sender
+{
+    intf_thread_t * p_intf = VLCIntf;
+    playlist_t * p_playlist = vlc_object_find( p_intf, VLC_OBJECT_PLAYLIST,
+                                                       FIND_ANYWHERE );
+
+    NSSavePanel *o_save_panel = [NSSavePanel savePanel];
+    NSString * o_name = [NSString stringWithFormat: @"%@", _NS("Untitled")];
+
+    //[o_save_panel setAllowedFileTypes: [NSArray arrayWithObjects: @"m3u", @"xpf", nil] ];
+    [o_save_panel setTitle: _NS("Save Playlist")];
+    [o_save_panel setPrompt: _NS("Save")];
+    [o_save_panel setAccessoryView: o_save_accessory_view];
 
+    if( [o_save_panel runModalForDirectory: nil
+            file: o_name] == NSOKButton )
+    {
+        NSString *o_filename = [o_save_panel filename];
+
+        if( [o_save_accessory_popup indexOfSelectedItem] == 1 )
+        {
+            NSString * o_real_filename;
+            NSRange range;
+            range.location = [o_filename length] - [@".xspf" length];
+            range.length = [@".xspf" length];
+
+            if( [o_filename compare:@".xspf" options: NSCaseInsensitiveSearch
+                                             range: range] != NSOrderedSame )
+            {
+                o_real_filename = [NSString stringWithFormat: @"%@.xspf", o_filename];
+            }
+            else
+            {
+                o_real_filename = o_filename;
+            }
+            playlist_Export( p_playlist, [o_real_filename fileSystemRepresentation], "export-xspf" );
+        }
+        else
+        {
+            NSString * o_real_filename;
+            NSRange range;
+            range.location = [o_filename length] - [@".m3u" length];
+            range.length = [@".m3u" length];
+
+            if( [o_filename compare:@".m3u" options: NSCaseInsensitiveSearch
+                                             range: range] != NSOrderedSame )
+            {
+                o_real_filename = [NSString stringWithFormat: @"%@.m3u", o_filename];
+            }
+            else
+            {
+                o_real_filename = o_filename;
+            }
+            playlist_Export( p_playlist, [o_real_filename fileSystemRepresentation], p_playlist->p_local_category, "export-m3u" );
+        }
+    }
+    vlc_object_release( p_playlist );
+}
+
+/* When called retrieves the selected outlineview row and plays that node or item */
 - (IBAction)playItem:(id)sender
 {
     intf_thread_t * p_intf = VLCIntf;
@@ -306,27 +776,20 @@ belongs to an Apple hidden private API, and then can "disapear" at any time*/
     {
         playlist_item_t *p_item;
         playlist_item_t *p_node = NULL;
-        int i;
 
         p_item = [[o_outline_view itemAtRow:[o_outline_view selectedRow]] pointerValue];
 
         if( p_item )
         {
-            if (p_item->i_children == -1)
+            if( p_item->i_children == -1 )
             {
-                for (i = 0 ; i < p_item->i_parents ; i++)
-                {
-                    if (p_item->pp_parents[i]->i_view == VIEW_SIMPLE)
-                    {
-                        p_node = p_item->pp_parents[i]->p_parent;
-                    }
-                }
+                p_node = p_item->p_parent;
+
             }
             else
             {
                 p_node = p_item;
-                if (p_node->pp_children[0]->i_children == -1 &&
-                    p_node->i_children > 0)
+                if( p_node->i_children > 0 && p_node->pp_children[0]->i_children == -1 )
                 {
                     p_item = p_node->pp_children[0];
                 }
@@ -335,15 +798,72 @@ belongs to an Apple hidden private API, and then can "disapear" at any time*/
                     p_item = NULL;
                 }
             }
+            playlist_Control( p_playlist, PLAYLIST_VIEWPLAY, 0, p_node, p_item );
+        }
+        vlc_object_release( p_playlist );
+    }
+}
 
-//        p_view = playlist_ViewFind( p_playlist, VIEW_SIMPLE );
+/* When called retrieves the selected outlineview row and plays that node or item */
+- (IBAction)preparseItem:(id)sender
+{
+    int i_count;
+    NSMutableArray *o_to_preparse;
+    intf_thread_t * p_intf = VLCIntf;
+    playlist_t * p_playlist = vlc_object_find( p_intf, VLC_OBJECT_PLAYLIST,
+                                                       FIND_ANYWHERE );
+                                                       
+    o_to_preparse = [NSMutableArray arrayWithArray:[[o_outline_view selectedRowEnumerator] allObjects]];
+    i_count = [o_to_preparse count];
 
+    if( p_playlist != NULL )
+    {
+        int i, i_row;
+        NSNumber *o_number;
+        playlist_item_t *p_item = NULL;
+
+        for( i = 0; i < i_count; i++ )
+        {
+            o_number = [o_to_preparse lastObject];
+            i_row = [o_number intValue];
+            p_item = [[o_outline_view itemAtRow:i_row] pointerValue];
+            [o_to_preparse removeObject: o_number];
+            [o_outline_view deselectRow: i_row];
 
-            playlist_Control( p_playlist, PLAYLIST_VIEWPLAY, VIEW_SIMPLE, p_node, p_item );
-//            playlist_Control( p_playlist, PLAYLIST_VIEWPLAY, VIEW_SIMPLE, p_view ? p_view->p_root : NULL, p_item );
+            if( p_item )
+            {
+                if( p_item->i_children == -1 )
+                {
+                    playlist_PreparseEnqueue( p_playlist, p_item->p_input );
+                }
+                else
+                {
+                    msg_Dbg( p_intf, "preparse of nodes not yet implemented" );
+                }
+            }
         }
         vlc_object_release( p_playlist );
     }
+    [self playlistUpdated];
+}
+
+- (IBAction)servicesChange:(id)sender
+{
+    NSMenuItem *o_mi = (NSMenuItem *)sender;
+    NSString *o_string = [o_mi representedObject];
+    playlist_t * p_playlist = vlc_object_find( VLCIntf, VLC_OBJECT_PLAYLIST,
+                                          FIND_ANYWHERE );
+    if( !playlist_IsServicesDiscoveryLoaded( p_playlist, [o_string cString] ) )
+        playlist_ServicesDiscoveryAdd( p_playlist, [o_string cString] );
+    else
+        playlist_ServicesDiscoveryRemove( p_playlist, [o_string cString] );
+
+    [o_mi setState: playlist_IsServicesDiscoveryLoaded( p_playlist,
+                                          [o_string cString] ) ? YES : NO];
+
+    vlc_object_release( p_playlist );
+    [self playlistUpdated];
+    return;
 }
 
 - (IBAction)selectAll:(id)sender
@@ -353,7 +873,7 @@ belongs to an Apple hidden private API, and then can "disapear" at any time*/
 
 - (IBAction)deleteItem:(id)sender
 {
-    int i, c, i_row;
+    int i, i_count, i_row;
     NSMutableArray *o_to_delete;
     NSNumber *o_number;
 
@@ -368,39 +888,40 @@ belongs to an Apple hidden private API, and then can "disapear" at any time*/
         return;
     }
     o_to_delete = [NSMutableArray arrayWithArray:[[o_outline_view selectedRowEnumerator] allObjects]];
-    c = [o_to_delete count];
+    i_count = [o_to_delete count];
 
-    for( i = 0; i < c; i++ ) {
-        playlist_item_t * p_item;
+    for( i = 0; i < i_count; i++ )
+    {
         o_number = [o_to_delete lastObject];
         i_row = [o_number intValue];
-
+        id o_item = [o_outline_view itemAtRow: i_row];
+        playlist_item_t *p_item = [o_item pointerValue];
         [o_to_delete removeObject: o_number];
         [o_outline_view deselectRow: i_row];
-        p_item = (playlist_item_t *)[[o_outline_view itemAtRow: i_row]pointerValue];
-        if (p_item->i_children > -1)
+
+        if( [[o_outline_view dataSource] outlineView:o_outline_view
+                                        numberOfChildrenOfItem: o_item]  > 0 )
+        //is a node and not an item
         {
-            if (p_playlist->status.i_status)
+            if( p_playlist->status.i_status != PLAYLIST_STOPPED &&
+                [self isItem: p_playlist->status.p_item inNode:
+                        ((playlist_item_t *)[o_item pointerValue])
+                        checkItemExistence: NO] == YES )
             {
-                if ([self isItem:p_playlist->status.p_item inNode: p_item]
-                                    == YES && p_playlist->status.i_status)
-                {
-                    playlist_Stop( p_playlist );
-                }
+                // if current item is in selected node and is playing then stop playlist
+                playlist_Stop( p_playlist );
             }
-            playlist_NodeDelete( p_playlist, p_item, VLC_TRUE);
+            vlc_mutex_lock( &p_playlist->object_lock );
+            playlist_NodeDelete( p_playlist, p_item, VLC_TRUE, VLC_FALSE );
+            vlc_mutex_unlock( &p_playlist->object_lock );
         }
         else
         {
-            if( p_playlist->status.p_item == [[o_outline_view itemAtRow: i_row]
-                        pointerValue] && p_playlist->status.i_status )
-            {
-                playlist_Stop( p_playlist );
-            }
-            playlist_LockDelete( p_playlist, p_item->input.i_id );
+            playlist_LockDelete( p_playlist, p_item->i_id );
         }
-        [self playlistUpdated];
     }
+    [self playlistUpdated];
+    vlc_object_release( p_playlist );
 }
 
 - (IBAction)sortNodeByName:(id)sender
@@ -424,7 +945,7 @@ belongs to an Apple hidden private API, and then can "disapear" at any time*/
         return;
     }
 
-    if ([o_outline_view selectedRow] > -1)
+    if( [o_outline_view selectedRow] > -1 )
     {
         p_item = [[o_outline_view itemAtRow: [o_outline_view selectedRow]]
                                                                 pointerValue];
@@ -432,140 +953,222 @@ belongs to an Apple hidden private API, and then can "disapear" at any time*/
     else
     /*If no item is selected, sort the whole playlist*/
     {
-        playlist_view_t * p_view = playlist_ViewFind( p_playlist, VIEW_SIMPLE );
-        p_item = p_view->p_root;
+        p_item = p_playlist->p_root_category;
     }
 
-    if (p_item->i_children > -1)
+    if( p_item->i_children > -1 ) // the item is a node
     {
-        vlc_mutex_lock(&p_playlist->object_lock );
+        vlc_mutex_lock( &p_playlist->object_lock );
         playlist_RecursiveNodeSort( p_playlist, p_item, i_mode, ORDER_NORMAL );
-        vlc_mutex_unlock(&p_playlist->object_lock );
+        vlc_mutex_unlock( &p_playlist->object_lock );
     }
     else
     {
-        int i;
+        vlc_mutex_lock( &p_playlist->object_lock );
+        playlist_RecursiveNodeSort( p_playlist,
+                p_item->p_parent, i_mode, ORDER_NORMAL );
+        vlc_mutex_unlock( &p_playlist->object_lock );
+    }
+    vlc_object_release( p_playlist );
+    [self playlistUpdated];
+}
+
+- (input_item_t *)createItem:(NSDictionary *)o_one_item
+{
+    intf_thread_t * p_intf = VLCIntf;
+    playlist_t * p_playlist = vlc_object_find( p_intf, VLC_OBJECT_PLAYLIST,
+                                                       FIND_ANYWHERE );
+
+    if( p_playlist == NULL )
+    {
+        return NULL;
+    }
+    input_item_t *p_input;
+    int i;
+    BOOL b_rem = FALSE, b_dir = FALSE;
+    NSString *o_uri, *o_name;
+    NSArray *o_options;
+    NSURL *o_true_file;
+
+    /* Get the item */
+    o_uri = (NSString *)[o_one_item objectForKey: @"ITEM_URL"];
+    o_name = (NSString *)[o_one_item objectForKey: @"ITEM_NAME"];
+    o_options = (NSArray *)[o_one_item objectForKey: @"ITEM_OPTIONS"];
+
+    /* Find the name for a disc entry ( i know, can you believe the trouble?) */
+    if( ( !o_name || [o_name isEqualToString:@""] ) && [o_uri rangeOfString: @"/dev/"].location != NSNotFound )
+    {
+        int i_count, i_index;
+        struct statfs *mounts = NULL;
 
-        for (i = 0 ; i < p_item->i_parents ; i++)
+        i_count = getmntinfo (&mounts, MNT_NOWAIT);
+        /* getmntinfo returns a pointer to static data. Do not free. */
+        for( i_index = 0 ; i_index < i_count; i_index++ )
         {
-            if (p_item->pp_parents[i]->i_view == VIEW_SIMPLE)
+            NSMutableString *o_temp, *o_temp2;
+            o_temp = [NSMutableString stringWithString: o_uri];
+            o_temp2 = [NSMutableString stringWithCString: mounts[i_index].f_mntfromname];
+            [o_temp replaceOccurrencesOfString: @"/dev/rdisk" withString: @"/dev/disk" options:nil range:NSMakeRange(0, [o_temp length]) ];
+            [o_temp2 replaceOccurrencesOfString: @"s0" withString: @"" options:nil range:NSMakeRange(0, [o_temp2 length]) ];
+            [o_temp2 replaceOccurrencesOfString: @"s1" withString: @"" options:nil range:NSMakeRange(0, [o_temp2 length]) ];
+
+            if( strstr( [o_temp fileSystemRepresentation], [o_temp2 fileSystemRepresentation] ) != NULL )
             {
-                vlc_mutex_lock(&p_playlist->object_lock );
-                playlist_RecursiveNodeSort( p_playlist,
-                        p_item->pp_parents[i]->p_parent, i_mode, ORDER_NORMAL );
-                vlc_mutex_unlock(&p_playlist->object_lock );
-                break;
+                o_name = [[NSFileManager defaultManager] displayNameAtPath: [NSString stringWithCString:mounts[i_index].f_mntonname]];
             }
         }
     }
-    vlc_object_release(p_playlist);
+    /* If no name, then make a guess */
+    if( !o_name) o_name = [[NSFileManager defaultManager] displayNameAtPath: o_uri];
+
+    if( [[NSFileManager defaultManager] fileExistsAtPath:o_uri isDirectory:&b_dir] && b_dir &&
+        [[NSWorkspace sharedWorkspace] getFileSystemInfoForPath: o_uri isRemovable: &b_rem
+                isWritable:NULL isUnmountable:NULL description:NULL type:NULL] && b_rem   )
+    {
+        /* All of this is to make sure CD's play when you D&D them on VLC */
+        /* Converts mountpoint to a /dev file */
+        struct statfs *buf;
+        char *psz_dev;
+        NSMutableString *o_temp;
+
+        buf = (struct statfs *) malloc (sizeof(struct statfs));
+        statfs( [o_uri fileSystemRepresentation], buf );
+        psz_dev = strdup(buf->f_mntfromname);
+        o_temp = [NSMutableString stringWithCString: psz_dev ];
+        [o_temp replaceOccurrencesOfString: @"/dev/disk" withString: @"/dev/rdisk" options:nil range:NSMakeRange(0, [o_temp length]) ];
+        [o_temp replaceOccurrencesOfString: @"s0" withString: @"" options:nil range:NSMakeRange(0, [o_temp length]) ];
+        [o_temp replaceOccurrencesOfString: @"s1" withString: @"" options:nil range:NSMakeRange(0, [o_temp length]) ];
+        o_uri = o_temp;
+    }
+
+    p_input = input_ItemNew( p_playlist, [o_uri fileSystemRepresentation], [o_name UTF8String] );
+    if( !p_input )
+       return NULL;
+
+    if( o_options )
+    {
+        for( i = 0; i < (int)[o_options count]; i++ )
+        {
+            vlc_input_item_AddOption( p_input, strdup( [[o_options objectAtIndex:i] UTF8String] ) );
+        }
+    }
+
+    /* Recent documents menu */
+    o_true_file = [NSURL fileURLWithPath: o_uri];
+    if( o_true_file != nil )
+    {
+        [[NSDocumentController sharedDocumentController]
+            noteNewRecentDocumentURL: o_true_file];
+    }
+
+    vlc_object_release( p_playlist );
+    return p_input;
+}
+
+- (void)appendArray:(NSArray*)o_array atPos:(int)i_position enqueue:(BOOL)b_enqueue
+{
+    int i_item;
+    playlist_t * p_playlist = vlc_object_find( VLCIntf, VLC_OBJECT_PLAYLIST,
+                                            FIND_ANYWHERE );
+    if( p_playlist == NULL )
+    {
+        return;
+    }
+
+    for( i_item = 0; i_item < (int)[o_array count]; i_item++ )
+    {
+        input_item_t *p_input;
+        NSDictionary *o_one_item;
+
+        /* Get the item */
+        o_one_item = [o_array objectAtIndex: i_item];
+        p_input = [self createItem: o_one_item];
+        if( !p_input )
+        {
+            continue;
+        }
+
+        /* Add the item */
+        playlist_PlaylistAddInput( p_playlist, p_input, PLAYLIST_INSERT,
+                        i_position == -1 ? PLAYLIST_END : i_position + i_item );
+
+        if( i_item == 0 && !b_enqueue )
+        {
+            playlist_item_t *p_item;
+            p_item = playlist_ItemGetByInput( p_playlist, p_input );
+            playlist_Control( p_playlist, PLAYLIST_ITEMPLAY, p_item );
+        }
+        else
+        {
+            playlist_item_t *p_item;
+            p_item = playlist_ItemGetByInput( p_playlist, p_input );
+            playlist_Control( p_playlist, PLAYLIST_PREPARSE, p_item );
+        }
+    }
     [self playlistUpdated];
+    vlc_object_release( p_playlist );
 }
 
-- (void)appendArray:(NSArray*)o_array atPos:(int)i_position enqueue:(BOOL)b_enqueue
+- (void)appendNodeArray:(NSArray*)o_array inNode:(playlist_item_t *)p_node atPos:(int)i_position enqueue:(BOOL)b_enqueue
 {
     int i_item;
-    intf_thread_t * p_intf = VLCIntf;
-    playlist_t * p_playlist = vlc_object_find( p_intf, VLC_OBJECT_PLAYLIST,
-                                                       FIND_ANYWHERE );
-
+    playlist_t * p_playlist = vlc_object_find( VLCIntf, VLC_OBJECT_PLAYLIST,
+                                            FIND_ANYWHERE );
     if( p_playlist == NULL )
     {
         return;
     }
 
-    for ( i_item = 0; i_item < (int)[o_array count]; i_item++ )
+    for( i_item = 0; i_item < (int)[o_array count]; i_item++ )
     {
-        /* One item */
+        input_item_t *p_input;
         NSDictionary *o_one_item;
-        int j, i_total_options = 0, i_new_id = -1;
-        int i_mode = PLAYLIST_INSERT;
-        BOOL b_rem = FALSE, b_dir = FALSE;
-        NSString *o_uri, *o_name;
-        NSArray *o_options;
-        NSURL *o_true_file;
-        char **ppsz_options = NULL;
 
         /* Get the item */
         o_one_item = [o_array objectAtIndex: i_item];
-        o_uri = (NSString *)[o_one_item objectForKey: @"ITEM_URL"];
-        o_name = (NSString *)[o_one_item objectForKey: @"ITEM_NAME"];
-        o_options = (NSArray *)[o_one_item objectForKey: @"ITEM_OPTIONS"];
-
-        /* If no name, then make a guess */
-        if( !o_name) o_name = [[NSFileManager defaultManager] displayNameAtPath: o_uri];
-
-        if( [[NSFileManager defaultManager] fileExistsAtPath:o_uri isDirectory:&b_dir] && b_dir &&
-            [[NSWorkspace sharedWorkspace] getFileSystemInfoForPath: o_uri isRemovable: &b_rem
-                    isWritable:NULL isUnmountable:NULL description:NULL type:NULL] && b_rem   )
+        p_input = [self createItem: o_one_item];
+        if( !p_input )
         {
-            /* All of this is to make sure CD's play when you D&D them on VLC */
-            /* Converts mountpoint to a /dev file */
-            struct statfs *buf;
-            char *psz_dev;
-            buf = (struct statfs *) malloc (sizeof(struct statfs));
-            statfs( [o_uri fileSystemRepresentation], buf );
-            psz_dev = strdup(buf->f_mntfromname);
-            o_uri = [NSString stringWithCString: psz_dev ];
-        }
-
-        if( o_options && [o_options count] > 0 )
-        {
-            /* Count the input options */
-            i_total_options = [o_options count];
-
-            /* Allocate ppsz_options */
-            for( j = 0; j < i_total_options; j++ )
-            {
-                if( !ppsz_options )
-                    ppsz_options = (char **)malloc( sizeof(char *) * i_total_options );
-
-                ppsz_options[j] = strdup([[o_options objectAtIndex:j] UTF8String]);
-            }
+            continue;
         }
 
         /* Add the item */
-        i_new_id = playlist_AddExt( p_playlist, [o_uri fileSystemRepresentation],
-                      [o_name UTF8String], i_mode,
-                      i_position == -1 ? PLAYLIST_END : i_position + i_item,
-                      0, (ppsz_options != NULL ) ? (const char **)ppsz_options : 0, i_total_options );
+       playlist_NodeAddInput( p_playlist, p_input, p_node,
+                                      PLAYLIST_INSERT,
+                                      i_position == -1 ?
+                                      PLAYLIST_END : i_position + i_item );
 
-        /* clean up
-        for( j = 0; j < i_total_options; j++ )
-            free( ppsz_options[j] );
-        if( ppsz_options ) free( ppsz_options ); */
 
-        /* Recent documents menu */
-        o_true_file = [NSURL fileURLWithPath: o_uri];
-        if( o_true_file != nil )
+        if( i_item == 0 && !b_enqueue )
         {
-            [[NSDocumentController sharedDocumentController]
-                noteNewRecentDocumentURL: o_true_file];
+            playlist_item_t *p_item;
+            p_item = playlist_ItemGetByInput( p_playlist, p_input );
+            playlist_Control( p_playlist, PLAYLIST_ITEMPLAY, p_item );
         }
-
-        if( i_item == 0 && !b_enqueue )
+        else
         {
-            playlist_Goto( p_playlist, playlist_GetPositionById( p_playlist, i_new_id ) );
-            playlist_Play( p_playlist );
+            playlist_item_t *p_item;
+            p_item = playlist_ItemGetByInput( p_playlist, p_input );
+            playlist_Control( p_playlist, PLAYLIST_PREPARSE, p_item );
         }
     }
-
+    [self playlistUpdated];
     vlc_object_release( p_playlist );
 }
 
 - (IBAction)handlePopUp:(id)sender
 
 {
-             intf_thread_t * p_intf = VLCIntf;
-             vlc_value_t val1,val2;
-             playlist_t * p_playlist = vlc_object_find( p_intf, VLC_OBJECT_PLAYLIST,
-                                                        FIND_ANYWHERE );
-             if( p_playlist == NULL )
-             {
-                 return;
-             }
+    intf_thread_t * p_intf = VLCIntf;
+    vlc_value_t val1,val2;
+    playlist_t * p_playlist = vlc_object_find( p_intf, VLC_OBJECT_PLAYLIST,
+                                            FIND_ANYWHERE );
+    if( p_playlist == NULL )
+    {
+        return;
+    }
 
-    switch ([o_loop_popup indexOfSelectedItem])
+    switch( [o_loop_popup indexOfSelectedItem] )
     {
         case 1:
 
@@ -587,7 +1190,7 @@ belongs to an Apple hidden private API, and then can "disapear" at any time*/
         default:
              var_Get( p_playlist, "repeat", &val1 );
              var_Get( p_playlist, "loop", &val2 );
-             if (val1.b_bool || val2.b_bool)
+             if( val1.b_bool || val2.b_bool )
              {
                   val1.b_bool = 0;
                   var_Set( p_playlist, "repeat", val1 );
@@ -602,12 +1205,12 @@ belongs to an Apple hidden private API, and then can "disapear" at any time*/
 
 - (NSMutableArray *)subSearchItem:(playlist_item_t *)p_item
 {
-    playlist_t * p_playlist = vlc_object_find( VLCIntf, VLC_OBJECT_PLAYLIST,
+    playlist_t *p_playlist = vlc_object_find( VLCIntf, VLC_OBJECT_PLAYLIST,
                                                        FIND_ANYWHERE );
-    playlist_item_t * p_selected_item;
+    playlist_item_t *p_selected_item;
     int i_current, i_selected_row;
 
-    if (!p_playlist)
+    if( !p_playlist )
         return NULL;
 
     i_selected_row = [o_outline_view selectedRow];
@@ -617,56 +1220,57 @@ belongs to an Apple hidden private API, and then can "disapear" at any time*/
     p_selected_item = (playlist_item_t *)[[o_outline_view itemAtRow:
                                             i_selected_row] pointerValue];
 
-    for (i_current = 0; i_current < p_item->i_children ; i_current++)
+    for( i_current = 0; i_current < p_item->i_children ; i_current++ )
     {
-        char * psz_temp;
-        NSString * o_current_name, * o_current_author;
+        char *psz_temp;
+        NSString *o_current_name, *o_current_author;
 
         vlc_mutex_lock( &p_playlist->object_lock );
         o_current_name = [NSString stringWithUTF8String:
-            p_item->pp_children[i_current]->input.psz_name];
-        psz_temp = playlist_ItemGetInfo(p_item ,_("Meta-information"),_("Author") );
+            p_item->pp_children[i_current]->p_input->psz_name];
+        psz_temp = vlc_input_item_GetInfo( p_item->p_input ,
+                   _("Meta-information"),_("Artist") );
         o_current_author = [NSString stringWithUTF8String: psz_temp];
         free( psz_temp);
         vlc_mutex_unlock( &p_playlist->object_lock );
 
-        if (p_selected_item == p_item->pp_children[i_current] &&
-                    b_selected_item_met == NO)
+        if( p_selected_item == p_item->pp_children[i_current] &&
+                    b_selected_item_met == NO )
         {
             b_selected_item_met = YES;
         }
-        else if (p_selected_item == p_item->pp_children[i_current] &&
-                    b_selected_item_met == YES)
+        else if( p_selected_item == p_item->pp_children[i_current] &&
+                    b_selected_item_met == YES )
         {
-            vlc_object_release(p_playlist);
+            vlc_object_release( p_playlist );
             return NULL;
         }
-        else if (b_selected_item_met == YES &&
-                    ([o_current_name rangeOfString:[o_search_field
+        else if( b_selected_item_met == YES &&
+                    ( [o_current_name rangeOfString:[o_search_field
                         stringValue] options:NSCaseInsensitiveSearch ].length ||
-                    [o_current_author rangeOfString:[o_search_field
-                        stringValue] options:NSCaseInsensitiveSearch ].length))
+                      [o_current_author rangeOfString:[o_search_field
+                        stringValue] options:NSCaseInsensitiveSearch ].length ) )
         {
-            vlc_object_release(p_playlist);
+            vlc_object_release( p_playlist );
             /*Adds the parent items in the result array as well, so that we can
             expand the tree*/
             return [NSMutableArray arrayWithObject: [NSValue
                             valueWithPointer: p_item->pp_children[i_current]]];
         }
-        if (p_item->pp_children[i_current]->i_children > 0)
+        if( p_item->pp_children[i_current]->i_children > 0 )
         {
             id o_result = [self subSearchItem:
                                             p_item->pp_children[i_current]];
-            if (o_result != NULL)
+            if( o_result != NULL )
             {
-                vlc_object_release(p_playlist);
+                vlc_object_release( p_playlist );
                 [o_result insertObject: [NSValue valueWithPointer:
                                 p_item->pp_children[i_current]] atIndex:0];
                 return o_result;
             }
         }
     }
-    vlc_object_release(p_playlist);
+    vlc_object_release( p_playlist );
     return NULL;
 }
 
@@ -674,7 +1278,6 @@ belongs to an Apple hidden private API, and then can "disapear" at any time*/
 {
     playlist_t * p_playlist = vlc_object_find( VLCIntf, VLC_OBJECT_PLAYLIST,
                                                        FIND_ANYWHERE );
-    playlist_view_t * p_view;
     id o_result;
 
     unsigned int i;
@@ -685,39 +1288,58 @@ belongs to an Apple hidden private API, and then can "disapear" at any time*/
     if( p_playlist == NULL )
         return;
 
-    p_view = playlist_ViewFind( p_playlist, VIEW_SIMPLE );
-
-    if (p_view)
-    {
         /*First, only search after the selected item:*
          *(b_selected_item_met = NO)                 */
-        o_result = [self subSearchItem:p_view->p_root];
-        if (o_result == NULL)
-        {
-            /* If the first search failed, search again from the beginning */
-            o_result = [self subSearchItem:p_view->p_root];
-        }
-        if (o_result != NULL)
-        {
-            for (i = 0 ; i < [o_result count] - 1 ; i++)
-            {
-                [o_outline_view expandItem: [o_outline_dict objectForKey:
-                            [NSString stringWithFormat: @"%p",
-                            [[o_result objectAtIndex: i] pointerValue]]]];
-            }
-            i_row = [o_outline_view rowForItem: [o_outline_dict objectForKey:
-                            [NSString stringWithFormat: @"%p",
-                            [[o_result objectAtIndex: [o_result count] - 1 ]
-                            pointerValue]]]];
-        }
-        if (i_row > -1)
+    o_result = [self subSearchItem:p_playlist->p_root_category];
+    if( o_result == NULL )
+    {
+        /* If the first search failed, search again from the beginning */
+        o_result = [self subSearchItem:p_playlist->p_root_category];
+    }
+    if( o_result != NULL )
+    {
+        int i_start;
+        if( [[o_result objectAtIndex: 0] pointerValue] ==
+                                                    p_playlist->p_local_category )
+        i_start = 1;
+        else
+        i_start = 0;
+
+        for( i = i_start ; i < [o_result count] - 1 ; i++ )
         {
-            [o_outline_view selectRow:i_row byExtendingSelection: NO];
-            [o_outline_view scrollRowToVisible: i_row];
+            [o_outline_view expandItem: [o_outline_dict objectForKey:
+                        [NSString stringWithFormat: @"%p",
+                        [[o_result objectAtIndex: i] pointerValue]]]];
         }
+        i_row = [o_outline_view rowForItem: [o_outline_dict objectForKey:
+                        [NSString stringWithFormat: @"%p",
+                        [[o_result objectAtIndex: [o_result count] - 1 ]
+                        pointerValue]]]];
+    }
+    if( i_row > -1 )
+    {
+        [o_outline_view selectRow:i_row byExtendingSelection: NO];
+        [o_outline_view scrollRowToVisible: i_row];
+    }
+    vlc_object_release( p_playlist );
+}
+
+- (IBAction)recursiveExpandNode:(id)sender
+{
+    id o_item = [o_outline_view itemAtRow: [o_outline_view selectedRow]];
+    playlist_item_t *p_item = (playlist_item_t *)[o_item pointerValue];
+
+    if( ![[o_outline_view dataSource] outlineView: o_outline_view
+                                                    isItemExpandable: o_item] )
+    {
+        o_item = [o_outline_dict objectForKey: [NSString
+                   stringWithFormat: @"%p", p_item->p_parent]];
     }
-    vlc_object_release(p_playlist);
 
+    /* We need to collapse the node first, since OSX refuses to recursively
+       expand an already expanded node, even if children nodes are collapsed. */
+    [o_outline_view collapseItem: o_item collapseChildren: YES];
+    [o_outline_view expandItem: o_item expandChildren: YES];
 }
 
 - (NSMenu *)menuForEvent:(NSEvent *)o_event
@@ -736,26 +1358,22 @@ belongs to an Apple hidden private API, and then can "disapear" at any time*/
     [o_mi_delete setEnabled: b_item_sel];
     [o_mi_selectall setEnabled: b_rows];
     [o_mi_info setEnabled: b_item_sel];
+    [o_mi_preparse setEnabled: b_item_sel];
+    [o_mi_recursive_expand setEnabled: b_item_sel];
+    [o_mi_sort_name setEnabled: b_item_sel];
+    [o_mi_sort_author setEnabled: b_item_sel];
 
     return( o_ctx_menu );
 }
 
-- (playlist_item_t *)selectedPlaylistItem
-{
-    return [[o_outline_view itemAtRow: [o_outline_view selectedRow]]
-                                                                pointerValue];
-}
-
-- (void) outlineView:(NSTableView*)o_tv
+- (void)outlineView: (NSTableView*)o_tv
                   didClickTableColumn:(NSTableColumn *)o_tc
 {
-    intf_thread_t * p_intf = VLCIntf;
-    playlist_t *p_playlist =
-        (playlist_t *)vlc_object_find( p_intf, VLC_OBJECT_PLAYLIST,
-                                       FIND_ANYWHERE );
-    playlist_view_t * p_view  = playlist_ViewFind( p_playlist, VIEW_SIMPLE );
     int i_mode = 0, i_type;
+    intf_thread_t *p_intf = VLCIntf;
 
+    playlist_t *p_playlist = (playlist_t *)vlc_object_find( p_intf, VLC_OBJECT_PLAYLIST,
+                                       FIND_ANYWHERE );
     if( p_playlist == NULL )
     {
         return;
@@ -763,8 +1381,9 @@ belongs to an Apple hidden private API, and then can "disapear" at any time*/
 
     /* Check whether the selected table column header corresponds to a
        sortable table column*/
-    if ( !(o_tc == o_tc_name || o_tc == o_tc_author))
+    if( !( o_tc == o_tc_name || o_tc == o_tc_author ) )
     {
+        vlc_object_release( p_playlist );
         return;
     }
 
@@ -777,16 +1396,16 @@ belongs to an Apple hidden private API, and then can "disapear" at any time*/
         b_isSortDescending = VLC_FALSE;
     }
 
-    if (o_tc == o_tc_name)
+    if( o_tc == o_tc_name )
     {
         i_mode = SORT_TITLE;
     }
-    else if (o_tc == o_tc_author)
+    else if( o_tc == o_tc_author )
     {
         i_mode = SORT_AUTHOR;
     }
 
-    if (b_isSortDescending)
+    if( b_isSortDescending )
     {
         i_type = ORDER_REVERSE;
     }
@@ -795,9 +1414,9 @@ belongs to an Apple hidden private API, and then can "disapear" at any time*/
         i_type = ORDER_NORMAL;
     }
 
-    vlc_mutex_lock(&p_playlist->object_lock );
-    playlist_RecursiveNodeSort(p_playlist, p_view->p_root, i_mode, i_type);
-    vlc_mutex_unlock(&p_playlist->object_lock );
+    vlc_mutex_lock( &p_playlist->object_lock );
+    playlist_RecursiveNodeSort( p_playlist, p_playlist->p_root_category, i_mode, i_type );
+    vlc_mutex_unlock( &p_playlist->object_lock );
 
     vlc_object_release( p_playlist );
     [self playlistUpdated];
@@ -805,7 +1424,7 @@ belongs to an Apple hidden private API, and then can "disapear" at any time*/
     o_tc_sortColumn = o_tc;
     [o_outline_view setHighlightedTableColumn:o_tc];
 
-    if (b_isSortDescending)
+    if( b_isSortDescending )
     {
         [o_outline_view setIndicatorImage:o_descendingSortingImage
                                                         inTableColumn:o_tc];
@@ -817,178 +1436,335 @@ belongs to an Apple hidden private API, and then can "disapear" at any time*/
     }
 }
 
-@end
-
-@implementation VLCPlaylist (NSOutlineViewDataSource)
 
-/* return the number of children for Obj-C pointer item */ /* DONE */
-- (int)outlineView:(NSOutlineView *)outlineView numberOfChildrenOfItem:(id)item
+- (void)outlineView:(NSOutlineView *)outlineView
+                                willDisplayCell:(id)cell
+                                forTableColumn:(NSTableColumn *)tableColumn
+                                item:(id)item
 {
-    int i_return = 0;
-    playlist_t * p_playlist = vlc_object_find( VLCIntf, VLC_OBJECT_PLAYLIST,
-                                                       FIND_ANYWHERE );
-    if( p_playlist == NULL )
-        return 0;
+    playlist_t *p_playlist = vlc_object_find( VLCIntf, VLC_OBJECT_PLAYLIST,
+                                          FIND_ANYWHERE );
 
-    if( item == nil )
+    id o_playing_item;
+
+    if( !p_playlist ) return;
+
+    o_playing_item = [o_outline_dict objectForKey:
+                [NSString stringWithFormat:@"%p",  p_playlist->status.p_item]];
+
+    if( [self isItem: [o_playing_item pointerValue] inNode:
+                        [item pointerValue] checkItemExistence: YES]
+                        || [o_playing_item isEqual: item] )
     {
-        /* root object */
-        playlist_view_t *p_view;
-        p_view = playlist_ViewFind( p_playlist, VIEW_SIMPLE );
-        if( p_view && p_view->p_root )
-            i_return = p_view->p_root->i_children;
+        [cell setFont: [NSFont boldSystemFontOfSize: 0]];
     }
     else
     {
-        playlist_item_t *p_item = (playlist_item_t *)[item pointerValue];
-        if( p_item )
-            i_return = p_item->i_children;
+        [cell setFont: [NSFont systemFontOfSize: 0]];
     }
     vlc_object_release( p_playlist );
-    if( i_return == -1 ) i_return = 0;
-    msg_Dbg( p_playlist, "I have %d children", i_return );
-    return i_return;
 }
 
-/* return the child at index for the Obj-C pointer item */ /* DONE */
-- (id)outlineView:(NSOutlineView *)outlineView child:(int)index ofItem:(id)item
+- (IBAction)addNode:(id)sender
 {
-    playlist_item_t *p_return = NULL;
+    /* simply adds a new node to the end of the playlist */
     playlist_t * p_playlist = vlc_object_find( VLCIntf, VLC_OBJECT_PLAYLIST,
-                                                       FIND_ANYWHERE );
-    NSValue * o_value;
+                                          FIND_ANYWHERE );
+    if( !p_playlist )
+    {
+        return;
+    }
 
-    if( p_playlist == NULL )
-        return nil;
+    playlist_item_t * p_item = playlist_NodeCreate( p_playlist,
+                                _("Empty Folder"), p_playlist->p_local_category );
 
-    if( item == nil )
+    if(! p_item )
+        msg_Warn( VLCIntf, "node creation failed" );
+
+    vlc_object_release( p_playlist );
+    [self playlistUpdated];
+}
+
+@end
+
+@implementation VLCPlaylist (NSOutlineViewDataSource)
+
+- (id)outlineView:(NSOutlineView *)outlineView child:(int)index ofItem:(id)item
+{
+    id o_value = [super outlineView: outlineView child: index ofItem: item];
+    playlist_t *p_playlist = vlc_object_find( VLCIntf, VLC_OBJECT_PLAYLIST,
+                                               FIND_ANYWHERE );
+
+    if( !p_playlist ) return nil;
+
+    if( p_playlist->i_size >= 2 )
     {
-        /* root object */
-        playlist_view_t *p_view;
-        p_view = playlist_ViewFind( p_playlist, VIEW_SIMPLE );
-        if( p_view && index < p_view->p_root->i_children )
-            p_return = p_view->p_root->pp_children[index];
+        [o_status_field setStringValue: [NSString stringWithFormat:
+                    _NS("%i items in the playlist"), p_playlist->i_size]];
     }
     else
     {
-        playlist_item_t *p_item = (playlist_item_t *)[item pointerValue];
-        if( p_item && index < p_item->i_children )
+        if( p_playlist->i_size == 0 )
         {
-            p_return = p_item->pp_children[index];
+            [o_status_field setStringValue: _NS("No items in the playlist")];
+        }
+        else
+        {
+            [o_status_field setStringValue: _NS("1 item in the playlist")];
         }
     }
-
-    [o_status_field setStringValue: [NSString stringWithFormat:
-                        _NS("%i items in playlist"), p_playlist->i_size]];
-
     vlc_object_release( p_playlist );
-    msg_Dbg( p_playlist, "childitem with index %d", index );
 
-    o_value = [NSValue valueWithPointer: p_return];
+    [o_outline_dict setObject:o_value forKey:[NSString stringWithFormat:@"%p",
+                                                    [o_value pointerValue]]];
 
-    [o_outline_dict setObject:o_value forKey:[NSString stringWithFormat:@"%p",                                                                      p_return]];
     return o_value;
+
 }
 
-/* is the item expandable */
-- (BOOL)outlineView:(NSOutlineView *)outlineView isItemExpandable:(id)item
+/* Required for drag & drop and reordering */
+- (BOOL)outlineView:(NSOutlineView *)outlineView writeItems:(NSArray *)items toPasteboard:(NSPasteboard *)pboard
 {
-    int i_return = 0;
-    playlist_t * p_playlist = vlc_object_find( VLCIntf, VLC_OBJECT_PLAYLIST,
-                                                       FIND_ANYWHERE );
-    if( p_playlist == NULL )
-        return NO;
+    unsigned int i;
+    playlist_t *p_playlist = vlc_object_find( VLCIntf, VLC_OBJECT_PLAYLIST,
+                                               FIND_ANYWHERE );
 
-    if( item == nil )
-    {
-        /* root object */
-        playlist_view_t *p_view;
-        p_view = playlist_ViewFind( p_playlist, VIEW_SIMPLE );
-        if( p_view && p_view->p_root )
-            i_return = p_view->p_root->i_children;
-    }
-    else
+    /* First remove the items that were moved during the last drag & drop
+       operation */
+    [o_items_array removeAllObjects];
+    [o_nodes_array removeAllObjects];
+
+    if( !p_playlist ) return NO;
+
+    for( i = 0 ; i < [items count] ; i++ )
     {
-        playlist_item_t *p_item = (playlist_item_t *)[item pointerValue];
-        if( p_item )
-            i_return = p_item->i_children;
+        id o_item = [items objectAtIndex: i];
+
+        /* Refuse to move items that are not in the General Node
+           (Service Discovery) */
+        if( ![self isItem: [o_item pointerValue] inNode:
+                        p_playlist->p_local_category checkItemExistence: NO])
+        {
+            vlc_object_release(p_playlist);
+            return NO;
+        }
+        /* Fill the items and nodes to move in 2 different arrays */
+        if( ((playlist_item_t *)[o_item pointerValue])->i_children > 0 )
+            [o_nodes_array addObject: o_item];
+        else
+            [o_items_array addObject: o_item];
     }
-    vlc_object_release( p_playlist );
 
-    if( i_return == -1 || i_return == 0 )
-        return NO;
-    else
-        return YES;
+    /* Now we need to check if there are selected items that are in already
+       selected nodes. In that case, we only want to move the nodes */
+    [self removeItemsFrom: o_nodes_array ifChildrenOf: o_nodes_array];
+    [self removeItemsFrom: o_items_array ifChildrenOf: o_nodes_array];
+
+    /* We add the "VLCPlaylistItemPboardType" type to be able to recognize
+       a Drop operation coming from the playlist. */
+
+    [pboard declareTypes: [NSArray arrayWithObjects:
+        @"VLCPlaylistItemPboardType", nil] owner: self];
+    [pboard setData:[NSData data] forType:@"VLCPlaylistItemPboardType"];
+
+    vlc_object_release(p_playlist);
+    return YES;
 }
 
-/* retrieve the string values for the cells */
-- (id)outlineView:(NSOutlineView *)outlineView objectValueForTableColumn:(NSTableColumn *)o_tc byItem:(id)item
+- (NSDragOperation)outlineView:(NSOutlineView *)outlineView validateDrop:(id <NSDraggingInfo>)info proposedItem:(id)item proposedChildIndex:(int)index
 {
-    id o_value = nil;
-    intf_thread_t * p_intf = VLCIntf;
-    playlist_t * p_playlist = vlc_object_find( p_intf, VLC_OBJECT_PLAYLIST,
+    playlist_t *p_playlist = vlc_object_find( VLCIntf, VLC_OBJECT_PLAYLIST,
                                                FIND_ANYWHERE );
-    playlist_item_t *p_item = (playlist_item_t *)[item pointerValue];
+    NSPasteboard *o_pasteboard = [info draggingPasteboard];
+
+    if( !p_playlist ) return NSDragOperationNone;
 
-    if( p_playlist == NULL || p_item == NULL )
+    /* Dropping ON items is not allowed if item is not a node */
+    if( item )
     {
-        return( @"error" );
+        if( index == NSOutlineViewDropOnItemIndex &&
+                ((playlist_item_t *)[item pointerValue])->i_children == -1 )
+        {
+            vlc_object_release( p_playlist );
+            return NSDragOperationNone;
+        }
     }
 
-    if( [[o_tc identifier] isEqualToString:@"1"] )
+    /* We refuse to drop an item in anything else than a child of the General
+       Node. We still accept items that would be root nodes of the outlineview
+       however, to allow drop in an empty playlist. */
+    if( !([self isItem: [item pointerValue] inNode: p_playlist->p_local_category
+                                    checkItemExistence: NO] || item == nil) )
     {
-        o_value = [NSString stringWithUTF8String:
-            p_item->input.psz_name];
-        if( o_value == NULL )
-            o_value = [NSString stringWithCString:
-                p_item->input.psz_name];
+        vlc_object_release( p_playlist );
+        return NSDragOperationNone;
     }
-    else if( [[o_tc identifier] isEqualToString:@"2"] )
-    {
-        char *psz_temp;
-        psz_temp = playlist_ItemGetInfo( p_item ,_("Meta-information"),_("Artist") );
 
-        if( psz_temp == NULL )
-            o_value = @"";
-        else
+    /* Drop from the Playlist */
+    if( [[o_pasteboard types] containsObject: @"VLCPlaylistItemPboardType"] )
+    {
+        unsigned int i;
+        for( i = 0 ; i < [o_nodes_array count] ; i++ )
         {
-            o_value = [NSString stringWithUTF8String: psz_temp];
-            if( o_value == NULL )
+            /* We refuse to Drop in a child of an item we are moving */
+            if( [self isItem: [item pointerValue] inNode:
+                    [[o_nodes_array objectAtIndex: i] pointerValue]
+                    checkItemExistence: NO] )
             {
-                o_value = [NSString stringWithCString: psz_temp];
+                vlc_object_release( p_playlist );
+                return NSDragOperationNone;
             }
-            free( psz_temp );
         }
+        vlc_object_release(p_playlist);
+        return NSDragOperationMove;
     }
-    else if( [[o_tc identifier] isEqualToString:@"3"] )
+
+    /* Drop from the Finder */
+    else if( [[o_pasteboard types] containsObject: NSFilenamesPboardType] )
     {
-        char psz_duration[MSTRTIME_MAX_SIZE];
-        mtime_t dur = p_item->input.i_duration;
-        if( dur != -1 )
+        vlc_object_release(p_playlist);
+        return NSDragOperationGeneric;
+    }
+    vlc_object_release(p_playlist);
+    return NSDragOperationNone;
+}
+
+- (BOOL)outlineView:(NSOutlineView *)outlineView acceptDrop:(id <NSDraggingInfo>)info item:(id)item childIndex:(int)index
+{
+    playlist_t * p_playlist =  vlc_object_find( VLCIntf, VLC_OBJECT_PLAYLIST,
+                                                       FIND_ANYWHERE );
+    NSPasteboard *o_pasteboard = [info draggingPasteboard];
+
+    if( !p_playlist ) return NO;
+
+    /* Drag & Drop inside the playlist */
+    if( [[o_pasteboard types] containsObject: @"VLCPlaylistItemPboardType"] )
+    {
+        int i_row, i_removed_from_node = 0;
+        unsigned int i;
+        playlist_item_t *p_new_parent, *p_item = NULL;
+        NSArray *o_all_items = [o_nodes_array arrayByAddingObjectsFromArray:
+                                                                o_items_array];
+        /* If the item is to be dropped as root item of the outline, make it a
+           child of the General node.
+           Else, choose the proposed parent as parent. */
+        if( item == nil ) p_new_parent = p_playlist->p_local_category;
+        else p_new_parent = [item pointerValue];
+
+        /* Make sure the proposed parent is a node.
+           (This should never be true) */
+        if( p_new_parent->i_children < 0 )
         {
-            secstotimestr( psz_duration, dur/1000000 );
-            o_value = [NSString stringWithUTF8String: psz_duration];
+            vlc_object_release( p_playlist );
+            return NO;
         }
-        else
+
+        for( i = 0; i < [o_all_items count]; i++ )
         {
-            o_value = @"-:--:--";
+            playlist_item_t *p_old_parent = NULL;
+            int i_old_index = 0;
+
+            p_item = [[o_all_items objectAtIndex:i] pointerValue];
+            p_old_parent = p_item->p_parent;
+            if( !p_old_parent )
+            continue;
+            /* We may need the old index later */
+            if( p_new_parent == p_old_parent )
+            {
+                int j;
+                for( j = 0; j < p_old_parent->i_children; j++ )
+                {
+                    if( p_old_parent->pp_children[j] == p_item )
+                    {
+                        i_old_index = j;
+                        break;
+                    }
+                }
+            }
+
+            vlc_mutex_lock( &p_playlist->object_lock );
+            // Acually detach the item from the old position
+            if( playlist_NodeRemoveItem( p_playlist, p_item, p_old_parent ) ==
+                VLC_SUCCESS )
+            {
+                int i_new_index;
+                /* Calculate the new index */
+                if( index == -1 )
+                i_new_index = -1;
+                /* If we move the item in the same node, we need to take into
+                   account that one item will be deleted */
+                else
+                {
+                    if ((p_new_parent == p_old_parent &&
+                                   i_old_index < index + (int)i) )
+                    {
+                        i_removed_from_node++;
+                    }
+                    i_new_index = index + i - i_removed_from_node;
+                }
+                // Reattach the item to the new position
+                playlist_NodeInsert( p_playlist, p_item, p_new_parent, i_new_index );
+            }
+            vlc_mutex_unlock( &p_playlist->object_lock );
+        }
+        [self playlistUpdated];
+        i_row = [o_outline_view rowForItem:[o_outline_dict
+            objectForKey:[NSString stringWithFormat: @"%p",
+            [[o_all_items objectAtIndex: 0] pointerValue]]]];
+
+        if( i_row == -1 )
+        {
+            i_row = [o_outline_view rowForItem:[o_outline_dict
+            objectForKey:[NSString stringWithFormat: @"%p", p_new_parent]]];
         }
+
+        [o_outline_view deselectAll: self];
+        [o_outline_view selectRow: i_row byExtendingSelection: NO];
+        [o_outline_view scrollRowToVisible: i_row];
+
+        vlc_object_release(p_playlist);
+        return YES;
     }
 
-    vlc_object_release( p_playlist );
+    else if( [[o_pasteboard types] containsObject: NSFilenamesPboardType] )
+    {
+        int i;
+        playlist_item_t *p_node = [item pointerValue];
 
-    return( o_value );
-}
+        NSArray *o_array = [NSArray array];
+        NSArray *o_values = [[o_pasteboard propertyListForType:
+                                        NSFilenamesPboardType]
+                                sortedArrayUsingSelector:
+                                        @selector(caseInsensitiveCompare:)];
 
-/* Required for drag & drop and reordering */
-- (BOOL)outlineView:(NSOutlineView *)outlineView writeItems:(NSArray *)items toPasteboard:(NSPasteboard *)pboard
-{
-    return NO;
-}
+        for( i = 0; i < (int)[o_values count]; i++)
+        {
+            NSDictionary *o_dic;
+            o_dic = [NSDictionary dictionaryWithObject:[o_values
+                        objectAtIndex:i] forKey:@"ITEM_URL"];
+            o_array = [o_array arrayByAddingObject: o_dic];
+        }
 
-- (NSDragOperation)outlineView:(NSOutlineView *)outlineView validateDrop:(id <NSDraggingInfo>)info proposedItem:(id)item proposedChildIndex:(int)index
-{
-    return NSDragOperationNone;
+        if ( item == nil )
+        {
+            [self appendArray: o_array atPos: index enqueue: YES];
+        }
+        /* This should never occur */
+        else if( p_node->i_children == -1 )
+        {
+            vlc_object_release( p_playlist );
+            return NO;
+        }
+        else
+        {
+            [self appendNodeArray: o_array inNode: p_node
+                atPos: index enqueue: YES];
+        }
+        vlc_object_release( p_playlist );
+        return YES;
+    }
+    vlc_object_release( p_playlist );
+    return NO;
 }
 
 /* Delegate method of NSWindow */