One more time removing of some useless tests.
[vlc.git] / modules / gui / macosx / controls.m
1 /*****************************************************************************
2  * controls.m: MacOS X interface module
3  *****************************************************************************
4  * Copyright (C) 2002-2007 the VideoLAN team
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  *          Benjamin Pracht <bigben at videolan doit org>
11  *          Felix K├╝hne <fkuehne at videolan dot org>
12  *
13  * This program is free software; you can redistribute it and/or modify
14  * it under the terms of the GNU General Public License as published by
15  * the Free Software Foundation; either version 2 of the License, or
16  * (at your option) any later version.
17  *
18  * This program is distributed in the hope that it will be useful,
19  * but WITHOUT ANY WARRANTY; without even the implied warranty of
20  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
21  * GNU General Public License for more details.
22  *
23  * You should have received a copy of the GNU General Public License
24  * along with this program; if not, write to the Free Software
25  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston MA 02110-1301, USA.
26  *****************************************************************************/
27
28 /*****************************************************************************
29  * Preamble
30  *****************************************************************************/
31 #include <stdlib.h>                                      /* malloc(), free() */
32 #include <sys/param.h>                                    /* for MAXPATHLEN */
33 #include <string.h>
34
35 #import "intf.h"
36 #import "vout.h"
37 #import "open.h"
38 #import "controls.h"
39 #import "playlist.h"
40 #include <vlc_osd.h>
41 #include <vlc_keys.h>
42
43 /*****************************************************************************
44  * VLCControls implementation
45  *****************************************************************************/
46 @implementation VLCControls
47
48 - (id)init
49 {
50     [super init];
51     o_fs_panel = [[VLCFSPanel alloc] init];
52     return self;
53 }
54
55 - (void)awakeFromNib
56 {
57     [o_specificTime_mi setTitle: _NS("Jump To Time")];
58     [o_specificTime_cancel_btn setTitle: _NS("Cancel")];
59     [o_specificTime_ok_btn setTitle: _NS("OK")];
60     [o_specificTime_sec_lbl setStringValue: _NS("sec.")];
61     [o_specificTime_goTo_lbl setStringValue: _NS("Jump to time")];
62
63     o_repeat_off = [NSImage imageNamed:@"repeat_embedded"];
64
65     [self controlTintChanged];
66
67     [[NSNotificationCenter defaultCenter] addObserver: self
68                                              selector: @selector( controlTintChanged )
69                                                  name: NSControlTintDidChangeNotification
70                                                object: nil];
71 }
72
73 - (void)controlTintChanged
74 {
75     int i_repeat = 0;
76     if( [o_btn_repeat image] == o_repeat_single )
77         i_repeat = 1;
78     else if( [o_btn_repeat image] == o_repeat_all )
79         i_repeat = 2;
80
81     if( [NSColor currentControlTint] == NSGraphiteControlTint )
82     {
83         o_repeat_single = [NSImage imageNamed:@"repeat_single_embedded_graphite"];
84         o_repeat_all = [NSImage imageNamed:@"repeat_embedded_graphite"];
85         
86         [o_btn_shuffle setAlternateImage: [NSImage imageNamed: @"shuffle_embedded_graphite"]];
87         [o_btn_addNode setAlternateImage: [NSImage imageNamed: @"add_embedded_graphite"]];
88     }
89     else
90     {
91         o_repeat_single = [NSImage imageNamed:@"repeat_single_embedded_blue"];
92         o_repeat_all = [NSImage imageNamed:@"repeat_embedded_blue"];
93         
94         [o_btn_shuffle setAlternateImage: [NSImage imageNamed: @"shuffle_embedded_blue"]];
95         [o_btn_addNode setAlternateImage: [NSImage imageNamed: @"add_embedded_blue"]];
96     }
97     
98     /* update the repeat button, but keep its state */
99     if( i_repeat == 1 )
100         [self repeatOne];
101     else if( i_repeat == 2 )
102         [self repeatAll];
103     else
104         [self repeatOff];
105 }
106
107 - (void)dealloc
108 {
109     [[NSNotificationCenter defaultCenter] removeObserver: self];
110     
111     [o_repeat_single release];
112     [o_repeat_all release];
113     [o_repeat_off release];
114     
115     [super dealloc];
116 }
117
118 - (IBAction)play:(id)sender
119 {
120     vlc_value_t val;
121     intf_thread_t * p_intf = VLCIntf;
122     playlist_t * p_playlist = pl_Yield( p_intf );
123
124     vlc_mutex_lock( &p_playlist->object_lock );
125     if( playlist_IsEmpty( p_playlist ) )
126     {
127         vlc_mutex_unlock( &p_playlist->object_lock );
128         vlc_object_release( p_playlist );
129         [o_main intfOpenFileGeneric: (id)sender];
130     }
131     else
132     {
133         vlc_mutex_unlock( &p_playlist->object_lock );
134         vlc_object_release( p_playlist );
135     }
136
137     val.i_int = config_GetInt( p_intf, "key-play-pause" );
138     var_Set( p_intf->p_libvlc, "key-pressed", val );
139 }
140
141 /* Small helper method */
142
143 -(id) getVoutView
144 {
145     id o_window;
146     id o_vout_view = nil;
147     id o_embedded_vout_list = [[VLCMain sharedInstance] getEmbeddedList];
148     NSEnumerator *o_enumerator = [[NSApp orderedWindows] objectEnumerator];
149     while( !o_vout_view && ( o_window = [o_enumerator nextObject] ) )
150     {
151         /* We have an embedded vout */
152         if( [o_embedded_vout_list windowContainsEmbedded: o_window] )
153         {
154             o_vout_view = [o_embedded_vout_list getViewForWindow: o_window];
155         }
156         /* We have a detached vout */
157         else if( [[o_window className] isEqualToString: @"VLCVoutWindow"] )
158         {
159             msg_Dbg( VLCIntf, "detached vout controls.m call getVoutView" );
160             o_vout_view = [o_window getVoutView];
161         }
162     }
163     return o_vout_view;
164 }
165
166
167 - (IBAction)stop:(id)sender
168 {
169     vlc_value_t val;
170     intf_thread_t * p_intf = VLCIntf;
171     val.i_int = config_GetInt( p_intf, "key-stop" );
172     var_Set( p_intf->p_libvlc, "key-pressed", val );
173 }
174
175 - (IBAction)faster:(id)sender
176 {
177     vlc_value_t val;
178     intf_thread_t * p_intf = VLCIntf;
179     val.i_int = config_GetInt( p_intf, "key-faster" );
180     var_Set( p_intf->p_libvlc, "key-pressed", val );
181 }
182
183 - (IBAction)slower:(id)sender
184 {
185     vlc_value_t val;
186     intf_thread_t * p_intf = VLCIntf;
187     val.i_int = config_GetInt( p_intf, "key-slower" );
188     var_Set( p_intf->p_libvlc, "key-pressed", val );
189 }
190
191 - (IBAction)prev:(id)sender
192 {
193     vlc_value_t val;
194     intf_thread_t * p_intf = VLCIntf;
195     val.i_int = config_GetInt( p_intf, "key-prev" );
196     var_Set( p_intf->p_libvlc, "key-pressed", val );
197 }
198
199 - (IBAction)next:(id)sender
200 {
201     vlc_value_t val;
202     intf_thread_t * p_intf = VLCIntf;
203     val.i_int = config_GetInt( p_intf, "key-next" );
204     var_Set( p_intf->p_libvlc, "key-pressed", val );
205 }
206
207 - (IBAction)random:(id)sender
208 {
209     vlc_value_t val;
210     intf_thread_t * p_intf = VLCIntf;
211     playlist_t * p_playlist = pl_Yield( p_intf );
212
213     var_Get( p_playlist, "random", &val );
214     val.b_bool = !val.b_bool;
215     var_Set( p_playlist, "random", val );
216     if( val.b_bool )
217     {
218         vout_OSDMessage( p_intf, DEFAULT_CHAN, _( "Random On" ) );
219         config_PutInt( p_playlist, "random", 1 );
220     }
221     else
222     {
223         vout_OSDMessage( p_intf, DEFAULT_CHAN, _( "Random Off" ) );
224         config_PutInt( p_playlist, "random", 0 );
225     }
226
227     p_intf->p_sys->b_playmode_update = VLC_TRUE;
228     p_intf->p_sys->b_intf_update = VLC_TRUE;
229     vlc_object_release( p_playlist );
230 }
231
232 /* three little ugly helpers */
233 - (void)repeatOne
234 {
235     [o_btn_repeat setImage: o_repeat_single];
236     [o_btn_repeat setAlternateImage: o_repeat_all];
237 }
238 - (void)repeatAll
239 {
240     [o_btn_repeat setImage: o_repeat_all];
241     [o_btn_repeat setAlternateImage: o_repeat_off];
242 }
243 - (void)repeatOff
244 {
245     [o_btn_repeat setImage: o_repeat_off];
246     [o_btn_repeat setAlternateImage: o_repeat_single];
247 }
248 - (void)shuffle
249 {
250     vlc_value_t val;
251     playlist_t *p_playlist = pl_Yield( VLCIntf );
252     var_Get( p_playlist, "random", &val );
253     [o_btn_shuffle setState: val.b_bool];
254     vlc_object_release( p_playlist );
255 }
256
257 - (IBAction)repeatButtonAction:(id)sender
258 {
259     vlc_value_t looping,repeating;
260     intf_thread_t * p_intf = VLCIntf;
261     playlist_t * p_playlist = pl_Yield( p_intf );
262
263     var_Get( p_playlist, "repeat", &repeating );
264     var_Get( p_playlist, "loop", &looping );
265
266     if( !repeating.b_bool && !looping.b_bool )
267     {
268         /* was: no repeating at all, switching to Repeat One */
269  
270         /* set our button's look */
271         [self repeatOne];
272  
273         /* prepare core communication */
274         repeating.b_bool = VLC_TRUE;
275         looping.b_bool = VLC_FALSE;
276         config_PutInt( p_playlist, "repeat", 1 );
277         config_PutInt( p_playlist, "loop", 0 );
278  
279         /* show the change */
280         vout_OSDMessage( p_intf, DEFAULT_CHAN, _( "Repeat One" ) );
281     }
282     else if( repeating.b_bool && !looping.b_bool )
283     {
284         /* was: Repeat One, switching to Repeat All */
285  
286         /* set our button's look */
287         [self repeatAll];
288  
289         /* prepare core communication */
290         repeating.b_bool = VLC_FALSE;
291         looping.b_bool = VLC_TRUE;
292         config_PutInt( p_playlist, "repeat", 0 );
293         config_PutInt( p_playlist, "loop", 1 );
294  
295         /* show the change */
296         vout_OSDMessage( p_intf, DEFAULT_CHAN, _( "Repeat All" ) );
297     }
298     else
299     {
300         /* was: Repeat All or bug in VLC, switching to Repeat Off */
301  
302         /* set our button's look */
303         [self repeatOff];
304  
305         /* prepare core communication */
306         repeating.b_bool = VLC_FALSE;
307         looping.b_bool = VLC_FALSE;
308         config_PutInt( p_playlist, "repeat", 0 );
309         config_PutInt( p_playlist, "loop", 0 );
310  
311         /* show the change */
312         vout_OSDMessage( p_intf, DEFAULT_CHAN, _( "Repeat Off" ) );
313     }
314
315     /* communicate with core and the main intf loop */
316     var_Set( p_playlist, "repeat", repeating );
317     var_Set( p_playlist, "loop", looping );
318     p_intf->p_sys->b_playmode_update = VLC_TRUE;
319     p_intf->p_sys->b_intf_update = VLC_TRUE;
320
321     vlc_object_release( p_playlist );
322 }
323
324
325 - (IBAction)repeat:(id)sender
326 {
327     vlc_value_t val;
328     intf_thread_t * p_intf = VLCIntf;
329     playlist_t * p_playlist = pl_Yield( p_intf );
330
331     var_Get( p_playlist, "repeat", &val );
332     if (!val.b_bool)
333     {
334         var_Set( p_playlist, "loop", val );
335     }
336     val.b_bool = !val.b_bool;
337     var_Set( p_playlist, "repeat", val );
338     if( val.b_bool )
339     {
340         vout_OSDMessage( p_intf, DEFAULT_CHAN, _( "Repeat One" ) );
341         config_PutInt( p_playlist, "repeat", 1 );
342     }
343     else
344     {
345         vout_OSDMessage( p_intf, DEFAULT_CHAN, _( "Repeat Off" ) );
346         config_PutInt( p_playlist, "repeat", 0 );
347     }
348  
349     p_intf->p_sys->b_playmode_update = VLC_TRUE;
350     p_intf->p_sys->b_intf_update = VLC_TRUE;
351     vlc_object_release( p_playlist );
352 }
353
354 - (IBAction)loop:(id)sender
355 {
356     vlc_value_t val;
357     intf_thread_t * p_intf = VLCIntf;
358     playlist_t * p_playlist = pl_Yield( p_intf );
359
360     var_Get( p_playlist, "loop", &val );
361     if (!val.b_bool)
362     {
363         var_Set( p_playlist, "repeat", val );
364     }
365     val.b_bool = !val.b_bool;
366     var_Set( p_playlist, "loop", val );
367     if( val.b_bool )
368     {
369         vout_OSDMessage( p_intf, DEFAULT_CHAN, _( "Repeat All" ) );
370         config_PutInt( p_playlist, "loop", 1 );
371     }
372     else
373     {
374         vout_OSDMessage( p_intf, DEFAULT_CHAN, _( "Repeat Off" ) );
375         config_PutInt( p_playlist, "loop", 0 );
376     }
377
378     p_intf->p_sys->b_playmode_update = VLC_TRUE;
379     p_intf->p_sys->b_intf_update = VLC_TRUE;
380     vlc_object_release( p_playlist );
381 }
382
383 - (IBAction)forward:(id)sender
384 {
385     vlc_value_t val;
386     intf_thread_t * p_intf = VLCIntf;
387     val.i_int = config_GetInt( p_intf, "key-jump+short" );
388     var_Set( p_intf->p_libvlc, "key-pressed", val );
389 }
390
391 - (IBAction)backward:(id)sender
392 {
393     vlc_value_t val;
394     intf_thread_t * p_intf = VLCIntf;
395     val.i_int = config_GetInt( p_intf, "key-jump-short" );
396     var_Set( p_intf->p_libvlc, "key-pressed", val );
397 }
398
399
400 - (IBAction)volumeUp:(id)sender
401 {
402     vlc_value_t val;
403     intf_thread_t * p_intf = VLCIntf;
404     val.i_int = config_GetInt( p_intf, "key-vol-up" );
405     var_Set( p_intf->p_libvlc, "key-pressed", val );
406     /* Manage volume status */
407     [o_main manageVolumeSlider];
408 }
409
410 - (IBAction)volumeDown:(id)sender
411 {
412     vlc_value_t val;
413     intf_thread_t * p_intf = VLCIntf;
414     val.i_int = config_GetInt( p_intf, "key-vol-down" );
415     var_Set( p_intf->p_libvlc, "key-pressed", val );
416     /* Manage volume status */
417     [o_main manageVolumeSlider];
418 }
419
420 - (IBAction)mute:(id)sender
421 {
422     vlc_value_t val;
423     intf_thread_t * p_intf = VLCIntf;
424     val.i_int = config_GetInt( p_intf, "key-vol-mute" );
425     var_Set( p_intf->p_libvlc, "key-pressed", val );
426     /* Manage volume status */
427     [o_main manageVolumeSlider];
428 }
429
430 - (IBAction)volumeSliderUpdated:(id)sender
431 {
432     intf_thread_t * p_intf = VLCIntf;
433     audio_volume_t i_volume = (audio_volume_t)[sender intValue];
434     int i_volume_step = 0;
435     i_volume_step = config_GetInt( p_intf->p_libvlc, "volume-step" );
436     aout_VolumeSet( p_intf, i_volume * i_volume_step );
437     /* Manage volume status */
438     [o_main manageVolumeSlider];
439 }
440
441 - (IBAction)showPosition: (id)sender
442 {
443     vout_thread_t *p_vout = vlc_object_find( VLCIntf, VLC_OBJECT_VOUT,
444                                              FIND_ANYWHERE );
445     if( p_vout != NULL )
446     {
447         vlc_value_t val;
448         intf_thread_t * p_intf = VLCIntf;
449         val.i_int = config_GetInt( p_intf, "key-position" );
450         var_Set( p_intf, "key-pressed", val );
451         vlc_object_release( (vlc_object_t *)p_vout );
452     }
453 }
454
455 - (IBAction)toogleFullscreen:(id)sender {
456     NSMenuItem *o_mi = [[NSMenuItem alloc] initWithTitle: _NS("Fullscreen") action: nil keyEquivalent:@""];
457     [self windowAction: [o_mi autorelease]];
458 }
459
460 - (BOOL) isFullscreen {
461     id o_vout_view = [self getVoutView];
462     if( o_vout_view )
463     {
464         return [o_vout_view isFullscreen];
465     }
466     return NO;
467 }
468
469 - (IBAction)windowAction:(id)sender
470 {
471     NSString *o_title = [sender title];
472
473     vout_thread_t *p_vout = vlc_object_find( VLCIntf, VLC_OBJECT_VOUT,
474                                               FIND_ANYWHERE );
475     if( p_vout != NULL )
476     {
477         id o_vout_view = [self getVoutView];
478         if( o_vout_view )
479         {
480             if( [o_title isEqualToString: _NS("Half Size") ] )
481                 [o_vout_view scaleWindowWithFactor: 0.5 animate: YES];
482             else if( [o_title isEqualToString: _NS("Normal Size") ] )
483                 [o_vout_view scaleWindowWithFactor: 1.0 animate: YES];
484             else if( [o_title isEqualToString: _NS("Double Size") ] )
485                 [o_vout_view scaleWindowWithFactor: 2.0 animate: YES];
486             else if( [o_title isEqualToString: _NS("Float on Top") ] )
487                 [o_vout_view toggleFloatOnTop];
488             else if( [o_title isEqualToString: _NS("Fit to Screen") ] )
489             {
490                 id o_window = [o_vout_view getWindow];
491                 if( ![o_window isZoomed] )
492                     [o_window performZoom:self];
493             }
494             else if( [o_title isEqualToString: _NS("Snapshot") ] )
495             {
496                 [o_vout_view snapshot];
497             }
498             else
499             {
500                 [o_vout_view toggleFullscreen];
501             }
502         }
503         vlc_object_release( (vlc_object_t *)p_vout );
504     }
505     else
506     {
507         playlist_t * p_playlist = pl_Yield( VLCIntf );
508
509         if( [o_title isEqualToString: _NS("Fullscreen")] ||
510             [sender isKindOfClass:[NSButton class]] )
511         {
512             vlc_value_t val;
513             var_Get( p_playlist, "fullscreen", &val );
514             var_Set( p_playlist, "fullscreen", (vlc_value_t)!val.b_bool );
515         }
516
517         vlc_object_release( p_playlist );
518     }
519
520 }
521
522 - (void)scrollWheel:(NSEvent *)theEvent
523 {
524     intf_thread_t * p_intf = VLCIntf;
525     float f_yabsvalue = [theEvent deltaY] > 0.0f ? [theEvent deltaY] : -[theEvent deltaY];
526     float f_xabsvalue = [theEvent deltaX] > 0.0f ? [theEvent deltaX] : -[theEvent deltaX];
527     int i, i_yvlckey, i_xvlckey;
528
529     if ([theEvent deltaY] < 0.0f)
530         i_yvlckey = KEY_MOUSEWHEELDOWN;
531     else
532         i_yvlckey = KEY_MOUSEWHEELUP;
533
534     if ([theEvent deltaX] < 0.0f)
535         i_xvlckey = KEY_MOUSEWHEELRIGHT;
536     else
537         i_xvlckey = KEY_MOUSEWHEELLEFT;
538
539     /* Send multiple key event, depending on the intensity of the event */
540     for (i = 0; i < (int)(f_yabsvalue/4.+1.) && f_yabsvalue > 0.05 ; i++)
541         var_SetInteger( p_intf->p_libvlc, "key-pressed", i_yvlckey );
542
543     /* Prioritize Y event (sound volume) over X event */
544     if (f_yabsvalue < 0.05)
545     {
546         for (i = 0; i < (int)(f_xabsvalue/6.+1.) && f_xabsvalue > 0.05; i++)
547          var_SetInteger( p_intf->p_libvlc, "key-pressed", i_xvlckey );
548     }
549 }
550
551 - (BOOL)keyEvent:(NSEvent *)o_event
552 {
553     BOOL eventHandled = NO;
554     unichar key = [[o_event charactersIgnoringModifiers] characterAtIndex: 0];
555
556     if( key )
557     {
558         vout_thread_t *p_vout = vlc_object_find( VLCIntf, VLC_OBJECT_VOUT,
559                                               FIND_ANYWHERE );
560         if( p_vout != NULL )
561         {
562             /* Escape */
563             if( key == (unichar) 0x1b )
564             {
565                 id o_vout_view = [self getVoutView];
566                 if( o_vout_view && [o_vout_view isFullscreen] )
567                 {
568                     [o_vout_view toggleFullscreen];
569                     eventHandled = YES;
570                 }
571             }
572             else if( key == ' ' )
573             {
574                 [self play:self];
575                 eventHandled = YES;
576             }
577             vlc_object_release( (vlc_object_t *)p_vout );
578         }
579     }
580     return eventHandled;
581 }
582
583 - (void)setupVarMenuItem:(NSMenuItem *)o_mi
584                     target:(vlc_object_t *)p_object
585                     var:(const char *)psz_variable
586                     selector:(SEL)pf_callback
587 {
588     vlc_value_t val, text;
589     int i_type = var_Type( p_object, psz_variable );
590
591     switch( i_type & VLC_VAR_TYPE )
592     {
593     case VLC_VAR_VOID:
594     case VLC_VAR_BOOL:
595     case VLC_VAR_VARIABLE:
596     case VLC_VAR_STRING:
597     case VLC_VAR_INTEGER:
598         break;
599     default:
600         /* Variable doesn't exist or isn't handled */
601         return;
602     }
603  
604     /* Make sure we want to display the variable */
605     if( i_type & VLC_VAR_HASCHOICE )
606     {
607         var_Change( p_object, psz_variable, VLC_VAR_CHOICESCOUNT, &val, NULL );
608         if( val.i_int == 0 ) return;
609         if( (i_type & VLC_VAR_TYPE) != VLC_VAR_VARIABLE && val.i_int == 1 )
610             return;
611     }
612  
613     /* Get the descriptive name of the variable */
614     var_Change( p_object, psz_variable, VLC_VAR_GETTEXT, &text, NULL );
615     [o_mi setTitle: [[VLCMain sharedInstance] localizedString: text.psz_string ?
616                                         text.psz_string : strdup( psz_variable ) ]];
617
618     var_Get( p_object, psz_variable, &val );
619     if( i_type & VLC_VAR_HASCHOICE )
620     {
621         NSMenu *o_menu = [o_mi submenu];
622
623         [self setupVarMenu: o_menu forMenuItem: o_mi target:p_object
624                         var:psz_variable selector:pf_callback];
625  
626         free( text.psz_string );
627         return;
628     }
629
630     VLCMenuExt *o_data;
631     switch( i_type & VLC_VAR_TYPE )
632     {
633     case VLC_VAR_VOID:
634         o_data = [[VLCMenuExt alloc] initWithVar: psz_variable Object: p_object->i_object_id
635                 Value: val ofType: i_type];
636         [o_mi setRepresentedObject: [NSValue valueWithPointer:[o_data retain]]];
637         break;
638
639     case VLC_VAR_BOOL:
640         o_data = [[VLCMenuExt alloc] initWithVar: psz_variable Object: p_object->i_object_id
641                 Value: val ofType: i_type];
642         [o_mi setRepresentedObject: [NSValue valueWithPointer:[o_data retain]]];
643         if( !( i_type & VLC_VAR_ISCOMMAND ) )
644             [o_mi setState: val.b_bool ? TRUE : FALSE ];
645         break;
646
647     default:
648         free( text.psz_string );
649         return;
650     }
651
652     if( ( i_type & VLC_VAR_TYPE ) == VLC_VAR_STRING ) free( val.psz_string );
653     free( text.psz_string );
654 }
655
656
657 - (void)setupVarMenu:(NSMenu *)o_menu
658                     forMenuItem: (NSMenuItem *)o_parent
659                     target:(vlc_object_t *)p_object
660                     var:(const char *)psz_variable
661                     selector:(SEL)pf_callback
662 {
663     vlc_value_t val, val_list, text_list;
664     int i_type, i, i_nb_items;
665
666     /* remove previous items */
667     i_nb_items = [o_menu numberOfItems];
668     for( i = 0; i < i_nb_items; i++ )
669     {
670         [o_menu removeItemAtIndex: 0];
671     }
672
673     /* Check the type of the object variable */
674     i_type = var_Type( p_object, psz_variable );
675
676     /* Make sure we want to display the variable */
677     if( i_type & VLC_VAR_HASCHOICE )
678     {
679         var_Change( p_object, psz_variable, VLC_VAR_CHOICESCOUNT, &val, NULL );
680         if( val.i_int == 0 ) return;
681         if( (i_type & VLC_VAR_TYPE) != VLC_VAR_VARIABLE && val.i_int == 1 )
682             return;
683     }
684     else
685     {
686         return;
687     }
688
689     switch( i_type & VLC_VAR_TYPE )
690     {
691     case VLC_VAR_VOID:
692     case VLC_VAR_BOOL:
693     case VLC_VAR_VARIABLE:
694     case VLC_VAR_STRING:
695     case VLC_VAR_INTEGER:
696         break;
697     default:
698         /* Variable doesn't exist or isn't handled */
699         return;
700     }
701
702     if( var_Get( p_object, psz_variable, &val ) < 0 )
703     {
704         return;
705     }
706
707     if( var_Change( p_object, psz_variable, VLC_VAR_GETLIST,
708                     &val_list, &text_list ) < 0 )
709     {
710         if( (i_type & VLC_VAR_TYPE) == VLC_VAR_STRING ) free( val.psz_string );
711         return;
712     }
713
714     /* make (un)sensitive */
715     [o_parent setEnabled: ( val_list.p_list->i_count > 1 )];
716
717     for( i = 0; i < val_list.p_list->i_count; i++ )
718     {
719         vlc_value_t another_val;
720         NSMenuItem * o_lmi;
721         NSString *o_title = @"";
722         VLCMenuExt *o_data;
723
724         switch( i_type & VLC_VAR_TYPE )
725         {
726         case VLC_VAR_STRING:
727             another_val.psz_string =
728                 strdup(val_list.p_list->p_values[i].psz_string);
729
730             o_title = [[VLCMain sharedInstance] localizedString: text_list.p_list->p_values[i].psz_string ?
731                 text_list.p_list->p_values[i].psz_string : val_list.p_list->p_values[i].psz_string ];
732
733             o_lmi = [o_menu addItemWithTitle: o_title action: pf_callback keyEquivalent: @""];
734             o_data = [[VLCMenuExt alloc] initWithVar: strdup(psz_variable) Object: p_object->i_object_id
735                     Value: another_val ofType: i_type];
736             [o_lmi setRepresentedObject: [NSValue valueWithPointer:[o_data retain]]];
737             [o_lmi setTarget: self];
738
739             if( !strcmp( val.psz_string, val_list.p_list->p_values[i].psz_string ) && !( i_type & VLC_VAR_ISCOMMAND ) )
740                 [o_lmi setState: TRUE ];
741
742             break;
743
744         case VLC_VAR_INTEGER:
745
746              o_title = text_list.p_list->p_values[i].psz_string ?
747                                  [[VLCMain sharedInstance] localizedString: strdup( text_list.p_list->p_values[i].psz_string )] :
748                                  [NSString stringWithFormat: @"%d",
749                                  val_list.p_list->p_values[i].i_int];
750
751             o_lmi = [[o_menu addItemWithTitle: o_title action: pf_callback keyEquivalent: @""] retain ];
752             o_data = [[VLCMenuExt alloc] initWithVar: strdup(psz_variable) Object: p_object->i_object_id
753                     Value: val_list.p_list->p_values[i] ofType: i_type];
754             [o_lmi setRepresentedObject: [NSValue valueWithPointer:[ o_data retain]]];
755             [o_lmi setTarget: self];
756
757             if( val_list.p_list->p_values[i].i_int == val.i_int && !( i_type & VLC_VAR_ISCOMMAND ) )
758                 [o_lmi setState: TRUE ];
759             break;
760
761         default:
762           break;
763         }
764     }
765
766     /* clean up everything */
767     if( (i_type & VLC_VAR_TYPE) == VLC_VAR_STRING ) free( val.psz_string );
768     var_Change( p_object, psz_variable, VLC_VAR_FREELIST, &val_list, &text_list );
769 }
770
771 - (IBAction)toggleVar:(id)sender
772 {
773     NSMenuItem *o_mi = (NSMenuItem *)sender;
774     VLCMenuExt *o_data = [[o_mi representedObject] pointerValue];
775     [NSThread detachNewThreadSelector: @selector(toggleVarThread:)
776         toTarget: self withObject: o_data];
777
778     return;
779 }
780
781 - (int)toggleVarThread: (id)_o_data
782 {
783     vlc_object_t *p_object;
784     NSAutoreleasePool * o_pool = [[NSAutoreleasePool alloc] init];
785     VLCMenuExt *o_data = (VLCMenuExt *)_o_data;
786
787     vlc_thread_set_priority( VLCIntf , VLC_THREAD_PRIORITY_LOW );
788
789     p_object = (vlc_object_t *)vlc_object_get( [o_data objectID] );
790
791     if( p_object != NULL )
792     {
793         var_Set( p_object, strdup([o_data name]), [o_data value] );
794         vlc_object_release( p_object );
795         [o_pool release];
796         return VLC_TRUE;
797     }
798     [o_pool release];
799     return VLC_EGENERIC;
800 }
801
802 - (IBAction)goToSpecificTime:(id)sender
803 {
804     if( sender == o_specificTime_cancel_btn )
805     {
806         [NSApp endSheet: o_specificTime_win];
807         [o_specificTime_win close];
808     }
809     else if( sender == o_specificTime_ok_btn )
810     {
811         input_thread_t * p_input = (input_thread_t *)vlc_object_find( VLCIntf, \
812             VLC_OBJECT_INPUT, FIND_ANYWHERE );
813         if( p_input )
814         {
815             unsigned int timeInSec = 0;
816             NSString * fieldContent = [o_specificTime_enter_fld stringValue];
817             if( [[fieldContent componentsSeparatedByString: @":"] count] > 1 &&
818                 [[fieldContent componentsSeparatedByString: @":"] count] <= 3 )
819             {
820                 NSArray * ourTempArray = \
821                     [fieldContent componentsSeparatedByString: @":"];
822
823                 if( [[fieldContent componentsSeparatedByString: @":"] count] == 3 )
824                 {
825                     timeInSec += ([[ourTempArray objectAtIndex: 0] intValue] * 3600); //h
826                     timeInSec += ([[ourTempArray objectAtIndex: 1] intValue] * 60); //m
827                     timeInSec += [[ourTempArray objectAtIndex: 2] intValue];        //s
828                 }
829                 else
830                 {
831                     timeInSec += ([[ourTempArray objectAtIndex: 0] intValue] * 60); //m
832                     timeInSec += [[ourTempArray objectAtIndex: 1] intValue]; //s
833                 }
834             }
835             else
836                 timeInSec = [fieldContent intValue];
837
838             input_Control( p_input, INPUT_SET_TIME, (int64_t)(timeInSec * 1000000));
839             vlc_object_release( p_input );
840         }
841  
842         [NSApp endSheet: o_specificTime_win];
843         [o_specificTime_win close];
844     }
845     else
846     {
847         input_thread_t * p_input = (input_thread_t *)vlc_object_find( VLCIntf, \
848             VLC_OBJECT_INPUT, FIND_ANYWHERE );
849         if( p_input )
850         {
851             /* we can obviously only do that if an input is available */
852             vlc_value_t pos, length;
853             var_Get( p_input, "time", &pos );
854             [o_specificTime_enter_fld setIntValue: (pos.i_time / 1000000)];
855             var_Get( p_input, "length", &length );
856             [o_specificTime_stepper setMaxValue: (length.i_time / 1000000)];
857
858             [NSApp beginSheet: o_specificTime_win modalForWindow: \
859                 [NSApp mainWindow] modalDelegate: self didEndSelector: nil \
860                 contextInfo: nil];
861             [o_specificTime_win makeKeyWindow];
862             vlc_object_release( p_input );
863         }
864     }
865 }
866
867 - (id)getFSPanel
868 {
869     if( o_fs_panel )
870         return o_fs_panel;
871     else
872     {
873         msg_Err( VLCIntf, "FSPanel is nil" );
874         return NULL;
875     }
876 }
877
878 @end
879
880 @implementation VLCControls (NSMenuValidation)
881
882 - (BOOL)validateMenuItem:(NSMenuItem *)o_mi
883 {
884     BOOL bEnabled = TRUE;
885     vlc_value_t val;
886     intf_thread_t * p_intf = VLCIntf;
887     playlist_t * p_playlist = pl_Yield( p_intf );
888
889     vlc_mutex_lock( &p_playlist->object_lock );
890
891 #define p_input p_playlist->p_input
892
893     if( [[o_mi title] isEqualToString: _NS("Faster")] ||
894         [[o_mi title] isEqualToString: _NS("Slower")] )
895     {
896         if( p_input != NULL )
897         {
898             bEnabled = p_input->b_can_pace_control;
899         }
900         else
901         {
902             bEnabled = FALSE;
903         }
904     }
905     else if( [[o_mi title] isEqualToString: _NS("Stop")] )
906     {
907         if( p_input == NULL )
908         {
909             bEnabled = FALSE;
910         }
911         [o_main setupMenus]; /* Make sure input menu is up to date */
912     }
913     else if( [[o_mi title] isEqualToString: _NS("Previous")] ||
914              [[o_mi title] isEqualToString: _NS("Next")] )
915     {
916         /** \todo fix i_size use */
917         bEnabled = p_playlist->items.i_size > 1;
918     }
919     else if( [[o_mi title] isEqualToString: _NS("Random")] )
920     {
921         int i_state;
922         var_Get( p_playlist, "random", &val );
923         i_state = val.b_bool ? NSOnState : NSOffState;
924         [o_mi setState: i_state];
925     }
926     else if( [[o_mi title] isEqualToString: _NS("Repeat One")] )
927     {
928         int i_state;
929         var_Get( p_playlist, "repeat", &val );
930         i_state = val.b_bool ? NSOnState : NSOffState;
931         [o_mi setState: i_state];
932     }
933     else if( [[o_mi title] isEqualToString: _NS("Repeat All")] )
934     {
935         int i_state;
936         var_Get( p_playlist, "loop", &val );
937         i_state = val.b_bool ? NSOnState : NSOffState;
938         [o_mi setState: i_state];
939     }
940     else if( [[o_mi title] isEqualToString: _NS("Step Forward")] ||
941              [[o_mi title] isEqualToString: _NS("Step Backward")] ||
942              [[o_mi title] isEqualToString: _NS("Jump To Time")])
943     {
944         if( p_input != NULL )
945         {
946             var_Get( p_input, "seekable", &val);
947             bEnabled = val.b_bool;
948         }
949         else bEnabled = FALSE;
950     }
951     else if( [[o_mi title] isEqualToString: _NS("Mute")] )
952     {
953         [o_mi setState: p_intf->p_sys->b_mute ? NSOnState : NSOffState];
954         [o_main setupMenus]; /* Make sure audio menu is up to date */
955     }
956     else if( [[o_mi title] isEqualToString: _NS("Half Size")] ||
957                 [[o_mi title] isEqualToString: _NS("Normal Size")] ||
958                 [[o_mi title] isEqualToString: _NS("Double Size")] ||
959                 [[o_mi title] isEqualToString: _NS("Fit to Screen")] ||
960                 [[o_mi title] isEqualToString: _NS("Snapshot")] ||
961                 [[o_mi title] isEqualToString: _NS("Fullscreen")] ||
962                 [[o_mi title] isEqualToString: _NS("Float on Top")] )
963     {
964         id o_window;
965         NSArray *o_windows = [NSApp orderedWindows];
966         NSEnumerator *o_enumerator = [o_windows objectEnumerator];
967         bEnabled = FALSE;
968  
969         vout_thread_t   *p_vout = vlc_object_find( p_intf, VLC_OBJECT_VOUT,
970                                               FIND_ANYWHERE );
971         if( p_vout != NULL )
972         {
973             if( [[o_mi title] isEqualToString: _NS("Float on Top")] )
974             {
975                 var_Get( p_vout, "video-on-top", &val );
976                 [o_mi setState: val.b_bool ?  NSOnState : NSOffState];
977             }
978
979             while( (o_window = [o_enumerator nextObject]))
980             {
981                 if( [[o_window className] isEqualToString: @"VLCVoutWindow"] ||
982                             [[[VLCMain sharedInstance] getEmbeddedList]
983                             windowContainsEmbedded: o_window])
984                 {
985                     bEnabled = TRUE;
986                     break;
987                 }
988             }
989             vlc_object_release( (vlc_object_t *)p_vout );
990         }
991         else if( [[o_mi title] isEqualToString: _NS("Fullscreen")] )
992         {
993             var_Get( p_playlist, "fullscreen", &val );
994             [o_mi setState: val.b_bool];
995             bEnabled = TRUE;
996         }
997         [o_main setupMenus]; /* Make sure video menu is up to date */
998     }
999
1000     vlc_mutex_unlock( &p_playlist->object_lock );
1001     vlc_object_release( p_playlist );
1002
1003     return( bEnabled );
1004 }
1005
1006 @end
1007
1008 /*****************************************************************************
1009  * VLCMenuExt implementation
1010  *****************************************************************************
1011  * Object connected to a playlistitem which remembers the data belonging to
1012  * the variable of the autogenerated menu
1013  *****************************************************************************/
1014 @implementation VLCMenuExt
1015
1016 - (id)initWithVar: (const char *)_psz_name Object: (int)i_id
1017         Value: (vlc_value_t)val ofType: (int)_i_type
1018 {
1019     self = [super init];
1020
1021     if( self != nil )
1022     {
1023         psz_name = strdup( _psz_name );
1024         i_object_id = i_id;
1025         value = val;
1026         i_type = _i_type;
1027     }
1028
1029     return( self );
1030 }
1031
1032 - (void)dealloc
1033 {
1034     free( psz_name );
1035     [super dealloc];
1036 }
1037
1038 - (char *)name
1039 {
1040     return psz_name;
1041 }
1042
1043 - (int)objectID
1044 {
1045     return i_object_id;
1046 }
1047
1048 - (vlc_value_t)value
1049 {
1050     return value;
1051 }
1052
1053 - (int)type
1054 {
1055     return i_type;
1056 }
1057
1058 @end
1059
1060
1061 /*****************************************************************************
1062  * VLCTimeField implementation
1063  *****************************************************************************
1064  * we need this to catch our click-event in the controller window
1065  *****************************************************************************/
1066
1067 @implementation VLCTimeField
1068 - (void)mouseDown: (NSEvent *)ourEvent
1069 {
1070     if( [ourEvent clickCount] > 1 )
1071         [[[VLCMain sharedInstance] getControls] goToSpecificTime: nil];
1072 }
1073 @end