CPUndoManager.j

Go to the documentation of this file.

/*
 * CPUndoManager.j
 * Foundation
 *
 * Created by Francisco Tolmasky.
 * Copyright 2008, 280 North, Inc.
 *
 * This library is free software; you can redistribute it and/or
 * modify it under the terms of the GNU Lesser General Public
 * License as published by the Free Software Foundation; either
 * version 2.1 of the License, or (at your option) any later version.
 *
 * This library is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
 * Lesser General Public License for more details.
 *
 * You should have received a copy of the GNU Lesser General Public
 * License along with this library; if not, write to the Free Software
 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
 */


var CPUndoManagerNormal     = 0,
    CPUndoManagerUndoing    = 1,
    CPUndoManagerRedoing    = 2;

CPUndoManagerCheckpointNotification         = @"CPUndoManagerCheckpointNotification";
CPUndoManagerDidOpenUndoGroupNotification   = @"CPUndoManagerDidOpenUndoGroupNotification";
CPUndoManagerDidCloseUndoGroupNotification  = @"CPUndoManagerDidCloseUndoGroupNotification";
CPUndoManagerDidRedoChangeNotification      = @"CPUndoManagerDidRedoChangeNotification";
CPUndoManagerDidUndoChangeNotification      = @"CPUndoManagerDidUndoChangeNotification";
CPUndoManagerWillCloseUndoGroupNotification = @"CPUndoManagerWillCloseUndoGroupNotification";
CPUndoManagerWillRedoChangeNotification     = @"CPUndoManagerWillRedoChangeNotification";
CPUndoManagerWillUndoChangeNotification     = @"CPUndoManagerWillUndoChangeNotification";

CPUndoCloseGroupingRunLoopOrdering          = 350000;

var _CPUndoGroupingPool         = [],
    _CPUndoGroupingPoolCapacity = 5;

/* @ignore */
@implementation _CPUndoGrouping : CPObject
{
    id              _parent;
    CPMutableArray  _invocations;
    CPString        _actionName;
}

+ (void)_poolUndoGrouping:(_CPUndoGrouping)anUndoGrouping
{
    if (!anUndoGrouping || _CPUndoGroupingPool.length >= _CPUndoGroupingPoolCapacity)
        return;

    _CPUndoGroupingPool.push(anUndoGrouping);
}

+ (id)undoGroupingWithParent:(_CPUndoGrouping)anUndoGrouping
{
    if (_CPUndoGroupingPool.length)
    {
        var grouping = _CPUndoGroupingPool.pop();

        grouping._parent = anUndoGrouping;

        if (grouping._invocations.length)
            grouping._invocations = [];

        return grouping;
    }

    return [[self alloc] initWithParent:anUndoGrouping];
}

- (id)initWithParent:(_CPUndoGrouping)anUndoGrouping
{
    self = [super init];

    if (self)
    {
        _parent = anUndoGrouping;
        _invocations = [];
        _actionName = @"";
    }

    return self;
}

- (_CPUndoGrouping)parent
{
    return _parent;
}

- (void)addInvocation:(CPInvocation)anInvocation
{
    _invocations.push(anInvocation);
}

- (void)addInvocationsFromArray:(CPArray)invocations
{
    [_invocations addObjectsFromArray:invocations];
}

- (BOOL)removeInvocationsWithTarget:(id)aTarget
{
    var index = _invocations.length;

    while (index--)
        if ([_invocations[index] target] == aTarget)
            _invocations.splice(index, 1);
}

- (CPArray)invocations
{
    return _invocations;
}

- (void)invoke
{
    var index = _invocations.length;

    while (index--)
        [_invocations[index] invoke];
}

- (void)setActionName:(CPString)aName
{
    _actionName = aName;
}

- (CPString)actionName
{
    return _actionName;
}

@end

var _CPUndoGroupingParentKey        = @"_CPUndoGroupingParentKey",
    _CPUndoGroupingInvocationsKey   = @"_CPUndoGroupingInvocationsKey",
    _CPUndoGroupingActionNameKey    = @"_CPUndoGroupingActionNameKey";

@implementation _CPUndoGrouping (CPCoder)

