]> git.sesse.net Git - vlc/blobdiff - modules/gui/macosx/playlist.m
macosx: fixed playlist/video toggling and some memory leaks
[vlc] / modules / gui / macosx / playlist.m
index f3d62dd56f08d5f68b3038c120c05094c0666569..e6846c6b3c434c25693be15a2cabc0a3fff7176a 100644 (file)
 #import "playlist.h"
 #import "controls.h"
 #import "misc.h"
-#import "sidebarview.h"
 
 #include <vlc_keys.h>
 #import <vlc_services_discovery.h>
 #import <vlc_osd.h>
 #import <vlc_interface.h>
 
+#include <vlc_url.h>
+
 
 /*****************************************************************************
  * VLCPlaylistView implementation
 }
 - (void)awakeFromNib
 {
-    playlist_t * p_playlist = pl_Hold( VLCIntf );
+    playlist_t * p_playlist = pl_Get( VLCIntf );
     [o_outline_view setTarget: self];
     [o_outline_view setDelegate: self];
     [o_outline_view setDataSource: self];
     [o_outline_view_other setDataSource: self];
     [o_outline_view_other setAllowsEmptySelection: NO];
 
-    pl_Release( VLCIntf );
     [self initStrings];
 }
 
 {
     int i_return = 0;
     playlist_item_t *p_item = NULL;
-    playlist_t * p_playlist = pl_Hold( VLCIntf );
+    playlist_t * p_playlist = pl_Get( VLCIntf );
     //assert( outlineView == o_outline_view );
 
     if( !item )
     if( p_item )
         i_return = p_item->i_children;
 
-    pl_Release( VLCIntf );
-
     return i_return > 0 ? i_return : 0;
 }
 
 {
     playlist_item_t *p_return = NULL, *p_item = NULL;
     NSValue *o_value;
-    playlist_t * p_playlist = pl_Hold( VLCIntf );
+    playlist_t * p_playlist = pl_Get( VLCIntf );
 
     PL_LOCK;
     if( item == nil )
         p_return = p_item->pp_children[index];
     PL_UNLOCK;
 
-    pl_Release( VLCIntf );
-
     o_value = [o_outline_dict objectForKey:[NSString stringWithFormat: @"%p", p_return]];
 
     if( o_value == nil )
     {
         /* FIXME: Why is there a warning if that happens all the time and seems
-         * to be normal? Add an assert and fix it. 
+         * to be normal? Add an assert and fix it.
          * msg_Warn( VLCIntf, "playlist item misses pointer value, adding one" ); */
         o_value = [[NSValue valueWithPointer: p_return] retain];
     }
 - (BOOL)outlineView:(NSOutlineView *)outlineView isItemExpandable:(id)item
 {
     int i_return = 0;
-    playlist_t *p_playlist = pl_Hold( VLCIntf );
+    playlist_t *p_playlist = pl_Get( VLCIntf );
 
     PL_LOCK;
     if( item == nil )
             i_return = p_item->i_children;
     }
     PL_UNLOCK;
-    pl_Release( VLCIntf );
 
     return (i_return >= 0);
 }
         }
         return @"error" ;
     }
+
     p_item = (playlist_item_t *)[item pointerValue];
     if( !p_item || !p_item->p_input )
     {
         }
         return @"error";
     }
