Changeset 744

Timestamp:

01/24/14 10:10:59 (10 years ago)

Author:

jts21

Message:

• Implement redo buffer (every time you undo the changes get pushed to the redo buffer)
• Modify undo/redo so each individual undo/redo is either a deletion or a modification, this fixes the problem where undoing a modification to an item whose id had changed would clone the item (now instead it will just not undo that modification, which should be fine since the only way to change an item's ID now is to move it to another frame and back again)
• Fix issue with copying/cutting when there were items on FreeItems that were connected to items on the Frame (i.e. when you were moving the corner of a shape)

Location:

trunk/src/org/expeditee

Files:

• agents/Format.java (modified) (1 diff)
• agents/HFormat.java (modified) (1 diff)
• gui/Frame.java (modified) (5 diffs)
• gui/FrameKeyboardActions.java (modified) (1 diff)
• gui/FrameMouseActions.java (modified) (4 diffs)
• gui/Help.java (modified) (1 diff)

trunk/src/org/expeditee/agents/Format.java

@@ -163 +163 @@
                  */
                 start.setChanged(true);
-                start.addToUndo(changedItems);
+                start.addToUndoMove(changedItems);
                 FrameGraphics.requestRefresh(true);
                 return null;

trunk/src/org/expeditee/agents/HFormat.java

@@ -48 +48 @@
                 
                 System.out.println(changedItems);
-                start.addToUndo(changedItems);
+                start.addToUndoMove(changedItems);
                 return null;
         }

trunk/src/org/expeditee/gui/Frame.java

@@ -94 +94 @@
         private boolean _saved = false;
 
+        private static final class History {
+                public enum Type {
+                        deletion,
+                        movement
+                }
+                public final List<Item> items;
+                public final Type type;
+                
+                public History(Collection<Item> items, Type type) {
+                        this.items = new LinkedList<Item>(items);
+                        this.type = type;
+                }
+                
+                public String toString() {
+                        return this.type.toString() + ":\n" + this.items.toString();
+                }
+        }
+        
         // list of deleted items that can be restored
-        private Stack<List<Item>> _undo = new Stack<List<Item>>();
+        private Stack<History> _undo = new Stack<History>();
+        private Stack<History> _redo = new Stack<History>();
 
         // basically just a list of smaller objects?
