#import "draw.h"
#import <math.h>

@implementation Graphic : Object

static int KNOB_WIDTH = 0.0;
static int KNOB_HEIGHT = 0.0;

#define MINSIZE 5.0	/* minimum size of a Graphic */

/* Object Versions */
#define NS30_VERSION 3
#define ROTATED_VERSION 4
#define CURRENT_VERSION ROTATED_VERSION

#define PI 3.1415926535

NXCursor *CrossCursor = nil;	/* global since subclassers may need it */

/* Optimization method. */

/*
 * The fastKnobFill optimization just keeps a list of black and dark gray
 * rectangles (the knobbies are made out of black and dark gray rectangles)
 * and emits them in a single NXRectFillList() which is much faster than
 * doing individual rectfills (we also save the repeated setgrays).
 */

static NXRect *blackRectList = NULL;
static int blackRectSize = 0;
static int blackRectCount = 0;
static NXRect *dkgrayRectList = NULL;
static int dkgrayRectSize = 0;
static int dkgrayRectCount = 0;

+ fastKnobFill:(const NXRect *)aRect isBlack:(BOOL)isBlack
{
    if (!aRect) return self;

    if (isBlack) {
	if (!blackRectList) {
	    blackRectSize = 16;
	    NX_ZONEMALLOC([NXApp zone], blackRectList, NXRect, blackRectSize);
	} else {
	    while (blackRectCount >= blackRectSize) blackRectSize <<= 1;
	    NX_ZONEREALLOC([NXApp zone], blackRectList, NXRect, blackRectSize);
	}
	blackRectList[blackRectCount++] = *aRect;
    } else {
	if (!dkgrayRectList) {
	    dkgrayRectSize = 16;
	    NX_ZONEMALLOC([NXApp zone], dkgrayRectList, NXRect, dkgrayRectSize);
	} else {
	    while (dkgrayRectCount >= dkgrayRectSize) dkgrayRectSize <<= 1;
	    NX_ZONEREALLOC([NXApp zone], dkgrayRectList, NXRect, dkgrayRectSize);
	}
	dkgrayRectList[dkgrayRectCount++] = *aRect;
    }

    return self;
}

+ showFastKnobFills
{
    PSsetgray(NX_BLACK);
    NXRectFillList(blackRectList, blackRectCount);
    PSsetgray(NX_DKGRAY);
    NXRectFillList(dkgrayRectList, dkgrayRectCount);
    blackRectCount = 0;
    dkgrayRectCount = 0;
    return self;
}

/* Factory methods. */

+ initialize
/*
 * This sets the class version so that we can compatibly read
 * old Graphic objects out of an archive.
 */
{
    [Graphic setVersion:CURRENT_VERSION];
    return self;
}

+ (BOOL)isEditable
/*
 * Any Graphic which can be edited should return YES from this
 * and its instances should do something in the response to the
 * edit:in: method.
 */
{
    return NO;
}

+ cursor
/*
 * Any Graphic that doesn't have a special cursor gets the default cross.
 * Since Draw has been converted to subproject in Hippo.bundle,
 * we have to find the tiff files. -- pfkeb
 */
{
    NXBundle	*bundle;
    NXImage	*image;
    NXPoint 	spot;
    char	buffer[MAXPATHLEN+1];

    if (!CrossCursor) {
        bundle = [NXBundle bundleForClass:[self class]];
        if ( [bundle getPath:buffer forResource:"cross" ofType:"tiff"] ) {
	    image = [[NXImage allocFromZone:[self zone]] initFromFile:buffer];
	    CrossCursor = [NXCursor newFromImage:image];
	    spot.x = 7.0; spot.y = 7.0;
	    [CrossCursor setHotSpot:&spot];
	}
    }

    return CrossCursor;
}

static void initClassVars()
{
    const char *value;
    NXCoord w = 2.0, h = 2.0;

    if (!KNOB_WIDTH) {
	value = NXGetDefaultValue([NXApp appName], "KnobWidth");
	if (value) w = floor(atof(value) / 2.0);
	value = NXGetDefaultValue([NXApp appName], "KnobHeight");
	if (value) h = floor(atof(value) / 2.0);
	w = MAX(w, 1.0); h = MAX(h, 1.0);
	KNOB_WIDTH = w * 2.0 + 1.0;	/* size must be odd */
	KNOB_HEIGHT = h * 2.0 + 1.0;
    }
}

/*
 * The currentGraphicIdentifier is a number that is kept unique for a given
 * Draw document by being monotonically increasing and is bumped each time a
 * new Graphic is created.  The method of the same name is used during the
 * archiving of a Draw document to write out what the number is at save-time.
 * updateCurrentGraphicIdentifer: is used at document load time to reset
 * the number to that level (if it's already higher, then we don't need to
 * bump it).
 */

static int currentGraphicIdentifier = 1;

+ (int)currentGraphicIdentifier
{
    return currentGraphicIdentifier;
}

+ updateCurrentGraphicIdentifier:(int)newMaxIdentifier
{
    if (newMaxIdentifier > currentGraphicIdentifier) currentGraphicIdentifier = newMaxIdentifier;
    return self;
}

- init
{
    [super init];
    gFlags.active = YES;
    gFlags.selected = YES;
    initClassVars();
    identifier = currentGraphicIdentifier++;
    return self;
}

- awake
{
    initClassVars();
    return [super awake];
}

/* Private C functions and macros used to implement methods in this class. */

