git.sesse.net Git - vlc/blob - modules/gui/macosx/Windows.m

   1 /*****************************************************************************
   2  * Windows.m: MacOS X interface module
   3  *****************************************************************************
   4  * Copyright (C) 2012-2013 VLC authors and VideoLAN
   5  * $Id$
   6  *
   7  * Authors: Felix Paul Kühne <fkuehne -at- videolan -dot- org>
   8  *          David Fuhrmann <david dot fuhrmann at googlemail dot com>
   9  *
  10  * This program is free software; you can redistribute it and/or modify
  11  * it under the terms of the GNU General Public License as published by
  12  * the Free Software Foundation; either version 2 of the License, or
  13  * (at your option) any later version.
  14  *
  15  * This program is distributed in the hope that it will be useful,
  16  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  17  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  18  * GNU General Public License for more details.
  19  *
  20  * You should have received a copy of the GNU General Public License
  21  * along with this program; if not, write to the Free Software
  22  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston MA 02110-1301, USA.
  23  *****************************************************************************/
  24
  25 #import "Windows.h"
  26 #import "intf.h"
  27 #import "CoreInteraction.h"
  28 #import "ControlsBar.h"
  29 #import "VideoView.h"
  30
  31 /*****************************************************************************
  32  * VLCWindow
  33  *
  34  *  Missing extension to NSWindow
  35  *****************************************************************************/
  36
  37 @implementation VLCWindow
  38
  39 @synthesize hasActiveVideo=b_has_active_video;
  40 @synthesize fullscreen=b_fullscreen;
  41
  42 - (id)initWithContentRect:(NSRect)contentRect styleMask:(NSUInteger)styleMask
  43                   backing:(NSBackingStoreType)backingType defer:(BOOL)flag
  44 {
  45     self = [super initWithContentRect:contentRect styleMask:styleMask backing:backingType defer:flag];
  46     if (self) {
  47         /* we don't want this window to be restored on relaunch */
  48         if (!OSX_SNOW_LEOPARD)
  49             [self setRestorable:NO];
  50     }
  51     return self;
  52 }
  53
  54 - (void)setCanBecomeKeyWindow: (BOOL)canBecomeKey
  55 {
  56     b_isset_canBecomeKeyWindow = YES;
  57     b_canBecomeKeyWindow = canBecomeKey;
  58 }
  59
  60 - (BOOL)canBecomeKeyWindow
  61 {
  62     if (b_isset_canBecomeKeyWindow)
  63         return b_canBecomeKeyWindow;
  64
  65     return [super canBecomeKeyWindow];
  66 }
  67
  68 - (void)setCanBecomeMainWindow: (BOOL)canBecomeMain
  69 {
  70     b_isset_canBecomeMainWindow = YES;
  71     b_canBecomeMainWindow = canBecomeMain;
  72 }
  73
  74 - (BOOL)canBecomeMainWindow
  75 {
  76     if (b_isset_canBecomeMainWindow)
  77         return b_canBecomeMainWindow;
  78
  79     return [super canBecomeMainWindow];
  80 }
  81
  82 - (void)closeAndAnimate: (BOOL)animate
  83 {
  84     NSInvocation *invoc;
  85
  86     if (!animate) {
  87         [super close];
  88         return;
  89     }
  90
  91     // TODO this callback stuff does not work and is not needed
  92     invoc = [[[NSInvocation alloc] init] autorelease];
  93     [invoc setSelector:@selector(close)];
  94     [invoc setTarget: self];
  95
  96     if (![self isVisible] || [self alphaValue] == 0.0) {
  97         [super close];
  98         return;
  99     }
 100
 101     [self orderOut: self animate: YES callback: invoc];
 102 }
 103
 104 - (void)orderOut: (id)sender animate: (BOOL)animate
 105 {
 106     NSInvocation *invoc = [[[NSInvocation alloc] init] autorelease];
 107     [invoc setSelector:@selector(orderOut:)];
 108     [invoc setTarget: self];
 109     [invoc setArgument: sender atIndex: 2];
 110     [self orderOut: sender animate: animate callback: invoc];
 111 }
 112
 113 - (void)orderOut: (id)sender animate: (BOOL)animate callback:(NSInvocation *)callback
 114 {
 115     NSViewAnimation *anim;
 116     NSViewAnimation *current_anim;
 117     NSMutableDictionary *dict;
 118
 119     if (!animate) {
 120         [self orderOut: sender];
 121         return;
 122     }
 123
 124     dict = [[NSMutableDictionary alloc] initWithCapacity:2];
 125
 126     [dict setObject:self forKey:NSViewAnimationTargetKey];
 127
 128     [dict setObject:NSViewAnimationFadeOutEffect forKey:NSViewAnimationEffectKey];
 129     anim = [[NSViewAnimation alloc] initWithViewAnimations:[NSArray arrayWithObject:dict]];
 130     [dict release];
 131
 132     [anim setAnimationBlockingMode:NSAnimationNonblocking];
 133     [anim setDuration:0.9];
 134     [anim setFrameRate:30];
 135     [anim setUserInfo:callback];
 136     [anim setDelegate:self];
 137
 138     @synchronized(self) {
 139         current_anim = self->o_current_animation;
 140
 141         if ([[[current_anim viewAnimations] objectAtIndex:0] objectForKey: NSViewAnimationEffectKey] == NSViewAnimationFadeOutEffect && [current_anim isAnimating]) {
 142             [anim release];
 143         } else {
 144             if (current_anim) {
 145                 [current_anim stopAnimation];
 146                 [anim setCurrentProgress:1.0 - [current_anim currentProgress]];
 147                 [current_anim release];
 148             }
 149             else
 150                 [anim setCurrentProgress:1.0 - [self alphaValue]];
 151             self->o_current_animation = anim;
 152             [anim startAnimation];
 153         }
 154     }
 155 }
 156
 157 - (void)orderFront: (id)sender animate: (BOOL)animate
 158 {
 159     NSViewAnimation *anim;
 160     NSViewAnimation *current_anim;
 161     NSMutableDictionary *dict;
 162
 163     if (!animate) {
 164         [super orderFront: sender];
 165         [self setAlphaValue: 1.0];
 166         return;
 167     }
 168
 169     if (![self isVisible]) {
 170         [self setAlphaValue: 0.0];
 171         [super orderFront: sender];
 172     }
 173     else if ([self alphaValue] == 1.0) {
 174         [super orderFront: self];
 175         return;
 176     }
 177
 178     dict = [[NSMutableDictionary alloc] initWithCapacity:2];
 179
 180     [dict setObject:self forKey:NSViewAnimationTargetKey];
 181
 182     [dict setObject:NSViewAnimationFadeInEffect forKey:NSViewAnimationEffectKey];
 183     anim = [[NSViewAnimation alloc] initWithViewAnimations:[NSArray arrayWithObject:dict]];
 184     [dict release];
 185
 186     [anim setAnimationBlockingMode:NSAnimationNonblocking];
 187     [anim setDuration:0.5];
 188     [anim setFrameRate:30];
 189     [anim setDelegate:self];
 190
 191     @synchronized(self) {
 192         current_anim = self->o_current_animation;
 193
 194         if ([[[current_anim viewAnimations] objectAtIndex:0] objectForKey: NSViewAnimationEffectKey] == NSViewAnimationFadeInEffect && [current_anim isAnimating]) {
 195             [anim release];
 196         } else {
 197             if (current_anim) {
 198                 [current_anim stopAnimation];
 199                 [anim setCurrentProgress:1.0 - [current_anim currentProgress]];
 200                 [current_anim release];
 201             }
 202             else
 203                 [anim setCurrentProgress:[self alphaValue]];
 204             self->o_current_animation = anim;
 205             [self orderFront: sender];
 206             [anim startAnimation];
 207         }
 208     }
 209 }
 210
 211 - (void)animationDidEnd:(NSAnimation*)anim
 212 {
 213     if ([self alphaValue] <= 0.0) {
 214         NSInvocation * invoc;
 215         [super orderOut: nil];
 216         [self setAlphaValue: 1.0];
 217         if ((invoc = [anim userInfo])) {
 218             [invoc invoke];
 219         }
 220     }
 221 }
 222
 223 - (VLCVoutView *)videoView
 224 {
 225     if ([[self contentView] class] == [VLCVoutView class])
 226         return (VLCVoutView *)[self contentView];
 227
 228     return nil;
 229 }
 230
 231
 232 @end
 233
 234
 235 /*****************************************************************************
 236  * VLCVideoWindowCommon
 237  *
 238  *  Common code for main window, detached window and extra video window
 239  *****************************************************************************/
 240
 241 @interface VLCVideoWindowCommon (Internal)
 242 - (void)customZoom:(id)sender;
 243 - (void)hasBecomeFullscreen;
 244 - (void)leaveFullscreenAndFadeOut:(BOOL)fadeout;
 245 - (void)hasEndedFullscreen;
 246 @end
 247
 248 @implementation VLCVideoWindowCommon
 249
 250 @synthesize videoView=o_video_view;
 251 @synthesize controlsBar=o_controls_bar;
 252 @synthesize enteringFullscreenTransition=b_entering_fullscreen_transition;
 253
 254 #pragma mark -
 255 #pragma mark Init
 256
 257 - (id)initWithContentRect:(NSRect)contentRect styleMask:(NSUInteger)styleMask
 258                   backing:(NSBackingStoreType)backingType defer:(BOOL)flag
 259 {
 260     b_dark_interface = config_GetInt(VLCIntf, "macosx-interfacestyle");
 261
 262     if (b_dark_interface) {
 263         styleMask = NSBorderlessWindowMask;
 264 #ifdef MAC_OS_X_VERSION_10_7
 265         if (!OSX_SNOW_LEOPARD)
 266             styleMask |= NSResizableWindowMask;
 267 #endif
 268     }
 269
 270     self = [super initWithContentRect:contentRect styleMask:styleMask
 271                               backing:backingType defer:flag];
 272
 273     /* we want to be moveable regardless of our style */
 274     [self setMovableByWindowBackground: YES];
 275     [self setCanBecomeKeyWindow:YES];
 276
 277     o_temp_view = [[NSView alloc] init];
 278     [o_temp_view setAutoresizingMask:NSViewHeightSizable | NSViewWidthSizable];
 279
 280     return self;
 281 }
 282
 283 - (void)dealloc
 284 {
 285     [o_temp_view release];
 286     [super dealloc];
 287 }
 288
 289 - (void)awakeFromNib
 290 {
 291     BOOL b_nativeFullscreenMode = NO;
 292 #ifdef MAC_OS_X_VERSION_10_7
 293     if (!OSX_SNOW_LEOPARD)
 294         b_nativeFullscreenMode = var_InheritBool(VLCIntf, "macosx-nativefullscreenmode");
 295 #endif
 296
 297     if (b_nativeFullscreenMode) {
 298         [self setCollectionBehavior: NSWindowCollectionBehaviorFullScreenPrimary];
 299     } else {
 300         [o_titlebar_view setFullscreenButtonHidden: YES];
 301     }
 302
 303     [super awakeFromNib];
 304 }
 305
 306 - (void)setTitle:(NSString *)title
 307 {
 308     if (!title || [title length] < 1)
 309         return;
 310
 311     if (b_dark_interface && o_titlebar_view)
 312         [o_titlebar_view setWindowTitle: title];
 313
 314     [super setTitle: title];
 315 }
 316
 317 #pragma mark -
 318 #pragma mark zoom / minimize / close
 319
 320 - (BOOL)validateMenuItem:(NSMenuItem *)menuItem
 321 {
 322     SEL s_menuAction = [menuItem action];
 323
 324     if ((s_menuAction == @selector(performClose:)) || (s_menuAction == @selector(performMiniaturize:)) || (s_menuAction == @selector(performZoom:)))
 325         return YES;
 326
 327     return [super validateMenuItem:menuItem];
 328 }
 329
 330 - (BOOL)windowShouldClose:(id)sender
 331 {
 332     return YES;
 333 }
 334
 335 - (void)performClose:(id)sender
 336 {
 337     if (!([self styleMask] & NSTitledWindowMask)) {
 338         [[NSNotificationCenter defaultCenter] postNotificationName:NSWindowWillCloseNotification object:self];
 339
 340         [self close];
 341     } else
 342         [super performClose: sender];
 343 }
 344
 345 - (void)performMiniaturize:(id)sender
 346 {
 347     if (!([self styleMask] & NSTitledWindowMask))
 348         [self miniaturize: sender];
 349     else
 350         [super performMiniaturize: sender];
 351 }
 352
 353 - (void)performZoom:(id)sender
 354 {
 355     if (!([self styleMask] & NSTitledWindowMask))
 356         [self customZoom: sender];
 357     else
 358         [super performZoom: sender];
 359 }
 360
 361 - (void)zoom:(id)sender
 362 {
 363     if (!([self styleMask] & NSTitledWindowMask))
 364         [self customZoom: sender];
 365     else
 366         [super zoom: sender];
 367 }
 368
 369 /**
 370  * Given a proposed frame rectangle, return a modified version
 371  * which will fit inside the screen.
 372  *
 373  * This method is based upon NSWindow.m, part of the GNUstep GUI Library, licensed under LGPLv2+.
 374  *    Authors:  Scott Christley <scottc@net-community.com>, Venkat Ajjanagadde <venkat@ocbi.com>,
 375  *              Felipe A. Rodriguez <far@ix.netcom.com>, Richard Frith-Macdonald <richard@brainstorm.co.uk>
 376  *    Copyright (C) 1996 Free Software Foundation, Inc.
 377  */
 378 - (NSRect) customConstrainFrameRect: (NSRect)frameRect toScreen: (NSScreen*)screen
 379 {
 380     NSRect screenRect = [screen visibleFrame];
 381     float difference;
 382
 383     /* Move top edge of the window inside the screen */
 384     difference = NSMaxY (frameRect) - NSMaxY (screenRect);
 385     if (difference > 0) {
 386         frameRect.origin.y -= difference;
 387     }
 388
 389     /* If the window is resizable, resize it (if needed) so that the
 390      bottom edge is on the screen or can be on the screen when the user moves
 391      the window */
 392     difference = NSMaxY (screenRect) - NSMaxY (frameRect);
 393     if (_styleMask & NSResizableWindowMask) {
 394         float difference2;
 395
 396         difference2 = screenRect.origin.y - frameRect.origin.y;
 397         difference2 -= difference;
 398         // Take in account the space between the top of window and the top of the
 399         // screen which can be used to move the bottom of the window on the screen
 400         if (difference2 > 0) {
 401             frameRect.size.height -= difference2;
 402             frameRect.origin.y += difference2;
 403         }
 404
 405         /* Ensure that resizing doesn't makewindow smaller than minimum */
 406         difference2 = [self minSize].height - frameRect.size.height;
 407         if (difference2 > 0) {
 408             frameRect.size.height += difference2;
 409             frameRect.origin.y -= difference2;
 410         }
 411     }
 412
 413     return frameRect;
 414 }
 415
 416 #define DIST 3
 417
 418 /**
 419  Zooms the receiver.   This method calls the delegate method
 420  windowShouldZoom:toFrame: to determine if the window should
 421  be allowed to zoom to full screen.
 422  *
 423  * This method is based upon NSWindow.m, part of the GNUstep GUI Library, licensed under LGPLv2+.
 424  *    Authors:  Scott Christley <scottc@net-community.com>, Venkat Ajjanagadde <venkat@ocbi.com>,
 425  *              Felipe A. Rodriguez <far@ix.netcom.com>, Richard Frith-Macdonald <richard@brainstorm.co.uk>
 426  *    Copyright (C) 1996 Free Software Foundation, Inc.
 427  */
 428 - (void) customZoom: (id)sender
 429 {
 430     NSRect maxRect = [[self screen] visibleFrame];
 431     NSRect currentFrame = [self frame];
 432
 433     if ([[self delegate] respondsToSelector: @selector(windowWillUseStandardFrame:defaultFrame:)]) {
 434         maxRect = [[self delegate] windowWillUseStandardFrame: self defaultFrame: maxRect];
 435     }
 436
 437     maxRect = [self customConstrainFrameRect: maxRect toScreen: [self screen]];
 438
 439     // Compare the new frame with the current one
 440     if ((abs(NSMaxX(maxRect) - NSMaxX(currentFrame)) < DIST)
 441         && (abs(NSMaxY(maxRect) - NSMaxY(currentFrame)) < DIST)
 442         && (abs(NSMinX(maxRect) - NSMinX(currentFrame)) < DIST)
 443         && (abs(NSMinY(maxRect) - NSMinY(currentFrame)) < DIST)) {
 444         // Already in zoomed mode, reset user frame, if stored
 445         if ([self frameAutosaveName] != nil) {
 446             [self setFrame: previousSavedFrame display: YES animate: YES];
 447             [self saveFrameUsingName: [self frameAutosaveName]];
 448         }
 449         return;
 450     }
 451
 452     if ([self frameAutosaveName] != nil) {
 453         [self saveFrameUsingName: [self frameAutosaveName]];
 454         previousSavedFrame = [self frame];
 455     }
 456
 457     [self setFrame: maxRect display: YES animate: YES];
 458 }
 459
 460 #pragma mark -
 461 #pragma mark Video window resizing logic
 462
 463 - (void)setWindowLevel:(NSInteger)i_state
 464 {
 465     if (var_InheritBool(VLCIntf, "video-wallpaper") || [self level] < NSNormalWindowLevel)
 466         return;
 467
 468     [self setLevel: i_state];
 469
 470 }
 471
 472 - (NSRect)getWindowRectForProposedVideoViewSize:(NSSize)size
 473 {
 474     NSSize windowMinSize = [self minSize];
 475     NSRect screenFrame = [[self screen] visibleFrame];
 476
 477     NSPoint topleftbase = NSMakePoint(0, [self frame].size.height);
 478     NSPoint topleftscreen = [self convertBaseToScreen: topleftbase];
 479
 480     unsigned int i_width = size.width;
 481     unsigned int i_height = size.height;
 482     if (i_width < windowMinSize.width)
 483         i_width = windowMinSize.width;
 484     if (i_height < f_min_video_height)
 485         i_height = f_min_video_height;
 486
 487     /* Calculate the window's new size */
 488     NSRect new_frame;
 489     new_frame.size.width = [self frame].size.width - [o_video_view frame].size.width + i_width;
 490     new_frame.size.height = [self frame].size.height - [o_video_view frame].size.height + i_height;
 491     new_frame.origin.x = topleftscreen.x;
 492     new_frame.origin.y = topleftscreen.y - new_frame.size.height;
 493
 494     /* make sure the window doesn't exceed the screen size the window is on */
 495     if (new_frame.size.width > screenFrame.size.width) {
 496         new_frame.size.width = screenFrame.size.width;
 497         new_frame.origin.x = screenFrame.origin.x;
 498     }
 499     if (new_frame.size.height > screenFrame.size.height) {
 500         new_frame.size.height = screenFrame.size.height;
 501         new_frame.origin.y = screenFrame.origin.y;
 502     }
 503     if (new_frame.origin.y < screenFrame.origin.y)
 504         new_frame.origin.y = screenFrame.origin.y;
 505
 506     CGFloat right_screen_point = screenFrame.origin.x + screenFrame.size.width;
 507     CGFloat right_window_point = new_frame.origin.x + new_frame.size.width;
 508     if (right_window_point > right_screen_point)
 509         new_frame.origin.x -= (right_window_point - right_screen_point);
 510
 511     return new_frame;
 512 }
 513
 514 - (void)resizeWindow
 515 {
 516     if ([self fullscreen])
 517         return;
 518
 519     NSRect window_rect = [self getWindowRectForProposedVideoViewSize:nativeVideoSize];
 520     [[self animator] setFrame:window_rect display:YES];
 521 }
 522
 523 - (void)setNativeVideoSize:(NSSize)size
 524 {
 525     nativeVideoSize = size;
 526
 527     if (var_InheritBool(VLCIntf, "macosx-video-autoresize") && !var_InheritBool(VLCIntf, "video-wallpaper"))
 528         [self resizeWindow];
 529 }
 530
 531 - (NSSize)windowWillResize:(NSWindow *)window toSize:(NSSize)proposedFrameSize
 532 {
 533     if (![[VLCMain sharedInstance] activeVideoPlayback] || nativeVideoSize.width == 0. || nativeVideoSize.height == 0. || window != self)
 534         return proposedFrameSize;
 535
 536     // needed when entering lion fullscreen mode
 537     if (b_entering_fullscreen_transition || [self fullscreen])
 538         return proposedFrameSize;
 539
 540     if ([[VLCCoreInteraction sharedInstance] aspectRatioIsLocked]) {
 541         NSRect videoWindowFrame = [self frame];
 542         NSRect viewRect = [o_video_view convertRect:[o_video_view bounds] toView: nil];
 543         NSRect contentRect = [self contentRectForFrameRect:videoWindowFrame];
 544         float marginy = viewRect.origin.y + videoWindowFrame.size.height - contentRect.size.height;
 545         float marginx = contentRect.size.width - viewRect.size.width;
 546         if (o_titlebar_view && b_dark_interface)
 547             marginy += [o_titlebar_view frame].size.height;
 548
 549         proposedFrameSize.height = (proposedFrameSize.width - marginx) * nativeVideoSize.height / nativeVideoSize.width + marginy;
 550     }
 551
 552     return proposedFrameSize;
 553 }
 554
 555
 556 #pragma mark -
 557 #pragma mark Mouse cursor handling
 558
 559 //  NSTimer selectors require this function signature as per Apple's docs
 560 - (void)hideMouseCursor:(NSTimer *)timer
 561 {
 562     [NSCursor setHiddenUntilMouseMoves: YES];
 563 }
 564
 565 - (void)recreateHideMouseTimer
 566 {
 567     if (t_hide_mouse_timer != nil) {
 568         [t_hide_mouse_timer invalidate];
 569         [t_hide_mouse_timer release];
 570     }
 571
 572     t_hide_mouse_timer = [NSTimer scheduledTimerWithTimeInterval:2
 573                                                           target:self
 574                                                         selector:@selector(hideMouseCursor:)
 575                                                         userInfo:nil
 576                                                          repeats:NO];
 577     [t_hide_mouse_timer retain];
 578 }
 579
 580 //  Called automatically if window's acceptsMouseMovedEvents property is true
 581 - (void)mouseMoved:(NSEvent *)theEvent
 582 {
 583     if (b_fullscreen)
 584         [self recreateHideMouseTimer];
 585
 586     [super mouseMoved: theEvent];
 587 }
 588
 589 #pragma mark -
 590 #pragma mark Lion native fullscreen handling
 591
 592 - (void)becomeKeyWindow
 593 {
 594     [super becomeKeyWindow];
 595
 596     // change fspanel state for the case when multiple windows are in fullscreen
 597     if ([self hasActiveVideo] && [self fullscreen])
 598         [[[VLCMainWindow sharedInstance] fsPanel] setActive:nil];
 599     else
 600         [[[VLCMainWindow sharedInstance] fsPanel] setNonActive:nil];
 601 }
 602
 603 - (void)resignKeyWindow
 604 {
 605     [super resignKeyWindow];
 606
 607     [[[VLCMainWindow sharedInstance] fsPanel] setNonActive:nil];
 608 }
 609
 610 - (void)windowWillEnterFullScreen:(NSNotification *)notification
 611 {
 612     // workaround, see #6668
 613     [NSApp setPresentationOptions:(NSApplicationPresentationFullScreen | NSApplicationPresentationAutoHideDock | NSApplicationPresentationAutoHideMenuBar)];
 614
 615     b_entering_fullscreen_transition = YES;
 616
 617     var_SetBool(pl_Get(VLCIntf), "fullscreen", true);
 618
 619     if ([self hasActiveVideo]) {
 620         vout_thread_t *p_vout = getVoutForActiveWindow();
 621         if (p_vout) {
 622             var_SetBool(p_vout, "fullscreen", true);
 623             vlc_object_release(p_vout);
 624         }
 625     }
 626
 627     if ([self hasActiveVideo])
 628         [[VLCMainWindow sharedInstance] recreateHideMouseTimer];
 629
 630     i_originalLevel = [self level];
 631     [[[VLCMain sharedInstance] voutController] updateWindowLevelForHelperWindows: NSNormalWindowLevel];
 632     [self setLevel:NSNormalWindowLevel];
 633
 634     if (b_dark_interface) {
 635         [o_titlebar_view removeFromSuperviewWithoutNeedingDisplay];
 636
 637         NSRect winrect;
 638         CGFloat f_titleBarHeight = [o_titlebar_view frame].size.height;
 639         winrect = [self frame];
 640
 641         winrect.size.height = winrect.size.height - f_titleBarHeight;
 642         [self setFrame: winrect display:NO animate:NO];
 643     }
 644
 645     [o_video_view setFrame: [[self contentView] frame]];
 646     if (![o_video_view isHidden]) {
 647         [[o_controls_bar bottomBarView] setHidden: YES];
 648     }
 649
 650
 651     [self setMovableByWindowBackground: NO];
 652 }
 653
 654 - (void)windowDidEnterFullScreen:(NSNotification *)notification
 655 {
 656     // Indeed, we somehow can have an "inactive" fullscreen (but a visible window!).
 657     // But this creates some problems when leaving fs over remote intfs, so activate app here.
 658     [NSApp activateIgnoringOtherApps:YES];
 659
 660     [self setFullscreen: YES];
 661     b_entering_fullscreen_transition = NO;
 662
 663     if ([self hasActiveVideo]) {
 664         [[[VLCMainWindow sharedInstance] fsPanel] setVoutWasUpdated: self];
 665         if (![o_video_view isHidden])
 666             [[[VLCMainWindow sharedInstance] fsPanel] setActive: nil];
 667     }
 668
 669     NSArray *subviews = [[self videoView] subviews];
 670     NSUInteger count = [subviews count];
 671
 672     for (NSUInteger x = 0; x < count; x++) {
 673         if ([[subviews objectAtIndex:x] respondsToSelector:@selector(reshape)])
 674             [[subviews objectAtIndex:x] reshape];
 675     }
 676
 677 }
 678
 679 - (void)windowWillExitFullScreen:(NSNotification *)notification
 680 {
 681     [self setFullscreen: NO];
 682
 683     var_SetBool(pl_Get(VLCIntf), "fullscreen", false);
 684
 685     if ([self hasActiveVideo]) {
 686         vout_thread_t *p_vout = getVoutForActiveWindow();
 687         if (p_vout) {
 688             var_SetBool(p_vout, "fullscreen", false);
 689             vlc_object_release(p_vout);
 690         }
 691     }
 692
 693     [NSCursor setHiddenUntilMouseMoves: NO];
 694     [[[VLCMainWindow sharedInstance] fsPanel] setNonActive: nil];
 695
 696
 697     if (b_dark_interface) {
 698         NSRect winrect;
 699         CGFloat f_titleBarHeight = [o_titlebar_view frame].size.height;
 700
 701         winrect = [o_video_view frame];
 702         winrect.size.height -= f_titleBarHeight;
 703         [o_video_view setFrame: winrect];
 704
 705         winrect = [self frame];
 706         [o_titlebar_view setFrame: NSMakeRect(0, winrect.size.height - f_titleBarHeight,
 707                                               winrect.size.width, f_titleBarHeight)];
 708         [[self contentView] addSubview: o_titlebar_view];
 709
 710         winrect.size.height = winrect.size.height + f_titleBarHeight;
 711         [self setFrame: winrect display:NO animate:NO];
 712     }
 713
 714     NSRect videoViewFrame = [o_video_view frame];
 715     videoViewFrame.origin.y += [o_controls_bar height];
 716     videoViewFrame.size.height -= [o_controls_bar height];
 717     [o_video_view setFrame: videoViewFrame];
 718
 719     if (![o_video_view isHidden]) {
 720         [[o_controls_bar bottomBarView] setHidden: NO];
 721     }
 722
 723     [self setMovableByWindowBackground: YES];
 724 }
 725
 726 - (void)windowDidExitFullScreen:(NSNotification *)notification
 727 {
 728     [[[VLCMain sharedInstance] voutController] updateWindowLevelForHelperWindows: i_originalLevel];
 729     [self setLevel:i_originalLevel];
 730 }
 731
 732 #pragma mark -
 733 #pragma mark Fullscreen Logic
 734
 735 - (void)enterFullscreen
 736 {
 737     NSMutableDictionary *dict1, *dict2;
 738     NSScreen *screen;
 739     NSRect screen_rect;
 740     NSRect rect;
 741     BOOL blackout_other_displays = var_InheritBool(VLCIntf, "macosx-black");
 742
 743     screen = [NSScreen screenWithDisplayID:(CGDirectDisplayID)var_InheritInteger(VLCIntf, "macosx-vdev")];
 744
 745     if (!screen) {
 746         msg_Dbg(VLCIntf, "chosen screen isn't present, using current screen for fullscreen mode");
 747         screen = [self screen];
 748     }
 749     if (!screen) {
 750         msg_Dbg(VLCIntf, "Using deepest screen");
 751         screen = [NSScreen deepestScreen];
 752     }
 753
 754     screen_rect = [screen frame];
 755
 756     if (o_controls_bar)
 757         [o_controls_bar setFullscreenState:YES];
 758     [[[VLCMainWindow sharedInstance] controlsBar] setFullscreenState:YES];
 759
 760     [[VLCMainWindow sharedInstance] recreateHideMouseTimer];
 761
 762     if (blackout_other_displays)
 763         [screen blackoutOtherScreens];
 764
 765     /* Make sure we don't see the window flashes in float-on-top mode */
 766     i_originalLevel = [self level];
 767     [[[VLCMain sharedInstance] voutController] updateWindowLevelForHelperWindows: NSNormalWindowLevel];
 768     [self setLevel:NSNormalWindowLevel];
 769
 770
 771     /* Only create the o_fullscreen_window if we are not in the middle of the zooming animation */
 772     if (!o_fullscreen_window) {
 773         /* We can't change the styleMask of an already created NSWindow, so we create another window, and do eye catching stuff */
 774
 775         rect = [[o_video_view superview] convertRect: [o_video_view frame] toView: nil]; /* Convert to Window base coord */
 776         rect.origin.x += [self frame].origin.x;
 777         rect.origin.y += [self frame].origin.y;
 778         o_fullscreen_window = [[VLCWindow alloc] initWithContentRect:rect styleMask: NSBorderlessWindowMask backing:NSBackingStoreBuffered defer:YES];
 779         [o_fullscreen_window setBackgroundColor: [NSColor blackColor]];
 780         [o_fullscreen_window setCanBecomeKeyWindow: YES];
 781         [o_fullscreen_window setCanBecomeMainWindow: YES];
 782         [o_fullscreen_window setHasActiveVideo: YES];
 783         [o_fullscreen_window setFullscreen: YES];
 784
 785         if (![self isVisible] || [self alphaValue] == 0.0) {
 786             /* We don't animate if we are not visible, instead we
 787              * simply fade the display */
 788             CGDisplayFadeReservationToken token;
 789
 790             if (blackout_other_displays) {
 791                 CGAcquireDisplayFadeReservation(kCGMaxDisplayReservationInterval, &token);
 792                 CGDisplayFade(token, 0.5, kCGDisplayBlendNormal, kCGDisplayBlendSolidColor, 0, 0, 0, YES);
 793             }
 794
 795             [screen setFullscreenPresentationOptions];
 796
 797             [o_video_view retain];
 798             [[o_video_view superview] replaceSubview:o_video_view with:o_temp_view];
 799             [o_temp_view setFrame:[o_video_view frame]];
 800             [o_fullscreen_window setContentView:o_video_view];
 801             [o_video_view release];
 802
 803             [o_fullscreen_window makeKeyAndOrderFront:self];
 804             [o_fullscreen_window orderFront:self animate:YES];
 805
 806             [o_fullscreen_window setFrame:screen_rect display:YES animate:YES];
 807             [o_fullscreen_window setLevel:NSNormalWindowLevel];
 808
 809             if (blackout_other_displays) {
 810                 CGDisplayFade(token, 0.3, kCGDisplayBlendSolidColor, kCGDisplayBlendNormal, 0, 0, 0, NO);
 811                 CGReleaseDisplayFadeReservation(token);
 812             }
 813
 814             /* Will release the lock */
 815             [self hasBecomeFullscreen];
 816
 817             return;
 818         }
 819
 820         /* Make sure video view gets visible in case the playlist was visible before */
 821         b_video_view_was_hidden = [o_video_view isHidden];
 822         [o_video_view setHidden: NO];
 823
 824         /* Make sure we don't see the o_video_view disappearing of the screen during this operation */
 825         NSDisableScreenUpdates();
 826         [o_video_view retain];
 827         [[o_video_view superview] replaceSubview:o_video_view with:o_temp_view];
 828         [o_temp_view setFrame:[o_video_view frame]];
 829         [o_fullscreen_window setContentView:o_video_view];
 830         [o_video_view release];
 831         [o_fullscreen_window makeKeyAndOrderFront:self];
 832         NSEnableScreenUpdates();
 833     }
 834
 835     /* We are in fullscreen (and no animation is running) */
 836     if ([self fullscreen]) {
 837         /* Make sure we are hidden */
 838         [self orderOut: self];
 839
 840         return;
 841     }
 842
 843     if (o_fullscreen_anim1) {
 844         [o_fullscreen_anim1 stopAnimation];
 845         [o_fullscreen_anim1 release];
 846     }
 847     if (o_fullscreen_anim2) {
 848         [o_fullscreen_anim2 stopAnimation];
 849         [o_fullscreen_anim2 release];
 850     }
 851
 852     [screen setFullscreenPresentationOptions];
 853
 854     dict1 = [[NSMutableDictionary alloc] initWithCapacity:2];
 855     dict2 = [[NSMutableDictionary alloc] initWithCapacity:3];
 856
 857     [dict1 setObject:self forKey:NSViewAnimationTargetKey];
 858     [dict1 setObject:NSViewAnimationFadeOutEffect forKey:NSViewAnimationEffectKey];
 859
 860     [dict2 setObject:o_fullscreen_window forKey:NSViewAnimationTargetKey];
 861     [dict2 setObject:[NSValue valueWithRect:[o_fullscreen_window frame]] forKey:NSViewAnimationStartFrameKey];
 862     [dict2 setObject:[NSValue valueWithRect:screen_rect] forKey:NSViewAnimationEndFrameKey];
 863
 864     /* Strategy with NSAnimation allocation:
 865      - Keep at most 2 animation at a time
 866      - leaveFullscreen/enterFullscreen are the only responsible for releasing and alloc-ing
 867      */
 868     o_fullscreen_anim1 = [[NSViewAnimation alloc] initWithViewAnimations:[NSArray arrayWithObject:dict1]];
 869     o_fullscreen_anim2 = [[NSViewAnimation alloc] initWithViewAnimations:[NSArray arrayWithObject:dict2]];
 870
 871     [dict1 release];
 872     [dict2 release];
 873
 874     [o_fullscreen_anim1 setAnimationBlockingMode: NSAnimationNonblocking];
 875     [o_fullscreen_anim1 setDuration: 0.3];
 876     [o_fullscreen_anim1 setFrameRate: 30];
 877     [o_fullscreen_anim2 setAnimationBlockingMode: NSAnimationNonblocking];
 878     [o_fullscreen_anim2 setDuration: 0.2];
 879     [o_fullscreen_anim2 setFrameRate: 30];
 880
 881     [o_fullscreen_anim2 setDelegate: self];
 882     [o_fullscreen_anim2 startWhenAnimation: o_fullscreen_anim1 reachesProgress: 1.0];
 883
 884     [o_fullscreen_anim1 startAnimation];
 885     /* fullscreenAnimation will be unlocked when animation ends */
 886 }
 887
 888 - (void)hasBecomeFullscreen
 889 {
 890     if ([[o_video_view subviews] count] > 0)
 891         [o_fullscreen_window makeFirstResponder: [[o_video_view subviews] objectAtIndex:0]];
 892
 893     [o_fullscreen_window makeKeyWindow];
 894     [o_fullscreen_window setAcceptsMouseMovedEvents: YES];
 895
 896     /* tell the fspanel to move itself to front next time it's triggered */
 897     [[[VLCMainWindow sharedInstance] fsPanel] setVoutWasUpdated: o_fullscreen_window];
 898     [[[VLCMainWindow sharedInstance] fsPanel] setActive: nil];
 899
 900     if ([self isVisible])
 901         [self orderOut: self];
 902
 903     [self setFullscreen:YES];
 904 }
 905
 906 - (void)leaveFullscreen
 907 {
 908     [self leaveFullscreenAndFadeOut: NO];
 909 }
 910
 911 - (void)leaveFullscreenAndFadeOut: (BOOL)fadeout
 912 {
 913     NSMutableDictionary *dict1, *dict2;
 914     NSRect frame;
 915     BOOL blackout_other_displays = var_InheritBool(VLCIntf, "macosx-black");
 916
 917     if (o_controls_bar)
 918         [o_controls_bar setFullscreenState:NO];
 919     [[[VLCMainWindow sharedInstance] controlsBar] setFullscreenState:NO];
 920
 921     /* We always try to do so */
 922     [NSScreen unblackoutScreens];
 923
 924     [[o_video_view window] makeKeyAndOrderFront: nil];
 925
 926     /* Don't do anything if o_fullscreen_window is already closed */
 927     if (!o_fullscreen_window) {
 928         return;
 929     }
 930
 931     if (fadeout) {
 932         /* We don't animate if we are not visible, instead we
 933          * simply fade the display */
 934         CGDisplayFadeReservationToken token;
 935
 936         if (blackout_other_displays) {
 937             CGAcquireDisplayFadeReservation(kCGMaxDisplayReservationInterval, &token);
 938             CGDisplayFade(token, 0.3, kCGDisplayBlendNormal, kCGDisplayBlendSolidColor, 0, 0, 0, YES);
 939         }
 940
 941         [[[VLCMainWindow sharedInstance] fsPanel] setNonActive: nil];
 942         [[o_fullscreen_window screen] setNonFullscreenPresentationOptions];
 943
 944         /* Will release the lock */
 945         [self hasEndedFullscreen];
 946
 947         /* Our window is hidden, and might be faded. We need to workaround that, so note it
 948          * here */
 949         b_window_is_invisible = YES;
 950
 951         if (blackout_other_displays) {
 952             CGDisplayFade(token, 0.5, kCGDisplayBlendSolidColor, kCGDisplayBlendNormal, 0, 0, 0, NO);
 953             CGReleaseDisplayFadeReservation(token);
 954         }
 955
 956         return;
 957     }
 958
 959     [self setAlphaValue: 0.0];
 960     [self orderFront: self];
 961     [[o_video_view window] orderFront: self];
 962
 963     [[[VLCMainWindow sharedInstance] fsPanel] setNonActive: nil];
 964     [[o_fullscreen_window screen] setNonFullscreenPresentationOptions];
 965
 966     if (o_fullscreen_anim1) {
 967         [o_fullscreen_anim1 stopAnimation];
 968         [o_fullscreen_anim1 release];
 969     }
 970     if (o_fullscreen_anim2) {
 971         [o_fullscreen_anim2 stopAnimation];
 972         [o_fullscreen_anim2 release];
 973     }
 974
 975     frame = [[o_temp_view superview] convertRect: [o_temp_view frame] toView: nil]; /* Convert to Window base coord */
 976     frame.origin.x += [self frame].origin.x;
 977     frame.origin.y += [self frame].origin.y;
 978
 979     dict2 = [[NSMutableDictionary alloc] initWithCapacity:2];
 980     [dict2 setObject:self forKey:NSViewAnimationTargetKey];
 981     [dict2 setObject:NSViewAnimationFadeInEffect forKey:NSViewAnimationEffectKey];
 982
 983     o_fullscreen_anim2 = [[NSViewAnimation alloc] initWithViewAnimations:[NSArray arrayWithObject:dict2]];
 984     [dict2 release];
 985
 986     [o_fullscreen_anim2 setAnimationBlockingMode: NSAnimationNonblocking];
 987     [o_fullscreen_anim2 setDuration: 0.3];
 988     [o_fullscreen_anim2 setFrameRate: 30];
 989
 990     [o_fullscreen_anim2 setDelegate: self];
 991
 992     dict1 = [[NSMutableDictionary alloc] initWithCapacity:3];
 993
 994     [dict1 setObject:o_fullscreen_window forKey:NSViewAnimationTargetKey];
 995     [dict1 setObject:[NSValue valueWithRect:[o_fullscreen_window frame]] forKey:NSViewAnimationStartFrameKey];
 996     [dict1 setObject:[NSValue valueWithRect:frame] forKey:NSViewAnimationEndFrameKey];
 997
 998     o_fullscreen_anim1 = [[NSViewAnimation alloc] initWithViewAnimations:[NSArray arrayWithObject:dict1]];
 999     [dict1 release];
1000
1001     [o_fullscreen_anim1 setAnimationBlockingMode: NSAnimationNonblocking];
1002     [o_fullscreen_anim1 setDuration: 0.2];
1003     [o_fullscreen_anim1 setFrameRate: 30];
1004     [o_fullscreen_anim2 startWhenAnimation: o_fullscreen_anim1 reachesProgress: 1.0];
1005
1006     /* Make sure o_fullscreen_window is the frontmost window */
1007     [o_fullscreen_window orderFront: self];
1008
1009     [o_fullscreen_anim1 startAnimation];
1010     /* fullscreenAnimation will be unlocked when animation ends */
1011 }
1012
1013 - (void)hasEndedFullscreen
1014 {
1015     [self setFullscreen:NO];
1016
1017     /* This function is private and should be only triggered at the end of the fullscreen change animation */
1018     /* Make sure we don't see the o_video_view disappearing of the screen during this operation */
1019     NSDisableScreenUpdates();
1020     [o_video_view retain];
1021     [o_video_view removeFromSuperviewWithoutNeedingDisplay];
1022     [[o_temp_view superview] replaceSubview:o_temp_view with:o_video_view];
1023     [o_video_view release];
1024     [o_video_view setFrame:[o_temp_view frame]];
1025     if ([[o_video_view subviews] count] > 0)
1026         [self makeFirstResponder: [[o_video_view subviews] objectAtIndex:0]];
1027
1028     [o_video_view setHidden: b_video_view_was_hidden];
1029
1030     [super makeKeyAndOrderFront:self]; /* our version (in main window) contains a workaround */
1031
1032     [o_fullscreen_window orderOut: self];
1033     NSEnableScreenUpdates();
1034
1035     [o_fullscreen_window release];
1036     o_fullscreen_window = nil;
1037
1038     [[[VLCMain sharedInstance] voutController] updateWindowLevelForHelperWindows: i_originalLevel];
1039     [self setLevel:i_originalLevel];
1040     [self setAlphaValue: config_GetFloat(VLCIntf, "macosx-opaqueness")];
1041
1042     // if we quit fullscreen because there is no video anymore, make sure non-embedded window is not visible
1043     if (![[VLCMain sharedInstance] activeVideoPlayback] && [self class] != [VLCMainWindow class])
1044         [self orderOut: self];
1045 }
1046
1047 - (void)animationDidEnd:(NSAnimation*)animation
1048 {
1049     NSArray *viewAnimations;
1050     if (o_makekey_anim == animation) {
1051         [o_makekey_anim release];
1052         return;
1053     }
1054     if ([animation currentValue] < 1.0)
1055         return;
1056
1057     /* Fullscreen ended or started (we are a delegate only for leaveFullscreen's/enterFullscren's anim2) */
1058     viewAnimations = [o_fullscreen_anim2 viewAnimations];
1059     if ([viewAnimations count] >=1 &&
1060         [[[viewAnimations objectAtIndex:0] objectForKey: NSViewAnimationEffectKey] isEqualToString:NSViewAnimationFadeInEffect]) {
1061         /* Fullscreen ended */
1062         [self hasEndedFullscreen];
1063     } else
1064     /* Fullscreen started */
1065         [self hasBecomeFullscreen];
1066 }
1067
1068 - (void)orderOut:(id)sender
1069 {
1070     [super orderOut:sender];
1071
1072     /*
1073      * TODO reimplement leaveFullscreenAndFadeOut:YES, or remove code
1074      * and the hack below
1075
1076     if (![NSStringFromClass([self class]) isEqualToString:@"VLCMainWindow"]) {
1077         [self leaveFullscreenAndFadeOut:YES];
1078     }
1079      */
1080 }
1081
1082 - (void)makeKeyAndOrderFront: (id)sender
1083 {
1084     /* Hack
1085      * when we exit fullscreen and fade out, we may endup in
1086      * having a window that is faded. We can't have it fade in unless we
1087      * animate again. */
1088
1089     if (!b_window_is_invisible) {
1090         /* Make sure we don't do it too much */
1091         [super makeKeyAndOrderFront: sender];
1092         return;
1093     }
1094
1095     [super setAlphaValue:0.0f];
1096     [super makeKeyAndOrderFront: sender];
1097
1098     NSMutableDictionary * dict = [[NSMutableDictionary alloc] initWithCapacity:2];
1099     [dict setObject:self forKey:NSViewAnimationTargetKey];
1100     [dict setObject:NSViewAnimationFadeInEffect forKey:NSViewAnimationEffectKey];
1101
1102     o_makekey_anim = [[NSViewAnimation alloc] initWithViewAnimations:[NSArray arrayWithObject:dict]];
1103     [dict release];
1104
1105     [o_makekey_anim setAnimationBlockingMode: NSAnimationNonblocking];
1106     [o_makekey_anim setDuration: 0.1];
1107     [o_makekey_anim setFrameRate: 30];
1108     [o_makekey_anim setDelegate: self];
1109
1110     [o_makekey_anim startAnimation];
1111     b_window_is_invisible = NO;
1112
1113     /* fullscreenAnimation will be unlocked when animation ends */
1114 }
1115
1116
1117 #pragma mark -
1118 #pragma mark Accessibility stuff
1119
1120 - (NSArray *)accessibilityAttributeNames
1121 {
1122     if (!b_dark_interface || !o_titlebar_view)
1123         return [super accessibilityAttributeNames];
1124
1125     static NSMutableArray *attributes = nil;
1126     if (attributes == nil) {
1127         attributes = [[super accessibilityAttributeNames] mutableCopy];
1128         NSArray *appendAttributes = [NSArray arrayWithObjects:NSAccessibilitySubroleAttribute,
1129                                      NSAccessibilityCloseButtonAttribute,
1130                                      NSAccessibilityMinimizeButtonAttribute,
1131                                      NSAccessibilityZoomButtonAttribute, nil];
1132
1133         for(NSString *attribute in appendAttributes) {
1134             if (![attributes containsObject:attribute])
1135                 [attributes addObject:attribute];
1136         }
1137     }
1138     return attributes;
1139 }
1140
1141 - (id)accessibilityAttributeValue: (NSString*)o_attribute_name
1142 {
1143     if (b_dark_interface && o_titlebar_view) {
1144         VLCMainWindowTitleView *o_tbv = o_titlebar_view;
1145
1146         if ([o_attribute_name isEqualTo: NSAccessibilitySubroleAttribute])
1147             return NSAccessibilityStandardWindowSubrole;
1148
1149         if ([o_attribute_name isEqualTo: NSAccessibilityCloseButtonAttribute])
1150             return [[o_tbv closeButton] cell];
1151
1152         if ([o_attribute_name isEqualTo: NSAccessibilityMinimizeButtonAttribute])
1153             return [[o_tbv minimizeButton] cell];
1154
1155         if ([o_attribute_name isEqualTo: NSAccessibilityZoomButtonAttribute])
1156             return [[o_tbv zoomButton] cell];
1157     }
1158
1159     return [super accessibilityAttributeValue: o_attribute_name];
1160 }
1161
1162 @end