DownAndOutView.m

//
//  DownAndOutView.m
//  DownAndOutª
//
//  Created by Fritz Anderson on Mon Aug 18 2003.
//  Copyright (c) 2003 Trustees of the University of Chicago. All rights reserved.
//  This program is free software; you can redistribute it and/or modify
//  it under the terms of the GNU General Public License as published by
//  the Free Software Foundation; either version 2 of the License, or
//  (at your option) any later version.
//  
//  This program is distributed in the hope that it will be useful,
//  but WITHOUT ANY WARRANTY; without even the implied warranty of
//  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
//  GNU General Public License for more details.
//  
//  You should have received a copy of the GNU General Public License
//  along with this program; if not, write to the Free Software
//  Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
//

#import "DownAndOutView.h"
#import "DownAndOutController.h"
#import "DAApplication.h"

#define CLOCK_RADIUS    clockRadius
#define CLOCK_WIDTH     (2.0 * CLOCK_RADIUS + 3.0)
#define CONTENT_HEIGHT  (2.0 * CLOCK_RADIUS)
#define FIXED_WIDTH     (3.0 + 7.0 * CLOCK_RADIUS)

#define MAX_V_COMPONENT 1.3


@implementation DownAndOutView

- (void) setDeadlineForSeconds: (int) seconds
{
    [deadline release];
    secondsLeft = seconds;
    deadline = [[NSDate dateWithTimeIntervalSinceNow: secondsLeft] retain];
}

- (void) resetClock
{
    [self setDeadlineForSeconds: [controller secondsBeforeLogout]];
}

- (id) initWithFrame: (NSRect) frame isPreview: (BOOL) isPreview
{
    self = [super initWithFrame: frame isPreview: isPreview];
    if (self) {     
        [self setAnimationTimeInterval:1/20.0];
        
        clockRadius = -1.0;
        controller = [[DownAndOutController alloc] initAsPreview: isPreview forView: self];
        //  controller will read and initialize clock radius, and thus also the images.
        
        state = kDOInitial;
    }
    return self;
}

- (float) clockRadius { return clockRadius; }

static NSDictionary *   attrs = nil;

- (void) setClockRadius: (float) newRadius
{
    if (newRadius != clockRadius) {
        clockRadius = newRadius;
        
        [pieImage release];
        pieImage = [[NSImage alloc] initWithSize: NSMakeSize(2.0 * clockRadius + 2.0, 2.0 * clockRadius + 2.0)];
        
        [textImage release];
        textImage = [[NSImage alloc] initWithSize: NSMakeSize(FIXED_WIDTH - CLOCK_WIDTH, CONTENT_HEIGHT)];

        [attrs release];
        NSFont *    times24Ital = [NSFont fontWithName: @"Times-Italic" size: (clockRadius/2.0) - 1.0];
        attrs = [[NSDictionary alloc] initWithObjectsAndKeys:
            times24Ital, NSFontAttributeName,
            [NSColor lightGrayColor], NSForegroundColorAttributeName,
            nil];
    }
}

- (void) dealloc
{
    [controller release];
    [deadline release];
    [pieImage release];
    [textImage release];
    [super dealloc];
}

- (void) fillTextImageWithSeconds: (int) seconds
{
    NSRect      frame = NSMakeRect(0.0, 0.0, FIXED_WIDTH - CLOCK_WIDTH, CONTENT_HEIGHT);
    
    NSString *  message = [controller messageTextForSeconds: seconds];
        
    [textImage lockFocus];
    
    [[NSColor blackColor] set];
    NSRectFill(frame);
    
    [message drawInRect: frame withAttributes: attrs];
    
    [textImage unlockFocus];
}

- (void) fillTextImageWithString: (NSString *) aString
{
    NSRect      frame = NSMakeRect(0.0, 0.0, FIXED_WIDTH - CLOCK_WIDTH, CONTENT_HEIGHT);
    
    [textImage lockFocus];
    
    [[NSColor blackColor] set];
    NSRectFill(frame);
    
    [aString drawInRect: frame withAttributes: attrs];
    
    [textImage unlockFocus];
}

