* be more accurate when fading in and out (refs #913 and hopefully fixes it)
[vlc.git] / modules / gui / macosx / vout.m
1 /*****************************************************************************
2  * vout.m: MacOS X video output module
3  *****************************************************************************
4  * Copyright (C) 2001-2006 the VideoLAN team
5  * $Id$
6  *
7  * Authors: Colin Delacroix <colin@zoy.org>
8  *          Florian G. Pflug <fgp@phlo.org>
9  *          Jon Lech Johansen <jon-vl@nanocrew.net>
10  *          Derk-Jan Hartman <hartman at videolan dot org>
11  *          Eric Petit <titer@m0k.org>
12  *          Benjamin Pracht <bigben at videolan dot org>
13  *          Felix K\9fhne <fkuehne at videolan dot org>
14  *
15  * This program is free software; you can redistribute it and/or modify
16  * it under the terms of the GNU General Public License as published by
17  * the Free Software Foundation; either version 2 of the License, or
18  * (at your option) any later version.
19  *
20  * This program is distributed in the hope that it will be useful,
21  * but WITHOUT ANY WARRANTY; without even the implied warranty of
22  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
23  * GNU General Public License for more details.
24  *
25  * You should have received a copy of the GNU General Public License
26  * along with this program; if not, write to the Free Software
27  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston MA 02110-1301, USA.
28  *****************************************************************************/
29
30 /*****************************************************************************
31  * Preamble
32  *****************************************************************************/
33 #include <errno.h>                                                 /* ENOMEM */
34 #include <stdlib.h>                                                /* free() */
35 #include <string.h>                                            /* strerror() */
36
37 /* BeginFullScreen, EndFullScreen */
38 #include <QuickTime/QuickTime.h>
39
40 #include <vlc_keys.h>
41
42 #include "intf.h"
43 #include "fspanel.h"
44 #include "vout.h"
45 #import "controls.h"
46
47 /*****************************************************************************
48  * DeviceCallback: Callback triggered when the video-device variable is changed
49  *****************************************************************************/
50 int DeviceCallback( vlc_object_t *p_this, const char *psz_variable,
51                      vlc_value_t old_val, vlc_value_t new_val, void *param )
52 {
53     vlc_value_t val;
54     vout_thread_t *p_vout = (vout_thread_t *)p_this;
55
56     msg_Dbg( p_vout, "set %d", new_val.i_int );
57     var_Create( p_vout->p_libvlc, "video-device", VLC_VAR_INTEGER );
58     var_Set( p_vout->p_libvlc, "video-device", new_val );
59
60     val.b_bool = VLC_TRUE;
61     var_Set( p_vout, "intf-change", val );
62     return VLC_SUCCESS;
63 }
64
65
66 /*****************************************************************************
67  * VLCEmbeddedList implementation
68  *****************************************************************************/
69 @implementation VLCEmbeddedList
70
71 - (id)init
72 {
73     [super init];
74     o_embedded_array = [NSMutableArray array];
75     return self;
76 }
77
78 - (id)getEmbeddedVout
79 {
80     unsigned int i;
81
82     for( i = 0; i < [o_embedded_array count]; i++ )
83     {
84         id o_vout_view = [o_embedded_array objectAtIndex: i];
85         if( ![o_vout_view isUsed] )
86         {
87             [o_vout_view setUsed: YES];
88             return o_vout_view;
89         }
90     }
91     return nil;
92 }
93
94 - (void)releaseEmbeddedVout: (id)o_vout_view
95 {
96     if( [o_embedded_array containsObject: o_vout_view] )
97     {
98         [o_vout_view setUsed: NO];
99     }
100     else
101     {
102         msg_Warn( VLCIntf, "cannot find Video Output");
103     }
104 }
105
106 - (void)addEmbeddedVout: (id)o_vout_view
107 {
108     if( ![o_embedded_array containsObject: o_vout_view] )
109     {
110         [o_embedded_array addObject: o_vout_view];
111     }
112 }
113
114 - (BOOL)windowContainsEmbedded: (id)o_window
115 {
116 /*    if( ![[o_window className] isEqualToString: @"VLCWindow"] )
117     {
118         NSLog( @"We were not given a VLCWindow" );
119     }*/
120     return ([self getViewForWindow: o_window] == nil ? NO : YES );
121 }
122
123 - (id)getViewForWindow: (id)o_window
124 {
125     id o_enumerator = [o_embedded_array objectEnumerator];
126     id o_current_embedded;
127
128     while( (o_current_embedded = [o_enumerator nextObject]) )
129     {
130         if( [o_current_embedded getWindow] == o_window )
131         {
132             return o_current_embedded;
133         }
134     }
135     return nil;
136 }
137
138 @end
139
140 /*****************************************************************************
141  * VLCVoutView implementation
142  *****************************************************************************/
143 @implementation VLCVoutView
144
145 - (id)initWithFrame:(NSRect)frameRect
146 {
147     [super initWithFrame: frameRect];
148     p_vout = NULL;
149     o_view = nil;
150     s_frame = &frameRect;
151
152     p_real_vout = NULL;
153     o_window = nil;
154     return self;
155 }
156
157 - (BOOL)setVout: (vout_thread_t *) vout subView: (NSView *) view
158                      frame: (NSRect *) frame
159 {
160     int i_device;
161     NSAutoreleasePool *o_pool = [[NSAutoreleasePool alloc] init];
162     NSArray *o_screens = [NSScreen screens];
163
164     p_vout  = vout;
165     o_view  = view;
166     s_frame = frame;
167
168     if( [o_screens count] <= 0 )
169     {
170         msg_Err( p_vout, "no OSX screens available" );
171         return NO;
172     }
173
174     p_real_vout = [VLCVoutView getRealVout: p_vout];
175
176     /* Get the pref value when this is the first time, otherwise retrieve the device from the top level video-device var */
177     if( var_Type( p_real_vout->p_libvlc, "video-device" ) == 0 )
178     {
179         i_device = var_GetInteger( p_vout, "macosx-vdev" );
180     }
181     else
182     {
183         i_device = var_GetInteger( p_real_vout->p_libvlc, "video-device" );
184     }
185
186     /* Setup the menuitem for the multiple displays. */
187     if( var_Type( p_real_vout, "video-device" ) == 0 )
188     {
189         int i = 1;
190         vlc_value_t val2, text;
191         NSScreen * o_screen;
192
193         var_Create( p_real_vout, "video-device", VLC_VAR_INTEGER |
194                                             VLC_VAR_HASCHOICE );
195         text.psz_string = _("Video Device");
196         var_Change( p_real_vout, "video-device", VLC_VAR_SETTEXT, &text, NULL );
197
198         NSEnumerator * o_enumerator = [o_screens objectEnumerator];
199
200         val2.i_int = 0;
201         text.psz_string = _("Default");
202         var_Change( p_real_vout, "video-device",
203                         VLC_VAR_ADDCHOICE, &val2, &text );
204         var_Set( p_real_vout, "video-device", val2 );
205
206         while( (o_screen = [o_enumerator nextObject]) != NULL )
207         {
208             char psz_temp[255];
209             NSRect s_rect = [o_screen frame];
210
211             snprintf( psz_temp, sizeof(psz_temp)/sizeof(psz_temp[0])-1,
212                       "%s %d (%dx%d)", _("Screen"), i,
213                       (int)s_rect.size.width, (int)s_rect.size.height );
214
215             text.psz_string = psz_temp;
216             val2.i_int = i;
217             var_Change( p_real_vout, "video-device",
218                         VLC_VAR_ADDCHOICE, &val2, &text );
219             if( i == i_device )
220             {
221                 var_Set( p_real_vout, "video-device", val2 );
222             }
223             i++;
224         }
225
226         var_AddCallback( p_real_vout, "video-device", DeviceCallback,
227                          NULL );
228
229         val2.b_bool = VLC_TRUE;
230         var_Set( p_real_vout, "intf-change", val2 );
231     }
232
233     /* Add the view. It's automatically resized to fit the window */
234     [self addSubview: o_view];
235     [self setAutoresizesSubviews: YES];
236     [o_pool release];
237
238     return YES;
239 }
240
241 - (void)resizeSubviewsWithOldSize:(NSSize)oldBoundsSize
242 {
243     [super resizeSubviewsWithOldSize: oldBoundsSize];
244     [o_view setFrameSize: [self frame].size];
245 }
246
247 - (void)closeVout
248 {
249     [[[[VLCMain sharedInstance] getControls] getFSPanel] fadeOut];
250
251     [o_view removeFromSuperview];
252     o_view = nil;
253     p_vout = NULL;
254     s_frame = nil;
255     o_window = nil;
256     p_real_vout = NULL;            
257 }
258
259 - (void)updateTitle
260 {
261     NSMutableString * o_title = nil, * o_mrl = nil;
262     input_thread_t * p_input;
263
264     if( p_vout == NULL )
265     {
266         return;
267     }
268
269     p_input = vlc_object_find( p_vout, VLC_OBJECT_INPUT, FIND_PARENT );
270
271     if( p_input == NULL )
272     {
273         return;
274     }
275
276     if( input_GetItem(p_input)->psz_name != NULL )
277         o_title = [NSMutableString stringWithUTF8String:
278             input_GetItem(p_input)->psz_name];
279     if( input_GetItem(p_input)->psz_uri != NULL )
280         o_mrl = [NSMutableString stringWithUTF8String:
281             input_GetItem(p_input)->psz_uri];
282     if( o_title == nil )
283         o_title = o_mrl;
284
285     if( o_mrl != nil )
286     {
287         /* FIXME once psz_access is exported, since that syntax is no longer valid */
288 #if 0
289         if( p_input->input.p_access && !strcmp( p_input->input.p_access->p_module->psz_shortname, "File" ) )
290         {
291             NSRange prefix_range = [o_mrl rangeOfString: @"file:"];
292             if( prefix_range.location != NSNotFound )
293                 [o_mrl deleteCharactersInRange: prefix_range];
294             [o_window setRepresentedFilename: o_mrl];
295         }
296 #endif
297         [o_window setTitle: o_title];
298     }
299     else
300     {
301         [o_window setTitle: [NSString stringWithCString: VOUT_TITLE]];
302     }
303     vlc_object_release( p_input );
304 }
305
306
307 - (void)setOnTop:(BOOL)b_on_top
308 {
309     if( b_on_top )
310     {
311         [o_window setLevel: NSStatusWindowLevel];
312     }
313     else
314     {
315         [o_window setLevel: NSNormalWindowLevel];
316     }
317 }
318
319 - (void)scaleWindowWithFactor: (float)factor
320 {
321     NSSize newsize;
322     int i_corrected_height, i_corrected_width;
323     NSPoint topleftbase;
324     NSPoint topleftscreen;
325
326     if ( !p_vout->b_fullscreen )
327     {
328         NSRect new_frame;
329         topleftbase.x = 0;
330         topleftbase.y = [o_window frame].size.height;
331         topleftscreen = [o_window convertBaseToScreen: topleftbase];
332
333         if( p_vout->render.i_height * p_vout->render.i_aspect >
334                         p_vout->render.i_width * VOUT_ASPECT_FACTOR )
335         {
336             i_corrected_width = p_vout->render.i_height * p_vout->render.i_aspect /
337                                             VOUT_ASPECT_FACTOR;
338             newsize.width = (int) ( i_corrected_width * factor );
339             newsize.height = (int) ( p_vout->render.i_height * factor );
340         }
341         else
342         {
343             i_corrected_height = p_vout->render.i_width * VOUT_ASPECT_FACTOR /
344                                             p_vout->render.i_aspect;
345             newsize.width = (int) ( p_vout->render.i_width * factor );
346             newsize.height = (int) ( i_corrected_height * factor );
347         }
348
349         /* Calculate the window's new size */
350         new_frame.size.width = [o_window frame].size.width -
351                                     [self frame].size.width + newsize.width;
352         new_frame.size.height = [o_window frame].size.height -
353                                     [self frame].size.height + newsize.height;
354
355         new_frame.origin.x = topleftscreen.x;
356         new_frame.origin.y = topleftscreen.y - new_frame.size.height;
357
358         [o_window setFrame: new_frame display: NO];
359
360         p_vout->i_changes |= VOUT_SIZE_CHANGE;
361     }
362 }
363
364 - (void)toggleFloatOnTop
365 {
366     vlc_value_t val;
367
368     if( !p_real_vout ) return;
369     if( var_Get( p_real_vout, "video-on-top", &val )>=0 && val.b_bool)
370     {
371         val.b_bool = VLC_FALSE;
372     }
373     else
374     {
375         val.b_bool = VLC_TRUE;
376     }
377     var_Set( p_real_vout, "video-on-top", val );
378 }
379
380 - (void)toggleFullscreen
381 {
382     vlc_value_t val;
383     if( !p_real_vout ) return;
384     var_Get( p_real_vout, "fullscreen", &val );
385     val.b_bool = !val.b_bool;
386     var_Set( p_real_vout, "fullscreen", val );
387     if( [self isFullscreen] )
388         [[[[VLCMain sharedInstance] getControls] getFSPanel] setActive: nil];
389     else
390         [[[[VLCMain sharedInstance] getControls] getFSPanel] setNonActive: nil];
391 }
392
393 - (BOOL)isFullscreen
394 {
395     vlc_value_t val;
396     var_Get( p_real_vout, "fullscreen", &val );
397     return( val.b_bool );
398 }
399
400 - (void)snapshot
401 {
402     vout_Control( p_real_vout, VOUT_SNAPSHOT );
403 }
404
405 - (void)manage
406 {
407     /* Disable Screensaver */
408     UpdateSystemActivity( UsrActivity );
409 }
410
411 - (id)getWindow
412 {
413     return o_window;
414 }
415
416 - (void)keyDown:(NSEvent *)o_event
417 {
418     unichar key = 0;
419     vlc_value_t val;
420     unsigned int i_pressed_modifiers = 0;
421     val.i_int = 0;
422
423     i_pressed_modifiers = [o_event modifierFlags];
424
425     if( i_pressed_modifiers & NSShiftKeyMask )
426         val.i_int |= KEY_MODIFIER_SHIFT;
427     if( i_pressed_modifiers & NSControlKeyMask )
428         val.i_int |= KEY_MODIFIER_CTRL;
429     if( i_pressed_modifiers & NSAlternateKeyMask )
430         val.i_int |= KEY_MODIFIER_ALT;
431     if( i_pressed_modifiers & NSCommandKeyMask )
432         val.i_int |= KEY_MODIFIER_COMMAND;
433
434     key = [[o_event charactersIgnoringModifiers] characterAtIndex: 0];
435
436     if( key )
437     {
438         /* Escape should always get you out of fullscreen */
439         if( key == (unichar) 0x1b )
440         {
441              if( p_real_vout && [self isFullscreen] )
442              {
443                  [self toggleFullscreen];
444              }
445         }
446         else if ( key == ' ' )
447         {
448             vlc_value_t val;
449             val.i_int = config_GetInt( p_vout, "key-play-pause" );
450             var_Set( p_vout->p_libvlc, "key-pressed", val );
451         }
452         else
453         {
454             val.i_int |= CocoaKeyToVLC( key );
455             var_Set( p_vout->p_libvlc, "key-pressed", val );
456         }
457     }
458     else
459     {
460         [super keyDown: o_event];
461     }
462 }
463
464 - (void)mouseDown:(NSEvent *)o_event
465 {
466     vlc_value_t val;
467
468     if( p_vout )
469     {
470         if( ( [o_event type] == NSLeftMouseDown ) &&
471           ( ! ( [o_event modifierFlags] &  NSControlKeyMask ) ) )
472         {
473             if( [o_event clickCount] <= 1 )
474             {
475                 /* single clicking */
476                 var_Get( p_vout, "mouse-button-down", &val );
477                 val.i_int |= 1;
478                 var_Set( p_vout, "mouse-button-down", val );
479             }
480             else
481             {
482                 /* multiple clicking */
483                 [self toggleFullscreen];
484             }
485         }
486         else if( ( [o_event type] == NSRightMouseDown ) ||
487                ( ( [o_event type] == NSLeftMouseDown ) &&
488                  ( [o_event modifierFlags] &  NSControlKeyMask ) ) )
489         {
490             msg_Dbg( p_vout, "received NSRightMouseDown (generic method) or Ctrl clic" );
491             [NSMenu popUpContextMenu: [[VLCMain sharedInstance] getVoutMenu] withEvent: o_event forView: [[[VLCMain sharedInstance] getControls] getVoutView]];
492         }
493     }
494
495     [super mouseDown: o_event];
496 }
497
498 - (void)otherMouseDown:(NSEvent *)o_event
499 {
500     vlc_value_t val;
501
502     if( p_vout && [o_event type] == NSOtherMouseDown )
503     {
504         var_Get( p_vout, "mouse-button-down", &val );
505         val.i_int |= 2;
506         var_Set( p_vout, "mouse-button-down", val );
507     }
508
509     [super mouseDown: o_event];
510 }
511
512 - (void)rightMouseDown:(NSEvent *)o_event
513 {
514     if( p_vout && [o_event type] == NSRightMouseDown )
515     {
516         msg_Dbg( p_vout, "received NSRightMouseDown (specific method)" );
517         [NSMenu popUpContextMenu: [[VLCMain sharedInstance] getVoutMenu] withEvent: o_event forView: [[[VLCMain sharedInstance] getControls] getVoutView]];
518     }
519
520     [super mouseDown: o_event];
521 }
522
523 - (void)mouseUp:(NSEvent *)o_event
524 {
525     vlc_value_t val;
526
527     if( p_vout && [o_event type] == NSLeftMouseUp )
528     {
529         vlc_value_t b_val;
530         b_val.b_bool = VLC_TRUE;
531         var_Set( p_vout, "mouse-clicked", b_val );
532
533         var_Get( p_vout, "mouse-button-down", &val );
534         val.i_int &= ~1;
535         var_Set( p_vout, "mouse-button-down", val );
536     }
537
538     [super mouseUp: o_event];
539 }
540
541 - (void)otherMouseUp:(NSEvent *)o_event
542 {
543     vlc_value_t val;
544
545     if( p_vout && [o_event type] == NSOtherMouseUp )
546     {
547         var_Get( p_vout, "mouse-button-down", &val );
548         val.i_int &= ~2;
549         var_Set( p_vout, "mouse-button-down", val );
550     }
551
552     [super mouseUp: o_event];
553 }
554
555 - (void)rightMouseUp:(NSEvent *)o_event
556 {
557     if( p_vout && [o_event type] == NSRightMouseUp )
558     {
559         /* FIXME: this isn't the appropriate place, but we can't receive
560          * NSRightMouseDown some how */
561         msg_Dbg( p_vout, "received NSRightMouseUp" ); 
562         [NSMenu popUpContextMenu: [[VLCMain sharedInstance] getVoutMenu] withEvent: o_event forView: [[[VLCMain sharedInstance] getControls] getVoutView]];
563     }
564
565     [super mouseUp: o_event];
566 }
567
568 - (void)mouseDragged:(NSEvent *)o_event
569 {
570     [self mouseMoved: o_event];
571 }
572
573 - (void)otherMouseDragged:(NSEvent *)o_event
574 {
575     [self mouseMoved: o_event];
576 }
577
578 - (void)rightMouseDragged:(NSEvent *)o_event
579 {
580     [self mouseMoved: o_event];
581 }
582
583 - (void)mouseMoved:(NSEvent *)o_event
584 {
585     NSPoint ml;
586     NSRect s_rect;
587     BOOL b_inside;
588
589     if( p_vout )
590     {
591         s_rect = [o_view bounds];
592         ml = [o_view convertPoint: [o_event locationInWindow] fromView: nil];
593         b_inside = [o_view mouse: ml inRect: s_rect];
594
595         if( b_inside )
596         {
597             vlc_value_t val;
598             unsigned int i_width, i_height, i_x, i_y;
599
600             vout_PlacePicture( p_vout, (unsigned int)s_rect.size.width,
601                                        (unsigned int)s_rect.size.height,
602                                        &i_x, &i_y, &i_width, &i_height );
603
604             val.i_int = ( ((int)ml.x) - i_x ) *
605                         p_vout->render.i_width / i_width;
606             var_Set( p_vout, "mouse-x", val );
607
608             if( [[o_view className] isEqualToString: @"VLCGLView"] )
609             {
610                 val.i_int = ( ((int)(s_rect.size.height - ml.y)) - i_y ) *
611                             p_vout->render.i_height / i_height;
612             }
613             else
614             {
615                 val.i_int = ( ((int)ml.y) - i_y ) *
616                             p_vout->render.i_height / i_height;
617             }
618             var_Set( p_vout, "mouse-y", val );
619
620             val.b_bool = VLC_TRUE;
621             var_Set( p_vout, "mouse-moved", val );
622         }
623         if( [self isFullscreen] )
624             [[[[VLCMain sharedInstance] getControls] getFSPanel] fadeIn];
625     }
626
627     [super mouseMoved: o_event];
628 }
629
630 - (BOOL)acceptsFirstResponder
631 {
632     return YES;
633 }
634
635 - (BOOL)becomeFirstResponder
636 {
637     return YES;
638 }
639
640 - (BOOL)resignFirstResponder
641 {
642     /* We need to stay the first responder or we'll miss some
643        events */
644     return NO;
645 }
646
647 /* Class methods used by the different vout modules */
648
649 + (vout_thread_t *)getRealVout: (vout_thread_t *)p_vout
650 {
651     /* p_real_vout: the vout we have to use to check for video-on-top
652        and a few other things. If we are the QuickTime output, it's us.
653        It we are the OpenGL provider, it is our parent. */
654     if( p_vout->i_object_type == VLC_OBJECT_OPENGL )
655     {
656         return (vout_thread_t *) p_vout->p_parent;
657     }
658     else
659     {
660         return p_vout;
661     }
662
663 }
664
665 + (id)getVoutView: (vout_thread_t *)p_vout subView: (NSView *)view
666                                     frame: (NSRect *)s_frame
667 {
668     vlc_value_t value_drawable;
669     int i_timeout;
670     id o_return = nil;
671
672     var_Get( p_vout->p_libvlc, "drawable", &value_drawable );
673
674     var_Create( p_vout, "macosx-vdev", VLC_VAR_INTEGER | VLC_VAR_DOINHERIT );
675     var_Create( p_vout, "macosx-stretch", VLC_VAR_BOOL | VLC_VAR_DOINHERIT );
676     var_Create( p_vout, "macosx-opaqueness", VLC_VAR_FLOAT | VLC_VAR_DOINHERIT );
677     var_Create( p_vout, "macosx-background", VLC_VAR_BOOL | VLC_VAR_DOINHERIT );
678     var_Create( p_vout, "macosx-black", VLC_VAR_BOOL | VLC_VAR_DOINHERIT );
679     var_Create( p_vout, "macosx-embedded", VLC_VAR_BOOL | VLC_VAR_DOINHERIT );
680
681
682     /* We only wait for NSApp to initialise if we're not embedded (as in the
683      * case of the Mozilla plugin).  We can tell whether we're embedded or not
684      * by examining the "drawable" value: if it's zero, we're running in the
685      * main Mac intf; if it's non-zero, we're embedded. */
686     if( value_drawable.i_int == 0 )
687     {
688         /* Wait for a MacOS X interface to appear. Timeout is 2 seconds. */
689         for( i_timeout = 20 ; i_timeout-- ; )
690         {
691             if( NSApp == NULL )
692             {
693                 msleep( INTF_IDLE_SLEEP );
694             }
695         }
696
697         if( NSApp == NULL )
698         {
699             /* No MacOS X intf, unable to communicate with MT */
700             msg_Err( p_vout, "no MacOS X interface present" );
701             return nil;
702         }
703         else
704         {
705             if ( VLCIntf && !(p_vout->b_fullscreen) &&
706                         !(var_GetBool( p_vout, "macosx-background" )) &&
707                         var_GetBool( p_vout, "macosx-embedded") )
708             {
709                 o_return = [[[VLCMain sharedInstance] getEmbeddedList]
710                                                             getEmbeddedVout];
711             }
712         }
713     }
714
715     /* No embedded vout is available */
716     if( o_return == nil )
717     {
718         NSRect null_rect;
719         bzero( &null_rect, sizeof( NSRect ) );
720         o_return = [[VLCDetachedVoutView alloc] initWithFrame: null_rect ];
721     }
722     [o_return setVout: p_vout subView: view frame: s_frame];
723     return o_return;
724 }
725
726 @end
727
728 /*****************************************************************************
729  * VLCDetachedVoutView implementation
730  *****************************************************************************/
731 @implementation VLCDetachedVoutView
732
733 - (id)initWithFrame: (NSRect)frameRect
734 {
735     [super initWithFrame: frameRect];
736     i_time_mouse_last_moved = 0;
737     return self;
738 }
739
740 - (bool)setVout: (vout_thread_t *) p_arg_vout subView: (NSView *) view
741                      frame: (NSRect *) s_arg_frame
742 {
743     BOOL b_return = [super setVout: p_arg_vout subView: view frame:s_arg_frame];
744     i_time_mouse_last_moved = mdate();
745     o_window = [[VLCWindow alloc] initWithVout: p_arg_vout view: self
746                                                     frame: s_arg_frame];
747     [self updateTitle];
748     [view setFrame: [self frame]];
749
750     if( var_GetBool( p_real_vout, "video-on-top" ) )
751     {
752         [o_window setLevel: NSStatusWindowLevel];
753     }
754
755
756     [o_window setAcceptsMouseMovedEvents: TRUE];
757     return b_return;
758 }
759
760 - (void)closeVout
761 {
762     [o_window closeWindow];
763     [o_window setAcceptsMouseMovedEvents: NO];
764     i_time_mouse_last_moved = 0;
765     [super closeVout];
766 }
767
768 - (void)mouseMoved:(NSEvent *)o_event
769 {
770     i_time_mouse_last_moved = mdate();
771     [super mouseMoved: o_event];
772 }
773
774 - (void)hideMouse:(BOOL)b_hide
775 {
776     BOOL b_inside;
777     NSPoint ml;
778     NSView *o_contents = [o_window contentView];
779
780     ml = [o_window convertScreenToBase:[NSEvent mouseLocation]];
781     ml = [o_contents convertPoint:ml fromView:nil];
782     b_inside = [o_contents mouse: ml inRect: [o_contents bounds]];
783
784     if( b_hide && b_inside )
785     {
786         [NSCursor setHiddenUntilMouseMoves: YES];
787     }
788     else if( !b_hide )
789     {
790         [NSCursor setHiddenUntilMouseMoves: NO];
791     }
792 }
793
794 - (void)manage
795 {
796     [super manage];
797     if( p_vout->b_fullscreen )
798     {
799         if( mdate() - i_time_mouse_last_moved > 3000000 )
800         {
801             [self hideMouse: YES];
802         }
803     }
804     else
805     {
806         [self hideMouse: NO];
807     }
808 }
809
810 @end
811
812 /*****************************************************************************
813  * VLCEmbeddedVoutView implementation
814  *****************************************************************************/
815
816 @implementation VLCEmbeddedVoutView
817
818 - (id)initWithFrame: (NSRect)frameRect
819 {
820     [super initWithFrame: frameRect];
821     b_used = NO;
822     [[[VLCMain sharedInstance] getEmbeddedList] addEmbeddedVout: self];
823     return self;
824 }
825
826 - (BOOL)setVout: (vout_thread_t *) p_arg_vout subView: (NSView *) view
827                      frame: (NSRect *) s_arg_frame
828
829 {
830     BOOL b_return;
831     b_return = [super setVout: p_arg_vout subView: view frame: s_arg_frame];
832     if( b_return )
833     {
834         o_window = [self window];
835         [o_window makeKeyAndOrderFront: self];
836         [o_window setAcceptsMouseMovedEvents: TRUE];
837
838         if( var_GetBool( p_real_vout, "video-on-top" ) )
839         {
840             [o_window setLevel: NSStatusWindowLevel];
841         }
842
843         [view setFrameSize: [self frame].size];
844     }
845     return b_return;
846 }
847
848 - (void)setUsed: (BOOL)b_new_used
849 {
850     b_used = b_new_used;
851 }
852
853 - (BOOL)isUsed
854 {
855     return b_used;
856 }
857
858 - (void)closeVout
859 {
860     [super closeVout];
861     [o_window setAcceptsMouseMovedEvents: NO];
862     [[[VLCMain sharedInstance] getEmbeddedList] releaseEmbeddedVout: self];
863 }
864
865
866 @end
867
868 @implementation VLCDetachedEmbeddedVoutView
869
870 - (BOOL)setVout: (vout_thread_t *) p_arg_vout subView: (NSView *) view
871                      frame: (NSRect *) s_arg_frame
872 {
873     BOOL b_return = [super setVout: p_arg_vout subView: view frame: s_arg_frame];
874
875     if( b_return )
876     {
877         [o_window setAlphaValue: var_GetFloat( p_vout, "macosx-opaqueness" )];
878         [self updateTitle];
879         [self scaleWindowWithFactor: 1.0];
880         [o_window makeKeyAndOrderFront: self];
881     }
882     return b_return;
883 }
884
885 - (void)closeVout
886 {
887     [o_window orderOut: self];
888     [super closeVout];
889 }
890
891 @end
892
893 /*****************************************************************************
894  * VLCWindow implementation
895  *****************************************************************************/
896 @implementation VLCWindow
897
898 - (id) initWithVout: (vout_thread_t *) vout view: (VLCVoutView *) view
899                      frame: (NSRect *) frame
900 {
901     p_vout  = vout;
902     o_view  = view;
903     s_frame = frame;
904
905     [self performSelectorOnMainThread: @selector(initReal:)
906         withObject: NULL waitUntilDone: YES];
907
908     if( !b_init_ok )
909     {
910         return NULL;
911     }
912
913     return self;
914 }
915
916 - (id)initReal: (id) sender
917 {
918     NSAutoreleasePool *o_pool = [[NSAutoreleasePool alloc] init];
919     NSArray *o_screens = [NSScreen screens];
920     NSScreen *o_screen;
921     vlc_bool_t b_menubar_screen = VLC_FALSE;
922     int i_device;
923
924     b_init_ok = VLC_FALSE;
925
926     p_real_vout = [VLCVoutView getRealVout: p_vout];
927     i_device = var_GetInteger( p_real_vout->p_libvlc, "video-device" );
928     b_black = var_GetBool( p_vout, "macosx-black" );
929     b_embedded = var_GetBool( p_vout, "macosx-embedded" );
930
931     /* Find out on which screen to open the window */
932     if( i_device <= 0 || i_device > (int)[o_screens count] )
933     {
934          /* No preference specified. Use the main screen */
935         o_screen = [NSScreen mainScreen];
936         i_device = [o_screens indexOfObject: o_screen];
937         if( o_screen == [o_screens objectAtIndex: 0] )
938             b_menubar_screen = VLC_TRUE;
939     }
940     else
941     {
942         i_device--;
943         o_screen = [o_screens objectAtIndex: i_device];
944         b_menubar_screen = ( i_device == 0 );
945     }
946
947     if( p_vout->b_fullscreen )
948     {
949         CGDisplayFadeReservationToken token;
950         NSRect screen_rect = [o_screen frame];
951         screen_rect.origin.x = screen_rect.origin.y = 0;
952
953         /* move the FSPanel to front in case that it is currently shown
954          * this won't and is not supposed to work when it's fading right now */
955         if( [[[[VLCMain sharedInstance] getControls] getFSPanel] isDisplayed] )
956             [[[[VLCMain sharedInstance] getControls] getFSPanel] orderFront: self];
957         
958         /* tell the fspanel to move itself to front next time it's triggered */
959         [[[[VLCMain sharedInstance] getControls] getFSPanel] setVoutWasUpdated: i_device];
960
961         /* Creates a window with size: screen_rect on o_screen */
962         [self initWithContentRect: screen_rect
963               styleMask: NSBorderlessWindowMask
964               backing: NSBackingStoreBuffered
965               defer: YES screen: o_screen];
966         
967         if( b_black == VLC_TRUE )
968         {
969             CGAcquireDisplayFadeReservation(kCGMaxDisplayReservationInterval, &token);
970             CGDisplayFade( token, 0.5, kCGDisplayBlendNormal, kCGDisplayBlendSolidColor, 0, 0, 0, true );
971             CGReleaseDisplayFadeReservation( token );
972             unsigned int i;
973             for( i = 0 ; i < [o_screens count]; i++)
974             {
975                 struct
976                 {
977                     CGDirectDisplayID displayID;
978                     CGGammaValue redMin, redMax, redGamma,
979                                  greenMin, greenMax, greenGamma,
980                                  blueMin, blueMax, blueGamma;
981                 } dispSettings;
982                 CGDisplayCount dspyCnt;
983                 CGPoint gPoint;
984
985                 if( i == (unsigned int)i_device ) continue;
986
987                 screen_rect = [[o_screens objectAtIndex: i] frame];
988
989                 gPoint.x = screen_rect.origin.x;
990                 gPoint.y = screen_rect.origin.y;
991                 CGGetDisplaysWithPoint( gPoint, 1, &(dispSettings.displayID), &dspyCnt);
992                 CGGetDisplayTransferByFormula(
993                     dispSettings.displayID,
994                     &dispSettings.redMin, &dispSettings.redMax, &dispSettings.redGamma,
995                     &dispSettings.greenMin, &dispSettings.greenMax, &dispSettings.greenGamma,
996                     &dispSettings.blueMin, &dispSettings.blueMax, &dispSettings.blueGamma );
997                 CGSetDisplayTransferByFormula(
998                     dispSettings.displayID,
999                     dispSettings.redMin,   0, dispSettings.redGamma,
1000                     dispSettings.greenMin, 0, dispSettings.greenGamma,
1001                     dispSettings.blueMin,  0, dispSettings.blueGamma );
1002             }
1003         }
1004         if( b_menubar_screen )
1005         {
1006             SetSystemUIMode( kUIModeAllHidden, kUIOptionAutoShowMenuBar);
1007         }
1008         if( b_black == VLC_TRUE )
1009         {
1010             CGAcquireDisplayFadeReservation(kCGMaxDisplayReservationInterval, &token);
1011             CGDisplayFade( token, 2 , kCGDisplayBlendSolidColor, kCGDisplayBlendNormal, 0, 0, 0, false );
1012             CGReleaseDisplayFadeReservation( token);
1013         }
1014     }
1015     else if( var_GetBool( p_vout, "macosx-background" ) )
1016     {
1017         NSRect screen_rect = [o_screen frame];
1018         screen_rect.origin.x = screen_rect.origin.y = 0;
1019
1020         /* Creates a window with size: screen_rect on o_screen */
1021         [self initWithContentRect: screen_rect
1022               styleMask: NSBorderlessWindowMask
1023               backing: NSBackingStoreBuffered
1024               defer: YES screen: o_screen];
1025
1026         [self setLevel: CGWindowLevelForKey(kCGDesktopWindowLevelKey)];
1027     }
1028     else
1029     {
1030         unsigned int i_stylemask = NSTitledWindowMask |
1031                                    NSMiniaturizableWindowMask |
1032                                    NSClosableWindowMask |
1033                                    NSResizableWindowMask;
1034
1035         NSRect s_rect;
1036         if( !s_frame )
1037         {
1038             s_rect.size.width  = p_vout->i_window_width;
1039             s_rect.size.height = p_vout->i_window_height;
1040         }
1041         else
1042         {
1043             s_rect = *s_frame;
1044         }
1045
1046         [self initWithContentRect: s_rect
1047               styleMask: i_stylemask
1048               backing: NSBackingStoreBuffered
1049               defer: YES screen: o_screen];
1050
1051         [self setAlphaValue: var_GetFloat( p_vout, "macosx-opaqueness" )];
1052
1053         if( !s_frame )
1054         {
1055             [self center];
1056         }
1057     }
1058
1059     [self makeKeyAndOrderFront: nil];
1060     [self setReleasedWhenClosed: YES];
1061
1062     /* We'll catch mouse events */
1063     [self makeFirstResponder: o_view];
1064
1065     /* Add the view. It's automatically resized to fit the window */
1066     [self setContentView: o_view];
1067
1068     [o_pool release];
1069
1070     b_init_ok = VLC_TRUE;
1071     return self;
1072 }
1073
1074 - (void)close
1075 {
1076     [o_view closeVout];
1077 }
1078
1079 - (void)closeWindow
1080 {
1081     /* XXX waitUntilDone = NO to avoid a possible deadlock when hitting
1082        Command-Q */
1083     [self setContentView: NULL];
1084     [self performSelectorOnMainThread: @selector(closeReal:)
1085         withObject: NULL waitUntilDone: NO];
1086 }
1087
1088 - (id)closeReal:(id)sender
1089 {
1090     if( b_black == VLC_TRUE )
1091     {
1092         CGDisplayFadeReservationToken token;
1093         CGAcquireDisplayFadeReservation(kCGMaxDisplayReservationInterval, &token);
1094         CGDisplayFade( token, 2, kCGDisplayBlendSolidColor, kCGDisplayBlendNormal, 0, 0, 0, false );
1095         CGReleaseDisplayFadeReservation( token);
1096         CGDisplayRestoreColorSyncSettings();
1097     }
1098     SetSystemUIMode( kUIModeNormal, 0);
1099     [super close];
1100     /* this does only work in embedded mode */
1101     if( b_embedded == VLC_TRUE )
1102         [[[[VLCMain sharedInstance] getControls] getFSPanel] orderOut: self];
1103
1104     return NULL;
1105 }
1106
1107 - (id)getVoutView
1108 {
1109     return o_view;
1110 }
1111
1112 - (BOOL)canBecomeKeyWindow
1113 {
1114     return YES;
1115 }
1116
1117 /* Sometimes crashes VLC....
1118 - (BOOL)performKeyEquivalent:(NSEvent *)o_event
1119 {
1120         return [[VLCMain sharedInstance] hasDefinedShortcutKey:o_event];
1121 }*/
1122
1123 /* This is actually the same as VLCControls::stop. */
1124
1125 - (BOOL)windowShouldClose:(id)sender
1126 {
1127     playlist_t * p_playlist = vlc_object_find( p_vout, VLC_OBJECT_PLAYLIST,
1128                                                        FIND_ANYWHERE );
1129     if( p_playlist == NULL )
1130     {
1131         return NO;
1132     }
1133
1134     playlist_Stop( p_playlist );
1135     vlc_object_release( p_playlist );
1136
1137     /* The window will be closed by the intf later. */
1138     return NO;
1139 }
1140
1141
1142 @end