I have a few questions about this code.

Shouldn't this be the following?

             setAfter( edit.getAfter() );

The edit for which the addEdit() method is executing is the previous edit,
the one that is already in the UndoManager queue.  It is the "this" edit
that is supposed to absorb anEdit, not the other way around, so the "this"
value should be modified.

I also wonder about the way that you call shouldAdd() twice.  First, it is
not the most efficient way to do things.  Why compute the value twice?
But far more important than that is the question of whether it will return
the same value from both calls.  Even if you know that it will, it is
better if this code is written so that the inconsistency cannot happen.

Finally, the shouldAdd() method cannot see the "anEdit" parameter that is
passed to addEdit(), so I wonder, how is it supposed to determine whether
the edit can be added?  It looks like you will get a ClassCastException if
an edit other than an UndoableGpsJTextFieldEdit were passed to addEdit().

For comparison, here is the addEdit() method from an UndoableEdit
implementation that I wrote a while back:

     public boolean addEdit( UndoableEdit edit ) {
        if ( edit instanceof MoveEdit ) {
           MoveEdit e = (MoveEdit) edit;
           if ( target == e.target ) {
              newPosition = e.newPosition;
              return true;
           }
        }
        return false;
     }

It occurs to me now that I probably should have added an e.die() just
before the return true.  I do not think it is critical, but it would be
appropriate.

That works, but I usually want to update the state of the undo and redo
Actions, so that the user knows whether undo and/or redo can be performed.
So I use a listener something like this:

  private UndoableEditListener editListener = new UndoableEditListener() {
     public void undoableEditHappened( UndoableEditEvent event ) {
        undoManager.addEdit( event.getEdit() );
        updateUndoActions();
     }
  };