- (NSRect) addedImageRect
{
    NSImage *       image = [controller addedImage];
    NSRect          retval = NSMakeRect(NSMinX(contentRect), NSMinY(contentRect), 0.0, CONTENT_HEIGHT);
    
    if (!image)
        return retval;
    
    NSSize          imageSize = [image size];
    
    if (imageSize.height <= CONTENT_HEIGHT) {
        //  Small images get drawn actual-size, vertically centered.
        
        retval.size = imageSize;
        retval.origin.y += (CONTENT_HEIGHT - imageSize.height) / 2.0;
        return retval;
    }
    
    //  Large images are constrained to the content height and
    //  proportional width.
    
    retval.size.height = CONTENT_HEIGHT;
    float           aspect = imageSize.width / imageSize.height;
    retval.size.width = CONTENT_HEIGHT * aspect;
    
    return retval;
}

- (void) startAnimation
{
    NSRect      frame = [self frame];
    frame.origin = NSZeroPoint;
    
    NSRect      imageRect = [self addedImageRect];
    
    contentRect.size = NSMakeSize(FIXED_WIDTH + imageRect.size.width + (imageRect.size.width? 3.0: 0.0), CONTENT_HEIGHT);
    contentRect.origin = NSZeroPoint;
    
    if ([controller shouldMove]) {      
        contentRect.origin = SSRandomPointForSizeWithinRect(contentRect.size, frame);
        
        velocity.x = SSRandomFloatBetween(-MAX_V_COMPONENT, MAX_V_COMPONENT);
        velocity.y = SSRandomFloatBetween(-MAX_V_COMPONENT, MAX_V_COMPONENT);
    }
    else {
        contentRect = SSCenteredRectInRect(contentRect, frame);
        velocity = NSZeroPoint;
    }
    
    [super startAnimation];
    [self resetClock];
}

- (void) stopAnimation
{
    [super stopAnimation];
    [deadline release];
    deadline = nil;
}


- (void) drawPieCenter: (NSPoint) center proportion: (float) proportion radius: (float) radius color: (NSColor *) color
{
    if (proportion <= 0.0 || proportion >= 1.0) {
        NSRect          bounds = NSMakeRect(center.x - radius, center.y - radius, 2.0 * radius, 2.0 * radius);
        NSBezierPath *  circle = [NSBezierPath bezierPathWithOvalInRect: bounds];
        
        [color set];
        [circle stroke];
        
        if (proportion <= 0.0)
            [[NSColor blackColor] set];
        [circle fill];
    }
    else {
        NSBezierPath *  emptyPart = [NSBezierPath bezierPath];
        [emptyPart moveToPoint: center];
        [emptyPart lineToPoint: NSMakePoint(center.x, center.y + radius)];
        
        float           endAngle = 90.0 + 360.0 * (1.0 - proportion);
        
        [emptyPart appendBezierPathWithArcWithCenter: center radius: radius startAngle: 90.0 endAngle: endAngle];
        [emptyPart lineToPoint: center];
        [color set];
        [emptyPart stroke];
        [[NSColor blackColor] set];
        [emptyPart fill];
        
        NSBezierPath *  filledPart = [NSBezierPath bezierPath];
        [filledPart moveToPoint: center];
        [filledPart lineToPoint: NSMakePoint(center.x, center.y + radius)];
        [filledPart appendBezierPathWithArcWithCenter: center radius: radius startAngle: 90.0 endAngle: endAngle clockwise: YES];
        [filledPart lineToPoint: center];
        [color set];
        [filledPart fill];
    }
}

- (void) fillPieImageInner: (float) inner outer: (float) outer
{
    NSPoint     pieCenter = NSMakePoint(CLOCK_RADIUS + 1.0, CLOCK_RADIUS + 1.0);
    
    [pieImage lockFocus];
    [self drawPieCenter: pieCenter
             proportion: outer 
                 radius: CLOCK_RADIUS 
                  color: [NSColor blueColor]];
    [self drawPieCenter: pieCenter
             proportion: inner
                 radius: CLOCK_RADIUS * 2.0/3.0 
                  color: [NSColor redColor]];   
    [pieImage unlockFocus];
}

