Return to Change.m CVS log

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

Annotation of Examples/AppKit/Draw/undo.subproj/Change.m, revision 1.1

1.1     ! root        1: #import "change.h"
        !             2: 
        !             3: /*
        !             4:  * Please refer to external reference pages for complete
        !             5:  * documentation on using the Change class.
        !             6:  */
        !             7: 
        !             8: @interface Change(PrivateMethods)
        !             9: 
        !            10: - calcTargetForAction:(SEL)theAction in:aView;
        !            11: 
        !            12: @end
        !            13: 
        !            14: @implementation Change
        !            15: 
        !            16: /* Methods called directly by your code */
        !            17: 
        !            18: - init
        !            19: {
        !            20:     [super init];
        !            21:     _changeFlags.disabled = NO;
        !            22:     _changeFlags.hasBeenDone = NO;
        !            23:     _changeFlags.changeInProgress = NO;
        !            24:     _changeManager = nil;
        !            25:     return self;
        !            26: }
        !            27: 
        !            28: - startChange
        !            29: {
        !            30:     return [self startChangeIn:nil];
        !            31: }
        !            32: 
        !            33: - startChangeIn:aView
        !            34: {
        !            35:     _changeFlags.changeInProgress = YES;
        !            36:     _changeManager = [NXApp calcTargetForAction:@selector(changeInProgress:)];
        !            37: 
        !            38:     if (_changeManager == nil && aView != nil)
        !            39:         _changeManager = [self calcTargetForAction:@selector(changeInProgress:) in:aView];
        !            40: 
        !            41:     if(_changeManager != nil) {
        !            42:        if ([_changeManager changeInProgress:self] && !_changeFlags.disabled)
        !            43:            return self;
        !            44:        else
        !            45:            return nil;
        !            46:     }
        !            47: 
        !            48:     return self;
        !            49: }
        !            50: 
        !            51: - endChange
        !            52: {
        !            53:     if (_changeManager == nil || _changeFlags.disabled) {
        !            54:        [self free];
        !            55:        return nil;
        !            56:     } else {
        !            57:        _changeFlags.hasBeenDone = YES;
        !            58:        _changeFlags.changeInProgress = NO;
        !            59:        if ([_changeManager changeComplete:self])
        !            60:            return self;
        !            61:        else
        !            62:            return nil;
        !            63:     }
        !            64: }
        !            65: 
        !            66: - changeManager
        !            67: {
        !            68:     return _changeManager;
        !            69: }
        !            70: 
        !            71: /* Methods called by ChangeManager or by your code */
        !            72: 
        !            73: - disable
        !            74: {
        !            75:     _changeFlags.disabled = YES;
        !            76:     return self;
        !            77: }
        !            78: 
        !            79: - (BOOL)disabled
        !            80: {
        !            81:     return _changeFlags.disabled;
        !            82: }
        !            83: 
        !            84: - (BOOL)hasBeenDone
        !            85: {
        !            86:     return _changeFlags.hasBeenDone;
        !            87: }
        !            88: 
        !            89: - (BOOL)changeInProgress
        !            90: {
        !            91:     return _changeFlags.changeInProgress;
        !            92: }
        !            93: 
        !            94: - (const char *)changeName
        !            95: /*
        !            96:  * To be overridden 
        !            97:  */
        !            98: {
        !            99:     return "";
        !           100: }
        !           101: 
        !           102: /* Methods called by ChangeManager */
        !           103: /* DO NOT call directly */
        !           104: 
        !           105: - saveBeforeChange
        !           106: /*
        !           107:  * To be overridden 
        !           108:  */
        !           109: {
        !           110:     return self;
        !           111: }
        !           112: 
        !           113: - saveAfterChange
        !           114: /*
        !           115:  * To be overridden 
        !           116:  */
        !           117: {
        !           118:     return self;
        !           119: }
        !           120: 
        !           121: - undoChange
        !           122: /*
        !           123:  * To be overridden. End with:
        !           124:  * return [super undoChange];
        !           125:  */
        !           126: {
        !           127:     _changeFlags.hasBeenDone = NO;
        !           128:     return self;
        !           129: }
        !           130: 
        !           131: - redoChange
        !           132: /*
        !           133:  * To be overridden. End with:
        !           134:  * return [super redoChange];
        !           135:  */
        !           136: {
        !           137:     _changeFlags.hasBeenDone = YES;
        !           138:     return self;
        !           139: }
        !           140: 
        !           141: - (BOOL)subsumeChange:change
        !           142: /*
        !           143:  * To be overridden 
        !           144:  */
        !           145: {
        !           146:     return NO;
        !           147: }
        !           148: 
        !           149: - (BOOL)incorporateChange:change
        !           150: /*
        !           151:  * To be overridden 
        !           152:  */
        !           153: {
        !           154:     return NO;
        !           155: }
        !           156: 
        !           157: - finishChange
        !           158: /*
        !           159:  * To be overridden 
        !           160:  */
        !           161: {
        !           162:     return self;
        !           163: }
        !           164: 
        !           165: /* Private Methods */
        !           166: 
        !           167: - calcTargetForAction:(SEL)theAction in:aView
        !           168: /*
        !           169:  * This method is intended to behave exactly like the Application
        !           170:  * method calcTargetForAction:, except that that method always returns
        !           171:  * nil if the application is not active, where we do our best to come
        !           172:  * up with a target anyway.
        !           173:  */
        !           174: {
        !           175:     id responder, nextResponder;
        !           176: 
        !           177:     responder = [[aView window] firstResponder];
        !           178:     while (![responder respondsTo:theAction]) {
        !           179:         nextResponder = nil;
        !           180:         if ([responder respondsTo:@selector(nextResponder)])
        !           181:             nextResponder = [responder nextResponder];
        !           182:        if (nextResponder == nil && [responder isKindOf:[Window class]])
        !           183:            nextResponder = [responder delegate];
        !           184:        if (nextResponder == nil)
        !           185:            nextResponder = NXApp;
        !           186:        if (nextResponder == nil && responder == NXApp)
        !           187:            nextResponder = [responder delegate];
        !           188:        responder = nextResponder;
        !           189:     }
        !           190:     return responder;
        !           191: }
        !           192: 
        !           193: @end

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