Playing around with undo & redo functionality on WP7

Following on from my previous post about 'undo, redo, undo, redo' I thought I would port this to WP7, I say port more a case of re-compile. What follows is an example of simple WP7 app using undo-redo functionality, whether this is any use for a real-world Wp& is up for debate.

I pushed the code out to GitHub here, the only explicit changes required was a WP7 solution & project files. I also added support for INotifyPropertyChanged this allows the CanUndo & CanRedo properties to push out change notifications - this was done to allow the binding of the enable property of an input control (button). So now the undoable class looks like this; the same implementation for all .Net versions:

public class Undoable : INotifyPropertyChanged
{
    public event PropertyChangedEventHandler PropertyChanged = delegate { };

    private readonly Stack<Memento> undoStack;
    private readonly Stack<Memento> redoStack;

    public Undoable()
    {
        undoStack = new Stack<Memento>();
        redoStack = new Stack<Memento>();
    }

    public bool CanUndo
    {
        get { return undoStack.Count != 0; }
    }

    public bool CanRedo
    {
        get { return redoStack.Count != 0; }
    }

    public void Add(Action undoAction)
    {
        undoStack.Push(new Memento(undoAction));
        redoStack.Clear();

        RaisePropertyChanged(() => CanUndo);
        RaisePropertyChanged(() => CanRedo);
    }

    public void Add(Action undoAction, Action redoAction)
    {
        undoStack.Push(new Memento(undoAction, redoAction));
        redoStack.Clear();

        RaisePropertyChanged(() => CanUndo);
        RaisePropertyChanged(() => CanRedo);
    }
        
    public void Undo()
    {
        if (undoStack.Count == 0)
        {
            return;
        }

        var current = undoStack.Pop();
        current.Undo();

        if (current.Redo != null)
        {
            redoStack.Push(current);
        }

        RaisePropertyChanged(() => CanUndo);
        RaisePropertyChanged(() => CanRedo);
    }

    public void Redo()
    {
        if (redoStack.Count == 0)
        {
            return;
        }

        var current = redoStack.Pop();
        current.Redo();
        undoStack.Push(current);

        RaisePropertyChanged(() => CanUndo);
        RaisePropertyChanged(() => CanRedo);
    }
        
    public void Clear()
    {
        redoStack.Clear();
        undoStack.Clear();

        RaisePropertyChanged(() => CanUndo);
        RaisePropertyChanged(() => CanRedo);
    }

    protected void RaisePropertyChanged<T>(Expression<Func<T>> expression)
    {
        PropertyChanged(this, new PropertyChangedEventArgs(ExpressionHelper.Name(expression)));
    }
}

The only thing of note in the above code snippet is the method signature of the RaisePropertyChanged method. I use an expression to avoid using magic strings for property names, the expression is then evaluated and returns the property name when evaluated inside the method.

So how is this used?

As I said in the previous post this was designed to be used from a Controller (ViewModel). The Controller 'controls' what & when is added to the undo list. In the following case the Controller has explicit properties to expose the state of the Model - properties on the ViewModel exposing properties on the Model, we aren't directly binding the Model to View. I'm inject the dependancies for the ViewModel and the Undoable instance is one of them - this could be shared between different ViewModels if required.

public class MainViewModel : ViewModelBase
{
    readonly Widget widget;
    readonly Undoable undoable;

    public MainViewModel(Undoable undoable)
    {
        this.undoable = undoable;
        widget = new Widget();
    }

    public Undoable Undoable
    {
        get { return undoable; }
    }

    public string Identifier
    {
        get { return widget.Identifier; }
        set
        {
            SetPropertyWithUndoActions(widget.Identifier,
                                       value,
                                       str => { widget.Identifier = str; },
                                       () => Identifier); 
        }
    }
}

The interesting part is the SetPropertyWithUndoActions method, as the name suggests it sets the value on the Model and adds actions to the undo-redo list represented by the Undoable instance. What I'm not showing here is there are 2 other similar method properties being exposed Name & Description. The ViewModel exposes these 3 properties to the View model.

The SetPropertyWithUndoActions method is shown below:

private void SetPropertyWithUndoActions<T>(T currentValue,
                                           T newValue,
                                           Action<T> setValue,
                                           Expression<Func<T>> expression)
{
    if (Equals(currentValue, newValue))
    {
        return;
    }

    var cVal = currentValue;
    undoable.Add(() =>
                 {
                     setValue(cVal);
                     RaisePropertyChanged(ExpressionHelper.Name(expression));
                 },
                 () =>
                 {
                     setValue(newValue);
                     RaisePropertyChanged(ExpressionHelper.Name(expression));
                 });

    setValue(newValue);
    RaisePropertyChanged(ExpressionHelper.Name(expression));
}

So now when ever I change the text in the text boxes representing the Identifier, Name or Description I will be able to undo & redo those actions. I wired the undo & redo to app bar buttons in the test app.

The screen shots don't really do it justice, but a user can now undo\redo any input field actions. There are a couple of caveats for the example app - it doesn't move the focus correctly when undo\redo an action and it does not place the cursor at the correct location either, both of these could be sorted out with some View specific logic.

The code for the WP7 demo app is available on the GitHub - check out the WP7 solution test project. I've also created a NuGet package.