====== CommandManager ======

**//Inherited from//**  NULL

**//Inherited by//**  NULL

**//Friend class//**  NULL

**//Description//**

所有的[[class:application:icommand|命令]]都必须在CommandManager里注册之后才能被主程序使用，命令的创建以及销毁都通过CommandManager来完成。所有的命令中有一种比较特殊的命令，它不需要任何输入，它的输出也不改变任何持久性数据，这种命令称为OneClick命令，OneClick命令一般都通过调用MainFrame的executeCommand函数直接来完成，但是需要通过函数isOneClickCommand来判断它是否属于这一类命令。定制的命令管理器一般需重新实现registercommands和isOneClickCommand函数。

**//Members//**
  * ICommand* [[commandmanager#m_pexecutingcmd|m_pExecutingCmd]]
  * deque<ICommand*> [[commandmanager#m_pcmdlist|m_pCmdList]]
  * vector<CmdHistory> [[commandmanager#m_pcmdhistory|m_pCmdHistory]]
  * unordered_map<string,ulong> [[commandmanager#m_pscriptmap|m_pScriptMap]]
  * unordered_map<ulong, string> * [[commandmanager#m_pcmdstatus|m_pCmdStatus]]
  * unordered_map<string, ScriptAPI> * [[commandmanager#m_pfapifunc|m_pfAPIFunc]]
  * unordered_map<string, vector<const CommandIndex*>> * [[commandmanager#m_pmodulecmds|m_pModuleCmds]]
  * Name [[commandmanager#m_strmodule|m_strModule]]
  * TypeID [[commandmanager#m_iexecmode|m_iExecMode]]
  * CmdIndexHash * [[commandmanager#m_pcmdindices|m_pCmdIndices]]
  * ulong [[commandmanager#m_ulnextcid|m_ulNextCid]]
  * ulong [[commandmanager#m_ulnextnewdoccid|m_ulNextNewDocCid]]
  * ulong [[commandmanager#m_ulnextopendoccid|m_ulNextOpenDocCid]]
**//Public interface//**
  * static CommandManager * [[commandmanager#instance|instance]]()
  * static IMainFrame * [[commandmanager#getmainframe|getMainFrame]]()
  * static void [[commandmanager#setmainframe|setMainFrame]](IMainFrame * mf)
  * virtual [[commandmanager#~commandmanager|~CommandManager]]()
  * ICommand * [[commandmanager#getcommand|getCommand]](int cid)
  * int [[commandmanager#getcommandidbyname|getCommandIDByName]](const char * name)
  * int [[commandmanager#getitemcommandid|getItemCommandID]](int type,const XItem * pi)
  * ulong [[commandmanager#getcommanditemtype|getCommandItemType]](XDocument * doc, int cid)
  * ICommand * [[commandmanager#createcommand|createCommand]](int cid,IMainFrame * pApp, XDocument * doc, bool bScript = false)
  * const char * [[commandmanager#getcommandname|getCommandName]](XDocument * doc, int cid)
  * ulong [[commandmanager#getcommandlicense|getCommandLicense]](XDocument * doc, int cid)
  * void [[commandmanager#destroycommand|destroyCommand]](ICommand * pCmd)
  * void [[commandmanager#clear|clear]](XDocument * doc = 0)
  * void [[commandmanager#registerout|registerOut]]()
  * const char * [[commandmanager#logcommand|logCommand]](ICommand * cmd)
  * void [[commandmanager#logapi|logAPI]](XDocument*doc, const char * apiName, const char * apiArgs)
  * ICommand * [[commandmanager#createscriptcommand|createScriptCommand]](const char * script,IMainFrame * frame, XDocument * doc)
  * bool [[commandmanager#registercommand|registerCommand]](int cid,int doc, CreateCommandFunc createF, DestroyCommandFunc destroyF, const char * name, ulong item_type = DItem_Unknown, ulong license = Lic_Base)
  * void [[commandmanager#registeroutcommand|registerOutCommand]](CommandIndex * ci)
  * void [[commandmanager#setcommandlicense|setCommandLicense]](int cid, int doc, ulong lic)
  * bool [[commandmanager#registerscriptapi|registerScriptAPI]](const char * apiName, ScriptAPI apiFunc)
  * ScriptAPI [[commandmanager#getscriptapi|getScriptAPI]](const char * apiName)
  * void [[commandmanager#begintransaction|beginTransaction]](ICommand * cmd)
  * void [[commandmanager#endtransaction|endTransaction]](ICommand * cmd)
  * void [[commandmanager#rollback|rollback]](ICommand *)
  * bool [[commandmanager#undo|undo]](XDocument * doc)
  * bool [[commandmanager#redo|redo]](XDocument * doc)
  * void [[commandmanager#reproduce|reproduce]](XDocument * doc,const char * history,const char * record)
  * const CmdHistory & [[commandmanager#gethistory|getHistory]](int index) const
  * int [[commandmanager#gethistorycount|getHistoryCount]]() const
  * void [[commandmanager#resetrecord|resetRecord]](XDocument * doc)
  * virtual void [[commandmanager#registercommands|registerCommands]]()
  * bool [[commandmanager#registermodule|registerModule]](const char * module)
  * void [[commandmanager#registeroutmodule|registerOutModule]](const char * module)
  * int [[commandmanager#filtercmdscript|filterCmdScript]](const char * keyword,vector<string> * cmd_list)
  * void [[commandmanager#serializehistory|serializeHistory]](XDocument * doc, bool bSave = true)
  * void [[commandmanager#loadcmdstatus|loadCmdStatus]](XDocument * doc, const char * scheme)
  * void [[commandmanager#savecmdstatus|saveCmdStatus]](XDocument * doc, const char * scheme)
  * const char * [[commandmanager#loadcmdstatus|loadCmdStatus]](XDocument * doc, ulong cid)
  * void [[commandmanager#savecmdstatus|saveCmdStatus]](ICommand * cmd)
  * TypeID [[commandmanager#getexecmode|getExecMode]]() const
  * void [[commandmanager#setexecmode|setExecMode]](int m)
  * void [[commandmanager#insertcommand|insertCommand]](ICommand * cmd, int index = -1)
  * ICommand * [[commandmanager#getfirstcommand|getFirstCommand]]()
  * ICommand * [[commandmanager#getlastcommand|getLastCommand]]()
  * void [[commandmanager#setexecutingcommand|setExecutingCommand]](ICommand * cmd)
  * ICommand * [[commandmanager#getexecutingcommand|getExecutingCommand]]()
  * const CommandIndex * [[commandmanager#getcommandindex|getCommandIndex]](ulong cid, ulong doc) const
  * void [[commandmanager#bindcommandindexiterator|bindCommandIndexIterator]](CmdIndexIterator * itr)
  * ErrorCode [[commandmanager#executescript|executeScript]](IMainFrame * frame, XDocument * doc, const char * name, const char * args, bool bCheckParam = false)
  * void [[commandmanager#savedocumentcommandnames|saveDocumentCommandNames]](const char * docStr, const char * fname)
**//Protected interface//**
  * bool [[commandmanager#registercommand|registerCommand]](int id,const char * name,ulong license = Lic_Base)
**//Private interface//**
  * [[commandmanager#commandmanager1|CommandManager]]()

----

{{anchor:m_pexecutingcmd}}
**ICommand* m_pExecutingCmd**

当前正在执行的命令对象

{{anchor:m_pcmdlist}}
**deque<ICommand*> m_pCmdList**

通过命令管理器生成的命令对象链表

{{anchor:m_pcmdhistory}}
**vector<CmdHistory> m_pCmdHistory**

命令执行的历史记录

{{anchor:m_pscriptmap}}
**unordered_map<string,ulong> m_pScriptMap**

命令名与命令ID映射表

{{anchor:m_pcmdstatus}}
**unordered_map<ulong, string> * m_pCmdStatus**

命令窗口状态映射表

{{anchor:m_pfapifunc}}
**unordered_map<string, ScriptAPI> * m_pfAPIFunc**

API命令映射表

{{anchor:m_pmodulecmds}}
**unordered_map<string, vector<const CommandIndex*>> * m_pModuleCmds**

模块命令索引

{{anchor:m_strmodule}}
**Name m_strModule**

当前模块名

{{anchor:m_iexecmode}}
**TypeID m_iExecMode**

命令执行模式

{{anchor:m_pcmdindices}}
**CmdIndexHash * m_pCmdIndices**

命令索引表

{{anchor:m_ulnextcid}}
**ulong m_ulNextCid**

用于注册下一个命令的ID号

{{anchor:m_ulnextnewdoccid}}
**ulong m_ulNextNewDocCid**

用于注册下一个新建文档命令的ID号

{{anchor:m_ulnextopendoccid}}
**ulong m_ulNextOpenDocCid**

用于注册下一个打开文档命令的ID号

----

{{anchor:instance}}
**static CommandManager * instance()**
  *function: 返回命令管理器单例对象
  *parameters: NULL
  *return value: 命令管理器单例对象

{{anchor:getmainframe}}
**static IMainFrame * getMainFrame()**
  *function: 获取框架接口
  *parameters: NULL
  *return value: 框架接口

{{anchor:setmainframe}}
**static void setMainFrame(IMainFrame * mf)**
  *function: 设置框架接口
  *parameters: 
    - [i]IMainFrame * mf: 框架接口
  *return value: 无

{{anchor:~commandmanager}}
**virtual ~CommandManager()**
  *function: 析构函数
  *parameters: NULL
  *return value: 无

{{anchor:getcommand}}
**ICommand * getCommand(int cid)**
  *function: 获取ID为cid的命令指针
  *parameters: 
    - [i]int cid: 命令ID
  *return value: 命令对象

{{anchor:getcommandidbyname}}
**int getCommandIDByName(const char * name)**
  *function: 通过命令名获取命令ID
  *parameters: 
    - [i]const char * name: 命令名
  *return value: 命令ID

{{anchor:getitemcommandid}}
**int getItemCommandID(int type,const XItem * pi)**
  *function: 根据数据对象获取对象命令的ID
  *parameters: 
    - [i]int type: 数据对象类型
    - [i]const XItem * pi: 数据对象
  *return value: 对象命令的ID

{{anchor:getcommanditemtype}}
**ulong getCommandItemType(XDocument * doc, int cid)**
  *function: 获取对象命令所对应的对象类型
  *parameters: 
    - [i]XDocument * doc: 文档对象
    - [i] int cid: 命令ID
  *return value: 命令ID所对应的对象类型

{{anchor:createcommand}}
**ICommand * createCommand(int cid,IMainFrame * pApp, XDocument * doc, bool bScript = false)**
  *function: 创建ID为cid的命令
  *parameters: 
    - [i]int cid: 命令ID
    - [i]IMainFrame * pApp: 主框架
    - [i] XDocument * doc: 文档指针
    - [i] bool bScript = false: 是否脚本模式
  *return value: 命令对象

{{anchor:getcommandname}}
**const char * getCommandName(XDocument * doc, int cid)**
  *function: 获取命令名
  *parameters: 
    - [i]XDocument * doc: 命令所应用的文档
    - [i] int cid: 命令ID
  *return value: 命令名

{{anchor:getcommandlicense}}
**ulong getCommandLicense(XDocument * doc, int cid)**
  *function: 获取命令的许可证
  *parameters: 
    - [i]XDocument * doc: 命令所应用的文档
    - [i] int cid: 命令ID
  *return value: 命令的许可证ID

{{anchor:destroycommand}}
**void destroyCommand(ICommand * pCmd)**
  *function: 销毁命令
  *parameters: 
    - [i]ICommand * pCmd: 命令对象
  *return value: 无

{{anchor:clear}}
**void clear(XDocument * doc = 0)**
  *function: 清空应用于文档doc的所有命令
  *parameters: 
    - [i]XDocument * doc = 0: 文档指针
  *return value: 无

{{anchor:registerout}}
**void registerOut()**
  *function: 注销所有命令
  *parameters: NULL
  *return value: 无

{{anchor:logcommand}}
**const char * logCommand(ICommand * cmd)**
  *function: 记录命令的脚本宏
  *parameters: 
    - [i]ICommand * cmd: 命令对象
  *return value: 无

{{anchor:logapi}}
**void logAPI(XDocument*doc, const char * apiName, const char * apiArgs)**
  *function: 记录API脚本
  *parameters: 
    - [i]XDocument*doc: API所应用的文档
    - [i] const char * apiName: API名字
    - [i] const char * apiArgs: API参数
  *return value: 无

{{anchor:createscriptcommand}}
**ICommand * createScriptCommand(const char * script,IMainFrame * frame, XDocument * doc)**
  *function: 创建脚本模式的命令对象
  *parameters: 
    - [i]const char * script: 脚本字符串
    - [i]IMainFrame * frame: 框架接口
    - [i] XDocument * doc: 应用文档
  *return value: 命令对象

{{anchor:registercommand}}
**bool registerCommand(int cid,int doc, CreateCommandFunc createF, DestroyCommandFunc destroyF, const char * name, ulong item_type = DItem_Unknown, ulong license = Lic_Base)**
  *function: 注册命令
  *parameters: 
    - [i]int cid: 命令ID
    - [i]int doc: 文档ID
    - [i] CreateCommandFunc createF: 命令构造API
    - [i] DestroyCommandFunc destroyF: 命令析构API
    - [i] const char * name: 命令名
    - [i] ulong item_type = DItem_Unknown: 对象类型（当命令为对象命令时）
    - [i] ulong license = Lic_Base: 命令的许可证ID
  *return value: 成功注册返回true，否则返回false（如同名命令在该应用文档空间中已经注册）

{{anchor:registeroutcommand}}
**void registerOutCommand(CommandIndex * ci)**
  *function: 注销命令
  *parameters: 
    - [i]CommandIndex * ci: 命令索引
  *return value: 无

{{anchor:setcommandlicense}}
**void setCommandLicense(int cid, int doc, ulong lic)**
  *function: 设置命令许可证
  *parameters: 
    - [i]int cid: 命令ID
    - [i] int doc: 应用文档ID
    - [i] ulong lic: 许可证ID
  *return value: 无

{{anchor:registerscriptapi}}
**bool registerScriptAPI(const char * apiName, ScriptAPI apiFunc)**
  *function: 注册API脚本命令
  *parameters: 
    - [i]const char * apiName: API名
    - [i] ScriptAPI apiFunc: API函数调用
  *return value: 成功注册返回true，否则返回false

{{anchor:getscriptapi}}
**ScriptAPI getScriptAPI(const char * apiName)**
  *function: 获取指定名字的脚本API
  *parameters: 
    - [i]const char * apiName: API名
  *return value: 脚本API函数

{{anchor:begintransaction}}
**void beginTransaction(ICommand * cmd)**
  *function: 命令执行前开始事务准备（通知数据操作记录器开始记录）
  *parameters: 
    - [i]ICommand * cmd: 命令对象
  *return value: 无

{{anchor:endtransaction}}
**void endTransaction(ICommand * cmd)**
  *function: 命令执行完提交事务（通知数据操作记录器停止记录）
  *parameters: 
    - [i]ICommand * cmd: 命令对象
  *return value: 无

{{anchor:rollback}}
**void rollback(ICommand * cmd)**
  *function: 回滚当前正在执行的命令所做的任何改动
  *parameters: 
    - [i]ICommand *: 命令对象
  *return value: 无

{{anchor:undo}}
**bool undo(XDocument * doc)**
  *function: 基于文档doc的数据操作记录撤销当前位置所对应的命令操作（数据操作记录会移动到上一个命令的记录尾部）
  *parameters: 
    - [i]XDocument * doc: 应用文档
  *return value: 成功撤销返回true，否则返回false

{{anchor:redo}}
**bool redo(XDocument * doc)**
  *function: 基于文档doc的数据操作记录重做当前位置所对应的命令操作（数据操作记录会移动到下一个命令的记录头部）
  *parameters: 
    - [i]XDocument * doc: 应用文档
  *return value: 成功重做返回true，否则返回false

{{anchor:reproduce}}
**void reproduce(XDocument * doc,const char * history,const char * record)**
  *function: 根据数据操作记录重现应用文档状态
  *parameters: 
    - [i]XDocument * doc: 应用文档
    - [i]const char * history: 命令历史文件
    - [i]const char * record: 数据操作记录文件
  *return value: 无

{{anchor:gethistory}}
**const CmdHistory & getHistory(int index) const**
  *function: 获取命令历史记录
  *parameters: 
    - [i]int index: 命令执行序号
  *return value: 命令历史记录

{{anchor:gethistorycount}}
**int getHistoryCount() const**
  *function: 获取历史命令的数目
  *parameters: NULL
  *return value: 历史命令的数目

{{anchor:resetrecord}}
**void resetRecord(XDocument * doc)**
  *function: 重置应用文档的数据操作记录
  *parameters: 
    - [i]XDocument * doc: 应用文档
  *return value: 无

{{anchor:registercommands}}
**virtual void registerCommands()**
  *function: 将命令注册到命令管理器中
  *parameters: NULL
  *return value: 无

{{anchor:registermodule}}
**bool registerModule(const char * module)**
  *function: 注册模块（模块内的所有命令将被注册）
  *parameters: 
    - [i]const char * module: 模块路径名
  *return value: 无

{{anchor:registeroutmodule}}
**void registerOutModule(const char * module)**
  *function: 注销模块（模块内的所有命令将被注销）
  *parameters: 
    - [i]const char * module: 模块路径名
  *return value: 无

{{anchor:filtercmdscript}}
**int filterCmdScript(const char * keyword,vector<string> * cmd_list)**
  *function: 匹配指定关键字的所有命令名
  *parameters: 
    - [i]const char * keyword: 关键字
    - [i]vector<string> * cmd_list: 命令名数组
  *return value: 返回匹配指定关键字的所有命令名的数目

{{anchor:serializehistory}}
**void serializeHistory(XDocument * doc, bool bSave = true)**
  *function: 序列化应用文档的历史命令记录
  *parameters: 
    - [i]XDocument * doc: 应用文档
    - [i] bool bSave = true: 保存（true）或者读取（false）
  *return value: 无

{{anchor:loadcmdstatus}}
**void loadCmdStatus(XDocument * doc, const char * scheme)**
  *function: 载入命令对话框状态配置
  *parameters: 
    - [i]XDocument * doc: 应用文档
    - [i] const char * scheme: 应用方案名
  *return value: 无

{{anchor:savecmdstatus}}
**void saveCmdStatus(XDocument * doc, const char * scheme)**
  *function: 保存命令对话框状态配置
  *parameters: 
    - [i]XDocument * doc: 应用文档
    - [i] const char * scheme: 应用方案名
  *return value: 无

{{anchor:loadcmdstatus}}
**const char * loadCmdStatus(XDocument * doc, ulong cid)**
  *function: 载入指定命令的对话框状态配置
  *parameters: 
    - [i]XDocument * doc: 应用文档
    - [i] ulong cid: 命令ID
  *return value: 配置字符串（最后一次运行命令的脚本记录）

{{anchor:savecmdstatus}}
**void saveCmdStatus(ICommand * cmd)**
  *function: 保存指定命令对象的状态配置
  *parameters: 
    - [i]ICommand * cmd: 命令对象
  *return value: 无

{{anchor:getexecmode}}
**TypeID getExecMode() const**
  *function: 获取命令执行模式
  *parameters: NULL
  *return value: 命令执行模式

{{anchor:setexecmode}}
**void setExecMode(int m)**
  *function: 设置命令执行模式
  *parameters: 
    - [i]int m: 命令执行模式
  *return value: 无

{{anchor:insertcommand}}
**void insertCommand(ICommand * cmd, int index = -1)**
  *function: 插入命令对象
  *parameters: 
    - [i]ICommand * cmd: 命令对象
    - [i] int index = -1: 命令队列序号
  *return value: 无

{{anchor:getfirstcommand}}
**ICommand * getFirstCommand()**
  *function: 获取命令序列的第一个命令
  *parameters: NULL
  *return value: 命令序列的第一个命令

{{anchor:getlastcommand}}
**ICommand * getLastCommand()**
  *function: 获取命令序列的最后一个命令
  *parameters: NULL
  *return value: 命令序列的最后一个命令

{{anchor:setexecutingcommand}}
**void setExecutingCommand(ICommand * cmd)**
  *function: 设置当前执行的命令
  *parameters: 
    - [i]ICommand * cmd: 命令对象
  *return value: 无

{{anchor:getexecutingcommand}}
**ICommand * getExecutingCommand()**
  *function: 获取当前执行的命令对象
  *parameters: NULL
  *return value: 当前执行的命令对象

{{anchor:getcommandindex}}
**const CommandIndex * getCommandIndex(ulong cid, ulong doc) const**
  *function: 获取命令索引
  *parameters: 
    - [i]ulong cid: 命令ID
    - [i] ulong doc: 文档ID
  *return value: 命令索引

{{anchor:bindcommandindexiterator}}
**void bindCommandIndexIterator(CmdIndexIterator * itr)**
  *function: 绑定命令索引访问迭代器
  *parameters: 
    - [i]CmdIndexIterator * itr: 命令索引访问迭代器
  *return value: 无

{{anchor:executescript}}
**ErrorCode executeScript(IMainFrame * frame, XDocument * doc, const char * name, const char * args, bool bCheckParam = false)**
  *function: 执行脚本
  *parameters: 
    - [i]IMainFrame * frame: 框架接口
    - [i] XDocument * doc: 应用文档
    - [i] const char * name: 命令名
    - [i] const char * args: 命令参数
    - [i] bool bCheckParam = false: 指定是否检查参数（在执行前）
  *return value: 成功执行返回Error_None,否则返回响应错误码

{{anchor:savedocumentcommandnames}}
**void saveDocumentCommandNames(const char * docStr, const char * fname)**
  *function: 保存指定文档类型的所有命令名
  *parameters: 
    - [i]const char * docStr: 文档标识名
    - [i] const char * fname: 保存文件路径
  *return value: 无

----

{{anchor:registercommand}}
**bool registerCommand(int id,const char * name,ulong license = Lic_Base)**
  *function: 将ID为id的命令注册到命令管理器中
  *parameters: 
    - [i]int id: 命令ID
    - [i]const char * name: 命令名字
    - [i]ulong license = Lic_Base: 命令的许可证ID
  *return value: 成功注册返回true，否则返回false

----

{{anchor:commandmanager1}}
**CommandManager()**
  *function: 构造函数，私有函数，以保证单例化运行
  *parameters: NULL
  *return value: 无