- (id)initWithCoder:(CPCoder)aCoder
{
    self = [super init];

    if (self)
    {
        _parent = [aCoder decodeObjectForKey:_CPUndoGroupingParentKey];
        _invocations = [aCoder decodeObjectForKey:_CPUndoGroupingInvocationsKey];
        _actionName = [aCoder decodeObjectForKey:_CPUndoGroupingActionNameKey];
    }

    return self;
}

- (void)encodeWithCoder:(CPCoder)aCoder
{
    [aCoder encodeObject:_parent forKey:_CPUndoGroupingParentKey];
    [aCoder encodeObject:_invocations forKey:_CPUndoGroupingInvocationsKey];
    [aCoder encodeObject:_actionName forKey:_CPUndoGroupingActionNameKey];
}

@end

@implementation CPUndoManager : CPObject
{
    CPMutableArray  _redoStack;
    CPMutableArray  _undoStack;

    BOOL            _groupsByEvent;
    int             _disableCount;
    int             _levelsOfUndo;
    id              _currentGrouping;
    int             _state;

    id              _preparedTarget;
    id              _undoManagerProxy;

    CPArray         _runLoopModes;
    BOOL            _registeredWithRunLoop;
}

- (id)init
{
    self = [super init];

    if (self)
    {
        _redoStack = [];
        _undoStack = [];

        _disableCount = 0;
        _state = CPUndoManagerNormal;

        [self setRunLoopModes:[CPDefaultRunLoopMode]];
        [self setGroupsByEvent:YES];

        _undoManagerProxy = [_CPUndoManagerProxy alloc];
        _undoManagerProxy._undoManager = self;
    }

    return self;
}

- (void)_addUndoInvocation:(CPInvocation)anInvocation
{
    if (!_currentGrouping)
        // Remember that we create these lazily...
        if ([self groupsByEvent])
            [self _beginUndoGroupingForEvent];
        else
            [CPException raise:CPInternalInconsistencyException reason:"No undo group is currently open"];

    [_currentGrouping addInvocation:anInvocation];

    if (_state === CPUndoManagerNormal)
        [_redoStack removeAllObjects];
}

// Registering Undo Operations
- (void)registerUndoWithTarget:(id)aTarget selector:(SEL)aSelector object:(id)anObject
{
    // Don't do anything if we're disabled.
    if (_disableCount > 0)
        return;

    //signature = [target methodSignatureForSelector:selector];
    // FIXME: we need method signatures.
    var invocation = [CPInvocation invocationWithMethodSignature:nil];

    [invocation setTarget:aTarget];
    [invocation setSelector:aSelector];
    [invocation setArgument:anObject atIndex:2];

    [self _addUndoInvocation:invocation];
}
- (id)prepareWithInvocationTarget:(id)aTarget
{
    _preparedTarget = aTarget;

    return _undoManagerProxy;
}

/*
    FIXME This method doesn't seem to do anything right
    @ignore
*/
- (CPMethodSignature)_methodSignatureOfPreparedTargetForSelector:(SEL)aSelector
{
    if ([_preparedTarget respondsToSelector:aSelector])
        return 1;

    return nil;//[_preparedTarget methodSignatureForSelector:selector];
}

- (void)_forwardInvocationToPreparedTarget:(CPInvocation)anInvocation
{
    // Don't do anything if we're disabled.
    if (_disableCount > 0)
        return;

/*
if (_currentGroup == nil)
        [NSException raise:NSInternalInconsistencyException
                    format:@"forwardInvocation called without first opening an undo group"];
*/
    [anInvocation setTarget:_preparedTarget];

    [self _addUndoInvocation:anInvocation];

    _preparedTarget = nil;
}

// Checking Undo Ability
- (BOOL)canRedo
{
    [[CPNotificationCenter defaultCenter]
        postNotificationName:CPUndoManagerCheckpointNotification
                      object:self];

    return [_redoStack count] > 0;
}

- (BOOL)canUndo
{
    if (_undoStack.length > 0)
        return YES;

    return [[_currentGrouping invocations] count] > 0;
}

// Preform Undo and Redo
- (void)undo
{
    if ([self groupingLevel] === 1)
        [self endUndoGrouping];

    [self undoNestedGroup];
}