+
     attempted_reload = NO;
 
     if( [[o_tc identifier] isEqualToString:@"name"] )
     {
         if( input_item_HasErrorWhenReading( p_item->p_input ) )
         {
-            o_value = [NSImage imageWithWarningIcon];
+            o_value = [[NSWorkspace sharedWorkspace] iconForFileType:NSFileTypeForHFSTypeCode(kAlertCautionIcon)];
+            [o_value setSize: NSMakeSize(16,16)];
         }
     }
     return o_value;
 
 - (void)awakeFromNib
 {
-    playlist_t * p_playlist = pl_Hold( VLCIntf );
+    playlist_t * p_playlist = pl_Get( VLCIntf );
 
     int i;
 
     o_tc_sortColumn = nil;
 
     char ** ppsz_name;
-    char ** ppsz_services = vlc_sd_GetNames( &ppsz_name );
+    char ** ppsz_services = vlc_sd_GetNames( VLCIntf, &ppsz_name, NULL );
     if( !ppsz_services )
-    {
-        pl_Release( VLCIntf );
         return;
-    }
-    
+
     for( i = 0; ppsz_services[i]; i++ )
     {
         bool  b_enabled;
     }
     free( ppsz_services );
     free( ppsz_name );
-
-    pl_Release( VLCIntf );
 }
 
 - (void)searchfieldChanged:(NSNotification *)o_notification
     [o_mi_sort_author setTitle: _NS("Sort Node by Author")];
     [o_mi_services setTitle: _NS("Services discovery")];
     [o_mm_mi_services setTitle: _NS("Services discovery")];
-    [o_status_field setStringValue: _NS("No items in the playlist")];
-    [o_status_field_embed setStringValue: _NS("No items in the playlist")];
 
     [o_search_field setToolTip: _NS("Search in Playlist")];
     [o_search_field_other setToolTip: _NS("Search in Playlist")];
-    [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")];
     // TODO Find a way to keep the dict size to a minimum
     //[o_outline_dict removeAllObjects];
     [o_outline_view reloadData];
-    [o_sidebar updateSidebar:[self playingItem]];
     [[[[VLCMain sharedInstance] wizard] playlistWizard] reloadOutlineView];
     [[[[VLCMain sharedInstance] bookmarks] dataTable] reloadData];
 
-    playlist_t *p_playlist = pl_Hold( VLCIntf );
-
-    PL_LOCK;
-    if( playlist_CurrentSize( p_playlist ) >= 2 )
-    {
-        [o_status_field setStringValue: [NSString stringWithFormat:
-                    _NS("%i items"),
-                playlist_CurrentSize( p_playlist )]];
-        [o_status_field_embed setStringValue: [NSString stringWithFormat:
-                                               _NS("%i items"),
-                                               playlist_CurrentSize( p_playlist )]];        
-    }
-    else
-    {
-        if( playlist_IsEmpty( p_playlist ) )
-        {
-            [o_status_field setStringValue: _NS("No items in the playlist")];
-            [o_status_field_embed setStringValue: _NS("No items in the playlist")];
-        }
-        else
-        {
-            [o_status_field setStringValue: _NS("1 item")];
-            [o_status_field_embed setStringValue: _NS("1 item")];
-        }
-    }
-    PL_UNLOCK;
-    pl_Release( VLCIntf );
-
     [self outlineViewSelectionDidChange: nil];
 }
 
-- (void)playModeUpdated
-{
-    playlist_t *p_playlist = pl_Hold( VLCIntf );
-
-    bool loop = var_GetBool( p_playlist, "loop" );
-    bool repeat = var_GetBool( p_playlist, "repeat" );
-    if( repeat )
-        [[[VLCMain sharedInstance] controls] repeatOne];
-    else if( loop )
-        [[[VLCMain sharedInstance] controls] repeatAll];
-    else
-        [[[VLCMain sharedInstance] controls] repeatOff];
-
-    [[[VLCMain sharedInstance] controls] shuffle];
-
-    pl_Release( VLCIntf );
-}
-
 - (void)outlineViewSelectionDidChange:(NSNotification *)notification
 {
     // FIXME: unsafe
             free( psz_uri );
         }
 
-        if( [[VLCMain sharedInstance] isPlaylistCollapsed] == NO )
-        {
-            /* update our info-panel to reflect the new item, if we aren't collapsed */
-            [[[VLCMain sharedInstance] info] updatePanelWithItem:p_item->p_input];
-        }
+        /* update our info-panel to reflect the new item */
+        [[[VLCMain sharedInstance] info] updatePanelWithItem:p_item->p_input];
     }
 }
 
     unsigned int j;
 
     // FIXME: unsafe
