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