- (void)undoNestedGroup
{
    if ([_undoStack count] <= 0)
        return;

    var defaultCenter = [CPNotificationCenter defaultCenter];

    [defaultCenter postNotificationName:CPUndoManagerCheckpointNotification
                                 object:self];

    [defaultCenter postNotificationName:CPUndoManagerWillUndoChangeNotification
                                 object:self];

    var undoGrouping = _undoStack.pop(),
        actionName = [undoGrouping actionName];

    _state = CPUndoManagerUndoing;

    [self _beginUndoGrouping];
    [undoGrouping invoke];
    [self endUndoGrouping];

    [_CPUndoGrouping _poolUndoGrouping:undoGrouping];

    _state = CPUndoManagerNormal;

    [[_redoStack lastObject] setActionName:actionName];

    [defaultCenter postNotificationName:CPUndoManagerDidUndoChangeNotification
                                 object:self];
}

- (void)redo
{
    // Don't do anything if we have no redos.
    if ([_redoStack count] <= 0)
        return;

/*    if (_state == NSUndoManagerUndoing)
        [NSException raise:NSInternalInconsistencyException
                    format:@"redo called while undoing"];
*/

    var defaultCenter = [CPNotificationCenter defaultCenter];

    [defaultCenter postNotificationName:CPUndoManagerCheckpointNotification
                                 object:self];

    [defaultCenter postNotificationName:CPUndoManagerWillRedoChangeNotification
                                 object:self];

    var oldUndoGrouping = _currentGrouping,
        undoGrouping = _redoStack.pop(),
        actionName = [undoGrouping actionName];

    _currentGrouping = nil;
    _state = CPUndoManagerRedoing;

    [self _beginUndoGrouping];
    [undoGrouping invoke];
    [self endUndoGrouping];

    [_CPUndoGrouping _poolUndoGrouping:undoGrouping];

    _currentGrouping = oldUndoGrouping;
    _state = CPUndoManagerNormal;

    [[_undoStack lastObject] setActionName:actionName];
    [defaultCenter postNotificationName:CPUndoManagerDidRedoChangeNotification object:self];
}

// Creating Undo Groups
- (void)beginUndoGrouping
{
    // It doesn't matter that the user is creating a group themselves, we are
    // pretending to have opened the group at the beginning of the run loop,
    // so create an implicit one here.
    if (!_currentGrouping && [self groupsByEvent])
        [self _beginUndoGroupingForEvent];

    [[CPNotificationCenter defaultCenter]
        postNotificationName:CPUndoManagerCheckpointNotification
                      object:self];

    [self _beginUndoGrouping];
}

/* @ignore */
- (void)_beginUndoGroupingForEvent
{
    [self _beginUndoGrouping];
    [self _registerWithRunLoop];
}

/* @ignore */
- (void)_beginUndoGrouping
{
    _currentGrouping = [_CPUndoGrouping undoGroupingWithParent:_currentGrouping];
}

- (void)endUndoGrouping
{
    if (!_currentGrouping)
        [CPException raise:CPInternalInconsistencyException reason:"endUndoGrouping. No undo group is currently open."];

    var defaultCenter = [CPNotificationCenter defaultCenter];

    [defaultCenter postNotificationName:CPUndoManagerCheckpointNotification
                                 object:self];

    var parent = [_currentGrouping parent];

    if (!parent && [_currentGrouping invocations].length > 0)
    {
        [defaultCenter
            postNotificationName:CPUndoManagerWillCloseUndoGroupNotification
                          object:self];

        // Put this group on the redo stack if we are currently undoing, otherwise
        // put it on the undo stack.  That way, "undos" become "redos".
        var stack = _state === CPUndoManagerUndoing ? _redoStack : _undoStack;

        stack.push(_currentGrouping);

        if (_levelsOfUndo > 0 && stack.length > _levelsOfUndo)
            stack.splice(0, 1);

        [defaultCenter
            postNotificationName:CPUndoManagerDidCloseUndoGroupNotification
                          object:self];
    }

    // Nested Undo Grouping
    else
    {
        [parent addInvocationsFromArray:[_currentGrouping invocations]];

        [_CPUndoGrouping _poolUndoGrouping:_currentGrouping];
    }

    _currentGrouping = parent;
}

- (void)enableUndoRegistration
{
    if (_disableCount <= 0)
        [CPException raise:CPInternalInconsistencyException
                    reason:"enableUndoRegistration. There are no disable messages in effect right now."];

    _disableCount--;
}