static void drawKnobs(const NXRect *rect, int cornerMask, BOOL black)
/*
 * Draws either the knobs or their shadows (not both).
 */
{
    NXRect knob;
    NXCoord dx, dy;
    BOOL oddx, oddy;

    knob = *rect;
    dx = knob.size.width / 2.0;
    dy = knob.size.height / 2.0;
    oddx = (floor(dx) != dx);
    oddy = (floor(dy) != dy);
    knob.size.width = KNOB_WIDTH;
    knob.size.height = KNOB_HEIGHT;
    knob.origin.x -= ((KNOB_WIDTH - 1.0) / 2.0);
    knob.origin.y -= ((KNOB_HEIGHT - 1.0) / 2.0);

    if (cornerMask & LOWER_LEFT_MASK) [Graphic fastKnobFill:&knob isBlack:black];
    knob.origin.y += dy;
    if (oddy) knob.origin.y -= 0.5;
    if (cornerMask & LEFT_SIDE_MASK) [Graphic fastKnobFill:&knob isBlack:black];
    knob.origin.y += dy;
    if (oddy) knob.origin.y += 0.5;
    if (cornerMask & UPPER_LEFT_MASK) [Graphic fastKnobFill:&knob isBlack:black];
    knob.origin.x += dx;
    if (oddx) knob.origin.x -= 0.5;
    if (cornerMask & TOP_SIDE_MASK) [Graphic fastKnobFill:&knob isBlack:black];
    knob.origin.x += dx;
    if (oddx) knob.origin.x += 0.5;
    if (cornerMask & UPPER_RIGHT_MASK) [Graphic fastKnobFill:&knob isBlack:black];
    knob.origin.y -= dy;
    if (oddy) knob.origin.y -= 0.5;
    if (cornerMask & RIGHT_SIDE_MASK) [Graphic fastKnobFill:&knob isBlack:black];
    knob.origin.y -= dy;
    if (oddy) knob.origin.y += 0.5;
    if (cornerMask & LOWER_RIGHT_MASK) [Graphic fastKnobFill:&knob isBlack:black];
    knob.origin.x -= dx;
    if (oddx) knob.origin.x += 0.5;
    if (cornerMask & BOTTOM_SIDE_MASK) [Graphic fastKnobFill:&knob isBlack:black];
}

static void unrotRect( NXRect *u, NXRect *b, NXPoint *p0, int angle );

/* Private methods sometimes overridden by subclassers */

- setGraphicsState
/*
 * Emits a gsave, must be balanced by grestore.
 */
{
    PSSetParameters(gFlags.linecap, gFlags.linejoin, linewidth);
    return self;
}

- setLineColor
{
    if (lineColor) {
	NXSetColor(*lineColor);
    } else {
	NXSetColor(NX_COLORBLACK);
    }
    return self;
}

- setFillColor
{
    if (fillColor) NXSetColor(*fillColor);
    return self;
}

- (int)cornerMask
/*
 * Returns a mask of the corners which should have a knobby in them.
 */
{
    return ALL_CORNERS;
}

/* Data link methods -- see Links.rtf and gvLinks.m for more info */

/*
 * Most Graphics aren't linked (i.e. their visual display is
 * not determined by some other document).  See Image and
 * TextGraphic for examples of Graphics that sometimes do.
 */

- setLink:(NXDataLink *)aLink
{
    return nil;
}

- (NXDataLink *)link
{
    return nil;
}

- (Graphic *)graphicLinkedBy:(NXDataLink *)aLink
/*
 * The reason we implement this method (instead of just relying on
 * saying if ([graphic link] == aLink)) is for the sake of Group
 * objects which may have a linked Graphic embedded in them.
 */
{
    NXDataLink *link = [self link];

    if (link) {
	if (!aLink) {	/* !aLink means any link */
	    return ([link disposition] != NX_LinkBroken) ? self : nil;
	} else {
	    return (aLink == link) ? self : nil;
	}
    }

    return nil;
}

- reviveLink:(NXDataLinkManager *)linkManager
/*
 * We never archive link information (but, of course, the unique identifer
 * is always archived with a Graphic).  Thus, when our document is reloaded,
 * we just asked the NXDataLinkManager which NXDataLink object is associated
 * with the NXSelection which represents this Graphic.
 */
{
    if (![self link]) [self setLink:[linkManager findDestinationLinkWithSelection:[self selection]]];
    return self;
}

- (NXSelection *)selection
/*
 * Just creates an NXSelection "bag o' bits" with our unique identifier in it.
 */
{
    char buffer[200];
    sprintf(buffer, "%d %d", ByGraphic, [self identifier]);
    return [[NXSelection allocFromZone:[self zone]] initWithDescription:buffer length:strlen(buffer)+1];
}

- (BOOL)mightBeLinked
/*
 * This is set whenever our Graphic has a link set in it.
 * It is never cleared.
 * We use it during copy/paste to determine whether we have
 * to check with the data link manager to possibly reestablish
 * a link to this object.
 */
{
    return gFlags.mightBeLinked;
}

/* Notification messages */

/*
 * These methods are sent when a Graphic is added to or removed
 * from a GraphicView (respectively).  Currently we only use them
 * to break and reestablish links if any.
 */

- wasAddedTo:(GraphicView *)sender
{
    NXDataLink *link;
    NXDataLinkManager *linkManager;

    if ((linkManager = [sender linkManager]) && (link = [self link])) {
	if ([link disposition] == NX_LinkBroken) {
	    [linkManager addLink:link at:[self selection]];
	}
    }

    return self;
}

- wasRemovedFrom:(GraphicView *)sender
{
    [[self link] break];
    return self;
}

/* Methods for uniquely identifying a Graphic. */

- resetIdentifier
{
    identifier = currentGraphicIdentifier++;
    return self;
}

