![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to Graphic.m CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [NeXTSTEP 3.3 examples] / Examples / AppKit / Draw|
Return to Graphic.m CVS log | Up to [NeXTSTEP 3.3 examples] / Examples / AppKit / Draw |
1.1 ! root 1: #import "draw.h" ! 2: ! 3: @implementation Graphic : Object ! 4: ! 5: static int KNOB_WIDTH = 0.0; ! 6: static int KNOB_HEIGHT = 0.0; ! 7: ! 8: #define MINSIZE 5.0 /* minimum size of a Graphic */ ! 9: ! 10: NXCursor *CrossCursor = nil; /* global since subclassers may need it */ ! 11: ! 12: /* Optimization method. */ ! 13: ! 14: /* ! 15: * The fastKnobFill optimization just keeps a list of black and dark gray ! 16: * rectangles (the knobbies are made out of black and dark gray rectangles) ! 17: * and emits them in a single NXRectFillList() which is much faster than ! 18: * doing individual rectfills (we also save the repeated setgrays). ! 19: */ ! 20: ! 21: static NXRect *blackRectList = NULL; ! 22: static int blackRectSize = 0; ! 23: static int blackRectCount = 0; ! 24: static NXRect *dkgrayRectList = NULL; ! 25: static int dkgrayRectSize = 0; ! 26: static int dkgrayRectCount = 0; ! 27: ! 28: + fastKnobFill:(const NXRect *)aRect isBlack:(BOOL)isBlack ! 29: { ! 30: if (!aRect) return self; ! 31: ! 32: if (isBlack) { ! 33: if (!blackRectList) { ! 34: blackRectSize = 16; ! 35: NX_ZONEMALLOC([NXApp zone], blackRectList, NXRect, blackRectSize); ! 36: } else { ! 37: while (blackRectCount >= blackRectSize) blackRectSize <<= 1; ! 38: NX_ZONEREALLOC([NXApp zone], blackRectList, NXRect, blackRectSize); ! 39: } ! 40: blackRectList[blackRectCount++] = *aRect; ! 41: } else { ! 42: if (!dkgrayRectList) { ! 43: dkgrayRectSize = 16; ! 44: NX_ZONEMALLOC([NXApp zone], dkgrayRectList, NXRect, dkgrayRectSize); ! 45: } else { ! 46: while (dkgrayRectCount >= dkgrayRectSize) dkgrayRectSize <<= 1; ! 47: NX_ZONEREALLOC([NXApp zone], dkgrayRectList, NXRect, dkgrayRectSize); ! 48: } ! 49: dkgrayRectList[dkgrayRectCount++] = *aRect; ! 50: } ! 51: ! 52: return self; ! 53: } ! 54: ! 55: + showFastKnobFills ! 56: { ! 57: PSsetgray(NX_BLACK); ! 58: NXRectFillList(blackRectList, blackRectCount); ! 59: PSsetgray(NX_DKGRAY); ! 60: NXRectFillList(dkgrayRectList, dkgrayRectCount); ! 61: blackRectCount = 0; ! 62: dkgrayRectCount = 0; ! 63: return self; ! 64: } ! 65: ! 66: /* Factory methods. */ ! 67: ! 68: + initialize ! 69: /* ! 70: * This sets the class version so that we can compatibly read ! 71: * old Graphic objects out of an archive. ! 72: */ ! 73: { ! 74: [Graphic setVersion:3]; ! 75: return self; ! 76: } ! 77: ! 78: + (BOOL)isEditable ! 79: /* ! 80: * Any Graphic which can be edited should return YES from this ! 81: * and its instances should do something in the response to the ! 82: * edit:in: method. ! 83: */ ! 84: { ! 85: return NO; ! 86: } ! 87: ! 88: + cursor ! 89: /* ! 90: * Any Graphic that doesn't have a special cursor gets the default cross. ! 91: */ ! 92: { ! 93: NXPoint spot; ! 94: ! 95: if (!CrossCursor) { ! 96: CrossCursor = [NXCursor newFromImage:[NXImage newFromSection:"Cross.tiff"]]; ! 97: spot.x = 7.0; spot.y = 7.0; ! 98: [CrossCursor setHotSpot:&spot]; ! 99: } ! 100: ! 101: return CrossCursor; ! 102: } ! 103: ! 104: static void initClassVars() ! 105: { ! 106: const char *value; ! 107: NXCoord w = 2.0, h = 2.0; ! 108: ! 109: if (!KNOB_WIDTH) { ! 110: value = NXGetDefaultValue([NXApp appName], "KnobWidth"); ! 111: if (value) w = floor(atof(value) / 2.0); ! 112: value = NXGetDefaultValue([NXApp appName], "KnobHeight"); ! 113: if (value) h = floor(atof(value) / 2.0); ! 114: w = MAX(w, 1.0); h = MAX(h, 1.0); ! 115: KNOB_WIDTH = w * 2.0 + 1.0; /* size must be odd */ ! 116: KNOB_HEIGHT = h * 2.0 + 1.0; ! 117: } ! 118: } ! 119: ! 120: /* ! 121: * The currentGraphicIdentifier is a number that is kept unique for a given ! 122: * Draw document by being monotonically increasing and is bumped each time a ! 123: * new Graphic is created. The method of the same name is used during the ! 124: * archiving of a Draw document to write out what the number is at save-time. ! 125: * updateCurrentGraphicIdentifer: is used at document load time to reset ! 126: * the number to that level (if it's already higher, then we don't need to ! 127: * bump it). ! 128: */ ! 129: ! 130: static int currentGraphicIdentifier = 1; ! 131: ! 132: + (int)currentGraphicIdentifier ! 133: { ! 134: return currentGraphicIdentifier; ! 135: } ! 136: ! 137: + updateCurrentGraphicIdentifier:(int)newMaxIdentifier ! 138: { ! 139: if (newMaxIdentifier > currentGraphicIdentifier) currentGraphicIdentifier = newMaxIdentifier; ! 140: return self; ! 141: } ! 142: ! 143: - init ! 144: { ! 145: [super init]; ! 146: gFlags.active = YES; ! 147: gFlags.selected = YES; ! 148: initClassVars(); ! 149: identifier = currentGraphicIdentifier++; ! 150: return self; ! 151: } ! 152: ! 153: - awake ! 154: { ! 155: initClassVars(); ! 156: return [super awake]; ! 157: } ! 158: ! 159: /* Private C functions and macros used to implement methods in this class. */ ! 160: ! 161: static void drawKnobs(const NXRect *rect, int cornerMask, BOOL black) ! 162: /* ! 163: * Draws either the knobs or their shadows (not both). ! 164: */ ! 165: { ! 166: NXRect knob; ! 167: NXCoord dx, dy; ! 168: BOOL oddx, oddy; ! 169: ! 170: knob = *rect; ! 171: dx = knob.size.width / 2.0; ! 172: dy = knob.size.height / 2.0; ! 173: oddx = (floor(dx) != dx); ! 174: oddy = (floor(dy) != dy); ! 175: knob.size.width = KNOB_WIDTH; ! 176: knob.size.height = KNOB_HEIGHT; ! 177: knob.origin.x -= ((KNOB_WIDTH - 1.0) / 2.0); ! 178: knob.origin.y -= ((KNOB_HEIGHT - 1.0) / 2.0); ! 179: ! 180: if (cornerMask & LOWER_LEFT_MASK) [Graphic fastKnobFill:&knob isBlack:black]; ! 181: knob.origin.y += dy; ! 182: if (oddy) knob.origin.y -= 0.5; ! 183: if (cornerMask & LEFT_SIDE_MASK) [Graphic fastKnobFill:&knob isBlack:black]; ! 184: knob.origin.y += dy; ! 185: if (oddy) knob.origin.y += 0.5; ! 186: if (cornerMask & UPPER_LEFT_MASK) [Graphic fastKnobFill:&knob isBlack:black]; ! 187: knob.origin.x += dx; ! 188: if (oddx) knob.origin.x -= 0.5; ! 189: if (cornerMask & TOP_SIDE_MASK) [Graphic fastKnobFill:&knob isBlack:black]; ! 190: knob.origin.x += dx; ! 191: if (oddx) knob.origin.x += 0.5; ! 192: if (cornerMask & UPPER_RIGHT_MASK) [Graphic fastKnobFill:&knob isBlack:black]; ! 193: knob.origin.y -= dy; ! 194: if (oddy) knob.origin.y -= 0.5; ! 195: if (cornerMask & RIGHT_SIDE_MASK) [Graphic fastKnobFill:&knob isBlack:black]; ! 196: knob.origin.y -= dy; ! 197: if (oddy) knob.origin.y += 0.5; ! 198: if (cornerMask & LOWER_RIGHT_MASK) [Graphic fastKnobFill:&knob isBlack:black]; ! 199: knob.origin.x -= dx; ! 200: if (oddx) knob.origin.x += 0.5; ! 201: if (cornerMask & BOTTOM_SIDE_MASK) [Graphic fastKnobFill:&knob isBlack:black]; ! 202: } ! 203: ! 204: /* Private methods sometimes overridden by subclassers */ ! 205: ! 206: - setGraphicsState ! 207: /* ! 208: * Emits a gsave, must be balanced by grestore. ! 209: */ ! 210: { ! 211: PSSetParameters(gFlags.linecap, gFlags.linejoin, linewidth); ! 212: return self; ! 213: } ! 214: ! 215: - setLineColor ! 216: { ! 217: if (lineColor) { ! 218: NXSetColor(*lineColor); ! 219: } else { ! 220: NXSetColor(NX_COLORBLACK); ! 221: } ! 222: return self; ! 223: } ! 224: ! 225: - setFillColor ! 226: { ! 227: if (fillColor) NXSetColor(*fillColor); ! 228: return self; ! 229: } ! 230: ! 231: - (int)cornerMask ! 232: /* ! 233: * Returns a mask of the corners which should have a knobby in them. ! 234: */ ! 235: { ! 236: return ALL_CORNERS; ! 237: } ! 238: ! 239: /* Data link methods -- see Links.rtf and gvLinks.m for more info */ ! 240: ! 241: /* ! 242: * Most Graphics aren't linked (i.e. their visual display is ! 243: * not determined by some other document). See Image and ! 244: * TextGraphic for examples of Graphics that sometimes do. ! 245: */ ! 246: ! 247: - setLink:(NXDataLink *)aLink ! 248: { ! 249: return nil; ! 250: } ! 251: ! 252: - (NXDataLink *)link ! 253: { ! 254: return nil; ! 255: } ! 256: ! 257: - (Graphic *)graphicLinkedBy:(NXDataLink *)aLink ! 258: /* ! 259: * The reason we implement this method (instead of just relying on ! 260: * saying if ([graphic link] == aLink)) is for the sake of Group ! 261: * objects which may have a linked Graphic embedded in them. ! 262: */ ! 263: { ! 264: NXDataLink *link = [self link]; ! 265: ! 266: if (link) { ! 267: if (!aLink) { /* !aLink means any link */ ! 268: return ([link disposition] != NX_LinkBroken) ? self : nil; ! 269: } else { ! 270: return (aLink == link) ? self : nil; ! 271: } ! 272: } ! 273: ! 274: return nil; ! 275: } ! 276: ! 277: - reviveLink:(NXDataLinkManager *)linkManager ! 278: /* ! 279: * We never archive link information (but, of course, the unique identifer ! 280: * is always archived with a Graphic). Thus, when our document is reloaded, ! 281: * we just asked the NXDataLinkManager which NXDataLink object is associated ! 282: * with the NXSelection which represents this Graphic. ! 283: */ ! 284: { ! 285: if (![self link]) [self setLink:[linkManager findDestinationLinkWithSelection:[self selection]]]; ! 286: return self; ! 287: } ! 288: ! 289: - (NXSelection *)selection ! 290: /* ! 291: * Just creates an NXSelection "bag o' bits" with our unique identifier in it. ! 292: */ ! 293: { ! 294: char buffer[200]; ! 295: sprintf(buffer, "%d %d", ByGraphic, [self identifier]); ! 296: return [[NXSelection allocFromZone:[self zone]] initWithDescription:buffer length:strlen(buffer)+1]; ! 297: } ! 298: ! 299: - (BOOL)mightBeLinked ! 300: /* ! 301: * This is set whenever our Graphic has a link set in it. ! 302: * It is never cleared. ! 303: * We use it during copy/paste to determine whether we have ! 304: * to check with the data link manager to possibly reestablish ! 305: * a link to this object. ! 306: */ ! 307: { ! 308: return gFlags.mightBeLinked; ! 309: } ! 310: ! 311: - readLinkFromPasteboard:(Pasteboard *)pboard usingManager:(NXDataLinkManager *)linkManager useNewIdentifier:(BOOL)useNewIdentifier ! 312: /* ! 313: * This is called by pasteFromPasteboard: when we paste a Graphic (i.e. copied/pasted from ! 314: * another Draw document) in case that Graphic was linked to something when it was copied. ! 315: * Since we called writeLinksToPasteboard: when we put the Graphic into the pasteboard (see ! 316: * writeLinkToPasteboard:types: above) we can simply retrieve all the link information for ! 317: * that graphic by using the linkManager method addLinkPreviouslyAt:fromPasteboard:at:. ! 318: */ ! 319: { ! 320: NXDataLink *link; ! 321: NXSelection *oldSelection, *newSelection; ! 322: ! 323: oldSelection = [self selection]; ! 324: if (linkManager && oldSelection) { ! 325: if (useNewIdentifier) [self resetIdentifier]; ! 326: newSelection = [self selection]; ! 327: link = [linkManager addLinkPreviouslyAt:oldSelection ! 328: fromPasteboard:pboard ! 329: at:newSelection]; ! 330: if (!link) [newSelection free]; ! 331: [self setLink:link]; ! 332: } ! 333: if (useNewIdentifier) [oldSelection free]; ! 334: ! 335: return self; ! 336: } ! 337: ! 338: /* Notification messages */ ! 339: ! 340: /* ! 341: * These methods are sent when a Graphic is added to or removed ! 342: * from a GraphicView (respectively). Currently we only use them ! 343: * to break and reestablish links if any. ! 344: */ ! 345: ! 346: - wasAddedTo:(GraphicView *)sender ! 347: { ! 348: NXDataLink *link; ! 349: NXDataLinkManager *linkManager; ! 350: ! 351: if ((linkManager = [sender linkManager]) && (link = [self link])) { ! 352: if ([link disposition] == NX_LinkBroken) { ! 353: [linkManager addLink:link at:[self selection]]; ! 354: } ! 355: } ! 356: ! 357: return self; ! 358: } ! 359: ! 360: - wasRemovedFrom:(GraphicView *)sender ! 361: { ! 362: [[self link] break]; ! 363: return self; ! 364: } ! 365: ! 366: /* Methods for uniquely identifying a Graphic. */ ! 367: ! 368: - resetIdentifier ! 369: { ! 370: identifier = currentGraphicIdentifier++; ! 371: return self; ! 372: } ! 373: ! 374: - writeIdentifierTo:(char *)buffer ! 375: /* ! 376: * This method is necessary to support a Group which never writes out ! 377: * its own identifier, but, instead has its components each write out ! 378: * their own identifier. ! 379: */ ! 380: { ! 381: sprintf(buffer, "%d", identifier); ! 382: return self; ! 383: } ! 384: ! 385: - (int)identifier ! 386: { ! 387: return identifier; ! 388: } ! 389: ! 390: - (Graphic *)graphicIdentifiedBy:(int)anIdentifier ! 391: { ! 392: return (identifier == anIdentifier) ? self : nil; ! 393: } ! 394: ! 395: /* Event handling */ ! 396: ! 397: - (BOOL)handleEvent:(NXEvent *)event at:(const NXPoint *)p inView:(View *)view ! 398: /* ! 399: * Currently the only Graphic's that handle events are Image Graphic's that ! 400: * are linked to something else (they follow the link on double-click and ! 401: * the track the mouse for link buttons, for example). This method should ! 402: * return YES only if it tracked the mouse until it went up. ! 403: */ ! 404: { ! 405: return NO; ! 406: } ! 407: ! 408: /* Number of Graphics this Graphic represents (always 1 for non-Group). */ ! 409: ! 410: - (int)graphicCount ! 411: /* ! 412: * This is really only here to support Groups. It is used by the ! 413: * Object Link stuff purely to know how much space will be needed to ! 414: * create an NXSelection with the unique identifiers of all the objects ! 415: * in the selection. ! 416: */ ! 417: { ! 418: return 1; ! 419: } ! 420: ! 421: /* Public routines mostly called by GraphicView's. */ ! 422: ! 423: - (const char *)title ! 424: { ! 425: return NXLoadLocalStringFromTableInBundle(NULL, nil, [self name], NULL); ! 426: } ! 427: ! 428: - (BOOL)isSelected ! 429: { ! 430: return gFlags.selected; ! 431: } ! 432: ! 433: - (BOOL)isActive ! 434: { ! 435: return gFlags.active; ! 436: } ! 437: ! 438: - (BOOL)isLocked ! 439: { ! 440: return gFlags.locked; ! 441: } ! 442: ! 443: - select ! 444: { ! 445: gFlags.selected = YES; ! 446: return self; ! 447: } ! 448: ! 449: - deselect ! 450: { ! 451: gFlags.selected = NO; ! 452: return self; ! 453: } ! 454: ! 455: - activate ! 456: /* ! 457: * Activation is used to *temporarily* take a Graphic out of the GraphicView. ! 458: */ ! 459: { ! 460: gFlags.active = YES; ! 461: return self; ! 462: } ! 463: ! 464: - deactivate ! 465: { ! 466: gFlags.active = NO; ! 467: return self; ! 468: } ! 469: ! 470: - lock ! 471: /* ! 472: * A locked graphic cannot be selected, resized or moved. ! 473: */ ! 474: { ! 475: gFlags.locked = YES; ! 476: return self; ! 477: } ! 478: ! 479: - unlock ! 480: { ! 481: gFlags.locked = NO; ! 482: return self; ! 483: } ! 484: ! 485: /* See TextGraphic for more info about form entries. */ ! 486: ! 487: - (BOOL)isFormEntry ! 488: { ! 489: return NO; ! 490: } ! 491: ! 492: - setFormEntry:(int)flag ! 493: { ! 494: return self; ! 495: } ! 496: ! 497: - (BOOL)hasFormEntries ! 498: { ! 499: return NO; ! 500: } ! 501: ! 502: - (BOOL)writeFormEntryToStream:(NXStream *)stream ! 503: { ! 504: return NO; ! 505: } ! 506: ! 507: /* See Group and Image for more info about cacheability. */ ! 508: ! 509: - setCacheable:(BOOL)flag ! 510: { ! 511: return self; ! 512: } ! 513: ! 514: - (BOOL)isCacheable ! 515: { ! 516: return YES; ! 517: } ! 518: ! 519: /* Getting and setting the bounds. */ ! 520: ! 521: - getBounds:(NXRect *)theRect ! 522: { ! 523: *theRect = bounds; ! 524: return self; ! 525: } ! 526: ! 527: - setBounds:(const NXRect *)aRect ! 528: { ! 529: bounds = *aRect; ! 530: return self; ! 531: } ! 532: ! 533: - (NXRect *)getExtendedBounds:(NXRect *)theRect ! 534: /* ! 535: * Returns, by reference, the rectangle which encloses the Graphic ! 536: * AND ITS KNOBBIES and its increased line width (if appropriate). ! 537: */ ! 538: { ! 539: if (bounds.size.width < 0.0) { ! 540: theRect->origin.x = bounds.origin.x + bounds.size.width; ! 541: theRect->size.width = - bounds.size.width; ! 542: } else { ! 543: theRect->origin.x = bounds.origin.x; ! 544: theRect->size.width = bounds.size.width; ! 545: } ! 546: if (bounds.size.height < 0.0) { ! 547: theRect->origin.y = bounds.origin.y + bounds.size.height; ! 548: theRect->size.height = - bounds.size.height; ! 549: } else { ! 550: theRect->origin.y = bounds.origin.y; ! 551: theRect->size.height = bounds.size.height; ! 552: } ! 553: ! 554: theRect->size.width = MAX(1.0, theRect->size.width); ! 555: theRect->size.height = MAX(1.0, theRect->size.height); ! 556: ! 557: NXInsetRect(theRect, - ((KNOB_WIDTH - 1.0) + linewidth + 1.0), ! 558: - ((KNOB_HEIGHT - 1.0) + linewidth + 1.0)); ! 559: ! 560: if (gFlags.arrow) { ! 561: if (linewidth) { ! 562: NXInsetRect(theRect, - linewidth * 2.5, - linewidth * 2.5); ! 563: } else { ! 564: NXInsetRect(theRect, - 13.0, - 13.0); ! 565: } ! 566: } ! 567: ! 568: NXIntegralRect(theRect); ! 569: ! 570: return theRect; ! 571: } ! 572: ! 573: - (int)knobHit:(const NXPoint *)p ! 574: /* ! 575: * Returns 0 if point is in bounds, and Graphic isOpaque, and no knobHit. ! 576: * Returns -1 if outside bounds or not opaque or not active. ! 577: * Returns corner number if there is a hit on a corner. ! 578: * We have to be careful when the bounds are off an odd size since the ! 579: * knobs on the sides are one pixel larger. ! 580: */ ! 581: { ! 582: NXRect eb; ! 583: NXRect knob; ! 584: NXCoord dx, dy; ! 585: BOOL oddx, oddy; ! 586: int cornerMask = [self cornerMask]; ! 587: ! 588: [self getExtendedBounds:&eb]; ! 589: ! 590: if (!gFlags.active) { ! 591: return -1; ! 592: } else if (!gFlags.selected) { ! 593: return (NXMouseInRect(p, &bounds, NO) && [self isOpaque]) ? 0 : -1; ! 594: } else { ! 595: if (!NXMouseInRect(p, &eb, NO)) return -1; ! 596: } ! 597: ! 598: knob = bounds; ! 599: dx = knob.size.width / 2.0; ! 600: dy = knob.size.height / 2.0; ! 601: oddx = (floor(dx) != dx); ! 602: oddy = (floor(dy) != dy); ! 603: knob.size.width = KNOB_WIDTH; ! 604: knob.size.height = KNOB_HEIGHT; ! 605: knob.origin.x -= ((KNOB_WIDTH - 1.0) / 2.0); ! 606: knob.origin.y -= ((KNOB_HEIGHT - 1.0) / 2.0); ! 607: ! 608: if ((cornerMask & LOWER_LEFT_MASK) && NXMouseInRect(p, &knob, NO)) ! 609: return(LOWER_LEFT); ! 610: knob.origin.y += dy; ! 611: if (oddy) knob.origin.y -= 0.5; ! 612: if ((cornerMask & LEFT_SIDE_MASK) && NXMouseInRect(p, &knob, NO)) ! 613: return(LEFT_SIDE); ! 614: knob.origin.y += dy; ! 615: if (oddy) knob.origin.y += 0.5; ! 616: if ((cornerMask & UPPER_LEFT_MASK) && NXMouseInRect(p, &knob, NO)) ! 617: return(UPPER_LEFT); ! 618: knob.origin.x += dx; ! 619: if (oddx) knob.origin.x -= 0.5; ! 620: if ((cornerMask & TOP_SIDE_MASK) && NXMouseInRect(p, &knob, NO)) ! 621: return(TOP_SIDE); ! 622: knob.origin.x += dx; ! 623: if (oddx) knob.origin.x += 0.5; ! 624: if ((cornerMask & UPPER_RIGHT_MASK) && NXMouseInRect(p, &knob, NO)) ! 625: return(UPPER_RIGHT); ! 626: knob.origin.y -= dy; ! 627: if (oddy) knob.origin.y -= 0.5; ! 628: if ((cornerMask & RIGHT_SIDE_MASK) && NXMouseInRect(p, &knob, NO)) ! 629: return(RIGHT_SIDE); ! 630: knob.origin.y -= dy; ! 631: if (oddy) knob.origin.y += 0.5; ! 632: if ((cornerMask & LOWER_RIGHT_MASK) && NXMouseInRect(p, &knob, NO)) ! 633: return(LOWER_RIGHT); ! 634: knob.origin.x -= dx; ! 635: if (oddx) knob.origin.x += 0.5; ! 636: if ((cornerMask & BOTTOM_SIDE_MASK) && NXMouseInRect(p, &knob, NO)) ! 637: return(BOTTOM_SIDE); ! 638: ! 639: return NXMouseInRect(p, &bounds, NO) ? ([self isOpaque] ? 0 : -1) : -1; ! 640: } ! 641: ! 642: /* This method is analogous to display (not drawSelf::) in View. */ ! 643: ! 644: - draw:(const NXRect *)rect ! 645: /* ! 646: * Draws the graphic inside rect. If rect is NULL, then it draws the ! 647: * entire Graphic. If the Graphic is not intersected by rect, then it ! 648: * is not drawn at all. If the Graphic is selected, it is drawn with ! 649: * its knobbies. This method is not intended to be overridden. It ! 650: * calls the overrideable method "draw" which doesn't have to worry ! 651: * about drawing the knobbies. ! 652: * ! 653: * Note the showFastKnobFills optimization here. If this Graphic is ! 654: * opaque then there is a possibility that it might obscure knobbies ! 655: * of Graphics underneath it, so we must emit the cached rectfills ! 656: * before drawing this Graphic. ! 657: */ ! 658: { ! 659: NXRect r; ! 660: ! 661: [self getExtendedBounds:&r]; ! 662: if (gFlags.active && (!rect || NXIntersectsRect(rect, &r))) { ! 663: if ([self isOpaque]) [Graphic showFastKnobFills]; ! 664: [self setGraphicsState]; /* does a gsave */ ! 665: [self draw]; ! 666: PSgrestore(); /* so we need a grestore here */ ! 667: if (NXDrawingStatus == NX_DRAWING) { ! 668: if (gFlags.selected) { ! 669: r.origin.x = floor(bounds.origin.x); ! 670: r.origin.y = floor(bounds.origin.y); ! 671: r.size.width = floor(bounds.origin.x + bounds.size.width + 0.99) - r.origin.x; ! 672: r.size.height = floor(bounds.origin.y + bounds.size.height + 0.99) - r.origin.y; ! 673: r.origin.x += 1.0; ! 674: r.origin.y -= 1.0; ! 675: drawKnobs(&r, [self cornerMask], YES); /* shadows */ ! 676: r.origin.x = floor(bounds.origin.x); ! 677: r.origin.y = floor(bounds.origin.y); ! 678: r.size.width = floor(bounds.origin.x + bounds.size.width + 0.99) - r.origin.x; ! 679: r.size.height = floor(bounds.origin.y + bounds.size.height + 0.99) - r.origin.y; ! 680: drawKnobs(&r, [self cornerMask], NO); /* knobs */ ! 681: } ! 682: } ! 683: return self; ! 684: } ! 685: ! 686: return nil; ! 687: } ! 688: ! 689: /* ! 690: * Returns whether this Graphic can emit, all by itself, fully ! 691: * encapsulated PostScript (or fully conforming TIFF) representing ! 692: * itself. This is an optimization for copy/paste. ! 693: */ ! 694: ! 695: - (BOOL)canEmitEPS ! 696: { ! 697: return NO; ! 698: } ! 699: ! 700: - (BOOL)canEmitTIFF ! 701: { ! 702: return NO; ! 703: } ! 704: ! 705: /* Sizing, aligning and moving. */ ! 706: ! 707: - moveLeftEdgeTo:(const NXCoord *)x ! 708: { ! 709: bounds.origin.x = *x; ! 710: return self; ! 711: } ! 712: ! 713: - moveRightEdgeTo:(const NXCoord *)x ! 714: { ! 715: bounds.origin.x = *x - bounds.size.width; ! 716: return self; ! 717: } ! 718: ! 719: - moveTopEdgeTo:(const NXCoord *)y ! 720: { ! 721: bounds.origin.y = *y - bounds.size.height; ! 722: return self; ! 723: } ! 724: ! 725: - moveBottomEdgeTo:(const NXCoord *)y ! 726: { ! 727: bounds.origin.y = *y; ! 728: return self; ! 729: } ! 730: ! 731: - moveHorizontalCenterTo:(const NXCoord *)x ! 732: { ! 733: bounds.origin.x = *x - floor(bounds.size.width / 2.0); ! 734: return self; ! 735: } ! 736: ! 737: - moveVerticalCenterTo:(const NXCoord *)y ! 738: { ! 739: bounds.origin.y = *y - floor(bounds.size.height / 2.0); ! 740: return self; ! 741: } ! 742: ! 743: - (NXCoord)baseline ! 744: { ! 745: return 0.0; ! 746: } ! 747: ! 748: - moveBaselineTo:(const NXCoord *)y ! 749: { ! 750: return self; ! 751: } ! 752: ! 753: - moveBy:(const NXPoint *)offset ! 754: { ! 755: bounds.origin.x += floor(offset->x); ! 756: bounds.origin.y += floor(offset->y); ! 757: return self; ! 758: } ! 759: ! 760: - moveTo:(const NXPoint *)p ! 761: { ! 762: bounds.origin.x = floor(p->x); ! 763: bounds.origin.y = floor(p->y); ! 764: return self; ! 765: } ! 766: ! 767: - centerAt:(const NXPoint *)p ! 768: { ! 769: bounds.origin.x = floor(p->x - bounds.size.width / 2.0); ! 770: bounds.origin.y = floor(p->y - bounds.size.height / 2.0); ! 771: return self; ! 772: } ! 773: ! 774: - sizeTo:(const NXSize *)size ! 775: { ! 776: bounds.size.width = floor(size->width); ! 777: bounds.size.height = floor(size->height); ! 778: return self; ! 779: } ! 780: ! 781: - sizeToNaturalAspectRatio ! 782: { ! 783: return [self constrainCorner:UPPER_RIGHT toAspectRatio:[self naturalAspectRatio]]; ! 784: } ! 785: ! 786: - sizeToGrid:(GraphicView *)graphicView ! 787: { ! 788: NXPoint p; ! 789: ! 790: [graphicView grid:&bounds.origin]; ! 791: p.x = bounds.origin.x + bounds.size.width; ! 792: p.y = bounds.origin.y + bounds.size.height; ! 793: [graphicView grid:&p]; ! 794: bounds.size.width = p.x - bounds.origin.x; ! 795: bounds.size.height = p.y - bounds.origin.y; ! 796: ! 797: return self; ! 798: } ! 799: ! 800: - alignToGrid:(GraphicView *)graphicView ! 801: { ! 802: [graphicView grid:&bounds.origin]; ! 803: return self; ! 804: } ! 805: ! 806: /* Compatibility method for old PSGraphic and Tiff classes. */ ! 807: ! 808: - replaceWithImage ! 809: { ! 810: return self; ! 811: } ! 812: ! 813: /* Public routines. */ ! 814: ! 815: - setLineWidth:(const float *)value ! 816: /* ! 817: * This is called with value indirected so that it can be called via ! 818: * a perform:with: method. Kind of screwy, but ... ! 819: */ ! 820: { ! 821: if (value) linewidth = *value; ! 822: return self; ! 823: } ! 824: ! 825: - (float)lineWidth ! 826: { ! 827: return linewidth; ! 828: } ! 829: ! 830: - setLineColor:(const NXColor *)color ! 831: { ! 832: if (color) { ! 833: if (NXEqualColor(*color, NX_COLORBLACK)) { ! 834: NX_FREE(lineColor); ! 835: lineColor = NULL; ! 836: gFlags.nooutline = NO; ! 837: } else { ! 838: if (!lineColor) NX_ZONEMALLOC([self zone], lineColor, NXColor, 1); ! 839: *lineColor = *color; ! 840: gFlags.nooutline = NO; ! 841: } ! 842: } ! 843: return self; ! 844: } ! 845: ! 846: - (NXColor)lineColor ! 847: { ! 848: return lineColor ? *lineColor : NX_COLORBLACK; ! 849: } ! 850: ! 851: - setFillColor:(const NXColor *)color ! 852: { ! 853: if (color) { ! 854: if (!fillColor) NX_ZONEMALLOC([self zone], fillColor, NXColor, 1); ! 855: *fillColor = *color; ! 856: if (![self fill]) [self setFill:FILL_NZWR]; ! 857: } ! 858: return self; ! 859: } ! 860: ! 861: - (NXColor)fillColor ! 862: { ! 863: return fillColor ? *fillColor : NX_COLORWHITE; ! 864: } ! 865: ! 866: - (Graphic *)colorAcceptorAt:(const NXPoint *)point ! 867: /* ! 868: * This method supports dragging and dropping colors on Graphics. ! 869: * Whatever object is returned from this may well be sent ! 870: * setFillColor: if the color actually gets dropped on it. ! 871: * See gvDrag.m's acceptsColor:atPoint: method. ! 872: */ ! 873: { ! 874: return nil; ! 875: } ! 876: ! 877: - changeFont:sender ! 878: { ! 879: return self; ! 880: } ! 881: ! 882: - font ! 883: { ! 884: return nil; ! 885: } ! 886: ! 887: - setGray:(const float *)value ! 888: /* ! 889: * This is called with value indirected so that it can be called via ! 890: * a perform:with: method. Kind of screwy, but ... ! 891: * Now that we have converted to using NXColor's, we'll interpret this ! 892: * method as a request to set the lineColor. ! 893: */ ! 894: { ! 895: NXColor color; ! 896: ! 897: if (value) { ! 898: color = NXConvertGrayToColor(*value); ! 899: [self setLineColor:&color]; ! 900: } ! 901: ! 902: return self; ! 903: } ! 904: ! 905: - (float)gray ! 906: { ! 907: float retval; ! 908: ! 909: if (lineColor) { ! 910: NXConvertColorToGray(*lineColor, &retval); ! 911: } else { ! 912: retval = NX_BLACK; ! 913: } ! 914: ! 915: return retval; ! 916: } ! 917: ! 918: - setFill:(int)mode ! 919: { ! 920: switch (mode) { ! 921: case FILL_NONE: gFlags.eofill = gFlags.fill = NO; break; ! 922: case FILL_EO: gFlags.eofill = YES; gFlags.fill = NO; break; ! 923: case FILL_NZWR: gFlags.eofill = NO; gFlags.fill = YES; break; ! 924: } ! 925: return self; ! 926: } ! 927: ! 928: - (int)fill ! 929: { ! 930: if (gFlags.eofill) { ! 931: return FILL_EO; ! 932: } else if (gFlags.fill) { ! 933: return FILL_NZWR; ! 934: } else { ! 935: return FILL_NONE; ! 936: } ! 937: } ! 938: ! 939: - setOutlined:(BOOL)outlinedFlag ! 940: { ! 941: gFlags.nooutline = outlinedFlag ? NO : YES; ! 942: return self; ! 943: } ! 944: ! 945: - (BOOL)isOutlined ! 946: { ! 947: return gFlags.nooutline ? NO : YES; ! 948: } ! 949: ! 950: - setLineCap:(int)capValue ! 951: { ! 952: if (capValue >= 0 && capValue <= 2) { ! 953: gFlags.linecap = capValue; ! 954: } ! 955: return self; ! 956: } ! 957: ! 958: - (int)lineCap ! 959: { ! 960: return gFlags.linecap; ! 961: } ! 962: ! 963: - setLineArrow:(int)arrowValue ! 964: { ! 965: if (arrowValue >= 0 && arrowValue <= 3) { ! 966: gFlags.arrow = arrowValue; ! 967: } ! 968: return self; ! 969: } ! 970: ! 971: - (int)lineArrow ! 972: { ! 973: return gFlags.arrow; ! 974: } ! 975: ! 976: - setLineJoin:(int)joinValue ! 977: { ! 978: if (joinValue >= 0 && joinValue <= 2) { ! 979: gFlags.linejoin = joinValue; ! 980: } ! 981: return self; ! 982: } ! 983: ! 984: - (int)lineJoin ! 985: { ! 986: return gFlags.linejoin; ! 987: } ! 988: ! 989: /* Archiver-related methods. */ ! 990: ! 991: - write:(NXTypedStream *)stream ! 992: /* ! 993: * Since a typical document has many Graphics, we want to try and make ! 994: * the archived document small, so we don't write out the linewidth and ! 995: * gray values if they are the most common 0 and NX_BLACK. To accomplish ! 996: * this, we note that we haven't written them out by setting the ! 997: * bits in gFlags. ! 998: */ ! 999: { ! 1000: [super write:stream]; ! 1001: gFlags.linewidthSet = (linewidth != 0.0); ! 1002: gFlags.lineColorSet = lineColor ? YES : NO; ! 1003: gFlags.fillColorSet = fillColor ? YES : NO; ! 1004: NXWriteTypes(stream, "ffffii", &bounds.origin.x, &bounds.origin.y, ! 1005: &bounds.size.width, &bounds.size.height, &gFlags, &identifier); ! 1006: if (gFlags.linewidthSet) NXWriteTypes(stream, "f", &linewidth); ! 1007: if (gFlags.lineColorSet) NXWriteColor(stream, *lineColor); ! 1008: if (gFlags.fillColorSet) NXWriteColor(stream, *fillColor); ! 1009: return self; ! 1010: } ! 1011: ! 1012: - read:(NXTypedStream *)stream ! 1013: { ! 1014: int version; ! 1015: float gray = NX_BLACK; ! 1016: ! 1017: [super read:stream]; ! 1018: version = NXTypedStreamClassVersion(stream, "Graphic"); ! 1019: if (version > 2) { ! 1020: NXReadTypes(stream, "ffffii", &bounds.origin.x, &bounds.origin.y, ! 1021: &bounds.size.width, &bounds.size.height, &gFlags, &identifier); ! 1022: } else if (version > 1) { ! 1023: NXReadTypes(stream, "ffffsi", &bounds.origin.x, &bounds.origin.y, ! 1024: &bounds.size.width, &bounds.size.height, &gFlags, &identifier); ! 1025: #ifdef __LITTLE_ENDIAN__ ! 1026: *(unsigned int *)&gFlags = *(unsigned int *)&gFlags <<= 16; ! 1027: #endif ! 1028: } else { ! 1029: NXReadTypes(stream, "ffffs", &bounds.origin.x, &bounds.origin.y, ! 1030: &bounds.size.width, &bounds.size.height, &gFlags); ! 1031: #ifdef __LITTLE_ENDIAN__ ! 1032: *(unsigned int *)&gFlags = *(unsigned int *)&gFlags <<= 16; ! 1033: #endif ! 1034: identifier = currentGraphicIdentifier++; ! 1035: } ! 1036: if (version > 1 && identifier >= currentGraphicIdentifier) currentGraphicIdentifier = identifier+1; ! 1037: if (gFlags.linewidthSet) NXReadTypes(stream, "f", &linewidth); ! 1038: if (version < 1) { ! 1039: if (gFlags.lineColorSet) NXReadTypes(stream, "f", &gray); ! 1040: if (gFlags.fillColorSet && (gFlags.eofill | gFlags.fill)) { ! 1041: NX_ZONEMALLOC([self zone], lineColor, NXColor, 1); ! 1042: *lineColor = NXConvertGrayToColor(NX_BLACK); ! 1043: NX_ZONEMALLOC([self zone], fillColor, NXColor, 1); ! 1044: *fillColor = NXConvertGrayToColor(gray); ! 1045: } else if (gFlags.eofill | gFlags.fill) { ! 1046: NX_ZONEMALLOC([self zone], fillColor, NXColor, 1); ! 1047: *fillColor = NXConvertGrayToColor(gray); ! 1048: [self setOutlined:NO]; ! 1049: } else { ! 1050: NX_ZONEMALLOC([self zone], lineColor, NXColor, 1); ! 1051: *lineColor = NXConvertGrayToColor(gray); ! 1052: } ! 1053: } else { ! 1054: if (gFlags.lineColorSet) { ! 1055: NX_ZONEMALLOC([self zone], lineColor, NXColor, 1); ! 1056: *lineColor = NXReadColor(stream); ! 1057: if (NXEqualColor(*lineColor, NX_COLORCLEAR)) { ! 1058: free(lineColor); ! 1059: lineColor = NULL; ! 1060: [self setOutlined:NO]; ! 1061: } ! 1062: } ! 1063: if (gFlags.fillColorSet) { ! 1064: NX_ZONEMALLOC([self zone], fillColor, NXColor, 1); ! 1065: *fillColor = NXReadColor(stream); ! 1066: if (NXEqualColor(*fillColor, NX_COLORCLEAR) || (NXAlphaComponent(*fillColor) == 0.0)) { ! 1067: free(fillColor); ! 1068: fillColor = NULL; ! 1069: [self setFill:FILL_NONE]; ! 1070: // } else if (!gFlags.eofill && !gFlags.fill) { // why did I add this code here? ! 1071: // gFlags.fill = YES; ! 1072: } ! 1073: } ! 1074: } ! 1075: ! 1076: return self; ! 1077: } ! 1078: ! 1079: /* Routines which may need subclassing for different Graphic types. */ ! 1080: ! 1081: - (BOOL)constrainByDefault ! 1082: { ! 1083: return NO; ! 1084: } ! 1085: ! 1086: - constrainCorner:(int)corner toAspectRatio:(float)aspect ! 1087: /* ! 1088: * Modifies the bounds rectangle by moving the specified corner so that ! 1089: * the Graphic maintains the specified aspect ratio. This is used during ! 1090: * constrained resizing. Can be overridden if the aspect ratio is not ! 1091: * sufficient to constrain resizing. ! 1092: */ ! 1093: { ! 1094: int newcorner; ! 1095: float actualAspect; ! 1096: ! 1097: if (!bounds.size.height || !bounds.size.width || !aspect) return self; ! 1098: actualAspect = bounds.size.width / bounds.size.height; ! 1099: if (actualAspect == aspect) return self; ! 1100: ! 1101: switch (corner) { ! 1102: case LEFT_SIDE: ! 1103: bounds.origin.x -= bounds.size.height * aspect-bounds.size.width; ! 1104: case RIGHT_SIDE: ! 1105: bounds.size.width = bounds.size.height * aspect; ! 1106: if (bounds.size.width) NXIntegralRect(&bounds); ! 1107: return self; ! 1108: case BOTTOM_SIDE: ! 1109: bounds.origin.y -= bounds.size.width / aspect-bounds.size.height; ! 1110: case TOP_SIDE: ! 1111: bounds.size.height = bounds.size.width / aspect; ! 1112: if (bounds.size.height) NXIntegralRect(&bounds); ! 1113: return self; ! 1114: case LOWER_LEFT: ! 1115: corner = 0; ! 1116: case 0: ! 1117: case UPPER_RIGHT: ! 1118: case UPPER_LEFT: ! 1119: case LOWER_RIGHT: ! 1120: if (actualAspect > aspect) { ! 1121: newcorner = ((corner|KNOB_DY_ONCE)&(~(KNOB_DY_TWICE))); ! 1122: } else { ! 1123: newcorner = ((corner|KNOB_DX_ONCE)&(~(KNOB_DX_TWICE))); ! 1124: } ! 1125: return [self constrainCorner:newcorner toAspectRatio:aspect]; ! 1126: default: ! 1127: return self; ! 1128: } ! 1129: } ! 1130: ! 1131: #define RESIZE_MASK (NX_MOUSEUPMASK|NX_MOUSEDRAGGEDMASK|NX_TIMERMASK) ! 1132: ! 1133: - resize:(NXEvent *)event by:(int)corner in:(GraphicView *)view ! 1134: /* ! 1135: * Resizes the graphic by the specified corner. If corner == CREATE, ! 1136: * then it is resized by the UPPER_RIGHT corner, but the initial size ! 1137: * is reset to 1 by 1. ! 1138: */ ! 1139: { ! 1140: NXPoint p, last; ! 1141: float aspect = 0.0; ! 1142: Window *window = [view window]; ! 1143: BOOL constrain, canScroll; ! 1144: DrawStatusType oldDrawStatus; ! 1145: NXTrackingTimer *timer = NULL; ! 1146: NXRect eb, starteb, oldeb, visibleRect; ! 1147: ! 1148: if (!gFlags.active || !gFlags.selected || !corner) return self; ! 1149: ! 1150: constrain = ((event->flags & NX_ALTERNATEMASK) && ! 1151: ((bounds.size.width && bounds.size.height) || corner == CREATE)); ! 1152: if ([self constrainByDefault]) constrain = !constrain; ! 1153: if (constrain) aspect = bounds.size.width / bounds.size.height; ! 1154: if (corner == CREATE) { ! 1155: bounds.size.width = bounds.size.height = 1.0; ! 1156: corner = UPPER_RIGHT; ! 1157: } ! 1158: ! 1159: gFlags.selected = NO; ! 1160: ! 1161: [self getExtendedBounds:&eb]; ! 1162: [view lockFocus]; ! 1163: gFlags.active = NO; ! 1164: [view cache:&eb andUpdateLinks:NO]; ! 1165: gFlags.active = YES; ! 1166: starteb = eb; ! 1167: [self draw:NULL]; ! 1168: [window flushWindow]; ! 1169: ! 1170: oldDrawStatus = DrawStatus; ! 1171: DrawStatus = Resizing; ! 1172: ! 1173: [view getVisibleRect:&visibleRect]; ! 1174: canScroll = !NXEqualRect(&visibleRect, &bounds); ! 1175: if (canScroll && !timer) timer = NXBeginTimer(NULL, 0.1, 0.1); ! 1176: ! 1177: last.x = last.y = -1.0; ! 1178: while (event->type != NX_MOUSEUP) { ! 1179: p = event->location; ! 1180: event = [NXApp getNextEvent:RESIZE_MASK]; ! 1181: if (event->type == NX_TIMER) event->location = p; ! 1182: p = event->location; ! 1183: [view convertPoint:&p fromView:nil]; ! 1184: [view grid:&p]; ! 1185: if (p.x != last.x || p.y != last.y) { ! 1186: corner = [self moveCorner:corner to:&p constrain:constrain]; ! 1187: if (constrain) [self constrainCorner:corner toAspectRatio:aspect]; ! 1188: oldeb = eb; ! 1189: [self getExtendedBounds:&eb]; ! 1190: [window disableFlushWindow]; ! 1191: [view drawSelf:&oldeb :1]; ! 1192: if (canScroll) { ! 1193: [view scrollPointToVisible:&p]; // actually we want to keep the "edges" of the ! 1194: // Graphic being resized that were visible when ! 1195: // the resize started visible throughout the ! 1196: // resizing time (this will be difficult if those ! 1197: // edges flip from being the left edge to the ! 1198: // right edge in the middle of the resize!). ! 1199: } ! 1200: [self draw:NULL]; ! 1201: [view tryToPerform:@selector(updateRulers:) with:(void *)&bounds]; ! 1202: [window reenableFlushWindow]; ! 1203: [window flushWindow]; ! 1204: last = p; ! 1205: NXPing(); ! 1206: } ! 1207: } ! 1208: ! 1209: if (canScroll && timer) { ! 1210: NXEndTimer(timer); ! 1211: timer = NULL; ! 1212: } ! 1213: ! 1214: gFlags.selected = YES; ! 1215: DrawStatus = oldDrawStatus; ! 1216: ! 1217: [view cache:&eb andUpdateLinks:NO]; // redraw after resizing a Graphic ! 1218: NXUnionRect(&eb, &starteb); ! 1219: [view updateTrackedLinks:&starteb]; ! 1220: [view tryToPerform:@selector(updateRulers:) with:nil]; ! 1221: [window flushWindow]; ! 1222: [view unlockFocus]; ! 1223: ! 1224: return self; ! 1225: } ! 1226: ! 1227: - (BOOL)create:(NXEvent *)event in:(GraphicView *)view ! 1228: /* ! 1229: * This method rarely needs to be subclassed. ! 1230: * It sets up an initial bounds, and calls resize:by:in:. ! 1231: */ ! 1232: { ! 1233: BOOL valid; ! 1234: NXCoord gridSpacing; ! 1235: ! 1236: bounds.origin = event->location; ! 1237: [view convertPoint:&bounds.origin fromView:nil]; ! 1238: [view grid:&bounds.origin]; ! 1239: ! 1240: gridSpacing = (NXCoord)[view gridSpacing]; ! 1241: bounds.size.height = gridSpacing; ! 1242: bounds.size.width = gridSpacing * [self naturalAspectRatio]; ! 1243: ! 1244: [self resize:event by:CREATE in:view]; ! 1245: ! 1246: valid = [self isValid]; ! 1247: ! 1248: if (valid) { ! 1249: gFlags.selected = YES; ! 1250: gFlags.active = YES; ! 1251: } else { ! 1252: gFlags.selected = NO; ! 1253: gFlags.active = NO; ! 1254: [view display]; ! 1255: } ! 1256: ! 1257: return valid; ! 1258: } ! 1259: ! 1260: - (BOOL)hit:(const NXPoint *)p ! 1261: { ! 1262: return (!gFlags.locked && gFlags.active && NXMouseInRect(p, &bounds, NO)); ! 1263: } ! 1264: ! 1265: - (BOOL)isOpaque ! 1266: { ! 1267: return [self fill] ? YES : NO; ! 1268: } ! 1269: ! 1270: - (BOOL)isValid ! 1271: /* ! 1272: * Called after a Graphic is created to see if it is valid (this usually ! 1273: * means "is it big enough?"). ! 1274: */ ! 1275: { ! 1276: return (bounds.size.width > MINSIZE && bounds.size.height > MINSIZE); ! 1277: } ! 1278: ! 1279: - (float)naturalAspectRatio ! 1280: /* ! 1281: * A natural aspect ratio of zero means it doesn't have a natural aspect ratio. ! 1282: */ ! 1283: { ! 1284: return 0.0; ! 1285: } ! 1286: ! 1287: - (int)moveCorner:(int)corner to:(const NXPoint *)p constrain:(BOOL)flag ! 1288: /* ! 1289: * Moves the specified corner to the specified point. ! 1290: * Returns the position of the corner after it was moved. ! 1291: */ ! 1292: { ! 1293: int newcorner = corner; ! 1294: ! 1295: if ((corner & KNOB_DX_ONCE) && (corner & KNOB_DX_TWICE)) { ! 1296: bounds.size.width += p->x - (bounds.origin.x + bounds.size.width); ! 1297: if (bounds.size.width <= 0.0) { ! 1298: newcorner &= ~ (KNOB_DX_ONCE | KNOB_DX_TWICE); ! 1299: bounds.origin.x += bounds.size.width; ! 1300: bounds.size.width = - bounds.size.width; ! 1301: } ! 1302: } else if (!(corner & KNOB_DX_ONCE)) { ! 1303: bounds.size.width += bounds.origin.x - p->x; ! 1304: bounds.origin.x = p->x; ! 1305: if (bounds.size.width <= 0.0) { ! 1306: newcorner |= KNOB_DX_ONCE | KNOB_DX_TWICE; ! 1307: bounds.origin.x += bounds.size.width; ! 1308: bounds.size.width = - bounds.size.width; ! 1309: } ! 1310: } ! 1311: ! 1312: if ((corner & KNOB_DY_ONCE) && (corner & KNOB_DY_TWICE)) { ! 1313: bounds.size.height += p->y - (bounds.origin.y + bounds.size.height); ! 1314: if (bounds.size.height <= 0.0) { ! 1315: newcorner &= ~ (KNOB_DY_ONCE | KNOB_DY_TWICE); ! 1316: bounds.origin.y += bounds.size.height; ! 1317: bounds.size.height = - bounds.size.height; ! 1318: } ! 1319: } else if (!(corner & KNOB_DY_ONCE)) { ! 1320: bounds.size.height += bounds.origin.y - p->y; ! 1321: bounds.origin.y = p->y; ! 1322: if (bounds.size.height <= 0.0) { ! 1323: newcorner |= KNOB_DY_ONCE | KNOB_DY_TWICE; ! 1324: bounds.origin.y += bounds.size.height; ! 1325: bounds.size.height = - bounds.size.height; ! 1326: } ! 1327: } ! 1328: ! 1329: if (newcorner != LOWER_LEFT) newcorner &= 0xf; ! 1330: if (!newcorner) newcorner = LOWER_LEFT; ! 1331: ! 1332: return newcorner; ! 1333: } ! 1334: ! 1335: - unitDraw ! 1336: /* ! 1337: * If a Graphic just wants to draw itself in the bounding box of ! 1338: * {{0.0,0.0},{1.0,1.0}}, it can simply override this method. ! 1339: * Everything else will work fine. ! 1340: */ ! 1341: { ! 1342: return self; ! 1343: } ! 1344: ! 1345: - draw ! 1346: /* ! 1347: * Almost all Graphics need to override this method. ! 1348: * It does the Graphic-specific drawing. ! 1349: * By default, it scales the coordinate system and calls unitDraw. ! 1350: */ ! 1351: { ! 1352: if (bounds.size.width >= 1.0 && bounds.size.height >= 1.0) { ! 1353: PStranslate(bounds.origin.x, bounds.origin.y); ! 1354: PSscale(bounds.size.width, bounds.size.height); ! 1355: [self unitDraw]; ! 1356: } ! 1357: return self; ! 1358: } ! 1359: ! 1360: - (BOOL)edit:(NXEvent *)event in:(View *)view ! 1361: /* ! 1362: * Any Graphic which has editable text should override this method ! 1363: * to edit that text. TextGraphic is an example. ! 1364: */ ! 1365: { ! 1366: return NO; ! 1367: } ! 1368: ! 1369: @end
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.