git.sesse.net Git - vlc/blob - 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
 865
 866 {
 867     BOOL b_return;
 868     b_return = [super setVout: p_arg_vout subView: view frame: s_arg_frame];
 869     if( b_return )
 870     {
 871         o_window = [self 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 - (void)setUsed: (BOOL)b_new_used
 886 {
 887     b_used = b_new_used;
 888 }
 889
 890 - (BOOL)isUsed
 891 {
 892     return b_used;
 893 }
 894
 895 - (void)closeVout
 896 {
 897     [super closeVout];
 898     [o_window setAcceptsMouseMovedEvents: NO];
 899     [[[VLCMain sharedInstance] getEmbeddedList] releaseEmbeddedVout: self];
 900 }
 901
 902
 903 @end
 904
 905 @implementation VLCDetachedEmbeddedVoutView
 906 - (void)awakeFromNib
 907 {
 908     o_embeddedwindow = [self window];
 909 }
 910
 911 - (BOOL)setVout: (vout_thread_t *) p_arg_vout subView: (NSView *) view
 912                      frame: (NSRect *) s_arg_frame
 913 {
 914     BOOL b_return = [super setVout: p_arg_vout subView: view frame: s_arg_frame];
 915
 916     /* o_window needs to point to our o_embeddedwindow, super might have set it
 917      * to the fullscreen window that o_embeddedwindow setups during fullscreen */
 918     o_window = o_embeddedwindow;
 919
 920     if( b_return )
 921     {
 922         [o_window setAlphaValue: var_GetFloat( p_vout, "macosx-opaqueness" )];
 923         [self updateTitle];
 924
 925         if(!([o_window isFullscreen]))
 926             [o_window makeKeyAndOrderFront: self];
 927
 928         NSLog(@"We are %s animating (%s)",  [o_window isVisible] && (![o_window isFullscreen]) ? "" :"not", [o_window isFullscreen] ? "fullscreen" : "");
 929
 930         [self scaleWindowWithFactor: 1.0 animate: [o_window isVisible] && (![o_window isFullscreen])];
 931     }
 932     return b_return;
 933 }
 934
 935 - (void)closeVout
 936 {
 937     playlist_t * p_playlist = pl_Yield( VLCIntf );
 938
 939     if(!playlist_IsPlaying( p_playlist ))
 940         [o_window performSelectorOnMainThread: @selector(orderOut:) withObject: self waitUntilDone: YES];
 941
 942     vlc_object_release( p_playlist );
 943
 944     [super closeVout];
 945 }
 946
 947 - (void)enterFullscreen
 948 {
 949     /* We are in a VLCEmbeddedWindow */
 950     [o_embeddedwindow performSelectorOnMainThread: @selector(enterFullscreen) withObject: NULL waitUntilDone: YES];
 951 }
 952
 953 - (void)leaveFullscreen
 954 {
 955     /* We are in a VLCEmbeddedWindow */
 956     [o_embeddedwindow performSelectorOnMainThread: @selector(leaveFullscreen) withObject: NULL waitUntilDone: YES];
 957 }
 958 @end
 959
 960 /*****************************************************************************
 961  * VLCVoutWindow implementation
 962  *****************************************************************************/
 963 @implementation VLCVoutWindow
 964
 965 - (id) initWithVout: (vout_thread_t *) vout view: (VLCVoutView *) view
 966                      frame: (NSRect *) frame
 967 {
 968     p_vout  = vout;
 969     o_view  = view;
 970     s_frame = frame;
 971
 972     [self performSelectorOnMainThread: @selector(initReal:)
 973         withObject: NULL waitUntilDone: YES];
 974
 975     if( !b_init_ok )
 976     {
 977         return NULL;
 978     }
 979
 980     return self;
 981 }
 982
 983 - (id)initReal: (id) sender
 984 {
 985     NSAutoreleasePool *o_pool = [[NSAutoreleasePool alloc] init];
 986     NSArray *o_screens = [NSScreen screens];
 987     NSScreen *o_screen;
 988     vlc_bool_t b_menubar_screen = VLC_FALSE;
 989     int i_device;
 990
 991     b_init_ok = VLC_FALSE;
 992
 993     p_real_vout = [VLCVoutView getRealVout: p_vout];
 994     i_device = var_GetInteger( p_real_vout->p_libvlc, "video-device" );
 995     b_black = var_GetBool( p_vout, "macosx-black" );
 996     b_embedded = var_GetBool( p_vout, "macosx-embedded" );
 997
 998     /* Find out on which screen to open the window */
 999     o_screen = [NSScreen screenWithDisplayID: (CGDirectDisplayID)i_device];
1000
1001     if( !o_screen )
1002         o_screen = [NSScreen mainScreen];
1003
1004     if( o_screen == [NSScreen mainScreen] )
1005         b_menubar_screen = VLC_TRUE;
1006
1007     if( p_vout->b_fullscreen )
1008     {
1009         CGDisplayFadeReservationToken token;
1010         NSRect screen_rect = [o_screen frame];
1011         screen_rect.origin.x = screen_rect.origin.y = 0;
1012
1013         /* move the FSPanel to front in case that it is currently shown
1014          * this won't and is not supposed to work when it's fading right now */
1015         if( [[[[VLCMain sharedInstance] getControls] getFSPanel] isDisplayed] )
1016             [[[[VLCMain sharedInstance] getControls] getFSPanel] orderFront: self];
1017
1018         /* tell the fspanel to move itself to front next time it's triggered */
1019         [[[[VLCMain sharedInstance] getControls] getFSPanel] setVoutWasUpdated: i_device];
1020
1021         /* Creates a window with size: screen_rect on o_screen */
1022         [self initWithContentRect: screen_rect
1023               styleMask: NSBorderlessWindowMask
1024               backing: NSBackingStoreBuffered
1025               defer: YES screen: o_screen];
1026
1027         if( b_black == VLC_TRUE )
1028             [o_screen blackoutOtherScreens];
1029
1030         if( b_menubar_screen )
1031         {
1032             SetSystemUIMode( kUIModeAllHidden, kUIOptionAutoShowMenuBar);
1033         }
1034         if( b_black == VLC_TRUE )
1035         {
1036             CGAcquireDisplayFadeReservation(kCGMaxDisplayReservationInterval, &token);
1037             CGDisplayFade( token, 2 , kCGDisplayBlendSolidColor, kCGDisplayBlendNormal, 0, 0, 0, false );
1038             CGReleaseDisplayFadeReservation( token);
1039         }
1040     }
1041     else if( var_GetBool( p_vout, "macosx-background" ) )
1042     {
1043         NSRect screen_rect = [o_screen frame];
1044         screen_rect.origin.x = screen_rect.origin.y = 0;
1045
1046         /* Creates a window with size: screen_rect on o_screen */
1047         [self initWithContentRect: screen_rect
1048               styleMask: NSBorderlessWindowMask
1049               backing: NSBackingStoreBuffered
1050               defer: YES screen: o_screen];
1051
1052         [self setLevel: CGWindowLevelForKey(kCGDesktopWindowLevelKey)];
1053     }
1054     else
1055     {
1056         unsigned int i_stylemask = NSTitledWindowMask |
1057                                    NSMiniaturizableWindowMask |
1058                                    NSClosableWindowMask |
1059                                    NSResizableWindowMask;
1060
1061         NSRect s_rect;
1062         if( !s_frame )
1063         {
1064             s_rect.size.width  = p_vout->i_window_width;
1065             s_rect.size.height = p_vout->i_window_height;
1066         }
1067         else
1068         {
1069             s_rect = *s_frame;
1070         }
1071
1072         [self initWithContentRect: s_rect
1073               styleMask: i_stylemask
1074               backing: NSBackingStoreBuffered
1075               defer: YES screen: o_screen];
1076
1077         [self setAlphaValue: var_GetFloat( p_vout, "macosx-opaqueness" )];
1078
1079         if( !s_frame )
1080         {
1081             [self center];
1082         }
1083     }
1084
1085     [self makeKeyAndOrderFront: nil];
1086     [self setReleasedWhenClosed: YES];
1087
1088     /* We'll catch mouse events */
1089     [self makeFirstResponder: o_view];
1090
1091     /* Add the view. It's automatically resized to fit the window */
1092     [self setContentView: o_view];
1093
1094     [o_pool release];
1095
1096     b_init_ok = VLC_TRUE;
1097     return self;
1098 }
1099
1100 - (void)close
1101 {
1102     [o_view closeVout];
1103 }
1104
1105 - (void)closeWindow
1106 {
1107     /* XXX waitUntilDone = NO to avoid a possible deadlock when hitting
1108        Command-Q */
1109     [self setContentView: NULL];
1110     [self performSelectorOnMainThread: @selector(closeReal:)
1111         withObject: NULL waitUntilDone: NO];
1112 }
1113
1114 - (id)closeReal:(id)sender
1115 {
1116     if( b_black == VLC_TRUE )
1117     {
1118         CGDisplayFadeReservationToken token;
1119         CGAcquireDisplayFadeReservation(kCGMaxDisplayReservationInterval, &token);
1120         CGDisplayFade( token, 2, kCGDisplayBlendSolidColor, kCGDisplayBlendNormal, 0, 0, 0, false );
1121         CGReleaseDisplayFadeReservation( token);
1122         CGDisplayRestoreColorSyncSettings();
1123     }
1124     SetSystemUIMode( kUIModeNormal, 0);
1125     [super close];
1126     /* this does only work in embedded mode */
1127     if( b_embedded == VLC_TRUE )
1128         [[[[VLCMain sharedInstance] getControls] getFSPanel] orderOut: self];
1129
1130     return NULL;
1131 }
1132
1133 - (id)getVoutView
1134 {
1135     return o_view;
1136 }
1137
1138 - (BOOL)canBecomeKeyWindow
1139 {
1140     return YES;
1141 }
1142
1143 /* Sometimes crashes VLC....
1144 - (BOOL)performKeyEquivalent:(NSEvent *)o_event
1145 {
1146         return [[VLCMain sharedInstance] hasDefinedShortcutKey:o_event];
1147 }*/
1148
1149 /* This is actually the same as VLCControls::stop. */
1150
1151 - (BOOL)windowShouldClose:(id)sender
1152 {
1153     playlist_t * p_playlist = vlc_object_find( p_vout, VLC_OBJECT_PLAYLIST,
1154                                                        FIND_ANYWHERE );
1155     if( p_playlist == NULL )
1156     {
1157         return NO;
1158     }
1159
1160     playlist_Stop( p_playlist );
1161     vlc_object_release( p_playlist );
1162
1163     /* The window will be closed by the intf later. */
1164     return NO;
1165 }
1166
1167
1168 @end