-    playlist_t *p_playlist = pl_Hold( VLCIntf );
+    playlist_t *p_playlist = pl_Get( VLCIntf );
     playlist_item_t *p_item, *p_temp_item;
     NSMutableArray *o_array = [NSMutableArray array];
 
     if( p_item == NULL )
     {
         PL_UNLOCK;
-        pl_Release( VLCIntf );
         return;
     }
 
             [o_outline_view expandItem: o_item];
         }
     }
-
-    pl_Release( VLCIntf );
 }
 
 /* Check if p_item is a child of p_node recursively. We need to check the item
                     locked:(BOOL)b_locked
 
 {
-    playlist_t * p_playlist = pl_Hold( VLCIntf );
+    playlist_t * p_playlist = pl_Get( VLCIntf );
     playlist_item_t *p_temp_item = p_item;
 
     if( p_node == p_item )
-    {
-        pl_Release( VLCIntf );
         return YES;
-    }
 
     if( p_node->i_children < 1)
-    {
-        pl_Release( VLCIntf );
         return NO;
-    }
 
     if ( p_temp_item )
     {
                 else if ( i == p_playlist->all_items.i_size - 1 )
                 {
                     if(!b_locked) PL_UNLOCK;
-                    pl_Release( VLCIntf );
                     return NO;
                 }
             }
             if( p_temp_item == p_node )
             {
                 if(!b_locked) PL_UNLOCK;
-                pl_Release( VLCIntf );
                 return YES;
             }
         }
         if(!b_locked) PL_UNLOCK;
     }
-
-    pl_Release( VLCIntf );
     return NO;
 }
 
                     inNode: (playlist_item_t *)p_node
                     checkItemExistence:(BOOL)b_check
 {
-    [self isItem:p_item inNode:p_node checkItemExistence:b_check locked:NO];
+    return [self isItem:p_item inNode:p_node checkItemExistence:b_check locked:NO];
 }
 
-/* This method is usefull for instance to remove the selected children of an
+/* This method is useful for instance to remove the selected children of an
    already selected node */
 - (void)removeItemsFrom:(id)o_items ifChildrenOf:(id)o_nodes
 {
 
 - (IBAction)savePlaylist:(id)sender
 {
-    playlist_t * p_playlist = pl_Hold( VLCIntf );
+    playlist_t * p_playlist = pl_Get( VLCIntf );
 
     NSSavePanel *o_save_panel = [NSSavePanel savePanel];
     NSString * o_name = [NSString stringWithFormat: @"%@", _NS("Untitled")];
     if( [o_save_panel runModalForDirectory: nil
             file: o_name] == NSOKButton )
     {
-        NSString *o_filename = [o_save_panel filename];
+        NSString *o_filename = [[o_save_panel URL] path];
 
         if( [o_save_accessory_popup indexOfSelectedItem] == 0 )
         {
                 p_playlist->p_local_category, "export-html" );
         }
     }
-    pl_Release( VLCIntf );
 }
 
 /* When called retrieves the selected outlineview row and plays that node or item */
 - (IBAction)playItem:(id)sender
 {
     intf_thread_t * p_intf = VLCIntf;
-    playlist_t * p_playlist = pl_Hold( p_intf );
+    playlist_t * p_playlist = pl_Get( p_intf );
 
     playlist_item_t *p_item;
     playlist_item_t *p_node = NULL;
         playlist_Control( p_playlist, PLAYLIST_VIEWPLAY, pl_Locked, p_node, p_item );
     }
     PL_UNLOCK;
