d07ea81c83ed4d376f8cf1a3d030f43ae466e6c7
[vlc.git] / modules / gui / macosx / controls.m
1 /*****************************************************************************
2  * controls.m: MacOS X interface module
3  *****************************************************************************
4  * Copyright (C) 2002-2009 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 Paul 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 #pragma mark -
44 /*****************************************************************************
45  * VLCControls implementation
46  *****************************************************************************/
47 @implementation VLCControls
48
49 - (id)init
50 {
51     [super init];
52     o_fs_panel = [[VLCFSPanel alloc] init];
53     b_lockAspectRatio = YES;
54     return self;
55 }
56
57 - (void)awakeFromNib
58 {
59     [o_specificTime_mi setTitle: _NS("Jump To Time")];
60     [o_specificTime_cancel_btn setTitle: _NS("Cancel")];
61     [o_specificTime_ok_btn setTitle: _NS("OK")];
62     [o_specificTime_sec_lbl setStringValue: _NS("sec.")];
63     [o_specificTime_goTo_lbl setStringValue: _NS("Jump to time")];
64
65     o_repeat_off = [NSImage imageNamed:@"repeat_embedded"];
66
67     [self controlTintChanged];
68
69     [[NSNotificationCenter defaultCenter] addObserver: self
70                                              selector: @selector( controlTintChanged )
71                                                  name: NSControlTintDidChangeNotification
72                                                object: nil];
73 }
74
75 - (void)controlTintChanged
76 {
77     int i_repeat = 0;
78     if( [o_btn_repeat image] == o_repeat_single )
79         i_repeat = 1;
80     else if( [o_btn_repeat image] == o_repeat_all )
81         i_repeat = 2;
82
83     if( [NSColor currentControlTint] == NSGraphiteControlTint )
84     {
85         o_repeat_single = [NSImage imageNamed:@"repeat_single_embedded_graphite"];
86         o_repeat_all = [NSImage imageNamed:@"repeat_embedded_graphite"];
87         
88         [o_btn_shuffle setAlternateImage: [NSImage imageNamed: @"shuffle_embedded_graphite"]];
89         [o_btn_addNode setAlternateImage: [NSImage imageNamed: @"add_embedded_graphite"]];
90     }
91     else
92     {
93         o_repeat_single = [NSImage imageNamed:@"repeat_single_embedded_blue"];
94         o_repeat_all = [NSImage imageNamed:@"repeat_embedded_blue"];
95         
96         [o_btn_shuffle setAlternateImage: [NSImage imageNamed: @"shuffle_embedded_blue"]];
97         [o_btn_addNode setAlternateImage: [NSImage imageNamed: @"add_embedded_blue"]];
98     }
99     
100     /* update the repeat button, but keep its state */
101     if( i_repeat == 1 )
102         [self repeatOne];
103     else if( i_repeat == 2 )
104         [self repeatAll];
105     else
106         [self repeatOff];
107 }
108
109 - (void)dealloc
110 {
111     [[NSNotificationCenter defaultCenter] removeObserver: self];
112     
113     [o_fs_panel release];
114     [o_repeat_single release];
115     [o_repeat_all release];
116     [o_repeat_off release];
117     
118     [super dealloc];
119 }
120
121 - (IBAction)play:(id)sender
122 {
123     intf_thread_t * p_intf = VLCIntf;
124     playlist_t * p_playlist = pl_Hold( p_intf );
125     bool empty;
126
127     PL_LOCK;
128     empty = playlist_IsEmpty( p_playlist );
129     PL_UNLOCK;
130
131     pl_Release( p_intf );
132
133     if( empty )
134         [o_main intfOpenFileGeneric: (id)sender];
135
136     var_SetInteger( p_intf->p_libvlc, "key-action", ACTIONID_PLAY_PAUSE );
137 }
138
139 - (id)voutView
140 {
141     id o_window;
142     id o_voutView = nil;
143     id o_embeddedViewList = [[VLCMain sharedInstance] embeddedList];
144     NSEnumerator *o_enumerator = [[NSApp orderedWindows] objectEnumerator];
145     while( !o_voutView && ( o_window = [o_enumerator nextObject] ) )
146     {
147         /* We have an embedded vout */
148         if( [o_embeddedViewList windowContainsEmbedded: o_window] )
149         {
150             o_voutView = [o_embeddedViewList viewForWindow: o_window];
151         }
152         /* We have a detached vout */
153         else if( [[o_window className] isEqualToString: @"VLCVoutWindow"] )
154         {
155             o_voutView = [o_window voutView];
156         }
157     }
158     return [[o_voutView retain] autorelease];
159 }
160
161 - (BOOL)aspectRatioIsLocked
162 {
163     return b_lockAspectRatio;
164 }
165
166 - (IBAction)stop:(id)sender
167 {
168     intf_thread_t * p_intf = VLCIntf;
169     var_SetInteger( p_intf->p_libvlc, "key-action", ACTIONID_STOP );
170     /* Close the window directly, because we do know that there
171      * won't be anymore video. It's currently waiting a bit. */
172     [[[self voutView] window] orderOut:self];
173 }
174
175 - (IBAction)faster:(id)sender
176 {
177     intf_thread_t * p_intf = VLCIntf;
178     var_SetInteger( p_intf->p_libvlc, "key-action", ACTIONID_FASTER );
179 }
180
181 - (IBAction)slower:(id)sender
182 {
183     intf_thread_t * p_intf = VLCIntf;
184     var_SetInteger( p_intf->p_libvlc, "key-action", ACTIONID_SLOWER );
185 }
186
187 - (IBAction)prev:(id)sender
188 {
189     intf_thread_t * p_intf = VLCIntf;
190     var_SetInteger( p_intf->p_libvlc, "key-action", ACTIONID_PREV );
191 }
192
193 - (IBAction)next:(id)sender
194 {
195     intf_thread_t * p_intf = VLCIntf;
196     var_SetInteger( p_intf->p_libvlc, "key-action", ACTIONID_NEXT );
197 }
198
199 - (IBAction)random:(id)sender
200 {
201     vlc_value_t val;
202     intf_thread_t * p_intf = VLCIntf;
203     playlist_t * p_playlist = pl_Hold( p_intf );
204
205     var_Get( p_playlist, "random", &val );
206     val.b_bool = !val.b_bool;
207     var_Set( p_playlist, "random", val );
208     if( val.b_bool )
209     {
210         vout_OSDMessage( p_intf, DEFAULT_CHAN, _( "Random On" ) );
211         config_PutInt( p_playlist, "random", 1 );
212     }
213     else
214     {
215         vout_OSDMessage( p_intf, DEFAULT_CHAN, _( "Random Off" ) );
216         config_PutInt( p_playlist, "random", 0 );
217     }
218
219     p_intf->p_sys->b_playmode_update = true;
220     p_intf->p_sys->b_intf_update = true;
221     pl_Release( p_intf );
222 }
223
224 /* three little ugly helpers */
225 - (void)repeatOne
226 {
227     [o_btn_repeat setImage: o_repeat_single];
228     [o_btn_repeat setAlternateImage: o_repeat_all];
229     [o_btn_repeat_embed setImage: [NSImage imageNamed:@"sidebarRepeatOneOn"]];
230 }
231 - (void)repeatAll
232 {
233     [o_btn_repeat setImage: o_repeat_all];
234     [o_btn_repeat setAlternateImage: o_repeat_off];
235     [o_btn_repeat_embed setImage: [NSImage imageNamed:@"sidebarRepeatOn"]];
236 }
237 - (void)repeatOff
238 {
239     [o_btn_repeat setImage: o_repeat_off];
240     [o_btn_repeat setAlternateImage: o_repeat_single];
241     [o_btn_repeat_embed setImage: [NSImage imageNamed:@"sidebarRepeat"]];
242 }
243 - (void)shuffle
244 {
245     vlc_value_t val;
246     playlist_t *p_playlist = pl_Hold( VLCIntf );
247     var_Get( p_playlist, "random", &val );
248     [o_btn_shuffle setState: val.b_bool];
249         if(val.b_bool)
250         [o_btn_shuffle_embed setImage: [NSImage imageNamed:@"sidebarShuffleOn"]];
251         else
252         [o_btn_shuffle_embed setImage: [NSImage imageNamed:@"sidebarShuffle"]];    
253     pl_Release( VLCIntf );
254 }
255
256 - (IBAction)repeatButtonAction:(id)sender
257 {
258     vlc_value_t looping,repeating;
259     intf_thread_t * p_intf = VLCIntf;
260     playlist_t * p_playlist = pl_Hold( p_intf );
261
262     var_Get( p_playlist, "repeat", &repeating );
263     var_Get( p_playlist, "loop", &looping );
264
265     if( !repeating.b_bool && !looping.b_bool )
266     {
267         /* was: no repeating at all, switching to Repeat One */
268  
269         /* set our button's look */
270         [self repeatOne];
271  
272         /* prepare core communication */
273         repeating.b_bool = true;
274         looping.b_bool = false;
275         config_PutInt( p_playlist, "repeat", 1 );
276         config_PutInt( p_playlist, "loop", 0 );
277  
278         /* show the change */
279         vout_OSDMessage( p_intf, DEFAULT_CHAN, _( "Repeat One" ) );
280     }
281     else if( repeating.b_bool && !looping.b_bool )
282     {
283         /* was: Repeat One, switching to Repeat All */
284  
285         /* set our button's look */
286         [self repeatAll];
287  
288         /* prepare core communication */
289         repeating.b_bool = false;
290         looping.b_bool = true;
291         config_PutInt( p_playlist, "repeat", 0 );
292         config_PutInt( p_playlist, "loop", 1 );
293  
294         /* show the change */
295         vout_OSDMessage( p_intf, DEFAULT_CHAN, _( "Repeat All" ) );
296     }
297     else
298     {
299         /* was: Repeat All or bug in VLC, switching to Repeat Off */
300  
301         /* set our button's look */
302         [self repeatOff];
303  
304         /* prepare core communication */
305         repeating.b_bool = false;
306         looping.b_bool = false;
307         config_PutInt( p_playlist, "repeat", 0 );
308         config_PutInt( p_playlist, "loop", 0 );
309  
310         /* show the change */
311         vout_OSDMessage( p_intf, DEFAULT_CHAN, _( "Repeat Off" ) );
312     }
313
314     /* communicate with core and the main intf loop */
315     var_Set( p_playlist, "repeat", repeating );
316     var_Set( p_playlist, "loop", looping );
317     p_intf->p_sys->b_playmode_update = true;
318     p_intf->p_sys->b_intf_update = true;
319
320     pl_Release( p_intf );
321 }
322
323
324 - (IBAction)repeat:(id)sender
325 {
326     vlc_value_t val;
327     intf_thread_t * p_intf = VLCIntf;
328     playlist_t * p_playlist = pl_Hold( p_intf );
329
330     var_Get( p_playlist, "repeat", &val );
331     if (!val.b_bool)
332     {
333         var_Set( p_playlist, "loop", val );
334     }
335     val.b_bool = !val.b_bool;
336     var_Set( p_playlist, "repeat", val );
337     if( val.b_bool )
338     {
339         vout_OSDMessage( p_intf, DEFAULT_CHAN, _( "Repeat One" ) );
340         config_PutInt( p_playlist, "repeat", 1 );
341     }
342     else
343     {
344         vout_OSDMessage( p_intf, DEFAULT_CHAN, _( "Repeat Off" ) );
345         config_PutInt( p_playlist, "repeat", 0 );
346     }
347  
348     p_intf->p_sys->b_playmode_update = true;
349     p_intf->p_sys->b_intf_update = true;
350     pl_Release( p_intf );
351 }
352
353 - (IBAction)loop:(id)sender
354 {
355     vlc_value_t val;
356     intf_thread_t * p_intf = VLCIntf;
357     playlist_t * p_playlist = pl_Hold( p_intf );
358
359     var_Get( p_playlist, "loop", &val );
360     if (!val.b_bool)
361     {
362         var_Set( p_playlist, "repeat", val );
363     }
364     val.b_bool = !val.b_bool;
365     var_Set( p_playlist, "loop", val );
366     if( val.b_bool )
367     {
368         vout_OSDMessage( p_intf, DEFAULT_CHAN, _( "Repeat All" ) );
369         config_PutInt( p_playlist, "loop", 1 );
370     }
371     else
372     {
373         vout_OSDMessage( p_intf, DEFAULT_CHAN, _( "Repeat Off" ) );
374         config_PutInt( p_playlist, "loop", 0 );
375     }
376
377     p_intf->p_sys->b_playmode_update = true;
378     p_intf->p_sys->b_intf_update = true;
379     pl_Release( p_intf );
380 }
381
382 - (IBAction)forward:(id)sender
383 {
384     intf_thread_t * p_intf = VLCIntf;
385     var_SetInteger( p_intf->p_libvlc, "key-action", ACTIONID_JUMP_FORWARD_SHORT );
386 }
387
388 - (IBAction)backward:(id)sender
389 {
390     vlc_value_t val;
391     intf_thread_t * p_intf = VLCIntf;
392     var_SetInteger( p_intf->p_libvlc, "key-action", ACTIONID_JUMP_BACKWARD_SHORT );
393 }
394
395
396 - (IBAction)volumeUp:(id)sender
397 {
398     intf_thread_t * p_intf = VLCIntf;
399     var_SetInteger( p_intf->p_libvlc, "key-action", ACTIONID_VOL_UP );
400     /* Manage volume status */
401     [o_main manageVolumeSlider];
402 }
403
404 - (IBAction)volumeDown:(id)sender
405 {
406     intf_thread_t * p_intf = VLCIntf;
407     var_SetInteger( p_intf->p_libvlc, "key-action", ACTIONID_VOL_DOWN );
408     /* Manage volume status */
409     [o_main manageVolumeSlider];
410 }
411
412 - (IBAction)mute:(id)sender
413 {
414     intf_thread_t * p_intf = VLCIntf;
415     var_SetInteger( p_intf->p_libvlc, "key-action", ACTIONID_VOL_MUTE );
416     /* Manage volume status */
417     [o_main manageVolumeSlider];
418 }
419
420 - (IBAction)volumeSliderUpdated:(id)sender
421 {
422     intf_thread_t * p_intf = VLCIntf;
423     playlist_t * p_playlist = pl_Hold( p_intf );
424     audio_volume_t i_volume = (audio_volume_t)[sender intValue];
425     int i_volume_step;
426
427     i_volume_step = config_GetInt( p_intf->p_libvlc, "volume-step" );
428     aout_VolumeSet( p_playlist, i_volume * i_volume_step );
429     pl_Release( p_playlist );
430     /* Manage volume status */
431     [o_main manageVolumeSlider];
432 }
433
434 - (IBAction)showPosition: (id)sender
435 {
436     input_thread_t * p_input = pl_CurrentInput( VLCIntf );
437     if( p_input != NULL )
438     {
439         vout_thread_t *p_vout = input_GetVout( p_input );
440         if( p_vout != NULL )
441         {
442             var_SetInteger( VLCIntf->p_libvlc, "key-action", ACTIONID_POSITION );
443             vlc_object_release( (vlc_object_t *)p_vout );
444         }
445         vlc_object_release( p_input );
446     }
447 }
448
449 - (IBAction)toogleFullscreen:(id)sender {
450     NSMenuItem *o_mi = [[NSMenuItem alloc] initWithTitle: _NS("Fullscreen") action: nil keyEquivalent:@""];
451     [self windowAction: [o_mi autorelease]];
452 }
453
454 - (BOOL) isFullscreen {
455     id o_vout_view = [self voutView];
456     if( o_vout_view )
457     {
458         return [o_vout_view isFullscreen];
459     }
460     return NO;
461 }
462
463 - (IBAction)windowAction:(id)sender
464 {
465     NSString *o_title = [sender title];
466     input_thread_t * p_input = pl_CurrentInput( VLCIntf );
467
468     if( p_input != NULL )
469     {
470         vout_thread_t *p_vout = input_GetVout( p_input );
471         if( p_vout != NULL )
472         {
473             id o_vout_view = [self voutView];
474             if( o_vout_view )
475             {
476                 if( [o_title isEqualToString: _NS("Half Size") ] )
477                     [o_vout_view scaleWindowWithFactor: 0.5 animate: YES];
478                 else if( [o_title isEqualToString: _NS("Normal Size") ] )
479                     [o_vout_view scaleWindowWithFactor: 1.0 animate: YES];
480                 else if( [o_title isEqualToString: _NS("Double Size") ] )
481                     [o_vout_view scaleWindowWithFactor: 2.0 animate: YES];
482                 else if( [o_title isEqualToString: _NS("Float on Top") ] )
483                     [o_vout_view toggleFloatOnTop];
484                 else if( [o_title isEqualToString: _NS("Fit to Screen") ] )
485                 {
486                     id o_window = [o_vout_view voutWindow];
487                     if( ![o_window isZoomed] )
488                         [o_window performZoom:self];
489                 }
490                 else if( [o_title isEqualToString: _NS("Snapshot") ] )
491                 {
492                     [o_vout_view snapshot];
493                 }
494                 else
495                 {
496                     /* Fullscreen state for next time will be saved here too */
497                     [o_vout_view toggleFullscreen];
498                 }
499             }
500             vlc_object_release( (vlc_object_t *)p_vout );
501         }
502         else
503         {
504             playlist_t * p_playlist = pl_Hold( VLCIntf );
505
506             if( [o_title isEqualToString: _NS("Fullscreen")] ||
507                 [sender isKindOfClass:[NSButton class]] )
508             {
509                 vlc_value_t val;
510                 var_Get( p_playlist, "fullscreen", &val );
511                 var_Set( p_playlist, "fullscreen", (vlc_value_t)!val.b_bool );
512             }
513
514             pl_Release( VLCIntf );
515         }
516         vlc_object_release( p_input );
517     }
518 }
519
520 - (IBAction)telxTransparent:(id)sender
521 {
522     intf_thread_t * p_intf = VLCIntf;
523     vlc_object_t *p_vbi;
524     p_vbi = (vlc_object_t *) vlc_object_find_name( p_intf,
525                     "zvbi", FIND_ANYWHERE );
526     if( p_vbi )
527     {
528         var_SetBool( p_vbi, "vbi-opaque", [sender state] );
529         [sender setState: ![sender state]];
530         vlc_object_release( p_vbi );
531     }
532 }
533
534 - (IBAction)telxNavLink:(id)sender
535 {
536     intf_thread_t * p_intf = VLCIntf;
537     vlc_object_t *p_vbi;
538     int i_page = 0;
539
540     if( [[sender title] isEqualToString: _NS("Index")] )
541         i_page = 'i' << 16;
542     else if( [[sender title] isEqualToString: _NS("Red")] )
543         i_page = 'r' << 16;
544     else if( [[sender title] isEqualToString: _NS("Green")] )
545         i_page = 'g' << 16;
546     else if( [[sender title] isEqualToString: _NS("Yellow")] )
547         i_page = 'y' << 16;
548     else if( [[sender title] isEqualToString: _NS("Blue")] )
549         i_page = 'b' << 16;
550     if( i_page == 0 ) return;
551
552     p_vbi = (vlc_object_t *) vlc_object_find_name( p_intf,
553                 "zvbi", FIND_ANYWHERE );
554     if( p_vbi )
555     {
556         var_SetInteger( p_vbi, "vbi-page", i_page );
557         vlc_object_release( p_vbi );
558     }
559 }
560
561 - (IBAction)lockVideosAspectRatio:(id)sender
562 {
563     if( [sender state] == NSOffState )
564         [sender setState: NSOnState];
565     else
566         [sender setState: NSOffState];
567
568     b_lockAspectRatio = !b_lockAspectRatio;
569 }
570
571 - (IBAction)addSubtitleFile:(id)sender
572 {
573     NSInteger i_returnValue = 0;
574     input_thread_t * p_input = pl_CurrentInput( VLCIntf );
575     if( !p_input ) return;
576
577     input_item_t *p_item = input_GetItem( p_input );
578     if( !p_item ) return;
579
580     char *path = input_item_GetURI( p_item );
581     if( !path ) path = strdup( "" );
582
583     NSOpenPanel * openPanel = [NSOpenPanel openPanel];
584     [openPanel setCanChooseFiles: YES];
585     [openPanel setCanChooseDirectories: NO];
586     [openPanel setAllowsMultipleSelection: YES];
587     i_returnValue = [openPanel runModalForDirectory: [NSString stringWithUTF8String: path] file: nil types: [NSArray arrayWithObjects: @"cdg",@"@idx",@"srt",@"sub",@"utf",@"ass",@"ssa",@"aqt",@"jss",@"psb",@"rt",@"smi", nil]];
588     free( path );
589
590     if( i_returnValue == NSOKButton )
591     {
592         NSUInteger c = 0;
593         if( !p_input ) return;
594         
595         c = [[openPanel filenames] count];
596
597         for (int i = 0; i < [[openPanel filenames] count] ; i++)
598         {
599             msg_Dbg( VLCIntf, "loading subs from %s", [[[openPanel filenames] objectAtIndex: i] UTF8String] );
600             if( input_AddSubtitle( p_input, [[[openPanel filenames] objectAtIndex: i] UTF8String], TRUE ) )
601                 msg_Warn( VLCIntf, "unable to load subtitles from '%s'",
602                          [[[openPanel filenames] objectAtIndex: i] UTF8String] );
603         }
604     }
605 }
606
607 - (void)scrollWheel:(NSEvent *)theEvent
608 {
609     intf_thread_t * p_intf = VLCIntf;
610     float f_yabsvalue = [theEvent deltaY] > 0.0f ? [theEvent deltaY] : -[theEvent deltaY];
611     float f_xabsvalue = [theEvent deltaX] > 0.0f ? [theEvent deltaX] : -[theEvent deltaX];
612     int i, i_yvlckey, i_xvlckey;
613
614     if ([theEvent deltaY] < 0.0f)
615         i_yvlckey = KEY_MOUSEWHEELDOWN;
616     else
617         i_yvlckey = KEY_MOUSEWHEELUP;
618
619     if ([theEvent deltaX] < 0.0f)
620         i_xvlckey = KEY_MOUSEWHEELRIGHT;
621     else
622         i_xvlckey = KEY_MOUSEWHEELLEFT;
623
624     /* Send multiple key event, depending on the intensity of the event */
625     for (i = 0; i < (int)(f_yabsvalue/4.+1.) && f_yabsvalue > 0.05 ; i++)
626         var_SetInteger( p_intf->p_libvlc, "key-pressed", i_yvlckey );
627
628     /* Prioritize Y event (sound volume) over X event */
629     if (f_yabsvalue < 0.05)
630     {
631         for (i = 0; i < (int)(f_xabsvalue/6.+1.) && f_xabsvalue > 0.05; i++)
632          var_SetInteger( p_intf->p_libvlc, "key-pressed", i_xvlckey );
633     }
634 }
635
636 - (BOOL)keyEvent:(NSEvent *)o_event
637 {
638     BOOL eventHandled = NO;
639     unichar key = [[o_event charactersIgnoringModifiers] characterAtIndex: 0];
640
641     if( key )
642     {
643         input_thread_t * p_input = pl_CurrentInput( VLCIntf );
644         if( p_input != NULL )
645         {
646             vout_thread_t *p_vout = input_GetVout( p_input );
647
648             if( p_vout != NULL )
649             {
650                 /* Escape */
651                 if( key == (unichar) 0x1b )
652                 {
653                     id o_vout_view = [self voutView];
654                     if( o_vout_view && [o_vout_view isFullscreen] )
655                     {
656                         [o_vout_view toggleFullscreen];
657                         eventHandled = YES;
658                     }
659                 }
660                 else if( key == ' ' )
661                 {
662                     [self play:self];
663                     eventHandled = YES;
664                 }
665                 vlc_object_release( (vlc_object_t *)p_vout );
666             }
667             vlc_object_release( p_input );
668         }
669     }
670     return eventHandled;
671 }
672
673 - (void)setupVarMenuItem:(NSMenuItem *)o_mi
674                     target:(vlc_object_t *)p_object
675                     var:(const char *)psz_variable
676                     selector:(SEL)pf_callback
677 {
678     vlc_value_t val, text;
679     int i_type = var_Type( p_object, psz_variable );
680
681     switch( i_type & VLC_VAR_TYPE )
682     {
683     case VLC_VAR_VOID:
684     case VLC_VAR_BOOL:
685     case VLC_VAR_VARIABLE:
686     case VLC_VAR_STRING:
687     case VLC_VAR_INTEGER:
688         break;
689     default:
690         /* Variable doesn't exist or isn't handled */
691         return;
692     }
693  
694     /* Make sure we want to display the variable */
695     if( i_type & VLC_VAR_HASCHOICE )
696     {
697         var_Change( p_object, psz_variable, VLC_VAR_CHOICESCOUNT, &val, NULL );
698         if( val.i_int == 0 ) return;
699         if( (i_type & VLC_VAR_TYPE) != VLC_VAR_VARIABLE && val.i_int == 1 )
700             return;
701     }
702  
703     /* Get the descriptive name of the variable */
704     var_Change( p_object, psz_variable, VLC_VAR_GETTEXT, &text, NULL );
705     [o_mi setTitle: [[VLCMain sharedInstance] localizedString: text.psz_string ?
706                                         text.psz_string : psz_variable ]];
707
708     if( i_type & VLC_VAR_HASCHOICE )
709     {
710         NSMenu *o_menu = [o_mi submenu];
711
712         [self setupVarMenu: o_menu forMenuItem: o_mi target:p_object
713                         var:psz_variable selector:pf_callback];
714  
715         free( text.psz_string );
716         return;
717     }
718     if( var_Get( p_object, psz_variable, &val ) < 0 )
719     {
720         return;
721     }
722
723     VLCAutoGeneratedMenuContent *o_data;
724     switch( i_type & VLC_VAR_TYPE )
725     {
726     case VLC_VAR_VOID:
727         o_data = [[VLCAutoGeneratedMenuContent alloc] initWithVariableName: psz_variable ofObject: p_object
728                 andValue: val ofType: i_type];
729         [o_mi setRepresentedObject: [o_data autorelease]];
730         break;
731
732     case VLC_VAR_BOOL:
733         o_data = [[VLCAutoGeneratedMenuContent alloc] initWithVariableName: psz_variable ofObject: p_object
734                 andValue: val ofType: i_type];
735         [o_mi setRepresentedObject: [o_data autorelease]];
736         if( !( i_type & VLC_VAR_ISCOMMAND ) )
737             [o_mi setState: val.b_bool ? TRUE : FALSE ];
738         break;
739
740     default:
741         break;
742     }
743
744     if( ( i_type & VLC_VAR_TYPE ) == VLC_VAR_STRING ) free( val.psz_string );
745     free( text.psz_string );
746 }
747
748
749 - (void)setupVarMenu:(NSMenu *)o_menu
750                     forMenuItem: (NSMenuItem *)o_parent
751                     target:(vlc_object_t *)p_object
752                     var:(const char *)psz_variable
753                     selector:(SEL)pf_callback
754 {
755     vlc_value_t val, val_list, text_list;
756     int i_type, i, i_nb_items;
757
758     /* remove previous items */
759     i_nb_items = [o_menu numberOfItems];
760     for( i = 0; i < i_nb_items; i++ )
761     {
762         [o_menu removeItemAtIndex: 0];
763     }
764
765     /* Check the type of the object variable */
766     i_type = var_Type( p_object, psz_variable );
767
768     /* Make sure we want to display the variable */
769     if( i_type & VLC_VAR_HASCHOICE )
770     {
771         var_Change( p_object, psz_variable, VLC_VAR_CHOICESCOUNT, &val, NULL );
772         if( val.i_int == 0 ) return;
773         if( (i_type & VLC_VAR_TYPE) != VLC_VAR_VARIABLE && val.i_int == 1 )
774             return;
775     }
776     else
777     {
778         return;
779     }
780
781     switch( i_type & VLC_VAR_TYPE )
782     {
783     case VLC_VAR_VOID:
784     case VLC_VAR_BOOL:
785     case VLC_VAR_VARIABLE:
786     case VLC_VAR_STRING:
787     case VLC_VAR_INTEGER:
788         break;
789     default:
790         /* Variable doesn't exist or isn't handled */
791         return;
792     }
793
794     if( var_Get( p_object, psz_variable, &val ) < 0 )
795     {
796         return;
797     }
798
799     if( var_Change( p_object, psz_variable, VLC_VAR_GETLIST,
800                     &val_list, &text_list ) < 0 )
801     {
802         if( (i_type & VLC_VAR_TYPE) == VLC_VAR_STRING ) free( val.psz_string );
803         return;
804     }
805
806     /* make (un)sensitive */
807     [o_parent setEnabled: ( val_list.p_list->i_count > 1 )];
808
809     /* Aspect Ratio */
810     if( [[o_parent title] isEqualToString: _NS("Aspect-ratio")] == YES )
811     {
812         NSMenuItem *o_lmi_tmp2;
813         o_lmi_tmp2 = [o_menu addItemWithTitle: _NS("Lock Aspect Ratio") action: @selector(lockVideosAspectRatio:) keyEquivalent: @""];
814         [o_lmi_tmp2 setTarget: self];
815         [o_lmi_tmp2 setEnabled: YES];
816         [o_lmi_tmp2 setState: b_lockAspectRatio];
817         [o_parent setEnabled: YES];
818         [o_menu addItem: [NSMenuItem separatorItem]];
819     }
820
821     /* special case for the subtitles items */
822     if( [[o_parent title] isEqualToString: _NS("Subtitles Track")] == YES )
823     {
824         NSMenuItem * o_lmi_tmp;
825         o_lmi_tmp = [o_menu addItemWithTitle: _NS("Open File...") action: @selector(addSubtitleFile:) keyEquivalent: @""];
826         [o_lmi_tmp setTarget: self];
827         [o_lmi_tmp setEnabled: YES];
828         [o_parent setEnabled: YES];
829         [o_menu addItem: [NSMenuItem separatorItem]];
830     }
831
832     for( i = 0; i < val_list.p_list->i_count; i++ )
833     {
834         NSMenuItem * o_lmi;
835         NSString *o_title = @"";
836         VLCAutoGeneratedMenuContent *o_data;
837
838         switch( i_type & VLC_VAR_TYPE )
839         {
840         case VLC_VAR_STRING:
841
842             o_title = [[VLCMain sharedInstance] localizedString: text_list.p_list->p_values[i].psz_string ?
843                 text_list.p_list->p_values[i].psz_string : val_list.p_list->p_values[i].psz_string ];
844
845             o_lmi = [o_menu addItemWithTitle: o_title action: pf_callback keyEquivalent: @""];
846             o_data = [[VLCAutoGeneratedMenuContent alloc] initWithVariableName: psz_variable ofObject: p_object
847                     andValue: val_list.p_list->p_values[i] ofType: i_type];
848             [o_lmi setRepresentedObject: [o_data autorelease]];
849             [o_lmi setTarget: self];
850
851             if( !strcmp( val.psz_string, val_list.p_list->p_values[i].psz_string ) && !( i_type & VLC_VAR_ISCOMMAND ) )
852                 [o_lmi setState: TRUE ];
853
854             break;
855
856         case VLC_VAR_INTEGER:
857
858              o_title = text_list.p_list->p_values[i].psz_string ?
859                                  [[VLCMain sharedInstance] localizedString: text_list.p_list->p_values[i].psz_string] :
860                                  [NSString stringWithFormat: @"%d",
861                                  val_list.p_list->p_values[i].i_int];
862
863             o_lmi = [o_menu addItemWithTitle: o_title action: pf_callback keyEquivalent: @""];
864             o_data = [[VLCAutoGeneratedMenuContent alloc] initWithVariableName: psz_variable ofObject: p_object
865                     andValue: val_list.p_list->p_values[i] ofType: i_type];
866             [o_lmi setRepresentedObject: [o_data autorelease]];
867             [o_lmi setTarget: self];
868
869             if( val_list.p_list->p_values[i].i_int == val.i_int && !( i_type & VLC_VAR_ISCOMMAND ) )
870                 [o_lmi setState: TRUE ];
871             break;
872
873         default:
874           break;
875         }
876     }
877
878     /* special case for the subtitles sub-menu
879      * In case that we don't have any subs, we don't want a separator item at the end */
880     if( [[o_parent title] isEqualToString: _NS("Subtitles Track")] == YES )
881     {
882         if( [o_menu numberOfItems] == 2 )
883             [o_menu removeItemAtIndex: 1];
884     }
885
886     /* clean up everything */
887     if( (i_type & VLC_VAR_TYPE) == VLC_VAR_STRING ) free( val.psz_string );
888     var_FreeList( &val_list, &text_list );
889 }
890
891 - (IBAction)toggleVar:(id)sender
892 {
893     NSMenuItem *o_mi = (NSMenuItem *)sender;
894     VLCAutoGeneratedMenuContent *o_data = [o_mi representedObject];
895     [NSThread detachNewThreadSelector: @selector(toggleVarThread:)
896         toTarget: self withObject: o_data];
897
898     return;
899 }
900
901 - (int)toggleVarThread: (id)data
902 {
903     vlc_object_t *p_object;
904     NSAutoreleasePool * o_pool = [[NSAutoreleasePool alloc] init];
905
906     assert([data isKindOfClass:[VLCAutoGeneratedMenuContent class]]);
907     VLCAutoGeneratedMenuContent *menuContent = (VLCAutoGeneratedMenuContent *)data;
908
909     vlc_thread_set_priority( VLCIntf , VLC_THREAD_PRIORITY_LOW );
910
911     p_object = [menuContent vlcObject];
912
913     if( p_object != NULL )
914     {
915         var_Set( p_object, [menuContent name], [menuContent value] );
916         vlc_object_release( p_object );
917         [o_pool release];
918         return true;
919     }
920     [o_pool release];
921     return VLC_EGENERIC;
922 }
923
924 - (IBAction)goToSpecificTime:(id)sender
925 {
926     if( sender == o_specificTime_cancel_btn )
927     {
928         [NSApp endSheet: o_specificTime_win];
929         [o_specificTime_win close];
930     }
931     else if( sender == o_specificTime_ok_btn )
932     {
933         input_thread_t * p_input = pl_CurrentInput( VLCIntf );
934         if( p_input )
935         {
936             unsigned int timeInSec = 0;
937             NSString * fieldContent = [o_specificTime_enter_fld stringValue];
938             if( [[fieldContent componentsSeparatedByString: @":"] count] > 1 &&
939                 [[fieldContent componentsSeparatedByString: @":"] count] <= 3 )
940             {
941                 NSArray * ourTempArray = \
942                     [fieldContent componentsSeparatedByString: @":"];
943
944                 if( [[fieldContent componentsSeparatedByString: @":"] count] == 3 )
945                 {
946                     timeInSec += ([[ourTempArray objectAtIndex: 0] intValue] * 3600); //h
947                     timeInSec += ([[ourTempArray objectAtIndex: 1] intValue] * 60); //m
948                     timeInSec += [[ourTempArray objectAtIndex: 2] intValue];        //s
949                 }
950                 else
951                 {
952                     timeInSec += ([[ourTempArray objectAtIndex: 0] intValue] * 60); //m
953                     timeInSec += [[ourTempArray objectAtIndex: 1] intValue]; //s
954                 }
955             }
956             else
957                 timeInSec = [fieldContent intValue];
958
959             input_Control( p_input, INPUT_SET_TIME, (int64_t)(timeInSec * 1000000));
960             vlc_object_release( p_input );
961         }
962
963         [NSApp endSheet: o_specificTime_win];
964         [o_specificTime_win close];
965     }
966     else
967     {
968         input_thread_t * p_input = pl_CurrentInput( VLCIntf );
969         if( p_input )
970         {
971             /* we can obviously only do that if an input is available */
972             vlc_value_t pos, length;
973             var_Get( p_input, "time", &pos );
974             [o_specificTime_enter_fld setIntValue: (pos.i_time / 1000000)];
975             var_Get( p_input, "length", &length );
976             [o_specificTime_stepper setMaxValue: (length.i_time / 1000000)];
977
978             [NSApp beginSheet: o_specificTime_win modalForWindow: \
979                 [NSApp mainWindow] modalDelegate: self didEndSelector: nil \
980                 contextInfo: nil];
981             [o_specificTime_win makeKeyWindow];
982             vlc_object_release( p_input );
983         }
984     }
985 }
986
987 - (id)fspanel
988 {
989     if( o_fs_panel )
990         return o_fs_panel;
991     else
992     {
993         msg_Err( VLCIntf, "FSPanel is nil" );
994         return NULL;
995     }
996 }
997
998 @end
999
1000 @implementation VLCControls (NSMenuValidation)
1001
1002 - (BOOL)validateMenuItem:(NSMenuItem *)o_mi
1003 {
1004     BOOL bEnabled = TRUE;
1005     vlc_value_t val;
1006     intf_thread_t * p_intf = VLCIntf;
1007     playlist_t * p_playlist = pl_Hold( p_intf );
1008     input_thread_t * p_input = playlist_CurrentInput( p_playlist );
1009
1010     if( [[o_mi title] isEqualToString: _NS("Faster")] ||
1011         [[o_mi title] isEqualToString: _NS("Slower")] )
1012     {
1013         if( p_input != NULL )
1014         {
1015             bEnabled = var_GetBool( p_input, "can-rate" );
1016         }
1017         else
1018         {
1019             bEnabled = FALSE;
1020         }
1021     }
1022     else if( [[o_mi title] isEqualToString: _NS("Stop")] )
1023     {
1024         if( p_input == NULL )
1025         {
1026             bEnabled = FALSE;
1027         }
1028         [o_main setupMenus]; /* Make sure input menu is up to date */
1029     }
1030     else if( [[o_mi title] isEqualToString: _NS("Previous")] ||
1031              [[o_mi title] isEqualToString: _NS("Next")] )
1032     {
1033         PL_LOCK;
1034         bEnabled = playlist_CurrentSize( p_playlist ) > 1;
1035         PL_UNLOCK;
1036     }
1037     else if( [[o_mi title] isEqualToString: _NS("Random")] )
1038     {
1039         int i_state;
1040         var_Get( p_playlist, "random", &val );
1041         i_state = val.b_bool ? NSOnState : NSOffState;
1042         [o_mi setState: i_state];
1043     }
1044     else if( [[o_mi title] isEqualToString: _NS("Repeat One")] )
1045     {
1046         int i_state;
1047         var_Get( p_playlist, "repeat", &val );
1048         i_state = val.b_bool ? NSOnState : NSOffState;
1049         [o_mi setState: i_state];
1050     }
1051     else if( [[o_mi title] isEqualToString: _NS("Repeat All")] )
1052     {
1053         int i_state;
1054         var_Get( p_playlist, "loop", &val );
1055         i_state = val.b_bool ? NSOnState : NSOffState;
1056         [o_mi setState: i_state];
1057     }
1058     else if( [[o_mi title] isEqualToString: _NS("Step Forward")] ||
1059              [[o_mi title] isEqualToString: _NS("Step Backward")] ||
1060              [[o_mi title] isEqualToString: _NS("Jump To Time")])
1061     {
1062         if( p_input != NULL )
1063         {
1064             var_Get( p_input, "can-seek", &val);
1065             bEnabled = val.b_bool;
1066         }
1067         else bEnabled = FALSE;
1068     }
1069     else if( [[o_mi title] isEqualToString: _NS("Mute")] )
1070     {
1071         [o_mi setState: p_intf->p_sys->b_mute ? NSOnState : NSOffState];
1072         [o_main setupMenus]; /* Make sure audio menu is up to date */
1073     }
1074     else if( [[o_mi title] isEqualToString: _NS("Half Size")] ||
1075                 [[o_mi title] isEqualToString: _NS("Normal Size")] ||
1076                 [[o_mi title] isEqualToString: _NS("Double Size")] ||
1077                 [[o_mi title] isEqualToString: _NS("Fit to Screen")] ||
1078                 [[o_mi title] isEqualToString: _NS("Snapshot")] ||
1079                 [[o_mi title] isEqualToString: _NS("Fullscreen")] ||
1080                 [[o_mi title] isEqualToString: _NS("Float on Top")] )
1081     {
1082         id o_window;
1083         NSArray *o_windows = [NSApp orderedWindows];
1084         NSEnumerator *o_enumerator = [o_windows objectEnumerator];
1085         bEnabled = FALSE;
1086  
1087         if( p_input != NULL )
1088         {
1089             vout_thread_t *p_vout = input_GetVout( p_input );
1090             if( p_vout != NULL )
1091             {
1092                 if( [[o_mi title] isEqualToString: _NS("Float on Top")] )
1093                 {
1094                     var_Get( p_vout, "video-on-top", &val );
1095                     [o_mi setState: val.b_bool ?  NSOnState : NSOffState];
1096                 }
1097     
1098                 while( (o_window = [o_enumerator nextObject]))
1099                 {
1100                     if( [[o_window className] isEqualToString: @"VLCVoutWindow"] ||
1101                                 [[[VLCMain sharedInstance] embeddedList]
1102                                 windowContainsEmbedded: o_window])
1103                     {
1104                         bEnabled = TRUE;
1105                         break;
1106                     }
1107                 }
1108     
1109                 vlc_object_release( (vlc_object_t *)p_vout );
1110             }
1111             vlc_object_release( p_input );
1112         }
1113         if( [[o_mi title] isEqualToString: _NS("Fullscreen")] )
1114         {
1115             var_Get( p_playlist, "fullscreen", &val );
1116             [o_mi setState: val.b_bool];
1117             bEnabled = TRUE;
1118         }
1119         [o_main setupMenus]; /* Make sure video menu is up to date */
1120     }
1121
1122     /* Special case for telx menu */
1123     if( [[o_mi title] isEqualToString: _NS("Normal Size")] )
1124     {
1125         NSMenuItem *item = [[o_mi menu] itemWithTitle:_NS("Teletext")];
1126                 bool b_telx = p_input && var_GetInteger( p_input, "teletext-es" ) >= 0;
1127
1128         [[item submenu] setAutoenablesItems:NO];
1129         for( int k=0; k < [[item submenu] numberOfItems]; k++ )
1130         {
1131             [[[item submenu] itemAtIndex:k] setEnabled: b_telx];
1132         }
1133     }
1134
1135     if( p_input ) vlc_object_release( p_input );
1136     pl_Release( p_intf );
1137
1138     return( bEnabled );
1139 }
1140
1141 @end
1142
1143 /*****************************************************************************
1144  * VLCAutoGeneratedMenuContent implementation
1145  *****************************************************************************
1146  * Object connected to a playlistitem which remembers the data belonging to
1147  * the variable of the autogenerated menu
1148  *****************************************************************************/
1149 @implementation VLCAutoGeneratedMenuContent
1150
1151 -(id) initWithVariableName:(const char *)name ofObject:(vlc_object_t *)object
1152         andValue:(vlc_value_t)val ofType:(int)type
1153 {
1154     self = [super init];
1155
1156     if( self != nil )
1157     {
1158         _vlc_object = vlc_object_hold( object );
1159         psz_name = strdup( name );
1160         i_type = type;
1161         value = val;
1162         if( (i_type & VLC_VAR_TYPE) == VLC_VAR_STRING )
1163             value.psz_string = strdup( val.psz_string );
1164     }
1165
1166     return( self );
1167 }
1168
1169 - (void)dealloc
1170 {
1171     vlc_object_release( _vlc_object );
1172     if( (i_type & VLC_VAR_TYPE) == VLC_VAR_STRING )
1173         free( value.psz_string );
1174     free( psz_name );
1175     [super dealloc];
1176 }
1177
1178 - (const char *)name
1179 {
1180     return psz_name;
1181 }
1182
1183 - (vlc_value_t)value
1184 {
1185     return value;
1186 }
1187
1188 - (vlc_object_t *)vlcObject
1189 {
1190     return vlc_object_hold( _vlc_object );
1191 }
1192
1193
1194 - (int)type
1195 {
1196     return i_type;
1197 }
1198
1199 @end
1200
1201
1202 /*****************************************************************************
1203  * VLCTimeField implementation
1204  *****************************************************************************
1205  * we need this to catch our click-event in the controller window
1206  *****************************************************************************/
1207
1208 @implementation VLCTimeField
1209 - (void)mouseDown: (NSEvent *)ourEvent
1210 {
1211     if( [ourEvent clickCount] > 1 )
1212         [[[VLCMain sharedInstance] controls] goToSpecificTime: nil];
1213     else
1214         [[VLCMain sharedInstance] timeFieldWasClicked: self];
1215 }
1216 @end