CPUUsageMonitor.m

   1 //
   2 //  CPUUsageMonitor.m
   3 //  CPU Usage
   4 //
   5 //  Created by Peter Hosey on 2006-06-21.
   6 //  Copyright 2006 Peter Hosey. All rights reserved.
   7 //
   8
   9 #import "CPUUsageMonitor.h"
  10
  11 #import "CPUUsageView.h"
  12 #import "NSString+Percentage.h"
  13
  14 #import "BZGridEnumerator.h"
  15
  16 #include <sys/types.h>
  17 //sqrtf, ceilf
  18 #include <math.h>
  19 //sysctl and its parameters
  20 #include <sys/sysctl.h>
  21 //errno, strerror
  22 #include <sys/errno.h>
  23 #include <string.h>
  24
  25 #define DOCK_ICON_SIZE 128.0f
  26
  27 @interface CPUUsageMonitor (PRIVATE)
  28
  29 - (void)layOutCellsInWindow:(NSWindow *)thisWindow;
  30
  31 @end
  32
  33 @implementation CPUUsageMonitor
  34
  35 + (void)initialize {
  36         [self exposeBinding:@"backgroundColor"];
  37         [self exposeBinding:@"cellWidth"];
  38         [self exposeBinding:@"cellHeight"];
  39         [self exposeBinding:@"shouldDrawToDockIcon"];
  40         [self exposeBinding:@"shouldDrawToWindow"];
  41 }
  42
  43 - init {
  44         if((self = [super init])) {
  45                 NSNumber *thirtyTwo = [NSNumber numberWithFloat:32.0f];
  46                 NSDictionary *defaultPrefs = [NSDictionary dictionaryWithObjectsAndKeys:
  47                         [NSArchiver archivedDataWithRootObject:[NSColor whiteColor]], @"Floater text color",
  48                         [NSNumber numberWithFloat:0.0f], @"Floater text opacity",
  49                         [NSArchiver archivedDataWithRootObject:[NSColor whiteColor]], @"Dock icon text color",
  50                         [NSNumber numberWithFloat:1.0f], @"Dock icon text opacity",
  51                         [NSArchiver archivedDataWithRootObject:[NSColor redColor]], @"Background color",
  52                         thirtyTwo, @"Cell width",
  53                         thirtyTwo, @"Cell height",
  54                         [NSNumber numberWithBool:YES], @"Draw CPU usage to window",
  55                         [NSNumber numberWithInt:CPUUsageOrientationVertical], @"Window orientation",
  56                         [NSNumber numberWithBool:NO], @"Draw CPU usage to Dock icon",
  57                         nil];
  58
  59                 [[NSUserDefaults standardUserDefaults] registerDefaults:defaultPrefs];
  60         }
  61         return self;
  62 }
  63
  64 #pragma mark NSApplication delegate conformance
  65
  66 - (void)applicationDidFinishLaunching:(NSNotification *)notification {
  67         //Set up us the properties of new cells.
  68         NSUserDefaults *defaults = [NSUserDefaults standardUserDefaults];
  69         NSData *data = [defaults dataForKey:@"Background color"];
  70         NSColor *color = data ? [NSUnarchiver unarchiveObjectWithData:data] : [NSColor redColor];
  71         [self setBackgroundColor:color];
  72
  73         [self setCellWidth:[defaults floatForKey:@"Cell width"]];
  74         [self setCellHeight:[defaults floatForKey:@"Cell height"]];
  75
  76         //Sign up for notifications of pref changes.
  77         NSUserDefaultsController *udc = [NSUserDefaultsController sharedUserDefaultsController];
  78         NSDictionary *colorBindingOptions = [NSDictionary dictionaryWithObject:@"NSUnarchiveFromData" forKey:NSValueTransformerNameBindingOption];
  79         [self bind:@"backgroundColor"      toObject:udc withKeyPath:@"values.Background color"            options:colorBindingOptions];
  80         [self bind:@"cellWidth"            toObject:udc withKeyPath:@"values.Cell width"                  options:nil];
  81         [self bind:@"cellHeight"           toObject:udc withKeyPath:@"values.Cell height"                 options:nil];
  82         [self bind:@"shouldDrawToDockIcon" toObject:udc withKeyPath:@"values.Draw CPU usage to Dock icon" options:nil];
  83         [self bind:@"shouldDrawToWindow"   toObject:udc withKeyPath:@"values.Draw CPU usage to window"    options:nil];
  84
  85         //Fetch the orientation from prefs.
  86         orientation = [defaults integerForKey:@"Window orientation"];
  87
  88         //Set up the orientation buttons.
  89         int buttonStates[2] = { NSOffState, NSOnState };
  90         [horizontalButton  setState:buttonStates[(orientation == CPUUsageOrientationHorizontal )]];
  91         [verticalButton    setState:buttonStates[(orientation == CPUUsageOrientationVertical   )]];
  92         [rectangularButton setState:buttonStates[(orientation == CPUUsageOrientationRectangular)]];
  93
  94         //We could get the number of processors the same way that we get the CPU usage info, but that allocates memory.
  95         enum { miblen = 2U };
  96         int mib[miblen] = { CTL_HW, HW_NCPU };
  97         size_t sizeOfNumCPUs = sizeof(numCPUs);
  98         int status = sysctl(mib, miblen,
  99                    &numCPUs, &sizeOfNumCPUs,
 100                    /*newp*/ NULL, /*newlen*/ 0U);
 101         if(status != 0)
 102                 numCPUs = 1; //XXX Should probably error out instead…
 103
 104         //Set up our display destinations.
 105         //First, the Dock icon window. We'll copy the content view into an image, which we set as the application icon.
 106         NSRect dockIconRect = { NSZeroPoint, { DOCK_ICON_SIZE, DOCK_ICON_SIZE } };
 107         dockIconWindow = [[NSPanel alloc] initWithContentRect:dockIconRect
 108                                                                                                 styleMask:NSBorderlessWindowMask
 109                                                                                                   backing:NSBackingStoreBuffered
 110                                                                                                         defer:YES];
 111         [dockIconWindow setTitle:@"CPU Usage hidden Dock-icon window"];
 112         [dockIconWindow setOpaque:NO];
 113         [dockIconWindow setAcceptsMouseMovedEvents:NO];
 114         [dockIconWindow setMovableByWindowBackground:YES];
 115         [dockIconWindow setHasShadow:NO];
 116         [dockIconWindow setIgnoresMouseEvents:YES];
 117         [dockIconWindow setReleasedWhenClosed:YES];
 118         [dockIconWindow setOneShot:NO];
 119         [dockIconWindow setBackgroundColor:[NSColor clearColor]];
 120         //We need to order the window in so that the views can draw. But we only want the user to see the Dock icon, not the window. So we set the alpha to 0.
 121         [dockIconWindow setAlphaValue:0.0f];
 122         [dockIconWindow orderBack:nil];
 123
 124         dockIconUsageViewsContainingView = [dockIconWindow contentView];
 125
 126         dockIconUsageViews = [[NSMutableArray alloc] initWithCapacity:numCPUs];
 127         [self layOutCellsInWindow:dockIconWindow];
 128
 129         //Second, create the floater.
 130         float numCPUsFloat = numCPUs;
 131         float numViewsX, numViewsY;
 132         if(orientation == CPUUsageOrientationHorizontal) {
 133                 numViewsX = numCPUsFloat;
 134                 numViewsY = 1.0f;
 135         } else if(orientation == CPUUsageOrientationVertical) {
 136                 numViewsX = 1.0f;
 137                 numViewsY = numCPUsFloat;
 138         } else {
 139                 numViewsX = ceilf(sqrtf(numCPUsFloat));
 140                 numViewsY = ceilf(numCPUsFloat / numViewsX);
 141         }
 142         float numCellsMissing = ((numViewsX * numViewsY) - numCPUsFloat);
 143
 144         //Here, these enumerators are used only to compute the frame of the window. No actual enumeration is done.
 145         BZGridEnumerator *floaterOddCellsEnum = nil;
 146         BZGridEnumerator *floaterCellsEnum = [[BZGridEnumerator alloc] initWithCellSize:(NSSize){ cellWidth, cellHeight }
 147                                                                                                                                         numberOfColumns:numViewsX
 148                                                                                                                                            numberOfRows:numViewsY];
 149         NSRect frame = [floaterCellsEnum overallRect];
 150         if(numCellsMissing) {
 151                 float numOddCells = numCellsMissing ? numViewsX - numCellsMissing : 0.0f;
 152                 /*oddCellsWidth is the fraction of the total frame width used by odd cells.
 153                  *total = X*Y
 154                  *numEmptySpaces = total - numCPUs
 155                  *numOddCPUs = X - numEmptySpaces
 156                  *oddCellsWidth = numOddCPUs / X
 157                  */
 158                 float oddCellsWidth = numOddCells / numViewsX;
 159                 float oddCellWidth = oddCellsWidth / numOddCells;
 160
 161                 floaterOddCellsEnum = [[BZGridEnumerator alloc] initWithCellSize:(NSSize){ frame.size.width * oddCellWidth, cellHeight }
 162                                                                                                                                   offset:(NSPoint){ 0.0f, cellHeight * numViewsY }
 163                                                                                                                  numberOfColumns:numOddCells
 164                                                                                                                         numberOfRows:1U];
 165                 frame.size.height += [floaterOddCellsEnum overallRect].size.height;
 166         }
 167
 168         window = [[NSWindow alloc] initWithContentRect:frame
 169                                                                                  styleMask:NSBorderlessWindowMask
 170                                                                                    backing:NSBackingStoreBuffered
 171                                                                                          defer:YES];
 172         [window setTitle:@"CPU Usage"];
 173         [window setOpaque:NO];
 174         [window setAcceptsMouseMovedEvents:NO];
 175         [window setMovableByWindowBackground:YES];
 176         [window setLevel:kCGDesktopWindowLevel + 2];
 177         [window setHasShadow:NO];
 178         [window setIgnoresMouseEvents:YES];
 179         [window setReleasedWhenClosed:YES];
 180         if(orientation != CPUUsageOrientationRectangular) {
 181                 BOOL isHorizontal = (orientation == CPUUsageOrientationHorizontal);
 182                 [window setResizeIncrements:(NSSize){ numCPUs * isHorizontal, numCPUs * !isHorizontal }];
 183         }
 184         [window setBackgroundColor:[NSColor clearColor]];
 185
 186         usageViews = [[NSMutableArray alloc] initWithCapacity:numCPUs];
 187         [self layOutCellsInWindow:window];
 188
 189         [window setFrameAutosaveName:@"CPU usage window"];
 190         if(![window setFrameUsingName:@"CPU usage window"])
 191                 [window center];
 192         else {
 193                 frame.origin = [window frame].origin;
 194                 [window setFrame:frame display:NO];
 195         }
 196         [preferencesPanel center];
 197
 198         CPUUsageLock = [[NSLock alloc] init];
 199         CPUUsage = NSZoneMalloc([self zone], numCPUs * sizeof(float));
 200
 201         updateTimer = [[NSTimer scheduledTimerWithTimeInterval:0.5
 202                                                                                                         target:self
 203                                                                                                   selector:@selector(updateCPUUsageButNotViews:)
 204                                                                                                   userInfo:nil
 205                                                                                                    repeats:YES] retain];
 206         [updateTimer fire];
 207
 208         //Launch the threaded timers that sweep our CPU usage array looking for views.
 209         for(unsigned i = 0U; i < numCPUs; ++i) {
 210                 [NSThread detachNewThreadSelector:@selector(threadedLaunchTimer:)
 211                                                                  toTarget:self
 212                                                            withObject:[NSNumber numberWithUnsignedInt:i]];
 213         }
 214
 215         if(shouldDrawToWindow)
 216                 [window orderFront:nil];
 217 }
 218
 219 - (void)applicationWillTerminate:(NSNotification *)notification {
 220         //First, fade out the window.
 221         NSDictionary *animDict = [NSDictionary dictionaryWithObjectsAndKeys:
 222                 window, NSViewAnimationTargetKey,
 223                 NSViewAnimationFadeOutEffect, NSViewAnimationEffectKey,
 224                 nil];
 225         NSViewAnimation *anim = [[NSViewAnimation alloc] initWithViewAnimations:[NSArray arrayWithObject:animDict]];
 226         [anim setDuration:0.5];
 227         [anim setAnimationBlockingMode:NSAnimationNonblockingThreaded];
 228
 229         //Tell the threads to stop, then wait for them to comply.
 230 //      threadsShouldExit = YES;
 231         threadsRemainingToDie = [usageViews count];
 232         [anim startAnimation];
 233
 234         unsigned sleepCount = 100U; //Wait no more than this many seconds.
 235         while(threadsRemainingToDie && sleepCount--)
 236                 [NSThread sleepUntilDate:[NSDate dateWithTimeIntervalSinceNow:0.1]];
 237
 238         //Wait for the animation to run out.
 239         while([anim isAnimating])
 240                 [NSThread sleepUntilDate:[NSDate dateWithTimeIntervalSinceNow:0.1]];
 241
 242         [updateTimer invalidate];
 243         [updateTimer release];
 244
 245         [usageViews release];
 246
 247         [backgroundColor release];
 248
 249         [window close];
 250
 251         NSZoneFree([self zone], CPUUsage);
 252
 253         [NSApp setApplicationIconImage:[NSImage imageNamed:@"CPUUsageIcon"]];
 254 }
 255
 256 - (void)applicationDidBecomeActive:(NSNotification *)notification {
 257         NSEnumerator *usageViewsEnum = [usageViews objectEnumerator];
 258         CPUUsageView *usageView;
 259         while((usageView = [usageViewsEnum nextObject])) {
 260                 [usageView setDrawsFrame:YES];
 261                 [usageView setNeedsDisplay:YES];
 262         }
 263
 264         [window setIgnoresMouseEvents:NO];
 265 }
 266 - (void)applicationWillResignActive:(NSNotification *)notification {
 267         NSEnumerator *usageViewsEnum = [usageViews objectEnumerator];
 268         CPUUsageView *usageView;
 269         while((usageView = [usageViewsEnum nextObject])) {
 270                 [usageView setDrawsFrame:NO];
 271                 [usageView setNeedsDisplay:YES];
 272         }
 273
 274         [window setIgnoresMouseEvents:YES];
 275 }
 276
 277 #pragma mark Stuff
 278
 279 - (void)drawToDockIcon {
 280         NSRect dockIconRect = { NSZeroPoint, { DOCK_ICON_SIZE, DOCK_ICON_SIZE } };
 281
 282         [dockIconUsageViewsContainingView lockFocus];
 283         NSBitmapImageRep *rep = [[NSBitmapImageRep alloc] initWithFocusedViewRect:dockIconRect];
 284         [dockIconUsageViewsContainingView unlockFocus];
 285
 286         NSImage *image = [[NSImage alloc] initWithSize:dockIconRect.size];
 287         [image addRepresentation:rep];
 288         [rep release];
 289
 290         //Add a border.
 291         [image lockFocus];
 292         [backgroundColor set];
 293         NSFrameRectWithWidth([dockIconUsageViewsContainingView frame], 2.0f);
 294         [image unlockFocus];
 295
 296         [NSApp setApplicationIconImage:image];
 297         [image release];
 298 }
 299
 300 #pragma mark Timer
 301
 302 - (void)threadedUpdateCPUUsageView:(NSTimer *)timer {
 303         unsigned i = [[timer userInfo] unsignedIntValue];
 304
 305         CPUUsageView *view = [usageViews objectAtIndex:i];
 306         CPUUsageView *viewInDockIcon = [dockIconUsageViews objectAtIndex:i];
 307
 308         [CPUUsageLock lock];
 309         [view setCPUUsage:CPUUsage[i]];
 310         [viewInDockIcon setCPUUsage:CPUUsage[i]];
 311         [CPUUsageLock unlock];
 312
 313         if(shouldDrawToWindow)
 314                 [view display];
 315         if(shouldDrawToDockIcon)
 316                 [viewInDockIcon display];
 317
 318         if(threadsRemainingToDie) {
 319                 [timer invalidate];
 320
 321                 [deathLock lock];
 322                 --threadsRemainingToDie;
 323                 [deathLock unlock];
 324         }
 325 }
 326 - (void)threadedLaunchTimer:(NSNumber *)CPUIndexNum {
 327         NSAutoreleasePool *pool = [[NSAutoreleasePool alloc] init];
 328
 329         NSRunLoop *runLoop = [NSRunLoop currentRunLoop];
 330
 331         NSTimer *timer = [NSTimer timerWithTimeInterval:0.5
 332                                                                                          target:self
 333                                                                                    selector:@selector(threadedUpdateCPUUsageView:)
 334                                                                                    userInfo:CPUIndexNum //userInfo
 335                                                                                         repeats:YES];
 336         [timer setFireDate:[NSDate dateWithTimeIntervalSinceNow:0.25]];
 337
 338         [runLoop addTimer:timer forMode:NSDefaultRunLoopMode];
 339         [runLoop run];
 340
 341         [pool release];
 342 }
 343
 344 //Main thread.
 345 - (void)updateCPUUsageButNotViews:(NSTimer *)timer {
 346         if(shouldDrawToDockIcon)
 347                 [self drawToDockIcon];
 348
 349         natural_t numProcessors_nobodyCares = 0U;
 350         processor_info_array_t processorInfo;
 351         mach_msg_type_number_t numProcessorInfo;
 352
 353         kern_return_t err = host_processor_info(mach_host_self(), PROCESSOR_CPU_LOAD_INFO, &numProcessors_nobodyCares, &processorInfo, &numProcessorInfo);
 354         if(err == KERN_SUCCESS) {
 355                 vm_map_t target_task = mach_task_self();
 356
 357                 [CPUUsageLock lock];
 358
 359                 for(unsigned i = 0U; i < numCPUs; ++i) {
 360                         //We only want the last $REFRESH_TIME seconds' worth of data, not all time.
 361                         float inUse, total;
 362                         if(lastProcessorInfo) {
 363                                 inUse = (
 364                                   (processorInfo[(CPU_STATE_MAX * i) + CPU_STATE_USER]   - lastProcessorInfo[(CPU_STATE_MAX * i) + CPU_STATE_USER])
 365                                 + (processorInfo[(CPU_STATE_MAX * i) + CPU_STATE_SYSTEM] - lastProcessorInfo[(CPU_STATE_MAX * i) + CPU_STATE_SYSTEM])
 366                                 + (processorInfo[(CPU_STATE_MAX * i) + CPU_STATE_NICE]   - lastProcessorInfo[(CPU_STATE_MAX * i) + CPU_STATE_NICE])
 367                                 );
 368                                 total = inUse + (processorInfo[(CPU_STATE_MAX * i) + CPU_STATE_IDLE] - lastProcessorInfo[(CPU_STATE_MAX * i) + CPU_STATE_IDLE]);
 369                         } else {
 370                                 inUse = processorInfo[(CPU_STATE_MAX * i) + CPU_STATE_USER] + processorInfo[(CPU_STATE_MAX * i) + CPU_STATE_SYSTEM] + processorInfo[(CPU_STATE_MAX * i) + CPU_STATE_NICE];
 371                                 total = inUse + processorInfo[(CPU_STATE_MAX * i) + CPU_STATE_IDLE];
 372                         }
 373
 374                         CPUUsage[i] = inUse / total;
 375                 }
 376
 377                 [CPUUsageLock unlock];
 378
 379                 if(lastProcessorInfo) {
 380                         size_t lastProcessorInfoSize = sizeof(integer_t) * numLastProcessorInfo;
 381                         vm_deallocate(target_task, (vm_address_t)lastProcessorInfo, lastProcessorInfoSize);
 382                 }
 383
 384                 lastProcessorInfo = processorInfo;
 385                 numLastProcessorInfo = numProcessorInfo;
 386         } else {
 387                 NSDictionary *dict = [NSDictionary dictionaryWithObjectsAndKeys:
 388                         NSLocalizedString(@"Could not get CPU load information", /*comment*/ nil), NSLocalizedDescriptionKey,
 389                         NSLocalizedString(@"Do you have a CPU in your computer? (Just kidding. I have no idea how to get a useful string from a kernel error code. --The Author)", /*comment*/ nil), NSLocalizedRecoverySuggestionErrorKey,
 390                         nil];
 391                 [NSApp presentError:[NSError errorWithDomain:NSMachErrorDomain code:err userInfo:dict]];
 392                 [NSApp terminate:nil];
 393         }
 394 }
 395
 396 #pragma mark Accessors
 397
 398 - (NSColor *)backgroundColor {
 399         return backgroundColor;
 400 }
 401 - (void)setBackgroundColor:(NSColor *)newBackgroundColor {
 402         if(backgroundColor != newBackgroundColor) {
 403                 [backgroundColor release];
 404                 backgroundColor = [newBackgroundColor retain];
 405         }
 406 }
 407
 408 - (float)cellWidth {
 409         return cellWidth;
 410 }
 411 - (void)setCellWidth:(float)newCellWidth {
 412         cellWidth = newCellWidth;
 413
 414         if(window) {
 415                 register float numCPUsFloat = numCPUs;
 416                 float numViewsX, numViewsY;
 417                 if(orientation == CPUUsageOrientationHorizontal) {
 418                         numViewsX = numCPUs;
 419                         numViewsY = 1.0f;
 420                 } else if(orientation == CPUUsageOrientationVertical) {
 421                         numViewsX = 1.0f;
 422                         numViewsY = numCPUs;
 423                 } else {
 424                         numViewsX = ceilf(sqrtf(numCPUsFloat));
 425                         numViewsY = ceilf(numCPUsFloat / numViewsX);
 426                 }
 427
 428                 NSRect oldFrame = [window frame];
 429                 NSRect newFrame = oldFrame;
 430                 newFrame.size.width  = cellWidth  * numViewsX;
 431                 newFrame.size.height = cellHeight * numViewsY;
 432 //              [window setFrame:newFrame display:YES animate:YES]; //For some reason, this blocks dragging the window around. Lucky me — the NSViewAnimation is prettier.
 433                 NSDictionary *animDict = [NSDictionary dictionaryWithObjectsAndKeys:
 434                         window, NSViewAnimationTargetKey,
 435                         [NSValue valueWithRect:oldFrame], NSViewAnimationStartFrameKey,
 436                         [NSValue valueWithRect:newFrame], NSViewAnimationEndFrameKey,
 437                         nil];
 438                 NSViewAnimation *anim = [[NSViewAnimation alloc] initWithViewAnimations:[NSArray arrayWithObject:animDict]];
 439                 [anim startAnimation];
 440                 [anim release];
 441         }
 442 }
 443
 444 - (float)cellHeight {
 445         return cellHeight;
 446 }
 447 - (void)setCellHeight:(float)newCellHeight {
 448         cellHeight = newCellHeight;
 449
 450         if(window) {
 451                 register float numCPUsFloat = numCPUs;
 452                 float numViewsX, numViewsY;
 453                 if(orientation == CPUUsageOrientationHorizontal) {
 454                         numViewsX = numCPUs;
 455                         numViewsY = 1.0f;
 456                 } else if(orientation == CPUUsageOrientationVertical) {
 457                         numViewsX = 1.0f;
 458                         numViewsY = numCPUs;
 459                 } else {
 460                         numViewsX = ceilf(sqrtf(numCPUsFloat));
 461                         numViewsY = ceilf(numCPUsFloat / numViewsX);
 462                 }
 463
 464                 NSRect oldFrame = [window frame];
 465                 NSRect newFrame = oldFrame;
 466                 newFrame.size.width  = cellWidth  * numViewsX;
 467                 newFrame.size.height = cellHeight * numViewsY;
 468 //              [window setFrame:frame display:YES animate:YES]; //For some reason, this blocks dragging the window around. Lucky me — the NSViewAnimation is prettier.
 469                 NSDictionary *animDict = [NSDictionary dictionaryWithObjectsAndKeys:
 470                         window, NSViewAnimationTargetKey,
 471                         [NSValue valueWithRect:oldFrame], NSViewAnimationStartFrameKey,
 472                         [NSValue valueWithRect:newFrame], NSViewAnimationEndFrameKey,
 473                         nil];
 474                 NSViewAnimation *anim = [[NSViewAnimation alloc] initWithViewAnimations:[NSArray arrayWithObject:animDict]];
 475                 [anim startAnimation];
 476                 [anim release];
 477         }
 478 }
 479
 480 - (BOOL)shouldDrawToDockIcon {
 481         return shouldDrawToDockIcon;
 482 }
 483 - (void)setShouldDrawToDockIcon:(BOOL)flag {
 484         shouldDrawToDockIcon = flag;
 485
 486         if(!shouldDrawToDockIcon)
 487                 [NSApp setApplicationIconImage:[NSImage imageNamed:@"CPUUsageIcon"]];
 488 }
 489
 490 - (BOOL)shouldDrawToWindow {
 491         return shouldDrawToWindow;
 492 }
 493 - (void)setShouldDrawToWindow:(BOOL)flag {
 494         shouldDrawToWindow = flag;
 495
 496         if(shouldDrawToWindow)
 497                 [window orderFront:nil];
 498         else
 499                 [window orderOut:nil];
 500 }
 501
 502 #pragma mark Actions
 503
 504 - (IBAction)setOrientationToVertical:sender {
 505         orientation = CPUUsageOrientationVertical;
 506         [[[NSUserDefaultsController sharedUserDefaultsController] values] setValue:[NSNumber numberWithInt:orientation] forKey:@"Window orientation"];
 507
 508         [self layOutCellsInWindow:window];
 509
 510         [verticalButton    setState:NSOnState];
 511         [horizontalButton  setState:NSOffState];
 512         [rectangularButton setState:NSOffState];
 513 }
 514 - (IBAction)setOrientationToHorizontal:sender {
 515         orientation = CPUUsageOrientationHorizontal;
 516         [[[NSUserDefaultsController sharedUserDefaultsController] values] setValue:[NSNumber numberWithInt:orientation] forKey:@"Window orientation"];
 517
 518         [self layOutCellsInWindow:window];
 519
 520         [verticalButton    setState:NSOffState];
 521         [horizontalButton  setState:NSOnState];
 522         [rectangularButton setState:NSOffState];
 523 }
 524 - (IBAction)setOrientationToRectangular:sender {
 525         orientation = CPUUsageOrientationRectangular;
 526         [[[NSUserDefaultsController sharedUserDefaultsController] values] setValue:[NSNumber numberWithInt:orientation] forKey:@"Window orientation"];
 527
 528         [self layOutCellsInWindow:window];
 529
 530         [verticalButton    setState:NSOffState];
 531         [horizontalButton  setState:NSOffState];
 532         [rectangularButton setState:NSOnState];
 533 }
 534
 535 @end
 536
 537 @implementation CPUUsageMonitor (PRIVATE)
 538
 539 - (void)layOutCellsInWindow:(NSWindow *)thisWindow {
 540         [thisWindow disableScreenUpdatesUntilFlush];
 541
 542         //Each cell in the Dock icon is square, so this rectangle may not be square. Consider a dual-proc machine.
 543         //And of course, the floater is non-square in most configurations.
 544         /*numCPUs = 8
 545          *+--+--+
 546          *|1 | 2|
 547          *+-+-+-+
 548          *|3|4|5|
 549          *+-+-+-+
 550          *|6|7|8|
 551          *+-+-+-+
 552          */
 553         register float numCPUsFloat = numCPUs;
 554         float numViewsX, numViewsY;
 555         if((thisWindow == window) && (orientation == CPUUsageOrientationHorizontal)) {
 556                 numViewsX = numCPUsFloat;
 557                 numViewsY = 1.0f;
 558         } else if((thisWindow == window) && (orientation == CPUUsageOrientationVertical)) {
 559                 numViewsX = 1.0f;
 560                 numViewsY = numCPUsFloat;
 561         } else {
 562                 numViewsX = ceilf(sqrtf(numCPUsFloat));
 563                 numViewsY = ceilf(numCPUsFloat / numViewsX);
 564         }
 565         BOOL drawingToDock = (thisWindow == dockIconWindow);
 566
 567         NSSize cellSize;
 568         if(drawingToDock) {
 569                 cellSize.width  = DOCK_ICON_SIZE / numViewsX;
 570                 cellSize.height = DOCK_ICON_SIZE / numViewsY;
 571         } else {
 572                 cellSize.width  = cellWidth;
 573                 cellSize.height = cellHeight;
 574         }
 575
 576         //Handle odd cells (1 and 2 above).
 577         //The number of cells missing from the row with the odd cells (in the example above, this = 1).
 578         float numCellsMissing = ((numViewsX * numViewsY) - numCPUsFloat);
 579         float numOddCellsFloat = numCellsMissing ? numViewsX - numCellsMissing : 0.0f;
 580         unsigned numOddCells = numOddCellsFloat;
 581         unsigned numNotOddCells = numCPUs - numOddCells;
 582
 583         BZGridEnumerator *floaterOddCellsEnum = nil;
 584         BZGridEnumerator *floaterCellsEnum = [[BZGridEnumerator alloc] initWithCellSize:cellSize
 585                                                                                                                                         numberOfColumns:numViewsX
 586                                                                                                                                            numberOfRows:numViewsY];
 587         NSRect frame = [floaterCellsEnum overallRect];
 588         if(numCellsMissing) {
 589                 /*oddCellsWidth is the fraction of the total frame width used by odd cells.
 590                  *total = X*Y
 591                  *numEmptySpaces = total - numCPUs
 592                  *numOddCPUs = X - numEmptySpaces
 593                  *oddCellsWidth = numOddCPUs / X
 594                  */
 595                 float oddCellsWidth = numOddCellsFloat / numViewsX;
 596                 float oddCellWidth = oddCellsWidth / numOddCellsFloat;
 597                 floaterOddCellsEnum = [[BZGridEnumerator alloc] initWithCellSize:(NSSize){ frame.size.width * oddCellWidth, cellSize.height }
 598                                                                                                                                   offset:(NSPoint){ 0.0f, cellSize.height * numViewsY }
 599                                                                                                                  numberOfColumns:numOddCells
 600                                                                                                                         numberOfRows:1U];
 601                 frame.size.height += [floaterOddCellsEnum overallRect].size.height;
 602         }
 603         frame.origin = [thisWindow frame].origin;
 604         [thisWindow setFrame:frame display:NO];
 605         float offsetY = drawingToDock ? ((DOCK_ICON_SIZE - frame.size.height) * 0.5f) : 0.0f;
 606
 607         //Sign up for notifications of pref changes.
 608         NSUserDefaultsController *udc = [NSUserDefaultsController sharedUserDefaultsController];
 609         NSDictionary *colorBindingOptions = [NSDictionary dictionaryWithObject:@"NSUnarchiveFromData" forKey:NSValueTransformerNameBindingOption];
 610
 611         NSMutableArray *usageViewsArray = (thisWindow == window) ? usageViews : dockIconUsageViews;
 612         unsigned usageViewsArrayCount = [usageViewsArray count];
 613
 614         //We need this information to set drawsFrame of every view to the correct value.
 615         //We don't need to retrieve it every time, so we get it once here and cache it in a variable.
 616         //The Dock icon window never has per-cell frames.
 617         BOOL shouldDrawFrame = [NSApp isActive] && (thisWindow == window);
 618
 619         //Add CPU usage views.
 620         unsigned numCols = numViewsX, numRows = numViewsY;
 621         NSView *contentView = [thisWindow contentView];
 622         unsigned CPUNum = 0U;
 623         if(numCellsMissing) {
 624                 while(numOddCells--) {
 625                         NSRect oddCellRect = [floaterOddCellsEnum nextRect];
 626                         oddCellRect.origin.y += offsetY;
 627
 628                         CPUUsageView *usageView;
 629                         if(CPUNum >= usageViewsArrayCount) {
 630                                 usageView = [[[CPUUsageView alloc] initWithFrame:oddCellRect] autorelease];
 631                                 [contentView addSubview:usageView];
 632                                 [usageViewsArray addObject:usageView];
 633                                 ++usageViewsArrayCount;
 634                         } else {
 635                                 usageView = [usageViewsArray objectAtIndex:CPUNum];
 636                                 [usageView setFrame:oddCellRect];
 637                         }
 638
 639                         [usageView setDrawsFrame:shouldDrawFrame];
 640                         [usageView setCPUUsage:8.88f]; //XXX TEMP - Should just not update the Dock icon until after all samples anyway
 641                         if(numCPUs > 1)
 642                                 [usageView setCPUNumber:++CPUNum];
 643
 644                         [usageView bind:@"textColor"
 645                                    toObject:udc
 646                                 withKeyPath:@"values.Dock icon text color"
 647                                         options:colorBindingOptions];
 648                         [usageView bind:@"textOpacity"
 649                                    toObject:udc
 650                                 withKeyPath:@"values.Dock icon text opacity"
 651                                         options:nil];
 652                         [usageView bind:@"backgroundColor"
 653                                    toObject:self
 654                                 withKeyPath:@"backgroundColor"
 655                                         options:nil];
 656
 657                         oddCellRect.origin.x += oddCellRect.size.width;
 658                 }
 659         }
 660         while(numNotOddCells--) {
 661                 frame = [floaterCellsEnum nextRect];
 662                 frame.origin.y += offsetY;
 663                 unsigned col = CPUNum % numCols, row = CPUNum / numRows;
 664
 665                 CPUUsageView *usageView;
 666                 if(CPUNum >= usageViewsArrayCount) {
 667                         usageView = [[[CPUUsageView alloc] initWithFrame:frame] autorelease];
 668                         [contentView addSubview:usageView];
 669                         [usageViewsArray addObject:usageView];
 670                         ++usageViewsArrayCount;
 671                 } else {
 672                         usageView = [usageViewsArray objectAtIndex:CPUNum];
 673                         [usageView setFrame:frame];
 674                 }
 675                 unsigned mask = NSViewWidthSizable | NSViewHeightSizable
 676                         | (NSViewMinXMargin * (col  > 0U)           )
 677                         | (NSViewMaxXMargin * (col < (numCols - 1U)))
 678                         | (NSViewMaxYMargin * (row  > 0U)           )
 679                         | (NSViewMinYMargin * (row < (numRows - 1U)))
 680                         ;
 681                 [usageView setAutoresizingMask:mask];
 682                 [usageView setMenu:contextualMenu];
 683
 684                 [usageView setDrawsFrame:shouldDrawFrame];
 685                 if(numCPUs > 1)
 686                         [usageView setCPUNumber:++CPUNum];
 687
 688                 [usageView bind:@"textColor"
 689                            toObject:udc
 690                         withKeyPath:@"values.Floater text color"
 691                                 options:colorBindingOptions];
 692                 [usageView bind:@"textOpacity"
 693                            toObject:udc
 694                         withKeyPath:@"values.Floater text opacity"
 695                                 options:nil];
 696                 [usageView bind:@"backgroundColor"
 697                            toObject:self
 698                         withKeyPath:@"backgroundColor"
 699                                 options:nil];
 700         }
 701
 702         [floaterOddCellsEnum release];
 703         [floaterCellsEnum release];
 704 }
 705
 706 @end