-    pl_Release( p_intf );
-}
-
-- (void)playSidebarItem:(id)item
-{
-    intf_thread_t * p_intf = VLCIntf;
-    playlist_t * p_playlist = pl_Hold( p_intf );
-    
-    playlist_item_t *p_item;
-    playlist_item_t *p_node = NULL;
-    
-    p_item = [item pointerValue];
-    
-    if( p_item )
-    {
-        if( p_item->i_children == -1 )
-        {
-            p_node = p_item->p_parent;
-            
-        }
-        else
-        {
-            p_node = p_item;
-            if( p_node->i_children > 0 && p_node->pp_children[0]->i_children == -1 )
-            {
-                p_item = p_node->pp_children[0];
-            }
-            else
-            {
-                p_item = NULL;
-            }
-        }
-        playlist_Control( p_playlist, PLAYLIST_VIEWPLAY, pl_Unlocked, p_node, p_item );
-    }
-    pl_Release( p_intf );
 }
 
 - (IBAction)revealItemInFinder:(id)sender
 
     if(! p_item || !p_item->p_input )
         return;
-    
-    char *psz_uri = input_item_GetURI( p_item->p_input );
+
+    char *psz_uri = decode_URI( input_item_GetURI( p_item->p_input ) );
     if( psz_uri )
         o_mrl = [NSMutableString stringWithUTF8String: psz_uri];
 
     NSRange prefix_range = [o_mrl rangeOfString: @"file:"];
     if( prefix_range.location != NSNotFound )
         [o_mrl deleteCharactersInRange: prefix_range];
-    
+
     if( [o_mrl characterAtIndex:0] == '/' )
         [[NSWorkspace sharedWorkspace] selectFile: o_mrl inFileViewerRootedAtPath: o_mrl];
