Return to Polygon.m CVS log

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

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

1.1     ! root        1: #import "draw.h"
        !             2: 
        !             3: /*
        !             4:  * This line is just a stub to get genstrings to generate
        !             5:  * a .strings file entry for the name of this type of Graphic.
        !             6:  * The name is used in the Undo New <Whatever> menu item.
        !             7:  *
        !             8:  * NXLocalString("Polygon", NULL, "Name of the tool that draws polygons, i.e., the %s of the New %s operation.")
        !             9:  */
        !            10: 
        !            11: @implementation Polygon
        !            12: 
        !            13: + initialize
        !            14: /*
        !            15:  * This bumps the class version so that we can compatibly read
        !            16:  * old Graphic objects out of an archive.
        !            17:  */
        !            18: {
        !            19:     [Polygon setVersion:1];
        !            20:     return self;
        !            21: }
        !            22: 
        !            23: + cursor
        !            24: /*
        !            25:  * The cursor inherited from Scribble is a pencil.
        !            26:  * That's not very appropriate, so CrossCursor is used instead.
        !            27:  */
        !            28: {
        !            29:     return CrossCursor;
        !            30: }
        !            31: 
        !            32: static void getRectFromBBox(NXRect *r, float x1, float y1, float x2, float y2)
        !            33: /*
        !            34:  * Takes two points (x1, y1) and (x2, y2) and updates the r rect to
        !            35:  * equal that bounding box.
        !            36:  */
        !            37: {
        !            38:     r->size.width = x1 - x2;
        !            39:     r->size.height = y1 - y2;
        !            40:     if (r->size.width < 0.0) {
        !            41:        r->origin.x = x2 + r->size.width;
        !            42:        r->size.width = 0.0 - r->size.width;
        !            43:     } else r->origin.x = x2;
        !            44:     if (r->size.height < 0.0) {
        !            45:        r->origin.y = y2 + r->size.height;
        !            46:        r->size.height = 0.0 - r->size.height;
        !            47:     } else r->origin.y = y2;
        !            48: }
        !            49: 
        !            50: /*
        !            51:  * This class probably is probably not implemented in the optimal way,
        !            52:  * but it shows how an existing implementation (i.e. Scribble) can be
        !            53:  * used to implement some other object.
        !            54:  *
        !            55:  * This method creates a polygon.  The user must drag out each segment of
        !            56:  * the polygon clicking to make a corner, finally ending with a double click.
        !            57:  *
        !            58:  * Start by getting the starting point of the polygon from the mouse down
        !            59:  * event passed in the event parameter (if the ALT key is not down, then we
        !            60:  * will close the path even if the user does not explicitly do so).
        !            61:  *
        !            62:  * Next, we initialize a chunk of space for the points to be stored in
        !            63:  * and initialize point[0] and point[1] to be the starting point (since the
        !            64:  * first thing in the userpath is a moveto).  We also initialize our bounding
        !            65:  * box to contain only that point.
        !            66:  *
        !            67:  * p represents the last point the user moved the mouse to.  We initialize it
        !            68:  * to start before entering the tracking loop.
        !            69:  *
        !            70:  * Inside the loop, last represents the last point the user confirmed (by
        !            71:  * clicking) as opposed to p, the last point the user moved to.  We update
        !            72:  * last every time we start the segment tracking loop (the inner,
        !            73:  * while (event->type != NX_MOUSEUP) loop).
        !            74:  *
        !            75:  * In the segment tracking loop, r represents the rectangle which must be
        !            76:  * redrawn to get rid of the last time we drew the segment we are currently
        !            77:  * tracking.  After we [view drawSelf:&r :1] to clear out the last segment,
        !            78:  * we recalculate the value of r for the next time around the loop.  Finally,
        !            79:  * we draw ourselves (i.e. all the other segments besides the one we are
        !            80:  * currently tracking) and then draw the segment we are currently tracking.
        !            81:  *
        !            82:  * After tracking the segment, we check to see if we are done.
        !            83:  * We are finished if any of the following are true:
        !            84:  *    1. The last segment the user created was smaller than a gridSpacing.
        !            85:  *    2. The user clicked on the starting point (thereby closing the path).
        !            86:  *    3. The mouse down is outside the view's bounds.
        !            87:  *    4. A kit defined or system defined event comes through.
        !            88:  *
        !            89:  * If we are not done (or we need to close the path), then we store the
        !            90:  * new point pair into points (reallocating our points
        !            91:  * and userPathOps arrays if we are out of room).  We then update our bounding
        !            92:  * box to reflect the new point and update our bounds to equal our bounding
        !            93:  * box.  If we aren't done, we look for the next mouse down to begin the
        !            94:  * tracking of another segment.
        !            95:  *
        !            96:  * After we are finished with all segments, we check to be sure that we have
        !            97:  * at least two segments (one segment is a line, not a polygon).  If the
        !            98:  * path is closed, then we need at least three segments.  If we have the
        !            99:  * requisite number of segments, then we reallocate our arrays to fit exactly
        !           100:  * our number of points and return YES.  Otherwise, we free the storage of
        !           101:  * those arrays and clean up any drawing we did and return NO.
        !           102:  */
        !           103: 
        !           104: #define POLYGON_MASK (NX_MOUSEDRAGGEDMASK|NX_MOUSEUPMASK)
        !           105: #define END_POLYGON_MASK (NX_KITDEFINEDMASK|NX_MOUSEDOWNMASK|NX_SYSDEFINEDMASK)
        !           106: 
        !           107: - (BOOL)create:(NXEvent *)event in:view
        !           108: {
        !           109:     float *pptr;
        !           110:     NXRect r, viewBounds;
        !           111:     NXPoint start, last, p;
        !           112:     Window *window = [view window];
        !           113:     BOOL closepath, done = NO, resend = NO;
        !           114:     float grid = (float)[view gridSpacing];
        !           115:     int windowNum = event->window, arrow = 0;
        !           116: 
        !           117:     if (![view gridIsEnabled])
        !           118:         grid = 1.0;
        !           119: 
        !           120:     gFlags.initialized = YES;
        !           121:     if (gFlags.arrow && gFlags.arrow != ARROW_AT_START) {
        !           122:        arrow = gFlags.arrow;
        !           123:        gFlags.arrow = (gFlags.arrow == ARROW_AT_END) ? 0 : ARROW_AT_START;
        !           124:     }
        !           125: 
        !           126:     start = event->location;
        !           127:     [view convertPoint:&start fromView:nil];
        !           128:     [view grid:&start];
        !           129: 
        !           130:     [view getVisibleRect:&viewBounds];
        !           131: 
        !           132:     closepath = (event->flags & NX_ALTERNATEMASK) ? NO : YES;
        !           133: 
        !           134:     length = 0;
        !           135:     [self allocateChunk];
        !           136:     pptr = points;
        !           137:     *pptr++ = bbox[0] = bbox[2] = start.x;
        !           138:     *pptr++ = bbox[1] = bbox[3] = start.y;
        !           139:     userPathOps[0] = dps_moveto;
        !           140: 
        !           141:     [view lockFocus];
        !           142: 
        !           143:     [self setLineColor];
        !           144:     PSsetlinewidth(linewidth);
        !           145: 
        !           146:     p = start;
        !           147:     event = [NXApp getNextEvent:POLYGON_MASK];
        !           148:     while (!done) {
        !           149:        last = p;
        !           150:        if (event->type == NX_MOUSEDOWN) {
        !           151:            if (event->data.mouse.click > 1) {
        !           152:                done = YES;
        !           153:                [NXApp getNextEvent:NX_MOUSEUPMASK];
        !           154:            } else if (event->window != windowNum) {
        !           155:                done = YES;
        !           156:                resend = YES;
        !           157:            } else {
        !           158:                p = event->location;
        !           159:                [view convertPoint:&p fromView:nil];
        !           160:                done = !NXMouseInRect(&p, &viewBounds, NO);
        !           161:                resend = YES;
        !           162:            }
        !           163:        } else if (event->type == NX_KITDEFINED ||
        !           164:                   event->type == NX_SYSDEFINED) {
        !           165:            done = YES;
        !           166:            resend = YES;
        !           167:        }
        !           168:        if (!done) {
        !           169:            while (event->type != NX_MOUSEUP) {
        !           170:                p = event->location;
        !           171:                [view convertPoint:&p fromView:nil];
        !           172:                [view grid:&p];
        !           173:                [view drawSelf:&r :1];
        !           174:                getRectFromBBox(&r, p.x, p.y, last.x, last.y);
        !           175:                [view scrollPointToVisible:&p];
        !           176:                NXInsetRect(&r, -2.0, -2.0);
        !           177:                [self draw];
        !           178:                PSmoveto(last.x, last.y);
        !           179:                PSlineto(p.x, p.y);
        !           180:                PSstroke();
        !           181:                [window flushWindow];
        !           182:                event = [NXApp getNextEvent:POLYGON_MASK];
        !           183:            }
        !           184:            if (fabs(p.x-start.x) <= grid && fabs(p.y-start.y) <= grid) {
        !           185:                done = YES;
        !           186:                closepath = YES;
        !           187:            }
        !           188:        }
        !           189:        if (!done || (closepath && length > 1)) {
        !           190:            if (done) p = start;
        !           191:            length++;
        !           192:            if (!(length % CHUNK_SIZE)) [self allocateChunk];
        !           193:            *pptr++ = p.x - last.x;
        !           194:            *pptr++ = p.y - last.y;
        !           195:            if (p.x < bbox[0]) bbox[0] = p.x;
        !           196:            if (p.x > bbox[2]) bbox[2] = p.x;
        !           197:            if (p.y < bbox[1]) bbox[1] = p.y;
        !           198:            if (p.y > bbox[3]) bbox[3] = p.y;
        !           199:            getRectFromBBox(&bounds, bbox[0], bbox[1], bbox[2], bbox[3]);
        !           200:            if (!done) event = [NXApp getNextEvent:END_POLYGON_MASK];
        !           201:        }
        !           202:     }
        !           203: 
        !           204:     [view unlockFocus];
        !           205: 
        !           206:     if (resend) DPSPostEvent(event, 1);
        !           207:     if (arrow) gFlags.arrow = arrow;
        !           208: 
        !           209:     if (length > (closepath ? 2 : 1)) {
        !           210:        points = NX_ZONEREALLOC([self zone], points, float, (length+1) << 1);
        !           211:        userPathOps = NX_ZONEREALLOC([self zone], userPathOps, char, length+1);
        !           212:        return YES;
        !           213:     } else {
        !           214:        NX_FREE(points); points = NULL;
        !           215:        NX_FREE(userPathOps); userPathOps = NULL;
        !           216:        [view drawSelf:[self getExtendedBounds:&r] :1];
        !           217:        return NO;
        !           218:     }
        !           219: }
        !           220: 
        !           221: - (Graphic *)colorAcceptorAt:(const NXPoint *)point
        !           222: {
        !           223:     if ([self hit:point]) return self;
        !           224:     return nil;
        !           225: }
        !           226: 
        !           227: @end
        !           228: 

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