- writeIdentifierTo:(char *)buffer
/*
 * This method is necessary to support a Group which never writes out
 * its own identifier, but, instead has its components each write out
 * their own identifier.
 */
{
    sprintf(buffer, "%d", identifier);
    return self;
}

- (int)identifier
{
    return identifier;
}

- (Graphic *)graphicIdentifiedBy:(int)anIdentifier
{
    return (identifier == anIdentifier) ? self : nil;
}

/* Event handling */

- (BOOL)handleEvent:(NXEvent *)event at:(const NXPoint *)p inView:(View *)view
/*
 * Currently the only Graphic's that handle events are Image Graphic's that
 * are linked to something else (they follow the link on double-click and
 * the track the mouse for link buttons, for example).  This method should
 * return YES only if it tracked the mouse until it went up.
 */
{
    return NO;
}

/* Number of Graphics this Graphic represents (always 1 for non-Group). */

- (int)graphicCount
/*
 * This is really only here to support Groups.  It is used by the
 * Object Link stuff purely to know how much space will be needed to
 * create an NXSelection with the unique identifiers of all the objects
 * in the selection.
 */
{
    return 1;
}

/* Public routines mostly called by GraphicView's. */

- (const char *)title
{
    return NXLoadLocalStringFromTableInBundle(NULL, nil, [self name], NULL);
}

- (BOOL)isSelected
{
    return gFlags.selected;
}

- (BOOL)isActive
{
    return gFlags.active;
}

- (BOOL)isLocked
{
    return gFlags.locked;
}

- select
{
    gFlags.selected = YES;
    return self;
}

- deselect
{
    gFlags.selected = NO;
    return self;
}

- activate
/*
 * Activation is used to *temporarily* take a Graphic out of the GraphicView.
 */
{
    gFlags.active = YES;
    return self;
}

- deactivate
{
    gFlags.active = NO;
    return self;
}

- lock
/*
 * A locked graphic cannot be selected, resized or moved.
 */
{
    gFlags.locked = YES;
    return self;
}

- unlock
{
    gFlags.locked = NO;
    return self;
}

/* See TextGraphic for more info about form entries. */

- (BOOL)isFormEntry
{
    return NO;
}

- setFormEntry:(int)flag
{
    return self;
}

- (BOOL)hasFormEntries
{
    return NO;
}

- (BOOL)writeFormEntryToStream:(NXStream *)stream
{
    return NO;
}

/* See Group and Image for more info about cacheability. */

- setCacheable:(BOOL)flag
{
    return self;
}

- (BOOL)isCacheable
{
    return YES;
}

/* Getting and setting the bounds. */

- getBounds:(NXRect *)theRect
{
    *theRect = bounds;
    return self;
}

- setBounds:(const NXRect *)aRect
{
    bounds = *aRect;
    return self;
}

- (NXRect *)getExtendedBounds:(NXRect *)theRect
/*
 * Returns, by reference, the rectangle which encloses the Graphic
 * AND ITS KNOBBIES and its increased line width (if appropriate).
 */
{
    if (bounds.size.width < 0.0) {
	theRect->origin.x = bounds.origin.x + bounds.size.width;
	theRect->size.width = - bounds.size.width;
    } else {
	theRect->origin.x = bounds.origin.x;
	theRect->size.width = bounds.size.width;
    }
    if (bounds.size.height < 0.0) {
	theRect->origin.y = bounds.origin.y + bounds.size.height;
	theRect->size.height = - bounds.size.height;
    } else {
	theRect->origin.y = bounds.origin.y;
	theRect->size.height = bounds.size.height;
    }

    theRect->size.width = MAX(1.0, theRect->size.width);
    theRect->size.height = MAX(1.0, theRect->size.height);

    NXInsetRect(theRect, - ((KNOB_WIDTH - 1.0) + linewidth + 1.0),
			 - ((KNOB_HEIGHT - 1.0) + linewidth + 1.0));

    if (gFlags.arrow) {
	if (linewidth) {
	    NXInsetRect(theRect, - linewidth * 2.5, - linewidth * 2.5);
	} else {
	    NXInsetRect(theRect, - 13.0, - 13.0);
	}
    }

    NXIntegralRect(theRect);    
    return theRect;
}