-}    
+}
 
 /* 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 = pl_Hold( p_intf );
+    playlist_t * p_playlist = pl_Get( p_intf );
+
     o_to_preparse = [NSMutableArray arrayWithArray:[[o_outline_view selectedRowEnumerator] allObjects]];
     i_count = [o_to_preparse count];
 
         {
             if( p_item->i_children == -1 )
             {
-                playlist_PreparseEnqueue( p_playlist, p_item->p_input, pl_Unlocked );
+                playlist_PreparseEnqueue( p_playlist, p_item->p_input );
             }
             else
             {
             }
         }
     }
-    pl_Release( p_intf );
     [self playlistUpdated];
 }
 
     int i_count;
     NSMutableArray *o_to_preparse;
     intf_thread_t * p_intf = VLCIntf;
-    playlist_t * p_playlist = pl_Hold( p_intf );
+    playlist_t * p_playlist = pl_Get( p_intf );
 
     o_to_preparse = [NSMutableArray arrayWithArray:[[o_outline_view selectedRowEnumerator] allObjects]];
     i_count = [o_to_preparse count];
 
         if( p_item && p_item->i_children == -1 )
         {
-            playlist_AskForArtEnqueue( p_playlist, p_item->p_input, pl_Unlocked );
+            playlist_AskForArtEnqueue( p_playlist, p_item->p_input );
         }
     }
-    pl_Release( p_intf );
     [self playlistUpdated];
 }
 
 {
     NSMenuItem *o_mi = (NSMenuItem *)sender;
     NSString *o_string = [o_mi representedObject];
-    playlist_t * p_playlist = pl_Hold( VLCIntf );
+    playlist_t * p_playlist = pl_Get( VLCIntf );
     if( !playlist_IsServicesDiscoveryLoaded( p_playlist, [o_string UTF8String] ) )
         playlist_ServicesDiscoveryAdd( p_playlist, [o_string UTF8String] );
     else
     [o_mi setState: playlist_IsServicesDiscoveryLoaded( p_playlist,
                                           [o_string UTF8String] ) ? YES : NO];
 
-    pl_Release( VLCIntf );
     [self playlistUpdated];
     return;
 }
     o_to_delete = [NSMutableArray arrayWithArray:[[o_outline_view selectedRowEnumerator] allObjects]];
     i_count = [o_to_delete count];
 
-    p_playlist = pl_Hold( p_intf );
+    p_playlist = pl_Get( p_intf );
 
     for( int i = 0; i < i_count; i++ )
     {
         PL_LOCK;
         playlist_item_t *p_item = [o_item pointerValue];
 #ifndef NDEBUG
-        msg_Dbg( p_intf, "deleting item %i (of %i) with id \"%i\", pointerValue \"%p\" and %i children", i+1, i_count, 
+        msg_Dbg( p_intf, "deleting item %i (of %i) with id \"%i\", pointerValue \"%p\" and %i children", i+1, i_count,
                 p_item->p_input->i_id, [o_item pointerValue], p_item->i_children +1 );
 #endif
         [o_to_delete removeObject: o_number];
                         checkItemExistence: NO locked:YES] == YES )
                 // if current item is in selected node and is playing then stop playlist
                 playlist_Control(p_playlist, PLAYLIST_STOP, pl_Locked );
-    
+
             playlist_NodeDelete( p_playlist, p_item, true, false );
         }
         else
     }
 
     [self playlistUpdated];
-    pl_Release( p_intf );
 }
 
 - (IBAction)sortNodeByName:(id)sender
 
 - (void)sortNode:(int)i_mode
 {
-    playlist_t * p_playlist = pl_Hold( VLCIntf );
+    playlist_t * p_playlist = pl_Get( VLCIntf );
     playlist_item_t * p_item;
 
     if( [o_outline_view selectedRow] > -1 )
                 p_item->p_parent, i_mode, ORDER_NORMAL );
     }
     PL_UNLOCK;
-    pl_Release( VLCIntf );
     [self playlistUpdated];
 }
 
 - (input_item_t *)createItem:(NSDictionary *)o_one_item
 {
     intf_thread_t * p_intf = VLCIntf;
-    playlist_t * p_playlist = pl_Hold( p_intf );
+    playlist_t * p_playlist = pl_Get( p_intf );
 
     input_item_t *p_input;
     int i;
         o_uri = o_temp;
     }
 
-    p_input = input_item_New( p_playlist, [o_uri fileSystemRepresentation], o_name ? [o_name UTF8String] : NULL );
+    p_input = input_item_New( [o_uri fileSystemRepresentation], o_name ? [o_name UTF8String] : NULL );
     if( !p_input )
-    {
-        pl_Release( p_intf );
         return NULL;
-    }
 
     if( o_options )
     {
     }
 
     /* Recent documents menu */
-    o_true_file = [NSURL fileURLWithPath: o_uri];
+    o_true_file = [NSURL URLWithString: o_uri];
     if( o_true_file != nil && (BOOL)config_GetInt( p_playlist, "macosx-recentitems" ) == YES )
     {
         [[NSDocumentController sharedDocumentController]
             noteNewRecentDocumentURL: o_true_file];
     }
