#import "CoreInteraction.h"
#import "AudioEffects.h"
#import "MainMenu.h"
-#import "misc.h"
+#import "open.h"
#import "controls.h" // TODO: remove me
#import "SideBarItem.h"
#import <vlc_playlist.h>
return _o_sharedInstance;
}
else
+ {
+ o_fspanel = [[VLCFSPanel alloc] init];
_o_sharedInstance = [super init];
+ }
return _o_sharedInstance;
}
[o_volume_down_btn setToolTip: _NS("Mute")];
[o_volume_up_btn setToolTip: _NS("Full Volume")];
[o_time_sld setToolTip: _NS("Position")];
+ [o_dropzone_btn setTitle: _NS("Open media...")];
+ [o_dropzone_lbl setStringValue: _NS("Drop media here")];
if (!b_dark_interface) {
[o_bottombar_view setImage: [NSImage imageNamed:@"bottom-background"]];
[o_play_btn setAlternateImage: o_play_pressed_img];
/* interface builder action */
- [o_video_view setFrame: [o_split_view frame]];
[self setDelegate: self];
[self setExcludedFromWindowsMenu: YES];
// Set that here as IB seems to be buggy
- [self setContentMinSize:NSMakeSize(500., 200.)];
+ [self setContentMinSize:NSMakeSize(500., 288.)];
[self setTitle: _NS("VLC media player")];
[o_playlist_btn setEnabled:NO];
-
- /* reset the interface */
- [self updateVolumeSlider];
- [self updateTimeSlider];
+ [o_video_view setFrame: [o_split_view frame]];
+ o_temp_view = [[NSView alloc] init];
+ [o_temp_view setAutoresizingMask:NSViewHeightSizable | NSViewWidthSizable];
+ [o_dropzone_view setFrame: [o_playlist_table frame]];
/* create the sidebar */
o_sidebaritems = [[NSMutableArray alloc] init];
SideBarItem *libraryItem = [SideBarItem itemWithTitle:_NS("LIBRARY") identifier:@"library"];
SideBarItem *playlistItem = [SideBarItem itemWithTitle:_NS("Playlist") identifier:@"playlist"];
+ [playlistItem setIcon: [NSImage imageNamed:@"document-music-playlist"]];
SideBarItem *mycompItem = [SideBarItem itemWithTitle:_NS("MY COMPUTER") identifier:@"mycomputer"];
SideBarItem *devicesItem = [SideBarItem itemWithTitle:_NS("DEVICES") identifier:@"devices"];
SideBarItem *lanItem = [SideBarItem itemWithTitle:_NS("LOCAL NETWORK") identifier:@"localnetwork"];
NSMutableArray *devicesItems = [[NSMutableArray alloc] init];
NSMutableArray *lanItems = [[NSMutableArray alloc] init];
NSMutableArray *mycompItems = [[NSMutableArray alloc] init];
+ NSString *o_identifier;
for (; *ppsz_name; ppsz_name++, ppsz_longname++, p_category++)
{
+ o_identifier = [NSString stringWithCString: *ppsz_name encoding: NSUTF8StringEncoding];
+ o_identifier = [[o_identifier componentsSeparatedByString:@"{"] objectAtIndex:0];
switch (*p_category) {
case SD_CAT_INTERNET:
- [internetItems addObject: [SideBarItem itemWithTitle: [NSString stringWithCString: *ppsz_longname encoding: NSUTF8StringEncoding] identifier: [NSString stringWithCString: *ppsz_name encoding: NSUTF8StringEncoding]]];
+ {
+ [internetItems addObject: [SideBarItem itemWithTitle: [NSString stringWithCString: *ppsz_longname encoding: NSUTF8StringEncoding] identifier: o_identifier]];
+ if (!strncmp( *ppsz_name, "podcast", 7 ))
+ [[internetItems lastObject] setIcon: [NSImage imageNamed:@"film-cast"]];
+ else
+ [[internetItems lastObject] setIcon: [NSImage imageNamed:@"NSApplicationIcon"]];
+ }
break;
case SD_CAT_DEVICES:
- [devicesItems addObject: [SideBarItem itemWithTitle: [NSString stringWithCString: *ppsz_longname encoding: NSUTF8StringEncoding] identifier: [NSString stringWithCString: *ppsz_name encoding: NSUTF8StringEncoding]]];
+ {
+ [devicesItems addObject: [SideBarItem itemWithTitle: [NSString stringWithCString: *ppsz_longname encoding: NSUTF8StringEncoding] identifier: o_identifier]];
+ [[devicesItems lastObject] setIcon: [NSImage imageNamed:@"NSApplicationIcon"]];
+ }
break;
case SD_CAT_LAN:
- [lanItems addObject: [SideBarItem itemWithTitle: [NSString stringWithCString: *ppsz_longname encoding: NSUTF8StringEncoding] identifier: [NSString stringWithCString: *ppsz_name encoding: NSUTF8StringEncoding]]];
+ {
+ [lanItems addObject: [SideBarItem itemWithTitle: [NSString stringWithCString: *ppsz_longname encoding: NSUTF8StringEncoding] identifier: o_identifier]];
+ [[lanItems lastObject] setIcon: [NSImage imageNamed:@"network-cloud"]];
+ }
break;
case SD_CAT_MYCOMPUTER:
- [mycompItems addObject: [SideBarItem itemWithTitle: [NSString stringWithCString: *ppsz_longname encoding: NSUTF8StringEncoding] identifier: [NSString stringWithCString: *ppsz_name encoding: NSUTF8StringEncoding]]];
+ {
+ [mycompItems addObject: [SideBarItem itemWithTitle: [NSString stringWithCString: *ppsz_longname encoding: NSUTF8StringEncoding] identifier: o_identifier]];
+ if (!strncmp( *ppsz_name, "video_dir", 9 ))
+ [[mycompItems lastObject] setIcon: [NSImage imageNamed:@"film"]];
+ else if (!strncmp( *ppsz_name, "audio_dir", 9 ))
+ [[mycompItems lastObject] setIcon: [NSImage imageNamed:@"music-beam"]];
+ else if (!strncmp( *ppsz_name, "picture_dir", 11 ))
+ [[mycompItems lastObject] setIcon: [NSImage imageNamed:@"picture"]];
+ else
+ [[mycompItems lastObject] setIcon: [NSImage imageNamed:@"NSApplicationIcon"]];
+ }
break;
default:
msg_Warn( VLCIntf, "unknown SD type found, skipping (%s)", *ppsz_name );
if ([internetItem hasChildren])
[o_sidebaritems addObject: internetItem];
- msg_Dbg( VLCIntf, "side bar should contain %lu items", [o_sidebaritems count] );
[o_sidebar_view reloadData];
+ [o_sidebar_view selectRowIndexes:[NSIndexSet indexSetWithIndex:0] byExtendingSelection:YES];
}
#pragma mark -
- (IBAction)togglePlaylist:(id)sender
{
if ([o_video_view isHidden] && [o_playlist_btn isEnabled]) {
- [o_video_view setHidden: NO];
[o_playlist_table setHidden: YES];
+ [o_video_view setHidden: NO];
}
else
{
- [o_playlist_table setHidden: NO];
[o_video_view setHidden: YES];
+ [o_playlist_table setHidden: NO];
}
}
o_time = [NSString stringWithUTF8String: secstotimestr( psz_time, (time.i_time / 1000000) )];
[o_time_fld setStringValue: o_time];
- [[[[VLCMain sharedInstance] controls] fspanel] setStreamPos: f_updated andTime: o_time];
+ [o_fspanel setStreamPos: f_updated andTime: o_time];
vlc_object_release( p_input );
}
[self drawFancyGradientEffectForTimeSlider];
- (IBAction)fullscreen:(id)sender
{
- NSLog( @"fullscreen mode not yet implemented" );
[[VLCCoreInteraction sharedInstance] toggleFullscreen];
}
+- (IBAction)dropzoneButtonAction:(id)sender
+{
+ [[[VLCMain sharedInstance] open] openFileGeneric];
+}
+
#pragma mark -
#pragma mark Update interface and respond to foreign events
+- (void)showDropZone
+{
+ [o_right_split_view addSubview: o_dropzone_view];
+ [o_dropzone_view setFrame: [o_playlist_table frame]];
+ [[o_playlist_table animator] setHidden:YES];
+}
+
+- (void)hideDropZone
+{
+ [o_dropzone_view removeFromSuperview];
+ [[o_playlist_table animator] setHidden: NO];
+}
+
- (void)updateTimeSlider
{
input_thread_t * p_input;
[o_time_fld setStringValue: o_time];
[o_time_fld setNeedsDisplay:YES];
-// [[[[VLCMain sharedInstance] controls] fspanel] setStreamPos: f_updated andTime: o_time];
+ [o_fspanel setStreamPos: f_updated andTime: o_time];
vlc_object_release( p_input );
}
else
int i_volume_step = 0;
i_volume_step = config_GetInt( VLCIntf->p_libvlc, "volume-step" );
[o_volume_sld setFloatValue: (float)i_lastShownVolume / i_volume_step];
-// [[[[VLCMain sharedInstance] controls] fspanel] setVolumeLevel: (float)i_lastShownVolume / i_volume_step];
+ [o_fspanel setVolumeLevel: (float)i_lastShownVolume / i_volume_step];
}
}
char *uri = input_item_GetURI( input_GetItem( p_input ) );
- if ([aString isEqualToString:@""])
- {
-
- char *file = uri ? strrchr( uri, '/' ) : NULL;
- if( file != NULL )
- {
- decode_URI( ++file );
- aString = [NSString stringWithUTF8String:file];
- }
- else
- aString = [NSString stringWithUTF8String:uri];
- }
-
- NSMutableString *o_mrl = [NSMutableString stringWithUTF8String: decode_URI(uri)];
+ NSURL * o_url = [NSURL URLWithString: [NSString stringWithUTF8String: uri]];
+ if ([o_url isFileURL])
+ [self setRepresentedURL: o_url];
+ else
+ [self setRepresentedURL: [NSURL URLWithString:@""]];
free( uri );
- NSRange prefix_range = [o_mrl rangeOfString: @"file:"];
- if( prefix_range.location != NSNotFound )
- [o_mrl deleteCharactersInRange: prefix_range];
- if( [o_mrl characterAtIndex:0] == '/' )
- {
- /* it's a local file */
- [self setRepresentedFilename: o_mrl];
- }
- else
+ if ([aString isEqualToString:@""])
{
- /* it's from the network or somewhere else,
- * we clear the previous path */
- [self setRepresentedFilename: @""];
+ if ([o_url isFileURL])
+ aString = [[NSFileManager defaultManager] displayNameAtPath: [o_url path]];
+ else
+ aString = [o_url absoluteString];
}
[self setTitle: aString];
- [[[[VLCMain sharedInstance] controls] fspanel] setStreamTitle: aString];
+ [o_fspanel setStreamTitle: aString];
}
else
{
[self setTitle: _NS("VLC media player")];
- [self setRepresentedFilename: @""];
+ [self setRepresentedURL: [NSURL URLWithString: @""]];
}
[o_pool release];
}
[o_bwd_btn setEnabled: (b_seekable || b_plmul || b_chapters)];
[[VLCMainMenu sharedInstance] setRateControlsEnabled: b_control];
-
[o_time_sld setEnabled: b_seekable];
[self updateTimeSlider];
- [[[[VLCMain sharedInstance] controls] fspanel] setSeekable: b_seekable];
+ [o_fspanel setSeekable: b_seekable];
+
+ PL_LOCK;
+ if (playlist_CurrentSize( p_playlist ) >= 1)
+ [self hideDropZone];
+ else
+ [self showDropZone];
+ PL_UNLOCK;
}
- (void)setPause
[o_play_btn setImage: o_pause_img];
[o_play_btn setAlternateImage: o_pause_pressed_img];
[o_play_btn setToolTip: _NS("Pause")];
+ [o_fspanel setPause];
}
- (void)setPlay
[o_play_btn setImage: o_play_img];
[o_play_btn setAlternateImage: o_play_pressed_img];
[o_play_btn setToolTip: _NS("Play")];
+ [o_fspanel setPlay];
}
- (void)drawFancyGradientEffectForTimeSlider
[o_playlist_btn setEnabled: [[VLCMain sharedInstance] activeVideoPlayback]];
}
+- (void)resizeWindow
+{
+ if ( !b_fullscreen )
+ {
+ NSPoint topleftbase;
+ NSPoint topleftscreen;
+ NSRect new_frame;
+ topleftbase.x = 0;
+ topleftbase.y = [self frame].size.height;
+ topleftscreen = [self convertBaseToScreen: topleftbase];
+
+ /* Calculate the window's new size */
+ new_frame.size.width = [self frame].size.width - [o_video_view frame].size.width + nativeVideoSize.width;
+ new_frame.size.height = [self frame].size.height - [o_video_view frame].size.height + nativeVideoSize.height;
+
+ new_frame.origin.x = topleftscreen.x;
+ new_frame.origin.y = topleftscreen.y - new_frame.size.height;
+
+ [[self animator] setFrame:new_frame display:YES];
+ }
+}
+
+- (void)setNativeVideoSize:(NSSize)size
+{
+ if (size.width != nativeVideoSize.width || size.height != nativeVideoSize.height )
+ {
+ nativeVideoSize = size;
+ [self resizeWindow];
+ }
+}
+
+#pragma mark -
+#pragma mark Fullscreen support
+- (void)showFullscreenController
+{
+ if (b_fullscreen)
+ [o_fspanel fadeIn];
+}
+
+- (BOOL)isFullscreen
+{
+ return b_fullscreen;
+}
+
+- (void)lockFullscreenAnimation
+{
+ [o_animation_lock lock];
+}
+
+- (void)unlockFullscreenAnimation
+{
+ [o_animation_lock unlock];
+}
+
+- (void)enterFullscreen
+{
+ NSMutableDictionary *dict1, *dict2;
+ NSScreen *screen;
+ NSRect screen_rect;
+ NSRect rect;
+ vout_thread_t *p_vout = getVout();
+ BOOL blackout_other_displays = config_GetInt( VLCIntf, "macosx-black" );
+
+ if( p_vout )
+ screen = [NSScreen screenWithDisplayID:(CGDirectDisplayID)var_GetInteger( p_vout, "video-device" )];
+
+ [self lockFullscreenAnimation];
+
+ if (!screen)
+ {
+ msg_Dbg( VLCIntf, "chosen screen isn't present, using current screen for fullscreen mode" );
+ screen = [self screen];
+ }
+ if (!screen)
+ {
+ msg_Dbg( VLCIntf, "Using deepest screen" );
+ screen = [NSScreen deepestScreen];
+ }
+
+ if( p_vout )
+ vlc_object_release( p_vout );
+
+ screen_rect = [screen frame];
+
+ [o_fullscreen_btn setState: YES];
+
+ [NSCursor setHiddenUntilMouseMoves: YES];
+
+ if( blackout_other_displays )
+ [screen blackoutOtherScreens];
+
+ /* Make sure we don't see the window flashes in float-on-top mode */
+ i_originalLevel = [self level];
+ [self setLevel:NSNormalWindowLevel];
+
+ /* Only create the o_fullscreen_window if we are not in the middle of the zooming animation */
+ if (!o_fullscreen_window)
+ {
+ /* We can't change the styleMask of an already created NSWindow, so we create another window, and do eye catching stuff */
+
+ rect = [[o_video_view superview] convertRect: [o_video_view frame] toView: nil]; /* Convert to Window base coord */
+ rect.origin.x += [self frame].origin.x;
+ rect.origin.y += [self frame].origin.y;
+ o_fullscreen_window = [[VLCWindow alloc] initWithContentRect:rect styleMask: NSBorderlessWindowMask backing:NSBackingStoreBuffered defer:YES];
+ [o_fullscreen_window setBackgroundColor: [NSColor blackColor]];
+ [o_fullscreen_window setCanBecomeKeyWindow: YES];
+
+ if (![self isVisible] || [self alphaValue] == 0.0)
+ {
+ /* We don't animate if we are not visible, instead we
+ * simply fade the display */
+ CGDisplayFadeReservationToken token;
+
+ if( blackout_other_displays )
+ {
+ CGAcquireDisplayFadeReservation( kCGMaxDisplayReservationInterval, &token );
+ CGDisplayFade( token, 0.5, kCGDisplayBlendNormal, kCGDisplayBlendSolidColor, 0, 0, 0, YES );
+ }
+
+ if ([screen isMainScreen])
+ SetSystemUIMode( kUIModeAllHidden, kUIOptionAutoShowMenuBar);
+
+ [[o_video_view superview] replaceSubview:o_video_view with:o_temp_view];
+ [o_temp_view setFrame:[o_video_view frame]];
+ [o_fullscreen_window setContentView:o_video_view];
+
+ [o_fullscreen_window makeKeyAndOrderFront:self];
+ [o_fullscreen_window orderFront:self animate:YES];
+
+ [o_fullscreen_window setFrame:screen_rect display:YES animate:YES];
+ [o_fullscreen_window setLevel:NSNormalWindowLevel];
+
+ if( blackout_other_displays )
+ {
+ CGDisplayFade( token, 0.3, kCGDisplayBlendSolidColor, kCGDisplayBlendNormal, 0, 0, 0, NO );
+ CGReleaseDisplayFadeReservation( token );
+ }
+
+ /* Will release the lock */
+ [self hasBecomeFullscreen];
+
+ return;
+ }
+
+ /* Make sure we don't see the o_video_view disappearing of the screen during this operation */
+ NSDisableScreenUpdates();
+ [[o_video_view superview] replaceSubview:o_video_view with:o_temp_view];
+ [o_temp_view setFrame:[o_video_view frame]];
+ [o_fullscreen_window setContentView:o_video_view];
+ [o_fullscreen_window makeKeyAndOrderFront:self];
+ NSEnableScreenUpdates();
+ }
+
+ /* We are in fullscreen (and no animation is running) */
+ if (b_fullscreen)
+ {
+ /* Make sure we are hidden */
+ [super orderOut: self];
+ [self unlockFullscreenAnimation];
+ return;
+ }
+
+ if (o_fullscreen_anim1)
+ {
+ [o_fullscreen_anim1 stopAnimation];
+ [o_fullscreen_anim1 release];
+ }
+ if (o_fullscreen_anim2)
+ {
+ [o_fullscreen_anim2 stopAnimation];
+ [o_fullscreen_anim2 release];
+ }
+
+ if ([screen isMainScreen])
+ SetSystemUIMode( kUIModeAllHidden, kUIOptionAutoShowMenuBar);
+
+ dict1 = [[NSMutableDictionary alloc] initWithCapacity:2];
+ dict2 = [[NSMutableDictionary alloc] initWithCapacity:3];
+
+ [dict1 setObject:self forKey:NSViewAnimationTargetKey];
+ [dict1 setObject:NSViewAnimationFadeOutEffect forKey:NSViewAnimationEffectKey];
+
+ [dict2 setObject:o_fullscreen_window forKey:NSViewAnimationTargetKey];
+ [dict2 setObject:[NSValue valueWithRect:[o_fullscreen_window frame]] forKey:NSViewAnimationStartFrameKey];
+ [dict2 setObject:[NSValue valueWithRect:screen_rect] forKey:NSViewAnimationEndFrameKey];
+
+ /* Strategy with NSAnimation allocation:
+ - Keep at most 2 animation at a time
+ - leaveFullscreen/enterFullscreen are the only responsible for releasing and alloc-ing
+ */
+ o_fullscreen_anim1 = [[NSViewAnimation alloc] initWithViewAnimations:[NSArray arrayWithObject:dict1]];
+ o_fullscreen_anim2 = [[NSViewAnimation alloc] initWithViewAnimations:[NSArray arrayWithObject:dict2]];
+
+ [dict1 release];
+ [dict2 release];
+
+ [o_fullscreen_anim1 setAnimationBlockingMode: NSAnimationNonblocking];
+ [o_fullscreen_anim1 setDuration: 0.3];
+ [o_fullscreen_anim1 setFrameRate: 30];
+ [o_fullscreen_anim2 setAnimationBlockingMode: NSAnimationNonblocking];
+ [o_fullscreen_anim2 setDuration: 0.2];
+ [o_fullscreen_anim2 setFrameRate: 30];
+
+ [o_fullscreen_anim2 setDelegate: self];
+ [o_fullscreen_anim2 startWhenAnimation: o_fullscreen_anim1 reachesProgress: 1.0];
+
+ [o_fullscreen_anim1 startAnimation];
+ /* fullscreenAnimation will be unlocked when animation ends */
+}
+
+- (void)hasBecomeFullscreen
+{
+ [o_fullscreen_window makeFirstResponder: o_video_view];
+
+ [o_fullscreen_window makeKeyWindow];
+ [o_fullscreen_window setAcceptsMouseMovedEvents: TRUE];
+
+ /* tell the fspanel to move itself to front next time it's triggered */
+ [o_fspanel setVoutWasUpdated: (int)[[o_fullscreen_window screen] displayID]];
+ [o_fspanel setActive: nil];
+
+ if([self isVisible])
+ [super orderOut: self];
+
+ [o_fspanel setActive: nil];
+
+ b_fullscreen = YES;
+ [self unlockFullscreenAnimation];
+}
+
+- (void)leaveFullscreen
+{
+ [self leaveFullscreenAndFadeOut: NO];
+}
+
+- (void)leaveFullscreenAndFadeOut: (BOOL)fadeout
+{
+ NSMutableDictionary *dict1, *dict2;
+ NSRect frame;
+ BOOL blackout_other_displays = config_GetInt( VLCIntf, "macosx-black" );
+
+ [self lockFullscreenAnimation];
+
+ b_fullscreen = NO;
+ [o_fullscreen_btn setState: NO];
+
+ /* We always try to do so */
+ [NSScreen unblackoutScreens];
+ vout_thread_t *p_vout = getVout();
+ if (p_vout)
+ {
+ if( var_GetBool( p_vout, "video-on-top" ) )
+ [self setLevel: NSStatusWindowLevel];
+ else
+ [self setLevel: NSNormalWindowLevel];
+ vlc_object_release( p_vout );
+ }
+ [self makeKeyAndOrderFront: nil];
+
+ /* Don't do anything if o_fullscreen_window is already closed */
+ if (!o_fullscreen_window)
+ {
+ [self unlockFullscreenAnimation];
+ return;
+ }
+
+ if (fadeout)
+ {
+ /* We don't animate if we are not visible, instead we
+ * simply fade the display */
+ CGDisplayFadeReservationToken token;
+
+ if( blackout_other_displays )
+ {
+ CGAcquireDisplayFadeReservation( kCGMaxDisplayReservationInterval, &token );
+ CGDisplayFade( token, 0.3, kCGDisplayBlendNormal, kCGDisplayBlendSolidColor, 0, 0, 0, YES );
+ }
+
+ [o_fspanel setNonActive: nil];
+ SetSystemUIMode( kUIModeNormal, kUIOptionAutoShowMenuBar);
+
+ /* Will release the lock */
+ [self hasEndedFullscreen];
+
+ /* Our window is hidden, and might be faded. We need to workaround that, so note it
+ * here */
+ b_window_is_invisible = YES;
+
+ if( blackout_other_displays )
+ {
+ CGDisplayFade( token, 0.5, kCGDisplayBlendSolidColor, kCGDisplayBlendNormal, 0, 0, 0, NO );
+ CGReleaseDisplayFadeReservation( token );
+ }
+
+ return;
+ }
+
+ [self setAlphaValue: 0.0];
+ [self orderFront: self];
+
+ [o_fspanel setNonActive: nil];
+ SetSystemUIMode( kUIModeNormal, kUIOptionAutoShowMenuBar);
+
+ if (o_fullscreen_anim1)
+ {
+ [o_fullscreen_anim1 stopAnimation];
+ [o_fullscreen_anim1 release];
+ }
+ if (o_fullscreen_anim2)
+ {
+ [o_fullscreen_anim2 stopAnimation];
+ [o_fullscreen_anim2 release];
+ }
+
+ frame = [[o_temp_view superview] convertRect: [o_temp_view frame] toView: nil]; /* Convert to Window base coord */
+ frame.origin.x += [self frame].origin.x;
+ frame.origin.y += [self frame].origin.y;
+
+ dict2 = [[NSMutableDictionary alloc] initWithCapacity:2];
+ [dict2 setObject:self forKey:NSViewAnimationTargetKey];
+ [dict2 setObject:NSViewAnimationFadeInEffect forKey:NSViewAnimationEffectKey];
+
+ o_fullscreen_anim2 = [[NSViewAnimation alloc] initWithViewAnimations:[NSArray arrayWithObjects:dict2, nil]];
+ [dict2 release];
+
+ [o_fullscreen_anim2 setAnimationBlockingMode: NSAnimationNonblocking];
+ [o_fullscreen_anim2 setDuration: 0.3];
+ [o_fullscreen_anim2 setFrameRate: 30];
+
+ [o_fullscreen_anim2 setDelegate: self];
+
+ dict1 = [[NSMutableDictionary alloc] initWithCapacity:3];
+
+ [dict1 setObject:o_fullscreen_window forKey:NSViewAnimationTargetKey];
+ [dict1 setObject:[NSValue valueWithRect:[o_fullscreen_window frame]] forKey:NSViewAnimationStartFrameKey];
+ [dict1 setObject:[NSValue valueWithRect:frame] forKey:NSViewAnimationEndFrameKey];
+
+ o_fullscreen_anim1 = [[NSViewAnimation alloc] initWithViewAnimations:[NSArray arrayWithObjects:dict1, nil]];
+ [dict1 release];
+
+ [o_fullscreen_anim1 setAnimationBlockingMode: NSAnimationNonblocking];
+ [o_fullscreen_anim1 setDuration: 0.2];
+ [o_fullscreen_anim1 setFrameRate: 30];
+ [o_fullscreen_anim2 startWhenAnimation: o_fullscreen_anim1 reachesProgress: 1.0];
+
+ /* Make sure o_fullscreen_window is the frontmost window */
+ [o_fullscreen_window orderFront: self];
+
+ [o_fullscreen_anim1 startAnimation];
+ /* fullscreenAnimation will be unlocked when animation ends */
+}
+
+- (void)hasEndedFullscreen
+{
+ /* This function is private and should be only triggered at the end of the fullscreen change animation */
+ /* Make sure we don't see the o_video_view disappearing of the screen during this operation */
+ NSDisableScreenUpdates();
+ [o_video_view retain];
+ [o_video_view removeFromSuperviewWithoutNeedingDisplay];
+ [[o_temp_view superview] replaceSubview:o_temp_view with:o_video_view];
+ [o_video_view release];
+ [o_video_view setFrame:[o_temp_view frame]];
+ [self makeFirstResponder: o_video_view];
+ if ([self isVisible])
+ [super makeKeyAndOrderFront:self]; /* our version contains a workaround */
+ [o_fullscreen_window orderOut: self];
+ NSEnableScreenUpdates();
+
+ [o_fullscreen_window release];
+ o_fullscreen_window = nil;
+ [self setLevel:i_originalLevel];
+
+ [self unlockFullscreenAnimation];
+}
+
+- (void)animationDidEnd:(NSAnimation*)animation
+{
+ NSArray *viewAnimations;
+ if( o_makekey_anim == animation )
+ {
+ [o_makekey_anim release];
+ return;
+ }
+ if ([animation currentValue] < 1.0)
+ return;
+
+ /* Fullscreen ended or started (we are a delegate only for leaveFullscreen's/enterFullscren's anim2) */
+ viewAnimations = [o_fullscreen_anim2 viewAnimations];
+ if ([viewAnimations count] >=1 &&
+ [[[viewAnimations objectAtIndex: 0] objectForKey: NSViewAnimationEffectKey] isEqualToString:NSViewAnimationFadeInEffect])
+ {
+ /* Fullscreen ended */
+ [self hasEndedFullscreen];
+ }
+ else
+ {
+ /* Fullscreen started */
+ [self hasBecomeFullscreen];
+ }
+}
+
+- (void)orderOut: (id)sender
+{
+ [super orderOut: sender];
+
+ /* Make sure we leave fullscreen */
+ [self leaveFullscreenAndFadeOut: YES];
+}
+
+- (void)makeKeyAndOrderFront: (id)sender
+{
+ /* Hack
+ * when we exit fullscreen and fade out, we may endup in
+ * having a window that is faded. We can't have it fade in unless we
+ * animate again. */
+
+ if(!b_window_is_invisible)
+ {
+ /* Make sure we don't do it too much */
+ [super makeKeyAndOrderFront: sender];
+ return;
+ }
+
+ [super setAlphaValue:0.0f];
+ [super makeKeyAndOrderFront: sender];
+
+ NSMutableDictionary * dict = [[NSMutableDictionary alloc] initWithCapacity:2];
+ [dict setObject:self forKey:NSViewAnimationTargetKey];
+ [dict setObject:NSViewAnimationFadeInEffect forKey:NSViewAnimationEffectKey];
+
+ o_makekey_anim = [[NSViewAnimation alloc] initWithViewAnimations:[NSArray arrayWithObject:dict]];
+ [dict release];
+
+ [o_makekey_anim setAnimationBlockingMode: NSAnimationNonblocking];
+ [o_makekey_anim setDuration: 0.1];
+ [o_makekey_anim setFrameRate: 30];
+ [o_makekey_anim setDelegate: self];
+
+ [o_makekey_anim startAnimation];
+ b_window_is_invisible = NO;
+
+ /* fullscreenAnimation will be unlocked when animation ends */
+}
+
+
+
+/* Make sure setFrame gets executed on main thread especially if we are animating.
+ * (Thus we won't block the video output thread) */
+- (void)setFrame:(NSRect)frame display:(BOOL)display animate:(BOOL)animate
+{
+ struct { NSRect frame; BOOL display; BOOL animate;} args;
+ NSData *packedargs;
+
+ args.frame = frame;
+ args.display = display;
+ args.animate = animate;
+
+ packedargs = [NSData dataWithBytes:&args length:sizeof(args)];
+
+ [self performSelectorOnMainThread:@selector(setFrameOnMainThread:)
+ withObject: packedargs waitUntilDone: YES];
+}
+
+- (void)setFrameOnMainThread:(NSData*)packedargs
+{
+ struct args { NSRect frame; BOOL display; BOOL animate; } * args = (struct args*)[packedargs bytes];
+
+ if( args->animate )
+ {
+ /* Make sure we don't block too long and set up a non blocking animation */
+ NSDictionary * dict = [NSDictionary dictionaryWithObjectsAndKeys:
+ self, NSViewAnimationTargetKey,
+ [NSValue valueWithRect:[self frame]], NSViewAnimationStartFrameKey,
+ [NSValue valueWithRect:args->frame], NSViewAnimationEndFrameKey, nil];
+
+ NSViewAnimation * anim = [[NSViewAnimation alloc] initWithViewAnimations:[NSArray arrayWithObject:dict]];
+ [dict release];
+
+ [anim setAnimationBlockingMode: NSAnimationNonblocking];
+ [anim setDuration: 0.4];
+ [anim setFrameRate: 30];
+ [anim startAnimation];
+ }
+ else {
+ [super setFrame:args->frame display:args->display animate:args->animate];
+ }
+}
+
#pragma mark -
#pragma mark Side Bar Data handling
/* taken under BSD-new from the PXSourceList sample project, adapted for VLC */