- (int)knobHit:(const NXPoint *)p
/*
 * Returns 0 if point is in bounds, and Graphic isOpaque, and no knobHit.
 * Returns -1 if outside bounds or not opaque or not active.
 * Returns corner number if there is a hit on a corner.
 * We have to be careful when the bounds are off an odd size since the
 * knobs on the sides are one pixel larger.
 */
{
    NXRect eb;
    NXRect knob;
    NXCoord dx, dy;
    BOOL oddx, oddy;
    int cornerMask = [self cornerMask];

    [self getExtendedBounds:&eb];

    if (!gFlags.active) {
	return -1;
    } else if (!gFlags.selected) {
        return (NXMouseInRect(p, &bounds, NO) && [self isOpaque]) ? 0 : -1;
    } else {
        if (!NXMouseInRect(p, &eb, NO)) return -1;
    }

    knob = bounds;
    dx = knob.size.width / 2.0;
    dy = knob.size.height / 2.0;
    oddx = (floor(dx) != dx);
    oddy = (floor(dy) != dy);
    knob.size.width = KNOB_WIDTH;
    knob.size.height = KNOB_HEIGHT;
    knob.origin.x -= ((KNOB_WIDTH - 1.0) / 2.0);
    knob.origin.y -= ((KNOB_HEIGHT - 1.0) / 2.0);

    if ((cornerMask & LOWER_LEFT_MASK) && NXMouseInRect(p, &knob, NO))
	return(LOWER_LEFT);
    knob.origin.y += dy;
    if (oddy) knob.origin.y -= 0.5;
    if ((cornerMask & LEFT_SIDE_MASK) && NXMouseInRect(p, &knob, NO))
	return(LEFT_SIDE);
    knob.origin.y += dy;
    if (oddy) knob.origin.y += 0.5;
    if ((cornerMask & UPPER_LEFT_MASK) && NXMouseInRect(p, &knob, NO))
	return(UPPER_LEFT);
    knob.origin.x += dx;
    if (oddx) knob.origin.x -= 0.5;
    if ((cornerMask & TOP_SIDE_MASK) && NXMouseInRect(p, &knob, NO))
	return(TOP_SIDE);
    knob.origin.x += dx;
    if (oddx) knob.origin.x += 0.5;
    if ((cornerMask & UPPER_RIGHT_MASK) && NXMouseInRect(p, &knob, NO))
	return(UPPER_RIGHT);
    knob.origin.y -= dy;
    if (oddy) knob.origin.y -= 0.5;
    if ((cornerMask & RIGHT_SIDE_MASK) && NXMouseInRect(p, &knob, NO))
	return(RIGHT_SIDE);
    knob.origin.y -= dy;
    if (oddy) knob.origin.y += 0.5;
    if ((cornerMask & LOWER_RIGHT_MASK) && NXMouseInRect(p, &knob, NO))
	return(LOWER_RIGHT);
    knob.origin.x -= dx;
    if (oddx) knob.origin.x += 0.5;
    if ((cornerMask & BOTTOM_SIDE_MASK) && NXMouseInRect(p, &knob, NO))
	return(BOTTOM_SIDE);

    return NXMouseInRect(p, &bounds, NO) ? ([self isOpaque] ? 0 : -1) : -1;
}

/* This method is analogous to display (not drawSelf::) in View. */

- draw:(const NXRect *)rect
/*
 * Draws the graphic inside rect.  If rect is NULL, then it draws the
 * entire Graphic.  If the Graphic is not intersected by rect, then it
 * is not drawn at all.  If the Graphic is selected, it is drawn with
 * its knobbies.  This method is not intended to be overridden.  It
 * calls the overrideable method "draw" which doesn't have to worry
 * about drawing the knobbies.
 *
 * Note the showFastKnobFills optimization here.  If this Graphic is
 * opaque then there is a possibility that it might obscure knobbies
 * of Graphics underneath it, so we must emit the cached rectfills
 * before drawing this Graphic.
 */
{
    NXRect              r;
    NXRect boundSave;

    [self getExtendedBounds:&r];
    if (gFlags.active && (!rect || NXIntersectsRect(rect, &r))) {
	if ([self isOpaque])
	    [Graphic showFastKnobFills];
	[self setGraphicsState];/* does a gsave */
 	if (rotAngle != 0.0) 
	{
	    boundSave = bounds;
	    unrotRect( &bounds, &boundSave, &unrotOrigin, rotAngle);
	    PStranslate(bounds.origin.x, bounds.origin.y);
	    PSrotate(rotAngle);
	    PStranslate(-bounds.origin.x, -bounds.origin.y);
	}
	[self draw];
	if (rotAngle != 0.0) bounds = boundSave;
	PSgrestore();		/* so we need a grestore here */
	if (NXDrawingStatus == NX_DRAWING) {
	    if (gFlags.selected) {
		r.origin.x = floor(bounds.origin.x);
		r.origin.y = floor(bounds.origin.y);
		r.size.width = floor(bounds.origin.x + bounds.size.width 
				     + 0.99) - r.origin.x;
		r.size.height = floor(bounds.origin.y + bounds.size.height 
		                      + 0.99) - r.origin.y;
		r.origin.x += 1.0;
		r.origin.y -= 1.0;
		drawKnobs(&r,[self cornerMask], YES);	/* shadows */
		r.origin.x = floor(bounds.origin.x);
		r.origin.y = floor(bounds.origin.y);
		r.size.width = floor(bounds.origin.x + bounds.size.width 
		                     + 0.99) - r.origin.x;
		r.size.height = floor(bounds.origin.y + bounds.size.height 
		                      + 0.99) - r.origin.y;
		drawKnobs(&r,[self cornerMask], NO);	/* knobs */
	    }
	}
	
	return self;
    }
    return nil;
}
/*
 * Returns whether this Graphic can emit, all by itself, fully
 * encapsulated PostScript (or fully conforming TIFF) representing
 * itself.  This is an optimization for copy/paste.
 */

- (BOOL)canEmitEPS
{
    return NO;
}

- (BOOL)canEmitTIFF
{
    return NO;
}

/* Sizing, aligning and moving. */

- moveLeftEdgeTo:(const NXCoord *)x
{
    bounds.origin.x = *x;
    return self;
}

- moveRightEdgeTo:(const NXCoord *)x
{
    bounds.origin.x = *x - bounds.size.width;
    return self;
}

- moveTopEdgeTo:(const NXCoord *)y
{
    bounds.origin.y = *y - bounds.size.height;
    return self;
}

- moveBottomEdgeTo:(const NXCoord *)y
{
    bounds.origin.y = *y;
    return self;
}

- moveHorizontalCenterTo:(const NXCoord *)x
{
    bounds.origin.x = *x - floor(bounds.size.width / 2.0);
    return self;
}

- moveVerticalCenterTo:(const NXCoord *)y
{
    bounds.origin.y = *y - floor(bounds.size.height / 2.0);
    return self;
}

- (NXCoord)baseline
{
    return 0.0;
}

- moveBaselineTo:(const NXCoord *)y
{
    return self;
}