- (void) drawRect: (NSRect) rect
{
    //  [super drawRect:rect];  //  Draws black background.
    [[NSColor blackColor] set];
    NSRectFill(rect);
    
    NSRect      imageRect = [self addedImageRect];
    NSImage *   addedImage = [controller addedImage];
    
    if (addedImage) {
        NSRect      sourceRect;
        sourceRect.origin = NSZeroPoint;
        sourceRect.size = [addedImage size];
        
        [addedImage drawInRect: imageRect fromRect: sourceRect operation: NSCompositeCopy fraction: 1.0];
    }
    
    [pieImage compositeToPoint: NSMakePoint(NSMaxX(imageRect) + 3.0, NSMinY(contentRect)) operation: NSCompositeCopy];
    [textImage compositeToPoint: NSMakePoint(NSMaxX(imageRect) + 3.0 + CLOCK_WIDTH,
                                            NSMinY(contentRect))
                      operation: NSCompositeCopy];
}

- (void) animateOneFrame
{
    NSTimeInterval  timeDiff = [deadline timeIntervalSinceDate: [NSDate date]];

    switch (state) {
        case kDOInitial:
            state = kDOCountdown;
            
        case kDOCountdown:
        {
            contentRect.origin.x += velocity.x;
            contentRect.origin.y += velocity.y;
            
            NSRect      frame = [self frame];
            
            if (NSMaxX(contentRect) >= NSMaxX(frame) || NSMinX(contentRect) <= NSMinX(frame)) {
                velocity.x = -velocity.x;
            }
            if (NSMaxY(contentRect) >= NSMaxY(frame) || NSMinY(contentRect) <= NSMinY(frame)) {
                velocity.y = -velocity.y;
            }
            
            if (timeDiff <= 0) {
                [self fillPieImageInner: 0.0 outer: 0.0];
                state = kDOQuitting;
            }
            else {
                if (floor(timeDiff) < secondsLeft) {
                    secondsLeft = floor(timeDiff);
                    [self fillTextImageWithSeconds: secondsLeft];
                    
                    float   minutes = floor(timeDiff / 60.0);
                    float   setMinutes = floor([controller secondsBeforeLogout] / 60.0);
                    float   seconds = floor(timeDiff - 60.0 * minutes);
                    
                    [self fillPieImageInner: minutes/setMinutes outer: seconds/60.0];
                }
                [self setNeedsDisplay: YES];
            }
        }
            break;
            
        case kDOQuitting:
            if ([self isPreview]) {
                //  Mode: preview/nontriggering
                [self resetClock];
                [self setNeedsDisplay: YES];
                state = kDOCountdown;
            }
            else {
                [self fillTextImageWithString: [NSString stringWithFormat: @"Logging out. Qutting %d applications.", [DAApplication countApplications]-1]];
                [controller quitApplications];
                [self setDeadlineForSeconds: 10];
                [self setNeedsDisplay: YES];
                state = kDOKilling;
            }
            break;

        case kDOKilling:
//          if (timeDiff <= 0 || [DAApplication countApplications] == 0) {
            if (timeDiff <= 0 || [DAApplication countApplications] != 0) {
                [self fillTextImageWithString: [NSString stringWithFormat: @"Killing %d applications.", [DAApplication countApplications]-1]];
                [self setNeedsDisplay: YES];
                [controller killApplications];
                state = kDOLogout;
            }
            break;
        case kDOLogout:
            [controller makeTouchFile];
            [controller logOut];
            state = kDODone;
            break;
        case kDODone:
            break;
    }
}

- (BOOL) hasConfigureSheet
{
    return YES;
}

- (NSWindow *) configureSheet
{
    NSBundle *      myBundle = [NSBundle bundleForClass: [self class]];
    NSDictionary *  context = [NSDictionary dictionaryWithObjectsAndKeys: controller, @"NSOwner", nil];
    
    //  [NSBundle loadNibNamed: @"DownAndOut" owner: controller];
    if ([myBundle loadNibFile: @"DownAndOut" externalNameTable: context withZone: [self zone]])
        return [controller panel];
    else
        return nil;
}

@end

---