/*****************************************************************************
* MainWindow.h: MacOS X interface module
*****************************************************************************
- * Copyright (C) 2002-2011 VideoLAN
+ * Copyright (C) 2002-2011 VLC authors and VideoLAN
* $Id$
*
* Authors: Felix Paul Kühne <fkuehne -at- videolan -dot- org>
* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston MA 02110-1301, USA.
*****************************************************************************/
+#import "CompatibilityFixes.h"
#import "MainWindow.h"
#import "intf.h"
#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>
#import <vlc_aout_intf.h>
#import <vlc_url.h>
#import <vlc_strings.h>
+#import <vlc_services_discovery.h>
@implementation VLCMainWindow
static VLCMainWindow *_o_sharedInstance = nil;
return _o_sharedInstance;
}
else
+ {
+ o_fspanel = [[VLCFSPanel alloc] init];
_o_sharedInstance = [super init];
+ }
return _o_sharedInstance;
}
[self setMovableByWindowBackground: YES];
/* we don't want this window to be restored on relaunch */
- if ([self respondsToSelector:@selector(setRestorable:)])
+ if (OSX_LION)
[self setRestorable:NO];
return self;
- (void)dealloc
{
config_PutInt( VLCIntf->p_libvlc, "volume", i_lastShownVolume );
+ [o_sidebaritems release];
[super dealloc];
}
- (void)awakeFromNib
{
+ /* setup the styled interface */
b_dark_interface = config_GetInt( VLCIntf, "macosx-interfacestyle" );
+ b_nativeFullscreenMode = config_GetInt( VLCIntf, "macosx-nativefullscreenmode" );
i_lastShownVolume = -1;
[o_play_btn setToolTip: _NS("Play/Pause")];
[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_time_sld_middle_view setImage: [NSImage imageNamed:@"progression-track-wrapper-middle"]];
[o_time_sld_right_view setImage: [NSImage imageNamed:@"progression-track-wrapper-right"]];
[o_volume_down_btn setImage: [NSImage imageNamed:@"volume-low"]];
- [o_volume_track_view setImage: [NSImage imageNamed:@"volumetrack"]];
+ [o_volume_track_view setImage: [NSImage imageNamed:@"volume-slider-track"]];
[o_volume_up_btn setImage: [NSImage imageNamed:@"volume-high"]];
- [o_effects_btn setImage: [NSImage imageNamed:@"effects-double-buttons"]];
- [o_effects_btn setAlternateImage: [NSImage imageNamed:@"effects-double-buttons-pressed"]];
+ if (OSX_LION && b_nativeFullscreenMode)
+ {
+ [o_effects_btn setImage: [NSImage imageNamed:@"effects-one-button"]];
+ [o_effects_btn setAlternateImage: [NSImage imageNamed:@"effects-one-button-blue"]];
+ }
+ else
+ {
+ [o_effects_btn setImage: [NSImage imageNamed:@"effects-double-buttons"]];
+ [o_effects_btn setAlternateImage: [NSImage imageNamed:@"effects-double-buttons-pressed"]];
+ }
[o_fullscreen_btn setImage: [NSImage imageNamed:@"fullscreen-double-buttons"]];
[o_fullscreen_btn setAlternateImage: [NSImage imageNamed:@"fullscreen-double-buttons-pressed"]];
[o_time_sld_fancygradient_view loadImagesInDarkStyle:NO];
[o_volume_down_btn setImage: [NSImage imageNamed:@"volume-low_dark"]];
[o_volume_track_view setImage: [NSImage imageNamed:@"volume-slider-track_dark"]];
[o_volume_up_btn setImage: [NSImage imageNamed:@"volume-high_dark"]];
- [o_effects_btn setImage: [NSImage imageNamed:@"effects-double-buttons_dark"]];
- [o_effects_btn setAlternateImage: [NSImage imageNamed:@"effects-double-buttons-pressed_dark"]];
+ if (OSX_LION && b_nativeFullscreenMode)
+ {
+ [o_effects_btn setImage: [NSImage imageNamed:@"effects-one-button_dark"]];
+ [o_effects_btn setAlternateImage: [NSImage imageNamed:@"effects-one-button-blue_dark"]];
+ }
+ else
+ {
+ [o_effects_btn setImage: [NSImage imageNamed:@"effects-double-buttons_dark"]];
+ [o_effects_btn setAlternateImage: [NSImage imageNamed:@"effects-double-buttons-pressed_dark"]];
+ }
[o_fullscreen_btn setImage: [NSImage imageNamed:@"fullscreen-double-buttons_dark"]];
[o_fullscreen_btn setAlternateImage: [NSImage imageNamed:@"fullscreen-double-buttons-pressed_dark"]];
[o_time_sld_fancygradient_view loadImagesInDarkStyle:YES];
[o_repeat_btn setAlternateImage: o_repeat_pressed_img];
[o_shuffle_btn setImage: o_shuffle_img];
[o_shuffle_btn setAlternateImage: o_shuffle_pressed_img];
-
[o_play_btn setImage: o_play_img];
[o_play_btn setAlternateImage: o_play_pressed_img];
- [o_video_view setFrame: [o_split_view frame]];
+ /* interface builder action */
[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];
+ [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]];
+ [o_left_split_view setFrame: [o_sidebar_view frame]];
+ if (OSX_LION && b_nativeFullscreenMode)
+ {
+ [self setCollectionBehavior: NSWindowCollectionBehaviorFullScreenPrimary];
+ NSRect frame;
+ float f_width = [o_fullscreen_btn frame].size.width;
+
+ #define moveItem( item ) \
+ frame = [item frame]; \
+ frame.origin.x = f_width + frame.origin.x; \
+ [item setFrame: frame]
+
+ moveItem( o_effects_btn );
+ moveItem( o_volume_up_btn );
+ moveItem( o_volume_sld );
+ moveItem( o_volume_track_view );
+ moveItem( o_volume_down_btn );
+ moveItem( o_time_fld );
+ moveItem( o_time_sld_right_view );
+ #undef moveItem
+
+ #define enlargeItem( item ) \
+ frame = [item frame]; \
+ frame.size.width = f_width + frame.size.width; \
+ [item setFrame: frame]
+
+ enlargeItem( o_time_sld );
+ enlargeItem( o_progress_bar );
+ enlargeItem( o_time_sld_middle_view );
+ enlargeItem( o_time_sld_fancygradient_view );
+ #undef enlargeItem
+
+ [o_fullscreen_btn removeFromSuperviewWithoutNeedingDisplay];
+ }
- [self updateVolumeSlider];
- [self updateTimeSlider];
+ /* 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"];
+ SideBarItem *internetItem = [SideBarItem itemWithTitle:_NS("INTERNET") identifier:@"internet"];
+
+ /* SD subnodes, inspired by the Qt4 intf */
+ char **ppsz_longnames;
+ int *p_categories;
+ char **ppsz_names = vlc_sd_GetNames( pl_Get( VLCIntf ), &ppsz_longnames, &p_categories );
+ if (!ppsz_names)
+ msg_Err( VLCIntf, "no sd item found" ); //TODO
+ char **ppsz_name = ppsz_names, **ppsz_longname = ppsz_longnames;
+ int *p_category = p_categories;
+ NSMutableArray *internetItems = [[NSMutableArray alloc] init];
+ 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: 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: o_identifier]];
+ [[devicesItems lastObject] setIcon: [NSImage imageNamed:@"NSApplicationIcon"]];
+ }
+ break;
+ case SD_CAT_LAN:
+ {
+ [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: 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 );
+ break;
+ }
+
+ free( *ppsz_name );
+ free( *ppsz_longname );
+ }
+ [mycompItem setChildren: [NSArray arrayWithArray: mycompItems]];
+ [devicesItem setChildren: [NSArray arrayWithArray: devicesItems]];
+ [lanItem setChildren: [NSArray arrayWithArray: lanItems]];
+ [internetItem setChildren: [NSArray arrayWithArray: internetItems]];
+ [mycompItems release];
+ [devicesItems release];
+ [lanItems release];
+ [internetItems release];
+ free( ppsz_names );
+ free( ppsz_longnames );
+ free( p_categories );
+
+ [libraryItem setChildren: [NSArray arrayWithObject: playlistItem]];
+ [o_sidebaritems addObject: libraryItem];
+ if ([mycompItem hasChildren])
+ [o_sidebaritems addObject: mycompItem];
+ if ([devicesItem hasChildren])
+ [o_sidebaritems addObject: devicesItem];
+ if ([lanItem hasChildren])
+ [o_sidebaritems addObject: lanItem];
+ if ([internetItem hasChildren])
+ [o_sidebaritems addObject: internetItem];
+
+ [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];
+ if (!b_nonembedded)
+ {
+ if ([o_video_view isHidden] && [o_playlist_btn isEnabled]) {
+ [o_split_view setHidden: YES];
+ [o_video_view setHidden: NO];
+ }
+ else
+ {
+ [o_video_view setHidden: YES];
+ [o_split_view setHidden: NO];
+ }
}
else
{
+ [o_split_view setHidden: NO];
[o_playlist_table setHidden: NO];
- [o_video_view setHidden: YES];
+ [o_video_view setHidden: ![[VLCMain sharedInstance] activeVideoPlayback]];
}
}
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;
p_input = pl_CurrentInput( VLCIntf );
if( p_input )
{
- NSAutoreleasePool *o_pool = [[NSAutoreleasePool alloc] init];
vlc_value_t time;
NSString * o_time;
vlc_value_t pos;
else
o_time = [NSString stringWithUTF8String: secstotimestr( psz_time, (time.i_time / 1000000) )];
+ if (dur == -1) {
+ [o_time_sld setEnabled: NO];
+ [o_time_sld setHidden: YES];
+ } else {
+ [o_time_sld setEnabled: YES];
+ [o_time_sld setHidden: NO];
+ }
+
[o_time_fld setStringValue: o_time];
[o_time_fld setNeedsDisplay:YES];
-// [[[[VLCMain sharedInstance] controls] fspanel] setStreamPos: f_updated andTime: o_time];
- [o_pool release];
+ [o_fspanel setStreamPos: f_updated andTime: o_time];
+ vlc_object_release( p_input );
}
else
{
[o_time_sld setFloatValue: 0.0];
[o_time_fld setStringValue: @"00:00"];
+ [o_time_sld setEnabled: NO];
+ [o_time_sld setHidden: YES];
}
[self performSelectorOnMainThread:@selector(drawFancyGradientEffectForTimeSlider) withObject:nil waitUntilDone:NO];
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: nil];
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: nil];
}
+
[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
- (id)videoView
{
+ vout_thread_t *p_vout = getVout();
+ if (config_GetInt( VLCIntf, "embedded-video" ))
+ {
+ if ([o_video_view window] != self)
+ {
+ [o_video_view removeFromSuperviewWithoutNeedingDisplay];
+ [o_video_view setFrame: [o_split_view frame]];
+ [[self contentView] addSubview:o_video_view positioned:NSWindowAbove relativeTo:nil];
+ }
+ b_nonembedded = NO;
+ }
+ else
+ {
+ [o_video_view removeFromSuperviewWithoutNeedingDisplay];
+ if (o_nonembedded_window)
+ [o_nonembedded_window release];
+
+ o_nonembedded_window = [[VLCWindow alloc] initWithContentRect:[o_video_view frame] styleMask: NSBorderlessWindowMask|NSResizableWindowMask backing:NSBackingStoreBuffered defer:YES];
+ [o_nonembedded_window setFrame:[o_video_view frame] display:NO];
+ [o_nonembedded_window setBackgroundColor: [NSColor blackColor]];
+ [o_nonembedded_window setMovableByWindowBackground: YES];
+ [o_nonembedded_window setCanBecomeKeyWindow: YES];
+ [o_nonembedded_window setHasShadow:YES];
+ [o_nonembedded_window setContentView: o_video_view];
+ [o_nonembedded_window setLevel:NSNormalWindowLevel];
+ [o_nonembedded_window useOptimizedDrawing: YES];
+ [o_nonembedded_window center];
+ [o_nonembedded_window makeKeyAndOrderFront:self];
+ [o_nonembedded_window orderFront:self animate:YES];
+ [o_nonembedded_window setReleasedWhenClosed:NO];
+ b_nonembedded = YES;
+ }
+
+ if (p_vout)
+ {
+ if( var_GetBool( p_vout, "video-on-top" ) )
+ [[o_video_view window] setLevel: NSStatusWindowLevel];
+ else
+ [[o_video_view window] setLevel: NSNormalWindowLevel];
+ vlc_object_release( p_vout );
+ }
return o_video_view;
}
- (void)setVideoplayEnabled
{
- [o_playlist_btn setEnabled: [[VLCMain sharedInstance] activeVideoPlayback]];
+ if (!b_nonembedded)
+ [o_playlist_btn setEnabled: [[VLCMain sharedInstance] activeVideoPlayback]];
+ else
+ {
+ [o_playlist_btn setEnabled: NO];
+ if (![[VLCMain sharedInstance] activeVideoPlayback])
+ [o_nonembedded_window orderOut: nil];
+ }
+}
+
+- (void)resizeWindow
+{
+ if ( !b_fullscreen && !(OSX_LION && [NSApp currentSystemPresentationOptions] == NSApplicationPresentationFullScreen && b_nativeFullscreenMode) )
+ {
+ 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])
+ {
+ if (OSX_LEOPARD)
+ SetSystemUIMode( kUIModeAllHidden, kUIOptionAutoShowMenuBar);
+ else
+ [NSApp setPresentationOptions:(NSApplicationPresentationAutoHideDock | NSApplicationPresentationAutoHideMenuBar)];
+ }
+
+ [[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])
+ {
+ if (OSX_LEOPARD)
+ SetSystemUIMode( kUIModeAllHidden, kUIOptionAutoShowMenuBar);
+ else
+ [NSApp setPresentationOptions:(NSApplicationPresentationAutoHideDock | NSApplicationPresentationAutoHideMenuBar)];
+ }
+
+ 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" ) )
+ [[o_video_view window] setLevel: NSStatusWindowLevel];
+ else
+ [[o_video_view window] setLevel: NSNormalWindowLevel];
+ vlc_object_release( p_vout );
+ }
+ [[o_video_view window] 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];
+ if (OSX_LEOPARD)
+ SetSystemUIMode( kUIModeNormal, kUIOptionAutoShowMenuBar);
+ else
+ [NSApp setPresentationOptions:(NSApplicationPresentationDefault)];
+
+ /* 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_video_view window] orderFront: self];
+
+ [o_fspanel setNonActive: nil];
+ if (OSX_LEOPARD)
+ SetSystemUIMode( kUIModeNormal, kUIOptionAutoShowMenuBar);
+ else
+ [NSApp setPresentationOptions:(NSApplicationPresentationDefault)];
+
+ 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]];
+
+ [anim setAnimationBlockingMode: NSAnimationNonblocking];
+ [anim setDuration: 0.4];
+ [anim setFrameRate: 30];
+ [anim startAnimation];
+
+ [anim release];
+ }
+ else {
+ [super setFrame:args->frame display:args->display animate:args->animate];
+ }
+}
+
+#pragma mark -
+#pragma mark Lion's native fullscreen handling
+- (void)windowWillEnterFullScreen:(NSNotification *)notification
+{
+ [NSCursor setHiddenUntilMouseMoves: YES];
+}
+
+- (void)windowWillExitFullScreen:(NSNotification *)notification
+{
+ [NSCursor setHiddenUntilMouseMoves: NO];
+}
+
+#pragma mark -
+#pragma mark Side Bar Data handling
+/* taken under BSD-new from the PXSourceList sample project, adapted for VLC */
+- (NSUInteger)sourceList:(PXSourceList*)sourceList numberOfChildrenOfItem:(id)item
+{
+ //Works the same way as the NSOutlineView data source: `nil` means a parent item
+ if(item==nil) {
+ return [o_sidebaritems count];
+ }
+ else {
+ return [[item children] count];
+ }
+}
+
+
+- (id)sourceList:(PXSourceList*)aSourceList child:(NSUInteger)index ofItem:(id)item
+{
+ //Works the same way as the NSOutlineView data source: `nil` means a parent item
+ if(item==nil) {
+ return [o_sidebaritems objectAtIndex:index];
+ }
+ else {
+ return [[item children] objectAtIndex:index];
+ }
+}
+
+
+- (id)sourceList:(PXSourceList*)aSourceList objectValueForItem:(id)item
+{
+ return [item title];
+}
+
+- (void)sourceList:(PXSourceList*)aSourceList setObjectValue:(id)object forItem:(id)item
+{
+ [item setTitle:object];
+}
+
+- (BOOL)sourceList:(PXSourceList*)aSourceList isItemExpandable:(id)item
+{
+ return [item hasChildren];
+}
+
+
+- (BOOL)sourceList:(PXSourceList*)aSourceList itemHasBadge:(id)item
+{
+ if ([[item identifier] isEqualToString: @"playlist"])
+ return YES;
+
+ return [item hasBadge];
+}
+
+
+- (NSInteger)sourceList:(PXSourceList*)aSourceList badgeValueForItem:(id)item
+{
+ if ([[item identifier] isEqualToString: @"playlist"]) {
+ playlist_t * p_playlist = pl_Get( VLCIntf );
+ NSInteger i_playlist_size;
+
+ PL_LOCK;
+ i_playlist_size = playlist_CurrentSize( p_playlist );
+ PL_UNLOCK;
+
+ return i_playlist_size;
+ }
+ return [item badgeValue];
+}
+
+
+- (BOOL)sourceList:(PXSourceList*)aSourceList itemHasIcon:(id)item
+{
+ return [item hasIcon];
+}
+
+
+- (NSImage*)sourceList:(PXSourceList*)aSourceList iconForItem:(id)item
+{
+ return [item icon];
+}
+
+- (NSMenu*)sourceList:(PXSourceList*)aSourceList menuForEvent:(NSEvent*)theEvent item:(id)item
+{
+ if ([theEvent type] == NSRightMouseDown || ([theEvent type] == NSLeftMouseDown && ([theEvent modifierFlags] & NSControlKeyMask) == NSControlKeyMask)) {
+ NSMenu * m = [[NSMenu alloc] init];
+ if (item != nil)
+ [m addItemWithTitle:[item title] action:nil keyEquivalent:@""];
+ return [m autorelease];
+ }
+ return nil;
+}
+
+#pragma mark -
+#pragma mark Side Bar Delegate Methods
+/* taken under BSD-new from the PXSourceList sample project, adapted for VLC */
+- (BOOL)sourceList:(PXSourceList*)aSourceList isGroupAlwaysExpanded:(id)group
+{
+ if([[group identifier] isEqualToString:@"library"])
+ return YES;
+
+ return NO;
+}
+
+- (void)sourceListSelectionDidChange:(NSNotification *)notification
+{
+ NSIndexSet *selectedIndexes = [o_sidebar_view selectedRowIndexes];
+
+ //Set the label text to represent the new selection
+ if([selectedIndexes count]==1) {
+ NSString *title = [[o_sidebar_view itemAtRow:[selectedIndexes firstIndex]] title];
+
+ [o_chosen_category_lbl setStringValue:title];
+ }
+ else {
+ [o_chosen_category_lbl setStringValue:@"(none)"];
+ }
}
@end
projects / vlc / blobdiff