![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to gvLinks.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 gvLinks.m CVS log | Up to [NeXTSTEP 3.3 examples] / Examples / AppKit / Draw |
1.1 root 1: #import "draw.h"
2:
3: @implementation GraphicView(Links)
4:
5: /* See the Links.rtf file for overview about Object Links in Draw. */
6:
7: #define BUFFER_SIZE 1100
8: #define INT_WIDTH 11
9:
10: /*
11: * Returns an NXSelection describe the current Graphic's selected in the view.
12: * If the user did Select All, then the gvFlags.selectAll bit is set and we
13: * return the allSelection NXSelection. If the user dragged out a rectangle,
14: * then the dragRect rectangle is set and we return a ByRect NXSelection.
15: * Otherwise, we return a ByGraphic NXSelection.
16: *
17: * We use the writeIdentifierTo: mechanism so that Group Graphic's can ask
18: * their components to write out all their identifiers so that we have a
19: * maximal chance of getting all the objects.
20: */
21:
22: - (NXSelection *)currentSelection
23: {
24: NXRect sbounds;
25: int i, graphicCount;
26: NXSelection *retval = nil;
27: char *s, *selbuf, buffer[BUFFER_SIZE];
28:
29: if (![slist count]) return [NXSelection emptySelection];
30:
31: if (gvFlags.selectAll) {
32: if ([slist count] == [glist count]) {
33: return [NXSelection allSelection];
34: } else {
35: gvFlags.selectAll = NO;
36: }
37: }
38:
39: if (dragRect) {
40: sbounds = *dragRect;
41: sprintf(buffer, "%d %d %d %d %d", ByRect,
42: (int)sbounds.origin.x, (int)sbounds.origin.y,
43: (int)(sbounds.size.width+0.5), (int)(sbounds.size.height+0.5));
44: selbuf = buffer;
45: } else {
46: graphicCount = 0;
47: i = [slist count];
48: while (i--) graphicCount += [[slist objectAt:i] graphicCount];
49: if (graphicCount > (BUFFER_SIZE / INT_WIDTH)) {
50: NX_MALLOC(selbuf, char, graphicCount * INT_WIDTH);
51: } else {
52: selbuf = buffer;
53: }
54: sprintf(buffer, "%d %d", ByList, graphicCount);
55: s = selbuf + strlen(selbuf);
56: i = [slist count];
57: while (i--) {
58: *s++ = ' ';
59: [[slist objectAt:i] writeIdentifierTo:s];
60: s += strlen(s);
61: }
62: }
63:
64: retval = [[NXSelection allocFromZone:[self zone]] initWithDescription:selbuf length:strlen(selbuf)+1];
65:
66: if (selbuf != buffer) free(selbuf);
67:
68: return retval;
69: }
70:
71: /*
72: * Used for destination selections only.
73: * Just extracts the unique identifier for the destination Image
74: * or TextGraphic and then searches through the glist to find that
75: * Graphic and returns it.
76: *
77: * Again, we use the graphicIdentifiedBy: mechanism so that we
78: * descend into Group's of Graphics to find a destination.
79: */
80:
81: - (Graphic *)findGraphicInSelection:(NXSelection *)selection
82: {
83: int i;
84: Graphic *graphic;
85: const char *selectionInfo;
86: int selectionInfoLength, identifier, selectionType;
87:
88: selectionInfo = [selection descriptionOfLength:&selectionInfoLength];
89: if (selectionInfo) {
90: sscanf(selectionInfo, "%d %d", &selectionType, &identifier);
91: if (selectionType == ByGraphic) {
92: for (i = [glist count]-1; i >= 0; i--) {
93: if (graphic = [[glist objectAt:i] graphicIdentifiedBy:identifier]) return graphic;
94: }
95: }
96: }
97:
98: return nil;
99: }
100:
101: /*
102: * Returns YES and theRect is valid only if the selection is one which
103: * the user created by dragging out a rectangle.
104: */
105:
106: - (BOOL)getRect:(NXRect *)theRect forSelection:(NXSelection *)selection
107: {
108: NXRect stackRect;
109: const char *selectionInfo;
110: int selectionInfoLength;
111: DrawSelectionType selectionType;
112:
113: if (selectionInfo = [selection descriptionOfLength:&selectionInfoLength]) {
114: if (!theRect) theRect = &stackRect;
115: sscanf(selectionInfo, "%d %f %f %f %f", (int *)&selectionType,
116: &(theRect->origin.x), &(theRect->origin.y),
117: &(theRect->size.width), &(theRect->size.height));
118: if (selectionType == ByRect) return YES;
119: }
120:
121: return NO;
122: }
123:
124: /*
125: * For source selections only.
126: * Returns the list of Graphics in the current document which were
127: * in the selection passed to this method. Note that any Group
128: * which includes a Graphic in the passed selection will be included
129: * in its entirety.
130: */
131:
132: - (List *)findGraphicsInSelection:(NXSelection *)selection
133: {
134: int i, count;
135: Graphic *graphic;
136: List *list = nil;
137: NXRect sBounds, gBounds;
138: int selectionInfoLength;
139: const char *s, *theGraphics;
140: DrawSelectionType selectionType;
141:
142: if ([selection isEqual:[NXSelection allSelection]]) {
143: count = [glist count];
144: list = [[List allocFromZone:[self zone]] initCount:count];
145: for (i = 0; i < count; i++) [list addObject:[glist objectAt:i]];
146: } else if ([self getRect:&sBounds forSelection:selection]) {
147: count = [glist count];
148: list = [[List allocFromZone:[self zone]] init];
149: for (i = 0; i < count; i++) {
150: graphic = [glist objectAt:i];
151: [graphic getBounds:&gBounds];
152: NXInsetRect(&gBounds, -0.1, -0.1);
153: if (NXIntersectsRect(&gBounds, &sBounds)) [list addObject:graphic];
154: }
155: } else if (s = [selection descriptionOfLength:&selectionInfoLength]) {
156: sscanf(s, "%d %d", (int *)&selectionType, &count);
157: if (selectionType == ByList) {
158: if (s = strchr(s, ' ')) s = strchr(s+1, ' ');
159: if (s++) {
160: theGraphics = s;
161: list = [[List allocFromZone:[self zone]] init];
162: count = [glist count];
163: for (i = 0; i < count; i++) {
164: graphic = [glist objectAt:i];
165: s = theGraphics;
166: while (s && *s) {
167: if ([graphic graphicIdentifiedBy:atoi(s)]) {
168: [list addObject:graphic];
169: break;
170: }
171: if (s = strchr(s, ' ')) s++;
172: }
173: }
174: }
175: }
176: }
177:
178: if (![list count]) {
179: [list free];
180: list = nil;
181: }
182:
183: return list;
184: }
185:
186: /*
187: * Importing/Exporting links.
188: */
189:
190: /*
191: * This method is called by copyToPasteboard:. It just puts a link to the currentSelection
192: * (presumably just written to the pasteboard by copyToPasteboard:) into the specified
193: * pboard. Note that it only does all this if we are writing all possible types to the
194: * pasteboard (typesList == NULL) or if we explicitly ask for the link to be written
195: * (typesList includes NXDataLinkPboardType).
196: */
197:
198: - writeLinkToPasteboard:(Pasteboard *)pboard types:(const NXAtom *)typesList
199: {
200: NXDataLink *link;
201:
202: if (linkManager && (!typesList || IncludesType(typesList, NXDataLinkPboardType))) {
203: if (link = [[NXDataLink alloc] initLinkedToSourceSelection:[self currentSelection] managedBy:linkManager supportingTypes:TypesDrawExports() count:NUM_TYPES_DRAW_EXPORTS]) {
204: [pboard addTypes:&NXDataLinkPboardType num:1 owner:[self class]];
205: [link writeToPasteboard:pboard];
206: [link free];
207: }
208: [linkManager writeLinksToPasteboard:pboard]; // for embedded linked things
209: }
210:
211: return self;
212: }
213:
214: /*
215: * Sets up a link from the Draw document to another document.
216: * This is called by the drag stuff (gvDrag.m) and the normal copy/paste stuff (gvPasteboard.m).
217: * We allow for the case of graphic being nil as long as the link is capable of supplying
218: * data of a type we can handle (currently Text or Image).
219: */
220:
221: - (BOOL)addLink:(NXDataLink *)link toGraphic:(Graphic *)graphic at:(const NXPoint *)p update:(int)update
222: {
223: NXSelection *selection = nil;
224:
225: if (!graphic && link && update != UPDATE_NEVER) {
226: if (TextPasteType([link types])) {
227: graphic = [[TextGraphic allocFromZone:[self zone]] initEmpty];
228: } else if (MatchTypes([link types], [NXImage imagePasteboardTypes])) {
229: graphic = [[Image allocFromZone:[self zone]] initEmpty];
230: }
231: update = UPDATE_IMMEDIATELY;
232: }
233:
234: if (graphic && link) {
235: selection = [graphic selection];
236: if ([linkManager addLink:link at:selection]) {
237: if (!update) [link setUpdateMode:NX_UpdateNever];
238: [graphic setLink:link];
239: if (graphic = [self placeGraphic:graphic at:p]) {
240: if (update == UPDATE_IMMEDIATELY) {
241: [link updateDestination];
242: graphic = [self findGraphicInSelection:selection];
243: if (![graphic isValid]) {
244: NXRunLocalizedAlertPanel(NULL, "Import Link",
245: "Unable to import linked data.", NULL, NULL, NULL,
246: "Message given to user when import of linked data fails.");
247: [self removeGraphic:graphic];
248: } else {
249: return YES;
250: }
251: } else {
252: return YES;
253: }
254: }
255: }
256: }
257:
258: [link free];
259: [selection free];
260: [graphic free];
261:
262: return NO;
263: }
264:
265: /*
266: * Keeping links up to date.
267: * These methods are called either to update a link that draw has to another
268: * document or to cause Draw to update another document that is linked to it.
269: */
270:
271: /*
272: * Sent whenever NeXTSTEP wants us to update some data in our document which
273: * we get by being linked to some other document.
274: */
275:
276: - pasteFromPasteboard:(Pasteboard *)pboard at:(NXSelection *)selection
277: {
278: id graphic;
279: NXRect gBounds;
280:
281: if (graphic = [self findGraphicInSelection:selection]) {
282: gBounds = [graphic reinitFromPasteboard:pboard];
283: [self cache:&gBounds]; // updating a destination link
284: [window flushWindow];
285: [self dirty];
286: return self;
287: }
288:
289: return nil;
290: }
291:
292: /*
293: * Lazy pasteboard method for cheapCopyAllowed case ONLY.
294: * See copyToPasteboard:at:cheapCopyAllowed: below.
295: */
296:
297: - pasteboard:(Pasteboard *)sender provideData:(const char *)type
298: {
299: List *list;
300: NXStream *stream;
301: NXSelection *selection;
302:
303: selection = [[NXSelection allocFromZone:[self zone]] initFromPasteboard:sender];
304: list = [self findGraphicsInSelection:selection];
305: if (list && (stream = NXOpenMemory(NULL, 0, NX_WRITEONLY))) {
306: if (type == NXPostScriptPboardType) {
307: [self writePSToStream:stream usingList:list];
308: } else if (type == NXTIFFPboardType) {
309: [self writeTIFFToStream:stream usingList:list];
310: }
311: [sender writeType:type fromStream:stream];
312: NXCloseMemory(stream, NX_FREEBUFFER);
313: }
314: [list free];
315: [selection free];
316:
317: return self;
318: }
319:
320: /*
321: * Called by NeXTSTEP when some other document needs to be updated because
322: * they are linked to something in our document.
323: */
324:
325: - copyToPasteboard:(Pasteboard *)pboard at:(NXSelection *)selection cheapCopyAllowed:(BOOL)cheapCopyAllowed
326: {
327: List *list;
328: NXStream *stream;
329: NXTypedStream *ts;
330: id retval = self;
331: const char *types[3];
332:
333: types[1] = NXPostScriptPboardType;
334: types[2] = NXTIFFPboardType;
335:
336: if (cheapCopyAllowed) {
337: if (list = [self findGraphicsInSelection:selection]) {
338: types[0] = NXSelectionPboardType;
339: [pboard declareTypes:types num:3 owner:self];
340: [selection writeToPasteboard:pboard];
341: } else {
342: retval = nil;
343: }
344: [list free];
345: } else {
346: types[0] = DrawPboardType;
347: [pboard declareTypes:types num:3 owner:[self class]];
348: list = [self findGraphicsInSelection:selection];
349: if (list && (stream = NXOpenMemory(NULL, 0, NX_WRITEONLY))) {
350: if (ts = NXOpenTypedStream(stream, NX_WRITEONLY)) {
351: NXWriteRootObject(ts, list);
352: NXCloseTypedStream(ts);
353: }
354: [pboard writeType:DrawPboardType fromStream:stream];
355: NXCloseMemory(stream, NX_FREEBUFFER);
356: } else {
357: retval = nil;
358: }
359: [list free];
360: }
361:
362: return retval;
363: }
364:
365:
366: /*
367: * Supports linking to an entire file (not just a selection therein).
368: * This occurs when you drag a file into Draw and link (see gvDrag).
369: * This is very analogous to the pasteFromPasteboard:at: above.
370: */
371:
372: - importFile:(const char *)filename at:(NXSelection *)selection
373: {
374: id graphic;
375: NXRect gBounds;
376:
377: if (graphic = [self findGraphicInSelection:selection]) {
378: gBounds = [graphic reinitFromFile:filename];
379: [self cache:&gBounds]; // updating a link to an imported file
380: [window flushWindow];
381: [self dirty];
382: return self;
383: }
384:
385: return nil;
386: }
387:
388: /* Other Links methods */
389:
390: /*
391: * Just makes the Link Inspector panel reflect whether any of the
392: * Graphic's currently selected are linked to some other document.
393: */
394:
395: - updateLinksPanel
396: {
397: int i, linkCount = 0;
398: Graphic *foundGraphic = nil, *graphic = nil;
399:
400: if (linkManager) {
401: for (i = [slist count]-1; i >= 0; i--) {
402: if (graphic = [[slist objectAt:i] graphicLinkedBy:NULL]) {
403: if ([graphic isKindOf:[Group class]]) {
404: linkCount += 2;
405: break;
406: } else {
407: linkCount += 1;
408: foundGraphic = graphic;
409: }
410: }
411: }
412: if (linkCount == 1) {
413: [NXDataLinkPanel setLink:[foundGraphic link] andManager:linkManager isMultiple:NO];
414: } else if (linkCount) {
415: [NXDataLinkPanel setLink:[foundGraphic link] andManager:linkManager isMultiple:YES];
416: } else {
417: [NXDataLinkPanel setLink:nil andManager:linkManager isMultiple:NO];
418: }
419: }
420:
421: return self;
422: }
423:
424: - (NXDataLinkManager *)linkManager
425: {
426: return linkManager;
427: }
428:
429: /*
430: * When we get a linkManager via this method, we must go and revive all the links.
431: * This is due to the fact that we don't archive ANY link information when we
432: * save a Draw document. However, the unique identifiers ARE archived, and thus,
433: * when we unarchive, we can recreate NXSelections with those unique identifiers
434: * and then ask the NXDataLinkManager for the link objects associated with those
435: * NXSelections.
436: *
437: * After we have revived all the links, we call breakLinkAndRedrawOutlines:
438: * with nil (meaning redraw the link outlines for all links).
439: */
440:
441: - setLinkManager:(NXDataLinkManager *)aLinkManager
442: {
443: if (!linkManager) {
444: linkManager = aLinkManager;
445: [glist makeObjectsPerform:@selector(reviveLink:) with:linkManager];
446: [self breakLinkAndRedrawOutlines:nil];
447: }
448: return self;
449: }
450:
451: /*
452: * This is called when the user chooses Open Source.
453: * It uses the trick of drawing directly into the GraphicView
454: * which, of course, is only ephemeral since the REAL contents
455: * of the GraphicView are stored in the backing store.
456: * This is convenient because Open Source is only a temporary
457: * the the user calls to see where the data for his link is
458: * coming from.
459: */
460:
461: - showSelection:(NXSelection *)selection
462: {
463: id retval = self;
464: List *graphics = nil;
465: NXRect *newInvalidRect;
466: NXRect sBounds, linkBounds;
467:
468: [self lockFocus];
469: if (invalidRect) {
470: [self drawSelf:invalidRect :1];
471: newInvalidRect = invalidRect;
472: invalidRect = NULL;
473: } else{
474: NX_MALLOC(newInvalidRect, NXRect, 1);
475: }
476: if ([self getRect:&linkBounds forSelection:selection]) {
477: PSsetgray(NX_LTGRAY);
478: NXFrameRectWithWidth(&linkBounds, 2.0);
479: *newInvalidRect = linkBounds;
480: graphics = [self findGraphicsInSelection:selection];
481: if (graphics) {
482: [self getBBox:&sBounds of:graphics];
483: NXUnionRect(&sBounds, newInvalidRect);
484: } else {
485: invalidRect = newInvalidRect;
486: [self scrollRectToVisible:invalidRect];
487: [window flushWindow];
488: retval = nil;
489: }
490: } else {
491: graphics = [self findGraphicsInSelection:selection];
492: if (graphics) {
493: [self getBBox:&sBounds of:graphics];
494: *newInvalidRect = sBounds;
495: } else {
496: retval = nil;
497: }
498: }
499:
500: if (retval) {
501: NXFrameLinkRect(&sBounds, NO);
502: invalidRect = newInvalidRect;
503: NXInsetRect(invalidRect, -NXLinkFrameThickness(), -NXLinkFrameThickness());
504: [self scrollRectToVisible:invalidRect];
505: [window flushWindow];
506: }
507:
508: [self unlockFocus];
509: [graphics free];
510:
511: return retval;
512: }
513:
514: /*
515: * Called when the Show Links button in the Link Inspector panel is clicked
516: * (the link argument will be nil in this case), or when a link is broken
517: * (the link argument will be the link that was broken).
518: */
519:
520: - breakLinkAndRedrawOutlines:(NXDataLink *)link
521: {
522: int i;
523: Graphic *graphic;
524: BOOL gotOne = NO;
525: NXRect eBounds, recacheBounds;
526:
527: for (i = [glist count]-1; i >= 0; i--) {
528: graphic = [glist objectAt:i];
529: if (graphic = [graphic graphicLinkedBy:link]) {
530: if (link && ([graphic link] == link) &&
531: ([link updateMode] == NX_UpdateNever)) {
532: [self removeGraphic:graphic];
533: }
534: if (!link || [linkManager areLinkOutlinesVisible]) {
535: [graphic getExtendedBounds:&eBounds];
536: if (gotOne) {
537: NXUnionRect(&eBounds, &recacheBounds);
538: } else {
539: recacheBounds = eBounds;
540: gotOne = YES;
541: }
542: }
543: }
544: }
545: if (gotOne) {
546: [self cache:&recacheBounds andUpdateLinks:NO];
547: [window flushWindow];
548: }
549:
550: return self;
551: }
552:
553: /*
554: * Tracking Link Changes.
555: *
556: * This is how we get "Continuous" updating links.
557: *
558: * We simply assume that a thing someone is linked to in our document
559: * changes whenever we have to redraw any rectangle in the GraphicView
560: * which intersects the linked-to rectangle. See cache:andUpdateLinks:
561: * in GraphicView.m.
562: */
563:
564: typedef struct {
565: NXRect linkRect;
566: NXDataLink *link;
567: BOOL dragged, all;
568: } LinkRect;
569:
570: - updateTrackedLinks:(const NXRect *)sRect
571: {
572: int i;
573: LinkRect *lr;
574: List *graphics;
575: NXSelection *selection;
576: NXRect *lRect, newRect;
577:
578: for (i = [linkTrackingRects count]-1; i >= 0; i--) {
579: if (NXIntersectsRect(sRect, (NXRect *)[linkTrackingRects elementAt:i])) {
580: lr = ((LinkRect *)[linkTrackingRects elementAt:i]);
581: [lr->link sourceEdited];
582: lRect = (NXRect *)[linkTrackingRects elementAt:i];
583: if (!lr->dragged && !lr->all && !NXContainsRect(lRect, sRect)) {
584: selection = [lr->link sourceSelection];
585: if (graphics = [self findGraphicsInSelection:selection]) {
586: [self getBBox:&newRect of:graphics];
587: *lRect = newRect;
588: [graphics free];
589: }
590: }
591: }
592: }
593:
594: return self;
595: }
596:
597: /* Add to linkTrackingRects. */
598:
599: - startTrackingLink:(NXDataLink *)link
600: {
601: LinkRect trackRect;
602: List *graphics = nil;
603: NXSelection *selection;
604: BOOL all = NO, dragged = NO, piecemeal = NO;
605:
606: selection = [link sourceSelection];
607: if ([selection isEqual:[NXSelection allSelection]]) {
608: all = YES;
609: trackRect.linkRect = bounds;
610: } else if ([self getRect:&trackRect.linkRect forSelection:selection]) {
611: dragged = YES;
612: } else if (graphics = [self findGraphicsInSelection:selection]) {
613: [self getBBox:&trackRect.linkRect of:graphics];
614: piecemeal = YES;
615: [graphics free];
616: } else {
617: return nil;
618: }
619:
620: if (all || dragged || piecemeal) {
621: if (!linkTrackingRects) {
622: linkTrackingRects = [[Storage allocFromZone:[self zone]] initCount:1 elementSize:sizeof(LinkRect) description:"{ffff@}"];
623: }
624: [self stopTrackingLink:link];
625: trackRect.link = link;
626: trackRect.dragged = dragged;
627: trackRect.all = all;
628: [linkTrackingRects addElement:&trackRect];
629: }
630:
631: return nil;
632: }
633:
634: /* Remove from linkTrackingRects. */
635:
636: - stopTrackingLink:(NXDataLink *)link
637: {
638: int i;
639:
640: for (i = [linkTrackingRects count]-1; i >= 0; i--) {
641: if (((LinkRect *)[linkTrackingRects elementAt:i])->link == link) {
642: [linkTrackingRects removeElementAt:i];
643: return self;
644: }
645: }
646:
647: return nil;
648: }
649:
650: @end
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.