开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > Windows编程 > 界面编程 > 对话框与窗口 > 查看源码
XTPSyntaxEditUndoManager.cpp
资源名称：Xtreme.ToolkitPro.v12.0.0.rar　[点击查看]
上传用户：szled88
上传日期：2015-04-09
资源大小：43957k
文件大小：20k
源码类别：

对话框与窗口

开发平台：

Visual C++

XTPSyntaxEditUndoManager.cpp：源码内容
  1. // XTPSyntaxEditUndoManager.cpp : implementation file
  2. //
  3. // This file is a part of the XTREME TOOLKIT PRO MFC class library.
  4. // (c)1998-2008 Codejock Software, All Rights Reserved.
  5. //
  6. // THIS SOURCE FILE IS THE PROPERTY OF CODEJOCK SOFTWARE AND IS NOT TO BE
  7. // RE-DISTRIBUTED BY ANY MEANS WHATSOEVER WITHOUT THE EXPRESSED WRITTEN
  8. // CONSENT OF CODEJOCK SOFTWARE.
  9. //
  10. // THIS SOURCE CODE CAN ONLY BE USED UNDER THE TERMS AND CONDITIONS OUTLINED
  11. // IN THE XTREME SYNTAX EDIT LICENSE AGREEMENT. CODEJOCK SOFTWARE GRANTS TO
  12. // YOU (ONE SOFTWARE DEVELOPER) THE LIMITED RIGHT TO USE THIS SOFTWARE ON A
  13. // SINGLE COMPUTER.
  14. //
  15. // CONTACT INFORMATION:
  16. // support@codejock.com
  17. // http://www.codejock.com
  18. //
  19. //////////////////////////////////////////////////////////////////////
  21. #include "stdafx.h"
  22. #include "Resource.h"
  24. // common includes
  25. #include "Common/XTPNotifyConnection.h"
  26. #include "Common/XTPSmartPtrInternalT.h"
  27. #include "Common/XTPResourceManager.h"
  29. // syntax editor includes
  30. #include "XTPSyntaxEditDefines.h"
  31. #include "XTPSyntaxEditStruct.h"
  32. #include "XTPSyntaxEditUndoManager.h"
  33. #include "XTPSyntaxEditLexPtrs.h"
  34. #include "XTPSyntaxEditLexClassSubObjT.h"
  35. #include "XTPSyntaxEditTextIterator.h"
  36. #include "XTPSyntaxEditSectionManager.h"
  37. #include "XTPSyntaxEditLexCfgFileReader.h"
  38. #include "XTPSyntaxEditLexClassSubObjDef.h"
  39. #include "XTPSyntaxEditLexClass.h"
  40. #include "XTPSyntaxEditLexParser.h"
  41. #include "XTPSyntaxEditBufferManager.h"
  42. #include "XTPSyntaxEditCtrl.h"
  44. #ifdef _DEBUG
  45. #define new DEBUG_NEW
  46. #undef THIS_FILE
  47. static char THIS_FILE[] = __FILE__;
  48. #endif
  50. /////////////////////////////////////////////////////////////////////////////
  52. CXTPSyntaxEditUndoRedoManager::CXTPSyntaxEditUndoRedoManager()
  53. {
  54. m_posSavedMark = m_posFirstUndo = NULL;
  55. //m_posSavedMark = BEFORE_START_POSITION;
  56. m_bGroupInsertMode = FALSE;
  58. m_nDataSizeLimit = 50 * 1024 * 1024;
  59. }
  61. CXTPSyntaxEditUndoRedoManager::~CXTPSyntaxEditUndoRedoManager()
  62. {
  63. Clear();
  64. }
  66. int CXTPSyntaxEditUndoRedoManager::DoUndo(XTP_EDIT_LINECOL& lcFrom, XTP_EDIT_LINECOL& lcTo, CXTPSyntaxEditCtrl* pEditCtrl)
  67. {
  68. int nRet = 0;
  69. if (m_posFirstUndo != NULL)
  70. {
  71. CXTPSyntaxEditCommand* pCmd = (CXTPSyntaxEditCommand*)m_CommandList.GetAt(m_posFirstUndo);
  72. if (pCmd != NULL)
  73. {
  74. nRet = pCmd->UnExecute(lcFrom, lcTo, pEditCtrl);
  75. }
  76. m_CommandList.GetPrev(m_posFirstUndo);
  77. }
  78. return nRet;
  79. }
  81. int CXTPSyntaxEditUndoRedoManager::DoRedo(XTP_EDIT_LINECOL& lcFrom, XTP_EDIT_LINECOL& lcTo, CXTPSyntaxEditCtrl* pEditCtrl)
  82. {
  83. int nRet = 0;
  84. // get next item
  85. if (m_posFirstUndo != NULL)
  86. {
  87. m_CommandList.GetNext(m_posFirstUndo);
  88. }
  89. else
  90. {
  91. m_posFirstUndo = m_CommandList.GetHeadPosition();
  92. }
  93. // do action
  94. if (m_posFirstUndo != NULL)
  95. {
  96. CXTPSyntaxEditCommand* pCmd = (CXTPSyntaxEditCommand*)m_CommandList.GetAt(m_posFirstUndo);
  97. if (pCmd != NULL)
  98. {
  99. nRet = pCmd->Execute(lcFrom, lcTo, pEditCtrl);
  100. }
  101. }
  102. return nRet;
  103. }
  105. void CXTPSyntaxEditUndoRedoManager::RemoveTail()
  106. {
  107. // remove tail of the list
  108. for (POSITION posTail = m_CommandList.GetTailPosition();
  109. posTail != m_posFirstUndo;
  110. posTail = m_CommandList.GetTailPosition())
  111. {
  112. CXTPSyntaxEditCommand* pCmd = (CXTPSyntaxEditCommand*)m_CommandList.GetTail();
  113. m_CommandList.RemoveTail();
  114. delete pCmd;
  115. }
  116. }
  118. int CXTPSyntaxEditUndoRedoManager::GetDataSize()
  119. {
  120. int nDataSize = 0;
  121. POSITION pos = m_CommandList.GetHeadPosition();
  122. while (pos)
  123. {
  124. CXTPSyntaxEditCommand* pCmd = (CXTPSyntaxEditCommand*)m_CommandList.GetNext(pos);
  125. if (pCmd)
  126. nDataSize += pCmd->GetDataSize();
  127. }
  129. return nDataSize;
  130. }
  132. void CXTPSyntaxEditUndoRedoManager::LimitDataSize(int nNewCommandData, int nDataSizeLimit)
  133. {
  134. int nDataSize = GetDataSize();
  135. if (nDataSize + nNewCommandData < nDataSizeLimit)
  136. return;
  138. POSITION pos = m_CommandList.GetHeadPosition();
  139. while (pos)
  140. {
  141. if (pos == m_posFirstUndo)
  142. {
  143. Clear();
  144. return;
  145. }
  147. CXTPSyntaxEditCommand* pCmd = (CXTPSyntaxEditCommand*)m_CommandList.GetNext(pos);
  148. if (pCmd)
  149. nDataSize -= pCmd->GetDataSize();
  151. if (nDataSize + nNewCommandData < nDataSizeLimit)
  152. break;
  153. }
  154. }
  156. void CXTPSyntaxEditUndoRedoManager::AddCommand(CXTPSyntaxEditCommand* pCommand)
  157. {
  158. RemoveTail();
  160. LimitDataSize(pCommand->GetDataSize(), m_nDataSizeLimit);
  162. // insert undo command
  163. if (!m_bGroupInsertMode)
  164. {
  165. m_CommandList.AddTail(pCommand);
  166. }
  167. else
  168. {
  169. CXTPSyntaxEditCommand* pCmd = m_CommandList.GetTailPosition() ?
  170. (CXTPSyntaxEditCommand*)m_CommandList.GetTail() : NULL;
  171. CXTPSyntaxEditBatchCommand* pBatchCmd = DYNAMIC_DOWNCAST(CXTPSyntaxEditBatchCommand, pCmd);
  172. if (!pBatchCmd)
  173. {
  174. pBatchCmd = new CXTPSyntaxEditBatchCommand();
  175. m_CommandList.AddTail(pBatchCmd);
  176. }
  177. pBatchCmd->AddCommand(pCommand);
  178. }
  179. m_posFirstUndo = m_CommandList.GetTailPosition();
  180. }
  182. void CXTPSyntaxEditUndoRedoManager::Clear()
  183. {
  184. for (POSITION posTail = m_CommandList.GetTailPosition();
  185. posTail != NULL;
  186. posTail = m_CommandList.GetTailPosition())
  187. {
  188. CXTPSyntaxEditCommand* pCmd = (CXTPSyntaxEditCommand*)m_CommandList.GetTail();
  189. m_CommandList.RemoveTail();
  190. delete pCmd;
  191. }
  192. m_posFirstUndo = NULL;
  193. }
  195. BOOL CXTPSyntaxEditUndoRedoManager::CanUndo()
  196. {
  197. if (m_posFirstUndo == NULL)
  198. return FALSE;
  200. return TRUE;
  201. }
  203. BOOL CXTPSyntaxEditUndoRedoManager::CanRedo()
  204. {
  205. POSITION posLast = m_CommandList.GetTailPosition();
  206. if (posLast == m_posFirstUndo)
  207. return FALSE;
  209. return TRUE;
  210. }
  212. void CXTPSyntaxEditUndoRedoManager::MarkSaved()
  213. {
  214. m_posSavedMark = m_posFirstUndo;
  215. }
  217. BOOL CXTPSyntaxEditUndoRedoManager::IsModified()
  218. {
  219. return m_posSavedMark != m_posFirstUndo;
  220. }
  222. void CXTPSyntaxEditUndoRedoManager::SetGroupInsertMode(BOOL bInsertInGroup)
  223. {
  224. if (m_bGroupInsertMode == bInsertInGroup)
  225. return;
  227. m_bGroupInsertMode = bInsertInGroup;
  228. if (m_bGroupInsertMode)
  229. {
  230. // add empty batch command
  231. RemoveTail();
  232. m_CommandList.AddTail(new CXTPSyntaxEditBatchCommand());
  233. m_posFirstUndo = m_CommandList.GetTailPosition();
  234. }
  235. else
  236. {
  237. // delete empty batch command if necessary
  238. CXTPSyntaxEditCommand* pCmd = m_CommandList.GetTailPosition() ?
  239. (CXTPSyntaxEditCommand*)m_CommandList.GetTail() : NULL;
  240. CXTPSyntaxEditBatchCommand* pBatchCmd = DYNAMIC_DOWNCAST(CXTPSyntaxEditBatchCommand, pCmd);
  241. if (pBatchCmd && pBatchCmd->GetCommandsCount() < 1)
  242. {
  243. m_CommandList.RemoveTail();
  244. delete pBatchCmd;
  245. m_posFirstUndo = m_CommandList.GetTailPosition();
  246. }
  247. }
  248. }
  250. const CStringList& CXTPSyntaxEditUndoRedoManager::GetUndoTextList()
  251. {
  252. m_lstUndoText.RemoveAll();
  254. // iterate all undo items
  255. POSITION posHead = m_CommandList.GetHeadPosition();
  256. do
  257. {
  258. CXTPSyntaxEditCommand* pCmd = (CXTPSyntaxEditCommand*)m_CommandList.GetAt(posHead);
  259. if (pCmd)
  260. {
  261. m_lstUndoText.AddTail(pCmd->GetCommandText());
  262. }
  263. if (posHead == m_posFirstUndo)
  264. break;
  265. else
  266. m_CommandList.GetNext(posHead);
  267. }
  268. while (posHead != NULL);
  270. return m_lstUndoText;
  271. }
  273. const CStringList& CXTPSyntaxEditUndoRedoManager::GetRedoTextList()
  274. {
  275. m_lstRedoText.RemoveAll();
  277. // iterate all redo items
  278. for (POSITION posTail = m_CommandList.GetTailPosition();
  279. posTail != m_posFirstUndo;
  280. m_CommandList.GetPrev(posTail))
  281. {
  282. CXTPSyntaxEditCommand* pCmd = (CXTPSyntaxEditCommand*)m_CommandList.GetAt(posTail);
  283. if (pCmd)
  284. {
  285. m_lstRedoText.AddHead(pCmd->GetCommandText());
  286. }
  287. }
  289. return m_lstRedoText;
  290. }
  292. void CXTPSyntaxEditUndoRedoManager::ChainLastCommand()
  293. {
  294. POSITION posPrev = m_posFirstUndo;
  296. // Take latest command and the previous, if any not exists - return
  297. CXTPSyntaxEditCommand* pCmd = posPrev ?
  298. (CXTPSyntaxEditCommand*)m_CommandList.GetPrev(posPrev) : NULL;
  299. if (!pCmd || !posPrev)
  300. return;
  302. CXTPSyntaxEditCommand* pPrevCmd = (CXTPSyntaxEditCommand*)m_CommandList.GetAt(posPrev);
  303. if (!pPrevCmd)
  304. return;
  306. // Convert previous command to batch, or create new batch if not exist
  307. CXTPSyntaxEditBatchCommand* pBatchCmd = DYNAMIC_DOWNCAST(CXTPSyntaxEditBatchCommand, pPrevCmd);
  308. if (!pBatchCmd)
  309. {
  310. // Create batch command
  311. pBatchCmd = new CXTPSyntaxEditBatchCommand();
  312. // add previous command to the batch
  313. pBatchCmd->AddCommand(pPrevCmd);
  314. // reinsert batch command instead of usual previous command
  315. m_CommandList.SetAt(posPrev, pBatchCmd);
  316. }
  317. pBatchCmd->AddCommand(pCmd);
  319. // make previous batch command as latest undo position
  320. m_CommandList.RemoveAt(m_posFirstUndo);
  321. m_posFirstUndo = posPrev;
  322. }
  324. void CXTPSyntaxEditUndoRedoManager::SetLastCommandText(LPCTSTR szText)
  325. {
  326. // Take the latest command
  327. CXTPSyntaxEditCommand* pCmd = m_posFirstUndo ?
  328. (CXTPSyntaxEditCommand*)m_CommandList.GetAt(m_posFirstUndo) : NULL;
  329. if (!pCmd)
  330. return;
  332. // Set its text
  333. pCmd->SetCommandText(szText);
  334. }
  336. void CXTPSyntaxEditUndoRedoManager::SetLastCommandText(UINT nTextId)
  337. {
  338. // load text from resources
  339. CString strText;
  340. XTPResourceManager()->LoadString(&strText, nTextId);
  342. // run text changing
  343. SetLastCommandText(strText);
  344. }
  345. //////////////////////////////////////////////////////////////////////
  346. // CXTPSyntaxEditCommand
  347. //////////////////////////////////////////////////////////////////////
  348. IMPLEMENT_DYNAMIC(CXTPSyntaxEditCommand, CObject)
  350. CXTPSyntaxEditCommand::CXTPSyntaxEditCommand()
  351. {
  352. XTPResourceManager()->LoadString(&m_strCommandText, XTP_IDS_EDIT_UNDEFINED);
  353. }
  355. CXTPSyntaxEditCommand::~CXTPSyntaxEditCommand()
  356. {
  357. }
  359. void CXTPSyntaxEditCommand::SetPositionInternally(CXTPSyntaxEditCtrl* pEditCtrl, const XTP_EDIT_LINECOL& lcPos)
  360. {
  361. if (pEditCtrl)
  362. {
  363. pEditCtrl->SetCurrentDocumentRow(lcPos.nLine);
  364. pEditCtrl->m_nCurrentCol = lcPos.nCol;
  365. }
  366. }
  367. //////////////////////////////////////////////////////////////////////
  368. // CXTPSyntaxEditBatchCommand
  369. //////////////////////////////////////////////////////////////////////
  370. IMPLEMENT_DYNAMIC(CXTPSyntaxEditBatchCommand, CXTPSyntaxEditCommand)
  372. CXTPSyntaxEditBatchCommand::CXTPSyntaxEditBatchCommand()
  373. {
  374. XTPResourceManager()->LoadString(&m_strCommandText, XTP_IDS_EDIT_MULTIPLE);
  375. }
  377. CXTPSyntaxEditBatchCommand::~CXTPSyntaxEditBatchCommand()
  378. {
  379. Clear();
  380. }
  382. int CXTPSyntaxEditBatchCommand::Execute(XTP_EDIT_LINECOL& lcFrom, XTP_EDIT_LINECOL& lcTo, CXTPSyntaxEditCtrl* pEditCtrl)
  383. {
  384. int nRet = 0;
  385. lcFrom = XTP_EDIT_LINECOL::MAXPOS;
  386. lcTo = XTP_EDIT_LINECOL::MINPOS;
  388. POSITION posCmd = m_CommandList.GetTailPosition();
  389. for ( int i = (int)m_CommandList.GetCount() - 1; i >= 0; i-- )
  390. {
  391. CXTPSyntaxEditCommand* pCmd = (CXTPSyntaxEditCommand*)m_CommandList.GetPrev(posCmd);
  392. if (pCmd != NULL)
  393. {
  394. XTP_EDIT_LINECOL lcTmpFrom, lcTmpTo;
  395. nRet |= pCmd->Execute(lcTmpFrom, lcTmpTo, pEditCtrl);
  396. lcFrom = min(lcFrom, lcTmpFrom);
  397. lcTo = max(lcTo, lcTmpTo);
  398. }
  399. }
  400. return nRet;
  401. }
  403. int CXTPSyntaxEditBatchCommand::UnExecute(XTP_EDIT_LINECOL& lcFrom, XTP_EDIT_LINECOL& lcTo, CXTPSyntaxEditCtrl* pEditCtrl)
  404. {
  405. int nRet = 0;
  406. lcFrom = XTP_EDIT_LINECOL::MAXPOS;
  407. lcTo = XTP_EDIT_LINECOL::MINPOS;
  409. POSITION posCmd = m_CommandList.GetHeadPosition();
  410. for ( int i = 0; i < m_CommandList.GetCount(); i++ )
  411. {
  412. CXTPSyntaxEditCommand* pCmd = (CXTPSyntaxEditCommand*)m_CommandList.GetNext(posCmd);
  413. if (pCmd != NULL)
  414. {
  415. XTP_EDIT_LINECOL lcTmpFrom, lcTmpTo;
  416. nRet |= pCmd->UnExecute(lcTmpFrom, lcTmpTo, pEditCtrl);
  417. lcFrom = min(lcFrom, lcTmpFrom);
  418. lcTo = max(lcTo, lcTmpTo);
  419. }
  420. }
  421. return nRet;
  422. }
  424. POSITION CXTPSyntaxEditBatchCommand::AddCommand(CXTPSyntaxEditCommand* pCmd)
  425. {
  426. // insert command
  427. return m_CommandList.AddHead(pCmd);
  428. }
  430. void CXTPSyntaxEditBatchCommand::Clear()
  431. {
  432. for ( POSITION posTail = m_CommandList.GetTailPosition();
  433. posTail != NULL;
  434. posTail = m_CommandList.GetTailPosition() )
  435. {
  436. CXTPSyntaxEditCommand* pCmd = (CXTPSyntaxEditCommand*)m_CommandList.GetTail();
  437. m_CommandList.RemoveTail();
  438. delete pCmd;
  439. }
  440. }
  442. int CXTPSyntaxEditBatchCommand::GetCommandsCount()
  443. {
  444. return (int)m_CommandList.GetCount();
  445. }
  447. int CXTPSyntaxEditBatchCommand::GetDataSize()
  448. {
  449. int nDataSize = 0;
  450. POSITION pos = m_CommandList.GetHeadPosition();
  451. while (pos)
  452. {
  453. CXTPSyntaxEditCommand* pCmd = (CXTPSyntaxEditCommand*)m_CommandList.GetNext(pos);
  454. if (pCmd)
  455. nDataSize += pCmd->GetDataSize();
  456. }
  458. return nDataSize;
  459. }
  461. //////////////////////////////////////////////////////////////////////
  462. // CXTPSyntaxEditBufferCommand
  463. //////////////////////////////////////////////////////////////////////
  464. IMPLEMENT_DYNAMIC(CXTPSyntaxEditBufferCommand, CXTPSyntaxEditCommand)
  466. CXTPSyntaxEditBufferCommand::CXTPSyntaxEditBufferCommand(
  467. CXTPSyntaxEditBufferManager* pMgr,
  468. LPCTSTR szText, const XTP_EDIT_LINECOL& lcFrom, const XTP_EDIT_LINECOL& lcTo)
  469. : m_pBufferMgr(pMgr), m_strText(szText), m_lcFrom(lcFrom), m_lcTo(lcTo)
  470. {
  471. }
  473. CXTPSyntaxEditBufferCommand::~CXTPSyntaxEditBufferCommand()
  474. {
  475. }
  477. CXTPSyntaxEditBufferCommand::CXTPSyntaxEditBufferKeepOverwriteSettings::CXTPSyntaxEditBufferKeepOverwriteSettings(CXTPSyntaxEditBufferManager* pBufferMgr)
  478. : m_pBufMgr(pBufferMgr)
  479. {
  480. m_bOldSettings = m_pBufMgr ? m_pBufMgr->GetOverwriteFlag() : FALSE;
  481. if (m_pBufMgr)
  482. {
  483. m_pBufMgr->SetOverwriteFlag(FALSE);
  484. }
  485. }
  487. CXTPSyntaxEditBufferCommand::CXTPSyntaxEditBufferKeepOverwriteSettings::~CXTPSyntaxEditBufferKeepOverwriteSettings()
  488. {
  489. if (m_pBufMgr)
  490. {
  491. m_pBufMgr->SetOverwriteFlag(m_bOldSettings);
  492. }
  493. }
  495. int CXTPSyntaxEditBufferCommand::DoDeleteText(XTP_EDIT_LINECOL& lcFrom, XTP_EDIT_LINECOL& lcTo, CXTPSyntaxEditCtrl* pEditCtrl)
  496. {
  497. if (!m_pBufferMgr)
  498. return 0;
  500. CXTPSyntaxEditBufferKeepOverwriteSettings bufOwr(m_pBufferMgr);
  502. m_pBufferMgr->GetLexParser()->OnBeforeEditChanged();
  504. // performs undoing operation
  505. m_pBufferMgr->DeleteText(m_lcFrom.nLine, m_lcFrom.nCol, m_lcTo.nLine, m_lcTo.nCol, FALSE);
  507. // send corresponding notification
  508. m_pBufferMgr->GetLexParser()->OnEditChanged(m_lcFrom, m_lcTo, xtpEditActDelete, m_pBufferMgr);
  510. // adjust cursor position
  511. SetPositionInternally(pEditCtrl, m_lcFrom);
  513. // calculate edit action
  514. int nEditAction = XTP_EDIT_EDITACTION_DELETETEXT;
  515. if (m_lcFrom.nLine != m_lcTo.nLine)
  516. nEditAction |= XTP_EDIT_EDITACTION_DELETEROW | XTP_EDIT_EDITACTION_MODIFYROW;
  517. else if (m_lcFrom.nCol != m_lcTo.nCol)
  518. nEditAction |= XTP_EDIT_EDITACTION_MODIFYROW;
  520. // set edit action bounds
  521. lcFrom = min(m_lcFrom, m_lcTo);
  522. lcTo = max(m_lcFrom, m_lcTo);
  524. return nEditAction;
  525. }
  527. int CXTPSyntaxEditBufferCommand::DoInsertText(XTP_EDIT_LINECOL& lcFrom, XTP_EDIT_LINECOL& lcTo, CXTPSyntaxEditCtrl* pEditCtrl)
  528. {
  529. if (!m_pBufferMgr)
  530. return 0;
  532. // performs undoing operation
  533. CXTPSyntaxEditBufferKeepOverwriteSettings bufOwr(m_pBufferMgr);
  535. m_pBufferMgr->GetLexParser()->OnBeforeEditChanged();
  537. m_pBufferMgr->InsertText(m_strText, m_lcFrom.nLine, m_lcFrom.nCol, FALSE);
  539. // send corresponding notification
  540. m_pBufferMgr->GetLexParser()->OnEditChanged(m_lcFrom, m_lcTo, xtpEditActInsert, m_pBufferMgr);
  542. // adjust cursor position
  543. SetPositionInternally(pEditCtrl, m_lcTo);
  545. // calculate edit action
  546. int nEditAction = XTP_EDIT_EDITACTION_INSERTTEXT;
  547. if (m_lcFrom.nLine != m_lcTo.nLine)
  548. nEditAction |= XTP_EDIT_EDITACTION_INSERTROW | XTP_EDIT_EDITACTION_MODIFYROW;
  549. else if (m_lcFrom.nCol != m_lcTo.nCol)
  550. nEditAction |= XTP_EDIT_EDITACTION_MODIFYROW;
  552. // set edit action bounds
  553. lcFrom = min(m_lcFrom, m_lcTo);
  554. lcTo = max(m_lcFrom, m_lcTo);
  556. return nEditAction;
  557. }
  559. //////////////////////////////////////////////////////////////////////
  560. // CXTPSyntaxEditDeleteStringCommand
  561. //////////////////////////////////////////////////////////////////////
  562. IMPLEMENT_DYNAMIC(CXTPSyntaxEditDeleteStringCommand, CXTPSyntaxEditBufferCommand)
  564. CXTPSyntaxEditDeleteStringCommand::CXTPSyntaxEditDeleteStringCommand(
  565. CXTPSyntaxEditBufferManager* pMgr,
  566. LPCTSTR szText, const XTP_EDIT_LINECOL& lcFrom, const XTP_EDIT_LINECOL& lcTo)
  567. : CXTPSyntaxEditBufferCommand(pMgr, szText, lcFrom, lcTo)
  568. {
  569. XTPResourceManager()->LoadString(&m_strCommandText, XTP_IDS_EDIT_DELETE);
  570. m_strCommandText += m_strText;
  571. }
  573. CXTPSyntaxEditDeleteStringCommand::~CXTPSyntaxEditDeleteStringCommand()
  574. {
  575. }
  577. int CXTPSyntaxEditDeleteStringCommand::Execute(XTP_EDIT_LINECOL& lcFrom, XTP_EDIT_LINECOL& lcTo, CXTPSyntaxEditCtrl* pEditCtrl)
  578. {
  579. return DoDeleteText(lcFrom, lcTo, pEditCtrl);
  580. }
  582. int CXTPSyntaxEditDeleteStringCommand::UnExecute(XTP_EDIT_LINECOL& lcFrom, XTP_EDIT_LINECOL& lcTo, CXTPSyntaxEditCtrl* pEditCtrl)
  583. {
  584. int nResult = DoInsertText(lcFrom, lcTo, pEditCtrl);
  586. return nResult;
  587. }
  588. //////////////////////////////////////////////////////////////////////
  589. // CXTPSyntaxEditInsertStringCommand
  590. //////////////////////////////////////////////////////////////////////
  591. IMPLEMENT_DYNAMIC(CXTPSyntaxEditInsertStringCommand, CXTPSyntaxEditBufferCommand)
  593. CXTPSyntaxEditInsertStringCommand::CXTPSyntaxEditInsertStringCommand(
  594. CXTPSyntaxEditBufferManager* pMgr,
  595. LPCTSTR szText, const XTP_EDIT_LINECOL& lcFrom, const XTP_EDIT_LINECOL& lcTo)
  596.    : CXTPSyntaxEditBufferCommand(pMgr, szText, lcFrom, lcTo)
  597. {
  598. XTPResourceManager()->LoadString(&m_strCommandText, XTP_IDS_EDIT_INSERT);
  599. m_strCommandText += m_strText;
  600. }
  602. CXTPSyntaxEditInsertStringCommand::~CXTPSyntaxEditInsertStringCommand()
  603. {
  604. }
  606. int CXTPSyntaxEditInsertStringCommand::Execute(XTP_EDIT_LINECOL& lcFrom, XTP_EDIT_LINECOL& lcTo, CXTPSyntaxEditCtrl* pEditCtrl)
  607. {
  608. return DoInsertText(lcFrom, lcTo, pEditCtrl);
  609. }
  611. int CXTPSyntaxEditInsertStringCommand::UnExecute(XTP_EDIT_LINECOL& lcFrom, XTP_EDIT_LINECOL& lcTo, CXTPSyntaxEditCtrl* pEditCtrl)
  612. {
  613. return DoDeleteText(lcFrom, lcTo, pEditCtrl);
  614. }
  616. //////////////////////////////////////////////////////////////////////
  617. // CXTPSyntaxEditReplaceStringCommand
  618. //////////////////////////////////////////////////////////////////////
  619. IMPLEMENT_DYNAMIC(CXTPSyntaxEditReplaceStringCommand, CXTPSyntaxEditBufferCommand)
  621. CXTPSyntaxEditReplaceStringCommand::CXTPSyntaxEditReplaceStringCommand(
  622. CXTPSyntaxEditBufferManager* pMgr,
  623. LPCTSTR szText, LPCTSTR szReplacedText,
  624. const XTP_EDIT_LINECOL& lcFrom, const XTP_EDIT_LINECOL& lcTo)
  625. : CXTPSyntaxEditBufferCommand(pMgr, szText, lcFrom, lcTo), m_strReplacedText(szReplacedText)
  626. {
  627. XTPResourceManager()->LoadString(&m_strCommandText, XTP_IDS_EDIT_MULTIPLE);
  628. m_strCommandText += m_strText;
  629. }
  631. CXTPSyntaxEditReplaceStringCommand::~CXTPSyntaxEditReplaceStringCommand()
  632. {
  633. }
  635. int CXTPSyntaxEditReplaceStringCommand::Execute(XTP_EDIT_LINECOL& lcFrom, XTP_EDIT_LINECOL& lcTo, CXTPSyntaxEditCtrl* pEditCtrl)
  636. {
  637. return DoReplaceText(m_strText, lcFrom, lcTo, pEditCtrl);
  638. }
  640. int CXTPSyntaxEditReplaceStringCommand::UnExecute(XTP_EDIT_LINECOL& lcFrom, XTP_EDIT_LINECOL& lcTo, CXTPSyntaxEditCtrl* pEditCtrl)
  641. {
  642. return DoReplaceText(m_strReplacedText, lcFrom, lcTo, pEditCtrl);
  643. }
  645. int CXTPSyntaxEditReplaceStringCommand::DoReplaceText(LPCTSTR szText, XTP_EDIT_LINECOL& lcFrom, XTP_EDIT_LINECOL& lcTo, CXTPSyntaxEditCtrl* pEditCtrl)
  646. {
  647. if (!m_pBufferMgr)
  648. return 0;
  650. // performs undoing operation
  651. CXTPSyntaxEditBufferKeepOverwriteSettings bufOwr(m_pBufferMgr);
  652. m_pBufferMgr->SetOverwriteFlag(TRUE);
  654. m_pBufferMgr->GetLexParser()->OnBeforeEditChanged();
  656. XTP_EDIT_LINECOL lcBegin = min(m_lcFrom, m_lcTo);
  657. m_pBufferMgr->InsertText(szText, lcBegin.nLine, lcBegin.nCol, FALSE);
  658. // send corresponding notification
  659. m_pBufferMgr->GetLexParser()->OnEditChanged(m_lcFrom, m_lcTo, xtpEditActInsert, m_pBufferMgr);
  661. // adjust cursor position
  662. SetPositionInternally(pEditCtrl, m_lcFrom);
  664. // calculate edit action
  665. int nEditAction = XTP_EDIT_EDITACTION_INSERTTEXT | XTP_EDIT_EDITACTION_DELETETEXT;
  666. if (m_lcFrom.nLine != m_lcTo.nLine)
  667. nEditAction |= XTP_EDIT_EDITACTION_INSERTROW | XTP_EDIT_EDITACTION_DELETEROW | XTP_EDIT_EDITACTION_MODIFYROW;
  668. else if (m_lcFrom.nCol != m_lcTo.nCol)
  669. nEditAction |= XTP_EDIT_EDITACTION_MODIFYROW;
  671. // set edit action bounds
  672. lcFrom = min(m_lcFrom, m_lcTo);
  673. lcTo = max(m_lcFrom, m_lcTo);
  675. return nEditAction;
  676. }