Undo/Redo的使用,以及用命令模式实现Undo/Redo无限制

 

1. import java.awt.*;
2. import java.awt.event.*;
3. import java.awt.geom.*;
4. import java.net.*;
5. import java.applet.*;
6. import java.util.LinkedList;
7. import java.util.Iterator;
8. import javax.swing.*;
9. import javax.swing.undo.*;
11. /**
12.  * A very simple applet demonstrating usage of javax.swing.undo package.
13.  */
14. public class undomgrtest extends JApplet {
16.     JButton linebutton;
18.     JButton circlebutton;
20.     JButton undobutton;
22.     JButton redobutton;
24.     JPanel buttonpanel;
26.     JGraphPanel graphpanel;
28.     LineListener linelistener;
30.     CircleListener circlelistener;
32.     UndoListener undolistener;
34.     RedoListener redolistener;
36.     LinkedList shapes;
38.     UndoManager undomgr;
40.     public void init() {
42.         // Force SwingApplet to come up in the System L&F
43.         String laf = UIManager.getSystemLookAndFeelClassName();
44.         try {
45.             UIManager.setLookAndFeel(laf);
46.             // If you want the Cross Platform L&F instead, comment out the above line and
47.             // uncomment the following:
48.             // UIManager.setLookAndFeel(UIManager.getCrossPlatformLookAndFeelClassName());
49.         } catch (UnsupportedLookAndFeelException exc) {
50.             System.err.println("Warning: UnsupportedLookAndFeel: " + laf);
51.         } catch (Exception exc) {
52.             System.err.println("Error loading " + laf + ": " + exc);
53.         }
55.         getContentPane().setLayout(new BorderLayout());
56.         linebutton = new JButton("Draw Line");
57.         circlebutton = new JButton("Draw Circle");
58.         undobutton = new JButton("Undo");
59.         redobutton = new JButton("Redo");
60.         graphpanel = new JGraphPanel(false);
61.         graphpanel.setPreferredSize(new Dimension(300, 300));
62.         buttonpanel = new JPanel(false);
63.         buttonpanel.setLayout(new FlowLayout());
64.         buttonpanel.add(linebutton);
65.         buttonpanel.add(circlebutton);
66.         buttonpanel.add(undobutton);
67.         buttonpanel.add(redobutton);
68.         getContentPane().add(buttonpanel, BorderLayout.SOUTH);
69.         getContentPane().add(graphpanel, BorderLayout.NORTH);
70.         linelistener = new LineListener();
71.         linebutton.addActionListener(linelistener);
72.         circlelistener = new CircleListener();
73.         circlebutton.addActionListener(circlelistener);
74.         undolistener = new UndoListener();
75.         undobutton.addActionListener(undolistener);
76.         redolistener = new RedoListener();
77.         redobutton.addActionListener(redolistener);
78.         shapes = new LinkedList();
79.         undomgr = new UndoManager();
80.     }
82.     public void stop() {
84.     }
86.     class JGraphPanel extends JPanel {
87.         public JGraphPanel(boolean doublebuffer) {
88.             super(doublebuffer);
89.         }
91.         public void paintComponent(Graphics g) {
92.             Graphics2D g2 = (Graphics2D) g;
93.             g2.setColor(Color.white);
94.             g2.fill3DRect(0, 0, getWidth(), getHeight(), true);
95.             Iterator it;
96.             Shape shape;
97.             g2.setColor(Color.black);
98.             for (it = shapes.iterator(); it.hasNext();) {
99.                 shape = (Shape) it.next();
100.                 g2.draw(shape);
101.             }
102.         }
103.     }
105.     class LineListener implements ActionListener {
106.         Shape temp;
108.         public void actionPerformed(ActionEvent e) {
109.             temp = new Line2D.Double(0.0, 0.0, Math.random() * 100.0, Math
110.                     .random() * 100.0);
111.             shapes.add(temp);
112.             repaint();
113.             UndoableEdit edit = new graphEdit(temp);
114.             undomgr.addEdit(edit);
115.         }
116.     }
118.     class CircleListener implements ActionListener {
119.         Shape temp;
121.         public void actionPerformed(ActionEvent e) {
122.             temp = new Ellipse2D.Double(0.0, 0.0, Math.random() * 100.0, Math
123.                     .random() * 100.0);
124.             shapes.add(temp);
125.             repaint();
126.             UndoableEdit edit = new graphEdit(temp);
127.             undomgr.addEdit(edit);
129.         }
130.     }
132.     class UndoListener implements ActionListener {
133.         public void actionPerformed(ActionEvent e) {
134.             try {
135.                 undomgr.undo();
136.             } catch (CannotUndoException ex) {
137.                 System.err.println("Can't Undo More");
138.             }
139.         }
140.     }
142.     class RedoListener implements ActionListener {
143.         public void actionPerformed(ActionEvent e) {
144.             try {
145.                 undomgr.redo();
146.             } catch (CannotRedoException ex) {
147.                 System.err.println("Can't Redo More");
148.             }
149.         }
150.     }
152.     class graphEdit extends AbstractUndoableEdit {
153.         Shape shape;
155.         public graphEdit(Shape _shape) {
156.             shape = _shape;
157.         }
159.         public void undo() {
160.             shapes.remove(shape);
161.             repaint();
162.             System.out.println("undo draw line");
163.         }
165.         public void redo() {
166.             shapes.add(shape);
167.             repaint();
168.             System.out.println("redo draw line");
169.         }
170.     }
171. }