- moveBy:(const NXPoint *)offset
{
    bounds.origin.x += floor(offset->x);
    bounds.origin.y += floor(offset->y);
    return self;
}

- moveTo:(const NXPoint *)p
{
    bounds.origin.x = floor(p->x);
    bounds.origin.y = floor(p->y);
    return self;
}

- centerAt:(const NXPoint *)p
{
    bounds.origin.x = floor(p->x - bounds.size.width / 2.0);
    bounds.origin.y = floor(p->y - bounds.size.height / 2.0);
    return self;
}

- sizeTo:(const NXSize *)size
{
    bounds.size.width = floor(size->width);
    bounds.size.height = floor(size->height);
    return self;
}

- sizeToNaturalAspectRatio
{
    return [self constrainCorner:UPPER_RIGHT toAspectRatio:[self naturalAspectRatio]];
}

- sizeToGrid:(GraphicView *)graphicView
{
    NXPoint p;

    [graphicView grid:&bounds.origin];
    p.x = bounds.origin.x + bounds.size.width;
    p.y = bounds.origin.y + bounds.size.height;
    [graphicView grid:&p];
    bounds.size.width = p.x - bounds.origin.x;
    bounds.size.height = p.y - bounds.origin.y;

    return self;
}

- alignToGrid:(GraphicView *)graphicView
{
    [graphicView grid:&bounds.origin];
    return self;
}

/* don't call this function with b == u */
static void unrotRect( NXRect *u, NXRect *b, NXPoint *p0, int angle )
{
    double a = angle * PI / 180.0;
    
    u->origin.x = p0->x * b->size.width;
    u->origin.y = p0->y * b->size.height;
    if (angle == 0 || angle == 180 || angle == -180)
    {
    	u->size.width = b->size.width;
	u->size.height = b->size.height;
    }
    else if (angle == 90 || angle == -90)
    {
    	u->size.width = b->size.height;
	u->size.height = b->size.width;
    }
    else if (angle > 0 && angle < 90) 
    {
    	u->size.width = (b->size.width - u->origin.x)/cos(a);
	u->size.height = u->origin.x / sin(a);
    }
    else if (angle > 90 && angle < 180) 
    {
    	u->size.width = (b->size.height - u->origin.y)/sin(a);
	u->size.height = -u->origin.y / cos(a);
    }
    else if (angle > -90 && angle < 0) 
    {
	u->size.width = -u->origin.y / sin(a);
    	u->size.height = (b->size.height - u->origin.y)/cos(a);
    }
    else
    {
	u->size.width = -u->origin.x / cos(a);
    	u->size.height = (-b->size.width + u->origin.x)/sin(a);
    }
    u->origin.x += b->origin.x;
    u->origin.y += b->origin.y;
}

- rotateTo:(const int *)angle
{
    NXRect temp;
    int a;
    
    if (*angle == rotAngle) return self;

    /*
     * make sure angle is in the useful range
     */
    a = *angle;
    while (a > 180) a -= 360;
    while (a < -180) a += 360;
    
    if (rotAngle == 0)
    	temp = bounds;
    else
	unrotRect( &temp, &bounds, &unrotOrigin, rotAngle);
    	
    rotAngle = a;
    if (rotAngle == 0)
    	bounds = temp;
    else
    {
        float ang = rotAngle * PI/180.0;
    	float x2 = temp.size.width * cos(ang);
	float y2 = temp.size.width * sin(ang);
	float x3 = x2 - temp.size.height * sin(ang);
	float y3 = y2 + temp.size.height * cos(ang);
	float x4 = - temp.size.height * sin(ang);
	float y4 = temp.size.height * cos(ang);
	bounds.origin.x = MIN(0.0, MIN(x2, MIN(x3, x4)));
	bounds.origin.y = MIN(0.0, MIN(y2, MIN(y3, y4)));
	bounds.size.width = MAX(0.0, MAX(x2, MAX(x3, x4))) - 
				bounds.origin.x;
	bounds.size.height = MAX(0.0, MAX(y2, MAX(y3, y4))) - 
				bounds.origin.y;
	bounds.origin.x += temp.origin.x;
	bounds.origin.y += temp.origin.y;
    }
    unrotOrigin.x = (temp.origin.x - bounds.origin.x)
    		/ bounds.size.width;
    unrotOrigin.y = (temp.origin.y - bounds.origin.y)
    		/ bounds.size.height;

    return self;
}

- rotateBy:(const int *) angle
{
    int t = rotAngle+*angle;
    return [self rotateTo: &t];
}

- (int) rotation
{
	return rotAngle;
}

/* Compatibility method for old PSGraphic and Tiff classes. */

- replaceWithImage
{
    return self;
}

/* Public routines. */

- setLineWidth:(const float *)value
/*
 * This is called with value indirected so that it can be called via
 * a perform:with: method.  Kind of screwy, but ...
 */
{
    if (value) linewidth = *value;
    return self;
}

- (float)lineWidth
{
    return linewidth;
}

- setLineColor:(const NXColor *)color
{
    if (color) {
	if (NXEqualColor(*color, NX_COLORBLACK)) {
	    NX_FREE(lineColor);
	    lineColor = NULL;
	    gFlags.nooutline = NO;
	} else {
	    if (!lineColor) NX_ZONEMALLOC([self zone], lineColor, NXColor, 1);
	    *lineColor = *color;
	    gFlags.nooutline = NO;
	}
    }
    return self;
}

- (NXColor)lineColor
{
    return lineColor ? *lineColor : NX_COLORBLACK;
}