- (BOOL)groupsByEvent
{
    return _groupsByEvent;
}

- (void)setGroupsByEvent:(BOOL)aFlag
{
    aFlag = !!aFlag;

    if (_groupsByEvent === aFlag)
        return;

    _groupsByEvent = aFlag;

    if (![self groupsByEvent])
        [self _unregisterWithRunLoop];
}

- (unsigned)groupingLevel
{
    var grouping = _currentGrouping,
        level = _currentGrouping ? 1 : 0;

    while (grouping = [grouping parent])
        ++level;

    return level;
}

// Disabling Undo
- (void)disableUndoRegistration
{
    ++_disableCount;
}

- (BOOL)isUndoRegistrationEnabled
{
    return _disableCount == 0;
}

// Checking Whether Undo or Redo Is Being Performed
- (BOOL)isUndoing
{
    return _state === CPUndoManagerUndoing;
}

- (BOOL)isRedoing
{
    return _state === CPUndoManagerRedoing;
}

// Clearing Undo Operations
- (void)removeAllActions
{
    // Close off any groupings.
    while (_currentGrouping)
        [self endUndoGrouping];

    // Won't need this anymore
    [self _unregisterWithRunLoop];

    _state = CPUndoManagerNormal;
    _redoStack = [];
    _undoStack = [];
    _disableCount = 0;
}

- (void)removeAllActionsWithTarget:(id)aTarget
{
    [_currentGrouping removeInvocationsWithTarget:aTarget];

    var index = _redoStack.length;

    while (index--)
    {
        var grouping = _redoStack[index];

        [grouping removeInvocationsWithTarget:aTarget];

        if (![grouping invocations].length)
            _redoStack.splice(index, 1);
    }

    index = _undoStack.length;

    while (index--)
    {
        var grouping = _undoStack[index];

        [grouping removeInvocationsWithTarget:aTarget];

        if (![grouping invocations].length)
            _undoStack.splice(index, 1);
    }
}

// Managing the Action Name
- (void)setActionName:(CPString)anActionName
{
    if (anActionName !== nil && _currentGrouping)
        [_currentGrouping setActionName:anActionName];
}

- (CPString)redoActionName
{
    if (![self canRedo])
        return nil;

    return [[_redoStack lastObject] actionName];
}

- (CPString)redoMenuItemTitle
{
    return [self redoMenuTitleForUndoActionName:[self redoActionName]];
}

- (CPString)redoMenuTitleForUndoActionName:(CPString)anActionName
{
    // This handles the empty string ("") case as well.
    if (anActionName || anActionName === 0)

        // FIXME: The terms @"Redo" and @"Redo %@" should be localized.
        // KEYWORDS: Localization
        return @"Redo " + anActionName;

    return @"Redo";
}

- (CPString)undoActionName
{
    if (![self canUndo])
        return nil;

    return [[_undoStack lastObject] actionName];
}

- (CPString)undoMenuItemTitle
{
    return [self undoMenuTitleForUndoActionName:[self undoActionName]];
}

- (CPString)undoMenuTitleForUndoActionName:(CPString)anActionName
{
    // This handles the empty string ("") case as well.
    if (anActionName || anActionName === 0)

        // FIXME: The terms @"Undo" and @"Undo %@" should be localized.
        // KEYWORDS: Localization
        return @"Undo " + anActionName;

    return @"Undo";
}

// Working With Run Loops
- (CPArray)runLoopModes
{
    return _runLoopModes;
}

- (void)setRunLoopModes:(CPArray)modes
{
    _runLoopModes = [modes copy];

    if (_registeredWithRunLoop)
    {
        [self _unregisterWithRunLoop];
        [self _registerWithRunLoop];
    }
}

- (void)_runLoopEndUndoGrouping
{
    [self endUndoGrouping];
    _registeredWithRunLoop = NO;
}

/* @ignore */
- (void)_registerWithRunLoop
{
    if (_registeredWithRunLoop)
        return;

    _registeredWithRunLoop = YES;
    [[CPRunLoop currentRunLoop]
        performSelector:@selector(_runLoopEndUndoGrouping)
                 target:self
               argument:nil
                  order:CPUndoCloseGroupingRunLoopOrdering
                  modes:_runLoopModes];
}

