]> git.sesse.net Git - vlc/blob - modules/gui/macosx/controls.m
* seperated the open, sout and sub-open dialogues from the main nib
[vlc] / modules / gui / macosx / controls.m
1 /*****************************************************************************
2  * controls.m: MacOS X interface module
3  *****************************************************************************
4  * Copyright (C) 2002-2003 VideoLAN
5  * $Id$
6  *
7  * Authors: Jon Lech Johansen <jon-vl@nanocrew.net>
8  *          Christophe Massiot <massiot@via.ecp.fr>
9  *          Derk-Jan Hartman <hartman at videolan dot org>
10  *
11  * This program is free software; you can redistribute it and/or modify
12  * it under the terms of the GNU General Public License as published by
13  * the Free Software Foundation; either version 2 of the License, or
14  * (at your option) any later version.
15  * 
16  * This program is distributed in the hope that it will be useful,
17  * but WITHOUT ANY WARRANTY; without even the implied warranty of
18  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
19  * GNU General Public License for more details.
20  *
21  * You should have received a copy of the GNU General Public License
22  * along with this program; if not, write to the Free Software
23  * Foundation, Inc., 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 #include <osd.h>
38
39 /*****************************************************************************
40  * VLCControls implementation 
41  *****************************************************************************/
42 @implementation VLCControls
43
44 - (IBAction)play:(id)sender
45 {
46     vlc_value_t val;
47     intf_thread_t * p_intf = VLCIntf;
48     playlist_t * p_playlist = vlc_object_find( p_intf, VLC_OBJECT_PLAYLIST,
49                                         FIND_ANYWHERE );
50     if( p_playlist )
51     {
52         vlc_mutex_lock( &p_playlist->object_lock );
53         if( p_playlist->i_size <= 0 )
54         {
55             vlc_mutex_unlock( &p_playlist->object_lock );
56             vlc_object_release( p_playlist );
57             [o_open openFileGeneric];
58         }
59         else
60         {
61             vlc_mutex_unlock( &p_playlist->object_lock );
62             vlc_object_release( p_playlist );
63         }
64
65     }
66     val.i_int = config_GetInt( p_intf, "key-play-pause" );
67     var_Set( p_intf->p_vlc, "key-pressed", val );
68 }
69
70 - (IBAction)stop:(id)sender
71 {
72     vlc_value_t val;
73     intf_thread_t * p_intf = VLCIntf;
74     val.i_int = config_GetInt( p_intf, "key-stop" );
75     var_Set( p_intf->p_vlc, "key-pressed", val );
76 }
77
78 - (IBAction)faster:(id)sender
79 {
80     vlc_value_t val;
81     intf_thread_t * p_intf = VLCIntf;
82     val.i_int = config_GetInt( p_intf, "key-faster" );
83     var_Set( p_intf->p_vlc, "key-pressed", val );
84 }
85
86 - (IBAction)slower:(id)sender
87 {
88     vlc_value_t val;
89     intf_thread_t * p_intf = VLCIntf;
90     val.i_int = config_GetInt( p_intf, "key-slower" );
91     var_Set( p_intf->p_vlc, "key-pressed", val );
92 }
93
94 - (IBAction)prev:(id)sender
95 {
96     vlc_value_t val;
97     intf_thread_t * p_intf = VLCIntf;
98     val.i_int = config_GetInt( p_intf, "key-prev" );
99     var_Set( p_intf->p_vlc, "key-pressed", val );
100 }
101
102 - (IBAction)next:(id)sender
103 {
104     vlc_value_t val;
105     intf_thread_t * p_intf = VLCIntf;
106     val.i_int = config_GetInt( p_intf, "key-next" );
107     var_Set( p_intf->p_vlc, "key-pressed", val );
108 }
109
110 - (IBAction)random:(id)sender
111 {
112     vlc_value_t val;
113     intf_thread_t * p_intf = VLCIntf;
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     var_Get( p_playlist, "random", &val );
122     val.b_bool = !val.b_bool;
123     var_Set( p_playlist, "random", val );
124     if( val.b_bool )
125     {
126         vout_OSDMessage( p_intf, DEFAULT_CHAN, _( "Random On" ) );
127     }
128     else
129     {
130         vout_OSDMessage( p_intf, DEFAULT_CHAN, _( "Random Off" ) );
131     }    
132
133     p_intf->p_sys->b_playlist_update = VLC_TRUE;
134     p_intf->p_sys->b_intf_update = VLC_TRUE;
135     vlc_object_release( p_playlist );
136 }
137
138 - (IBAction)repeat:(id)sender
139 {
140     vlc_value_t val;
141     intf_thread_t * p_intf = VLCIntf;
142     playlist_t * p_playlist = vlc_object_find( p_intf, VLC_OBJECT_PLAYLIST,
143                                                        FIND_ANYWHERE );
144     if( p_playlist == NULL )
145     {
146         return;
147     }
148
149     var_Get( p_playlist, "repeat", &val );
150     if (!val.b_bool)
151     {   
152         var_Set( p_playlist, "loop", val );
153     } 
154     val.b_bool = !val.b_bool;
155     var_Set( p_playlist, "repeat", val );
156     if( val.b_bool )
157     {
158         vout_OSDMessage( p_intf, DEFAULT_CHAN, _( "Repeat All" ) );
159     }
160     else
161     {
162         vout_OSDMessage( p_intf, DEFAULT_CHAN, _( "Repeat Off" ) );
163     }
164
165     p_intf->p_sys->b_playlist_update = VLC_TRUE;    
166     p_intf->p_sys->b_intf_update = VLC_TRUE;
167     vlc_object_release( p_playlist );
168 }
169
170 - (IBAction)loop:(id)sender
171 {
172     vlc_value_t val;
173     intf_thread_t * p_intf = VLCIntf;
174     playlist_t * p_playlist = vlc_object_find( p_intf, VLC_OBJECT_PLAYLIST,
175                                                        FIND_ANYWHERE );
176     if( p_playlist == NULL )
177     {
178         return;
179     }
180
181     var_Get( p_playlist, "loop", &val );
182     if (!val.b_bool)
183     {
184         var_Set( p_playlist, "repeat", val );
185     }
186     val.b_bool = !val.b_bool;
187     var_Set( p_playlist, "loop", val );
188     if( val.b_bool )
189     {
190         vout_OSDMessage( p_intf, DEFAULT_CHAN, _( "Repeat One" ) );
191     }
192     else
193     {
194         vout_OSDMessage( p_intf, DEFAULT_CHAN, _( "Repeat Off" ) );
195     }    
196
197     p_intf->p_sys->b_playlist_update = VLC_TRUE;
198     p_intf->p_sys->b_intf_update = VLC_TRUE;
199     vlc_object_release( p_playlist );
200 }
201
202 - (IBAction)forward:(id)sender
203 {
204     vlc_value_t val;
205     intf_thread_t * p_intf = VLCIntf;
206     val.i_int = config_GetInt( p_intf, "key-jump+10sec" );
207     var_Set( p_intf->p_vlc, "key-pressed", val );
208 }
209
210 - (IBAction)backward:(id)sender
211 {
212     vlc_value_t val;
213     intf_thread_t * p_intf = VLCIntf;
214     val.i_int = config_GetInt( p_intf, "key-jump-10sec" );
215     var_Set( p_intf->p_vlc, "key-pressed", val );
216 }
217
218
219 - (IBAction)volumeUp:(id)sender
220 {
221     vlc_value_t val;
222     intf_thread_t * p_intf = VLCIntf;
223     val.i_int = config_GetInt( p_intf, "key-vol-up" );
224     var_Set( p_intf->p_vlc, "key-pressed", val );
225     [self updateVolumeSlider];
226 }
227
228 - (IBAction)volumeDown:(id)sender
229 {
230     vlc_value_t val;
231     intf_thread_t * p_intf = VLCIntf;
232     val.i_int = config_GetInt( p_intf, "key-vol-down" );
233     var_Set( p_intf->p_vlc, "key-pressed", val );
234     [self updateVolumeSlider];
235 }
236
237 - (IBAction)mute:(id)sender
238 {
239     vlc_value_t val;
240     intf_thread_t * p_intf = VLCIntf;
241     val.i_int = config_GetInt( p_intf, "key-vol-mute" );
242     var_Set( p_intf->p_vlc, "key-pressed", val );
243     [self updateVolumeSlider];
244 }
245
246 - (IBAction)volumeSliderUpdated:(id)sender
247 {
248     intf_thread_t * p_intf = VLCIntf;
249     audio_volume_t i_volume = (audio_volume_t)[sender intValue];
250
251     aout_VolumeSet( p_intf, i_volume * AOUT_VOLUME_STEP );
252 }
253
254 - (void)updateVolumeSlider
255 {
256     intf_thread_t * p_intf = VLCIntf;
257     audio_volume_t i_volume;
258
259     aout_VolumeGet( p_intf, &i_volume );
260
261     [o_volumeslider setFloatValue: (float)(i_volume / AOUT_VOLUME_STEP)];
262 }
263
264 - (IBAction)windowAction:(id)sender
265 {
266     id o_window = [NSApp keyWindow];
267     NSString *o_title = [sender title];
268     NSArray *o_windows = [NSApp orderedWindows];
269     NSEnumerator *o_enumerator = [o_windows objectEnumerator];
270     vout_thread_t *p_vout = vlc_object_find( VLCIntf, VLC_OBJECT_VOUT,
271                                               FIND_ANYWHERE );
272
273     playlist_t * p_playlist = vlc_object_find( VLCIntf, VLC_OBJECT_PLAYLIST,
274                                               FIND_ANYWHERE );
275
276     if( p_vout != NULL )
277     {
278         while ((o_window = [o_enumerator nextObject]))
279         {
280             if( [[o_window className] isEqualToString: @"VLCWindow"] )
281             {
282                 if( [o_title isEqualToString: _NS("Half Size") ] )
283                     [o_window scaleWindowWithFactor: 0.5];
284                 else if( [o_title isEqualToString: _NS("Normal Size") ] )
285                     [o_window scaleWindowWithFactor: 1.0];
286                 else if( [o_title isEqualToString: _NS("Double Size") ] )
287                     [o_window scaleWindowWithFactor: 2.0];
288                 else if( [o_title isEqualToString: _NS("Float on Top") ] )
289                     [o_window toggleFloatOnTop];
290                 else if( [o_title isEqualToString: _NS("Fit to Screen") ] )
291                 {
292                     if( ![o_window isZoomed] )
293                         [o_window performZoom:self];
294                 }
295                 else if( [o_title isEqualToString: _NS("Snapshot") ] )
296                 {
297                     [o_window snapshot];
298                 }
299                 else
300                 {
301                     vlc_value_t val;
302                     var_Get( p_vout, "fullscreen", &val );
303                     var_Set( p_vout, "fullscreen", (vlc_value_t)!val.b_bool );
304                 }
305                 break;
306             }
307         }
308         vlc_object_release( (vlc_object_t *)p_vout );
309         if (p_playlist) vlc_object_release(p_playlist);
310     }
311
312     else if ( p_playlist != NULL )
313     {
314         if (! ([o_title isEqualToString: _NS("Half Size") ] ||
315                [o_title isEqualToString: _NS("Normal Size") ] ||
316                [o_title isEqualToString: _NS("Double Size") ] ||
317                [o_title isEqualToString: _NS("Float on Top") ] ||
318                [o_title isEqualToString: _NS("Fit to Screen") ] ))
319         {
320             vlc_value_t val;
321             var_Get( p_playlist, "fullscreen", &val );
322             var_Set( p_playlist, "fullscreen", (vlc_value_t)!val.b_bool );
323         }
324     vlc_object_release( (vlc_object_t *)p_playlist );
325     }
326
327 }
328
329 - (void)setupVarMenuItem:(NSMenuItem *)o_mi
330                     target:(vlc_object_t *)p_object
331                     var:(const char *)psz_variable
332                     selector:(SEL)pf_callback
333 {
334     vlc_value_t val, text;
335     int i_type = var_Type( p_object, psz_variable );
336
337     switch( i_type & VLC_VAR_TYPE )
338     {
339     case VLC_VAR_VOID:
340     case VLC_VAR_BOOL:
341     case VLC_VAR_VARIABLE:
342     case VLC_VAR_STRING:
343     case VLC_VAR_INTEGER:
344         break;
345     default:
346         /* Variable doesn't exist or isn't handled */
347         return;
348     }
349     
350     /* Make sure we want to display the variable */
351     if( i_type & VLC_VAR_HASCHOICE )
352     {
353         var_Change( p_object, psz_variable, VLC_VAR_CHOICESCOUNT, &val, NULL );
354         if( val.i_int == 0 ) return;
355         if( (i_type & VLC_VAR_TYPE) != VLC_VAR_VARIABLE && val.i_int == 1 )
356             return;
357     }
358     
359     /* Get the descriptive name of the variable */
360     var_Change( p_object, psz_variable, VLC_VAR_GETTEXT, &text, NULL );
361     [o_mi setTitle: [[VLCMain sharedInstance] localizedString: text.psz_string ?
362                                         text.psz_string : strdup( psz_variable ) ]];
363
364     var_Get( p_object, psz_variable, &val );
365     if( i_type & VLC_VAR_HASCHOICE )
366     {
367         NSMenu *o_menu = [o_mi submenu];
368
369         [self setupVarMenu: o_menu forMenuItem: o_mi target:p_object
370                         var:psz_variable selector:pf_callback];
371         
372         if( text.psz_string ) free( text.psz_string );
373         return;
374     }
375
376     VLCMenuExt *o_data;
377     switch( i_type & VLC_VAR_TYPE )
378     {
379     case VLC_VAR_VOID:
380         o_data = [[VLCMenuExt alloc] initWithVar: psz_variable Object: p_object->i_object_id
381                 Value: val ofType: i_type];
382         [o_mi setRepresentedObject: [NSValue valueWithPointer:[o_data retain]]];
383         break;
384
385     case VLC_VAR_BOOL:
386         o_data = [[VLCMenuExt alloc] initWithVar: psz_variable Object: p_object->i_object_id
387                 Value: val ofType: i_type];
388         [o_mi setRepresentedObject: [NSValue valueWithPointer:[o_data retain]]];
389         if( !( i_type & VLC_VAR_ISCOMMAND ) )
390             [o_mi setState: val.b_bool ? TRUE : FALSE ];
391         break;
392
393     default:
394         if( text.psz_string ) free( text.psz_string );
395         return;
396     }
397
398     if( ( i_type & VLC_VAR_TYPE ) == VLC_VAR_STRING ) free( val.psz_string );
399     if( text.psz_string ) free( text.psz_string );
400 }
401
402
403 - (void)setupVarMenu:(NSMenu *)o_menu
404                     forMenuItem: (NSMenuItem *)o_parent
405                     target:(vlc_object_t *)p_object
406                     var:(const char *)psz_variable
407                     selector:(SEL)pf_callback
408 {
409     vlc_value_t val, val_list, text_list;
410     int i_type, i, i_nb_items;
411
412     /* remove previous items */
413     i_nb_items = [o_menu numberOfItems];
414     for( i = 0; i < i_nb_items; i++ )
415     {
416         [o_menu removeItemAtIndex: 0];
417     }
418
419     /* Check the type of the object variable */
420     i_type = var_Type( p_object, psz_variable );
421
422     /* Make sure we want to display the variable */
423     if( i_type & VLC_VAR_HASCHOICE )
424     {
425         var_Change( p_object, psz_variable, VLC_VAR_CHOICESCOUNT, &val, NULL );
426         if( val.i_int == 0 ) return;
427         if( (i_type & VLC_VAR_TYPE) != VLC_VAR_VARIABLE && val.i_int == 1 )
428             return;
429     }
430     else
431     {
432         return;
433     }
434
435     switch( i_type & VLC_VAR_TYPE )
436     {
437     case VLC_VAR_VOID:
438     case VLC_VAR_BOOL:
439     case VLC_VAR_VARIABLE:
440     case VLC_VAR_STRING:
441     case VLC_VAR_INTEGER:
442         break;
443     default:
444         /* Variable doesn't exist or isn't handled */
445         return;
446     }
447
448     if( var_Get( p_object, psz_variable, &val ) < 0 )
449     {
450         return;
451     }
452
453     if( var_Change( p_object, psz_variable, VLC_VAR_GETLIST,
454                     &val_list, &text_list ) < 0 )
455     {
456         if( (i_type & VLC_VAR_TYPE) == VLC_VAR_STRING ) free( val.psz_string );
457         return;
458     }
459
460     /* make (un)sensitive */
461     [o_parent setEnabled: ( val_list.p_list->i_count > 1 )];
462
463     for( i = 0; i < val_list.p_list->i_count; i++ )
464     {
465         vlc_value_t another_val;
466         NSMenuItem * o_lmi;
467         NSString *o_title = @"";
468         VLCMenuExt *o_data;
469
470         switch( i_type & VLC_VAR_TYPE )
471         {
472         case VLC_VAR_STRING:
473             another_val.psz_string =
474                 strdup(val_list.p_list->p_values[i].psz_string);
475
476             o_title = [[VLCMain sharedInstance] localizedString: text_list.p_list->p_values[i].psz_string ?
477                 text_list.p_list->p_values[i].psz_string : val_list.p_list->p_values[i].psz_string ];
478
479             o_lmi = [o_menu addItemWithTitle: o_title action: pf_callback keyEquivalent: @""];
480             o_data = [[VLCMenuExt alloc] initWithVar: strdup(psz_variable) Object: p_object->i_object_id
481                     Value: another_val ofType: i_type];
482             [o_lmi setRepresentedObject: [NSValue valueWithPointer:[o_data retain]]];
483             [o_lmi setTarget: self];
484             
485             if( !strcmp( val.psz_string, val_list.p_list->p_values[i].psz_string ) && !( i_type & VLC_VAR_ISCOMMAND ) )
486                 [o_lmi setState: TRUE ];
487
488             break;
489
490         case VLC_VAR_INTEGER:
491
492              o_title = text_list.p_list->p_values[i].psz_string ?
493                                  [[VLCMain sharedInstance] localizedString: strdup( text_list.p_list->p_values[i].psz_string )] :
494                                  [NSString stringWithFormat: @"%d",
495                                  val_list.p_list->p_values[i].i_int];
496
497             o_lmi = [[o_menu addItemWithTitle: o_title action: pf_callback keyEquivalent: @""] retain ];
498             o_data = [[VLCMenuExt alloc] initWithVar: strdup(psz_variable) Object: p_object->i_object_id
499                     Value: val_list.p_list->p_values[i] ofType: i_type];
500             [o_lmi setRepresentedObject: [NSValue valueWithPointer:[ o_data retain]]];
501             [o_lmi setTarget: self];
502
503             if( val_list.p_list->p_values[i].i_int == val.i_int && !( i_type & VLC_VAR_ISCOMMAND ) )
504                 [o_lmi setState: TRUE ];
505             break;
506
507         default:
508           break;
509         }
510     }
511     
512     /* clean up everything */
513     if( (i_type & VLC_VAR_TYPE) == VLC_VAR_STRING ) free( val.psz_string );
514     var_Change( p_object, psz_variable, VLC_VAR_FREELIST, &val_list, &text_list );
515 }
516
517 - (IBAction)toggleVar:(id)sender
518 {
519     NSMenuItem *o_mi = (NSMenuItem *)sender;
520     VLCMenuExt *o_data = [[o_mi representedObject] pointerValue];
521     [NSThread detachNewThreadSelector: @selector(toggleVarThread:)
522         toTarget: self withObject: o_data];
523
524     return;
525 }
526
527 - (int)toggleVarThread: (id)_o_data
528 {
529     vlc_object_t *p_object;
530     NSAutoreleasePool * o_pool = [[NSAutoreleasePool alloc] init];
531     VLCMenuExt *o_data = (VLCMenuExt *)_o_data;
532
533     vlc_thread_set_priority( VLCIntf , VLC_THREAD_PRIORITY_LOW );
534
535     p_object = (vlc_object_t *)vlc_object_get( VLCIntf,
536                                     [o_data objectID] );
537
538     if( p_object != NULL )
539     {
540         var_Set( p_object, strdup([o_data name]), [o_data value] );
541         vlc_object_release( p_object );
542         [o_pool release];
543         return VLC_TRUE;
544     }
545     [o_pool release];
546     return VLC_EGENERIC;
547 }
548
549 @end
550
551 @implementation VLCControls (NSMenuValidation)
552  
553 - (BOOL)validateMenuItem:(NSMenuItem *)o_mi
554 {
555     BOOL bEnabled = TRUE;
556     vlc_value_t val;
557     intf_thread_t * p_intf = VLCIntf;
558     playlist_t * p_playlist = vlc_object_find( p_intf, VLC_OBJECT_PLAYLIST,
559                                                        FIND_ANYWHERE );
560
561     if( p_playlist != NULL )
562     {
563         vlc_mutex_lock( &p_playlist->object_lock );
564     }
565
566 #define p_input p_playlist->p_input
567
568     if( [[o_mi title] isEqualToString: _NS("Faster")] ||
569         [[o_mi title] isEqualToString: _NS("Slower")] )
570     {
571         if( p_playlist != NULL && p_input != NULL )
572         {
573             bEnabled = p_input->input.b_can_pace_control;
574         }
575         else
576         {
577             bEnabled = FALSE;
578         }
579     }
580     else if( [[o_mi title] isEqualToString: _NS("Stop")] )
581     {
582         if( p_playlist == NULL || p_input == NULL )
583         {
584             bEnabled = FALSE;
585         }
586     }
587     else if( [[o_mi title] isEqualToString: _NS("Previous")] ||
588              [[o_mi title] isEqualToString: _NS("Next")] )
589     {
590         if( p_playlist == NULL )
591         {
592             bEnabled = FALSE;
593         }
594         else
595         {
596             bEnabled = p_playlist->i_size > 1;
597         }
598     }
599     else if( [[o_mi title] isEqualToString: _NS("Random")] )
600     {
601         int i_state;
602         var_Get( p_playlist, "random", &val );
603         i_state = val.b_bool ? NSOnState : NSOffState;
604         [o_mi setState: i_state];
605     }
606     else if( [[o_mi title] isEqualToString: _NS("Repeat One")] )
607     {
608         int i_state;
609         var_Get( p_playlist, "repeat", &val );
610         i_state = val.b_bool ? NSOnState : NSOffState;
611         [o_mi setState: i_state];
612     }
613     else if( [[o_mi title] isEqualToString: _NS("Repeat All")] )
614     {
615         int i_state;
616         var_Get( p_playlist, "loop", &val );
617         i_state = val.b_bool ? NSOnState : NSOffState;
618         [o_mi setState: i_state];
619     }
620     else if( [[o_mi title] isEqualToString: _NS("Step Forward")] ||
621              [[o_mi title] isEqualToString: _NS("Step Backward")] )
622     {
623         bEnabled = FALSE;
624         if( p_playlist != NULL && p_input != NULL )
625         {
626             var_Get( p_input, "seekable", &val);
627             if( val.b_bool )
628             {
629                 bEnabled = TRUE;
630             }
631         }
632     }
633     else if( [[o_mi title] isEqualToString: _NS("Mute")] ) 
634     {
635         [o_mi setState: p_intf->p_sys->b_mute ? NSOnState : NSOffState];
636     }
637     else if( [[o_mi title] isEqualToString: _NS("Half Size")] ||
638                 [[o_mi title] isEqualToString: _NS("Normal Size")] ||
639                 [[o_mi title] isEqualToString: _NS("Double Size")] ||
640                 [[o_mi title] isEqualToString: _NS("Fit to Screen")] ||
641                 [[o_mi title] isEqualToString: _NS("Snapshot")] ||
642                 [[o_mi title] isEqualToString: _NS("Float on Top")] )
643     {
644         id o_window;
645         NSArray *o_windows = [NSApp orderedWindows];
646         NSEnumerator *o_enumerator = [o_windows objectEnumerator];
647         bEnabled = FALSE;
648         
649         vout_thread_t   *p_vout = vlc_object_find( p_intf, VLC_OBJECT_VOUT,
650                                               FIND_ANYWHERE );
651         if( p_vout != NULL )
652         {
653             if ( [[o_mi title] isEqualToString: _NS("Float on Top")] )
654             {
655                 var_Get( p_vout, "video-on-top", &val );
656                 [o_mi setState: val.b_bool ?  NSOnState : NSOffState];
657             }
658
659             while ((o_window = [o_enumerator nextObject]))
660             {
661                 if( [[o_window className] isEqualToString: @"VLCWindow"] )
662                 {
663                     bEnabled = TRUE;
664                     break;
665                 }
666             }
667             vlc_object_release( (vlc_object_t *)p_vout );
668         }
669     }
670     else if( [[o_mi title] isEqualToString: _NS("Fullscreen")])
671     {
672         if (p_playlist)
673         {
674             var_Get(p_playlist, "fullscreen", &val );
675             [o_mi setState: val.b_bool];
676             bEnabled = TRUE;
677         }
678         else
679         {
680             bEnabled = FALSE;
681         }
682     }
683
684
685     if( p_playlist != NULL )
686     {
687         vlc_mutex_unlock( &p_playlist->object_lock );
688         vlc_object_release( p_playlist );
689     }
690
691     return( bEnabled );
692 }
693
694 @end
695
696 /*****************************************************************************
697  * VLCMenuExt implementation 
698  *****************************************************************************
699  * Object connected to a playlistitem which remembers the data belonging to
700  * the variable of the autogenerated menu
701  *****************************************************************************/
702 @implementation VLCMenuExt
703
704 - (id)initWithVar: (const char *)_psz_name Object: (int)i_id
705         Value: (vlc_value_t)val ofType: (int)_i_type
706 {
707     self = [super init];
708
709     if( self != nil )
710     {
711         psz_name = strdup( _psz_name );
712         i_object_id = i_id;
713         value = val;
714         i_type = _i_type;
715     }
716
717     return( self );
718 }
719
720 - (void)dealloc
721 {
722     free( psz_name );
723 }
724
725 - (char *)name
726 {
727     return psz_name;
728 }
729
730 - (int)objectID
731 {
732     return i_object_id;
733 }
734
735 - (vlc_value_t)value
736 {
737     return value;
738 }
739
740 - (int)type
741 {
742     return i_type;
743 }
744
745 @end