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

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.