/* @ignore */
- (void)_unregisterWithRunLoop
{
    if (!_registeredWithRunLoop)
        return;

    _registeredWithRunLoop = NO;
    [[CPRunLoop currentRunLoop]
        cancelPerformSelector:@selector(_runLoopEndUndoGrouping)
                       target:self
                     argument:nil];
}

- (void)observeChangesForKeyPath:(CPString)aKeyPath ofObject:(id)anObject
{
    [anObject addObserver:self
              forKeyPath:aKeyPath
                 options:CPKeyValueObservingOptionOld | CPKeyValueObservingOptionNew
                 context:NULL];
}

- (void)stopObservingChangesForKeyPath:(CPString)aKeyPath ofObject:(id)anObject
{
    [anObject removeObserver:self forKeyPath:aKeyPath];
}

- (void)observeValueForKeyPath:(CPString)aKeyPath
                      ofObject:(id)anObject
                        change:(CPDictionary)aChange
                       context:(id)aContext
{
    // Don't add no-ops to the undo stack.
    var before = [aChange valueForKey:CPKeyValueChangeOldKey],
        after = [aChange valueForKey:CPKeyValueChangeNewKey];
    if (before === after || (before !== nil && before.isa && (after === nil || after.isa) && [before isEqual:after]))
        return;

    [[self prepareWithInvocationTarget:anObject]
        applyChange:[aChange inverseChangeDictionary]
          toKeyPath:aKeyPath];
}

@end

var CPUndoManagerRedoStackKey       = @"CPUndoManagerRedoStackKey",
    CPUndoManagerUndoStackKey       = @"CPUndoManagerUndoStackKey",

    CPUndoManagerLevelsOfUndoKey    = @"CPUndoManagerLevelsOfUndoKey",
    CPUndoManagerActionNameKey      = @"CPUndoManagerActionNameKey",
    CPUndoManagerCurrentGroupingKey = @"CPUndoManagerCurrentGroupingKey",

    CPUndoManagerRunLoopModesKey    = @"CPUndoManagerRunLoopModesKey",
    CPUndoManagerGroupsByEventKey   = @"CPUndoManagerGroupsByEventKey";

@implementation CPUndoManager (CPCoding)

- (id)initWithCoder:(CPCoder)aCoder
{
    self = [super init];

    if (self)
    {
        _redoStack = [aCoder decodeObjectForKey:CPUndoManagerRedoStackKey];
        _undoStack = [aCoder decodeObjectForKey:CPUndoManagerUndoStackKey];

        _levelsOfUndo = [aCoder decodeObjectForKey:CPUndoManagerLevelsOfUndoKey];
//        _actionName = [aCoder decodeObjectForKey:CPUndoManagerActionNameKey];
        _currentGrouping = [aCoder decodeObjectForKey:CPUndoManagerCurrentGroupingKey];

        _state = CPUndoManagerNormal;

        [self setRunLoopModes:[aCoder decodeObjectForKey:CPUndoManagerRunLoopModesKey]];
        [self setGroupsByEvent:[aCoder decodeBoolForKey:CPUndoManagerGroupsByEventKey]];
    }

    return self;
}

- (void)encodeWithCoder:(CPCoder)aCoder
{
    [aCoder encodeObject:_redoStack forKey:CPUndoManagerRedoStackKey];
    [aCoder encodeObject:_undoStack forKey:CPUndoManagerUndoStackKey];

    [aCoder encodeInt:_levelsOfUndo forKey:CPUndoManagerLevelsOfUndoKey];
//    [aCoder encodeObject:_actionName forKey:CPUndoManagerActionNameKey];

    [aCoder encodeObject:_currentGrouping forKey:CPUndoManagerCurrentGroupingKey];

    [aCoder encodeObject:_runLoopModes forKey:CPUndoManagerRunLoopModesKey];
    [aCoder encodeBool:_groupsByEvent forKey:CPUndoManagerGroupsByEventKey];
}

@end

@implementation _CPUndoManagerProxy : CPProxy
{
    CPUndoManager   _undoManager;
}

- (CPMethodSignature)methodSignatureForSelector:(SEL)aSelector
{
    return [_undoManager _methodSignatureOfPreparedTargetForSelector:aSelector];
}

- (void)forwardInvocation:(CPInvocation)anInvocation
{
    [_undoManager _forwardInvocationToPreparedTarget:anInvocation];
}

@end