e401a0689405839dc58fa0af6281cdb7888c3c91
[vlc.git] / plugins / gtk / gtk_playlist.c
1 /*****************************************************************************
2  * gtk_playlist.c : Interface for the playlist dialog
3  *****************************************************************************
4  * Copyright (C) 2001 VideoLAN
5  * $Id: gtk_playlist.c,v 1.32 2002/06/01 12:31:59 sam Exp $
6  *
7  * Authors: Pierre Baillet <oct@zoy.org>
8  *          St├ęphane Borel <stef@via.ecp.fr>
9  *      
10  * This program is free software; you can redistribute it and/or modify
11  * it under the terms of the GNU General Public License as published by
12  * the Free Software Foundation; either version 2 of the License, or
13  * (at your option) any later version.
14  * 
15  * This program is distributed in the hope that it will be useful,
16  * but WITHOUT ANY WARRANTY; without even the implied warranty of
17  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
18  * GNU General Public License for more details.
19  *
20  * You should have received a copy of the GNU General Public License
21  * along with this program; if not, write to the Free Software
22  * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111, USA.
23  *****************************************************************************/
24
25 /*****************************************************************************
26  * Preamble
27  *****************************************************************************/
28 #include <stdlib.h>
29 #include <string.h>
30
31 #include <vlc/vlc.h>
32 #include <vlc/intf.h>
33
34 #include <sys/types.h>          /* for readdir  and stat stuff */
35
36 #if (!defined( WIN32 ) || defined(__MINGW32__))
37 /* Mingw has its own version of dirent */
38 #   include <dirent.h>
39 #endif
40
41 #include <sys/stat.h>
42 #include <unistd.h>
43
44 #ifdef MODULE_NAME_IS_gnome
45 #   include <gnome.h>
46 #else
47 #   include <gtk/gtk.h>
48 #endif
49
50 #include "gtk_callbacks.h"
51 #include "gtk_interface.h"
52 #include "gtk_support.h"
53 #include "gtk_playlist.h"
54 #include "gtk_common.h"
55
56 /****************************************************************************
57  * Local prototypes
58  ****************************************************************************/
59 static void UrlDecode( char *encoded_path );
60
61 /****************************************************************************
62  * Playlist window management
63  ****************************************************************************/
64 gboolean GtkPlaylistShow( GtkWidget       *widget,
65                           GdkEventButton  *event,
66                           gpointer         user_data )
67 {
68 #if 0 /* PLAYLIST TARASS */
69     intf_thread_t *p_intf = GetIntf( GTK_WIDGET(widget), (char*)user_data );
70
71     if( GTK_WIDGET_VISIBLE( p_intf->p_sys->p_playlist ) )
72     {
73         gtk_widget_hide( p_intf->p_sys->p_playlist );
74     } 
75     else 
76     {        
77         GtkCList * p_clist;
78
79         p_clist = GTK_CLIST( gtk_object_get_data(
80             GTK_OBJECT( p_intf->p_sys->p_playlist ), "playlist_clist" ) );
81         GtkRebuildCList( p_clist , p_intf->p_vlc->p_playlist );
82         gtk_widget_show( p_intf->p_sys->p_playlist );
83         gdk_window_raise( p_intf->p_sys->p_playlist->window );
84     }
85 #endif
86
87     return TRUE;
88 }
89
90
91 void GtkPlaylistOk( GtkButton * button, gpointer user_data )
92 {
93      gtk_widget_hide( gtk_widget_get_toplevel( GTK_WIDGET (button) ) );
94 }
95
96
97 void GtkPlaylistCancel( GtkButton * button, gpointer user_data )
98 {
99      gtk_widget_hide( gtk_widget_get_toplevel( GTK_WIDGET (button) ) );
100 }
101
102
103
104 gboolean GtkPlaylistPrev( GtkWidget       *widget,
105                           GdkEventButton  *event,
106                           gpointer         user_data )
107 {
108 #if 0 /* PLAYLIST TARASS */
109     intf_thread_t *p_intf = GetIntf( GTK_WIDGET(widget), (char*)user_data );
110
111     if( p_intf->p_sys->p_input != NULL )
112     {
113         /* FIXME: temporary hack */
114         intf_PlaylistPrev( p_intf->p_vlc->p_playlist );
115         intf_PlaylistPrev( p_intf->p_vlc->p_playlist );
116         p_intf->p_sys->p_input->b_eof = 1;
117     }
118 #endif
119
120     return TRUE;
121 }
122
123
124 gboolean GtkPlaylistNext( GtkWidget       *widget,
125                           GdkEventButton  *event,
126                           gpointer         user_data)
127 {
128 #if 0 /* PLAYLIST TARASS */
129     intf_thread_t *p_intf = GetIntf( GTK_WIDGET(widget), (char*)user_data );
130
131     if( p_intf->p_sys->p_input != NULL )
132     {
133         /* FIXME: temporary hack */
134         p_intf->p_sys->p_input->b_eof = 1;
135     }
136 #endif
137
138     return TRUE;
139 }
140
141 /****************************************************************************
142  * Menu callbacks for playlist functions
143  ****************************************************************************/
144 void GtkPlaylistActivate( GtkMenuItem * menuitem, gpointer user_data )
145 {
146     GtkPlaylistShow( GTK_WIDGET( menuitem ), NULL, user_data );
147 }
148
149
150 void GtkNextActivate( GtkMenuItem * menuitem, gpointer user_data )
151 {
152     GtkPlaylistNext( GTK_WIDGET( menuitem ), NULL, user_data );
153 }
154
155
156 void GtkPrevActivate( GtkMenuItem * menuitem, gpointer user_data )
157 {
158     GtkPlaylistPrev( GTK_WIDGET( menuitem ), NULL, user_data );
159 }
160
161
162 /****************************************************************************
163  * Playlist core functions
164  ****************************************************************************/
165 void GtkPlaylistAddUrl( GtkMenuItem * menuitem, gpointer user_data )
166 {
167
168 }
169
170
171 void GtkPlaylistDeleteAll( GtkMenuItem * menuitem, gpointer user_data )
172 {
173
174 }
175
176
177 void GtkPlaylistDeleteSelected( GtkMenuItem * menuitem, gpointer user_data )
178 {
179 #if 0 /* PLAYLIST TARASS */
180     /* user wants to delete a file in the queue */
181     GList *     p_selection;
182     GtkCList *  p_clist;
183     playlist_t *p_playlist;
184     
185     /* catch the thread back */
186     intf_thread_t *p_intf = GetIntf( GTK_WIDGET(menuitem), /*(char*)user_data*/"intf_playlist" );
187
188     p_playlist = p_intf->p_vlc->p_playlist;
189     
190     /* lock the struct */
191     vlc_mutex_lock( &p_intf->change_lock );
192
193     p_clist = GTK_CLIST( gtk_object_get_data( GTK_OBJECT(
194         p_intf->p_sys->p_playlist ), "playlist_clist" ) );
195     
196     /* I use UNDOCUMENTED features to retrieve the selection... */
197     p_selection = p_clist->selection;
198     
199     if( g_list_length( p_selection ) > 0 )
200     {
201         /* reverse-sort so that we can delete from the furthest
202          * to the closest item to delete...
203          */
204         p_selection = g_list_sort( p_selection, GtkCompareItems );
205         g_list_foreach( p_selection, GtkDeleteGListItem, p_intf );
206         /* rebuild the CList */
207         GtkRebuildCList( p_clist, p_playlist );
208     }
209     
210     vlc_mutex_unlock( &p_intf->change_lock );
211 #endif
212 }
213
214 void GtkPlaylistCrop( GtkMenuItem * menuitem, gpointer user_data )
215 {
216     /* Ok, this is a really small thing, but, hey, it works and
217        might be useful, who knows ? */
218     GtkPlaylistInvert( menuitem, user_data );
219     GtkPlaylistDeleteSelected( menuitem, user_data );
220 }
221
222 void GtkPlaylistInvert( GtkMenuItem * menuitem, gpointer user_data )
223 {
224 #if 0 /* PLAYLIST TARASS */
225     playlist_t *p_playlist;
226     GtkCList *  p_clist;
227     int *       pi_selected;
228     int         i_sel_l;
229     int         i_dummy;
230     
231     /* catch the thread back */
232     intf_thread_t *p_intf = GetIntf( GTK_WIDGET(menuitem), (char*)user_data );
233
234     p_playlist = p_intf->p_vlc->p_playlist;
235     
236     /* lock the struct */
237     vlc_mutex_lock( &p_intf->change_lock );
238
239     p_clist = GTK_CLIST( gtk_object_get_data( GTK_OBJECT(
240         p_intf->p_sys->p_playlist ), "playlist_clist" ) );
241     
242     /* have to copy the selection to an int *
243        I wasn't able to copy the g_list to another g_list
244        glib only does pointer copies, not real copies :( */
245     
246     pi_selected = malloc( sizeof(int) *g_list_length( p_clist->selection ) );
247     i_sel_l = g_list_length( p_clist->selection );
248
249     for( i_dummy = 0 ; i_dummy < i_sel_l ; i_dummy++)
250     {
251         pi_selected[i_dummy] = (long)g_list_nth_data( p_clist->selection,
252                                                       i_dummy );
253     }
254     
255     gtk_clist_freeze( p_clist );
256     gtk_clist_select_all( p_clist );
257
258     for( i_dummy = 0; i_dummy < i_sel_l; i_dummy++)
259     {
260         gtk_clist_unselect_row( p_clist, pi_selected[i_dummy], 0 );
261         gtk_clist_unselect_row( p_clist, pi_selected[i_dummy], 1 );
262     }
263
264     free( pi_selected );
265     gtk_clist_thaw( p_clist );
266
267     vlc_mutex_unlock( &p_intf->change_lock );
268 #endif
269 }
270
271 void GtkPlaylistSelect( GtkMenuItem * menuitem, gpointer user_data)
272 {
273
274 }
275
276 gboolean GtkPlaylistEvent( GtkWidget * widget,
277                            GdkEvent  * event,
278                            gpointer    user_data)
279 {
280 #if 0 /* PLAYLIST TARASS */
281     intf_thread_t *p_intf = GetIntf( GTK_WIDGET(widget), (char*)user_data );
282
283     if( ( event->button ).type == GDK_2BUTTON_PRESS )
284     {
285         GtkCList *  p_clist;
286         gint        i_row;
287         gint        i_col;
288
289         p_clist = GTK_CLIST( gtk_object_get_data( GTK_OBJECT(
290             p_intf->p_sys->p_playlist ), "playlist_clist" ) );
291         
292         if( gtk_clist_get_selection_info( p_clist, (event->button).x, 
293                     (event->button).y, &i_row, &i_col ) == 1 )
294         {
295             /* clicked is in range. */
296             if( p_intf->p_sys->p_input != NULL )
297             {
298                 /* FIXME: temporary hack */
299                 p_intf->p_sys->p_input->b_eof = 1;
300             }
301
302             intf_PlaylistJumpto( p_intf->p_vlc->p_playlist, i_row - 1 );
303         }
304         return TRUE;
305     }
306 #endif
307
308     return FALSE;
309 }
310
311 void GtkPlaylistDragData( GtkWidget       *widget,
312                           GdkDragContext  *drag_context,
313                           gint             x,
314                           gint             y,
315                           GtkSelectionData *data,
316                           guint            info,
317                           guint            time,
318                           gpointer         user_data )
319 {
320 #if 0 /* PLAYLIST TARASS */
321     intf_thread_t * p_intf = GetIntf( GTK_WIDGET(widget), (char*)user_data );
322     GtkCList *      p_clist;
323     gint            i_row;
324     gint            i_col;
325     int             i_end = p_intf->p_vlc->p_playlist->i_size;
326
327     p_clist = GTK_CLIST( gtk_object_get_data( GTK_OBJECT(
328         p_intf->p_sys->p_playlist ), "playlist_clist" ) );
329    
330     if( gtk_clist_get_selection_info( p_clist, x, y, &i_row, &i_col ) == 1 )
331     {
332         /* we are dropping somewhere into the clist items */
333         GtkDropDataReceived( p_intf, data, info, i_row );
334     } 
335     else 
336     {
337         /* else, put that at the end of the playlist */
338         GtkDropDataReceived( p_intf, data, info, PLAYLIST_END );
339     }
340
341     intf_PlaylistJumpto( p_intf->p_vlc->p_playlist, i_end - 1 );
342 #endif
343 }
344
345
346 gboolean GtkPlaylistDragMotion( GtkWidget       *widget,
347                                 GdkDragContext  *drag_context,
348                                 gint             x,
349                                 gint             y,
350                                 guint            time,
351                                 gpointer         user_data )
352 {
353 #if 0 /* PLAYLIST TARASS */
354     intf_thread_t *p_intf;
355     GtkCList *  p_clist;
356     gint        i_row;
357     gint        i_col;
358     int         i_dummy;
359     GdkColor    color;
360
361     p_intf = GetIntf( GTK_WIDGET(widget), (char*)user_data );
362
363     p_clist = GTK_CLIST( gtk_object_get_data( GTK_OBJECT(
364         p_intf->p_sys->p_playlist ), "playlist_clist" ) );
365
366     if( !GTK_WIDGET_TOPLEVEL(widget) )
367     {
368         gdk_window_raise( p_intf->p_sys->p_playlist->window );
369     }
370
371     color.red =   0xffff;
372     color.blue =  0xffff;
373     color.green = 0xffff;
374
375     gtk_clist_freeze( p_clist );
376     
377     for( i_dummy = 0; i_dummy < p_clist->rows; i_dummy++)
378     {
379        gtk_clist_set_background ( p_clist, i_dummy , &color);
380     }
381
382     color.red = 0xffff;
383     color.blue = 0;
384     color.green = 0;
385     i_row = p_intf->p_vlc->p_playlist->i_index;
386     gtk_clist_set_background( p_clist, i_row, &color );
387         
388     if( gtk_clist_get_selection_info( p_clist, x, y, &i_row, &i_col ) == 1)
389     {
390         color.red = 0;
391         color.blue = 0xf000;
392         color.green = 0x9000;
393         gtk_clist_set_background ( p_clist, i_row - 1, &color);
394         gtk_clist_set_background ( p_clist, i_row, &color);
395     }
396
397     gtk_clist_thaw( p_clist );
398 #endif
399     
400     return TRUE;
401 }
402
403 void GtkDropDataReceived( intf_thread_t * p_intf,
404         GtkSelectionData * p_data, guint i_info, int i_position)
405 {
406 #if 0 /* PLAYLIST TARASS */
407     /* first we'll have to split against all the '\n' we have */
408     gchar *     p_protocol;
409     gchar *     p_temp;
410     gchar *     p_next;
411     gchar *     p_string = p_data->data ;
412     GList *     p_files = NULL;
413     GtkCList *  p_clist;
414
415     
416     /* catch the playlist back */
417     playlist_t * p_playlist = p_intf->p_vlc->p_playlist;
418    
419
420     /* if this has been URLencoded, decode it
421      * 
422      * Is it a good thing to do it in place ?
423      * probably not... 
424      */
425     if( i_info == DROP_ACCEPT_TEXT_URI_LIST )
426     {
427         UrlDecode( p_string );
428     }
429     
430     /* this cuts string into single file drops */
431     /* this code was borrowed from xmms, thx guys :) */
432     while( *p_string)
433     {
434         p_next = strchr( p_string, '\n' );
435         if( p_next )
436         {
437             if( *( p_next - 1 ) == '\r' )
438             {
439                 *( p_next - 1) = '\0';
440             }
441             *p_next = '\0';
442         }
443
444         /* do we have a protocol or something ? */
445         p_temp = strstr( p_string, ":" );
446         if( p_temp != NULL && p_temp[0] != '\0' )
447         {
448             char i_save;
449
450             i_save = p_temp[0];
451             p_temp[0] = '\0';
452             p_protocol = strdup( p_string );
453             p_temp[0] = i_save;
454             p_temp++;
455
456             /* Allowed things are proto: or proto:// */
457             if( p_temp[0] == '/' && p_temp[1] == '/')
458             {
459                 /* eat two '/'s */
460                 p_temp += 2;
461             }
462             msg_Dbg( p_intf, "playlist protocol '%s', target '%s'",
463                              p_protocol, p_temp );
464         } 
465         else 
466         {
467             p_protocol = strdup( "" );
468         }
469          
470         /* if it uses the file protocol we can do something, else, sorry :( 
471          * I think this is a good choice for now, as we don't have any
472          * ability to read http:// or ftp:// files
473          * what about adding dvd:// to the list of authorized proto ? */
474         
475         if( strcmp( p_protocol, "file:" ) == 0 )
476         {
477             p_files = g_list_concat( p_files, GtkReadFiles( p_string ) ); 
478         }
479         else
480         {
481             p_files = g_list_concat( p_files,
482                       g_list_append( NULL, g_strdup( p_string ) ) );
483         }
484        
485         /* free the malloc and go on... */
486         free( p_protocol );
487
488         if( p_next == NULL )
489         {
490             break;
491         }
492         p_string = p_next + 1;
493     }
494    
495     /* At this point, we have a nice big list maybe NULL */
496     if( p_files != NULL )
497     {
498         /* lock the interface */
499         vlc_mutex_lock( &p_intf->change_lock );
500
501         msg_Dbg( p_intf, "list has %d elements", g_list_length( p_files ) ); 
502         GtkAppendList( p_playlist, i_position, p_files );
503
504         /* get the CList  and rebuild it. */
505         p_clist = GTK_CLIST( lookup_widget( p_intf->p_sys->p_playlist,
506                                             "playlist_clist" ) ); 
507         GtkRebuildCList( p_clist , p_playlist );
508         
509         /* unlock the interface */
510         vlc_mutex_unlock( &p_intf->change_lock );
511     }
512 #endif
513 }
514
515
516 void GtkDeleteGListItem( gpointer data, gpointer param )
517 {
518 #if 0 /* PLAYLIST TARASS */
519     int i_cur_row = (long)data;
520     intf_thread_t * p_intf = param;    
521     
522     intf_PlaylistDelete( p_intf->p_vlc->p_playlist, i_cur_row );
523
524     /* are we deleting the current played stream */
525     if( p_intf->p_sys->i_playing == i_cur_row )
526     {
527         /* next ! */
528         p_intf->p_sys->p_input->b_eof = 1;
529         /* this has to set the slider to 0 */
530         
531         /* step minus one */
532         p_intf->p_sys->i_playing-- ;
533
534         vlc_mutex_lock( &p_intf->p_vlc->p_playlist->change_lock );
535         p_intf->p_vlc->p_playlist->i_index-- ;
536         vlc_mutex_unlock( &p_intf->p_vlc->p_playlist->change_lock );
537     }
538 #endif
539 }
540
541
542 gint GtkCompareItems( gconstpointer a, gconstpointer b )
543 {
544     return b - a;
545 }
546
547
548 /* check a file (string) against supposed valid extension */
549 int GtkHasValidExtension( gchar * psz_filename )
550 {
551     char * ppsz_ext[6] = { "mpg", "mpeg", "vob", "mp2", "ts", "ps" };
552     int  i_ext = 6;
553     int  i_dummy;
554
555     gchar * psz_ext = strrchr( psz_filename, '.' ) + sizeof( char );
556
557     for( i_dummy = 0 ; i_dummy < i_ext ; i_dummy++ )
558     {
559         if( strcmp( psz_ext, ppsz_ext[i_dummy] ) == 0 )
560         {
561             return 1;
562         }
563     }
564
565     return 0;
566 }
567
568 /* recursive function: descend into folders and build a list of
569  * valid filenames */
570 GList * GtkReadFiles( gchar * psz_fsname )
571 {
572     struct stat statbuf;
573     GList  *    p_current = NULL;
574
575     /* get the attributes of this file */
576     stat( psz_fsname, &statbuf );
577     
578     /* is it a regular file ? */
579     if( S_ISREG( statbuf.st_mode ) )
580     {
581         if( GtkHasValidExtension( psz_fsname ) )
582         {
583 //X            msg_Warn( "%s is a valid file. Stacking on the playlist",
584 //X                      psz_fsname );
585             return g_list_append( NULL, g_strdup( psz_fsname ) );
586         } 
587         else
588         {
589             return NULL;
590         }
591     } 
592     /* is it a directory (should we check for symlinks ?) */
593     else if( S_ISDIR( statbuf.st_mode ) ) 
594     {
595         /* have to cd into this dir */
596         DIR *           p_current_dir = opendir( psz_fsname );
597         struct dirent * p_dir_content; 
598         
599 //X        msg_Warn( "%s is a folder.", psz_fsname );
600         
601         if( p_current_dir == NULL )
602         {
603             /* something went bad, get out of here ! */
604             return p_current;
605         }
606         p_dir_content = readdir( p_current_dir );
607
608         /* while we still have entries in the directory */
609         while( p_dir_content != NULL )
610         {
611             /* if it is "." or "..", forget it */
612             if( ( strcmp( p_dir_content->d_name, "." ) != 0 ) &&
613                 ( strcmp( p_dir_content->d_name, ".." ) != 0 ) )
614             {
615                 /* else build the new directory by adding
616                    fsname "/" and the current entry name 
617                    (kludgy :()
618                   */
619                 char *  psz_newfs = malloc ( 2 + strlen( psz_fsname ) +
620                             strlen( p_dir_content->d_name ) * sizeof(char) );
621                 strcpy( psz_newfs, psz_fsname );
622                 strcpy( psz_newfs + strlen( psz_fsname ) + 1,
623                         p_dir_content->d_name );
624                 psz_newfs[strlen( psz_fsname )] = '/';
625                 
626                 p_current = g_list_concat( p_current,
627                                            GtkReadFiles( psz_newfs ) );
628                     
629                 g_free( psz_newfs );
630             }
631             p_dir_content = readdir( p_current_dir );
632         }
633         return p_current;
634     }
635     return NULL;
636 }
637
638 /* add items in a playlist 
639  * when i_pos==-1 add to the end of the list... 
640  */
641 int GtkAppendList( playlist_t * p_playlist, int i_pos, GList * p_list )
642 {
643 #if 0 /* PLAYLIST TARASS */
644     guint i_dummy;
645     guint i_length;
646
647     i_length = g_list_length( p_list );
648
649     for( i_dummy = 0; i_dummy < i_length ; i_dummy++ )
650     {
651         intf_PlaylistAdd( p_playlist, 
652                 /* ok; this is a really nasty trick to insert
653                    the item where they are suppose to go but, hey
654                    this works :P (btw, you are really nasty too) */
655                 i_pos==PLAYLIST_END?PLAYLIST_END:( i_pos + i_dummy ), 
656                 g_list_nth_data( p_list, i_dummy ) );
657     }
658 #endif
659     return 0;
660 }
661
662 /* statis timeouted function */
663 void GtkPlayListManage( intf_thread_t * p_intf )
664 {
665 #if 0 /* PLAYLIST TARASS */
666     /* this thing really sucks for now :( */
667
668     /* TODO speak more with interface/intf_playlist.c */
669
670     playlist_t *    p_playlist = p_intf->p_vlc->p_playlist ;
671     GtkCList *      p_clist;
672
673     if( GTK_IS_WIDGET( p_intf->p_sys->p_playlist ) )
674     {
675         p_clist = GTK_CLIST( gtk_object_get_data( GTK_OBJECT(
676                        p_intf->p_sys->p_playlist ), "playlist_clist" ) );
677     
678         vlc_mutex_lock( &p_playlist->change_lock );
679     
680         if( p_intf->p_sys->i_playing != p_playlist->i_index )
681         {
682             GdkColor color;
683     
684             color.red = 0xffff;
685             color.blue = 0;
686             color.green = 0;
687     
688             gtk_clist_set_background( p_clist, p_playlist->i_index, &color );
689     
690             if( p_intf->p_sys->i_playing != -1 )
691             {
692                 color.red = 0xffff;
693                 color.blue = 0xffff;
694                 color.green = 0xffff;
695                 gtk_clist_set_background( p_clist, p_intf->p_sys->i_playing,
696                                           &color);
697             }
698             p_intf->p_sys->i_playing = p_playlist->i_index;
699         }
700     
701         vlc_mutex_unlock( &p_playlist->change_lock );
702     }
703 #endif
704 }
705
706 void GtkRebuildCList( GtkCList * p_clist, playlist_t * p_playlist )
707 {
708 #if 0 /* PLAYLIST TARASS */
709     int         i_dummy;
710     gchar *     ppsz_text[2];
711     GdkColor    red;
712     red.red     = 65535;
713     red.blue    = 0;
714     red.green   = 0;
715     
716     gtk_clist_freeze( p_clist );
717     gtk_clist_clear( p_clist );
718    
719     vlc_mutex_lock( &p_playlist->change_lock );
720     for( i_dummy = p_playlist->i_size ; i_dummy-- ; )
721     {
722         ppsz_text[0] = p_playlist->p_item[i_dummy].psz_name;
723         ppsz_text[1] = "no info";
724         gtk_clist_insert( p_clist, 0, ppsz_text );
725     }
726     vlc_mutex_unlock( &p_playlist->change_lock );
727
728     gtk_clist_set_background( p_clist, p_playlist->i_index, &red);
729     gtk_clist_thaw( p_clist );
730 #endif
731 }
732
733 /* URL-decode a file: URL path, return NULL if it's not what we expect */
734 static void UrlDecode( char *encoded_path )
735 {
736     char *tmp = NULL, *cur = NULL, *ext = NULL;
737     int realchar;
738
739     if( !encoded_path || *encoded_path == '\0' )
740     {
741         return;
742     }
743
744     cur = encoded_path ;
745
746     tmp = calloc(strlen(encoded_path) + 1,  sizeof(char) );
747
748     while ( ( ext = strchr(cur, '%') ) != NULL)
749     {
750         strncat(tmp, cur, (ext - cur) / sizeof(char));
751         ext++;
752
753         if (!sscanf(ext, "%2x", &realchar))
754         {
755             free(tmp);
756             return;
757         }
758
759         tmp[strlen(tmp)] = (char)realchar;
760
761         cur = ext + 2;
762     }
763
764     strcat(tmp, cur);
765     strcpy(encoded_path,tmp);
766 }
767