ee88c016ba34a2245379553ff87bc1f43d510f7f
[vlc.git] / modules / gui / macosx / controls.m
1 /*****************************************************************************
2  * controls.m: MacOS X interface plugin
3  *****************************************************************************
4  * Copyright (C) 2002-2003 VideoLAN
5  * $Id: controls.m,v 1.31 2003/04/15 14:05:13 hartman Exp $
6  *
7  * Authors: Jon Lech Johansen <jon-vl@nanocrew.net>
8  *          Christophe Massiot <massiot@via.ecp.fr>
9  *          Derk-Jan Hartman <thedj@users.sourceforge.net>
10  *
11  * This program is free software; you can redistribute it and/or modify
12  * it under the terms of the GNU General Public License as published by
13  * the Free Software Foundation; either version 2 of the License, or
14  * (at your option) any later version.
15  * 
16  * This program is distributed in the hope that it will be useful,
17  * but WITHOUT ANY WARRANTY; without even the implied warranty of
18  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
19  * GNU General Public License for more details.
20  *
21  * You should have received a copy of the GNU General Public License
22  * along with this program; if not, write to the Free Software
23  * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111, USA.
24  *****************************************************************************/
25
26 /*****************************************************************************
27  * Preamble
28  *****************************************************************************/
29 #include <stdlib.h>                                      /* malloc(), free() */
30 #include <sys/param.h>                                    /* for MAXPATHLEN */
31 #include <string.h>
32
33 #include "intf.h"
34 #include "vout.h"
35 #include "open.h"
36 #include "controls.h"
37
38 /*****************************************************************************
39  * VLCControls implementation 
40  *****************************************************************************/
41 @implementation VLCControls
42
43 - (IBAction)play:(id)sender
44 {
45     intf_thread_t * p_intf = [NSApp getIntf];
46
47     playlist_t * p_playlist = vlc_object_find( p_intf, VLC_OBJECT_PLAYLIST,
48                                                        FIND_ANYWHERE );
49     if( p_playlist == NULL )
50     {
51         return;
52     }
53
54     if( playlist_IsPlaying( p_playlist ) )
55     {
56         playlist_Pause( p_playlist );
57         vlc_object_release( p_playlist );
58     }
59     else
60     {
61         if( !playlist_IsEmpty( p_playlist ) )
62         {
63             playlist_Play( p_playlist );
64             vlc_object_release( p_playlist );
65         }
66         else
67         {
68             vlc_object_release( p_playlist );
69             [o_open openFileGeneric: nil];
70         }
71     }
72 }
73
74 - (IBAction)stop:(id)sender
75 {
76     intf_thread_t * p_intf = [NSApp getIntf];
77
78     playlist_t * p_playlist = vlc_object_find( p_intf, VLC_OBJECT_PLAYLIST,
79                                                        FIND_ANYWHERE );
80     if( p_playlist == NULL )
81     {
82         return;
83     }
84
85     playlist_Stop( p_playlist );
86     vlc_object_release( p_playlist );
87 }
88
89 - (IBAction)faster:(id)sender
90 {
91     intf_thread_t * p_intf = [NSApp getIntf];
92
93     playlist_t * p_playlist = vlc_object_find( p_intf, VLC_OBJECT_PLAYLIST,
94                                                        FIND_ANYWHERE );
95     if( p_playlist == NULL )
96     {
97         return;
98     }
99
100     vlc_mutex_lock( &p_playlist->object_lock );
101     if( p_playlist->p_input != NULL )
102     {
103         input_SetStatus( p_playlist->p_input, INPUT_STATUS_FASTER );
104     } 
105     vlc_mutex_unlock( &p_playlist->object_lock );
106
107     vlc_object_release( p_playlist );
108 }
109
110 - (IBAction)slower:(id)sender
111 {
112     intf_thread_t * p_intf = [NSApp getIntf];
113
114     playlist_t * p_playlist = vlc_object_find( p_intf, VLC_OBJECT_PLAYLIST,
115                                                        FIND_ANYWHERE );
116     if( p_playlist == NULL )
117     {
118         return;
119     }
120
121     vlc_mutex_lock( &p_playlist->object_lock );
122     if( p_playlist->p_input != NULL )
123     {
124         input_SetStatus( p_playlist->p_input, INPUT_STATUS_SLOWER );
125     }
126     vlc_mutex_unlock( &p_playlist->object_lock );
127
128     vlc_object_release( p_playlist );
129 }
130
131 - (IBAction)prev:(id)sender
132 {
133     intf_thread_t * p_intf = [NSApp getIntf];
134
135     playlist_t * p_playlist = vlc_object_find( p_intf, VLC_OBJECT_PLAYLIST,
136                                                        FIND_ANYWHERE );
137     if( p_playlist == NULL )
138     {
139         return;
140     }
141
142     vlc_mutex_lock( &p_playlist->object_lock );
143
144     if( p_playlist->p_input == NULL )
145     {
146         vlc_mutex_unlock( &p_playlist->object_lock );
147         vlc_object_release( p_playlist );  
148         return;
149     }
150
151     vlc_mutex_lock( &p_playlist->p_input->stream.stream_lock );
152
153 #define p_area p_playlist->p_input->stream.p_selected_area
154
155     if( p_area->i_part_nb > 1 && p_area->i_part > 1 )
156     {
157         p_area->i_part--;
158
159         vlc_mutex_unlock( &p_playlist->p_input->stream.stream_lock );
160         input_ChangeArea( p_playlist->p_input, p_area );
161         vlc_mutex_unlock( &p_playlist->object_lock );
162
163         p_intf->p_sys->b_chapter_update = VLC_TRUE;
164     }
165     else
166     {
167         vlc_mutex_unlock( &p_playlist->p_input->stream.stream_lock );
168         vlc_mutex_unlock( &p_playlist->object_lock );
169         playlist_Prev( p_playlist );
170     }
171
172 #undef p_area
173
174     vlc_object_release( p_playlist );
175 }
176
177 - (IBAction)next:(id)sender
178 {
179     intf_thread_t * p_intf = [NSApp getIntf];
180
181     playlist_t * p_playlist = vlc_object_find( p_intf, VLC_OBJECT_PLAYLIST,
182                                                        FIND_ANYWHERE );
183     if( p_playlist == NULL )
184     {
185         return;
186     }
187
188     vlc_mutex_lock( &p_playlist->object_lock );
189
190     if( p_playlist->p_input == NULL )
191     {
192         vlc_mutex_unlock( &p_playlist->object_lock );
193         vlc_object_release( p_playlist );  
194         return;
195     }
196
197     vlc_mutex_lock( &p_playlist->p_input->stream.stream_lock );
198
199 #define p_area p_playlist->p_input->stream.p_selected_area
200
201     if( p_area->i_part_nb > 1 && p_area->i_part + 1 < p_area->i_part_nb )
202     {
203         p_area->i_part++;
204
205         vlc_mutex_unlock( &p_playlist->p_input->stream.stream_lock );
206         input_ChangeArea( p_playlist->p_input, p_area );
207         vlc_mutex_unlock( &p_playlist->object_lock );
208
209         p_intf->p_sys->b_chapter_update = VLC_TRUE;
210     }
211     else
212     {
213         vlc_mutex_unlock( &p_playlist->p_input->stream.stream_lock );
214         vlc_mutex_unlock( &p_playlist->object_lock );
215         playlist_Next( p_playlist );
216     }
217
218 #undef p_area
219
220     vlc_object_release( p_playlist );
221 }
222
223 - (IBAction)loop:(id)sender
224 {
225     intf_thread_t * p_intf = [NSApp getIntf];
226
227     playlist_t * p_playlist = vlc_object_find( p_intf, VLC_OBJECT_PLAYLIST,
228                                                        FIND_ANYWHERE );
229     if( p_playlist == NULL )
230     {
231         return;
232     }
233
234     config_PutInt( p_playlist, "loop",
235                    !config_GetInt( p_playlist, "loop" ) );
236
237     vlc_object_release( p_playlist );
238 }
239
240 - (IBAction)forward:(id)sender
241 {
242     intf_thread_t * p_intf = [NSApp getIntf];
243     playlist_t * p_playlist = vlc_object_find( p_intf, VLC_OBJECT_PLAYLIST,
244                                                        FIND_ANYWHERE );
245     if( p_playlist == NULL || p_playlist->p_input == NULL )
246     {
247         if ( p_playlist != NULL ) vlc_object_release( p_playlist );
248         return;
249     }
250
251     input_Seek( p_playlist->p_input, 5, INPUT_SEEK_SECONDS | INPUT_SEEK_CUR );
252     vlc_object_release( p_playlist );
253 }
254
255 - (IBAction)backward:(id)sender
256 {
257     intf_thread_t * p_intf = [NSApp getIntf];
258     playlist_t * p_playlist = vlc_object_find( p_intf, VLC_OBJECT_PLAYLIST,
259                                                        FIND_ANYWHERE );
260     if( p_playlist == NULL || p_playlist->p_input == NULL )
261     {
262         if ( p_playlist != NULL ) vlc_object_release( p_playlist );
263         return;
264     }
265
266     input_Seek( p_playlist->p_input, -5, INPUT_SEEK_SECONDS | INPUT_SEEK_CUR );
267     vlc_object_release( p_playlist );
268 }
269
270 - (IBAction)volumeUp:(id)sender
271 {
272     intf_thread_t * p_intf = [NSApp getIntf];
273
274     if( p_intf->p_sys->b_mute )
275     {
276         [self mute: nil];
277     }
278
279     aout_VolumeUp( p_intf, 1, NULL );
280
281     [self updateVolumeSlider];
282 }
283
284 - (IBAction)volumeDown:(id)sender
285 {
286     intf_thread_t * p_intf = [NSApp getIntf];
287
288     if( p_intf->p_sys->b_mute )
289     {
290         [self mute: nil];
291     }
292     
293     aout_VolumeDown( p_intf, 1, NULL );
294
295     [self updateVolumeSlider];
296 }
297
298 - (IBAction)mute:(id)sender
299 {
300     intf_thread_t * p_intf = [NSApp getIntf];
301     audio_volume_t i_volume;
302
303     aout_VolumeMute( p_intf, &i_volume );
304     p_intf->p_sys->b_mute = ( i_volume == 0 );
305
306     [self updateVolumeSlider];
307 }
308
309 - (IBAction)volumeSliderUpdated:(id)sender
310 {
311     intf_thread_t * p_intf = [NSApp getIntf];
312     audio_volume_t i_volume = (audio_volume_t)[sender intValue];
313
314     aout_VolumeSet( p_intf, i_volume * AOUT_VOLUME_STEP );
315 }
316
317 - (void)updateVolumeSlider
318 {
319     intf_thread_t * p_intf = [NSApp getIntf];
320     audio_volume_t i_volume;
321
322     aout_VolumeGet( p_intf, &i_volume );
323
324     [o_volumeslider setFloatValue: (float)(i_volume / AOUT_VOLUME_STEP)]; 
325 }
326
327 - (IBAction)halfWindow:(id)sender
328 {
329     id o_window = [NSApp keyWindow];
330     NSArray *o_windows = [NSApp windows];
331     NSEnumerator *o_enumerator = [o_windows objectEnumerator];
332     
333     while ((o_window = [o_enumerator nextObject]))
334     {
335         if( [[o_window className] isEqualToString: @"VLCWindow"] )
336         {
337             [o_window scaleWindowWithFactor: 0.5];
338         }
339     }
340 }
341
342 - (IBAction)normalWindow:(id)sender
343 {
344     id o_window = [NSApp keyWindow];
345     NSArray *o_windows = [NSApp windows];
346     NSEnumerator *o_enumerator = [o_windows objectEnumerator];
347     
348     while ((o_window = [o_enumerator nextObject]))
349     {
350         if( [[o_window className] isEqualToString: @"VLCWindow"] )
351         {
352             [o_window scaleWindowWithFactor: 1];
353         }
354     }
355 }
356
357 - (IBAction)doubleWindow:(id)sender
358 {
359     id o_window = [NSApp keyWindow];
360     NSArray *o_windows = [NSApp windows];
361     NSEnumerator *o_enumerator = [o_windows objectEnumerator];
362     
363     while ((o_window = [o_enumerator nextObject]))
364     {
365         if( [[o_window className] isEqualToString: @"VLCWindow"] )
366         {
367             [o_window scaleWindowWithFactor: 2];
368         }
369     }
370 }
371
372
373 - (IBAction)fullscreen:(id)sender
374 {
375     id o_window = [NSApp keyWindow];
376     NSArray *o_windows = [NSApp windows];
377     NSEnumerator *o_enumerator = [o_windows objectEnumerator];
378     
379     while ((o_window = [o_enumerator nextObject]))
380     {
381         if( [[o_window className] isEqualToString: @"VLCWindow"] )
382         {
383             [o_window toggleFullscreen];
384         }
385     }
386 }
387
388 - (IBAction)deinterlace:(id)sender
389 {
390     intf_thread_t * p_intf = [NSApp getIntf];
391     BOOL bEnable = [sender state] == NSOffState;
392
393     if( bEnable )
394     {
395         config_PutPsz( p_intf, "filter", "deinterlace" );
396         config_PutPsz( p_intf, "deinterlace-mode",
397                     [[sender title] lossyCString] );
398     }
399     else
400     {
401         config_PutPsz( p_intf, "filter", NULL );
402     }
403 }
404
405 - (IBAction)toggleProgram:(id)sender
406 {
407     NSMenuItem * o_mi = (NSMenuItem *)sender;
408     intf_thread_t * p_intf = [NSApp getIntf];
409
410     playlist_t * p_playlist = vlc_object_find( p_intf, VLC_OBJECT_PLAYLIST,
411                                                        FIND_ANYWHERE );
412     if( p_playlist == NULL )
413     {
414         return;
415     }
416
417     vlc_mutex_lock( &p_playlist->object_lock );
418
419     if( p_playlist->p_input == NULL )
420     {
421         vlc_mutex_unlock( &p_playlist->object_lock );
422         vlc_object_release( p_playlist );
423         return;
424     }
425
426     if( [o_mi state] == NSOffState )
427     {
428         u16 i_program_id = [o_mi tag];
429
430         input_ChangeProgram( p_playlist->p_input, i_program_id );
431         input_SetStatus( p_playlist->p_input, INPUT_STATUS_PLAY );
432     }
433
434     vlc_mutex_unlock( &p_playlist->object_lock );
435     vlc_object_release( p_playlist );
436 }
437
438 - (IBAction)toggleTitle:(id)sender
439 {
440     NSMenuItem * o_mi = (NSMenuItem *)sender;
441     intf_thread_t * p_intf = [NSApp getIntf];
442
443     playlist_t * p_playlist = vlc_object_find( p_intf, VLC_OBJECT_PLAYLIST,
444                                                        FIND_ANYWHERE );
445     if( p_playlist == NULL )
446     {
447         return;
448     }
449
450     vlc_mutex_lock( &p_playlist->object_lock );
451
452     if( p_playlist->p_input == NULL )
453     {
454         vlc_mutex_unlock( &p_playlist->object_lock );
455         vlc_object_release( p_playlist );
456         return;
457     }
458
459     if( [o_mi state] == NSOffState )
460     {
461         int i_title = [o_mi tag];
462
463 #define p_input p_playlist->p_input
464         input_ChangeArea( p_input, p_input->stream.pp_areas[i_title] );
465         input_SetStatus( p_input, INPUT_STATUS_PLAY );
466 #undef p_input
467     }
468
469     vlc_mutex_unlock( &p_playlist->object_lock );
470     vlc_object_release( p_playlist );
471 }
472
473 - (IBAction)toggleChapter:(id)sender
474 {
475     NSMenuItem * o_mi = (NSMenuItem *)sender;
476     intf_thread_t * p_intf = [NSApp getIntf];
477
478     playlist_t * p_playlist = vlc_object_find( p_intf, VLC_OBJECT_PLAYLIST,
479                                                        FIND_ANYWHERE );
480     if( p_playlist == NULL )
481     {
482         return;
483     }
484
485     vlc_mutex_lock( &p_playlist->object_lock );
486
487     if( p_playlist->p_input == NULL )
488     {
489         vlc_mutex_unlock( &p_playlist->object_lock );
490         vlc_object_release( p_playlist );
491         return;
492     }
493
494     if( [o_mi state] == NSOffState )
495     {
496         int i_chapter = [o_mi tag];
497
498 #define p_input p_playlist->p_input
499         p_input->stream.p_selected_area->i_part = i_chapter;
500         input_ChangeArea( p_input, p_input->stream.p_selected_area );
501         input_SetStatus( p_input, INPUT_STATUS_PLAY );
502 #undef p_input
503     }
504
505     vlc_mutex_unlock( &p_playlist->object_lock );
506     vlc_object_release( p_playlist );
507 }
508
509 - (IBAction)toggleLanguage:(id)sender
510 {
511     NSMenuItem * o_mi = (NSMenuItem *)sender;
512     intf_thread_t * p_intf = [NSApp getIntf];
513
514     playlist_t * p_playlist = vlc_object_find( p_intf, VLC_OBJECT_PLAYLIST,
515                                                        FIND_ANYWHERE );
516     if( p_playlist == NULL )
517     {
518         return;
519     }
520
521     vlc_mutex_lock( &p_playlist->object_lock );
522
523     if( p_playlist->p_input == NULL )
524     {
525         vlc_mutex_unlock( &p_playlist->object_lock );
526         vlc_object_release( p_playlist );
527         return;
528     }
529
530 #if 0
531     /* We do not use this code, because you need to start stop .avi for
532      * it to work, so not very useful now  --hartman */
533     if ( [o_mi state] == NSOffState && [o_mi tag] == 2000 )
534     {
535         NSOpenPanel *o_open_panel = [NSOpenPanel openPanel];
536         
537         [o_open_panel setAllowsMultipleSelection: NO];
538         [o_open_panel setTitle: _NS("Open subtitle file")];
539         [o_open_panel setPrompt: _NS("Open")];
540     
541         if( [o_open_panel runModalForDirectory: nil 
542                 file: nil types: nil] == NSOKButton )
543         {
544             NSString *o_filename = [[o_open_panel filenames] objectAtIndex: 0];
545             config_PutPsz( p_intf, "sub-file", strdup( [o_filename cString] ));
546         }
547     }
548 #endif
549
550 #define p_input p_playlist->p_input
551
552     if( !p_intf->p_sys->b_audio_update )
553     {
554         NSValue * o_value = [o_mi representedObject];
555         es_descriptor_t * p_es = [o_value pointerValue];
556
557         if( [o_mi state] == NSOnState )
558         {
559             /* we just have one ES to disable */
560             input_ToggleES( p_input, p_es, 0 );
561         }
562         else
563         {
564             unsigned int i;
565             int i_cat = [o_mi tag];
566
567             vlc_mutex_lock( &p_input->stream.stream_lock );
568
569 #define ES p_input->stream.pp_selected_es[i]
570
571             /* unselect the selected ES in the same class */
572             for( i = 0; i < p_input->stream.i_selected_es_number; i++ )
573             {
574                 if( ES->i_cat == i_cat )
575                 {
576                     vlc_mutex_unlock( &p_input->stream.stream_lock );
577                     input_ToggleES( p_input, ES, 0 );
578                     vlc_mutex_lock( &p_input->stream.stream_lock );
579                     break;
580                 }
581             }
582
583 #undef ES
584
585             vlc_mutex_unlock( &p_input->stream.stream_lock );
586
587             input_ToggleES( p_input, p_es, 1 );
588         }
589     }
590
591 #undef p_input
592
593     vlc_mutex_unlock( &p_playlist->object_lock );
594     vlc_object_release( p_playlist );
595 }
596
597 - (IBAction)toggleVar:(id)sender
598 {
599     NSMenuItem * o_mi = (NSMenuItem *)sender;
600     
601     if( [o_mi state] == NSOffState )
602     {
603         const char * psz_variable = (const char *)[o_mi tag];
604         char * psz_value = [NSApp delocalizeString: [o_mi title]];
605         vlc_object_t * p_object = (vlc_object_t *)
606             [[o_mi representedObject] pointerValue];
607         vlc_value_t val;
608         /* psz_string sucks */
609         val.psz_string = (char *)psz_value;
610
611         if ( var_Set( p_object, psz_variable, val ) < 0 )
612         {
613             msg_Warn( p_object, "cannot set variable (%s)", psz_value );
614         }
615
616         free( psz_value );
617     }
618 }
619
620 @end
621
622 @implementation VLCControls (NSMenuValidation)
623  
624 - (BOOL)validateMenuItem:(NSMenuItem *)o_mi
625 {
626     BOOL bEnabled = TRUE;
627     NSMenu * o_menu = [o_mi menu];
628     intf_thread_t * p_intf = [NSApp getIntf];
629
630     playlist_t * p_playlist = vlc_object_find( p_intf, VLC_OBJECT_PLAYLIST,
631                                                        FIND_ANYWHERE );
632
633     if( p_playlist != NULL )
634     {
635         vlc_mutex_lock( &p_playlist->object_lock );
636     }
637
638 #define p_input p_playlist->p_input
639
640     if( [[o_mi title] isEqualToString: _NS("Faster")] ||
641         [[o_mi title] isEqualToString: _NS("Slower")] )
642     {
643         if( p_playlist != NULL && p_input != NULL )
644         {
645             vlc_mutex_lock( &p_input->stream.stream_lock );
646             bEnabled = p_input->stream.b_pace_control;
647             vlc_mutex_unlock( &p_input->stream.stream_lock );
648         }
649         else
650         {
651             bEnabled = FALSE;
652         }
653     }
654     else if( [[o_mi title] isEqualToString: _NS("Stop")] )
655     {
656         if( p_playlist == NULL || p_input == NULL )
657         {
658             bEnabled = FALSE;
659         }
660     }
661     else if( [[o_mi title] isEqualToString: _NS("Previous")] ||
662              [[o_mi title] isEqualToString: _NS("Next")] )
663     {
664         if( p_playlist == NULL )
665         {
666             bEnabled = FALSE;
667         }
668         else
669         {
670             bEnabled = p_playlist->i_size > 1;
671
672             if( p_input != NULL )
673             {
674                 vlc_mutex_lock( &p_input->stream.stream_lock );
675                 bEnabled |= p_input->stream.p_selected_area->i_part_nb > 1;
676                 vlc_mutex_unlock( &p_input->stream.stream_lock );
677             }
678         }
679     }
680     else if( [[o_mi title] isEqualToString: _NS("Loop")] )
681     {
682         int i_state = config_GetInt( p_playlist, "loop" ) ?
683                       NSOnState : NSOffState;
684
685         [o_mi setState: i_state];
686     }
687     else if( [[o_mi title] isEqualToString: _NS("Step Forward")] ||
688              [[o_mi title] isEqualToString: _NS("Step Backward")] )
689     {
690         if( p_playlist != NULL && p_input != NULL )
691         {
692             vlc_mutex_lock( &p_input->stream.stream_lock );
693             bEnabled = p_input->stream.b_seekable;
694             vlc_mutex_unlock( &p_input->stream.stream_lock );
695         }
696         else
697         {
698             bEnabled = FALSE;
699         }
700     }
701     else if( [[o_mi title] isEqualToString: _NS("Mute")] ) 
702     {
703         [o_mi setState: p_intf->p_sys->b_mute ? NSOnState : NSOffState];
704     }
705     else if( [[o_mi title] isEqualToString: _NS("Fullscreen")] ||
706                 [[o_mi title] isEqualToString: _NS("Half Size")] ||
707                 [[o_mi title] isEqualToString: _NS("Normal Size")] ||
708                 [[o_mi title] isEqualToString: _NS("Double Size")])    
709     {
710         id o_window;
711         NSArray *o_windows = [NSApp windows];
712         NSEnumerator *o_enumerator = [o_windows objectEnumerator];
713         bEnabled = FALSE;
714         
715         while ((o_window = [o_enumerator nextObject]))
716         {
717             if( [[o_window className] isEqualToString: @"VLCWindow"] )
718             {
719                 bEnabled = TRUE;
720                 break;
721             }
722         }
723     }
724     else if( o_menu != nil && 
725              [[o_menu title] isEqualToString: _NS("Deinterlace")] )
726     {
727         char * psz_filter = config_GetPsz( p_intf, "filter" );
728         
729         if( psz_filter != NULL )
730         {
731             free( psz_filter );
732             
733             psz_filter = config_GetPsz( p_intf, "deinterlace-mode" );
734         }
735
736         if( psz_filter != NULL )
737         {
738             if( strcmp( psz_filter, [[o_mi title] lossyCString] ) == 0 )
739             {
740                 [o_mi setState: NSOnState];
741             }
742             else
743             {
744                 [o_mi setState: NSOffState];
745             }
746
747             free( psz_filter );
748         }
749         else
750         {
751             [o_mi setState: NSOffState];
752         }
753     }
754
755     if( p_playlist != NULL )
756     {
757         vlc_mutex_unlock( &p_playlist->object_lock );
758         vlc_object_release( p_playlist );
759     }
760
761     return( bEnabled );
762 }
763
764 @end