Sizing is now in, with appropriate UI. Still working on the last of the positioning...
[MenuTunes.git] / MainController.m
1 #import "MainController.h"
2 #import "MenuController.h"
3 #import "PreferencesController.h"
4 #import "NetworkController.h"
5 #import "NetworkObject.h"
6 #import <ITKit/ITHotKeyCenter.h>
7 #import <ITKit/ITHotKey.h>
8 #import <ITKit/ITKeyCombo.h>
9 #import "StatusWindow.h"
10 #import "StatusWindowController.h"
11 #import "StatusItemHack.h"
12
13 @interface MainController(Private)
14 - (ITMTRemote *)loadRemote;
15 - (void)timerUpdate;
16 - (void)setLatestSongIdentifier:(NSString *)newIdentifier;
17 - (void)showCurrentTrackInfo;
18 - (void)applicationLaunched:(NSNotification *)note;
19 - (void)applicationTerminated:(NSNotification *)note;
20 @end
21
22 static MainController *sharedController;
23
24 @implementation MainController
25
26 + (MainController *)sharedController
27 {
28     return sharedController;
29 }
30
31 /*************************************************************************/
32 #pragma mark -
33 #pragma mark INITIALIZATION/DEALLOCATION METHODS
34 /*************************************************************************/
35
36 - (id)init
37 {
38     if ( ( self = [super init] ) ) {
39         sharedController = self;
40         
41         remoteArray = [[NSMutableArray alloc] initWithCapacity:1];
42         [[PreferencesController sharedPrefs] setController:self];
43         statusWindowController = [StatusWindowController sharedController];
44         menuController = [[MenuController alloc] init];
45         df = [[NSUserDefaults standardUserDefaults] retain];
46         timerUpdating = NO;
47         blinged = NO;
48     }
49     return self;
50 }
51
52 - (void)applicationDidFinishLaunching:(NSNotification *)note
53 {
54     //Turn on debug mode if needed
55     if ([df boolForKey:@"ITDebugMode"]) {
56         SetITDebugMode(YES);
57     }
58     
59     currentRemote = [self loadRemote];
60     [[self currentRemote] begin];
61     
62     //Turn on network stuff if needed
63     networkController = [[NetworkController alloc] init];
64     if ([df boolForKey:@"enableSharing"]) {
65         [self setServerStatus:YES];
66     } else if ([df boolForKey:@"useSharedPlayer"]) {
67         if ([self connectToServer] == 0) {
68             [NSTimer scheduledTimerWithTimeInterval:45 target:self selector:@selector(checkForRemoteServer:) userInfo:nil repeats:YES];
69         }
70     }
71     
72     //Setup for notification of the remote player launching or quitting
73     [[[NSWorkspace sharedWorkspace] notificationCenter]
74             addObserver:self
75             selector:@selector(applicationTerminated:)
76             name:NSWorkspaceDidTerminateApplicationNotification
77             object:nil];
78     
79     [[[NSWorkspace sharedWorkspace] notificationCenter]
80             addObserver:self
81             selector:@selector(applicationLaunched:)
82             name:NSWorkspaceDidLaunchApplicationNotification
83             object:nil];
84     
85     if ( ! [df objectForKey:@"menu"] ) {  // If this is nil, defaults have never been registered.
86         [[PreferencesController sharedPrefs] registerDefaults];
87     }
88     
89     [StatusItemHack install];
90     statusItem = [[ITStatusItem alloc]
91             initWithStatusBar:[NSStatusBar systemStatusBar]
92             withLength:NSSquareStatusItemLength];
93     
94     bling = [[MTBlingController alloc] init];
95     [self blingTime];
96     registerTimer = [[NSTimer scheduledTimerWithTimeInterval:10.0
97                              target:self
98                              selector:@selector(blingTime)
99                              userInfo:nil
100                              repeats:YES] retain];
101     
102     NS_DURING
103         if ([[self currentRemote] playerRunningState] == ITMTRemotePlayerRunning) {
104             [self applicationLaunched:nil];
105         } else {
106             if ([df boolForKey:@"LaunchPlayerWithMT"])
107                 [self showPlayer];
108             else
109                 [self applicationTerminated:nil];
110         }
111     NS_HANDLER
112         [self networkError:localException];
113     NS_ENDHANDLER
114     
115     [statusItem setImage:[NSImage imageNamed:@"MenuNormal"]];
116     [statusItem setAlternateImage:[NSImage imageNamed:@"MenuInverted"]];
117
118     [networkController startRemoteServerSearch];
119     [NSApp deactivate];
120 }
121
122 - (ITMTRemote *)loadRemote
123 {
124     NSString *folderPath = [[NSBundle mainBundle] builtInPlugInsPath];
125     ITDebugLog(@"Gathering remotes.");
126     if (folderPath) {
127         NSArray      *bundlePathList = [NSBundle pathsForResourcesOfType:@"remote" inDirectory:folderPath];
128         NSEnumerator *enumerator     = [bundlePathList objectEnumerator];
129         NSString     *bundlePath;
130
131         while ( (bundlePath = [enumerator nextObject]) ) {
132             NSBundle* remoteBundle = [NSBundle bundleWithPath:bundlePath];
133
134             if (remoteBundle) {
135                 Class remoteClass = [remoteBundle principalClass];
136
137                 if ([remoteClass conformsToProtocol:@protocol(ITMTRemote)] &&
138                     [remoteClass isKindOfClass:[NSObject class]]) {
139                     id remote = [remoteClass remote];
140                     ITDebugLog(@"Adding remote at path %@", bundlePath);
141                     [remoteArray addObject:remote];
142                 }
143             }
144         }
145
146 //      if ( [remoteArray count] > 0 ) {  // UNCOMMENT WHEN WE HAVE > 1 PLUGIN
147 //          if ( [remoteArray count] > 1 ) {
148 //              [remoteArray sortUsingSelector:@selector(sortAlpha:)];
149 //          }
150 //          [self loadModuleAccessUI]; //Comment out this line to disable remote visibility
151 //      }
152     }
153 //  NSLog(@"%@", [remoteArray objectAtIndex:0]);  //DEBUG
154     return [remoteArray objectAtIndex:0];
155 }
156
157 /*************************************************************************/
158 #pragma mark -
159 #pragma mark INSTANCE METHODS
160 /*************************************************************************/
161
162 /*- (void)startTimerInNewThread
163 {
164     NSAutoreleasePool *pool = [[NSAutoreleasePool alloc] init];
165     NSRunLoop *runLoop = [NSRunLoop currentRunLoop];
166     refreshTimer = [[NSTimer scheduledTimerWithTimeInterval:0.5
167                              target:self
168                              selector:@selector(timerUpdate)
169                              userInfo:nil
170                              repeats:YES] retain];
171     [runLoop run];
172     ITDebugLog(@"Timer started.");
173     [pool release];
174 }*/
175
176 - (void)setBlingTime:(NSDate*)date
177 {
178     NSMutableDictionary *globalPrefs;
179     [df synchronize];
180     globalPrefs = [[df persistentDomainForName:@".GlobalPreferences"] mutableCopy];
181     if (date) {
182         [globalPrefs setObject:date forKey:@"ITMTTrialStart"];
183     } else {
184         [globalPrefs removeObjectForKey:@"ITMTTrialStart"];
185     }
186     [df setPersistentDomain:globalPrefs forName:@".GlobalPreferences"];
187     [df synchronize];
188     [globalPrefs release];
189 }
190
191 - (NSDate*)getBlingTime
192 {
193     [df synchronize];
194     return [[df persistentDomainForName:@".GlobalPreferences"] objectForKey:@"ITMTTrialStart"];
195 }
196
197 - (void)blingTime
198 {
199     NSDate *now = [NSDate date];
200     if (![self blingBling]) {
201         if ( (! [self getBlingTime] ) || ([now timeIntervalSinceDate:[self getBlingTime]] < 0) ) {
202             [self setBlingTime:now];
203         }
204         if ( ([now timeIntervalSinceDate:[self getBlingTime]] >= 604800) && (blinged != YES) ) {
205             blinged = YES;
206             [statusItem setEnabled:NO];
207             [self clearHotKeys];
208             if ([refreshTimer isValid]) {
209                 [refreshTimer invalidate];
210             }
211             [statusWindowController showRegistrationQueryWindow];
212         }
213     } else {
214         if (blinged) {
215             [statusItem setEnabled:YES];
216             [self setupHotKeys];
217             if (![refreshTimer isValid]) {
218                 [refreshTimer release];
219                 refreshTimer = [[NSTimer scheduledTimerWithTimeInterval:0.5
220                              target:self
221                              selector:@selector(timerUpdate)
222                              userInfo:nil
223                              repeats:YES] retain];
224             }
225             blinged = NO;
226         }
227         [self setBlingTime:nil];
228     }
229 }
230
231 - (void)blingNow
232 {
233     [bling showPanel];
234 }
235
236 - (BOOL)blingBling
237 {
238     if ( ! ([bling checkDone] == 2475) ) {
239         return NO;
240     } else {
241         return YES;
242     }
243 }
244
245 - (BOOL)songIsPlaying
246 {
247     NSString *identifier = nil;
248     NS_DURING
249         identifier = [[self currentRemote] playerStateUniqueIdentifier];
250     NS_HANDLER
251         [self networkError:localException];
252     NS_ENDHANDLER
253     return ( ! ([identifier isEqualToString:@"0-0"]) );
254 }
255
256 - (BOOL)radioIsPlaying
257 {
258     ITMTRemotePlayerPlaylistClass class = nil;
259     NS_DURING
260         class = [[self currentRemote] currentPlaylistClass];
261     NS_HANDLER
262         [self networkError:localException];
263     NS_ENDHANDLER
264     return (class  == ITMTRemotePlayerRadioPlaylist );
265 }
266
267 - (BOOL)songChanged
268 {
269     NSString *identifier = nil;
270     NS_DURING
271         identifier = [[self currentRemote] playerStateUniqueIdentifier];
272     NS_HANDLER
273         [self networkError:localException];
274     NS_ENDHANDLER
275     return ( ! [identifier isEqualToString:_latestSongIdentifier] );
276 }
277
278 - (NSString *)latestSongIdentifier
279 {
280     return _latestSongIdentifier;
281 }
282
283 - (void)setLatestSongIdentifier:(NSString *)newIdentifier
284 {
285     ITDebugLog(@"Setting latest song identifier to %@", newIdentifier);
286     [_latestSongIdentifier autorelease];
287     _latestSongIdentifier = [newIdentifier copy];
288 }
289
290 - (void)timerUpdate
291 {
292     if ([networkController isConnectedToServer]) {
293         [statusItem setMenu:[menuController menu]];
294     }
295     
296     if ( [self songChanged] && (timerUpdating != YES) ) {
297         ITDebugLog(@"The song changed.");
298         timerUpdating = YES;
299         
300         NS_DURING
301             latestPlaylistClass = [[self currentRemote] currentPlaylistClass];
302             [menuController rebuildSubmenus];
303     
304             if ( [df boolForKey:@"showSongInfoOnChange"] ) {
305                 [self performSelector:@selector(showCurrentTrackInfo) withObject:nil afterDelay:0.0];
306             }
307             
308             [self setLatestSongIdentifier:[[self currentRemote] playerStateUniqueIdentifier]];
309         NS_HANDLER
310             [self networkError:localException];
311         NS_ENDHANDLER
312         
313         timerUpdating = NO;
314     }
315 }
316
317 - (void)menuClicked
318 {
319     ITDebugLog(@"Menu clicked.");
320     if ([networkController isConnectedToServer]) {
321         //Used the cached version
322         return;
323     }
324     
325     NS_DURING
326         if ([[self currentRemote] playerRunningState] == ITMTRemotePlayerRunning) {
327             [statusItem setMenu:[menuController menu]];
328         } else {
329             [statusItem setMenu:[menuController menuForNoPlayer]];
330         }
331     NS_HANDLER
332         [self networkError:localException];
333     NS_ENDHANDLER
334 }
335
336 //
337 //
338 // Menu Selectors
339 //
340 //
341
342 - (void)playPause
343 {
344     NS_DURING
345         ITMTRemotePlayerPlayingState state = [[self currentRemote] playerPlayingState];
346         ITDebugLog(@"Play/Pause toggled");
347         if (state == ITMTRemotePlayerPlaying) {
348             [[self currentRemote] pause];
349         } else if ((state == ITMTRemotePlayerForwarding) || (state == ITMTRemotePlayerRewinding)) {
350             [[self currentRemote] pause];
351             [[self currentRemote] play];
352         } else {
353             [[self currentRemote] play];
354         }
355     NS_HANDLER
356         [self networkError:localException];
357     NS_ENDHANDLER
358     
359     [self timerUpdate];
360 }
361
362 - (void)nextSong
363 {
364     ITDebugLog(@"Going to next song.");
365     NS_DURING
366         [[self currentRemote] goToNextSong];
367     NS_HANDLER
368         [self networkError:localException];
369     NS_ENDHANDLER
370     [self timerUpdate];
371 }
372
373 - (void)prevSong
374 {
375     ITDebugLog(@"Going to previous song.");
376     NS_DURING
377         [[self currentRemote] goToPreviousSong];
378     NS_HANDLER
379         [self networkError:localException];
380     NS_ENDHANDLER
381     [self timerUpdate];
382 }
383
384 - (void)fastForward
385 {
386     ITDebugLog(@"Fast forwarding.");
387     NS_DURING
388         [[self currentRemote] forward];
389     NS_HANDLER
390         [self networkError:localException];
391     NS_ENDHANDLER
392     [self timerUpdate];
393 }
394
395 - (void)rewind
396 {
397     ITDebugLog(@"Rewinding.");
398     NS_DURING
399         [[self currentRemote] rewind];
400     NS_HANDLER
401         [self networkError:localException];
402     NS_ENDHANDLER
403     [self timerUpdate];
404 }
405
406 - (void)selectPlaylistAtIndex:(int)index
407 {
408     ITDebugLog(@"Selecting playlist %i", index);
409     NS_DURING
410         [[self currentRemote] switchToPlaylistAtIndex:index];
411     NS_HANDLER
412         [self networkError:localException];
413     NS_ENDHANDLER
414     [self timerUpdate];
415 }
416
417 - (void)selectSongAtIndex:(int)index
418 {
419     ITDebugLog(@"Selecting song %i", index);
420     NS_DURING
421         [[self currentRemote] switchToSongAtIndex:index];
422     NS_HANDLER
423         [self networkError:localException];
424     NS_ENDHANDLER
425     [self timerUpdate];
426 }
427
428 - (void)selectSongRating:(int)rating
429 {
430     ITDebugLog(@"Selecting song rating %i", rating);
431     NS_DURING
432         [[self currentRemote] setCurrentSongRating:(float)rating / 100.0];
433     NS_HANDLER
434         [self networkError:localException];
435     NS_ENDHANDLER
436     [self timerUpdate];
437 }
438
439 - (void)selectEQPresetAtIndex:(int)index
440 {
441     ITDebugLog(@"Selecting EQ preset %i", index);
442     NS_DURING
443         [[self currentRemote] switchToEQAtIndex:index];
444     NS_HANDLER
445         [self networkError:localException];
446     NS_ENDHANDLER
447     [self timerUpdate];
448 }
449
450 - (void)showPlayer
451 {
452     ITDebugLog(@"Beginning show player.");
453     if ( ( playerRunningState == ITMTRemotePlayerRunning) ) {
454         ITDebugLog(@"Showing player interface.");
455         NS_DURING
456             [[self currentRemote] showPrimaryInterface];
457         NS_HANDLER
458             [self networkError:localException];
459         NS_ENDHANDLER
460     } else {
461         ITDebugLog(@"Launching player.");
462         NS_DURING
463             if (![[NSWorkspace sharedWorkspace] launchApplication:[[self currentRemote] playerFullName]]) {
464                 ITDebugLog(@"Error Launching Player");
465             }
466         NS_HANDLER
467             [self networkError:localException];
468         NS_ENDHANDLER
469     }
470     ITDebugLog(@"Finished show player.");
471 }
472
473 - (void)showPreferences
474 {
475     ITDebugLog(@"Show preferences.");
476     [[PreferencesController sharedPrefs] showPrefsWindow:self];
477 }
478
479 - (void)showTestWindow
480 {
481     [self showCurrentTrackInfo];
482 }
483
484 - (void)quitMenuTunes
485 {
486     ITDebugLog(@"Quitting MenuTunes.");
487     [NSApp terminate:self];
488 }
489
490 //
491 //
492
493 - (void)closePreferences
494 {
495     ITDebugLog(@"Preferences closed.");
496     if ( ( playerRunningState == ITMTRemotePlayerRunning) ) {
497         [self setupHotKeys];
498     }
499 }
500
501 - (ITMTRemote *)currentRemote
502 {
503     return currentRemote;
504 }
505
506 //
507 //
508 // Hot key setup
509 //
510 //
511
512 - (void)clearHotKeys
513 {
514     NSEnumerator *hotKeyEnumerator = [[[ITHotKeyCenter sharedCenter] allHotKeys] objectEnumerator];
515     ITHotKey *nextHotKey;
516     ITDebugLog(@"Clearing hot keys.");
517     while ( (nextHotKey = [hotKeyEnumerator nextObject]) ) {
518         [[ITHotKeyCenter sharedCenter] unregisterHotKey:nextHotKey];
519     }
520     ITDebugLog(@"Done clearing hot keys.");
521 }
522
523 - (void)setupHotKeys
524 {
525     ITHotKey *hotKey;
526     ITDebugLog(@"Setting up hot keys.");
527     
528     if (playerRunningState == ITMTRemotePlayerNotRunning) {
529         return;
530     }
531     
532     if ([df objectForKey:@"PlayPause"] != nil) {
533         ITDebugLog(@"Setting up play pause hot key.");
534         hotKey = [[ITHotKey alloc] init];
535         [hotKey setName:@"PlayPause"];
536         [hotKey setKeyCombo:[ITKeyCombo keyComboWithPlistRepresentation:[df objectForKey:@"PlayPause"]]];
537         [hotKey setTarget:self];
538         [hotKey setAction:@selector(playPause)];
539         [[ITHotKeyCenter sharedCenter] registerHotKey:[hotKey autorelease]];
540     }
541     
542     if ([df objectForKey:@"NextTrack"] != nil) {
543         ITDebugLog(@"Setting up next track hot key.");
544         hotKey = [[ITHotKey alloc] init];
545         [hotKey setName:@"NextTrack"];
546         [hotKey setKeyCombo:[ITKeyCombo keyComboWithPlistRepresentation:[df objectForKey:@"NextTrack"]]];
547         [hotKey setTarget:self];
548         [hotKey setAction:@selector(nextSong)];
549         [[ITHotKeyCenter sharedCenter] registerHotKey:[hotKey autorelease]];
550     }
551     
552     if ([df objectForKey:@"PrevTrack"] != nil) {
553         ITDebugLog(@"Setting up previous track hot key.");
554         hotKey = [[ITHotKey alloc] init];
555         [hotKey setName:@"PrevTrack"];
556         [hotKey setKeyCombo:[ITKeyCombo keyComboWithPlistRepresentation:[df objectForKey:@"PrevTrack"]]];
557         [hotKey setTarget:self];
558         [hotKey setAction:@selector(prevSong)];
559         [[ITHotKeyCenter sharedCenter] registerHotKey:[hotKey autorelease]];
560     }
561     
562     if ([df objectForKey:@"ShowPlayer"] != nil) {
563         ITDebugLog(@"Setting up show player hot key.");
564         hotKey = [[ITHotKey alloc] init];
565         [hotKey setName:@"ShowPlayer"];
566         [hotKey setKeyCombo:[ITKeyCombo keyComboWithPlistRepresentation:[df objectForKey:@"ShowPlayer"]]];
567         [hotKey setTarget:self];
568         [hotKey setAction:@selector(showPlayer)];
569         [[ITHotKeyCenter sharedCenter] registerHotKey:[hotKey autorelease]];
570     }
571     
572     if ([df objectForKey:@"TrackInfo"] != nil) {
573         ITDebugLog(@"Setting up track info hot key.");
574         hotKey = [[ITHotKey alloc] init];
575         [hotKey setName:@"TrackInfo"];
576         [hotKey setKeyCombo:[ITKeyCombo keyComboWithPlistRepresentation:[df objectForKey:@"TrackInfo"]]];
577         [hotKey setTarget:self];
578         [hotKey setAction:@selector(showCurrentTrackInfo)];
579         [[ITHotKeyCenter sharedCenter] registerHotKey:[hotKey autorelease]];
580     }
581     
582     if ([df objectForKey:@"UpcomingSongs"] != nil) {
583         ITDebugLog(@"Setting up upcoming songs hot key.");
584         hotKey = [[ITHotKey alloc] init];
585         [hotKey setName:@"UpcomingSongs"];
586         [hotKey setKeyCombo:[ITKeyCombo keyComboWithPlistRepresentation:[df objectForKey:@"UpcomingSongs"]]];
587         [hotKey setTarget:self];
588         [hotKey setAction:@selector(showUpcomingSongs)];
589         [[ITHotKeyCenter sharedCenter] registerHotKey:[hotKey autorelease]];
590     }
591     
592     if ([df objectForKey:@"ToggleLoop"] != nil) {
593         ITDebugLog(@"Setting up toggle loop hot key.");
594         hotKey = [[ITHotKey alloc] init];
595         [hotKey setName:@"ToggleLoop"];
596         [hotKey setKeyCombo:[ITKeyCombo keyComboWithPlistRepresentation:[df objectForKey:@"ToggleLoop"]]];
597         [hotKey setTarget:self];
598         [hotKey setAction:@selector(toggleLoop)];
599         [[ITHotKeyCenter sharedCenter] registerHotKey:[hotKey autorelease]];
600     }
601     
602     if ([df objectForKey:@"ToggleShuffle"] != nil) {
603         ITDebugLog(@"Setting up toggle shuffle hot key.");
604         hotKey = [[ITHotKey alloc] init];
605         [hotKey setName:@"ToggleShuffle"];
606         [hotKey setKeyCombo:[ITKeyCombo keyComboWithPlistRepresentation:[df objectForKey:@"ToggleShuffle"]]];
607         [hotKey setTarget:self];
608         [hotKey setAction:@selector(toggleShuffle)];
609         [[ITHotKeyCenter sharedCenter] registerHotKey:[hotKey autorelease]];
610     }
611     
612     if ([df objectForKey:@"IncrementVolume"] != nil) {
613         ITDebugLog(@"Setting up increment volume hot key.");
614         hotKey = [[ITHotKey alloc] init];
615         [hotKey setName:@"IncrementVolume"];
616         [hotKey setKeyCombo:[ITKeyCombo keyComboWithPlistRepresentation:[df objectForKey:@"IncrementVolume"]]];
617         [hotKey setTarget:self];
618         [hotKey setAction:@selector(incrementVolume)];
619         [[ITHotKeyCenter sharedCenter] registerHotKey:[hotKey autorelease]];
620     }
621     
622     if ([df objectForKey:@"DecrementVolume"] != nil) {
623         ITDebugLog(@"Setting up decrement volume hot key.");
624         hotKey = [[ITHotKey alloc] init];
625         [hotKey setName:@"DecrementVolume"];
626         [hotKey setKeyCombo:[ITKeyCombo keyComboWithPlistRepresentation:[df objectForKey:@"DecrementVolume"]]];
627         [hotKey setTarget:self];
628         [hotKey setAction:@selector(decrementVolume)];
629         [[ITHotKeyCenter sharedCenter] registerHotKey:[hotKey autorelease]];
630     }
631     
632     if ([df objectForKey:@"IncrementRating"] != nil) {
633         ITDebugLog(@"Setting up increment rating hot key.");
634         hotKey = [[ITHotKey alloc] init];
635         [hotKey setName:@"IncrementRating"];
636         [hotKey setKeyCombo:[ITKeyCombo keyComboWithPlistRepresentation:[df objectForKey:@"IncrementRating"]]];
637         [hotKey setTarget:self];
638         [hotKey setAction:@selector(incrementRating)];
639         [[ITHotKeyCenter sharedCenter] registerHotKey:[hotKey autorelease]];
640     }
641     
642     if ([df objectForKey:@"DecrementRating"] != nil) {
643         ITDebugLog(@"Setting up decrement rating hot key.");
644         hotKey = [[ITHotKey alloc] init];
645         [hotKey setName:@"DecrementRating"];
646         [hotKey setKeyCombo:[ITKeyCombo keyComboWithPlistRepresentation:[df objectForKey:@"DecrementRating"]]];
647         [hotKey setTarget:self];
648         [hotKey setAction:@selector(decrementRating)];
649         [[ITHotKeyCenter sharedCenter] registerHotKey:[hotKey autorelease]];
650     }
651     ITDebugLog(@"Finished setting up hot keys.");
652 }
653
654 - (void)showCurrentTrackInfo
655 {
656     ITMTRemotePlayerSource  source      = 0;
657     NSString               *title       = nil;
658     NSString               *album       = nil;
659     NSString               *artist      = nil;
660     NSString               *time        = nil;
661     NSString               *track       = nil;
662     int                     rating      = -1;
663     
664     NS_DURING
665         source      = [[self currentRemote] currentSource];
666         title       = [[self currentRemote] currentSongTitle];
667     NS_HANDLER
668         [self networkError:localException];
669     NS_ENDHANDLER
670     
671     ITDebugLog(@"Showing track info status window.");
672     
673     if ( title ) {
674
675         if ( [df boolForKey:@"showAlbum"] ) {
676             NS_DURING
677                 album = [[self currentRemote] currentSongAlbum];
678             NS_HANDLER
679                 [self networkError:localException];
680             NS_ENDHANDLER
681         }
682
683         if ( [df boolForKey:@"showArtist"] ) {
684             NS_DURING
685                 artist = [[self currentRemote] currentSongArtist];
686             NS_HANDLER
687                 [self networkError:localException];
688             NS_ENDHANDLER
689         }
690
691         if ( [df boolForKey:@"showTime"] ) {
692             NS_DURING
693                 time = [NSString stringWithFormat:@"%@: %@ / %@",
694                 @"Time",
695                 [[self currentRemote] currentSongElapsed],
696                 [[self currentRemote] currentSongLength]];
697             NS_HANDLER
698                 [self networkError:localException];
699             NS_ENDHANDLER
700         }
701
702         if ( [df boolForKey:@"showTrackNumber"] ) {
703             int trackNo    = 0;
704             int trackCount = 0;
705             
706             NS_DURING
707                 trackNo    = [[self currentRemote] currentSongTrack];
708                 trackCount = [[self currentRemote] currentAlbumTrackCount];
709             NS_HANDLER
710                 [self networkError:localException];
711             NS_ENDHANDLER
712             
713             if ( (trackNo > 0) || (trackCount > 0) ) {
714                 track = [NSString stringWithFormat:@"%@: %i %@ %i",
715                     @"Track", trackNo, @"of", trackCount];
716             }
717         }
718
719         if ( [df boolForKey:@"showTrackRating"] ) {
720             float currentRating = 0;
721             
722             NS_DURING
723                 currentRating = [[self currentRemote] currentSongRating];
724             NS_HANDLER
725                 [self networkError:localException];
726             NS_ENDHANDLER
727             
728             if (currentRating >= 0.0) {
729                 rating = ( currentRating * 5 );
730             }
731         }
732         
733     } else {
734         title = NSLocalizedString(@"noSongPlaying", @"No song is playing.");
735     }
736
737     [statusWindowController showSongInfoWindowWithSource:source
738                                                    title:title
739                                                    album:album
740                                                   artist:artist
741                                                     time:time
742                                                    track:track
743                                                   rating:rating];
744 }
745
746 - (void)showUpcomingSongs
747 {
748     int numSongs = 0;
749     NS_DURING
750         numSongs = [[self currentRemote] numberOfSongsInPlaylistAtIndex:[[self currentRemote] currentPlaylistIndex]];
751     NS_HANDLER
752         [self networkError:localException];
753     NS_ENDHANDLER
754     
755     ITDebugLog(@"Showing upcoming songs status window.");
756     NS_DURING
757         if (numSongs > 0) {
758             int numSongsInAdvance = [df integerForKey:@"SongsInAdvance"];
759             NSMutableArray *songList = [NSMutableArray arrayWithCapacity:numSongsInAdvance];
760             int curTrack = [[self currentRemote] currentSongIndex];
761             int i;
762     
763             for (i = curTrack + 1; i <= curTrack + numSongsInAdvance; i++) {
764                 if (i <= numSongs) {
765                     [songList addObject:[[self currentRemote] songTitleAtIndex:i]];
766                 }
767             }
768             
769             if ([songList count] == 0) {
770                 [songList addObject:NSLocalizedString(@"noUpcomingSongs", @"No upcoming songs.")];
771             }
772             
773             [statusWindowController showUpcomingSongsWindowWithTitles:songList];
774         } else {
775             [statusWindowController showUpcomingSongsWindowWithTitles:[NSArray arrayWithObject:NSLocalizedString(@"noUpcomingSongs", @"No upcoming songs.")]];
776         }
777     NS_HANDLER
778         [self networkError:localException];
779     NS_ENDHANDLER
780 }
781
782 - (void)incrementVolume
783 {
784     NS_DURING
785         float volume  = [[self currentRemote] volume];
786         float dispVol = volume;
787         ITDebugLog(@"Incrementing volume.");
788         volume  += 0.110;
789         dispVol += 0.100;
790         
791         if (volume > 1.0) {
792             volume  = 1.0;
793             dispVol = 1.0;
794         }
795     
796         ITDebugLog(@"Setting volume to %f", volume);
797         [[self currentRemote] setVolume:volume];
798     
799         // Show volume status window
800         [statusWindowController showVolumeWindowWithLevel:dispVol];
801     NS_HANDLER
802         [self networkError:localException];
803     NS_ENDHANDLER
804 }
805
806 - (void)decrementVolume
807 {
808     NS_DURING
809         float volume  = [[self currentRemote] volume];
810         float dispVol = volume;
811         ITDebugLog(@"Decrementing volume.");
812         volume  -= 0.090;
813         dispVol -= 0.100;
814     
815         if (volume < 0.0) {
816             volume  = 0.0;
817             dispVol = 0.0;
818         }
819         
820         ITDebugLog(@"Setting volume to %f", volume);
821         [[self currentRemote] setVolume:volume];
822         
823         //Show volume status window
824         [statusWindowController showVolumeWindowWithLevel:dispVol];
825     NS_HANDLER
826         [self networkError:localException];
827     NS_ENDHANDLER
828 }
829
830 - (void)incrementRating
831 {
832     NS_DURING
833         float rating = [[self currentRemote] currentSongRating];
834         ITDebugLog(@"Incrementing rating.");
835         
836         if ([[self currentRemote] currentPlaylistIndex] == 0) {
837             ITDebugLog(@"No song playing, rating change aborted.");
838             return;
839         }
840         
841         rating += 0.2;
842         if (rating > 1.0) {
843             rating = 1.0;
844         }
845         ITDebugLog(@"Setting rating to %f", rating);
846         [[self currentRemote] setCurrentSongRating:rating];
847         
848         //Show rating status window
849         [statusWindowController showRatingWindowWithRating:rating];
850     NS_HANDLER
851         [self networkError:localException];
852     NS_ENDHANDLER
853 }
854
855 - (void)decrementRating
856 {
857     NS_DURING
858         float rating = [[self currentRemote] currentSongRating];
859         ITDebugLog(@"Decrementing rating.");
860         
861         if ([[self currentRemote] currentPlaylistIndex] == 0) {
862             ITDebugLog(@"No song playing, rating change aborted.");
863             return;
864         }
865         
866         rating -= 0.2;
867         if (rating < 0.0) {
868             rating = 0.0;
869         }
870         ITDebugLog(@"Setting rating to %f", rating);
871         [[self currentRemote] setCurrentSongRating:rating];
872         
873         //Show rating status window
874         [statusWindowController showRatingWindowWithRating:rating];
875     NS_HANDLER
876         [self networkError:localException];
877     NS_ENDHANDLER
878 }
879
880 - (void)toggleLoop
881 {
882     NS_DURING
883         ITMTRemotePlayerRepeatMode repeatMode = [[self currentRemote] repeatMode];
884         ITDebugLog(@"Toggling repeat mode.");
885         switch (repeatMode) {
886             case ITMTRemotePlayerRepeatOff:
887                 repeatMode = ITMTRemotePlayerRepeatAll;
888             break;
889             case ITMTRemotePlayerRepeatAll:
890                 repeatMode = ITMTRemotePlayerRepeatOne;
891             break;
892             case ITMTRemotePlayerRepeatOne:
893                 repeatMode = ITMTRemotePlayerRepeatOff;
894             break;
895         }
896         ITDebugLog(@"Setting repeat mode to %i", repeatMode);
897         [[self currentRemote] setRepeatMode:repeatMode];
898         
899         //Show loop status window
900         [statusWindowController showRepeatWindowWithMode:repeatMode];
901     NS_HANDLER
902         [self networkError:localException];
903     NS_ENDHANDLER
904 }
905
906 - (void)toggleShuffle
907 {
908     NS_DURING
909         BOOL newShuffleEnabled = ( ! [[self currentRemote] shuffleEnabled] );
910         ITDebugLog(@"Toggling shuffle mode.");
911         [[self currentRemote] setShuffleEnabled:newShuffleEnabled];
912         //Show shuffle status window
913         ITDebugLog(@"Setting shuffle mode to %i", newShuffleEnabled);
914         [statusWindowController showShuffleWindow:newShuffleEnabled];
915     NS_HANDLER
916         [self networkError:localException];
917     NS_ENDHANDLER
918 }
919
920 - (void)registerNowOK
921 {
922     [[StatusWindow sharedWindow] setLocked:NO];
923     [[StatusWindow sharedWindow] vanish:self];
924     [[StatusWindow sharedWindow] setIgnoresMouseEvents:YES];
925
926     [self blingNow];
927 }
928
929 - (void)registerNowCancel
930 {
931     [[StatusWindow sharedWindow] setLocked:NO];
932     [[StatusWindow sharedWindow] vanish:self];
933     [[StatusWindow sharedWindow] setIgnoresMouseEvents:YES];
934
935     [NSApp terminate:self];
936 }
937
938 /*************************************************************************/
939 #pragma mark -
940 #pragma mark NETWORK HANDLERS
941 /*************************************************************************/
942
943 - (void)setServerStatus:(BOOL)newStatus
944 {
945     if (newStatus) {
946         //Turn on
947         [networkController setServerStatus:YES];
948     } else {
949         //Tear down
950         [networkController setServerStatus:NO];
951     }
952 }
953
954 - (int)connectToServer
955 {
956     int result;
957     ITDebugLog(@"Attempting to connect to shared remote.");
958     result = [networkController connectToHost:[df stringForKey:@"sharedPlayerHost"]];
959     //Connect
960     if (result == 1) {
961         [[PreferencesController sharedPrefs] resetRemotePlayerTextFields];
962         currentRemote = [[[networkController networkObject] remote] retain];
963         [self timerUpdate];
964         ITDebugLog(@"Connection successful.");
965         return 1;
966     } else if (result == 0) {
967         ITDebugLog(@"Connection failed.");
968         currentRemote = [remoteArray objectAtIndex:0];
969         return 0;
970     } else {
971         //Do something about the password being invalid
972         ITDebugLog(@"Connection failed.");
973         currentRemote = [remoteArray objectAtIndex:0];
974         return -1;
975     }
976 }
977
978 - (BOOL)disconnectFromServer
979 {
980     ITDebugLog(@"Disconnecting from shared remote.");
981     //Disconnect
982     [currentRemote release];
983     currentRemote = [remoteArray objectAtIndex:0];
984     [networkController disconnect];
985     [self timerUpdate];
986     return YES;
987 }
988
989 - (void)checkForRemoteServer:(NSTimer *)timer
990 {
991     ITDebugLog(@"Checking for remote server.");
992     if ([networkController checkForServerAtHost:[df stringForKey:@"sharedPlayerHost"]]) {
993         ITDebugLog(@"Remote server found.");
994         [timer invalidate];
995         if (![networkController isConnectedToServer]) {
996             [[StatusWindowController sharedController] showReconnectQueryWindow];
997         }
998     } else {
999         ITDebugLog(@"Remote server not found.");
1000     }
1001 }
1002
1003 - (void)networkError:(NSException *)exception
1004 {
1005     ITDebugLog(@"Remote exception thrown: %@: %@", [exception name], [exception reason]);
1006     NSLog(@"%@", [exception reason]);
1007     if ([[exception name] isEqualToString:NSPortTimeoutException] && [networkController isConnectedToServer]) {
1008         NSRunCriticalAlertPanel(@"Remote MenuTunes Disconnected", @"The MenuTunes server you were connected to stopped responding or quit. MenuTunes will revert back to the local player.", @"OK", nil, nil);
1009         if ([self disconnectFromServer]) {
1010             [[PreferencesController sharedPrefs] resetRemotePlayerTextFields];
1011             [NSTimer scheduledTimerWithTimeInterval:45 target:self selector:@selector(checkForRemoteServer:) userInfo:nil repeats:YES];
1012         } else {
1013             ITDebugLog(@"CRITICAL ERROR, DISCONNECTING!");
1014         }
1015     }
1016 }
1017
1018 - (void)reconnect
1019 {
1020     if ([self connectToServer] == 0) {
1021         [NSTimer scheduledTimerWithTimeInterval:45 target:self selector:@selector(checkForRemoteServer:) userInfo:nil repeats:YES];
1022     }
1023     [[StatusWindow sharedWindow] setLocked:NO];
1024     [[StatusWindow sharedWindow] vanish:self];
1025     [[StatusWindow sharedWindow] setIgnoresMouseEvents:YES];
1026 }
1027
1028 - (void)cancelReconnect
1029 {
1030     [[StatusWindow sharedWindow] setLocked:NO];
1031     [[StatusWindow sharedWindow] vanish:self];
1032     [[StatusWindow sharedWindow] setIgnoresMouseEvents:YES];
1033 }
1034
1035 /*************************************************************************/
1036 #pragma mark -
1037 #pragma mark WORKSPACE NOTIFICATION HANDLERS
1038 /*************************************************************************/
1039
1040 - (void)applicationLaunched:(NSNotification *)note
1041 {
1042     NS_DURING
1043         if (!note || [[[note userInfo] objectForKey:@"NSApplicationName"] isEqualToString:[[self currentRemote] playerFullName]]) {
1044             ITDebugLog(@"Remote application launched.");
1045             playerRunningState = ITMTRemotePlayerRunning;
1046             [[self currentRemote] begin];
1047             [self setLatestSongIdentifier:@""];
1048             [self timerUpdate];
1049             refreshTimer = [[NSTimer scheduledTimerWithTimeInterval:([networkController isConnectedToServer] ? 10.0 : 0.5)
1050                                 target:self
1051                                 selector:@selector(timerUpdate)
1052                                 userInfo:nil
1053                                 repeats:YES] retain];
1054             //[NSThread detachNewThreadSelector:@selector(startTimerInNewThread) toTarget:self withObject:nil];
1055             [self setupHotKeys];
1056         }
1057     NS_HANDLER
1058         [self networkError:localException];
1059     NS_ENDHANDLER
1060 }
1061
1062  - (void)applicationTerminated:(NSNotification *)note
1063  {
1064     NS_DURING
1065         if (!note || [[[note userInfo] objectForKey:@"NSApplicationName"] isEqualToString:[[self currentRemote] playerFullName]]) {
1066             ITDebugLog(@"Remote application terminated.");
1067             [[self currentRemote] halt];
1068             [refreshTimer invalidate];
1069             [refreshTimer release];
1070             refreshTimer = nil;
1071             [self clearHotKeys];
1072             playerRunningState = ITMTRemotePlayerNotRunning;
1073         }
1074     NS_HANDLER
1075         [self networkError:localException];
1076     NS_ENDHANDLER
1077  }
1078
1079
1080 /*************************************************************************/
1081 #pragma mark -
1082 #pragma mark NSApplication DELEGATE METHODS
1083 /*************************************************************************/
1084
1085 - (void)applicationWillTerminate:(NSNotification *)note
1086 {
1087     [networkController stopRemoteServerSearch];
1088     [self clearHotKeys];
1089     [[NSStatusBar systemStatusBar] removeStatusItem:statusItem];
1090 }
1091
1092
1093 /*************************************************************************/
1094 #pragma mark -
1095 #pragma mark DEALLOCATION METHOD
1096 /*************************************************************************/
1097
1098 - (void)dealloc
1099 {
1100     [self applicationTerminated:nil];
1101     [bling release];
1102     [statusItem release];
1103     [statusWindowController release];
1104     [menuController release];
1105     [networkController release];
1106     [super dealloc];
1107 }
1108
1109 @end