- setFillColor:(const NXColor *)color
{
    if (color) {
	if (!fillColor) NX_ZONEMALLOC([self zone], fillColor, NXColor, 1);
	*fillColor = *color;
	if (![self fill]) [self setFill:FILL_NZWR];
    }
    return self;
}

- (NXColor)fillColor
{
    return fillColor ? *fillColor : NX_COLORWHITE;
}

- (Graphic *)colorAcceptorAt:(const NXPoint *)point
/*
 * This method supports dragging and dropping colors on Graphics.
 * Whatever object is returned from this may well be sent
 * setFillColor: if the color actually gets dropped on it.
 * See gvDrag.m's acceptsColor:atPoint: method.
 */
{
    return nil;
}

- changeFont:sender
{
    return self;
}

- font
{
    return nil;
}

- setGray:(const float *)value
/*
 * This is called with value indirected so that it can be called via
 * a perform:with: method.  Kind of screwy, but ...
 * Now that we have converted to using NXColor's, we'll interpret this
 * method as a request to set the lineColor.
 */
{
    NXColor color;

    if (value) {
	color = NXConvertGrayToColor(*value);
	[self setLineColor:&color];
    }

    return self;
}

- (float)gray
{
    float retval;

    if (lineColor) {
	NXConvertColorToGray(*lineColor, &retval);
    } else {
	retval = NX_BLACK;
    }

    return retval;
}

- setFill:(int)mode
{
    switch (mode) {
	case FILL_NONE:	gFlags.eofill = gFlags.fill = NO; break;
	case FILL_EO:	gFlags.eofill = YES; gFlags.fill = NO; break;
	case FILL_NZWR:	gFlags.eofill = NO; gFlags.fill = YES; break;
    }
    return self;
}

- (int)fill
{
    if (gFlags.eofill) {
	return FILL_EO;
    } else if (gFlags.fill) {
	return FILL_NZWR;
    } else {
	return FILL_NONE;
    }
}

- setOutlined:(BOOL)outlinedFlag
{
    gFlags.nooutline = outlinedFlag ? NO : YES;
    return self;
}

- (BOOL)isOutlined
{
    return gFlags.nooutline ? NO : YES;
}

- setLineCap:(int)capValue
{
    if (capValue >= 0 && capValue <= 2) {
	gFlags.linecap = capValue;
    }
    return self;
}

- (int)lineCap
{
    return gFlags.linecap;
}

- setLineArrow:(int)arrowValue
{
    if (arrowValue >= 0 && arrowValue <= 3) {
	gFlags.arrow = arrowValue;
    }
    return self;
}

- (int)lineArrow
{
    return gFlags.arrow;
}

- setLineJoin:(int)joinValue
{
    if (joinValue >= 0 && joinValue <= 2) {
	gFlags.linejoin = joinValue;
    }
    return self;
}

- (int)lineJoin
{
    return gFlags.linejoin;
}

/* Archiver-related methods. */

- write:(NXTypedStream *)stream
/*
 * Since a typical document has many Graphics, we want to try and make
 * the archived document small, so we don't write out the linewidth and
 * gray values if they are the most common 0 and NX_BLACK.  To accomplish
 * this, we note that we haven't written them out by setting the
 * bits in gFlags.
 */
{
    [super write:stream];
    gFlags.linewidthSet = (linewidth != 0.0);
    gFlags.lineColorSet = lineColor ? YES : NO;
    gFlags.fillColorSet = fillColor ? YES : NO;
    NXWriteTypes(stream, "ffffii", &bounds.origin.x, &bounds.origin.y,
	&bounds.size.width, &bounds.size.height, &gFlags, &identifier);
    if (gFlags.linewidthSet) NXWriteTypes(stream, "f", &linewidth);
    if (gFlags.lineColorSet) NXWriteColor(stream, *lineColor);
    if (gFlags.fillColorSet) NXWriteColor(stream, *fillColor);
    
    // new with ROTATED_VERSION 
    NXWriteTypes(stream, "f", &rotAngle);
    NXWriteTypes(stream, "ff", &unrotOrigin.x, &unrotOrigin.y );
    
    return self;
}

- read:(NXTypedStream *)stream
{
    int version;
    float gray = NX_BLACK;

    [super read:stream];
    version = NXTypedStreamClassVersion(stream, "Graphic");
    if (version > 2) {
	NXReadTypes(stream, "ffffii", &bounds.origin.x, &bounds.origin.y,
	    &bounds.size.width, &bounds.size.height, &gFlags, &identifier);
    } else if (version > 1) {
	NXReadTypes(stream, "ffffsi", &bounds.origin.x, &bounds.origin.y,
	    &bounds.size.width, &bounds.size.height, &gFlags, &identifier);
    } else {
	NXReadTypes(stream, "ffffs", &bounds.origin.x, &bounds.origin.y,
	    &bounds.size.width, &bounds.size.height, &gFlags);
	identifier = currentGraphicIdentifier++;
    }
    if (version > 1 && identifier >= currentGraphicIdentifier) currentGraphicIdentifier = identifier+1;
    if (gFlags.linewidthSet) NXReadTypes(stream, "f", &linewidth);
    if (version < 1) {
	if (gFlags.lineColorSet) NXReadTypes(stream, "f", &gray);
	if (gFlags.fillColorSet && (gFlags.eofill | gFlags.fill)) {
	    NX_ZONEMALLOC([self zone], lineColor, NXColor, 1);
	    *lineColor = NXConvertGrayToColor(NX_BLACK);
	    NX_ZONEMALLOC([self zone], fillColor, NXColor, 1);
	    *fillColor = NXConvertGrayToColor(gray);
	} else if (gFlags.eofill | gFlags.fill) {
	    NX_ZONEMALLOC([self zone], fillColor, NXColor, 1);
	    *fillColor = NXConvertGrayToColor(gray);
	    [self setOutlined:NO];
	} else {
	    NX_ZONEMALLOC([self zone], lineColor, NXColor, 1);
	    *lineColor = NXConvertGrayToColor(gray);
	}
    } else {
	if (gFlags.lineColorSet) {
	    NX_ZONEMALLOC([self zone], lineColor, NXColor, 1);
	    *lineColor = NXReadColor(stream);
	    if (NXEqualColor(*lineColor, NX_COLORCLEAR)) {
		free(lineColor);
		lineColor = NULL;
		[self setOutlined:NO];
	    }
	}
	if (gFlags.fillColorSet) {
	    NX_ZONEMALLOC([self zone], fillColor, NXColor, 1);
	    *fillColor = NXReadColor(stream);
	    if (NXEqualColor(*fillColor, NX_COLORCLEAR) || (NXAlphaComponent(*fillColor) == 0.0)) {
		free(fillColor);
		fillColor = NULL;
		[self setFill:FILL_NONE];
//	    } else if (!gFlags.eofill && !gFlags.fill) {	// why did I add this code here?
//		gFlags.fill = YES;
	    }
	}
    }

    if (version >= ROTATED_VERSION)
    {
    	NXReadTypes(stream, "f", &rotAngle);
	NXReadTypes(stream, "ff", &unrotOrigin.x, &unrotOrigin.y );
    }

    return self;
}