174. 利用Command模式实现无限次数的Undo/Redo功能- - 
175. 几乎现在所有的文档式应用程序中，都提供了恢复/撤消功能，如Word,Excel,还有我们的写Java程序用的JBuilder。
177. 在早期，许多的应用程序还只能提供单一的Undo/Redo，自进入90年代以来，随着OOP及Design Pattern的流行，实现无限次数的Undo/Redo编辑功能已不是难事。
179. 每一个编辑动作我们可以把它当成一个命令，如cut,del等，在做每一个编辑动作前，我们先要保存旧的数据，以便于undo它。我们为这些编辑命令设计了如下一个通用接口:
180. public Interface Command
181. {
183.     public void execute();　
185.     public void undo();
187. }
188. 其中execute用来执行命令,undo用来恢复(undo).
190. 接下来实现这个接口,先来实现Cut命令:
191. public class CutCommand implements Command
192. {
194.     public void execute()
195.     {
196.         /* 备份旧数据 */
197.         /* 剪切 */
199.     }
201.     public void undo()
202.     {
203.          /*  还原成备份的数据  */
204.     }
206. }
210. 再来实现一个Delete命令:
211. public class DeleteCommand implements Command
212. {
214.     public void execute()
215.     {
216.         /* 备份旧数据 */
217.         /* 删除 */
219.     }
221.     public void undo()
222.     {
223.          /*  还原成备份的数据  */
224.     }
226. }
230. OK,我们就只列出了cut和del两个命令,其它的命令相似的写法.
233. 这样的话我们每做一个编辑动作,就执行一个相应的command.接下来我们要考虑如何将这些执行过的命令保存下来,以实现undo/redo. 我们再设计一个CommandManager:
234. public Interface CommandManager
235. {
236.     public void storeCommand(Command cmd);
237.     public void clearAllCommand();
238.     public void undo();
239.     public void redo();
240. }
241. 再来实现一个CommandManager, 我们称作CommandHistoryManager:
242. public class CommandHistoryManager implements CommandManager
243. {
244.  Vector undoList=new Vector();
245.  Vector redoList=new Vector();
248.  public void storeCommand(Command cmd)
249.  {
250.   undoList.add(cmd);
251.  }
252.  public void clearAllCommand()
253.  {
254.   undoList.clear();
255.   redoList.clear();
256.  }
257.  public void undo()
258.  {
259.         if ( undoList.size() <= 0 ) return;
260.         Command cmd = ((Command)(undoList.get(undoList.size()-1)));
261.         cmd.undo();
262.         undoList.remove(cmd);
263.         redoList.add(cmd);
264.  }
265.  public void redo()
266.  {
267.         if ( redoList.size() <= 0 ) return;
268.         Command cmd = ((Command)(redoList.get(redoList.size()-1)));
269.         cmd.execute();
270.         redoList.remove(cmd);
271.         undoList.add(cmd);
272.   
273.  }
275. }
276. 通过storeCommand()方法，每次执行的command就可以保存到undoList中，假设再在我们在程序中放置了两个按钮，一个undo,一个redo.按下undo按钮，就执行CommandHistoryManager的undo()方法，undo()方法会调用undoList中保存的最后一个command的undo()方法，并将这个command再放到redoList中，最后从undoList中删除这个命令。这时如果再按redo按钮，它会调用CommandHistoryManager中的redo()方法。redo()方法会调用redoList中保存的最后一个command的execute()方法，并将这个command又存回到undoList中。这样就实现了无限次数的undo/redo功能。

