Return to Group.m CVS log

Up to [NeXTSTEP 3.3 examples] / Examples / AppKit / Draw

Annotation of Examples/AppKit/Draw/Group.m, revision 1.1

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 entirely on one line w/o wrapping. */
        !             4: 
        !             5: #define GROUP_CACHE_THRESHOLD 4
        !             6: 
        !             7: @implementation Group : Graphic
        !             8: /*
        !             9:  * This Graphic is used to create heirarchical groups of other Graphics.
        !            10:  * It simply keeps a list of all the Graphics in the group and resizes
        !            11:  * and translates them as the Group object itself is resized and moved.
        !            12:  * It also passes messages sent to the Group onto its members.
        !            13:  *
        !            14:  * For efficiency, we cache the group whenever it passes the caching
        !            15:  * threshold.  Thus, grouping becomes a tool to let the user have some
        !            16:  * control over the memory/speed tradeoff (which can be different
        !            17:  * depending on the kind of drawing the user is making).
        !            18:  */
        !            19: 
        !            20: /* Factory method */
        !            21: 
        !            22: + initialize
        !            23: /*
        !            24:  * This bumps the class version so that we can compatibly read
        !            25:  * old Graphic objects out of an archive.
        !            26:  */
        !            27: {
        !            28:     [Group setVersion:3];
        !            29:     return self;
        !            30: }
        !            31: 
        !            32: /* Initialization */
        !            33: 
        !            34: - initList:(List *)list
        !            35: /*
        !            36:  * Creates a new grouping with list containing the list of Graphics
        !            37:  * in the group.  Groups of Groups is perfectly allowable.  We have
        !            38:  * to keep track of the largest linewidth in the group as well as
        !            39:  * whether any of the elements of the group have arrows since both
        !            40:  * of those attributes affect the extended bounds of the Group.
        !            41:  * We set any objects which might be cacheing (notably subgroups of
        !            42:  * this group) to be not cacheable since it is no use for them to
        !            43:  * cache themselves when we are caching them as well.  We also have
        !            44:  * to check to see if there are any TextGraphic's in the group
        !            45:  * because we can't cache ourselves if there are (unfortunately).
        !            46:  */
        !            47: {
        !            48:     int i;
        !            49:     NXRect r;
        !            50:     Graphic *graphic;
        !            51: 
        !            52:     [super init];
        !            53: 
        !            54:     gFlags.mightBeLinked = YES;
        !            55:     i = [list count];
        !            56:     graphic = [list objectAt:--i];
        !            57:     [graphic getBounds:&bounds];
        !            58:     gFlags.arrow = [graphic lineArrow];
        !            59:     linewidth = [graphic lineWidth];
        !            60:     bounds.size.width = MAX(1.0, bounds.size.width);
        !            61:     bounds.size.height = MAX(1.0, bounds.size.height);
        !            62:     while (i) {
        !            63:        graphic = [list objectAt:--i];
        !            64:        [graphic getBounds:&r];
        !            65:        [graphic setCacheable:NO];
        !            66:        r.size.width = MAX(1.0, r.size.width);
        !            67:        r.size.height = MAX(1.0, r.size.height);
        !            68:        NXUnionRect(&r, &bounds);
        !            69:        if (!gFlags.arrow && [graphic lineArrow]) gFlags.arrow = [graphic lineArrow];
        !            70:        if ([graphic lineWidth] > linewidth) linewidth = [graphic lineWidth];
        !            71:        if ([graphic isKindOf:[TextGraphic class]] || ([graphic isKindOf:[Group class]] && [(Group *)graphic hasTextGraphic])) hasTextGraphic = YES;
        !            72:     }
        !            73: 
        !            74:     components = list;
        !            75:     lastRect = bounds;
        !            76: 
        !            77:     return self;
        !            78: }
        !            79: 
        !            80: - free
        !            81: {
        !            82:     [components freeObjects];
        !            83:     [components free];
        !            84:     [cache free];
        !            85:     return [super free];
        !            86: }
        !            87: 
        !            88: /* Public methods */
        !            89: 
        !            90: - transferSubGraphicsTo:(List *)list at:(int)position
        !            91: /*
        !            92:  * Called by Ungroup.  This just unloads the components into the
        !            93:  * passed list, modifying the bounds of each of the Graphics
        !            94:  * accordingly (remember that when a Graphic joins a Group, its
        !            95:  * bounds are still kept in GraphicView coordinates (not
        !            96:  * Group-relative coordinates), but they may be non-integral,
        !            97:  * we can't allow non-integral bounds outside a group because
        !            98:  * it conflicts with the compositing rules (and we use
        !            99:  * compositing to move graphics around).
        !           100:  */
        !           101: {
        !           102:     int i, count;
        !           103:     Graphic *graphic;
        !           104:     NXRect gbounds;
        !           105:     BOOL zeroWidth, zeroHeight;
        !           106: 
        !           107:     count = [components count];
        !           108:     for (i = (count - 1); i >= 0; i--) {
        !           109:        graphic = [components objectAt:i];
        !           110:        [graphic getBounds:&gbounds];
        !           111:        if (!gbounds.size.width) {
        !           112:            zeroWidth = YES;
        !           113:            gbounds.size.width = 1.0;
        !           114:        } else zeroWidth = NO;
        !           115:        if (!gbounds.size.height) {
        !           116:            zeroHeight = YES;
        !           117:            gbounds.size.height = 1.0;
        !           118:        } else zeroHeight = NO;
        !           119:        NXIntegralRect(&gbounds);
        !           120:        if (zeroWidth) gbounds.size.width = 0.0;
        !           121:        if (zeroHeight) gbounds.size.height = 0.0;
        !           122:        [graphic setBounds:&gbounds];
        !           123:        [graphic setCacheable:YES];
        !           124:        [list insertObject:graphic at:position];
        !           125:     }
        !           126: 
        !           127:     return self;
        !           128: }
        !           129: 
        !           130: - (List *)subGraphics
        !           131: {
        !           132:     return components;
        !           133: }
        !           134: 
        !           135: /* Group must override all the setting routines to forward to components */
        !           136: 
        !           137: - makeGraphicsPerform:(SEL)aSelector with:(const void *)anArgument
        !           138: {
        !           139:     [components makeObjectsPerform:aSelector with:(id)anArgument];
        !           140:     [cache free];
        !           141:     cache = nil;
        !           142:     return self;
        !           143: }
        !           144: 
        !           145: - changeFont:sender
        !           146: {
        !           147:     return [self makeGraphicsPerform:@selector(changeFont:) with:sender];
        !           148: }
        !           149: 
        !           150: - (Font *)font
        !           151: {
        !           152:     int i;
        !           153:     Font *gfont, *font = nil;
        !           154: 
        !           155:     i = [components count];
        !           156:     while (i--) {
        !           157:        gfont = [[components objectAt:i] font];
        !           158:        if (gfont) {
        !           159:            if (font && font != gfont) {
        !           160:                font = nil;
        !           161:                break;
        !           162:            } else {
        !           163:                font = gfont;
        !           164:            }
        !           165:        }
        !           166:     }
        !           167: 
        !           168:     return font;
        !           169: }
        !           170: 
        !           171: - setLineWidth:(const float *)value
        !           172: {
        !           173:     return [self makeGraphicsPerform:@selector(setLineWidth:) with:value];
        !           174: }
        !           175: 
        !           176: - setGray:(const float *)value
        !           177: {
        !           178:     return [self makeGraphicsPerform:@selector(setGray:) with:value];
        !           179: }
        !           180: 
        !           181: - setFillColor:(NXColor *)aColor
        !           182: {
        !           183:     return [self makeGraphicsPerform:@selector(setFillColor:) with:aColor];
        !           184: }
        !           185: 
        !           186: - setFill:(int)mode
        !           187: {
        !           188:     return [self makeGraphicsPerform:@selector(setFill:) with:(void *)mode];
        !           189: }
        !           190: 
        !           191: - setLineColor:(NXColor *)aColor
        !           192: {
        !           193:     return [self makeGraphicsPerform:@selector(setLineColor:) with:aColor];
        !           194: }
        !           195: 
        !           196: - setLineCap:(int)value
        !           197: {
        !           198:     return [self makeGraphicsPerform:@selector(setLineCap:) with:(void *)value];
        !           199: }
        !           200: 
        !           201: - setLineArrow:(int)value
        !           202: {
        !           203:     return [self makeGraphicsPerform:@selector(setLineArrow:) with:(void *)value];
        !           204: }
        !           205: 
        !           206: - setLineJoin:(int)value
        !           207: {
        !           208:     return [self makeGraphicsPerform:@selector(setLineJoin:) with:(void *)value];
        !           209: }
        !           210: 
        !           211: /* Link methods */
        !           212: 
        !           213: /*
        !           214:  * Called after unarchiving and after a linkManager has been created for
        !           215:  * the document this Graphic is in.  Graphic's implementation of this just
        !           216:  * adds the link to the linkManager.
        !           217:  */
        !           218: 
        !           219: - reviveLink:(NXDataLinkManager *)linkManager
        !           220: {
        !           221:     [components makeObjectsPerform:@selector(reviveLink:) with:linkManager];
        !           222:     return self;
        !           223: }
        !           224: 
        !           225: /*
        !           226:  * This returns self if there is more than one linked Graphic in the Group.
        !           227:  * If aLink is not nil, returns the Graphic which is linked by that link.
        !           228:  * If aLink is nil, then it returns the one and only linked Graphic in the
        !           229:  * group or nil otherwise.  Used when updating the link panel and when
        !           230:  * redrawing link outlines.
        !           231:  */
        !           232: 
        !           233: - (Graphic *)graphicLinkedBy:(NXDataLink *)aLink
        !           234: {
        !           235:     int i, linkCount = 0;
        !           236:     Graphic *graphic = nil;
        !           237: 
        !           238:     for (i = [components count]-1; i >= 0; i--) {
        !           239:        if (graphic = [[components objectAt:i] graphicLinkedBy:aLink]) {
        !           240:            if ([graphic isKindOf:[Group class]]) return graphic;
        !           241:            linkCount++;
        !           242:        }
        !           243:     }
        !           244: 
        !           245:     return (linkCount <= 1) ? graphic : self;
        !           246: }
        !           247: 
        !           248: /*
        !           249:  * When you copy/paste a Graphic, its identifier must be reset to something
        !           250:  * different since you don't want the pasted one to have the same identifier
        !           251:  * as the copied one!  See gvPasteboard.m.
        !           252:  */
        !           253: 
        !           254: - resetIdentifier
        !           255: {
        !           256:     [components makeObjectsPerform:@selector(resetIdentifier)];
        !           257:     return self;
        !           258: }
        !           259: 
        !           260: /*
        !           261:  * Used when creating an NXSelection representing all the Graphics
        !           262:  * in a selection.  Has to recurse through Groups because you still
        !           263:  * want the NXSelection to be valid even if the Graphics are ungrouped
        !           264:  * in the interim between the time the selection is determined to the
        !           265:  * time the links stuff asks questions about the selection later.
        !           266:  */
        !           267: 
        !           268: - writeIdentifierTo:(char *)buffer
        !           269: {
        !           270:     int i = [components count];
        !           271:     char *s = buffer;
        !           272: 
        !           273:     if (i) {
        !           274:        [[components objectAt:--i] writeIdentifierTo:s];
        !           275:        s += strlen(s);
        !           276:        while (i--) {
        !           277:            *s++ = ' ';
        !           278:            [[components objectAt:i] writeIdentifierTo:s];
        !           279:            s += strlen(s);
        !           280:        }
        !           281:     }
        !           282: 
        !           283:     return self;
        !           284: }
        !           285: 
        !           286: /*
        !           287:  * This is used by the links stuff to allocate a buffer big enough to
        !           288:  * put all the identifiers for all the graphics in this Group into.
        !           289:  */
        !           290: 
        !           291: - (int)graphicCount
        !           292: {
        !           293:     int count = 0, i = [components count];
        !           294:     while (i--) count += [[components objectAt:i] graphicCount];
        !           295:     return count;
        !           296: }
        !           297: 
        !           298: /*
        !           299:  * See the method findGraphicInSelection: in gvLinks.m to see how this
        !           300:  * method is used (it basically just lets you get back to a Graphic
        !           301:  * from its identifier whether its in a Group or not).
        !           302:  */
        !           303: 
        !           304: - (Graphic *)graphicIdentifiedBy:(int)anIdentifier
        !           305: {
        !           306:     int i = [components count];
        !           307:     while (i--) {
        !           308:        Graphic *graphic = [components objectAt:i];
        !           309:        if (graphic = [graphic graphicIdentifiedBy:anIdentifier]) return graphic;
        !           310:     }
        !           311:     return nil;
        !           312: }
        !           313: 
        !           314: /*
        !           315:  * We pass this method onto all the things inside the group since
        !           316:  * there might be linked things inside the group.
        !           317:  */
        !           318: 
        !           319: - readLinkFromPasteboard:(Pasteboard *)pboard usingManager:(NXDataLinkManager *)linkManager useNewIdentifier:(BOOL)useNewIdentifier
        !           320: {
        !           321:     int i = [components count];
        !           322:     while (i--) {
        !           323:        Graphic *graphic = [components objectAt:i];
        !           324:        if ([graphic mightBeLinked]) [graphic readLinkFromPasteboard:pboard usingManager:linkManager useNewIdentifier:useNewIdentifier];
        !           325:     }
        !           326:     return nil;
        !           327: }
        !           328: 
        !           329: /* Form Entry methods.  See TextGraphic.m for details. */
        !           330: 
        !           331: - (BOOL)hasFormEntries
        !           332: {
        !           333:     int i = [components count];
        !           334:     while (i--) if ([[components objectAt:i] hasFormEntries]) return YES;
        !           335:     return NO;
        !           336: }
        !           337: 
        !           338: - (BOOL)writeFormEntryToStream:(NXStream *)stream
        !           339: {
        !           340:     BOOL retval = NO;
        !           341:     int i = [components count];
        !           342:     while (i--) if ([[components objectAt:i] writeFormEntryToStream:stream]) retval = YES;
        !           343:     return retval;
        !           344: }
        !           345: 
        !           346: /* Notification methods */
        !           347: 
        !           348: - wasRemovedFrom:(GraphicView *)sender
        !           349: {
        !           350:     [components makeObjectsPerform:@selector(wasRemovedFrom:) with:sender];
        !           351:     [cache free];
        !           352:     cache = nil;
        !           353:     return self;
        !           354: }
        !           355: 
        !           356: - wasAddedTo:(GraphicView *)sender
        !           357: {
        !           358:     [components makeObjectsPerform:@selector(wasAddedTo:) with:sender];
        !           359:     return self;
        !           360: }
        !           361: 
        !           362: /* Color drag-and-drop support. */
        !           363: 
        !           364: - (Graphic *)colorAcceptorAt:(const NXPoint *)point
        !           365: {
        !           366:     int i, count;
        !           367:     Graphic *graphic;
        !           368: 
        !           369:     count = [components count];
        !           370:     for (i = 0; i < count; i++) {
        !           371:        if (graphic = [[components objectAt:i] colorAcceptorAt:point]) return graphic;
        !           372:     }
        !           373: 
        !           374:     return nil;
        !           375: }
        !           376: 
        !           377: /* We can't cache ourselves if we have a TextGraphic in the Group. */
        !           378: 
        !           379: - (BOOL)hasTextGraphic
        !           380: {
        !           381:     return hasTextGraphic;
        !           382: }
        !           383: 
        !           384: - setCacheable:(BOOL)flag
        !           385: /*
        !           386:  * Sets whether we do caching of this Group or not.
        !           387:  */
        !           388: {
        !           389:     dontCache = flag ? NO : YES;
        !           390:     if (dontCache) {
        !           391:        [cache free];
        !           392:        cache = nil;
        !           393:     }
        !           394:     return self;
        !           395: }
        !           396: 
        !           397: - (BOOL)isCacheable
        !           398: {
        !           399:     return !hasTextGraphic && !dontCache;
        !           400: }
        !           401: 
        !           402: - draw
        !           403: /*
        !           404:  * Individually scales and translates each Graphic in the group and draws
        !           405:  * them.  This is done this way so that ungrouping is trivial.  Note that
        !           406:  * if we are caching, we need to take the extra step of translating
        !           407:  * everything to the origin, drawing them in the cache, then translating
        !           408:  * them back.
        !           409:  */
        !           410: {
        !           411:     int i;
        !           412:     Graphic *g;
        !           413:     NXRect eb, b;
        !           414:     float sx = 1.0, sy = 1.0, tx, ty;
        !           415:     BOOL changed, changedSize, caching = NO;
        !           416: 
        !           417:     if (bounds.size.width < 1.0 || bounds.size.height < 1.0 || !components) return self;
        !           418: 
        !           419:     changedSize = lastRect.size.width != bounds.size.width || lastRect.size.height != bounds.size.height;
        !           420:     changed = changedSize || lastRect.origin.x != bounds.origin.x || lastRect.origin.y != bounds.origin.y;
        !           421: 
        !           422:     if ((changedSize || !cache) && NXDrawingStatus == NX_DRAWING) {
        !           423:        [cache free];
        !           424:        cache = nil;
        !           425:        if (DrawStatus != Resizing && [self isCacheable] && [components count] > GROUP_CACHE_THRESHOLD) {
        !           426:            caching = YES;
        !           427:            [self getExtendedBounds:&eb];
        !           428:            cache = [[NXImage allocFromZone:[self zone]] initSize:&eb.size];
        !           429:            [cache lockFocus];
        !           430:            [[[NXApp focusView] window] reenableDisplay];       /* workaround for AppKit bug? */
        !           431:            PStranslate(- eb.origin.x, - eb.origin.y);
        !           432:            PSsetalpha(0.0);
        !           433:            PSsetgray(NX_WHITE);
        !           434:            NXRectFill(&eb);
        !           435:            PSsetalpha(1.0);
        !           436:        }
        !           437:     }
        !           438: 
        !           439:     if (changedSize) {
        !           440:        sx = bounds.size.width / lastRect.size.width;
        !           441:        sy = bounds.size.height / lastRect.size.height;
        !           442:     }
        !           443: 
        !           444:     i = [components count];
        !           445:     while (i) {
        !           446:        g = [components objectAt:--i];
        !           447:        if (changed) {
        !           448:            [g getBounds:&b];
        !           449:            tx = (bounds.origin.x + ((b.origin.x - lastRect.origin.x) / lastRect.size.width * bounds.size.width)) - b.origin.x;
        !           450:            ty = (bounds.origin.y + ((b.origin.y - lastRect.origin.y) / lastRect.size.height * bounds.size.height)) - b.origin.y;
        !           451:            b.origin.x = b.origin.x + tx;
        !           452:            b.origin.y = b.origin.y + ty;
        !           453:            b.size.width = b.size.width * sx;
        !           454:            b.size.height = b.size.height * sy;
        !           455:            [g setBounds:&b];
        !           456:        }
        !           457:        if (NXDrawingStatus != NX_DRAWING || !cache || caching) {
        !           458:            [g setGraphicsState];       /* does a gsave ... */
        !           459:            [g draw];
        !           460:            PSgrestore();               /* ... so we need this grestore */
        !           461:        }
        !           462:     }
        !           463: 
        !           464:     if (cache && NXDrawingStatus == NX_DRAWING) {
        !           465:        if (caching) {
        !           466:            [cache unlockFocus];
        !           467:        } else {
        !           468:            [self getExtendedBounds:&eb];
        !           469:        }
        !           470:        [cache composite:NX_SOVER toPoint:&eb.origin];
        !           471:     }
        !           472: 
        !           473:     lastRect = bounds;
        !           474: 
        !           475:     return self;
        !           476: }
        !           477: 
        !           478: - (BOOL)hit:(const NXPoint *)point
        !           479: /*
        !           480:  * Gets a hit if any of the items in the group gets a hit.
        !           481:  */
        !           482: {
        !           483:     int i;
        !           484:     NXPoint p;
        !           485:     float px, py;
        !           486:     Graphic *graphic;
        !           487: 
        !           488:     if ([super hit:point]) {
        !           489:        if (components) {
        !           490:            p = *point;
        !           491:            px = (p.x - bounds.origin.x) / bounds.size.width;
        !           492:            p.x = px * lastRect.size.width + lastRect.origin.x;
        !           493:            py = (p.y - bounds.origin.y) / bounds.size.height;
        !           494:            p.y = py * lastRect.size.height + lastRect.origin.y;
        !           495:            i = [components count];
        !           496:            while (i) {
        !           497:                graphic = [components objectAt:--i];
        !           498:                if ([graphic hit:&p]) return YES;
        !           499:            }
        !           500:        } else {
        !           501:            return YES;
        !           502:        }
        !           503:     }
        !           504: 
        !           505:     return NO;
        !           506: }
        !           507: 
        !           508: /* Compatibility methods */
        !           509: 
        !           510: - replaceWithImage
        !           511: /*
        !           512:  * Since we got rid of Tiff and PSGraphic and replaced them
        !           513:  * with the unified Image graphic, we need to go through our
        !           514:  * list and replace all of them with an Image graphic.
        !           515:  */
        !           516: {
        !           517:     int i;
        !           518:     Graphic *graphic, *newGraphic;
        !           519: 
        !           520:     for (i = [components count]-1; i >= 0; i--) {
        !           521:        graphic = [components objectAt:i];
        !           522:        newGraphic = [graphic replaceWithImage];
        !           523:        if (graphic != newGraphic) {
        !           524:            if (graphic) {
        !           525:                [components replaceObjectAt:i with:newGraphic];
        !           526:            } else {
        !           527:                [components removeObjectAt:i];
        !           528:            }
        !           529:        }
        !           530:     }
        !           531: 
        !           532:     return self;
        !           533: }
        !           534: 
        !           535: /* Archiving methods */
        !           536: 
        !           537: - write:(NXTypedStream *)stream
        !           538: /*
        !           539:  * Just writes out the components.
        !           540:  */
        !           541: {
        !           542:     [super write:stream];
        !           543:     NXWriteTypes(stream, "@", &components);
        !           544:     NXWriteType(stream, "c", &dontCache);
        !           545:     NXWriteRect(stream, &lastRect);
        !           546:     NXWriteType(stream, "c", &hasTextGraphic);
        !           547:     return self;
        !           548: }
        !           549: 
        !           550: static BOOL checkForTextGraphic(List *list)
        !           551: {
        !           552:     int i;
        !           553:     Graphic *graphic;
        !           554: 
        !           555:     for (i = [list count]-1; i >= 0; i--) {
        !           556:        graphic = [list objectAt:i];
        !           557:        if ([graphic isKindOf:[TextGraphic class]] || ([graphic isKindOf:[Group class]] && [(Group *)graphic hasTextGraphic])) return YES;
        !           558:     }
        !           559: 
        !           560:     return NO;
        !           561: }
        !           562: 
        !           563: - read:(NXTypedStream *)stream
        !           564: {
        !           565:     [super read:stream];
        !           566:     NXReadTypes(stream, "@", &components);
        !           567:     lastRect = bounds;
        !           568:     if (NXTypedStreamClassVersion(stream, "Group") > 1) {
        !           569:        NXReadType(stream, "c", &dontCache);
        !           570:        NXReadRect(stream, &lastRect);
        !           571:     }
        !           572:     if (NXTypedStreamClassVersion(stream, "Group") > 2) {
        !           573:        NXReadType(stream, "c", &hasTextGraphic);
        !           574:     } else {
        !           575:        hasTextGraphic = checkForTextGraphic(components);
        !           576:     }
        !           577:     return self;
        !           578: }
        !           579: 
        !           580: @end
        !           581: 

This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.