Skip to main content

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.






Comments

Popular posts from this blog

Implementing a busy indicator using a visual overlay in MVVM

This is a technique we use at work to lock the UI whilst some long running process is happening - preventing the user clicking on stuff whilst it's retrieving or rendering data. Now we could have done this by launching a child dialog window but that feels rather out of date and clumsy, we wanted a more modern pattern similar to the way <div> overlays are done on the web. Imagine we have the following simple WPF app and when 'Click' is pressed a busy waiting overlay is shown for the duration entered into the text box. What I'm interested in here is not the actual UI element of the busy indicator but how I go about getting this to show & hide from when using MVVM. The actual UI elements are the standard Busy Indicator coming from the WPF Toolkit : The XAML behind this window is very simple, the important part is the ViewHost. As you can see the ViewHost uses a ContentPresenter element which is bound to the view model, IMainViewModel, it contains 3 child v

Custom AuthorizationHandler for SignalR Hubs

How to implement IAuthorizationRequirement for SignalR in Asp.Net Core v5.0 Been battling this for a couple of days, and eventually ended up raising an issue on Asp.Net Core gitHub  to find the answer. Wanting to do some custom authorization on a SignalR Hub when the client makes a connection (Hub is created) and when an endpoint (Hub method) is called:  I was assuming I could use the same Policy for both class & method attributes, but it ain't so - not because you can't, because you need the signatures to be different. Method implementation has a resource type of HubInnovationContext: I assumed class implementation would have a resource type of HubConnectionContext - client connects etc... This isn't the case, it's infact of type DefaultHttpContext . For me I don't even need that, it can be removed completely  from the inheritence signature and override implementation. Only other thing to note, and this could be a biggy, is the ordering of the statements in th

Showing a message box from a ViewModel in MVVM

I was doing a code review with a client last week for a WPF app using MVVM and they asked ' How can I show a message from the ViewModel? '. What follows is how I would (and have) solved the problem in the past. When I hear the words ' show a message... ' I instantly think you mean show a transient modal message box that requires the user input before continuing ' with something else ' - once the user has interacted with the message box it will disappear. The following solution only applies to this scenario. The first solution is the easiest but is very wrong from a separation perspective. It violates the ideas behind the Model-View-Controller pattern because it places View concerns inside the ViewModel - the ViewModel now knows about the type of the View and specifically it knows how to show a message box window: The second approach addresses this concern by introducing the idea of messaging\events between the ViewModel and the View. In the example below