使用设计模式实现Undo,Redo框架

编辑器程序少不了要支持undo, redo功能，如何实现？本文就是参考了设计模式中给出的思路实现了一个。

这里主要用到了两个模式：命令(command)模式， 备忘录(memento)模式

所谓编辑，功能上可以分成3个原子操作：添加新内容，编辑已有内容，删除已有内容, 因此编辑功能3个command实现，AddCommand, EditCommand, DeleteCommand. 这3个命令实现了相同的接口do, undo.

 

先说一下代码的风格，自从使用WTL，就喜欢上了WTL的代码风格，本文就是仿照WTL风格写的.

先看一下Command的接口：

 

1. class CCommand  
2. {
4. public:
5.  virtual ~CCommand();
7. public:
8.  virtual bool Do() = 0;
9.  virtual bool Undo() = 0;
10.  virtual bool CanUndo() = 0;
12. };

AddCommand, EditCommand, DeleteCommand都实现了这个接口类。

下面WTL风格代码开始了：

先留个空架子

 

 

1. template<class TBase/*where TBase : public CCommand*/>
2. class CCommandImplBase : public TBase
3. {
4. ／／先空着，以后留着扩展
5. };

下面是主要实现：用到了event, 当Command执行时会触发event,你可以在时间里做一些诸如试图更新, 所谓event，跟C#里的事件相似，感兴趣的可以看我前面的文章用C++模拟C#事件机制。

 

 

1. template< class T, class TBase = CCommand, class TTraits = CommandTraits >
2. class CCommandImpl : public CCommandImplBase
3. {
4. public:
5.  typedef TTraits::CmdEvent CmdEvent;
6.  typedef CmdEvent::EventHandler EventHandler;
8. public:
9.  CCommandImpl(typename CmdEvent::EventArgs/* const& */args) : m_Args(args)
10.  {
11. #if (_MSC_VER >= 1300)
12.   //COMPLIE_ASSERT(IsPointer(args));
13.   bool bRet = TypeTraits::IsPointer();
14. #endif
15.  }
16.  virtual ~CCommandImpl()
17.  {
19.  }
22. public:
23.  void RegisterDoHandler(typename CmdEvent::EventHandler/* const*/& handler)
24.  {
25.   m_DoEvent += handler;
26.  }
28.  void UnRegisterDoHandler(typename CmdEvent::EventHandler/* const*/& handler)
29.  {
30.   m_DoEvent -= handler;
31.  }
33.  void RegisterUndoHandler(typename CmdEvent::EventHandler/* const*/& handler)
34.  {
35.   m_UndoEvent += handler;
36.  }
38.  void UnRegisterUndoHandler(typename CmdEvent::EventHandler/* const*/& handler)
39.  {
40.   m_UndoEvent -= handler;
41.  }
45. public:
47.  virtual bool Do()
48.  {
49.   if (!DoCommand())
50.   {
51.    return false;
52.   }
54.   typename CmdEvent::ReturnValue ret = m_DoEvent(GetEventArgs());
55.   
56.   return true;
57.  }
59.  virtual bool Undo()
60.  {
61.   if (!CanUndo())
62.   {
63.    return false;
64.   }
65.   
66.   if (!UndoCommand())
67.   {
68.    return false;
69.   }
71.   typename CmdEvent::ReturnValue ret = m_UndoEvent(GetEventArgs());
72.   
73.   return true;
74.  }
76.  virtual bool CanUndo()
77.  {
78.   return TTraits::CanUndo;
79.  }
81. protected:
82.  virtual bool DoCommand() = 0;
83.  virtual bool UndoCommand(){return true;}
85. // implementations
86. protected:
87.  typename CmdEvent::EventArgs /*const&*/ GetEventArgs() const
88.  {
89.   return m_Args;
90.  }
92. private:
94.  CmdEvent m_DoEvent;
95.  CmdEvent m_UndoEvent;
96.  typename CmdEvent::EventArgs m_Args;
97. };

这里用到了CommandTraits模板，所谓Traits,能在编译时提供一些类型信息,感兴趣的同学可以去侯捷的网站看看Traits: 類型的else-if-then機製，相关的文章好多。

CommandTraits是一系列模板特化, 每个Traits包含一个event类型, 这在前面已经用到了.

 