/* Routines which may need subclassing for different Graphic types. */

- (BOOL)constrainByDefault
{
    return NO;
}

- constrainCorner:(int)corner toAspectRatio:(float)aspect
/*
 * Modifies the bounds rectangle by moving the specified corner so that
 * the Graphic maintains the specified aspect ratio.  This is used during
 * constrained resizing.  Can be overridden if the aspect ratio is not
 * sufficient to constrain resizing.
 */
{
    int newcorner;
    float actualAspect;

    if (!bounds.size.height || !bounds.size.width || !aspect) return self;
    actualAspect = bounds.size.width / bounds.size.height;
    if (actualAspect == aspect) return self;

    switch (corner) {
    case LEFT_SIDE:
	bounds.origin.x -= bounds.size.height * aspect-bounds.size.width;
    case RIGHT_SIDE:
	bounds.size.width = bounds.size.height * aspect;
	if (bounds.size.width) NXIntegralRect(&bounds);
	return self;
    case BOTTOM_SIDE:
	bounds.origin.y -= bounds.size.width / aspect-bounds.size.height;
    case TOP_SIDE:
	bounds.size.height = bounds.size.width / aspect;
	if (bounds.size.height) NXIntegralRect(&bounds);
	return self;
    case LOWER_LEFT:
	corner = 0;
    case 0:
    case UPPER_RIGHT:
    case UPPER_LEFT:
    case LOWER_RIGHT:
	if (actualAspect > aspect) {
	    newcorner = ((corner|KNOB_DY_ONCE)&(~(KNOB_DY_TWICE)));
	} else {
	    newcorner = ((corner|KNOB_DX_ONCE)&(~(KNOB_DX_TWICE)));
	}
	return [self constrainCorner:newcorner toAspectRatio:aspect];
    default:
	return self;
    }
}

#define RESIZE_MASK (NX_MOUSEUPMASK|NX_MOUSEDRAGGEDMASK|NX_TIMERMASK)

- resize:(NXEvent *)event by:(int)corner in:(GraphicView *)view
/*
 * Resizes the graphic by the specified corner.  If corner == CREATE,
 * then it is resized by the UPPER_RIGHT corner, but the initial size
 * is reset to 1 by 1.
 */
{
    NXPoint p, last;
    float aspect = 0.0;
    Window *window = [view window];
    BOOL constrain, canScroll;
    DrawStatusType oldDrawStatus;
    NXTrackingTimer *timer = NULL;
    NXRect eb, starteb, oldeb, visibleRect;

    if (!gFlags.active || !gFlags.selected || !corner) return self;

    constrain = ((event->flags & NX_ALTERNATEMASK) &&
	((bounds.size.width && bounds.size.height) || corner == CREATE));
    if ([self constrainByDefault]) constrain = !constrain;
    if (constrain) aspect = bounds.size.width / bounds.size.height;
    if (corner == CREATE) {
	bounds.size.width = bounds.size.height = 1.0;
	corner = UPPER_RIGHT;
    }

    gFlags.selected = NO;

    [self getExtendedBounds:&eb];
    [view lockFocus];
    gFlags.active = NO;
    [view cache:&eb andUpdateLinks:NO];
    gFlags.active = YES;
    starteb = eb;
    [self draw:NULL];
    [window flushWindow];

    oldDrawStatus = DrawStatus;
    DrawStatus = Resizing;

    [view getVisibleRect:&visibleRect];
    canScroll = !NXEqualRect(&visibleRect, &bounds);
    if (canScroll && !timer) timer = NXBeginTimer(NULL, 0.1, 0.1);

    while (event->type != NX_MOUSEUP) {
	p = event->location;
	event = [NXApp getNextEvent:RESIZE_MASK];
	if (event->type == NX_TIMER) event->location = p;
	p = event->location;
	[view convertPoint:&p fromView:nil];
	[view grid:&p];
	if (p.x != last.x || p.y != last.y) {
	    corner = [self moveCorner:corner to:&p constrain:constrain];
	    if (constrain) [self constrainCorner:corner toAspectRatio:aspect];
	    oldeb = eb;
	    [self getExtendedBounds:&eb];
	    [window disableFlushWindow];
	    [view drawSelf:&oldeb :1];
	    if (canScroll) {
		[view scrollPointToVisible:&p]; // actually we want to keep the "edges" of the
						// Graphic being resized that were visible when
						// the resize started visible throughout the
						// resizing time (this will be difficult if those
						// edges flip from being the left edge to the
						// right edge in the middle of the resize!).
	    }
	    [self draw:NULL];
	    [view tryToPerform:@selector(updateRulers:) with:(void *)&bounds];
	    [window reenableFlushWindow];
	    [window flushWindow];
	    last = p;
	    NXPing();
	}
    }

    if (canScroll && timer) {
	NXEndTimer(timer);
	timer = NULL;
    }

    gFlags.selected = YES;
    DrawStatus = oldDrawStatus;

    [view cache:&eb andUpdateLinks:NO];	// redraw after resizing a Graphic
    NXUnionRect(&eb, &starteb);
    [view updateTrackedLinks:&starteb];
    [view tryToPerform:@selector(updateRulers:) with:nil];
    [window flushWindow];
    [view unlockFocus];

    return self;
}