-
-    pl_Release( p_intf );
     return p_input;
 }
 
 - (void)appendArray:(NSArray*)o_array atPos:(int)i_position enqueue:(BOOL)b_enqueue
 {
     int i_item;
-    playlist_t * p_playlist = pl_Hold( VLCIntf );
+    playlist_t * p_playlist = pl_Get( VLCIntf );
 
     PL_LOCK;
     for( i_item = 0; i_item < (int)[o_array count]; i_item++ )
 
         /* Add the item */
         /* FIXME: playlist_AddInput() can fail */
-        
+
         playlist_AddInput( p_playlist, p_input, PLAYLIST_INSERT,
              i_position == -1 ? PLAYLIST_END : i_position + i_item, true,
          pl_Locked );
     PL_UNLOCK;
 
     [self playlistUpdated];
-    pl_Release( VLCIntf );
 }
 
 - (void)appendNodeArray:(NSArray*)o_array inNode:(playlist_item_t *)p_node atPos:(int)i_position enqueue:(BOOL)b_enqueue
 {
     int i_item;
-    playlist_t * p_playlist = pl_Hold( VLCIntf );
+    playlist_t * p_playlist = pl_Get( VLCIntf );
 
     for( i_item = 0; i_item < (int)[o_array count]; i_item++ )
     {
         if( !p_input ) continue;
 
         /* Add the item */
-        /* FIXME: playlist_BothAddInput() can fail */
         PL_LOCK;
-        playlist_BothAddInput( p_playlist, p_input, p_node,
+        playlist_NodeAddInput( p_playlist, p_input, p_node,
                                       PLAYLIST_INSERT,
                                       i_position == -1 ?
                                       PLAYLIST_END : i_position + i_item,
-                                      NULL, NULL, pl_Locked );
+                                      pl_Locked );
 
 
         if( i_item == 0 && !b_enqueue )
         vlc_gc_decref( p_input );
     }
     [self playlistUpdated];
-    pl_Release( VLCIntf );
 }
 
 - (NSMutableArray *)subSearchItem:(playlist_item_t *)p_item
 {
-    playlist_t *p_playlist = pl_Hold( VLCIntf );
+    playlist_t *p_playlist = pl_Get( VLCIntf );
     playlist_item_t *p_selected_item;
     int i_current, i_selected_row;
 
         else if( p_selected_item == p_item->pp_children[i_current] &&
                     b_selected_item_met == YES )
         {
-            pl_Release( VLCIntf );
             return NULL;
         }
         else if( b_selected_item_met == YES &&
                       [o_current_author rangeOfString:[o_search_field
                         stringValue] options:NSCaseInsensitiveSearch].length ) )
         {
-            pl_Release( VLCIntf );
             /*Adds the parent items in the result array as well, so that we can
             expand the tree*/
             return [NSMutableArray arrayWithObject: [NSValue
                                             p_item->pp_children[i_current]];
             if( o_result != NULL )
             {
-                pl_Release( VLCIntf );
                 [o_result insertObject: [NSValue valueWithPointer:
                                 p_item->pp_children[i_current]] atIndex:0];
                 return o_result;
             }
         }
     }
-    pl_Release( VLCIntf );
     return NULL;
 }
 
 - (IBAction)searchItem:(id)sender
 {
-    playlist_t * p_playlist = pl_Hold( VLCIntf );
+    playlist_t * p_playlist = pl_Get( VLCIntf );
     id o_result;
 
     unsigned int i;
                [o_outline_view selectRowIndexes:[NSIndexSet indexSetWithIndex:i_row] byExtendingSelection:NO];
         [o_outline_view scrollRowToVisible: i_row];
     }
-    pl_Release( VLCIntf );
 }
 
 - (IBAction)recursiveExpandNode:(id)sender
     int i_mode, i_type = 0;
     intf_thread_t *p_intf = VLCIntf;
 
-    playlist_t *p_playlist = pl_Hold( p_intf );
+    playlist_t *p_playlist = pl_Get( p_intf );
 
     /* Check whether the selected table column header corresponds to a
        sortable table column*/
     if( !( o_tc == o_tc_name || o_tc == o_tc_author ) )
     {
-        pl_Release( p_intf );
         return;
     }
 
     playlist_RecursiveNodeSort( p_playlist, p_playlist->p_root_category, i_mode, i_type );
     PL_UNLOCK;
 
-    pl_Release( p_intf );
     [self playlistUpdated];
 
     o_tc_sortColumn = o_tc;
                                 forTableColumn:(NSTableColumn *)tableColumn
                                 item:(id)item
 {
-    playlist_t *p_playlist = pl_Hold( VLCIntf );
+    playlist_t *p_playlist = pl_Get( VLCIntf );
 
     id o_playing_item;
 
     {
         [cell setFont: [[NSFontManager sharedFontManager] convertFont:[cell font] toNotHaveTrait:NSBoldFontMask]];
     }
-    pl_Release( VLCIntf );
 }
 
 - (id)playingItem
 {
-    playlist_t *p_playlist = pl_Hold( VLCIntf );
-    
+    playlist_t *p_playlist = pl_Get( VLCIntf );
+
     id o_playing_item;
 
     PL_LOCK;
-    o_playing_item = [o_outline_dict objectForKey:
-                      [NSString stringWithFormat:@"%p",  playlist_CurrentPlayingItem( p_playlist )]];
+    o_playing_item = [o_outline_dict objectForKey: [NSString stringWithFormat:@"%p",  playlist_CurrentPlayingItem( p_playlist )]];
     PL_UNLOCK;
 
-    pl_Release( VLCIntf );
-    
     return o_playing_item;
 }
