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