@@ -892 +911 @@
 
         /**
-         * Adds the given list of Items to the undo stack. This is the same as
-         * calling addToUndo() for each Item in the list.
-         * 
-         * @param items
-         *            The List of Items to add to the undo stack.
-         */
-        public void addToUndo(Collection<Item> items) {
+         * Adds the given History event to the stack.
+         * 
+         * @param stack The stack to add to
+         * @param items The items to put in the event
+         * @param type  The type of event that occurred
+         */
+        private void addToUndo(Collection<Item> items, History.Type type) {
                 if (items.size() < 1)
                         return;
                 
-//              System.out.println("Added: " + items);
-
-                _undo.push(new LinkedList<Item>(items));
+                System.out.println("Added: " + items);
+
+                _undo.push(new History(items, type));
+        }
+        
+        public void addToUndoDelete(Collection<Item> items) {
+                addToUndo(items, History.Type.deletion);
+        }
+        public void addToUndoMove(Collection<Item> items) {
+                addToUndo(items, History.Type.movement);
         }
 
         public void undo() {
-                List<Item> undo = null;
                 boolean bReparse = false;
                 boolean bRecalculate = false;
@@ -915 +940 @@
                         return;
 
-                undo = _undo.pop();
+                History undo = _undo.pop();
                 
-//              System.out.println("Undoing: " + undo);
-
-                for(Item i : undo) {
-                        // if the change was to characteristics
-                        if(i.isVisible() && _body.contains(i)) {
-                                _body.set(_body.indexOf(i), i);
-                        // the item was deleted
-                        } else {
-                                _body.add(i);
+                System.out.println("Undoing: " + undo);
+
+                switch(undo.type) {
+                case deletion:
+                        _redo.push(undo);
+                for(Item i : undo.items) {
+                        _body.add(i);
                                 bReparse |= i.hasOverlay();
                                 bRecalculate |= i.recalculateWhenChanged();
@@ -935 +958 @@
                                         i.setOffset(0, 0);
                                 }
-                        }
+                }
+                break;
+                case movement:
+                        List<Item> changed = new LinkedList<Item>(_body);
+                        changed.retainAll(undo.items);
+                        _redo.push(new History(changed, History.Type.movement));
+                        for(Item i : undo.items) {
+                                int index;
+                                if(i.isVisible() && (index = _body.indexOf(i)) != -1) {
+                                        _body.set(index, i);
+                                }
+                }
+                        break;
+                }
+                change();
+                FrameMouseActions.getInstance().refreshHighlights();
+                if (bReparse) {
+                        FrameUtils.Parse(this, false, false);
+                } else {
+                        notifyObservers(bRecalculate);
+                }
+                // always request a refresh otherwise filled shapes
+                // that were broken by a deletion and then reconnected by the undo
+                // don't get filled until the user otherwise causes them to redraw
+                FrameGraphics.requestRefresh(false);
+                FrameGraphics.Repaint();
+                ItemUtils.EnclosedCheck(_body);
+        }
+        
+        public void redo() {
+                boolean bReparse = false;
+                boolean bRecalculate = false;
+
+                if (_redo.size() <= 0)
+                        return;
+
+                History redo = _redo.pop();
+                
+                System.out.println("Redoing: " + redo);
+
+                switch(redo.type) {
+                case deletion:
+                        _undo.push(redo);
+                for(Item i : redo.items) {
+                        _body.remove(i);
+                                bReparse |= i.hasOverlay();
+                                bRecalculate |= i.recalculateWhenChanged();
+                                if (i instanceof Line) {
+                                        Line line = (Line) i;
+                                        line.getStartItem().removeLine(line);
+                                        line.getEndItem().removeLine(line);
+                                } else {
+                                        i.setOffset(0, 0);
+                                }
+                }
+                break;
+                case movement:
+                        List<Item> changed = new LinkedList<Item>(_body);
+                        changed.retainAll(redo.items);
+                        _undo.push(new History(changed, History.Type.movement));
+                        for(Item i : redo.items) {
+                                int index;
+                                if(i.isVisible() && (index = _body.indexOf(i)) != -1) {
+                                        _body.set(index, i);
+                                }
+                }
+                        break;
                 }
                 change();
@@ -1477 +1566 @@
                 }
                 _body.removeAll(newBody);
-                addToUndo(_body);
+                addToUndoDelete(_body);
                 _body = newBody;
                 change();

trunk/src/org/expeditee/gui/FrameKeyboardActions.java

@@ -817 +817 @@
                         break;
                 case KeyEvent.VK_Z:
-                        DisplayIO.getCurrentFrame().undo();
+                        if(isShiftDown) {
+                                DisplayIO.getCurrentFrame().redo();
+                        } else {
+                                DisplayIO.getCurrentFrame().undo();
+                        }
                         return;
                 case KeyEvent.VK_D:

trunk/src/org/expeditee/gui/FrameMouseActions.java

@@ -1675 +1675 @@
                 inWindow = false;
                 // System.out.println("Left window");
-                if(FreeItems.itemsAttachedToCursor())
-                        ItemSelection.cut();
+                if(FreeItems.itemsAttachedToCursor()) {
+                        boolean cut = true;
+                        for(Item i : FreeItems.getInstance()) {
+                                for(Item j : i.getAllConnected()) {
+                                        if(!FreeItems.getInstance().contains(j)) {
+                                                cut = false;
+                                                break;
+                                        }
+                                }
+                        }
+                        if(cut) {
+                                ItemSelection.cut();
+                        }
+                }
         }
         
@@ -2599 +2611 @@
                                 // otherwise this is an undo command
                         } else {
-                                DisplayIO.getCurrentFrame().undo();
+                                if(isControlDown()) {
+                                        DisplayIO.getCurrentFrame().redo();
+                                } else {
+                                        DisplayIO.getCurrentFrame().undo();
+                                }
                         }
                         return;
@@ -2669 +2685 @@
                         SessionStats.DeletedItems(toUndo);
                         if (parent != null) {
-                                parent.addToUndo(toUndo);
+                                parent.addToUndoDelete(toUndo);
                                 parent.removeAllItems(toUndo); // toDelete.getConnected()
                         }
@@ -2755 +2771 @@
                 // the current frame as well as the overlay frame
                 Frame currentFrame = DisplayIO.getCurrentFrame();
-                currentFrame.addToUndo(itemList);
+                currentFrame.addToUndoDelete(itemList);
                 itemList.clear();
                 if (bReparse) {

trunk/src/org/expeditee/gui/Help.java

@@ -129 +129 @@
                         break;
                 case background:
-                        if((other & cursor) == 0) return "Undo last delete";
+                        if((other & cursor) == 0) {
+                                if((mod & control) != 0) return "Redo";
+                                return "Undo";
+                        }
                         break;
                 }