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

   1 /*****************************************************************************
   2  * MainWindow.h: MacOS X interface module
   3  *****************************************************************************
   4  * Copyright (C) 2002-2011 VLC authors and VideoLAN
   5  * $Id$
   6  *
   7  * Authors: Felix Paul Kühne <fkuehne -at- videolan -dot- org>
   8  *          Jon Lech Johansen <jon-vl@nanocrew.net>
   9  *          Christophe Massiot <massiot@via.ecp.fr>
  10  *          Derk-Jan Hartman <hartman at videolan.org>
  11  *
  12  * This program is free software; you can redistribute it and/or modify
  13  * it under the terms of the GNU General Public License as published by
  14  * the Free Software Foundation; either version 2 of the License, or
  15  * (at your option) any later version.
  16  *
  17  * This program is distributed in the hope that it will be useful,
  18  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  19  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  20  * GNU General Public License for more details.
  21  *
  22  * You should have received a copy of the GNU General Public License
  23  * along with this program; if not, write to the Free Software
  24  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston MA 02110-1301, USA.
  25  *****************************************************************************/
  26
  27 #import "CompatibilityFixes.h"
  28 #import "MainWindow.h"
  29 #import "intf.h"
  30 #import "CoreInteraction.h"
  31 #import "AudioEffects.h"
  32 #import "MainMenu.h"
  33 #import "open.h"
  34 #import "controls.h" // TODO: remove me
  35 #import "SideBarItem.h"
  36 #import <vlc_playlist.h>
  37 #import <vlc_aout_intf.h>
  38 #import <vlc_url.h>
  39 #import <vlc_strings.h>
  40 #import <vlc_services_discovery.h>
  41
  42 @implementation VLCMainWindow
  43 static VLCMainWindow *_o_sharedInstance = nil;
  44
  45 + (VLCMainWindow *)sharedInstance
  46 {
  47     return _o_sharedInstance ? _o_sharedInstance : [[self alloc] init];
  48 }
  49
  50 #pragma mark -
  51 #pragma mark Initialization
  52
  53 - (id)init
  54 {
  55     if( _o_sharedInstance)
  56     {
  57         [self dealloc];
  58         return _o_sharedInstance;
  59     }
  60     else
  61     {
  62         o_fspanel = [[VLCFSPanel alloc] init];
  63         _o_sharedInstance = [super init];
  64     }
  65
  66     return _o_sharedInstance;
  67 }
  68
  69 - (id)initWithContentRect:(NSRect)contentRect styleMask:(NSUInteger)styleMask
  70                   backing:(NSBackingStoreType)backingType defer:(BOOL)flag
  71 {
  72 //     styleMask ^= NSTexturedBackgroundWindowMask;
  73
  74     self = [super initWithContentRect:contentRect styleMask:styleMask //& ~NSTitledWindowMask
  75                               backing:backingType defer:flag];
  76
  77     [[VLCMain sharedInstance] updateTogglePlaylistState];
  78
  79     /* we want to be moveable regardless of our style */
  80     [self setMovableByWindowBackground: YES];
  81
  82     /* we don't want this window to be restored on relaunch */
  83     if (OSX_LION)
  84         [self setRestorable:NO];
  85
  86     return self;
  87 }
  88
  89 - (BOOL)performKeyEquivalent:(NSEvent *)o_event
  90 {
  91     /* We indeed want to prioritize Cocoa key equivalent against libvlc,
  92      so we perform the menu equivalent now. */
  93     if([[NSApp mainMenu] performKeyEquivalent:o_event])
  94         return TRUE;
  95
  96     return [[VLCMain sharedInstance] hasDefinedShortcutKey:o_event] || [(VLCControls *)[[VLCMain sharedInstance] controls] keyEvent:o_event];
  97 }
  98
  99 - (void)dealloc
 100 {
 101     config_PutInt( VLCIntf->p_libvlc, "volume", i_lastShownVolume );
 102     [o_sidebaritems release];
 103     [super dealloc];
 104 }
 105
 106 - (void)awakeFromNib
 107 {
 108     /* setup the styled interface */
 109     b_dark_interface = config_GetInt( VLCIntf, "macosx-interfacestyle" );
 110     b_nativeFullscreenMode = config_GetInt( VLCIntf, "macosx-nativefullscreenmode" );
 111     i_lastShownVolume = -1;
 112
 113     [o_play_btn setToolTip: _NS("Play/Pause")];
 114     [o_bwd_btn setToolTip: _NS("Backward")];
 115     [o_fwd_btn setToolTip: _NS("Forward")];
 116     [o_stop_btn setToolTip: _NS("Stop")];
 117     [o_playlist_btn setToolTip: _NS("Show/Hide Playlist")];
 118     [o_repeat_btn setToolTip: _NS("Repeat")];
 119     [o_shuffle_btn setToolTip: _NS("Shuffle")];
 120     [o_effects_btn setToolTip: _NS("Effects")];
 121     [o_fullscreen_btn setToolTip: _NS("Toggle Fullscreen mode")];
 122     [[o_search_fld cell] setPlaceholderString: _NS("Search")];
 123     [o_volume_sld setToolTip: _NS("Volume")];
 124     [o_volume_down_btn setToolTip: _NS("Mute")];
 125     [o_volume_up_btn setToolTip: _NS("Full Volume")];
 126     [o_time_sld setToolTip: _NS("Position")];
 127     [o_dropzone_btn setTitle: _NS("Open media...")];
 128     [o_dropzone_lbl setStringValue: _NS("Drop media here")];
 129
 130     if (!b_dark_interface) {
 131         [o_bottombar_view setImage: [NSImage imageNamed:@"bottom-background"]];
 132         [o_bwd_btn setImage: [NSImage imageNamed:@"back"]];
 133         [o_bwd_btn setAlternateImage: [NSImage imageNamed:@"back-pressed"]];
 134         o_play_img = [[NSImage imageNamed:@"play"] retain];
 135         o_play_pressed_img = [[NSImage imageNamed:@"play-pressed"] retain];
 136         o_pause_img = [[NSImage imageNamed:@"pause"] retain];
 137         o_pause_pressed_img = [[NSImage imageNamed:@"pause-pressed"] retain];
 138         [o_fwd_btn setImage: [NSImage imageNamed:@"forward"]];
 139         [o_fwd_btn setAlternateImage: [NSImage imageNamed:@"forward-pressed"]];
 140         [o_stop_btn setImage: [NSImage imageNamed:@"stop"]];
 141         [o_stop_btn setAlternateImage: [NSImage imageNamed:@"stop-pressed"]];
 142         [o_playlist_btn setImage: [NSImage imageNamed:@"playlist"]];
 143         [o_playlist_btn setAlternateImage: [NSImage imageNamed:@"playlist-pressed"]];
 144         o_repeat_img = [[NSImage imageNamed:@"repeat"] retain];
 145         o_repeat_pressed_img = [[NSImage imageNamed:@"repeat-pressed"] retain];
 146         o_repeat_all_img  = [[NSImage imageNamed:@"repeat-all"] retain];
 147         o_repeat_all_pressed_img = [[NSImage imageNamed:@"repeat-all-pressed"] retain];
 148         o_repeat_one_img = [[NSImage imageNamed:@"repeat-one"] retain];
 149         o_repeat_one_pressed_img = [[NSImage imageNamed:@"repeat-one-pressed"] retain];
 150         o_shuffle_img = [[NSImage imageNamed:@"shuffle"] retain];
 151         o_shuffle_pressed_img = [[NSImage imageNamed:@"shuffle-pressed"] retain];
 152         o_shuffle_on_img = [[NSImage imageNamed:@"shuffle-blue"] retain];
 153         o_shuffle_on_pressed_img = [[NSImage imageNamed:@"shuffle-blue-pressed"] retain];
 154         [o_time_sld_left_view setImage: [NSImage imageNamed:@"progression-track-wrapper-left"]];
 155         [o_time_sld_middle_view setImage: [NSImage imageNamed:@"progression-track-wrapper-middle"]];
 156         [o_time_sld_right_view setImage: [NSImage imageNamed:@"progression-track-wrapper-right"]];
 157         [o_volume_down_btn setImage: [NSImage imageNamed:@"volume-low"]];
 158         [o_volume_track_view setImage: [NSImage imageNamed:@"volume-slider-track"]];
 159         [o_volume_up_btn setImage: [NSImage imageNamed:@"volume-high"]];
 160         if (OSX_LION && b_nativeFullscreenMode)
 161         {
 162             [o_effects_btn setImage: [NSImage imageNamed:@"effects-one-button"]];
 163             [o_effects_btn setAlternateImage: [NSImage imageNamed:@"effects-one-button-blue"]];
 164         }
 165         else
 166         {
 167             [o_effects_btn setImage: [NSImage imageNamed:@"effects-double-buttons"]];
 168             [o_effects_btn setAlternateImage: [NSImage imageNamed:@"effects-double-buttons-pressed"]];
 169         }
 170         [o_fullscreen_btn setImage: [NSImage imageNamed:@"fullscreen-double-buttons"]];
 171         [o_fullscreen_btn setAlternateImage: [NSImage imageNamed:@"fullscreen-double-buttons-pressed"]];
 172         [o_time_sld_fancygradient_view loadImagesInDarkStyle:NO];
 173     }
 174     else
 175     {
 176         /* TODO: we also need to change the window style here... */
 177         [o_bottombar_view setImage: [NSImage imageNamed:@"bottom-background_dark"]];
 178         [o_bwd_btn setImage: [NSImage imageNamed:@"back_dark"]];
 179         [o_bwd_btn setAlternateImage: [NSImage imageNamed:@"back-pressed_dark"]];
 180         o_play_img = [[NSImage imageNamed:@"play_dark"] retain];
 181         o_play_pressed_img = [[NSImage imageNamed:@"play-pressed_dark"] retain];
 182         o_pause_img = [[NSImage imageNamed:@"pause_dark"] retain];
 183         o_pause_pressed_img = [[NSImage imageNamed:@"pause-pressed_dark"] retain];
 184         [o_fwd_btn setImage: [NSImage imageNamed:@"forward_dark"]];
 185         [o_fwd_btn setAlternateImage: [NSImage imageNamed:@"forward-pressed_dark"]];
 186         [o_stop_btn setImage: [NSImage imageNamed:@"stop_dark"]];
 187         [o_stop_btn setAlternateImage: [NSImage imageNamed:@"stop-pressed_dark"]];
 188         [o_playlist_btn setImage: [NSImage imageNamed:@"playlist_dark"]];
 189         [o_playlist_btn setAlternateImage: [NSImage imageNamed:@"playlist-pressed_dark"]];
 190         o_repeat_img = [[NSImage imageNamed:@"repeat_dark"] retain];
 191         o_repeat_pressed_img = [[NSImage imageNamed:@"repeat-pressed_dark"] retain];
 192         o_repeat_all_img  = [[NSImage imageNamed:@"repeat-all-blue_dark"] retain];
 193         o_repeat_all_pressed_img = [[NSImage imageNamed:@"repeat-all-blue-pressed_dark"] retain];
 194         o_repeat_one_img = [[NSImage imageNamed:@"repeat-one-blue_dark"] retain];
 195         o_repeat_one_pressed_img = [[NSImage imageNamed:@"repeat-one-blue-pressed_dark"] retain];
 196         o_shuffle_img = [[NSImage imageNamed:@"shuffle_dark"] retain];
 197         o_shuffle_pressed_img = [[NSImage imageNamed:@"shuffle-pressed_dark"] retain];
 198         o_shuffle_on_img = [[NSImage imageNamed:@"shuffle-blue_dark"] retain];
 199         o_shuffle_on_pressed_img = [[NSImage imageNamed:@"shuffle-blue-pressed_dark"] retain];
 200         [o_time_fld setTextColor: [NSColor colorWithCalibratedRed:229.0 green:229.0 blue:229.0 alpha:100.0]];
 201         [o_time_sld_left_view setImage: [NSImage imageNamed:@"progression-track-wrapper-left_dark"]];
 202         [o_time_sld_middle_view setImage: [NSImage imageNamed:@"progression-track-wrapper-middle_dark"]];
 203         [o_time_sld_right_view setImage: [NSImage imageNamed:@"progression-track-wrapper-right_dark"]];
 204         [o_volume_down_btn setImage: [NSImage imageNamed:@"volume-low_dark"]];
 205         [o_volume_track_view setImage: [NSImage imageNamed:@"volume-slider-track_dark"]];
 206         [o_volume_up_btn setImage: [NSImage imageNamed:@"volume-high_dark"]];
 207         if (OSX_LION && b_nativeFullscreenMode)
 208         {
 209             [o_effects_btn setImage: [NSImage imageNamed:@"effects-one-button_dark"]];
 210             [o_effects_btn setAlternateImage: [NSImage imageNamed:@"effects-one-button-blue_dark"]];
 211         }
 212         else
 213         {
 214             [o_effects_btn setImage: [NSImage imageNamed:@"effects-double-buttons_dark"]];
 215             [o_effects_btn setAlternateImage: [NSImage imageNamed:@"effects-double-buttons-pressed_dark"]];
 216         }
 217         [o_fullscreen_btn setImage: [NSImage imageNamed:@"fullscreen-double-buttons_dark"]];
 218         [o_fullscreen_btn setAlternateImage: [NSImage imageNamed:@"fullscreen-double-buttons-pressed_dark"]];
 219         [o_time_sld_fancygradient_view loadImagesInDarkStyle:YES];
 220     }
 221     [o_repeat_btn setImage: o_repeat_img];
 222     [o_repeat_btn setAlternateImage: o_repeat_pressed_img];
 223     [o_shuffle_btn setImage: o_shuffle_img];
 224     [o_shuffle_btn setAlternateImage: o_shuffle_pressed_img];
 225     [o_play_btn setImage: o_play_img];
 226     [o_play_btn setAlternateImage: o_play_pressed_img];
 227
 228     /* interface builder action */
 229     [self setDelegate: self];
 230     [self setExcludedFromWindowsMenu: YES];
 231     // Set that here as IB seems to be buggy
 232     [self setContentMinSize:NSMakeSize(500., 288.)];
 233     [self setTitle: _NS("VLC media player")];
 234     [o_playlist_btn setEnabled:NO];
 235     [o_video_view setFrame: [o_split_view frame]];
 236     o_temp_view = [[NSView alloc] init];
 237     [o_temp_view setAutoresizingMask:NSViewHeightSizable | NSViewWidthSizable];
 238     [o_dropzone_view setFrame: [o_playlist_table frame]];
 239     [o_left_split_view setFrame: [o_sidebar_view frame]];
 240     if (OSX_LION && b_nativeFullscreenMode)
 241     {
 242         [self setCollectionBehavior: NSWindowCollectionBehaviorFullScreenPrimary];
 243         NSRect frame;
 244         float f_width = [o_fullscreen_btn frame].size.width;
 245
 246         #define moveItem( item ) \
 247         frame = [item frame]; \
 248         frame.origin.x = f_width + frame.origin.x; \
 249         [item setFrame: frame]
 250
 251         moveItem( o_effects_btn );
 252         moveItem( o_volume_up_btn );
 253         moveItem( o_volume_sld );
 254         moveItem( o_volume_track_view );
 255         moveItem( o_volume_down_btn );
 256         moveItem( o_time_fld );
 257         moveItem( o_time_sld_right_view );
 258         #undef moveItem
 259
 260         #define enlargeItem( item ) \
 261         frame = [item frame]; \
 262         frame.size.width = f_width + frame.size.width; \
 263         [item setFrame: frame]
 264
 265         enlargeItem( o_time_sld );
 266         enlargeItem( o_progress_bar );
 267         enlargeItem( o_time_sld_middle_view );
 268         enlargeItem( o_time_sld_fancygradient_view );
 269         #undef enlargeItem
 270
 271         [o_fullscreen_btn removeFromSuperviewWithoutNeedingDisplay];
 272     }
 273
 274     /* create the sidebar */
 275     o_sidebaritems = [[NSMutableArray alloc] init];
 276     SideBarItem *libraryItem = [SideBarItem itemWithTitle:_NS("LIBRARY") identifier:@"library"];
 277     SideBarItem *playlistItem = [SideBarItem itemWithTitle:_NS("Playlist") identifier:@"playlist"];
 278     [playlistItem setIcon: [NSImage imageNamed:@"document-music-playlist"]];
 279     SideBarItem *mycompItem = [SideBarItem itemWithTitle:_NS("MY COMPUTER") identifier:@"mycomputer"];
 280     SideBarItem *devicesItem = [SideBarItem itemWithTitle:_NS("DEVICES") identifier:@"devices"];
 281     SideBarItem *lanItem = [SideBarItem itemWithTitle:_NS("LOCAL NETWORK") identifier:@"localnetwork"];
 282     SideBarItem *internetItem = [SideBarItem itemWithTitle:_NS("INTERNET") identifier:@"internet"];
 283
 284     /* SD subnodes, inspired by the Qt4 intf */
 285     char **ppsz_longnames;
 286     int *p_categories;
 287     char **ppsz_names = vlc_sd_GetNames( pl_Get( VLCIntf ), &ppsz_longnames, &p_categories );
 288     if (!ppsz_names)
 289         msg_Err( VLCIntf, "no sd item found" ); //TODO
 290     char **ppsz_name = ppsz_names, **ppsz_longname = ppsz_longnames;
 291     int *p_category = p_categories;
 292     NSMutableArray *internetItems = [[NSMutableArray alloc] init];
 293     NSMutableArray *devicesItems = [[NSMutableArray alloc] init];
 294     NSMutableArray *lanItems = [[NSMutableArray alloc] init];
 295     NSMutableArray *mycompItems = [[NSMutableArray alloc] init];
 296     NSString *o_identifier;
 297     for (; *ppsz_name; ppsz_name++, ppsz_longname++, p_category++)
 298     {
 299         o_identifier = [NSString stringWithCString: *ppsz_name encoding: NSUTF8StringEncoding];
 300         o_identifier = [[o_identifier componentsSeparatedByString:@"{"] objectAtIndex:0];
 301         switch (*p_category) {
 302             case SD_CAT_INTERNET:
 303                 {
 304                     [internetItems addObject: [SideBarItem itemWithTitle: [NSString stringWithCString: *ppsz_longname encoding: NSUTF8StringEncoding] identifier: o_identifier]];
 305                     if (!strncmp( *ppsz_name, "podcast", 7 ))
 306                         [[internetItems lastObject] setIcon: [NSImage imageNamed:@"film-cast"]];
 307                     else
 308                         [[internetItems lastObject] setIcon: [NSImage imageNamed:@"NSApplicationIcon"]];
 309                 }
 310                 break;
 311             case SD_CAT_DEVICES:
 312                 {
 313                     [devicesItems addObject: [SideBarItem itemWithTitle: [NSString stringWithCString: *ppsz_longname encoding: NSUTF8StringEncoding] identifier: o_identifier]];
 314                     [[devicesItems lastObject] setIcon: [NSImage imageNamed:@"NSApplicationIcon"]];
 315                 }
 316                 break;
 317             case SD_CAT_LAN:
 318                 {
 319                     [lanItems addObject: [SideBarItem itemWithTitle: [NSString stringWithCString: *ppsz_longname encoding: NSUTF8StringEncoding] identifier: o_identifier]];
 320                     [[lanItems lastObject] setIcon: [NSImage imageNamed:@"network-cloud"]];
 321                 }
 322                 break;
 323             case SD_CAT_MYCOMPUTER:
 324                 {
 325                     [mycompItems addObject: [SideBarItem itemWithTitle: [NSString stringWithCString: *ppsz_longname encoding: NSUTF8StringEncoding] identifier: o_identifier]];
 326                     if (!strncmp( *ppsz_name, "video_dir", 9 ))
 327                         [[mycompItems lastObject] setIcon: [NSImage imageNamed:@"film"]];
 328                     else if (!strncmp( *ppsz_name, "audio_dir", 9 ))
 329                         [[mycompItems lastObject] setIcon: [NSImage imageNamed:@"music-beam"]];
 330                     else if (!strncmp( *ppsz_name, "picture_dir", 11 ))
 331                         [[mycompItems lastObject] setIcon: [NSImage imageNamed:@"picture"]];
 332                     else
 333                         [[mycompItems lastObject] setIcon: [NSImage imageNamed:@"NSApplicationIcon"]];
 334                 }
 335                 break;
 336             default:
 337                 msg_Warn( VLCIntf, "unknown SD type found, skipping (%s)", *ppsz_name );
 338                 break;
 339         }
 340
 341         free( *ppsz_name );
 342         free( *ppsz_longname );
 343     }
 344     [mycompItem setChildren: [NSArray arrayWithArray: mycompItems]];
 345     [devicesItem setChildren: [NSArray arrayWithArray: devicesItems]];
 346     [lanItem setChildren: [NSArray arrayWithArray: lanItems]];
 347     [internetItem setChildren: [NSArray arrayWithArray: internetItems]];
 348     [mycompItems release];
 349     [devicesItems release];
 350     [lanItems release];
 351     [internetItems release];
 352     free( ppsz_names );
 353     free( ppsz_longnames );
 354     free( p_categories );
 355
 356     [libraryItem setChildren: [NSArray arrayWithObject: playlistItem]];
 357     [o_sidebaritems addObject: libraryItem];
 358     if ([mycompItem hasChildren])
 359         [o_sidebaritems addObject: mycompItem];
 360     if ([devicesItem hasChildren])
 361         [o_sidebaritems addObject: devicesItem];
 362     if ([lanItem hasChildren])
 363         [o_sidebaritems addObject: lanItem];
 364     if ([internetItem hasChildren])
 365         [o_sidebaritems addObject: internetItem];
 366
 367     [o_sidebar_view reloadData];
 368     [o_sidebar_view selectRowIndexes:[NSIndexSet indexSetWithIndex:0] byExtendingSelection:YES];
 369 }
 370
 371 #pragma mark -
 372 #pragma mark Button Actions
 373
 374 - (IBAction)play:(id)sender
 375 {
 376     [[VLCCoreInteraction sharedInstance] play];
 377 }
 378
 379 - (void)resetPreviousButton
 380 {
 381     if (([NSDate timeIntervalSinceReferenceDate] - last_bwd_event) >= 0.35) {
 382         // seems like no further event occured, so let's switch the playback item
 383         [[VLCCoreInteraction sharedInstance] previous];
 384         just_triggered_previous = NO;
 385     }
 386 }
 387
 388 - (void)resetBackwardSkip
 389 {
 390     // the user stopped skipping, so let's allow him to change the item
 391     if (([NSDate timeIntervalSinceReferenceDate] - last_bwd_event) >= 0.35)
 392         just_triggered_previous = NO;
 393 }
 394
 395 - (IBAction)bwd:(id)sender
 396 {
 397     if(!just_triggered_previous)
 398     {
 399         just_triggered_previous = YES;
 400         [self performSelector:@selector(resetPreviousButton)
 401                    withObject: NULL
 402                    afterDelay:0.40];
 403     }
 404     else
 405     {
 406         if (([NSDate timeIntervalSinceReferenceDate] - last_fwd_event) > 0.12 )
 407         {
 408             // we just skipped 3 "continous" events, otherwise we are too fast
 409             [[VLCCoreInteraction sharedInstance] backward];
 410             last_bwd_event = [NSDate timeIntervalSinceReferenceDate];
 411             [self performSelector:@selector(resetBackwardSkip)
 412                        withObject: NULL
 413                        afterDelay:0.40];
 414         }
 415     }
 416 }
 417
 418 - (void)resetNextButton
 419 {
 420     if (([NSDate timeIntervalSinceReferenceDate] - last_fwd_event) >= 0.35) {
 421         // seems like no further event occured, so let's switch the playback item
 422         [[VLCCoreInteraction sharedInstance] next];
 423         just_triggered_next = NO;
 424     }
 425 }
 426
 427 - (void)resetForwardSkip
 428 {
 429     // the user stopped skipping, so let's allow him to change the item
 430     if (([NSDate timeIntervalSinceReferenceDate] - last_fwd_event) >= 0.35)
 431         just_triggered_next = NO;
 432 }
 433
 434 - (IBAction)fwd:(id)sender
 435 {
 436    if(!just_triggered_next)
 437     {
 438         just_triggered_next = YES;
 439         [self performSelector:@selector(resetNextButton)
 440                    withObject: NULL
 441                    afterDelay:0.40];
 442     }
 443     else
 444     {
 445         if (([NSDate timeIntervalSinceReferenceDate] - last_fwd_event) > 0.12 )
 446         {
 447             // we just skipped 3 "continous" events, otherwise we are too fast
 448             [[VLCCoreInteraction sharedInstance] forward];
 449             last_fwd_event = [NSDate timeIntervalSinceReferenceDate];
 450             [self performSelector:@selector(resetForwardSkip)
 451                        withObject: NULL
 452                        afterDelay:0.40];
 453         }
 454     }
 455 }
 456
 457 - (IBAction)stop:(id)sender
 458 {
 459     [[VLCCoreInteraction sharedInstance] stop];
 460 }
 461
 462 - (IBAction)togglePlaylist:(id)sender
 463 {
 464     if (!b_nonembedded)
 465     {
 466         if ([o_video_view isHidden] && [o_playlist_btn isEnabled]) {
 467             [o_split_view setHidden: YES];
 468             [o_video_view setHidden: NO];
 469         }
 470         else
 471         {
 472             [o_video_view setHidden: YES];
 473             [o_split_view setHidden: NO];
 474         }
 475     }
 476     else
 477     {
 478         [o_split_view setHidden: NO];
 479         [o_playlist_table setHidden: NO];
 480         [o_video_view setHidden: ![[VLCMain sharedInstance] activeVideoPlayback]];
 481     }
 482 }
 483
 484 - (void)setRepeatOne
 485 {
 486     [o_repeat_btn setImage: o_repeat_one_img];
 487     [o_repeat_btn setAlternateImage: o_repeat_one_pressed_img];
 488 }
 489
 490 - (void)setRepeatAll
 491 {
 492     [o_repeat_btn setImage: o_repeat_all_img];
 493     [o_repeat_btn setAlternateImage: o_repeat_all_pressed_img];
 494 }
 495
 496 - (void)setRepeatOff
 497 {
 498     [o_repeat_btn setImage: o_repeat_img];
 499     [o_repeat_btn setAlternateImage: o_repeat_pressed_img];
 500 }
 501
 502 - (IBAction)repeat:(id)sender
 503 {
 504     vlc_value_t looping,repeating;
 505     intf_thread_t * p_intf = VLCIntf;
 506     playlist_t * p_playlist = pl_Get( p_intf );
 507
 508     var_Get( p_playlist, "repeat", &repeating );
 509     var_Get( p_playlist, "loop", &looping );
 510
 511     if( !repeating.b_bool && !looping.b_bool )
 512     {
 513         /* was: no repeating at all, switching to Repeat One */
 514         [[VLCCoreInteraction sharedInstance] repeatOne];
 515         [self setRepeatOne];
 516     }
 517     else if( repeating.b_bool && !looping.b_bool )
 518     {
 519         /* was: Repeat One, switching to Repeat All */
 520         [[VLCCoreInteraction sharedInstance] repeatAll];
 521         [self setRepeatAll];
 522     }
 523     else
 524     {
 525         /* was: Repeat All or bug in VLC, switching to Repeat Off */
 526         [[VLCCoreInteraction sharedInstance] repeatOff];
 527         [self setRepeatOff];
 528     }
 529 }
 530
 531 - (void)setShuffle
 532 {
 533     bool b_value;
 534     playlist_t *p_playlist = pl_Get( VLCIntf );
 535     b_value = var_GetBool( p_playlist, "random" );
 536         if(b_value) {
 537         [o_shuffle_btn setImage: o_shuffle_on_img];
 538         [o_shuffle_btn setAlternateImage: o_shuffle_on_pressed_img];
 539     }
 540     else
 541     {
 542         [o_shuffle_btn setImage: o_shuffle_img];
 543         [o_shuffle_btn setAlternateImage: o_shuffle_pressed_img];
 544     }
 545 }
 546
 547 - (IBAction)shuffle:(id)sender
 548 {
 549     [[VLCCoreInteraction sharedInstance] shuffle];
 550     [self setShuffle];
 551 }
 552
 553 - (IBAction)timeSliderAction:(id)sender
 554 {
 555     float f_updated;
 556     input_thread_t * p_input;
 557
 558     switch( [[NSApp currentEvent] type] )
 559     {
 560         case NSLeftMouseUp:
 561         case NSLeftMouseDown:
 562         case NSLeftMouseDragged:
 563             f_updated = [sender floatValue];
 564             break;
 565
 566         default:
 567             return;
 568     }
 569     p_input = pl_CurrentInput( VLCIntf );
 570     if( p_input != NULL )
 571     {
 572         vlc_value_t time;
 573         vlc_value_t pos;
 574         NSString * o_time;
 575         char psz_time[MSTRTIME_MAX_SIZE];
 576
 577         pos.f_float = f_updated / 10000.;
 578         var_Set( p_input, "position", pos );
 579         [o_time_sld setFloatValue: f_updated];
 580
 581         var_Get( p_input, "time", &time );
 582
 583         mtime_t dur = input_item_GetDuration( input_GetItem( p_input ) );
 584         if( [o_time_fld timeRemaining] && dur != -1 )
 585         {
 586             o_time = [NSString stringWithFormat: @"-%s", secstotimestr( psz_time, ((dur - time.i_time) / 1000000) )];
 587         }
 588         else
 589             o_time = [NSString stringWithUTF8String: secstotimestr( psz_time, (time.i_time / 1000000) )];
 590
 591         [o_time_fld setStringValue: o_time];
 592         [o_fspanel setStreamPos: f_updated andTime: o_time];
 593         vlc_object_release( p_input );
 594     }
 595     [self drawFancyGradientEffectForTimeSlider];
 596 }
 597
 598 - (IBAction)volumeAction:(id)sender
 599 {
 600     if (sender == o_volume_sld)
 601         [[VLCCoreInteraction sharedInstance] setVolume: [sender intValue]];
 602     else if (sender == o_volume_down_btn)
 603         [[VLCCoreInteraction sharedInstance] mute];
 604     else
 605         [[VLCCoreInteraction sharedInstance] setVolume: 400];
 606 }
 607
 608 - (IBAction)effects:(id)sender
 609 {
 610     [[VLCMainMenu sharedInstance] showAudioEffects: sender];
 611 }
 612
 613 - (IBAction)fullscreen:(id)sender
 614 {
 615     [[VLCCoreInteraction sharedInstance] toggleFullscreen];
 616 }
 617
 618 - (IBAction)dropzoneButtonAction:(id)sender
 619 {
 620     [[[VLCMain sharedInstance] open] openFileGeneric];
 621 }
 622
 623 #pragma mark -
 624 #pragma mark Update interface and respond to foreign events
 625 - (void)showDropZone
 626 {
 627     [o_right_split_view addSubview: o_dropzone_view];
 628     [o_dropzone_view setFrame: [o_playlist_table frame]];
 629     [[o_playlist_table animator] setHidden:YES];
 630 }
 631
 632 - (void)hideDropZone
 633 {
 634     [o_dropzone_view removeFromSuperview];
 635     [[o_playlist_table animator] setHidden: NO];
 636 }
 637
 638 - (void)updateTimeSlider
 639 {
 640     input_thread_t * p_input;
 641     p_input = pl_CurrentInput( VLCIntf );
 642     if( p_input )
 643     {
 644         vlc_value_t time;
 645         NSString * o_time;
 646         vlc_value_t pos;
 647         char psz_time[MSTRTIME_MAX_SIZE];
 648         float f_updated;
 649
 650         var_Get( p_input, "position", &pos );
 651         f_updated = 10000. * pos.f_float;
 652         [o_time_sld setFloatValue: f_updated];
 653
 654         var_Get( p_input, "time", &time );
 655
 656         mtime_t dur = input_item_GetDuration( input_GetItem( p_input ) );
 657         if( [o_time_fld timeRemaining] && dur != -1 )
 658         {
 659             o_time = [NSString stringWithFormat: @"-%s", secstotimestr( psz_time, ((dur - time.i_time) / 1000000))];
 660         }
 661         else
 662             o_time = [NSString stringWithUTF8String: secstotimestr( psz_time, (time.i_time / 1000000) )];
 663
 664         if (dur == -1) {
 665             [o_time_sld setEnabled: NO];
 666             [o_time_sld setHidden: YES];
 667         } else {
 668             [o_time_sld setEnabled: YES];
 669             [o_time_sld setHidden: NO];
 670         }
 671
 672         [o_time_fld setStringValue: o_time];
 673         [o_time_fld setNeedsDisplay:YES];
 674         [o_fspanel setStreamPos: f_updated andTime: o_time];
 675         vlc_object_release( p_input );
 676     }
 677     else
 678     {
 679         [o_time_sld setFloatValue: 0.0];
 680         [o_time_fld setStringValue: @"00:00"];
 681         [o_time_sld setEnabled: NO];
 682         [o_time_sld setHidden: YES];
 683     }
 684
 685     [self performSelectorOnMainThread:@selector(drawFancyGradientEffectForTimeSlider) withObject:nil waitUntilDone:NO];
 686 }
 687
 688 - (void)updateVolumeSlider
 689 {
 690     audio_volume_t i_volume;
 691     playlist_t * p_playlist = pl_Get( VLCIntf );
 692
 693     i_volume = aout_VolumeGet( p_playlist );
 694
 695     if( i_volume != i_lastShownVolume )
 696     {
 697         i_lastShownVolume = i_volume;
 698         int i_volume_step = 0;
 699         i_volume_step = config_GetInt( VLCIntf->p_libvlc, "volume-step" );
 700         [o_volume_sld setFloatValue: (float)i_lastShownVolume / i_volume_step];
 701         [o_fspanel setVolumeLevel: (float)i_lastShownVolume / i_volume_step];
 702     }
 703 }
 704
 705 - (void)updateName
 706 {
 707     NSAutoreleasePool *o_pool = [[NSAutoreleasePool alloc] init];
 708     input_thread_t * p_input;
 709     p_input = pl_CurrentInput( VLCIntf );
 710     if( p_input )
 711     {
 712         NSString *aString;
 713         char *format = var_InheritString( VLCIntf, "input-title-format" );
 714         char *formated = str_format_meta( p_input, format );
 715         free( format );
 716         aString = [NSString stringWithUTF8String:formated];
 717         free( formated );
 718
 719         char *uri = input_item_GetURI( input_GetItem( p_input ) );
 720
 721         NSURL * o_url = [NSURL URLWithString: [NSString stringWithUTF8String: uri]];
 722         if ([o_url isFileURL])
 723             [self setRepresentedURL: o_url];
 724         else
 725             [self setRepresentedURL: nil];
 726         free( uri );
 727
 728         if ([aString isEqualToString:@""])
 729         {
 730             if ([o_url isFileURL])
 731                 aString = [[NSFileManager defaultManager] displayNameAtPath: [o_url path]];
 732             else
 733                 aString = [o_url absoluteString];
 734         }
 735
 736         [self setTitle: aString];
 737         [o_fspanel setStreamTitle: aString];
 738     }
 739     else
 740     {
 741         [self setTitle: _NS("VLC media player")];
 742         [self setRepresentedURL: nil];
 743     }
 744
 745     [o_pool release];
 746 }
 747
 748 - (void)updateWindow
 749 {
 750     bool b_input = false;
 751     bool b_plmul = false;
 752     bool b_control = false;
 753     bool b_seekable = false;
 754     bool b_chapters = false;
 755
 756     playlist_t * p_playlist = pl_Get( VLCIntf );
 757
 758     PL_LOCK;
 759     b_plmul = playlist_CurrentSize( p_playlist ) > 1;
 760     PL_UNLOCK;
 761
 762     input_thread_t * p_input = playlist_CurrentInput( p_playlist );
 763
 764     bool b_buffering = NO;
 765
 766     if( ( b_input = ( p_input != NULL ) ) )
 767     {
 768         /* seekable streams */
 769         cachedInputState = input_GetState( p_input );
 770         if ( cachedInputState == INIT_S || cachedInputState == OPENING_S )
 771             b_buffering = YES;
 772
 773         /* seekable streams */
 774         b_seekable = var_GetBool( p_input, "can-seek" );
 775
 776         /* check whether slow/fast motion is possible */
 777         b_control = var_GetBool( p_input, "can-rate" );
 778
 779         /* chapters & titles */
 780         //FIXME! b_chapters = p_input->stream.i_area_nb > 1;
 781         vlc_object_release( p_input );
 782     }
 783
 784     if( b_buffering )
 785     {
 786         [o_progress_bar startAnimation:self];
 787         [o_progress_bar setIndeterminate:YES];
 788         [o_progress_bar setHidden:NO];
 789     } else {
 790         [o_progress_bar stopAnimation:self];
 791         [o_progress_bar setHidden:YES];
 792     }
 793
 794     [o_stop_btn setEnabled: b_input];
 795     [o_fwd_btn setEnabled: (b_seekable || b_plmul || b_chapters)];
 796     [o_bwd_btn setEnabled: (b_seekable || b_plmul || b_chapters)];
 797     [[VLCMainMenu sharedInstance] setRateControlsEnabled: b_control];
 798
 799     [o_time_sld setEnabled: b_seekable];
 800     [self updateTimeSlider];
 801     [o_fspanel setSeekable: b_seekable];
 802
 803     PL_LOCK;
 804     if (playlist_CurrentSize( p_playlist ) >= 1)
 805         [self hideDropZone];
 806     else
 807         [self showDropZone];
 808     PL_UNLOCK;
 809 }
 810
 811 - (void)setPause
 812 {
 813     [o_play_btn setImage: o_pause_img];
 814     [o_play_btn setAlternateImage: o_pause_pressed_img];
 815     [o_play_btn setToolTip: _NS("Pause")];
 816     [o_fspanel setPause];
 817 }
 818
 819 - (void)setPlay
 820 {
 821     [o_play_btn setImage: o_play_img];
 822     [o_play_btn setAlternateImage: o_play_pressed_img];
 823     [o_play_btn setToolTip: _NS("Play")];
 824     [o_fspanel setPlay];
 825 }
 826
 827 - (void)drawFancyGradientEffectForTimeSlider
 828 {
 829     NSAutoreleasePool * o_pool = [[NSAutoreleasePool alloc] init];
 830     float f_value = ([o_time_sld_middle_view frame].size.width -5) * ([o_time_sld intValue] / [o_time_sld maxValue]);
 831     if (f_value > 5.0)
 832     {
 833         if (f_value != [o_time_sld_fancygradient_view frame].size.width)
 834         {
 835             [o_time_sld_fancygradient_view setHidden: NO];
 836             [o_time_sld_fancygradient_view setFrame: NSMakeRect( [o_time_sld_fancygradient_view frame].origin.x, [o_time_sld_fancygradient_view frame].origin.y, f_value, [o_time_sld_fancygradient_view frame].size.height )];
 837             [o_time_sld_fancygradient_view setNeedsDisplay:YES];
 838             [o_time_sld_middle_view setNeedsDisplay:YES];
 839         }
 840     }
 841     else
 842     {
 843         [o_time_sld_fancygradient_view setHidden: YES];
 844     }
 845     [o_pool release];
 846 }
 847
 848 #pragma mark -
 849 #pragma mark Video Output handling
 850
 851 - (id)videoView
 852 {
 853     vout_thread_t *p_vout = getVout();
 854     if (config_GetInt( VLCIntf, "embedded-video" ))
 855     {
 856         if ([o_video_view window] != self)
 857         {
 858             [o_video_view removeFromSuperviewWithoutNeedingDisplay];
 859             [o_video_view setFrame: [o_split_view frame]];
 860             [[self contentView] addSubview:o_video_view positioned:NSWindowAbove relativeTo:nil];
 861         }
 862         b_nonembedded = NO;
 863     }
 864     else
 865     {
 866         [o_video_view removeFromSuperviewWithoutNeedingDisplay];
 867         if (o_nonembedded_window)
 868             [o_nonembedded_window release];
 869
 870         o_nonembedded_window = [[VLCWindow alloc] initWithContentRect:[o_video_view frame] styleMask: NSBorderlessWindowMask|NSResizableWindowMask backing:NSBackingStoreBuffered defer:YES];
 871         [o_nonembedded_window setFrame:[o_video_view frame] display:NO];
 872         [o_nonembedded_window setBackgroundColor: [NSColor blackColor]];
 873         [o_nonembedded_window setMovableByWindowBackground: YES];
 874         [o_nonembedded_window setCanBecomeKeyWindow: YES];
 875         [o_nonembedded_window setHasShadow:YES];
 876         [o_nonembedded_window setContentView: o_video_view];
 877         [o_nonembedded_window setLevel:NSNormalWindowLevel];
 878         [o_nonembedded_window useOptimizedDrawing: YES];
 879         [o_nonembedded_window center];
 880         [o_nonembedded_window makeKeyAndOrderFront:self];
 881         [o_nonembedded_window orderFront:self animate:YES];
 882         [o_nonembedded_window setReleasedWhenClosed:NO];
 883         b_nonembedded = YES;
 884     }
 885
 886     if (p_vout)
 887     {
 888         if( var_GetBool( p_vout, "video-on-top" ) )
 889             [[o_video_view window] setLevel: NSStatusWindowLevel];
 890         else
 891             [[o_video_view window] setLevel: NSNormalWindowLevel];
 892         vlc_object_release( p_vout );
 893     }
 894     return o_video_view;
 895 }
 896
 897 - (void)setVideoplayEnabled
 898 {
 899     if (!b_nonembedded)
 900         [o_playlist_btn setEnabled: [[VLCMain sharedInstance] activeVideoPlayback]];
 901     else
 902     {
 903         [o_playlist_btn setEnabled: NO];
 904         if (![[VLCMain sharedInstance] activeVideoPlayback])
 905             [o_nonembedded_window orderOut: nil];
 906     }
 907 }
 908
 909 - (void)resizeWindow
 910 {
 911     if ( !b_fullscreen && !(OSX_LION && [NSApp currentSystemPresentationOptions] == NSApplicationPresentationFullScreen && b_nativeFullscreenMode) )
 912     {
 913         NSPoint topleftbase;
 914         NSPoint topleftscreen;
 915         NSRect new_frame;
 916         topleftbase.x = 0;
 917         topleftbase.y = [self frame].size.height;
 918         topleftscreen = [self convertBaseToScreen: topleftbase];
 919
 920         /* Calculate the window's new size */
 921         new_frame.size.width = [self frame].size.width - [o_video_view frame].size.width + nativeVideoSize.width;
 922         new_frame.size.height = [self frame].size.height - [o_video_view frame].size.height + nativeVideoSize.height;
 923
 924         new_frame.origin.x = topleftscreen.x;
 925         new_frame.origin.y = topleftscreen.y - new_frame.size.height;
 926
 927         [[self animator] setFrame:new_frame display:YES];
 928     }
 929 }
 930
 931 - (void)setNativeVideoSize:(NSSize)size
 932 {
 933     if (size.width != nativeVideoSize.width || size.height != nativeVideoSize.height )
 934     {
 935         nativeVideoSize = size;
 936         [self resizeWindow];
 937     }
 938 }
 939
 940 #pragma mark -
 941 #pragma mark Fullscreen support
 942 - (void)showFullscreenController
 943 {
 944     if (b_fullscreen)
 945         [o_fspanel fadeIn];
 946 }
 947
 948 - (BOOL)isFullscreen
 949 {
 950     return b_fullscreen;
 951 }
 952
 953 - (void)lockFullscreenAnimation
 954 {
 955     [o_animation_lock lock];
 956 }
 957
 958 - (void)unlockFullscreenAnimation
 959 {
 960     [o_animation_lock unlock];
 961 }
 962
 963 - (void)enterFullscreen
 964 {
 965     NSMutableDictionary *dict1, *dict2;
 966     NSScreen *screen;
 967     NSRect screen_rect;
 968     NSRect rect;
 969     vout_thread_t *p_vout = getVout();
 970     BOOL blackout_other_displays = config_GetInt( VLCIntf, "macosx-black" );
 971
 972     if( p_vout )
 973         screen = [NSScreen screenWithDisplayID:(CGDirectDisplayID)var_GetInteger( p_vout, "video-device" )];
 974
 975     [self lockFullscreenAnimation];
 976
 977     if (!screen)
 978     {
 979         msg_Dbg( VLCIntf, "chosen screen isn't present, using current screen for fullscreen mode" );
 980         screen = [self screen];
 981     }
 982     if (!screen)
 983     {
 984         msg_Dbg( VLCIntf, "Using deepest screen" );
 985         screen = [NSScreen deepestScreen];
 986     }
 987
 988     if( p_vout )
 989         vlc_object_release( p_vout );
 990
 991     screen_rect = [screen frame];
 992
 993     [o_fullscreen_btn setState: YES];
 994
 995     [NSCursor setHiddenUntilMouseMoves: YES];
 996
 997     if( blackout_other_displays )
 998         [screen blackoutOtherScreens];
 999
1000     /* Make sure we don't see the window flashes in float-on-top mode */
1001     i_originalLevel = [self level];
1002     [self setLevel:NSNormalWindowLevel];
1003
1004     /* Only create the o_fullscreen_window if we are not in the middle of the zooming animation */
1005     if (!o_fullscreen_window)
1006     {
1007         /* We can't change the styleMask of an already created NSWindow, so we create another window, and do eye catching stuff */
1008
1009         rect = [[o_video_view superview] convertRect: [o_video_view frame] toView: nil]; /* Convert to Window base coord */
1010         rect.origin.x += [self frame].origin.x;
1011         rect.origin.y += [self frame].origin.y;
1012         o_fullscreen_window = [[VLCWindow alloc] initWithContentRect:rect styleMask: NSBorderlessWindowMask backing:NSBackingStoreBuffered defer:YES];
1013         [o_fullscreen_window setBackgroundColor: [NSColor blackColor]];
1014         [o_fullscreen_window setCanBecomeKeyWindow: YES];
1015
1016         if (![self isVisible] || [self alphaValue] == 0.0)
1017         {
1018             /* We don't animate if we are not visible, instead we
1019              * simply fade the display */
1020             CGDisplayFadeReservationToken token;
1021
1022             if( blackout_other_displays )
1023             {
1024                 CGAcquireDisplayFadeReservation( kCGMaxDisplayReservationInterval, &token );
1025                 CGDisplayFade( token, 0.5, kCGDisplayBlendNormal, kCGDisplayBlendSolidColor, 0, 0, 0, YES );
1026             }
1027
1028             if ([screen isMainScreen])
1029             {
1030                 if (OSX_LEOPARD)
1031                     SetSystemUIMode( kUIModeAllHidden, kUIOptionAutoShowMenuBar);
1032                 else
1033                     [NSApp setPresentationOptions:(NSApplicationPresentationAutoHideDock | NSApplicationPresentationAutoHideMenuBar)];
1034             }
1035
1036             [[o_video_view superview] replaceSubview:o_video_view with:o_temp_view];
1037             [o_temp_view setFrame:[o_video_view frame]];
1038             [o_fullscreen_window setContentView:o_video_view];
1039
1040             [o_fullscreen_window makeKeyAndOrderFront:self];
1041             [o_fullscreen_window orderFront:self animate:YES];
1042
1043             [o_fullscreen_window setFrame:screen_rect display:YES animate:YES];
1044             [o_fullscreen_window setLevel:NSNormalWindowLevel];
1045
1046             if( blackout_other_displays )
1047             {
1048                 CGDisplayFade( token, 0.3, kCGDisplayBlendSolidColor, kCGDisplayBlendNormal, 0, 0, 0, NO );
1049                 CGReleaseDisplayFadeReservation( token );
1050             }
1051
1052             /* Will release the lock */
1053             [self hasBecomeFullscreen];
1054
1055             return;
1056         }
1057
1058         /* Make sure we don't see the o_video_view disappearing of the screen during this operation */
1059         NSDisableScreenUpdates();
1060         [[o_video_view superview] replaceSubview:o_video_view with:o_temp_view];
1061         [o_temp_view setFrame:[o_video_view frame]];
1062         [o_fullscreen_window setContentView:o_video_view];
1063         [o_fullscreen_window makeKeyAndOrderFront:self];
1064         NSEnableScreenUpdates();
1065     }
1066
1067     /* We are in fullscreen (and no animation is running) */
1068     if (b_fullscreen)
1069     {
1070         /* Make sure we are hidden */
1071         [super orderOut: self];
1072         [self unlockFullscreenAnimation];
1073         return;
1074     }
1075
1076     if (o_fullscreen_anim1)
1077     {
1078         [o_fullscreen_anim1 stopAnimation];
1079         [o_fullscreen_anim1 release];
1080     }
1081     if (o_fullscreen_anim2)
1082     {
1083         [o_fullscreen_anim2 stopAnimation];
1084         [o_fullscreen_anim2 release];
1085     }
1086
1087     if ([screen isMainScreen])
1088     {
1089         if (OSX_LEOPARD)
1090             SetSystemUIMode( kUIModeAllHidden, kUIOptionAutoShowMenuBar);
1091         else
1092             [NSApp setPresentationOptions:(NSApplicationPresentationAutoHideDock | NSApplicationPresentationAutoHideMenuBar)];
1093     }
1094
1095     dict1 = [[NSMutableDictionary alloc] initWithCapacity:2];
1096     dict2 = [[NSMutableDictionary alloc] initWithCapacity:3];
1097
1098     [dict1 setObject:self forKey:NSViewAnimationTargetKey];
1099     [dict1 setObject:NSViewAnimationFadeOutEffect forKey:NSViewAnimationEffectKey];
1100
1101     [dict2 setObject:o_fullscreen_window forKey:NSViewAnimationTargetKey];
1102     [dict2 setObject:[NSValue valueWithRect:[o_fullscreen_window frame]] forKey:NSViewAnimationStartFrameKey];
1103     [dict2 setObject:[NSValue valueWithRect:screen_rect] forKey:NSViewAnimationEndFrameKey];
1104
1105     /* Strategy with NSAnimation allocation:
1106      - Keep at most 2 animation at a time
1107      - leaveFullscreen/enterFullscreen are the only responsible for releasing and alloc-ing
1108      */
1109     o_fullscreen_anim1 = [[NSViewAnimation alloc] initWithViewAnimations:[NSArray arrayWithObject:dict1]];
1110     o_fullscreen_anim2 = [[NSViewAnimation alloc] initWithViewAnimations:[NSArray arrayWithObject:dict2]];
1111
1112     [dict1 release];
1113     [dict2 release];
1114
1115     [o_fullscreen_anim1 setAnimationBlockingMode: NSAnimationNonblocking];
1116     [o_fullscreen_anim1 setDuration: 0.3];
1117     [o_fullscreen_anim1 setFrameRate: 30];
1118     [o_fullscreen_anim2 setAnimationBlockingMode: NSAnimationNonblocking];
1119     [o_fullscreen_anim2 setDuration: 0.2];
1120     [o_fullscreen_anim2 setFrameRate: 30];
1121
1122     [o_fullscreen_anim2 setDelegate: self];
1123     [o_fullscreen_anim2 startWhenAnimation: o_fullscreen_anim1 reachesProgress: 1.0];
1124
1125     [o_fullscreen_anim1 startAnimation];
1126     /* fullscreenAnimation will be unlocked when animation ends */
1127 }
1128
1129 - (void)hasBecomeFullscreen
1130 {
1131     [o_fullscreen_window makeFirstResponder: o_video_view];
1132
1133     [o_fullscreen_window makeKeyWindow];
1134     [o_fullscreen_window setAcceptsMouseMovedEvents: TRUE];
1135
1136     /* tell the fspanel to move itself to front next time it's triggered */
1137     [o_fspanel setVoutWasUpdated: (int)[[o_fullscreen_window screen] displayID]];
1138     [o_fspanel setActive: nil];
1139
1140     if([self isVisible])
1141         [super orderOut: self];
1142
1143     [o_fspanel setActive: nil];
1144
1145     b_fullscreen = YES;
1146     [self unlockFullscreenAnimation];
1147 }
1148
1149 - (void)leaveFullscreen
1150 {
1151     [self leaveFullscreenAndFadeOut: NO];
1152 }
1153
1154 - (void)leaveFullscreenAndFadeOut: (BOOL)fadeout
1155 {
1156     NSMutableDictionary *dict1, *dict2;
1157     NSRect frame;
1158     BOOL blackout_other_displays = config_GetInt( VLCIntf, "macosx-black" );
1159
1160     [self lockFullscreenAnimation];
1161
1162     b_fullscreen = NO;
1163     [o_fullscreen_btn setState: NO];
1164
1165     /* We always try to do so */
1166     [NSScreen unblackoutScreens];
1167     vout_thread_t *p_vout = getVout();
1168     if (p_vout)
1169     {
1170         if( var_GetBool( p_vout, "video-on-top" ) )
1171             [[o_video_view window] setLevel: NSStatusWindowLevel];
1172         else
1173             [[o_video_view window] setLevel: NSNormalWindowLevel];
1174         vlc_object_release( p_vout );
1175     }
1176     [[o_video_view window] makeKeyAndOrderFront: nil];
1177
1178     /* Don't do anything if o_fullscreen_window is already closed */
1179     if (!o_fullscreen_window)
1180     {
1181         [self unlockFullscreenAnimation];
1182         return;
1183     }
1184
1185     if (fadeout)
1186     {
1187         /* We don't animate if we are not visible, instead we
1188          * simply fade the display */
1189         CGDisplayFadeReservationToken token;
1190
1191         if( blackout_other_displays )
1192         {
1193             CGAcquireDisplayFadeReservation( kCGMaxDisplayReservationInterval, &token );
1194             CGDisplayFade( token, 0.3, kCGDisplayBlendNormal, kCGDisplayBlendSolidColor, 0, 0, 0, YES );
1195         }
1196
1197         [o_fspanel setNonActive: nil];
1198         if (OSX_LEOPARD)
1199             SetSystemUIMode( kUIModeNormal, kUIOptionAutoShowMenuBar);
1200         else
1201             [NSApp setPresentationOptions:(NSApplicationPresentationDefault)];
1202
1203         /* Will release the lock */
1204         [self hasEndedFullscreen];
1205
1206         /* Our window is hidden, and might be faded. We need to workaround that, so note it
1207          * here */
1208         b_window_is_invisible = YES;
1209
1210         if( blackout_other_displays )
1211         {
1212             CGDisplayFade( token, 0.5, kCGDisplayBlendSolidColor, kCGDisplayBlendNormal, 0, 0, 0, NO );
1213             CGReleaseDisplayFadeReservation( token );
1214         }
1215
1216         return;
1217     }
1218
1219     [self setAlphaValue: 0.0];
1220     [self orderFront: self];
1221     [[o_video_view window] orderFront: self];
1222
1223     [o_fspanel setNonActive: nil];
1224     if (OSX_LEOPARD)
1225         SetSystemUIMode( kUIModeNormal, kUIOptionAutoShowMenuBar);
1226     else
1227         [NSApp setPresentationOptions:(NSApplicationPresentationDefault)];
1228
1229     if (o_fullscreen_anim1)
1230     {
1231         [o_fullscreen_anim1 stopAnimation];
1232         [o_fullscreen_anim1 release];
1233     }
1234     if (o_fullscreen_anim2)
1235     {
1236         [o_fullscreen_anim2 stopAnimation];
1237         [o_fullscreen_anim2 release];
1238     }
1239
1240     frame = [[o_temp_view superview] convertRect: [o_temp_view frame] toView: nil]; /* Convert to Window base coord */
1241     frame.origin.x += [self frame].origin.x;
1242     frame.origin.y += [self frame].origin.y;
1243
1244     dict2 = [[NSMutableDictionary alloc] initWithCapacity:2];
1245     [dict2 setObject:self forKey:NSViewAnimationTargetKey];
1246     [dict2 setObject:NSViewAnimationFadeInEffect forKey:NSViewAnimationEffectKey];
1247
1248     o_fullscreen_anim2 = [[NSViewAnimation alloc] initWithViewAnimations:[NSArray arrayWithObjects:dict2, nil]];
1249     [dict2 release];
1250
1251     [o_fullscreen_anim2 setAnimationBlockingMode: NSAnimationNonblocking];
1252     [o_fullscreen_anim2 setDuration: 0.3];
1253     [o_fullscreen_anim2 setFrameRate: 30];
1254
1255     [o_fullscreen_anim2 setDelegate: self];
1256
1257     dict1 = [[NSMutableDictionary alloc] initWithCapacity:3];
1258
1259     [dict1 setObject:o_fullscreen_window forKey:NSViewAnimationTargetKey];
1260     [dict1 setObject:[NSValue valueWithRect:[o_fullscreen_window frame]] forKey:NSViewAnimationStartFrameKey];
1261     [dict1 setObject:[NSValue valueWithRect:frame] forKey:NSViewAnimationEndFrameKey];
1262
1263     o_fullscreen_anim1 = [[NSViewAnimation alloc] initWithViewAnimations:[NSArray arrayWithObjects:dict1, nil]];
1264     [dict1 release];
1265
1266     [o_fullscreen_anim1 setAnimationBlockingMode: NSAnimationNonblocking];
1267     [o_fullscreen_anim1 setDuration: 0.2];
1268     [o_fullscreen_anim1 setFrameRate: 30];
1269     [o_fullscreen_anim2 startWhenAnimation: o_fullscreen_anim1 reachesProgress: 1.0];
1270
1271     /* Make sure o_fullscreen_window is the frontmost window */
1272     [o_fullscreen_window orderFront: self];
1273
1274     [o_fullscreen_anim1 startAnimation];
1275     /* fullscreenAnimation will be unlocked when animation ends */
1276 }
1277
1278 - (void)hasEndedFullscreen
1279 {
1280     /* This function is private and should be only triggered at the end of the fullscreen change animation */
1281     /* Make sure we don't see the o_video_view disappearing of the screen during this operation */
1282     NSDisableScreenUpdates();
1283     [o_video_view retain];
1284     [o_video_view removeFromSuperviewWithoutNeedingDisplay];
1285     [[o_temp_view superview] replaceSubview:o_temp_view with:o_video_view];
1286     [o_video_view release];
1287     [o_video_view setFrame:[o_temp_view frame]];
1288     [self makeFirstResponder: o_video_view];
1289     if ([self isVisible])
1290         [super makeKeyAndOrderFront:self]; /* our version contains a workaround */
1291     [o_fullscreen_window orderOut: self];
1292     NSEnableScreenUpdates();
1293
1294     [o_fullscreen_window release];
1295     o_fullscreen_window = nil;
1296     [self setLevel:i_originalLevel];
1297
1298     [self unlockFullscreenAnimation];
1299 }
1300
1301 - (void)animationDidEnd:(NSAnimation*)animation
1302 {
1303     NSArray *viewAnimations;
1304     if( o_makekey_anim == animation )
1305     {
1306         [o_makekey_anim release];
1307         return;
1308     }
1309     if ([animation currentValue] < 1.0)
1310         return;
1311
1312     /* Fullscreen ended or started (we are a delegate only for leaveFullscreen's/enterFullscren's anim2) */
1313     viewAnimations = [o_fullscreen_anim2 viewAnimations];
1314     if ([viewAnimations count] >=1 &&
1315         [[[viewAnimations objectAtIndex: 0] objectForKey: NSViewAnimationEffectKey] isEqualToString:NSViewAnimationFadeInEffect])
1316     {
1317         /* Fullscreen ended */
1318         [self hasEndedFullscreen];
1319     }
1320     else
1321     {
1322         /* Fullscreen started */
1323         [self hasBecomeFullscreen];
1324     }
1325 }
1326
1327 - (void)orderOut: (id)sender
1328 {
1329     [super orderOut: sender];
1330
1331     /* Make sure we leave fullscreen */
1332     [self leaveFullscreenAndFadeOut: YES];
1333 }
1334
1335 - (void)makeKeyAndOrderFront: (id)sender
1336 {
1337     /* Hack
1338      * when we exit fullscreen and fade out, we may endup in
1339      * having a window that is faded. We can't have it fade in unless we
1340      * animate again. */
1341
1342     if(!b_window_is_invisible)
1343     {
1344         /* Make sure we don't do it too much */
1345         [super makeKeyAndOrderFront: sender];
1346         return;
1347     }
1348
1349     [super setAlphaValue:0.0f];
1350     [super makeKeyAndOrderFront: sender];
1351
1352     NSMutableDictionary * dict = [[NSMutableDictionary alloc] initWithCapacity:2];
1353     [dict setObject:self forKey:NSViewAnimationTargetKey];
1354     [dict setObject:NSViewAnimationFadeInEffect forKey:NSViewAnimationEffectKey];
1355
1356     o_makekey_anim = [[NSViewAnimation alloc] initWithViewAnimations:[NSArray arrayWithObject:dict]];
1357     [dict release];
1358
1359     [o_makekey_anim setAnimationBlockingMode: NSAnimationNonblocking];
1360     [o_makekey_anim setDuration: 0.1];
1361     [o_makekey_anim setFrameRate: 30];
1362     [o_makekey_anim setDelegate: self];
1363
1364     [o_makekey_anim startAnimation];
1365     b_window_is_invisible = NO;
1366
1367     /* fullscreenAnimation will be unlocked when animation ends */
1368 }
1369
1370 /* Make sure setFrame gets executed on main thread especially if we are animating.
1371  * (Thus we won't block the video output thread) */
1372 - (void)setFrame:(NSRect)frame display:(BOOL)display animate:(BOOL)animate
1373 {
1374     struct { NSRect frame; BOOL display; BOOL animate;} args;
1375     NSData *packedargs;
1376
1377     args.frame = frame;
1378     args.display = display;
1379     args.animate = animate;
1380
1381     packedargs = [NSData dataWithBytes:&args length:sizeof(args)];
1382
1383     [self performSelectorOnMainThread:@selector(setFrameOnMainThread:)
1384                            withObject: packedargs waitUntilDone: YES];
1385 }
1386
1387 - (void)setFrameOnMainThread:(NSData*)packedargs
1388 {
1389     struct args { NSRect frame; BOOL display; BOOL animate; } * args = (struct args*)[packedargs bytes];
1390
1391     if( args->animate )
1392     {
1393         /* Make sure we don't block too long and set up a non blocking animation */
1394         NSDictionary * dict = [NSDictionary dictionaryWithObjectsAndKeys:
1395                                self, NSViewAnimationTargetKey,
1396                                [NSValue valueWithRect:[self frame]], NSViewAnimationStartFrameKey,
1397                                [NSValue valueWithRect:args->frame], NSViewAnimationEndFrameKey, nil];
1398
1399         NSViewAnimation * anim = [[NSViewAnimation alloc] initWithViewAnimations:[NSArray arrayWithObject:dict]];
1400
1401         [anim setAnimationBlockingMode: NSAnimationNonblocking];
1402         [anim setDuration: 0.4];
1403         [anim setFrameRate: 30];
1404         [anim startAnimation];
1405
1406         [anim release];
1407     }
1408     else {
1409         [super setFrame:args->frame display:args->display animate:args->animate];
1410     }
1411 }
1412
1413 #pragma mark -
1414 #pragma mark Lion's native fullscreen handling
1415 - (void)windowWillEnterFullScreen:(NSNotification *)notification
1416 {
1417     [NSCursor setHiddenUntilMouseMoves: YES];
1418 }
1419
1420 - (void)windowWillExitFullScreen:(NSNotification *)notification
1421 {
1422     [NSCursor setHiddenUntilMouseMoves: NO];
1423 }
1424
1425 #pragma mark -
1426 #pragma mark Side Bar Data handling
1427 /* taken under BSD-new from the PXSourceList sample project, adapted for VLC */
1428 - (NSUInteger)sourceList:(PXSourceList*)sourceList numberOfChildrenOfItem:(id)item
1429 {
1430         //Works the same way as the NSOutlineView data source: `nil` means a parent item
1431         if(item==nil) {
1432                 return [o_sidebaritems count];
1433         }
1434         else {
1435                 return [[item children] count];
1436         }
1437 }
1438
1439
1440 - (id)sourceList:(PXSourceList*)aSourceList child:(NSUInteger)index ofItem:(id)item
1441 {
1442     //Works the same way as the NSOutlineView data source: `nil` means a parent item
1443         if(item==nil) {
1444                 return [o_sidebaritems objectAtIndex:index];
1445         }
1446         else {
1447                 return [[item children] objectAtIndex:index];
1448         }
1449 }
1450
1451
1452 - (id)sourceList:(PXSourceList*)aSourceList objectValueForItem:(id)item
1453 {
1454         return [item title];
1455 }
1456
1457 - (void)sourceList:(PXSourceList*)aSourceList setObjectValue:(id)object forItem:(id)item
1458 {
1459         [item setTitle:object];
1460 }
1461
1462 - (BOOL)sourceList:(PXSourceList*)aSourceList isItemExpandable:(id)item
1463 {
1464         return [item hasChildren];
1465 }
1466
1467
1468 - (BOOL)sourceList:(PXSourceList*)aSourceList itemHasBadge:(id)item
1469 {
1470     if ([[item identifier] isEqualToString: @"playlist"])
1471         return YES;
1472
1473         return [item hasBadge];
1474 }
1475
1476
1477 - (NSInteger)sourceList:(PXSourceList*)aSourceList badgeValueForItem:(id)item
1478 {
1479     if ([[item identifier] isEqualToString: @"playlist"]) {
1480         playlist_t * p_playlist = pl_Get( VLCIntf );
1481         NSInteger i_playlist_size;
1482
1483         PL_LOCK;
1484         i_playlist_size = playlist_CurrentSize( p_playlist );
1485         PL_UNLOCK;
1486
1487         return i_playlist_size;
1488     }
1489         return [item badgeValue];
1490 }
1491
1492
1493 - (BOOL)sourceList:(PXSourceList*)aSourceList itemHasIcon:(id)item
1494 {
1495         return [item hasIcon];
1496 }
1497
1498
1499 - (NSImage*)sourceList:(PXSourceList*)aSourceList iconForItem:(id)item
1500 {
1501         return [item icon];
1502 }
1503
1504 - (NSMenu*)sourceList:(PXSourceList*)aSourceList menuForEvent:(NSEvent*)theEvent item:(id)item
1505 {
1506         if ([theEvent type] == NSRightMouseDown || ([theEvent type] == NSLeftMouseDown && ([theEvent modifierFlags] & NSControlKeyMask) == NSControlKeyMask)) {
1507                 NSMenu * m = [[NSMenu alloc] init];
1508                 if (item != nil)
1509                         [m addItemWithTitle:[item title] action:nil keyEquivalent:@""];
1510                 return [m autorelease];
1511         }
1512         return nil;
1513 }
1514
1515 #pragma mark -
1516 #pragma mark Side Bar Delegate Methods
1517 /* taken under BSD-new from the PXSourceList sample project, adapted for VLC */
1518 - (BOOL)sourceList:(PXSourceList*)aSourceList isGroupAlwaysExpanded:(id)group
1519 {
1520         if([[group identifier] isEqualToString:@"library"])
1521                 return YES;
1522
1523         return NO;
1524 }
1525
1526 - (void)sourceListSelectionDidChange:(NSNotification *)notification
1527 {
1528         NSIndexSet *selectedIndexes = [o_sidebar_view selectedRowIndexes];
1529
1530         //Set the label text to represent the new selection
1531     if([selectedIndexes count]==1) {
1532                 NSString *title = [[o_sidebar_view itemAtRow:[selectedIndexes firstIndex]] title];
1533
1534                 [o_chosen_category_lbl setStringValue:title];
1535         }
1536         else {
1537                 [o_chosen_category_lbl setStringValue:@"(none)"];
1538         }
1539 }
1540
1541 @end
1542
1543 @implementation VLCProgressBarGradientEffect
1544 - (void)dealloc
1545 {
1546     [o_time_sld_gradient_left_img release];
1547     [o_time_sld_gradient_middle_img release];
1548     [o_time_sld_gradient_right_img release];
1549     [super dealloc];
1550 }
1551
1552 - (void)loadImagesInDarkStyle: (BOOL)b_value
1553 {
1554     if (b_value)
1555     {
1556         o_time_sld_gradient_left_img = [[NSImage imageNamed:@"progressbar-fill-left_dark"] retain];
1557         o_time_sld_gradient_middle_img = [[NSImage imageNamed:@"progressbar-fill-middle_dark"] retain];
1558         o_time_sld_gradient_right_img = [[NSImage imageNamed:@"progressbar-fill-right_dark"] retain];
1559     }
1560     else
1561     {
1562         o_time_sld_gradient_left_img = [[NSImage imageNamed:@"progression-fill-left"] retain];
1563         o_time_sld_gradient_middle_img = [[NSImage imageNamed:@"progression-fill-middle"] retain];
1564         o_time_sld_gradient_right_img = [[NSImage imageNamed:@"progression-fill-right"] retain];
1565     }
1566 }
1567
1568 - (void)drawRect:(NSRect)rect
1569 {
1570     NSRect bnds = [self bounds];
1571     NSDrawThreePartImage( bnds, o_time_sld_gradient_left_img, o_time_sld_gradient_middle_img, o_time_sld_gradient_right_img, NO, NSCompositeSourceOver, 1, NO );
1572 }
1573 @end