1. 利用Command模式实现无限次数的Undo/Redo功能- - 
2. 几乎现在所有的文档式应用程序中，都提供了恢复/撤消功能，如Word,Excel,还有我们的写Java程序用的JBuilder。
4. 在早期，许多的应用程序还只能提供单一的Undo/Redo，自进入90年代以来，随着OOP及Design Pattern的流行，实现无限次数的Undo/Redo编辑功能已不是难事。
6. 每一个编辑动作我们可以把它当成一个命令，如cut,del等，在做每一个编辑动作前，我们先要保存旧的数据，以便于undo它。我们为这些编辑命令设计了如下一个通用接口:
7. public Interface Command
8. {
10.     public void execute();　
12.     public void undo();
14. }
15. 其中execute用来执行命令,undo用来恢复(undo).
17. 接下来实现这个接口,先来实现Cut命令:
18. public class CutCommand implements Command
19. {
21.     public void execute()
22.     {
23.         /* 备份旧数据 */
24.         /* 剪切 */
26.     }
28.     public void undo()
29.     {
30.          /*  还原成备份的数据  */
31.     }
33. }
37. 再来实现一个Delete命令:
38. public class DeleteCommand implements Command
39. {
41.     public void execute()
42.     {
43.         /* 备份旧数据 */
44.         /* 删除 */
46.     }
48.     public void undo()
49.     {
50.          /*  还原成备份的数据  */
51.     }
53. }
57. OK,我们就只列出了cut和del两个命令,其它的命令相似的写法.
60. 这样的话我们每做一个编辑动作,就执行一个相应的command.接下来我们要考虑如何将这些执行过的命令保存下来,以实现undo/redo. 我们再设计一个CommandManager:
61. public Interface CommandManager
62. {
63.     public void storeCommand(Command cmd);
64.     public void clearAllCommand();
65.     public void undo();
66.     public void redo();
67. }
68. 再来实现一个CommandManager, 我们称作CommandHistoryManager:
69. public class CommandHistoryManager implements CommandManager
70. {
71.  Vector undoList=new Vector();
72.  Vector redoList=new Vector();
75.  public void storeCommand(Command cmd)
76.  {
77.   undoList.add(cmd);
78.  }
79.  public void clearAllCommand()
80.  {
81.   undoList.clear();
82.   redoList.clear();
83.  }
84.  public void undo()
85.  {
86.         if ( undoList.size() <= 0 ) return;
87.         Command cmd = ((Command)(undoList.get(undoList.size()-1)));
88.         cmd.undo();
89.         undoList.remove(cmd);
90.         redoList.add(cmd);
91.  }
92.  public void redo()
93.  {
94.         if ( redoList.size() <= 0 ) return;
95.         Command cmd = ((Command)(redoList.get(redoList.size()-1)));
96.         cmd.execute();
97.         redoList.remove(cmd);
98.         undoList.add(cmd);
99.   
100.  }
102. }
103. 通过storeCommand()方法，每次执行的command就可以保存到undoList中，假设再在我们在程序中放置了两个按钮，一个undo,一个redo.按下undo按钮，就执行CommandHistoryManager的undo()方法，undo()方法会调用undoList中保存的最后一个command的undo()方法，并将这个command再放到redoList中，最后从undoList中删除这个命令。这时如果再按redo按钮，它会调用CommandHistoryManager中的redo()方法。redo()方法会调用redoList中保存的最后一个command的execute()方法，并将这个command又存回到undoList中。这样就实现了无限次数的undo/redo功能。