![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to Image.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 Image.m CVS log | Up to [NeXTSTEP 3.3 examples] / Examples / AppKit / Draw |
1.1 root 1: #import "draw.h"
2:
3: /* Optimally viewed in a wide window. Make your window big enough so that this comment fits on one line without wrapping. */
4:
5: /*
6: * Image is a simple graphic which takes PostScript or
7: * TIFF images and draws them in a bounding box (it scales
8: * the image if the bounding box is changed). It is
9: * implemented using the NXImage class. Using NXImage
10: * here is especially nice since it images its PostScript
11: * in a separate context (thus, any errors that PostScript
12: * generates will not affect our main drawing context).
13: */
14:
15: @implementation Image : Graphic
16:
17: /* Initialize the class */
18:
19: + initialize
20: {
21: [Image setVersion:7];
22: return self;
23: }
24:
25: /* Factory methods. */
26:
27: + highlightedLinkButtonImage:(NXSize *)size
28: /*
29: * Just makes an NXLinkButtonH NXImage the same size as
30: * the size passed in. I suppose this could just be a
31: * function.
32: */
33: {
34: static NXImage *retval = nil;
35: if (!retval) {
36: retval = [[NXImage findImageNamed:"NXLinkButtonH"] copy];
37: [retval setScalable:YES];
38: [retval setDataRetained:YES];
39: }
40: [retval setSize:size];
41: return retval;
42: }
43:
44: + (BOOL)canInitFromPasteboard:(Pasteboard *)pboard
45: {
46: return [NXImage canInitFromPasteboard:pboard];
47: }
48:
49: static BOOL checkImage(NXImage *anImage)
50: /*
51: * Locking focus on an NXImage forces it to draw and thus verifies
52: * whether there are any PostScript or TIFF errors in the source of
53: * the image. lockFocus returns YES only if there are no errors.
54: */
55: {
56: if ([anImage lockFocus]) {
57: [anImage unlockFocus];
58: return YES;
59: }
60: return NO;
61: }
62:
63: /* Creation/Initialization Methods */
64:
65: - init
66: /*
67: * This creates basically an "empty" Image.
68: * This is the designated initializer for Image.
69: * Be careful, however, because by the time this
70: * returns, a newly initialized Image may not be
71: * fully initialized (it'll be "valid," just not
72: * necessarily fully initialized). If you want that
73: * behaviour, override finishedWithInit.
74: */
75: {
76: [super init];
77: originalSize.width = originalSize.height = 1.0;
78: bounds.size = originalSize;
79: return self;
80: }
81:
82: - finishedWithInit
83: /*
84: * Called when a newly initialized Image is fully
85: * initialized and ready to roll. For subclassers
86: * only.
87: */
88: {
89: return self;
90: }
91:
92: - initEmpty
93: /*
94: * Creates a blank Image.
95: */
96: {
97: [self init];
98: return [self finishedWithInit];
99: }
100:
101: - initFromStream:(NXStream *)stream
102: /*
103: * Creates a new NXImage and sets it to be scalable and to retain
104: * its data (which means that when we archive it, it will actually
105: * write the TIFF or PostScript data into the stream).
106: */
107: {
108: [self init];
109:
110: if (stream) {
111: image = [NXImage allocFromZone:[self zone]];
112: if ((image = [image initFromStream:stream])) {
113: [image setDataRetained:YES];
114: if (checkImage(image)) {
115: [image getSize:&originalSize];
116: [image setScalable:YES];
117: bounds.size = originalSize;
118: return [self finishedWithInit];
119: }
120: }
121: }
122:
123: [self free];
124:
125: return nil;
126: }
127:
128: - initFromPasteboard:(Pasteboard *)pboard;
129: /*
130: * Creates a new NXImage and sets it to be scalable and to retain
131: * its data (which means that when we archive it, it will actually
132: * write the TIFF or PostScript data into the stream).
133: */
134: {
135: [self init];
136:
137: if (pboard) {
138: image = [NXImage allocFromZone:[self zone]];
139: if ((image = [image initFromPasteboard:pboard])) {
140: [image setDataRetained:YES];
141: if (checkImage(image)) {
142: [image getSize:&originalSize];
143: [image setScalable:YES];
144: bounds.size = originalSize;
145: return [self finishedWithInit];
146: }
147: }
148: }
149:
150: [self free];
151:
152: return nil;
153: }
154:
155: - initFromFile:(const char *)file
156: /*
157: * Creates an NXImage by reading data from an .eps or .tiff file.
158: */
159: {
160: [self init];
161:
162: image = [[NXImage allocFromZone:[self zone]] init];
163: if ([image loadFromFile:file]) {
164: [image setDataRetained:YES];
165: if (checkImage(image)) {
166: [image getSize:&originalSize];
167: [image setScalable:YES];
168: bounds.size = originalSize;
169: return [self finishedWithInit];
170: }
171: }
172:
173: [self free];
174:
175: return nil;
176: }
177:
178: - doInitFromImage:(NXImage *)anImage
179: /*
180: * Common code for initFromImage: and unarchiving.
181: */
182: {
183: if (anImage) {
184: image = anImage;
185: [image getSize:&originalSize];
186: [image setScalable:YES];
187: [image setDataRetained:YES];
188: bounds.size = originalSize;
189: } else {
190: [self free];
191: self = nil;
192: }
193: return self;
194: }
195:
196: - initFromImage:(NXImage *)anImage
197: /*
198: * Initializes an Image from a specific NXImage.
199: */
200: {
201: [self init];
202: return [[self doInitFromImage:anImage] finishedWithInit];
203: }
204:
205: - initFromIcon:(NXImage *)anImage
206: /*
207: * Same as initFromImage:, but we remember that this particular
208: * NXImage was actually a file icon (which enables us to double-click
209: * on it to open the icon, see handleEvent:).
210: */
211: {
212: if ([self initFromImage:anImage]) {
213: amIcon = YES;
214: return self;
215: } else {
216: return nil;
217: }
218: }
219:
220: - initWithLinkButton
221: /*
222: * Creates an image which is just the link button.
223: * This is only applicable with Object Links.
224: */
225: {
226: if ([self initFromImage:[[NXImage findImageNamed:"NXLinkButton"] copy]]) {
227: amLinkButton = YES;
228: return self;
229: } else {
230: return nil;
231: }
232: }
233:
234: - (NXRect)resetImage:(NXImage *)newImage
235: /*
236: * Called by the "reinit" methods to reset all of our instance
237: * variables based on using a new NXImage for our image.
238: */
239: {
240: NXRect eBounds, neBounds;
241:
242: [image free];
243: image = newImage;
244: [self getExtendedBounds:&eBounds];
245: [image getSize:&neBounds.size];
246: neBounds.size.width *= bounds.size.width / originalSize.width;
247: neBounds.size.height *= bounds.size.height / originalSize.height;
248: neBounds.origin.x = bounds.origin.x - floor((neBounds.size.width - bounds.size.width) / 2.0 + 0.5);
249: neBounds.origin.y = bounds.origin.y - floor((neBounds.size.height - bounds.size.height) / 2.0 + 0.5);
250: [self setBounds:&neBounds];
251: [self getExtendedBounds:&neBounds];
252: NXUnionRect(&eBounds, &neBounds);
253: [image setDataRetained:YES];
254: [image getSize:&originalSize];
255: [image setScalable:YES];
256:
257: return neBounds;
258: }
259:
260: - (NXRect)reinitFromPasteboard:(Pasteboard *)pboard
261: /*
262: * Reset all of our instance variable based on extract an
263: * NXImage from data in the the passed pboard. Happens when
264: * we update a link through Object Links.
265: */
266: {
267: NXRect neBounds;
268: NXImage *newImage;
269:
270: newImage = [NXImage allocFromZone:[self zone]];
271: if ((newImage = [newImage initFromPasteboard:pboard])) {
272: [newImage setDataRetained:YES];
273: if (checkImage(newImage)) return [self resetImage:newImage];
274: }
275:
276: [newImage free];
277: neBounds.origin.x = neBounds.origin.y = 0.0;
278: neBounds.size.width = neBounds.size.height = 0.0;
279:
280: return neBounds;
281: }
282:
283: - (NXRect)reinitFromFile:(const char *)file
284: /*
285: * Reset all of our instance variable based on extract an
286: * NXImage from the data in the passed file. Happens when
287: * we update a link through Object Links.
288: */
289: {
290: NXRect neBounds;
291: NXImage *newImage;
292:
293: newImage = [[NXImage allocFromZone:[self zone]] init];
294: if ([newImage loadFromFile:file]) {
295: [newImage setDataRetained:YES];
296: if (checkImage(newImage)) return [self resetImage:newImage];
297: }
298:
299: [newImage free];
300: neBounds.origin.x = neBounds.origin.y = 0.0;
301: neBounds.size.width = neBounds.size.height = 0.0;
302:
303: return neBounds;
304: }
305:
306: /* All those allocation/initialization method and only this one free method. */
307:
308: - free
309: {
310: [image free];
311: return [super free];
312: }
313:
314: /* Link methods */
315:
316: - setLink:(NXDataLink *)aLink
317: /*
318: * It's "might" be linked because we're linked now, but might
319: * have our link broken in the future and the mightBeLinked flag
320: * is only advisory and is never cleared. It is used just so that
321: * we know we might want to try to reestablish a link with this
322: * Graphic after a cut/paste. No biggie if there really is no
323: * link associated with this any more. In gvLinks.m, see
324: * readLinkForGraphic:fromPasteboard:useNewIdentifier:, and in
325: * gvPasteboard.m, see pasteFromPasteboard:andLink:at:.
326: * If this Image is a link button, then we obviously never need
327: * to update the link because we don't actually show the data
328: * associated with the link (we just show that little link button).
329: */
330: {
331: NXDataLink *oldLink = link;
332: link = aLink;
333: gFlags.mightBeLinked = YES;
334: if (amLinkButton) [link setUpdateMode:NX_UpdateNever];
335: return oldLink;
336: }
337:
338: - (NXDataLink *)link
339: {
340: return link;
341: }
342:
343: /* Event-handling */
344:
345: - trackLinkButton:(NXEvent *)event at:(const NXPoint *)startPoint inView:(View *)view
346: /*
347: * This method tracks that little link button. Note that the link button is a diamond,
348: * but we track the whole rectangle. This is unfortunate, but we can't be sure that,
349: * in the future, the shape of the link button might not change (thus, what we really
350: * need is a NeXTSTEP function to track the thing!). Anyway, we track it and if the
351: * mouse goes up inside the button, we openSource on the link (we wouldn't be here if
352: * we didn't have a link).
353: */
354: {
355: NXPoint p;
356: NXImage *realImage, *highImage, *imageToDraw;
357:
358: p = *startPoint;
359: realImage = image;
360: highImage = [[self class] highlightedLinkButtonImage:&bounds.size];
361: image = imageToDraw = highImage;
362: [self draw];
363: [[view window] flushWindow];
364: do {
365: event = [NXApp getNextEvent:NX_MOUSEDRAGGEDMASK|NX_MOUSEUPMASK];
366: p = event->location;
367: [view convertPoint:&p fromView:nil];
368: imageToDraw = NXMouseInRect(&p, &bounds, NO) ? highImage : realImage;
369: if (imageToDraw != image) {
370: image = imageToDraw;
371: [self draw];
372: [[view window] flushWindow];
373: }
374: } while (event->type != NX_MOUSEUP);
375:
376: if (imageToDraw == highImage) {
377: [link openSource];
378: image = realImage;
379: [self draw];
380: [[view window] flushWindow];
381: }
382:
383: return self;
384: }
385:
386: - (BOOL)handleEvent:(NXEvent *)event at:(const NXPoint *)p inView:(View *)view
387: {
388: if (NXMouseInRect(p, &bounds, NO)) {
389: if (amLinkButton && !gFlags.selected && !(event->flags & (NX_CONTROLMASK|NX_SHIFTMASK|NX_ALTERNATEMASK))) {
390: [self trackLinkButton:event at:p inView:view];
391: return YES;
392: } else if (link && (event->data.mouse.click == 2) && (amIcon || (event->flags & NX_CONTROLMASK))) {
393: [NXApp getNextEvent:NX_MOUSEUPMASK];
394: [link openSource];
395: return YES;
396: }
397: }
398: return NO;
399: }
400:
401: /* Methods overridden from superclass to support links. */
402:
403: - (int)cornerMask
404: /*
405: * Link buttons are too small to have corners AND sides, so
406: * we only let link buttons have knobbies on the corners.
407: */
408: {
409: if (amLinkButton) {
410: return LOWER_LEFT_MASK|UPPER_LEFT_MASK|UPPER_RIGHT_MASK|LOWER_RIGHT_MASK;
411: } else {
412: return [super cornerMask];
413: }
414: }
415:
416: - (NXRect *)getExtendedBounds:(NXRect *)theRect
417: /*
418: * We have to augment this because we might have a link frame
419: * (if show links is on), so we have to extend our extended bounds
420: * a bit.
421: */
422: {
423: NXRect linkBounds, *retval;
424: float linkFrameThickness = NXLinkFrameThickness();
425:
426: linkBounds = bounds;
427: linkBounds.origin.x -= linkFrameThickness;
428: linkBounds.size.width += linkFrameThickness * 2.0;
429: linkBounds.origin.y -= linkFrameThickness;
430: linkBounds.size.height += linkFrameThickness;
431:
432: retval = [super getExtendedBounds:theRect];
433:
434: return NXUnionRect(&linkBounds, retval);
435: }
436:
437: - (BOOL)constrainByDefault;
438: /*
439: * Icons and link buttons look funny outside their natural
440: * aspect ratio, so we constrain them (by default) to keep
441: * their natural ratio. You can still use the Alternate key
442: * to NOT constrain these.
443: */
444: {
445: return (amLinkButton || amIcon);
446: }
447:
448: /* Methods overridden from superclass */
449:
450: - (BOOL)isValid
451: {
452: return image ? YES : NO;
453: }
454:
455: - (BOOL)isOpaque
456: {
457: return [[image bestRepresentation] isOpaque];
458: }
459:
460: - (float)naturalAspectRatio
461: {
462: if (!originalSize.height) return 0.0;
463: return originalSize.width / originalSize.height;
464: }
465:
466: - draw
467: /*
468: * If we are resizing, we just draw a gray box.
469: * If not, then we simply see if our bounds have changed
470: * and update the NXImage object if they have. Then,
471: * if we do not allow alpha (i.e. this is a TIFF image),
472: * we paint a white background square (we don't allow
473: * alpha in our TIFF images since it won't print and
474: * Draw is WYSIWYG). Finally, we SOVER the image.
475: * If we are not keeping the cache around, we tell
476: * NXImage to toss its cached version of the image
477: * via the message recache.
478: *
479: * If we are linked to something and the user has chosen
480: * "Show Links", then linkOutlinesAreVisible, so we must
481: * draw a link border around ourself.
482: */
483: {
484: NXRect r;
485: NXPoint p;
486: NXSize currentSize;
487:
488: if (bounds.size.width < 1.0 || bounds.size.height < 1.0) return self;
489:
490: if (DrawStatus == Resizing) {
491: PSsetgray(NX_DKGRAY);
492: PSsetlinewidth(0.0);
493: PSrectstroke(bounds.origin.x, bounds.origin.y, bounds.size.width, bounds.size.height);
494: } else if (image) {
495: p = bounds.origin;
496: [image getSize:¤tSize];
497: if (currentSize.width != bounds.size.width || currentSize.height != bounds.size.height) {
498: if ([image isScalable]) {
499: [image setSize:&bounds.size];
500: } else {
501: p.x = bounds.origin.x + floor((bounds.size.width - currentSize.width) / 2.0 + 0.5);
502: p.y = bounds.origin.y + floor((bounds.size.height - currentSize.height) / 2.0 + 0.5);
503: }
504: }
505: if ([[image bestRepresentation] isOpaque]) {
506: PSsetgray(NX_WHITE);
507: NXRectFill(&bounds);
508: }
509: [image composite:NX_SOVER toPoint:&p];
510: if (dontCache && NXDrawingStatus == NX_DRAWING) [image recache];
511: if ((NXDrawingStatus == NX_DRAWING) && !amLinkButton && [[link manager] areLinkOutlinesVisible]) {
512: r.origin.x = floor(bounds.origin.x);
513: r.origin.y = floor(bounds.origin.y);
514: r.size.width = floor(bounds.origin.x + bounds.size.width + 0.99) - r.origin.x;
515: r.size.height = floor(bounds.origin.y + bounds.size.height + 0.99) - r.origin.y;
516: NXFrameLinkRect(&r, YES); // YES means "is a destination link"
517: }
518: }
519:
520: return self;
521: }
522:
523: /* Direct writing of EPS or TIFF. */
524:
525: - (BOOL)canEmitEPS
526: /*
527: * If we have a representation that can provide EPS directly, then,
528: * if we are copying PostScript to the Pasteboard and this Image is the
529: * only Graphic selected, then we might as well just have the EPS which
530: * represents this Image go straight to the Pasteboard rather than
531: * wrapping it up in the copyPSCodeInside: wrappers. Of course, we
532: * can only do that if we haven't been resized.
533: *
534: * See gvPasteboard.m's writePSToStream:.
535: */
536: {
537: List *reps = [image representationList];
538: int i = [reps count];
539:
540: if (originalSize.width == bounds.size.width && originalSize.height == bounds.size.height) {
541: while (i--) {
542: if ([[reps objectAt:i] respondsTo:@selector(getEPS:length:)]) {
543: return YES;
544: }
545: }
546: }
547:
548: return NO;
549: }
550:
551: - writeEPSToStream:(NXStream *)stream
552: /*
553: * If canEmitEPS above returns YES, then we can write ourself out directly
554: * as EPS. This method does that.
555: */
556: {
557: List *reps = [image representationList];
558: int i = [reps count];
559: char *data;
560: int length;
561:
562: while (i--) {
563: if ([[reps objectAt:i] respondsTo:@selector(getEPS:length:)]) {
564: [[reps objectAt:i] getEPS:&data length:&length];
565: NXWrite(stream, data, length);
566: return self; // should I free data before returning?
567: }
568: }
569:
570: return self;
571: }
572:
573: - (BOOL)canEmitTIFF
574: /*
575: * Similar to canEmitEPS, except its for TIFF.
576: */
577: {
578: return (originalSize.width == bounds.size.width && originalSize.height == bounds.size.height);
579: }
580:
581: - writeTIFFToStream:(NXStream *)stream
582: /*
583: * Ditto above.
584: */
585: {
586: [image writeTIFF:stream allRepresentations:YES];
587: return self;
588: }
589:
590: /* Caching. */
591:
592: - setCacheable:(BOOL)flag
593: {
594: dontCache = flag ? NO : YES;
595: return self;
596: }
597:
598: - (BOOL)isCacheable
599: {
600: return !dontCache;
601: }
602:
603: /* Archiving. */
604:
605: - write:(NXTypedStream *)stream
606: /*
607: * All that is needed to archive the NXImage.
608: */
609: {
610: [super write:stream];
611: NXWriteType(stream, "c", &amLinkButton);
612: NXWriteType(stream, "c", &amIcon);
613: if (!amLinkButton) {
614: NXWriteObject(stream, image);
615: NXWriteSize(stream, &originalSize);
616: }
617: return self;
618: }
619:
620: - read:(NXTypedStream *)stream
621: /*
622: * This contains lots of compatibility code for
623: * interim versions. See if you can figure out the
624: * various ways we approached archiving link info!
625: */
626: {
627: BOOL alphaOk;
628: NXRect savedBounds;
629: int version, linkNumber;
630:
631: [super read:stream];
632: version = NXTypedStreamClassVersion(stream, "Image");
633: if (version > 5) NXReadType(stream, "c", &amLinkButton);
634: if (version > 6) NXReadType(stream, "c", &amIcon);
635: if (amLinkButton) {
636: savedBounds = bounds;
637: [self doInitFromImage:[[NXImage findImageNamed:"NXLinkButton"] copy]];
638: bounds = savedBounds;
639: } else {
640: image = NXReadObject(stream);
641: NXReadSize(stream, &originalSize);
642: }
643: if (version <= 2) NXReadTypes(stream, "c", &alphaOk);
644: if (version == 4) {
645: NXReadObject(stream); // used to be the NXDataLink
646: } else if (version > 2 && version < 6) {
647: NXReadTypes(stream, "i", &linkNumber);
648: }
649:
650: return self;
651: }
652:
653: @end
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.