-
-- (IBAction)addNode:(id)sender
-{
-    playlist_t * p_playlist = pl_Hold( VLCIntf );
-    vlc_thread_set_priority( p_playlist, VLC_THREAD_PRIORITY_LOW );
-
-    PL_LOCK;
-    playlist_NodeCreate( p_playlist, _("Empty Folder"),
-                                      p_playlist->p_local_category, 0, NULL );
-    PL_UNLOCK;
-
-    pl_Release( VLCIntf );
-
-    [self playlistUpdated];
-}
 @end
 
 @implementation VLCPlaylist (NSOutlineViewDataSource)
 - (id)outlineView:(NSOutlineView *)outlineView child:(NSInteger)index ofItem:(id)item
 {
     id o_value = [super outlineView: outlineView child: index ofItem: item];
-    playlist_t *p_playlist = pl_Hold( VLCIntf );
-
-    PL_LOCK;
-    if( playlist_CurrentSize( p_playlist )  >= 2 )
-    {
-        [o_status_field setStringValue: [NSString stringWithFormat:
-                    _NS("%i items"),
-             playlist_CurrentSize( p_playlist )]];
-        [o_status_field_embed setStringValue: [NSString stringWithFormat:
-                                               _NS("%i items"),
-                                               playlist_CurrentSize( p_playlist )]];
-    }
-    else
-    {
-        if( playlist_IsEmpty( p_playlist ) )
-        {
-            [o_status_field setStringValue: _NS("No items in the playlist")];
-            [o_status_field_embed setStringValue: _NS("No items in the playlist")];
-        }
-        else
-        {
-            [o_status_field setStringValue: _NS("1 item")];
-            [o_status_field_embed setStringValue: _NS("1 item")];
-        }
-    }
-    PL_UNLOCK;
-
-    pl_Release( VLCIntf );
 
     [o_outline_dict setObject:o_value forKey:[NSString stringWithFormat:@"%p",
                                                     [o_value pointerValue]]];
 - (BOOL)outlineView:(NSOutlineView *)outlineView writeItems:(NSArray *)items toPasteboard:(NSPasteboard *)pboard
 {
     unsigned int i;
-    playlist_t *p_playlist = pl_Hold( VLCIntf );
+    playlist_t *p_playlist = pl_Get( VLCIntf );
 
     /* First remove the items that were moved during the last drag & drop
        operation */
 
         /* 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] &&
-            var_CreateGetBool( p_playlist, "media-library" ) &&
-            ![self isItem: [o_item pointerValue] inNode:
-                        p_playlist->p_ml_category checkItemExistence: NO] ||
+        if( (![self isItem: [o_item pointerValue] inNode: p_playlist->p_local_category checkItemExistence: NO] &&
+            var_CreateGetBool( p_playlist, "media-library" ) && ![self isItem: [o_item pointerValue] inNode: p_playlist->p_ml_category checkItemExistence: NO]) ||
             [o_item pointerValue] == p_playlist->p_local_category ||
             [o_item pointerValue] == p_playlist->p_ml_category )
         {
-            pl_Release( VLCIntf );
             return NO;
         }
         /* Fill the items and nodes to move in 2 different arrays */
         @"VLCPlaylistItemPboardType", nil] owner: self];
     [pboard setData:[NSData data] forType:@"VLCPlaylistItemPboardType"];
 
