Implementing redo alongside undo with UndoManager in drawing application Swift 3 - ios

Question

I am working on a project that includes an annotation tool allowing users to "draw" on documents with finger gestures or a pencil. Naturally, I'm keen on implementing undo/redo for drawn paths.
My implementation for the drawing app is relatively conventional. What the user sees on the screen is the combination of a cached bitmap image (a snapshot of all the paths that have been drawn before the current one) together with a "live" rendering of the current path (a UIBezierPath). When touchesEnded is triggered, the new path is added to the bitmap.
I have been able to implement undo with relatively little trouble. I have created a standard undoManager for the class:
let myUndoManager : UndoManager = {
let mUM : UndoManager = UndoManager()
mUM.levelsOfUndo = 6
return mUM
}()
The function that is called at the end of touchesEnded to render the new cached path is called drawBitmap. At the start of this function, assuming there is a previous cached path and before drawing the new one, I register the following undo action with the undo manager:
let previousCachedPath : UIImage = self.cachedPath
self.myUndoManager.registerUndo(withTarget: self, selector: #selector(self.setBitmap(_:)), object: previousCachedPath)
setBitmap(_ previousCachedPath : UIImage) is a function that resets the displayed bitmap to the provided image.
I have a undo/redo buttons linked to undo() and redo() methods respectively. Aside from some logic dictating when these buttons should be active (i.e. to make sure you can't press undo when nothing has been drawn etc.), these simply call myUndoManager.undo() and myUndoManager.redo() respectively:
func undo() -> Void {
guard self.myUndoManager.canUndo else { return }
self.myUndoManager.undo()
if !self.redoButton.isEnabled {
self.redoButton.isEnabled = true
}
if !self.myUndoManager.canUndo {
self.undoButton.isEnabled = false
}
self.setNeedsDisplay()
}
func redo() -> Void {
guard self.myUndoManager.canRedo else { return }
self.myUndoManager.redo()
if !self.undoButton.isEnabled {
self.undoButton.isEnabled = true
}
if !self.myUndoManager.canRedo {
self.redoButton.isEnabled = false
}
self.setNeedsDisplay()
}
As I mentioned, undo works perfectly to the specified six levels of undoability. However, I'm clearly missing something with redo. My initial hope was that the undoManager would automatically transfer undo tasks from the undo stack to the redo stack when undo is called, but this is clearly not happening.
I have already searched for answers, and I think the closest to what I need may to use mutual recursion as per:
Using NSUndoManager, how to register undos using Swift closures
However, I have been unable to make this work. Any help therefore appreciated!

Answer 1

Thanks to #matt 's help, I solved this by putting everything in the setBitmap(_:) function. To try and better understand things, I implemented both the registerUndo(withTarget:selector:) approach:
func setBitmap(_ toCachedPath : UIImage) -> Void {
self.myUndoManager.registerUndo(withTarget: self, selector: #selector(self.setBitmap(_:)), object: self.cachedPath)
UIGraphicsBeginImageContextWithOptions(self.bounds.size, false, 0.0)
toCachedPath.draw(at: CGPoint.zero)
self.cachedPath = UIGraphicsGetImageFromCurrentImageContext()
UIGraphicsEndImageContext()
}
And also with the prepare(withInvocationTarget:) approach:
func setBitmap(_ toCachedPath : UIImage) -> Void {
if self.cachedPath != nil {
(self.rWUndoManager.prepare(withInvocationTarget: self) as AnyObject).setBitmap(self.cachedPath)
}
UIGraphicsBeginImageContextWithOptions(self.bounds.size, false, 0.0)
toCachedPath.draw(at: CGPoint.zero)
self.cachedPath = UIGraphicsGetImageFromCurrentImageContext()
UIGraphicsEndImageContext()
}
Hope that helps anybody else who were scratching their heads as much as I was.

Answer 2

Actually you could use the closure version registerUndo(withTarget:handler:) for redo to work too. Just make sure it would work with the selector one registerUndo(withTarget:selector:object:) first, i.e. make a function which takes only one parameter, like in your answer. And then you can replace the selector-based method with the closure one:
func setBitmap(_ toCachedPath : UIImage) -> Void {
let oldCachedPath = cachedPath // For not referencing it with `self` in the closure.
myUndoManager.registerUndo(withTarget: self) {
$0.setBitmap(oldCachedPath)
}
UIGraphicsBeginImageContextWithOptions(self.bounds.size, false, 0.0)
toCachedPath.draw(at: CGPoint.zero)
self.cachedPath = UIGraphicsGetImageFromCurrentImageContext()
UIGraphicsEndImageContext()
}
I guess the closure version is just a repackage of the selector version which recognises only one method and one input parameter, so we still have to write like this for it to work.