- (BOOL)create:(NXEvent *)event in:(GraphicView *)view
/*
 * This method rarely needs to be subclassed.
 * It sets up an initial bounds, and calls resize:by:in:.
 */
{
    BOOL valid;
    NXCoord gridSpacing;

    bounds.origin = event->location;
    [view convertPoint:&bounds.origin fromView:nil];
    [view grid:&bounds.origin];

    gridSpacing = (NXCoord)[view gridSpacing];
    bounds.size.height = gridSpacing;
    bounds.size.width = gridSpacing * [self naturalAspectRatio];

    [self resize:event by:CREATE in:view];

    valid = [self isValid];

    if (valid) {
	gFlags.selected = YES;
	gFlags.active = YES;
    } else {
	gFlags.selected = NO;
	gFlags.active = NO;
	[view display];
    }

    return valid;
}

- (BOOL)hit:(const NXPoint *)p
{
    return (!gFlags.locked && gFlags.active && NXMouseInRect(p, &bounds, NO));
}

- (BOOL)isOpaque
{
    return [self fill] ? YES : NO;
}

- (BOOL)isValid
/*
 * Called after a Graphic is created to see if it is valid (this usually
 * means "is it big enough?").
 */
{
    return (bounds.size.width > MINSIZE && bounds.size.height > MINSIZE);
}

- (float)naturalAspectRatio
/*
 * A natural aspect ratio of zero means it doesn't have a natural aspect ratio.
 */
{
    return 0.0;
}

- (int)moveCorner:(int)corner to:(const NXPoint *)p constrain:(BOOL)flag
/*
 * Moves the specified corner to the specified point.
 * Returns the position of the corner after it was moved.
 */
{
    int newcorner = corner;

    if ((corner & KNOB_DX_ONCE) && (corner & KNOB_DX_TWICE)) {
	bounds.size.width += p->x - (bounds.origin.x + bounds.size.width);
	if (bounds.size.width <= 0.0) {
	    newcorner &= ~ (KNOB_DX_ONCE | KNOB_DX_TWICE);
	    bounds.origin.x += bounds.size.width;
	    bounds.size.width = - bounds.size.width;
	}
    } else if (!(corner & KNOB_DX_ONCE)) {
	bounds.size.width += bounds.origin.x - p->x;
	bounds.origin.x = p->x;
	if (bounds.size.width <= 0.0) {
	    newcorner |= KNOB_DX_ONCE | KNOB_DX_TWICE;
	    bounds.origin.x += bounds.size.width;
	    bounds.size.width = - bounds.size.width;
	}
    }

    if ((corner & KNOB_DY_ONCE) && (corner & KNOB_DY_TWICE)) {
	bounds.size.height += p->y - (bounds.origin.y + bounds.size.height);
	if (bounds.size.height <= 0.0) {
	    newcorner &= ~ (KNOB_DY_ONCE | KNOB_DY_TWICE);
	    bounds.origin.y += bounds.size.height;
	    bounds.size.height = - bounds.size.height;
	}
    } else if (!(corner & KNOB_DY_ONCE)) {
	bounds.size.height += bounds.origin.y - p->y;
	bounds.origin.y = p->y;
	if (bounds.size.height <= 0.0) {
	    newcorner |= KNOB_DY_ONCE | KNOB_DY_TWICE;
	    bounds.origin.y += bounds.size.height;
	    bounds.size.height = - bounds.size.height;
	}
    }

    if (newcorner != LOWER_LEFT) newcorner &= 0xf;
    if (!newcorner) newcorner = LOWER_LEFT;

    return newcorner;
}

- unitDraw
/*
 * If a Graphic just wants to draw itself in the bounding box of
 * {{0.0,0.0},{1.0,1.0}}, it can simply override this method.
 * Everything else will work fine.
 */
{
    return self;
}

- draw
/*
 * Almost all Graphics need to override this method.
 * It does the Graphic-specific drawing.
 * By default, it scales the coordinate system and calls unitDraw.
 */
{
    if (bounds.size.width >= 1.0 && bounds.size.height >= 1.0) {
	PStranslate(bounds.origin.x, bounds.origin.y);
	PSscale(bounds.size.width, bounds.size.height);
	[self unitDraw];
    }
    return self;
}

- (BOOL)edit:(NXEvent *)event in:(View *)view
/*
 * Any Graphic which has editable text should override this method
 * to edit that text.  TextGraphic is an example.
 */
{
    return NO;
}

/* Methods added to support Hippo drawing */

- forward:(SEL)aSelector :(marg_list)argFrame
{
    return self;
}
@end