-    pl_Release( VLCIntf );
     return YES;
 }
 
 - (NSDragOperation)outlineView:(NSOutlineView *)outlineView validateDrop:(id <NSDraggingInfo>)info proposedItem:(id)item proposedChildIndex:(NSInteger)index
 {
-    playlist_t *p_playlist = pl_Hold( VLCIntf );
+    playlist_t *p_playlist = pl_Get( VLCIntf );
     NSPasteboard *o_pasteboard = [info draggingPasteboard];
 
     if( !p_playlist ) return NSDragOperationNone;
         if( index == NSOutlineViewDropOnItemIndex &&
                 ((playlist_item_t *)[item pointerValue])->i_children == -1 )
         {
-            pl_Release( VLCIntf );
             return NSDragOperationNone;
         }
     }
     /* Don't allow on drop on playlist root element's child */
     if( !item && index != NSOutlineViewDropOnItemIndex)
     {
-        pl_Release( VLCIntf );
         return NSDragOperationNone;
     }
 
     /* 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] || 
+    if( !( ([self isItem: [item pointerValue] inNode: p_playlist->p_local_category checkItemExistence: NO] ||
         ( var_CreateGetBool( p_playlist, "media-library" ) && [self isItem: [item pointerValue] inNode: p_playlist->p_ml_category checkItemExistence: NO] ) ) || item == nil ) )
     {
-        pl_Release( VLCIntf );
         return NSDragOperationNone;
     }
 
                     [[o_nodes_array objectAtIndex: i] pointerValue]
                     checkItemExistence: NO] )
             {
-                pl_Release( VLCIntf );
                 return NSDragOperationNone;
             }
         }
-        pl_Release( VLCIntf );
         return NSDragOperationMove;
     }
 
     /* Drop from the Finder */
     else if( [[o_pasteboard types] containsObject: NSFilenamesPboardType] )
     {
-        pl_Release( VLCIntf );
         return NSDragOperationGeneric;
     }
-    pl_Release( VLCIntf );
     return NSDragOperationNone;
 }
 
 - (BOOL)outlineView:(NSOutlineView *)outlineView acceptDrop:(id <NSDraggingInfo>)info item:(id)item childIndex:(NSInteger)index
 {
-    playlist_t * p_playlist =  pl_Hold( VLCIntf );
+    playlist_t * p_playlist =  pl_Get( VLCIntf );
     NSPasteboard *o_pasteboard = [info draggingPasteboard];
 
     /* Drag & Drop inside the playlist */
            (This should never be true) */
         if( p_new_parent->i_children < 0 )
         {
-            pl_Release( VLCIntf );
             return NO;
         }
 
         [o_outline_view selectRowIndexes:[NSIndexSet indexSetWithIndex:i_row] byExtendingSelection:NO];
         [o_outline_view scrollRowToVisible: i_row];
 
-        pl_Release( VLCIntf );
         return YES;
     }
 
         for( i = 0; i < (int)[o_values count]; i++)
         {
             NSDictionary *o_dic;
-            o_dic = [NSDictionary dictionaryWithObject:[o_values
-                        objectAtIndex:i] forKey:@"ITEM_URL"];
+            char *psz_uri = make_URI([[o_values objectAtIndex:i] UTF8String], NULL);
+            if( !psz_uri )
+                continue;
+
+            o_dic = [NSDictionary dictionaryWithObject:[NSString stringWithCString:psz_uri encoding:NSUTF8StringEncoding] forKey:@"ITEM_URL"];
+
+            free( psz_uri );
+
             o_array = [o_array arrayByAddingObject: o_dic];
         }
 
             [self appendNodeArray:o_array inNode: p_node
                 atPos:index enqueue:YES];
         }
-        pl_Release( VLCIntf );
         return YES;
     }
-    pl_Release( VLCIntf );
     return NO;
 }
 @end