WIP

Here's the flowchart of the system that is read from left to right. A line of code (or pseudo code) is an orange box. Black arrows point from an orange box to its actual method's implementation. Method implementations, if/else blocks, and for loops are in groups. Finally, red lines indicate the order in which the code is run.

And here's a better version read top to down.

I'm now working on implementing updateChangesPostUndoBubble in DocumentDAG. However, I just realized that I will probably need to change the way the NonlinearUndoManager attempts to merge a previously done change. I'm not yet sure how that will affect everything else.

If forgetHistory discards all previous history, should it invalidate the undoAvailable and redoAvailable properties? Also, should it automatically update the marked position to ensure it isn't pointing to some old, forgotten position?

It would be nice if changes could be named so that an undo / redo UI could display the name of the last change that will be undone or redone, e.g. "Undo 'Move Object'".

Coming from TomasMikula/RichTextFX#486 (more specifically, Tomas comment on how to solve an issue):

Another option is to give the UndoManager a way to know whether merge resulted in an empty change. This could be done for example by adding an extra parameter Predicate<C> isEmpty to the factory method create above. Undo manager would then test changes for emptiness and automatically discard empty changes without trying to apply them.

As you can see here:

http://search.maven.org/#artifactdetails%7Corg.fxmisc.undo%7Cundofx%7C1.0.0%7Cjar

The defined dependency:

<dependency>
      <groupId>org.reactfx</groupId>
      <artifactId>reactfx</artifactId>
      <version>1.0+</version>
      <scope>compile</scope>
</dependency>

Has a plus sign which makes the dependency corrupt.

I was wondering if it is possible to add and remove event streams from the stream that is being used by the UndoManager. In my use case the user is creating a flow diagram and keeps adding nodes to it. Each node has an x and a y property. I want to "monitor" these coordinates via the help of two event streams and I want to add them to the event stream of the undo manager without loosing the current history. How can I do this?

Rather than trying to store all changes in the graph and using the queues as proxy (my approach in #10), I decided to store the changes in the queues and use the graph to store the edges and the queues themselves. This way, the queues feel more queue-like and all three types of queues can be used in the same non-linear undo graph: an unlimited, a fixed-size, and a zero-size queue.

Can you change the return results for undoAvailableProperty and redoAvailableProperty to BooleanExpression or BooleanBinding? This would simplify binding Button.disableProperty().bind(UndoManager.undoAvailableProperty().not()) in RichTextFX

This PR is the same as the previous one (#11), just starting from the latest commit and streamlined to remove my earlier mistakes. It does not yet include the NonlinearUndoManagerFactory because I want to work on implementing the FixedSizeNonlinearChangeQueue.

This isn't ready to be merged, but gives you an idea on how I'm trying to implement this.

I still have a few things to figure out:

• How does Current Position get updated now that its position is relative to other changes being added/forgotten/undone/redone?
  • A NonLinearChangeQueue needs two lists: the first for tracking all of the changes it has added (for forgetHistory()) and the second for tracking which undos/redos it can currently undo/redo. Every time a queue undos/redos/adds (and forgets?) a change, all other queue's 2nd list needs to be updated.
• How should FixedSizeQueues be handled? The items to consider are the above situation and the creation of a new edit when a "bubbly" edit is split into two parts, the 'buried' edit that takes the place of the original, and the new 'bubbled' edit that gets put on the top of the graph?
• How should NonLinearChangeQueue#equals method be implemented? Currently, I'm using an int ID that can be set by the NonLinearUndoManagerFactory, but I am not sure if another approach would be better.
• How should the list of undoable/redoable changes be determined? This will use functional programming in some way
• What is the timeline of updates (e.g. adding, undoing/redoing, forgetting history, etc.)?
• Does the current approach insure that new updates are sorted accordingly? (where the first edit in either of the two lists in NonLinearChangeQueue was created before the next one)

This is probably me not understanding the changes in 1.2, but when I undo an action, then redo it, and then try to take a new action, the undo manager crashes with an Unexpected change received.

Am I supposed to send redone changes to the change stream as well?

Hello,

I am experimenting with mark(); and isAtMarkedPosition();

I type in some text let's say word "hello" and set the mark(); position at that point. When I type an extra character (it takes me to a different step) and do control+z to undo, the isAtMarkedPosition() returns false (it should be returning true). Also, when I type in a character and remove that character, then it also isAtMarkedPosition() returns false. The only time when isAtMarkedPosition(); returns false is when you type in "hello", mark();, and then do undo (control + z) and then do redo (control+shift+z). In all other cases, it returns false.

I'm using Scala 2.11.7 with UndoFX in my project, and when I try to compile, the compile fails with assertion failed: TVar<?0=null>.

This only happens with UndoFX 1.2, and it was fine before on UndoFX 1.1.1, and the only changes I've made are to comply with 1.2's new interface. I've even changed from using SAM conversion to instantiate the undo manager to anonymous classes, and the failure still takes place. Even a stacktrace simply spits out internal Scala compiler errors, so I can't quite debug what's causing the error.

My build tool is Gradle 2.7, if it means anything.

I've also tried this on a fresh Gradle Scala project, and the same error results.

This is the sample code for the fresh project that fails to compile:

import java.util.function.{Consumer, Function}

import org.fxmisc.undo.UndoManagerFactory
import org.reactfx.EventSource

object Main {
  val changes = new EventSource[Change]

  val undoManager = UndoManagerFactory.unlimitedHistoryUndoManager(
  changes,
  new Function[Change, Change] {
    override def apply(t: Change): Change = t.invert
  },
  new Consumer[Change] {
    override def accept(t: Change): Unit = t.apply()
  }
  )

}

case class Change(oldVal: Boolean, newVal: Boolean) {
  def invert: Change = Change(newVal, oldVal)

  def apply(): Unit = println(newVal)
}