1. template<class T>
2. struct CommandTraits;
4. //Common Command Traits
6. template<>
7. struct CommandTraits
8. {
9.  typedef Event<bool, CAddEventArgs const*> CmdEvent;
10.  enum { CanUndo = true};
11. };
13. template<>
14. struct CommandTraits
15. {
16.  typedef Event<bool, CEditEventArgs const*> CmdEvent;
17.  enum { CanUndo = true};
18. };
20. template<>
21. struct CommandTraits
22. {
23.  typedef Event<bool, CDeleteEventArgs const*> CmdEvent;
24.  enum { CanUndo = true};
25. };

在接下来就是

AddCommand, EditCommand, DeleteCommand 的实现了

可以使用备忘录模式将每个命令需要保存的数据(CmdEvent::EventArgs)提取出来，可以用一组get,set操作实现状态的提取和保存，具体保存的内容因项目而易，很简单，不罗嗦了：

 

 

1. class CAddCommand : public CCommandImpl
2. {
3. public:
4.  CAddCommand(CAddEventArgs const* pArgs);
5.  virtual ~CAddCommand();
6. protected:
7.  virtual bool DoCommand()
9.  {
11.     //这里写实际的代码，比如可以将输入的内容存起来. 可以考虑用备忘录模式实现下同，就不罗列代码了
13.  }
15.  virtual bool UndoCommand()
17.  {
19.     //这里写实际的代码，比如可以将输入的内容删掉. 下同，就不罗列代码了
21.  }
23. };
25. class CEditCommand : public CCommandImpl
26. {
27. public:
28.  CEditCommand(CEditEventArgs const* pArgs);
29.  virtual ~CEditCommand();
30. protected:
31.  virtual bool DoCommand();
33.  virtual bool UndoCommand();

}; class  CDeleteCommand :  public  CCommandImpl { public :  CDeleteCommand(CDeleteEventArgs  const * pArgs);   virtual  ~CDeleteCommand(); protected :   virtual   bool  DoCommand();   virtual   bool  UndoCommand(); };

所有的命令都全了，可是还要把所有命令按顺序存储,Undo的时候这按这个相反的顺序拿出来就可以了,用std::stack正好,下面实现了一个CCommandManager  , 就是用来管理命令的：

 

 

1. template< class TCommand /*where TCommand : public CCommand*/ >
2. class CCommandManager  
3. {
4. public:
5.  CCommandManager()
6.  :m_UndoStack()
7.  {
9.  }
10.  virtual ~CCommandManager(){}
11. public:
12.  bool Excecute(TCommand* cmd)
13.  {
14.   if (!cmd->Do())
15.   {
16.    return false;
17.   }
19.   if (cmd->CanUndo())
20.   {
21.    m_UndoStack.push(cmd);
22.   }
25.   return true;
26.  }
28.  bool ReExecute()
29.  {
30.   TCommand* cmd = m_RedoStack.top();
31.   
32.   if (!Excecute(cmd))
33.   {
34.    return false;
35.   }
37.   m_RedoStack.pop();
39.   return true;  
40.  }
42.  bool UnExecute()
43.  {
44.   TCommand* cmd = m_UndoStack.top();
45.   
46.   if (!cmd->Undo())
47.   {
48.    return false;
49.   }
51.   m_UndoStack.pop();
52.   m_RedoStack.push(cmd);
55.   return true;
56.  }
58.  void Reset()
59.  {
60.   if (!m_UndoStack.empty())
61.   {
62.    TCommand* pCmd = m_UndoStack.top();
63.    m_UndoStack.pop();
64.    delete pCmd;
65.   }
66.  }
68. private:
69.  std::stack m_UndoStack;
70.  std::stack m_RedoStack; 
71. };

CCommandManager还可以实现为单件模式，这样可以提供一个全局访问点,这里因为篇幅关系不实现了。

 

至此整个Undo,Redo的框架已经实现完了，下面介绍如何使用

1. //1. 定义命令参数并填写需要的值
3. CAddEventArgs* pArgs = new CAddEventArgs(......);
5. //2. 定义Command, 并把相应的参数填进去.
6. CAddCommand* cmd = new CAddCommand(pArgs);
7. //3. 定义事件响应函数.
8. CAddCommand::EventHandler Handler(GetView(), &CKeyinToolView::OnEditPOI);
9. //4. 把事件响应函数注册到event
11. cmd ->RegisterDoHandler(Handler);
13. //5. 现在放心的运行命令，运行成功则CommandManager会信息保存到Undo栈中，并触发event处理函数.
15. GetCommandManager()->Excecute(cmd)。
17. //6. 在需要Undo的时候只需这样
19. GetCommandManager()->UnExcecute()。
21. //7. 在需要Redo的时候只需这样
23. GetCommandManager()->ReExcecute()。