Return to ChangeDetail.m CVS log

Up to [NeXTSTEP 3.3 examples] / Examples / AppKit / Draw / graphicsUndo.subproj

Annotation of Examples/AppKit/Draw/graphicsUndo.subproj/ChangeDetail.m, revision 1.1

1.1     ! root        1: #import "drawundo.h"
        !             2: 
        !             3: /*
        !             4:  * Please refer to external documentation about Draw
        !             5:  * with Undo for information about what ChangeDetails 
        !             6:  * are and where they fit in.
        !             7:  *
        !             8:  * The ChangeDetail.h and ChangeDetail.m files contain
        !             9:  * the @interfaces and @implementations for the 11 
        !            10:  * subclasses of ChangeDetail, as well as for ChangeDetail
        !            11:  * itself. We grouped all the classes into one pair of 
        !            12:  * files because the classes are so tiny and their behavior
        !            13:  * is so similar.
        !            14:  *
        !            15:  * ChangeDetail
        !            16:  *     ArrowChangeDetail
        !            17:  *     DimensionsChangeDetail
        !            18:  *     FillColorChangeDetail
        !            19:  *     FillModeChangeDetail
        !            20:  *     LineCapChangeDetail
        !            21:  *     LineColorChangeDetail
        !            22:  *     LineJoinChangeDetail
        !            23:  *     LineWidthChangeDetail
        !            24:  *     MoveChangeDetail
        !            25:  *     OrderChangeDetail
        !            26:  * 
        !            27:  */
        !            28: 
        !            29: @interface ChangeDetail(PrivateMethods)
        !            30: 
        !            31: - (BOOL)personalChangeExpected;
        !            32: 
        !            33: @end
        !            34: 
        !            35: @implementation ChangeDetail
        !            36: 
        !            37: - initGraphic:aGraphic change:aChange
        !            38: {
        !            39:     List *subGraphics;
        !            40:     int count, i;
        !            41:     id changeDetail;
        !            42:     
        !            43:     graphic = aGraphic;
        !            44:     change = aChange;
        !            45:     if ([graphic isKindOf:[Group class]] && [self useNestedDetails]) {
        !            46:         detailsDetails = [[List alloc] init];
        !            47:        subGraphics = [(Group *)graphic subGraphics];
        !            48:        count = [subGraphics count];
        !            49:        changeExpected = NO;
        !            50:        for (i = 0; i < count; i++) {
        !            51:            changeDetail = [[[aChange changeDetailClass] alloc] initGraphic:[subGraphics objectAt:i] change:aChange];
        !            52:            changeExpected = changeExpected || [changeDetail changeExpected];
        !            53:            [detailsDetails addObject:changeDetail];
        !            54:        }
        !            55:     } else {
        !            56:         detailsDetails = nil;
        !            57:        changeExpected = [self personalChangeExpected];
        !            58:     }
        !            59:     return self;
        !            60: }
        !            61: 
        !            62: - free
        !            63: {
        !            64:     [detailsDetails freeObjects];
        !            65:     [detailsDetails free];
        !            66:     return [super free];
        !            67: }
        !            68: 
        !            69: - graphic
        !            70: {
        !            71:     return graphic;
        !            72: }
        !            73: 
        !            74: - (BOOL)useNestedDetails
        !            75: {
        !            76:     return YES;
        !            77: }
        !            78: 
        !            79: - (BOOL)changeExpected
        !            80: {
        !            81:     return changeExpected;
        !            82: }
        !            83: 
        !            84: - recordDetail
        !            85: {
        !            86:     if(detailsDetails)
        !            87:         [detailsDetails makeObjectsPerform:@selector(recordDetail)];
        !            88:     else
        !            89:       [self recordIt];
        !            90:     return self;
        !            91: }
        !            92: 
        !            93: - undoDetail
        !            94: {
        !            95:     if (detailsDetails)
        !            96:         [detailsDetails makeObjectsPerform:@selector(undoDetail)];
        !            97:     else
        !            98:       [self undoIt];
        !            99:     return self;
        !           100: }
        !           101: 
        !           102: - redoDetail
        !           103: {
        !           104:     if (detailsDetails)
        !           105:         [detailsDetails makeObjectsPerform:@selector(redoDetail)];
        !           106:     else
        !           107:       [self redoIt];
        !           108:     return self;
        !           109: }
        !           110: 
        !           111: - recordIt
        !           112: {
        !           113:     /* Implemented by subclasses */
        !           114:     return self;
        !           115: }
        !           116: 
        !           117: - undoIt
        !           118: {
        !           119:     /* Implemented by subclasses */
        !           120:     return self;
        !           121: }
        !           122: 
        !           123: - redoIt
        !           124: {
        !           125:     /* Implemented by subclasses */
        !           126:     return self;
        !           127: }
        !           128: 
        !           129: - (BOOL)personalChangeExpected
        !           130: {
        !           131:     return YES;
        !           132: }
        !           133: 
        !           134: @end
        !           135: 
        !           136: @implementation ArrowChangeDetail
        !           137: 
        !           138: - recordIt
        !           139: {
        !           140:     oldLineArrow = [graphic lineArrow];
        !           141:     return self;
        !           142: }
        !           143: 
        !           144: - undoIt
        !           145: {
        !           146:     [graphic setLineArrow:oldLineArrow];
        !           147:     return self;
        !           148: }
        !           149: 
        !           150: - redoIt
        !           151: {
        !           152:     [graphic setLineArrow:[change lineArrow]];
        !           153:     return self;
        !           154: }
        !           155: 
        !           156: - (BOOL)personalChangeExpected
        !           157: {
        !           158:     return ([graphic lineArrow] != [change lineArrow]);
        !           159: }
        !           160: 
        !           161: @end
        !           162: 
        !           163: @implementation DimensionsChangeDetail
        !           164: 
        !           165: - (BOOL)useNestedDetails
        !           166: {
        !           167:     return NO;
        !           168: }
        !           169: 
        !           170: - recordDetail
        !           171: {
        !           172:     [graphic getBounds:&oldBounds];
        !           173:     return self;
        !           174: }
        !           175: 
        !           176: - undoDetail
        !           177: {
        !           178:     [graphic getBounds:&newBounds];
        !           179:     [graphic setBounds:&oldBounds];
        !           180:     return self;
        !           181: }
        !           182: 
        !           183: - redoDetail
        !           184: {
        !           185:     [graphic setBounds:&newBounds];
        !           186:     return self;
        !           187: }
        !           188: 
        !           189: @end
        !           190: 
        !           191: @implementation FillChangeDetail
        !           192: 
        !           193: - recordIt
        !           194: {
        !           195:     oldFillColor = [graphic fillColor];
        !           196:     oldFillMode = [graphic fill];
        !           197:     return self;
        !           198: }
        !           199: 
        !           200: - undoIt
        !           201: {
        !           202:     newFillColor = [graphic fillColor];
        !           203:     newFillMode = [graphic fill];
        !           204:     [graphic setFillColor:&oldFillColor];
        !           205:     [graphic setFill:oldFillMode];
        !           206:     return self;
        !           207: }
        !           208: 
        !           209: - redoIt
        !           210: {
        !           211:     [graphic setFillColor:&newFillColor];
        !           212:     [graphic setFill:newFillMode];
        !           213:     return self;
        !           214: }
        !           215: 
        !           216: - (BOOL)personalChangeExpected
        !           217: {
        !           218:     return ([graphic fill] != [change fill]);
        !           219: }
        !           220: 
        !           221: @end
        !           222: 
        !           223: @implementation LineCapChangeDetail
        !           224: 
        !           225: - recordIt
        !           226: {
        !           227:     oldLineCap = [graphic lineCap];
        !           228:     return self;
        !           229: }
        !           230: 
        !           231: - undoIt
        !           232: {
        !           233:     [graphic setLineCap:oldLineCap];
        !           234:     return self;
        !           235: }
        !           236: 
        !           237: - redoIt
        !           238: {
        !           239:     [graphic setLineCap:[change lineCap]];
        !           240:     return self;
        !           241: }
        !           242: 
        !           243: - (BOOL)personalChangeExpected
        !           244: {
        !           245:     return ([graphic lineCap] != [change lineCap]);
        !           246: }
        !           247: 
        !           248: @end
        !           249: 
        !           250: @implementation LineColorChangeDetail
        !           251: 
        !           252: - recordIt
        !           253: {
        !           254:     oldColor = [graphic lineColor];
        !           255:     oldIsOutlined = [graphic isOutlined];
        !           256:     return self;
        !           257: }
        !           258: 
        !           259: - undoIt
        !           260: {
        !           261:     [graphic setLineColor:&oldColor];
        !           262:     [graphic setOutlined:oldIsOutlined];
        !           263:     return self;
        !           264: }
        !           265: 
        !           266: - redoIt
        !           267: {
        !           268:     NXColor color = [change lineColor];
        !           269:     [graphic setLineColor:&color];
        !           270:     [graphic setOutlined:YES];
        !           271:     return self;
        !           272: }
        !           273: 
        !           274: - (BOOL)personalChangeExpected
        !           275: {
        !           276:     return (!NXEqualColor([graphic lineColor], [change lineColor]));
        !           277: }
        !           278: 
        !           279: @end
        !           280: 
        !           281: @implementation LineJoinChangeDetail
        !           282: 
        !           283: - recordIt
        !           284: {
        !           285:     oldLineJoin = [graphic lineJoin];
        !           286:     return self;
        !           287: }
        !           288: 
        !           289: - undoIt
        !           290: {
        !           291:     [graphic setLineJoin:oldLineJoin];
        !           292:     return self;
        !           293: }
        !           294: 
        !           295: - redoIt
        !           296: {
        !           297:     [graphic setLineJoin:[change lineJoin]];
        !           298:     return self;
        !           299: }
        !           300: 
        !           301: - (BOOL)personalChangeExpected
        !           302: {
        !           303:     return ([graphic lineJoin] != [change lineJoin]);
        !           304: }
        !           305: 
        !           306: @end
        !           307: 
        !           308: @implementation LineWidthChangeDetail
        !           309: 
        !           310: - recordIt
        !           311: {
        !           312:     oldLineWidth = [graphic lineWidth];
        !           313:     return self;
        !           314: }
        !           315: 
        !           316: - undoIt
        !           317: {
        !           318:     [graphic setLineWidth:&oldLineWidth];
        !           319:     return self;
        !           320: }
        !           321: 
        !           322: - redoIt
        !           323: {
        !           324:     float lineWidth = [change lineWidth];
        !           325:     [graphic setLineWidth:&lineWidth];
        !           326:     return self;
        !           327: }
        !           328: 
        !           329: - (BOOL)personalChangeExpected
        !           330: {
        !           331:     return ([graphic lineWidth] != [change lineWidth]);
        !           332: }
        !           333: 
        !           334: @end
        !           335: 
        !           336: @implementation MoveChangeDetail
        !           337: 
        !           338: - (BOOL)useNestedDetails
        !           339: {
        !           340:     return NO;
        !           341: }
        !           342: 
        !           343: - undoDetail
        !           344: {
        !           345:     [graphic moveBy:[change undoVector]];
        !           346:     return self;
        !           347: }
        !           348: 
        !           349: - redoDetail
        !           350: {
        !           351:     [graphic moveBy:[change redoVector]];
        !           352:     return self;
        !           353: }
        !           354: 
        !           355: @end
        !           356: 
        !           357: @implementation OrderChangeDetail
        !           358: 
        !           359: - (BOOL)useNestedDetails
        !           360: {
        !           361:     return NO;
        !           362: }
        !           363: 
        !           364: - recordGraphicPositionIn:graphicList
        !           365: {
        !           366:     graphicPosition = [graphicList indexOf:graphic];
        !           367:     return self;
        !           368: }
        !           369: 
        !           370: - (unsigned)graphicPosition
        !           371: {
        !           372:     return graphicPosition;
        !           373: }
        !           374: 
        !           375: @end

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