MainController.m

   1 #import "MainController.h"
   2 #import "MenuController.h"
   3 #import "PreferencesController.h"
   4 #import <ITKit/ITHotKeyCenter.h>
   5 #import <ITKit/ITHotKey.h>
   6 #import <ITKit/ITKeyCombo.h>
   7 #import "StatusWindow.h"
   8 #import "StatusWindowController.h"
   9 #import "StatusItemHack.h"
  10
  11 @interface MainController(Private)
  12 - (ITMTRemote *)loadRemote;
  13 - (void)timerUpdate;
  14 - (void)setLatestSongIdentifier:(NSString *)newIdentifier;
  15 - (void)showCurrentTrackInfo;
  16 - (void)applicationLaunched:(NSNotification *)note;
  17 - (void)applicationTerminated:(NSNotification *)note;
  18 @end
  19
  20 static MainController *sharedController;
  21
  22 @implementation MainController
  23
  24 + (MainController *)sharedController
  25 {
  26     return sharedController;
  27 }
  28
  29 /*************************************************************************/
  30 #pragma mark -
  31 #pragma mark INITIALIZATION/DEALLOCATION METHODS
  32 /*************************************************************************/
  33
  34 - (id)init
  35 {
  36     if ( ( self = [super init] ) ) {
  37         sharedController = self;
  38
  39         remoteArray = [[NSMutableArray alloc] initWithCapacity:1];
  40         statusWindowController = [StatusWindowController sharedController];
  41         menuController = [[MenuController alloc] init];
  42         df = [[NSUserDefaults standardUserDefaults] retain];
  43         timerUpdating = NO;
  44     }
  45     return self;
  46 }
  47
  48 - (void)applicationDidFinishLaunching:(NSNotification *)note
  49 {
  50     //Turn on debug mode if needed
  51     if ([df boolForKey:@"ITDebugMode"]) {
  52         SetITDebugMode(YES);
  53     }
  54
  55     currentRemote = [self loadRemote];
  56     [currentRemote begin];
  57
  58     //Setup for notification of the remote player launching or quitting
  59     [[[NSWorkspace sharedWorkspace] notificationCenter]
  60             addObserver:self
  61             selector:@selector(applicationTerminated:)
  62             name:NSWorkspaceDidTerminateApplicationNotification
  63             object:nil];
  64
  65     [[[NSWorkspace sharedWorkspace] notificationCenter]
  66             addObserver:self
  67             selector:@selector(applicationLaunched:)
  68             name:NSWorkspaceDidLaunchApplicationNotification
  69             object:nil];
  70
  71     if ( ! [df objectForKey:@"menu"] ) {  // If this is nil, defaults have never been registered.
  72         [[PreferencesController sharedPrefs] registerDefaults];
  73     }
  74
  75     [StatusItemHack install];
  76     statusItem = [[ITStatusItem alloc]
  77             initWithStatusBar:[NSStatusBar systemStatusBar]
  78             withLength:NSSquareStatusItemLength];
  79
  80     bling = [[MTBlingController alloc] init];
  81     [self blingTime];
  82     registerTimer = [[NSTimer scheduledTimerWithTimeInterval:10.0
  83                              target:self
  84                              selector:@selector(blingTime)
  85                              userInfo:nil
  86                              repeats:YES] retain];
  87
  88     if ([currentRemote playerRunningState] == ITMTRemotePlayerRunning) {
  89         [self applicationLaunched:nil];
  90     } else {
  91         if ([df boolForKey:@"LaunchPlayerWithMT"])
  92             [self showPlayer];
  93         else
  94             [self applicationTerminated:nil];
  95     }
  96
  97     [statusItem setImage:[NSImage imageNamed:@"MenuNormal"]];
  98     [statusItem setAlternateImage:[NSImage imageNamed:@"MenuInverted"]];
  99
 100     [NSApp deactivate];
 101 }
 102
 103 - (ITMTRemote *)loadRemote
 104 {
 105     NSString *folderPath = [[NSBundle mainBundle] builtInPlugInsPath];
 106     ITDebugLog(@"Gathering remotes.");
 107     if (folderPath) {
 108         NSArray      *bundlePathList = [NSBundle pathsForResourcesOfType:@"remote" inDirectory:folderPath];
 109         NSEnumerator *enumerator     = [bundlePathList objectEnumerator];
 110         NSString     *bundlePath;
 111
 112         while ( (bundlePath = [enumerator nextObject]) ) {
 113             NSBundle* remoteBundle = [NSBundle bundleWithPath:bundlePath];
 114
 115             if (remoteBundle) {
 116                 Class remoteClass = [remoteBundle principalClass];
 117
 118                 if ([remoteClass conformsToProtocol:@protocol(ITMTRemote)] &&
 119                     [remoteClass isKindOfClass:[NSObject class]]) {
 120                     id remote = [remoteClass remote];
 121                     ITDebugLog(@"Adding remote at path %@", bundlePath);
 122                     [remoteArray addObject:remote];
 123                 }
 124             }
 125         }
 126
 127 //      if ( [remoteArray count] > 0 ) {  // UNCOMMENT WHEN WE HAVE > 1 PLUGIN
 128 //          if ( [remoteArray count] > 1 ) {
 129 //              [remoteArray sortUsingSelector:@selector(sortAlpha:)];
 130 //          }
 131 //          [self loadModuleAccessUI]; //Comment out this line to disable remote visibility
 132 //      }
 133     }
 134 //  NSLog(@"%@", [remoteArray objectAtIndex:0]);  //DEBUG
 135     return [remoteArray objectAtIndex:0];
 136 }
 137
 138 /*************************************************************************/
 139 #pragma mark -
 140 #pragma mark INSTANCE METHODS
 141 /*************************************************************************/
 142
 143 /*- (void)startTimerInNewThread
 144 {
 145     NSAutoreleasePool *pool = [[NSAutoreleasePool alloc] init];
 146     NSRunLoop *runLoop = [NSRunLoop currentRunLoop];
 147     refreshTimer = [[NSTimer scheduledTimerWithTimeInterval:0.5
 148                              target:self
 149                              selector:@selector(timerUpdate)
 150                              userInfo:nil
 151                              repeats:YES] retain];
 152     [runLoop run];
 153     ITDebugLog(@"Timer started.");
 154     [pool release];
 155 }*/
 156
 157 - (void)setBlingTime:(NSDate*)date
 158 {
 159     NSMutableDictionary *globalPrefs;
 160     [df synchronize];
 161     globalPrefs = [[df persistentDomainForName:@".GlobalPreferences"] mutableCopy];
 162     [globalPrefs setObject:date forKey:@"ITMTTrialStart"];
 163     [df setPersistentDomain:globalPrefs forName:@".GlobalPreferences"];
 164     [df synchronize];
 165     [globalPrefs release];
 166 }
 167
 168 - (NSDate*)getBlingTime
 169 {
 170     [df synchronize];
 171     return [[df persistentDomainForName:@".GlobalPreferences"] objectForKey:@"ITMTTrialStart"];
 172 }
 173
 174 - (void)blingTime
 175 {
 176     NSDate *now = [NSDate date];
 177     if ( (! [self getBlingTime] ) || ([now timeIntervalSinceDate:[self getBlingTime]] < 0) ) {
 178         [self setBlingTime:now];
 179     }
 180     if ( ([now timeIntervalSinceDate:[self getBlingTime]] >= 604800) ) {
 181         [statusItem setEnabled:NO];
 182         [self clearHotKeys];
 183         if ([refreshTimer isValid]) {
 184         [refreshTimer invalidate];
 185         }
 186         if ([registerTimer isValid]) {
 187         [registerTimer invalidate];
 188         }
 189         [statusWindowController showRegistrationQueryWindow];
 190     }
 191 }
 192
 193 - (void)blingNow
 194 {
 195     [bling showPanel];
 196 }
 197
 198 - (BOOL)blingBling
 199 {
 200     if ( ! ([bling checkDone] == 2475) ) {
 201         return NO;
 202     } else {
 203         return YES;
 204     }
 205 }
 206
 207 - (BOOL)songIsPlaying
 208 {
 209     return ( ! ([[currentRemote playerStateUniqueIdentifier] isEqualToString:@"0-0"]) );
 210 }
 211
 212 - (BOOL)radioIsPlaying
 213 {
 214     return ( [currentRemote currentPlaylistClass] == ITMTRemotePlayerRadioPlaylist );
 215 }
 216
 217 - (BOOL)songChanged
 218 {
 219     return ( ! [[currentRemote playerStateUniqueIdentifier] isEqualToString:_latestSongIdentifier] );
 220 }
 221
 222 - (NSString *)latestSongIdentifier
 223 {
 224     return _latestSongIdentifier;
 225 }
 226
 227 - (void)setLatestSongIdentifier:(NSString *)newIdentifier
 228 {
 229     ITDebugLog(@"Setting latest song identifier to %@", newIdentifier);
 230     [_latestSongIdentifier autorelease];
 231     _latestSongIdentifier = [newIdentifier copy];
 232 }
 233
 234 - (void)timerUpdate
 235 {
 236     if ( [self songChanged] && (timerUpdating != YES) ) {
 237         ITDebugLog(@"The song changed.");
 238         timerUpdating = YES;
 239         latestPlaylistClass = [currentRemote currentPlaylistClass];
 240         [menuController rebuildSubmenus];
 241
 242         if ( [df boolForKey:@"showSongInfoOnChange"] ) {
 243             [self performSelector:@selector(showCurrentTrackInfo) withObject:nil afterDelay:0.0];
 244         }
 245
 246         [self setLatestSongIdentifier:[currentRemote playerStateUniqueIdentifier]];
 247
 248         timerUpdating = NO;
 249     }
 250 }
 251
 252 - (void)menuClicked
 253 {
 254     ITDebugLog(@"Menu clicked.");
 255     if ([currentRemote playerRunningState] == ITMTRemotePlayerRunning) {
 256         [statusItem setMenu:[menuController menu]];
 257     } else {
 258         [statusItem setMenu:[menuController menuForNoPlayer]];
 259     }
 260 }
 261
 262 //
 263 //
 264 // Menu Selectors
 265 //
 266 //
 267
 268 - (void)playPause
 269 {
 270     ITMTRemotePlayerPlayingState state = [currentRemote playerPlayingState];
 271     ITDebugLog(@"Play/Pause toggled");
 272     if (state == ITMTRemotePlayerPlaying) {
 273         [currentRemote pause];
 274     } else if ((state == ITMTRemotePlayerForwarding) || (state == ITMTRemotePlayerRewinding)) {
 275         [currentRemote pause];
 276         [currentRemote play];
 277     } else {
 278         [currentRemote play];
 279     }
 280     [self timerUpdate];
 281 }
 282
 283 - (void)nextSong
 284 {
 285     ITDebugLog(@"Going to next song.");
 286     [currentRemote goToNextSong];
 287     [self timerUpdate];
 288 }
 289
 290 - (void)prevSong
 291 {
 292     ITDebugLog(@"Going to previous song.");
 293     [currentRemote goToPreviousSong];
 294     [self timerUpdate];
 295 }
 296
 297 - (void)fastForward
 298 {
 299     ITDebugLog(@"Fast forwarding.");
 300     [currentRemote forward];
 301     [self timerUpdate];
 302 }
 303
 304 - (void)rewind
 305 {
 306     ITDebugLog(@"Rewinding.");
 307     [currentRemote rewind];
 308     [self timerUpdate];
 309 }
 310
 311 - (void)selectPlaylistAtIndex:(int)index
 312 {
 313     ITDebugLog(@"Selecting playlist %i", index);
 314     [currentRemote switchToPlaylistAtIndex:index];
 315     [self timerUpdate];
 316 }
 317
 318 - (void)selectSongAtIndex:(int)index
 319 {
 320     ITDebugLog(@"Selecting song %i", index);
 321     [currentRemote switchToSongAtIndex:index];
 322     [self timerUpdate];
 323 }
 324
 325 - (void)selectSongRating:(int)rating
 326 {
 327     ITDebugLog(@"Selecting song rating %i", rating);
 328     [currentRemote setCurrentSongRating:(float)rating / 100.0];
 329     [self timerUpdate];
 330 }
 331
 332 - (void)selectEQPresetAtIndex:(int)index
 333 {
 334     ITDebugLog(@"Selecting EQ preset %i", index);
 335     [currentRemote switchToEQAtIndex:index];
 336     [self timerUpdate];
 337 }
 338
 339 - (void)showPlayer
 340 {
 341     ITDebugLog(@"Beginning show player.");
 342     if ( ( playerRunningState == ITMTRemotePlayerRunning) ) {
 343         ITDebugLog(@"Showing player interface.");
 344         [currentRemote showPrimaryInterface];
 345     } else {
 346         ITDebugLog(@"Launching player.");
 347         if (![[NSWorkspace sharedWorkspace] launchApplication:[currentRemote playerFullName]]) {
 348             ITDebugLog(@"Error Launching Player");
 349         }
 350     }
 351     ITDebugLog(@"Finished show player.");
 352 }
 353
 354 - (void)showPreferences
 355 {
 356     ITDebugLog(@"Show preferences.");
 357     [[PreferencesController sharedPrefs] setController:self];
 358     [[PreferencesController sharedPrefs] showPrefsWindow:self];
 359 }
 360
 361 - (void)quitMenuTunes
 362 {
 363     ITDebugLog(@"Quitting MenuTunes.");
 364     [NSApp terminate:self];
 365 }
 366
 367 //
 368 //
 369
 370 - (void)closePreferences
 371 {
 372     ITDebugLog(@"Preferences closed.");
 373     if ( ( playerRunningState == ITMTRemotePlayerRunning) ) {
 374         [self setupHotKeys];
 375     }
 376 }
 377
 378 - (ITMTRemote *)currentRemote
 379 {
 380     return currentRemote;
 381 }
 382
 383 //
 384 //
 385 // Hot key setup
 386 //
 387 //
 388
 389 - (void)clearHotKeys
 390 {
 391     NSEnumerator *hotKeyEnumerator = [[[ITHotKeyCenter sharedCenter] allHotKeys] objectEnumerator];
 392     ITHotKey *nextHotKey;
 393     ITDebugLog(@"Clearing hot keys.");
 394     while ( (nextHotKey = [hotKeyEnumerator nextObject]) ) {
 395         [[ITHotKeyCenter sharedCenter] unregisterHotKey:nextHotKey];
 396     }
 397     ITDebugLog(@"Done clearing hot keys.");
 398 }
 399
 400 - (void)setupHotKeys
 401 {
 402     ITHotKey *hotKey;
 403     ITDebugLog(@"Setting up hot keys.");
 404
 405     if (playerRunningState == ITMTRemotePlayerNotRunning) {
 406         return;
 407     }
 408
 409     if ([df objectForKey:@"PlayPause"] != nil) {
 410         ITDebugLog(@"Setting up play pause hot key.");
 411         hotKey = [[ITHotKey alloc] init];
 412         [hotKey setName:@"PlayPause"];
 413         [hotKey setKeyCombo:[ITKeyCombo keyComboWithPlistRepresentation:[df objectForKey:@"PlayPause"]]];
 414         [hotKey setTarget:self];
 415         [hotKey setAction:@selector(playPause)];
 416         [[ITHotKeyCenter sharedCenter] registerHotKey:[hotKey autorelease]];
 417     }
 418
 419     if ([df objectForKey:@"NextTrack"] != nil) {
 420         ITDebugLog(@"Setting up next track hot key.");
 421         hotKey = [[ITHotKey alloc] init];
 422         [hotKey setName:@"NextTrack"];
 423         [hotKey setKeyCombo:[ITKeyCombo keyComboWithPlistRepresentation:[df objectForKey:@"NextTrack"]]];
 424         [hotKey setTarget:self];
 425         [hotKey setAction:@selector(nextSong)];
 426         [[ITHotKeyCenter sharedCenter] registerHotKey:[hotKey autorelease]];
 427     }
 428
 429     if ([df objectForKey:@"PrevTrack"] != nil) {
 430         ITDebugLog(@"Setting up previous track hot key.");
 431         hotKey = [[ITHotKey alloc] init];
 432         [hotKey setName:@"PrevTrack"];
 433         [hotKey setKeyCombo:[ITKeyCombo keyComboWithPlistRepresentation:[df objectForKey:@"PrevTrack"]]];
 434         [hotKey setTarget:self];
 435         [hotKey setAction:@selector(prevSong)];
 436         [[ITHotKeyCenter sharedCenter] registerHotKey:[hotKey autorelease]];
 437     }
 438
 439     if ([df objectForKey:@"ShowPlayer"] != nil) {
 440         ITDebugLog(@"Setting up show player hot key.");
 441         hotKey = [[ITHotKey alloc] init];
 442         [hotKey setName:@"ShowPlayer"];
 443         [hotKey setKeyCombo:[ITKeyCombo keyComboWithPlistRepresentation:[df objectForKey:@"ShowPlayer"]]];
 444         [hotKey setTarget:self];
 445         [hotKey setAction:@selector(showPlayer)];
 446         [[ITHotKeyCenter sharedCenter] registerHotKey:[hotKey autorelease]];
 447     }
 448
 449     if ([df objectForKey:@"TrackInfo"] != nil) {
 450         ITDebugLog(@"Setting up track info hot key.");
 451         hotKey = [[ITHotKey alloc] init];
 452         [hotKey setName:@"TrackInfo"];
 453         [hotKey setKeyCombo:[ITKeyCombo keyComboWithPlistRepresentation:[df objectForKey:@"TrackInfo"]]];
 454         [hotKey setTarget:self];
 455         [hotKey setAction:@selector(showCurrentTrackInfo)];
 456         [[ITHotKeyCenter sharedCenter] registerHotKey:[hotKey autorelease]];
 457     }
 458
 459     if ([df objectForKey:@"UpcomingSongs"] != nil) {
 460         ITDebugLog(@"Setting up upcoming songs hot key.");
 461         hotKey = [[ITHotKey alloc] init];
 462         [hotKey setName:@"UpcomingSongs"];
 463         [hotKey setKeyCombo:[ITKeyCombo keyComboWithPlistRepresentation:[df objectForKey:@"UpcomingSongs"]]];
 464         [hotKey setTarget:self];
 465         [hotKey setAction:@selector(showUpcomingSongs)];
 466         [[ITHotKeyCenter sharedCenter] registerHotKey:[hotKey autorelease]];
 467     }
 468
 469     if ([df objectForKey:@"ToggleLoop"] != nil) {
 470         ITDebugLog(@"Setting up toggle loop hot key.");
 471         hotKey = [[ITHotKey alloc] init];
 472         [hotKey setName:@"ToggleLoop"];
 473         [hotKey setKeyCombo:[ITKeyCombo keyComboWithPlistRepresentation:[df objectForKey:@"ToggleLoop"]]];
 474         [hotKey setTarget:self];
 475         [hotKey setAction:@selector(toggleLoop)];
 476         [[ITHotKeyCenter sharedCenter] registerHotKey:[hotKey autorelease]];
 477     }
 478
 479     if ([df objectForKey:@"ToggleShuffle"] != nil) {
 480         ITDebugLog(@"Setting up toggle shuffle hot key.");
 481         hotKey = [[ITHotKey alloc] init];
 482         [hotKey setName:@"ToggleShuffle"];
 483         [hotKey setKeyCombo:[ITKeyCombo keyComboWithPlistRepresentation:[df objectForKey:@"ToggleShuffle"]]];
 484         [hotKey setTarget:self];
 485         [hotKey setAction:@selector(toggleShuffle)];
 486         [[ITHotKeyCenter sharedCenter] registerHotKey:[hotKey autorelease]];
 487     }
 488
 489     if ([df objectForKey:@"IncrementVolume"] != nil) {
 490         ITDebugLog(@"Setting up increment volume hot key.");
 491         hotKey = [[ITHotKey alloc] init];
 492         [hotKey setName:@"IncrementVolume"];
 493         [hotKey setKeyCombo:[ITKeyCombo keyComboWithPlistRepresentation:[df objectForKey:@"IncrementVolume"]]];
 494         [hotKey setTarget:self];
 495         [hotKey setAction:@selector(incrementVolume)];
 496         [[ITHotKeyCenter sharedCenter] registerHotKey:[hotKey autorelease]];
 497     }
 498
 499     if ([df objectForKey:@"DecrementVolume"] != nil) {
 500         ITDebugLog(@"Setting up decrement volume hot key.");
 501         hotKey = [[ITHotKey alloc] init];
 502         [hotKey setName:@"DecrementVolume"];
 503         [hotKey setKeyCombo:[ITKeyCombo keyComboWithPlistRepresentation:[df objectForKey:@"DecrementVolume"]]];
 504         [hotKey setTarget:self];
 505         [hotKey setAction:@selector(decrementVolume)];
 506         [[ITHotKeyCenter sharedCenter] registerHotKey:[hotKey autorelease]];
 507     }
 508
 509     if ([df objectForKey:@"IncrementRating"] != nil) {
 510         ITDebugLog(@"Setting up increment rating hot key.");
 511         hotKey = [[ITHotKey alloc] init];
 512         [hotKey setName:@"IncrementRating"];
 513         [hotKey setKeyCombo:[ITKeyCombo keyComboWithPlistRepresentation:[df objectForKey:@"IncrementRating"]]];
 514         [hotKey setTarget:self];
 515         [hotKey setAction:@selector(incrementRating)];
 516         [[ITHotKeyCenter sharedCenter] registerHotKey:[hotKey autorelease]];
 517     }
 518
 519     if ([df objectForKey:@"DecrementRating"] != nil) {
 520         ITDebugLog(@"Setting up decrement rating hot key.");
 521         hotKey = [[ITHotKey alloc] init];
 522         [hotKey setName:@"DecrementRating"];
 523         [hotKey setKeyCombo:[ITKeyCombo keyComboWithPlistRepresentation:[df objectForKey:@"DecrementRating"]]];
 524         [hotKey setTarget:self];
 525         [hotKey setAction:@selector(decrementRating)];
 526         [[ITHotKeyCenter sharedCenter] registerHotKey:[hotKey autorelease]];
 527     }
 528     ITDebugLog(@"Finished setting up hot keys.");
 529 }
 530
 531 - (void)showCurrentTrackInfo
 532 {
 533     ITMTRemotePlayerSource  source      = [currentRemote currentSource];
 534     NSString               *title       = [currentRemote currentSongTitle];
 535     NSString               *album       = nil;
 536     NSString               *artist      = nil;
 537     NSString               *time        = nil;
 538     NSString               *track       = nil;
 539     int                     rating      = -1;
 540
 541     ITDebugLog(@"Showing track info status window.");
 542
 543     if ( title ) {
 544
 545         if ( [df boolForKey:@"showAlbum"] ) {
 546             album = [currentRemote currentSongAlbum];
 547         }
 548
 549         if ( [df boolForKey:@"showArtist"] ) {
 550             artist = [currentRemote currentSongArtist];
 551         }
 552
 553         if ( [df boolForKey:@"showTime"] ) {
 554             time = [NSString stringWithFormat:@"%@: %@ / %@",
 555                 @"Time",
 556                 [currentRemote currentSongElapsed],
 557                 [currentRemote currentSongLength]];
 558         }
 559
 560         if ( [df boolForKey:@"showTrackNumber"] ) {
 561             int trackNo    = [currentRemote currentSongTrack];
 562             int trackCount = [currentRemote currentAlbumTrackCount];
 563
 564             if ( (trackNo > 0) || (trackCount > 0) ) {
 565                 track = [NSString stringWithFormat:@"%@: %i %@ %i",
 566                     @"Track", trackNo, @"of", trackCount];
 567             }
 568         }
 569
 570         if ( [df boolForKey:@"showTrackRating"] ) {
 571             float currentRating = [currentRemote currentSongRating];
 572             if (currentRating >= 0.0) {
 573                 rating = ( currentRating * 5 );
 574             }
 575         }
 576
 577     } else {
 578         title = NSLocalizedString(@"noSongPlaying", @"No song is playing.");
 579     }
 580
 581     [statusWindowController showSongInfoWindowWithSource:source
 582                                                    title:title
 583                                                    album:album
 584                                                   artist:artist
 585                                                     time:time
 586                                                    track:track
 587                                                   rating:rating];
 588 }
 589
 590 - (void)showUpcomingSongs
 591 {
 592     int curPlaylist = [currentRemote currentPlaylistIndex];
 593     int numSongs = [currentRemote numberOfSongsInPlaylistAtIndex:curPlaylist];
 594     ITDebugLog(@"Showing upcoming songs status window.");
 595     if (numSongs > 0) {
 596         NSMutableArray *songList = [NSMutableArray arrayWithCapacity:5];
 597         int numSongsInAdvance = [df integerForKey:@"SongsInAdvance"];
 598         int curTrack = [currentRemote currentSongIndex];
 599         int i;
 600
 601         for (i = curTrack + 1; i <= curTrack + numSongsInAdvance; i++) {
 602             if (i <= numSongs) {
 603                 [songList addObject:[currentRemote songTitleAtIndex:i]];
 604             }
 605         }
 606
 607         [statusWindowController showUpcomingSongsWindowWithTitles:songList];
 608
 609     } else {
 610         [statusWindowController showUpcomingSongsWindowWithTitles:[NSArray arrayWithObject:NSLocalizedString(@"noUpcomingSongs", @"No upcoming songs.")]];
 611     }
 612 }
 613
 614 - (void)incrementVolume
 615 {
 616     float volume  = [currentRemote volume];
 617     float dispVol = volume;
 618     ITDebugLog(@"Incrementing volume.");
 619     volume  += 0.110;
 620     dispVol += 0.100;
 621
 622     if (volume > 1.0) {
 623         volume  = 1.0;
 624         dispVol = 1.0;
 625     }
 626
 627     ITDebugLog(@"Setting volume to %f", volume);
 628     [currentRemote setVolume:volume];
 629
 630     // Show volume status window
 631     [statusWindowController showVolumeWindowWithLevel:dispVol];
 632 }
 633
 634 - (void)decrementVolume
 635 {
 636     float volume  = [currentRemote volume];
 637     float dispVol = volume;
 638     ITDebugLog(@"Decrementing volume.");
 639     volume  -= 0.090;
 640     dispVol -= 0.100;
 641
 642     if (volume < 0.0) {
 643         volume  = 0.0;
 644         dispVol = 0.0;
 645     }
 646
 647     ITDebugLog(@"Setting volume to %f", volume);
 648     [currentRemote setVolume:volume];
 649
 650     //Show volume status window
 651     [statusWindowController showVolumeWindowWithLevel:dispVol];
 652 }
 653
 654 - (void)incrementRating
 655 {
 656     float rating = [currentRemote currentSongRating];
 657     ITDebugLog(@"Incrementing rating.");
 658
 659     if ([currentRemote currentPlaylistIndex] == 0) {
 660         ITDebugLog(@"No song playing, rating change aborted.");
 661         return;
 662     }
 663
 664     rating += 0.2;
 665     if (rating > 1.0) {
 666         rating = 1.0;
 667     }
 668     ITDebugLog(@"Setting rating to %f", rating);
 669     [currentRemote setCurrentSongRating:rating];
 670
 671     //Show rating status window
 672     [statusWindowController showRatingWindowWithRating:rating];
 673 }
 674
 675 - (void)decrementRating
 676 {
 677     float rating = [currentRemote currentSongRating];
 678     ITDebugLog(@"Decrementing rating.");
 679
 680     if ([currentRemote currentPlaylistIndex] == 0) {
 681         ITDebugLog(@"No song playing, rating change aborted.");
 682         return;
 683     }
 684
 685     rating -= 0.2;
 686     if (rating < 0.0) {
 687         rating = 0.0;
 688     }
 689     ITDebugLog(@"Setting rating to %f", rating);
 690     [currentRemote setCurrentSongRating:rating];
 691
 692     //Show rating status window
 693     [statusWindowController showRatingWindowWithRating:rating];
 694 }
 695
 696 - (void)toggleLoop
 697 {
 698     ITMTRemotePlayerRepeatMode repeatMode = [currentRemote repeatMode];
 699     ITDebugLog(@"Toggling repeat mode.");
 700     switch (repeatMode) {
 701         case ITMTRemotePlayerRepeatOff:
 702             repeatMode = ITMTRemotePlayerRepeatAll;
 703         break;
 704         case ITMTRemotePlayerRepeatAll:
 705             repeatMode = ITMTRemotePlayerRepeatOne;
 706         break;
 707         case ITMTRemotePlayerRepeatOne:
 708             repeatMode = ITMTRemotePlayerRepeatOff;
 709         break;
 710     }
 711     ITDebugLog(@"Setting repeat mode to %i", repeatMode);
 712     [currentRemote setRepeatMode:repeatMode];
 713
 714     //Show loop status window
 715     [statusWindowController showRepeatWindowWithMode:repeatMode];
 716 }
 717
 718 - (void)toggleShuffle
 719 {
 720     BOOL newShuffleEnabled = ( ! [currentRemote shuffleEnabled] );
 721     ITDebugLog(@"Toggling shuffle mode.");
 722     [currentRemote setShuffleEnabled:newShuffleEnabled];
 723     //Show shuffle status window
 724     ITDebugLog(@"Setting shuffle mode to %i", newShuffleEnabled);
 725     [statusWindowController showShuffleWindow:newShuffleEnabled];
 726 }
 727
 728 - (void)registerNowOK
 729 {
 730     [[StatusWindow sharedWindow] setLocked:NO];
 731     [[StatusWindow sharedWindow] vanish:self];
 732     [[StatusWindow sharedWindow] setIgnoresMouseEvents:YES];
 733
 734     [self blingNow];
 735 }
 736
 737 - (void)registerNowCancel
 738 {
 739     [[StatusWindow sharedWindow] setLocked:NO];
 740     [[StatusWindow sharedWindow] vanish:self];
 741     [[StatusWindow sharedWindow] setIgnoresMouseEvents:YES];
 742
 743     [NSApp terminate:self];
 744 }
 745
 746
 747 /*************************************************************************/
 748 #pragma mark -
 749 #pragma mark WORKSPACE NOTIFICATION HANDLERS
 750 /*************************************************************************/
 751
 752 - (void)applicationLaunched:(NSNotification *)note
 753 {
 754     if (!note || [[[note userInfo] objectForKey:@"NSApplicationName"] isEqualToString:[currentRemote playerFullName]]) {
 755         ITDebugLog(@"Remote application launched.");
 756         [currentRemote begin];
 757         [self setLatestSongIdentifier:@""];
 758         [self timerUpdate];
 759         refreshTimer = [[NSTimer scheduledTimerWithTimeInterval:0.5
 760                              target:self
 761                              selector:@selector(timerUpdate)
 762                              userInfo:nil
 763                              repeats:YES] retain];
 764         //[NSThread detachNewThreadSelector:@selector(startTimerInNewThread) toTarget:self withObject:nil];
 765         [self setupHotKeys];
 766         playerRunningState = ITMTRemotePlayerRunning;
 767     }
 768 }
 769
 770  - (void)applicationTerminated:(NSNotification *)note
 771  {
 772      if (!note || [[[note userInfo] objectForKey:@"NSApplicationName"] isEqualToString:[currentRemote playerFullName]]) {
 773         ITDebugLog(@"Remote application terminated.");
 774         [currentRemote halt];
 775         [refreshTimer invalidate];
 776         [refreshTimer release];
 777         refreshTimer = nil;
 778         [registerTimer invalidate];
 779         [registerTimer release];
 780         registerTimer = nil;
 781         [self clearHotKeys];
 782         playerRunningState = ITMTRemotePlayerNotRunning;
 783      }
 784  }
 785
 786
 787 /*************************************************************************/
 788 #pragma mark -
 789 #pragma mark NSApplication DELEGATE METHODS
 790 /*************************************************************************/
 791
 792 - (void)applicationWillTerminate:(NSNotification *)note
 793 {
 794     [self clearHotKeys];
 795     [[NSStatusBar systemStatusBar] removeStatusItem:statusItem];
 796 }
 797
 798
 799 /*************************************************************************/
 800 #pragma mark -
 801 #pragma mark DEALLOCATION METHOD
 802 /*************************************************************************/
 803
 804 - (void)dealloc
 805 {
 806     [self applicationTerminated:nil];
 807     [bling release];
 808     [statusItem release];
 809     [statusWindowController release];
 810     [menuController release];
 811     [super dealloc];
 812 }
 813
 814
 815 @end