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

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

对话框与窗口

开发平台：

Visual C++

XTPSyntaxEditLineMarksManager.cpp：源码内容
  1. // XTPSyntaxEditLineMarksManager.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"
  23. // common includes
  24. #include "Common/XTPSmartPtrInternalT.h"
  26. // syntax editor includes
  27. #include "XTPSyntaxEditLineMarksManager.h"
  29. #ifdef _DEBUG
  30. #define new DEBUG_NEW
  31. #undef THIS_FILE
  32. static char THIS_FILE[] = __FILE__;
  33. #endif
  35. /////////////////////////////////////////////////////////////////////////////
  36. // CXTPSyntaxEditLineMarksManager
  38. IMPLEMENT_DYNAMIC(CXTPSyntaxEditLineMarksManager, CCmdTarget)
  40. ////////////////////////////////////////////////////////////////////////////
  41. XTP_EDIT_LMPARAM::~XTP_EDIT_LMPARAM()
  42. {
  43. }
  45. XTP_EDIT_LMPARAM::XTP_EDIT_LMPARAM()
  46. {
  47. Clear();
  48. }
  50. XTP_EDIT_LMPARAM::XTP_EDIT_LMPARAM(const XTP_EDIT_LMPARAM& rSrc)
  51. {
  52. *this = rSrc;
  53. }
  55. XTP_EDIT_LMPARAM::XTP_EDIT_LMPARAM(DWORD dwVal)
  56. {
  57. m_eType = xtpEditLMPT_DWORD;
  58. m_dwValue = dwVal;
  59. }
  61. XTP_EDIT_LMPARAM::XTP_EDIT_LMPARAM(double dblValue)
  62. {
  63. m_eType = xtpEditLMPT_double;
  64. m_dblValue = dblValue;
  65. }
  67. XTP_EDIT_LMPARAM::XTP_EDIT_LMPARAM(void* pPtr)
  68. {
  69. m_eType = xtpEditLMPT_Ptr;
  71. *this = pPtr;
  72. }
  74. const XTP_EDIT_LMPARAM& XTP_EDIT_LMPARAM::operator=(const XTP_EDIT_LMPARAM& rSrc)
  75. {
  76. m_eType = rSrc.m_eType;
  78. if (m_eType == xtpEditLMPT_Unknown)
  79. {
  80. Clear();
  81. }
  82. else if (m_eType == xtpEditLMPT_DWORD)
  83. {
  84. m_dwValue = rSrc.m_dwValue;
  85. }
  86. else if (m_eType == xtpEditLMPT_double)
  87. {
  88. m_dblValue = rSrc.m_dblValue;
  89. }
  90. else if (m_eType == xtpEditLMPT_Ptr)
  91. {
  92. m_Ptr = rSrc.m_Ptr;
  93. }
  94. else
  95. {
  96. ASSERT(FALSE);
  97. }
  99. return *this;
  100. }
  102. const XTP_EDIT_LMPARAM& XTP_EDIT_LMPARAM::operator=(DWORD dwValue)
  103. {
  104. m_Ptr = NULL;
  106. m_eType = xtpEditLMPT_DWORD;
  107. m_dwValue = dwValue;
  108. return *this;
  109. }
  111. const XTP_EDIT_LMPARAM& XTP_EDIT_LMPARAM::operator=(double dblValue)
  112. {
  113. m_Ptr = NULL;
  115. m_eType = xtpEditLMPT_double;
  116. m_dblValue = dblValue;
  117. return *this;
  118. }
  120. void XTP_EDIT_LMPARAM::SetPtr(void* pPtr, CXTPSyntaxEditVoidObj::TPFDeleter pfDeleter)
  121. {
  122. ASSERT(!pPtr || pPtr != m_Ptr);
  124. m_eType = xtpEditLMPT_Ptr;
  126. CXTPSyntaxEditVoidObj* pVoidObj = NULL;
  127. if (pPtr)
  128. {
  129. pVoidObj = new CXTPSyntaxEditVoidObj(pPtr, pfDeleter);
  130. }
  131. m_Ptr = pVoidObj;
  132. }
  134. const XTP_EDIT_LMPARAM& XTP_EDIT_LMPARAM::operator=(void* pPtr)
  135. {
  136. SetPtr(pPtr, NULL);
  137. return *this;
  138. }
  140. XTP_EDIT_LMPARAM::operator DWORD() const
  141. {
  142. if (m_eType == xtpEditLMPT_DWORD)
  143. {
  144. return m_dwValue;
  145. }
  146. ASSERT(FALSE);
  147. return 0;
  148. }
  150. XTP_EDIT_LMPARAM::operator double() const
  151. {
  152. if (m_eType == xtpEditLMPT_double)
  153. {
  154. return m_dblValue;
  155. }
  156. else if (m_eType == xtpEditLMPT_DWORD)
  157. {
  158. return m_dwValue;
  159. }
  160. ASSERT(FALSE);
  161. return 0;
  162. }
  164. XTP_EDIT_LMPARAM::operator void*() const
  165. {
  166. return GetPtr();
  167. }
  169. void* XTP_EDIT_LMPARAM::GetPtr() const
  170. {
  171. if (m_eType == xtpEditLMPT_Ptr)
  172. {
  173. return m_Ptr ? m_Ptr->GetPtr() : NULL;
  174. }
  175. return NULL;
  176. }
  178. BOOL XTP_EDIT_LMPARAM::IsValid() const
  179. {
  180. return  m_eType == xtpEditLMPT_DWORD ||
  181. m_eType == xtpEditLMPT_double ||
  182. m_eType == xtpEditLMPT_Ptr;
  183. }
  185. void XTP_EDIT_LMPARAM::Clear()
  186. {
  187. m_eType = xtpEditLMPT_Unknown;
  189. m_dwValue = 0;
  190. m_dblValue = 0;
  191. m_Ptr = NULL;
  192. }
  194. ////////////////////////////////////////////////////////////////////////////
  195. //struct XTP_EDIT_LMDATA
  197. XTP_EDIT_LMDATA::~XTP_EDIT_LMDATA()
  198. {
  199. }
  201. XTP_EDIT_LMDATA::XTP_EDIT_LMDATA()
  202. {
  203. m_nRow = 0;
  204. }
  206. XTP_EDIT_LMDATA::XTP_EDIT_LMDATA(const XTP_EDIT_LMDATA& rSrc)
  207. {
  208. *this = rSrc;
  209. }
  211. const XTP_EDIT_LMDATA& XTP_EDIT_LMDATA::operator=(const XTP_EDIT_LMDATA& rSrc)
  212. {
  213. m_nRow = rSrc.m_nRow;
  214. m_Param = rSrc.m_Param;
  216. return *this;
  217. }
  219. /////////////////////////////////////////////////////////////////////////////
  221. //////////////////////////////////////////////////////////////////////////
  222. CXTPSyntaxEditLineMarksManager::CLineMarksList::~CLineMarksList()
  223. {
  224. RemoveAll();
  225. }
  227. int CXTPSyntaxEditLineMarksManager::CLineMarksList::FindIndex(const int nKey)
  228. {
  229. const int nCount = (int)m_array.GetSize();
  231. // binary search
  232. int nLeftIndex = 0, nRightIndex = nCount - 1;
  233. while (nRightIndex >= nLeftIndex)
  234. {
  235. XTP_EDIT_LMDATA* pLeftData = m_array.GetAt(nLeftIndex);
  236. XTP_EDIT_LMDATA* pRightData = m_array.GetAt(nRightIndex);
  237. if (!pLeftData || !pRightData)
  238. break;
  240. if (nKey == pLeftData->m_nRow)
  241. return nLeftIndex;
  243. if (nKey == pRightData->m_nRow)
  244. return nRightIndex;
  246. int nMediumIndex = (nRightIndex + nLeftIndex) / 2;
  248. if (nMediumIndex == nRightIndex || nMediumIndex == nLeftIndex)
  249. break;
  251. XTP_EDIT_LMDATA* pMediumData = m_array.GetAt(nMediumIndex);
  252. if (!pMediumData)
  253. break;
  255. if (nKey == pMediumData->m_nRow)
  256. {
  257. return nMediumIndex;
  258. }
  259. else if (nKey > pMediumData->m_nRow)
  260. {
  261. nLeftIndex = nMediumIndex;
  262. }
  263. else // if (nKey < pMediumData->m_nRow)
  264. {
  265. nRightIndex = nMediumIndex;
  266. }
  267. }
  268. return -1;
  269. }
  271. int CXTPSyntaxEditLineMarksManager::CLineMarksList::FindLowerIndex(const int nKey)
  272. {
  273. const int nCount = (int)m_array.GetSize();
  275. if (nCount == 0)
  276. return -1;
  278. // binary search
  279. int nLeftIndex = 0, nRightIndex = nCount - 1;
  280. while (nRightIndex >= nLeftIndex)
  281. {
  282. int nMediumIndex = (nRightIndex + nLeftIndex) / 2;
  284. XTP_EDIT_LMDATA* pMediumData = m_array.GetAt(nMediumIndex);
  285. if (!pMediumData)
  286. break;
  288. XTP_EDIT_LMDATA* pMediumNextData = nMediumIndex + 1 < nCount ?
  289. m_array.GetAt(nMediumIndex + 1) : NULL;
  291. if (nKey >= pMediumData->m_nRow &&
  292. (!pMediumNextData || (pMediumNextData && nKey < pMediumNextData->m_nRow)))
  293. {
  294. return nMediumIndex;
  295. }
  296. else if (nKey > pMediumData->m_nRow)
  297. {
  298. if (nLeftIndex < nMediumIndex)
  299. nLeftIndex = nMediumIndex;
  300. else if (nLeftIndex + 1 == nRightIndex)
  301. nLeftIndex = nRightIndex;
  302. else
  303. break;
  304. }
  305. else
  306. {
  307. if (nRightIndex > nMediumIndex)
  308. nRightIndex = nMediumIndex;
  309. else if (nRightIndex - 1 == nLeftIndex)
  310. nRightIndex = nLeftIndex;
  311. else
  312. break;
  313. }
  314. }
  316. return -1;
  317. }
  319. int CXTPSyntaxEditLineMarksManager::CLineMarksList::FindUpperIndex(const int nKey)
  320. {
  321. const int nCount = (int)m_array.GetSize();
  323. if (nCount == 0)
  324. return -1;
  326. // binary search
  327. int nLeftIndex = 0, nRightIndex = nCount - 1;
  328. while (nRightIndex >= nLeftIndex)
  329. {
  330. int nMediumIndex = (nRightIndex + nLeftIndex) / 2;
  332. XTP_EDIT_LMDATA* pMediumData = m_array.GetAt(nMediumIndex);
  333. if (!pMediumData)
  334. break;
  336. XTP_EDIT_LMDATA* pMediumPrevData = nMediumIndex > 0 ?
  337. m_array.GetAt(nMediumIndex - 1) : NULL;
  339. if (nKey <= pMediumData->m_nRow &&
  340. (!pMediumPrevData || (pMediumPrevData && nKey > pMediumPrevData->m_nRow)))
  341. {
  342. return nMediumIndex;
  343. }
  344. else if (nKey > pMediumData->m_nRow)
  345. {
  346. if (nLeftIndex < nMediumIndex)
  347. nLeftIndex = nMediumIndex;
  348. else if (nLeftIndex + 1 == nRightIndex)
  349. nLeftIndex = nRightIndex;
  350. else
  351. break;
  352. }
  353. else
  354. {
  355. if (nRightIndex > nMediumIndex)
  356. nRightIndex = nMediumIndex;
  357. else if (nRightIndex - 1 == nLeftIndex)
  358. nRightIndex = nLeftIndex;
  359. else
  360. break;
  361. }
  362. }
  363. return -1;
  364. }
  366. void CXTPSyntaxEditLineMarksManager::CLineMarksList::Add(const XTP_EDIT_LMDATA& lmData)
  367. {
  368. int nIndex = FindUpperIndex(lmData.m_nRow);
  369. if (nIndex < 0)
  370. {
  371. m_array.Add(new XTP_EDIT_LMDATA(lmData));
  372. }
  373. else
  374. {
  375. XTP_EDIT_LMDATA* pOldData = m_array.GetAt(nIndex);
  376. if (pOldData->m_nRow == lmData.m_nRow)
  377. {
  378. // just copy data because the key already exists
  379. *pOldData = lmData;
  380. }
  381. else
  382. {
  383. // insert new element for the new key
  384. m_array.InsertAt(nIndex, new XTP_EDIT_LMDATA(lmData));
  385. }
  386. }
  388. }
  390. void CXTPSyntaxEditLineMarksManager::CLineMarksList::Remove(const int nKey)
  391. {
  392. int nIndex = FindIndex(nKey);
  393. if (nIndex >= 0)
  394. {
  395. XTP_EDIT_LMDATA* pData = m_array.GetAt(nIndex);
  396. if (pData)
  397. delete pData;
  398. m_array.RemoveAt(nIndex);
  399. }
  400. }
  402. POSITION CXTPSyntaxEditLineMarksManager::CLineMarksList::FindAt(int nKey)
  403. {
  404. // find a record with the specified key
  405. INT_PTR nIndex = FindIndex(nKey);
  406. return nIndex >= 0 ? (POSITION)(nIndex + 1) : NULL;
  407. }
  409. POSITION CXTPSyntaxEditLineMarksManager::CLineMarksList::FindNext(int nKey)
  410. {
  411. INT_PTR nIndex = FindUpperIndex(nKey);
  412. if (nIndex >= 0)
  413. {
  414. return (POSITION)(nIndex + 1);
  415. }
  416. return NULL;
  417. }
  419. POSITION CXTPSyntaxEditLineMarksManager::CLineMarksList::FindPrev(int nKey)
  420. {
  421. INT_PTR nIndex = FindLowerIndex(nKey);
  422. if (nIndex >= 0)
  423. {
  424. return (POSITION)(nIndex + 1);
  425. }
  426. return NULL;
  427. }
  429. void CXTPSyntaxEditLineMarksManager::CLineMarksList::RefreshLineMarks(
  430. int nRowFrom, int nRowTo, int nRefreshType)
  431. {
  432. int nDiff = abs(nRowTo - nRowFrom);
  434. BOOL bDel = (nRefreshType & xtpEditLMRefresh_Delete);
  435. BOOL bDel_only1 = (nRefreshType & xtpEditLMRefresh_Delete_only1);
  436. BOOL bDel_only2 = (nRefreshType & xtpEditLMRefresh_Delete_only2);
  437. BOOL bInsertAt0 = (nRefreshType & xtpEditLMRefresh_InsertAt0);
  439. if (nRefreshType & xtpEditLMRefresh_Delete)
  440. nDiff *= -1;
  442. if (nRefreshType & (xtpEditLMRefresh_Delete_only1 | xtpEditLMRefresh_Delete_only2))
  443. nDiff = 0;
  445. int nRowU = max(nRowTo, nRowFrom);
  446. int nRowL = min(nRowTo, nRowFrom);
  448. const int nCount = (int)m_array.GetSize();
  449. CXTPSyntaxEditLineMarkPointersArray newArray;
  450. newArray.SetSize(0, m_array.GetSize());
  452. int nPrevDataRow = -1;
  454. for (int nIndex = 0; nIndex < nCount; nIndex++)
  455. {
  456. XTP_EDIT_LMDATA* pData = m_array.GetAt(nIndex);
  457. if (!pData)
  458. continue;
  460. if (pData->m_nRow < nRowL ||
  461. pData->m_nRow == nRowL && !bDel_only1 && !bInsertAt0)
  462. {
  463. // does not affect refresh
  464. newArray.Add(pData);
  466. nPrevDataRow = pData->m_nRow;
  467. }
  468. else if (bDel && pData->m_nRow < nRowU ||
  469.  bDel_only1 && pData->m_nRow == nRowL ||
  470.  bDel_only2 && pData->m_nRow == nRowU)
  471. {
  472. // delete line mark
  473. delete pData;
  474. }
  475. else
  476. {
  477. // refresh position
  478. pData->m_nRow += nDiff;
  480. if (nPrevDataRow == pData->m_nRow)
  481. {
  482. // delete line mark
  483. delete pData;
  484. }
  485. else
  486. {
  487. newArray.Add(pData);
  488. nPrevDataRow = pData->m_nRow;
  489. }
  490. }
  491. }
  492. // update data in the old array
  493. m_array.RemoveAll();
  494. m_array.Append(newArray);
  495. }
  497. void CXTPSyntaxEditLineMarksManager::CLineMarksList::RemoveAll()
  498. {
  499. const int nCount = (int)m_array.GetSize();
  500. for (int i = 0; i < nCount; i++)
  501. {
  502. XTP_EDIT_LMDATA* pData = m_array.GetAt(i);
  503. if (pData)
  504. delete pData;
  505. }
  507. m_array.RemoveAll();
  508. }
  510. int CXTPSyntaxEditLineMarksManager::CLineMarksList::GetCount()
  511. {
  512. return (int)m_array.GetSize();
  513. }
  515. POSITION CXTPSyntaxEditLineMarksManager::CLineMarksList::GetFirstLineMark()
  516. {
  517. return BEFORE_START_POSITION;
  518. }
  520. XTP_EDIT_LMDATA* CXTPSyntaxEditLineMarksManager::CLineMarksList::GetNextLineMark(POSITION& pos)
  521. {
  522. // Rule: pos == element index + 1  (because 0=NULL and mean no more elements)
  524. // check for the beginning of the list
  525. if (pos == BEFORE_START_POSITION)
  526. {
  527. pos = (POSITION)1;
  528. }
  530. // get data corresponding to the position
  531. XTP_EDIT_LMDATA* pData = (INT_PTR)pos > (INT_PTR)m_array.GetSize() ? NULL : m_array.GetAt((INT_PTR)pos - 1);
  533. // increase position
  534. pos = (POSITION)((INT_PTR)pos + 1);
  536. // check for the end of the array
  537. if ((INT_PTR)pos > (INT_PTR)m_array.GetSize() )
  538. {
  539. //pos = (POSITION)m_array.GetSize();
  540. pos = NULL;
  541. }
  543. // return the data for the initial position
  544. return pData;
  545. }
  547. XTP_EDIT_LMDATA* CXTPSyntaxEditLineMarksManager::CLineMarksList::GetLineMarkAt(const POSITION pos)
  548. {
  549. // Rule: pos == element index + 1  (because 0=NULL and mean no more elements)
  551. INT_PTR nIndex = (INT_PTR)pos - 1;
  552. if (nIndex < 0 || nIndex >= (INT_PTR)m_array.GetSize())
  553. {
  554. return NULL;
  555. }
  556. return m_array.GetAt(nIndex);
  557. }
  558. /////////////////////////////////////////////////////////////////////////////
  560. CXTPSyntaxEditLineMarksManager::CLineMarksListPtr
  561. CXTPSyntaxEditLineMarksManager::CLineMarksListsMap::GetList(LPCTSTR szMarkType)
  562. {
  563. CLineMarksListPtr ptrList;
  564. if (!m_map.Lookup(szMarkType, ptrList))
  565. {
  566. return NULL;
  567. }
  568. return ptrList;
  569. }
  571. CXTPSyntaxEditLineMarksManager::CLineMarksListPtr
  572. CXTPSyntaxEditLineMarksManager::CLineMarksListsMap::AddList(LPCTSTR szMarkType)
  573. {
  574. CLineMarksListPtr ptrList(new CLineMarksList());
  575. m_map.SetAt(szMarkType, ptrList);
  576. return ptrList;
  577. }
  579. void CXTPSyntaxEditLineMarksManager::CLineMarksListsMap::RefreshLineMarks(
  580. int nRowFrom, int nRowTo, int nRefreshType)
  581. {
  582. POSITION pos = m_map.GetStartPosition();
  583. CString strKey;
  584. CLineMarksListPtr ptrList;
  585. while (pos != NULL)
  586. {
  587. m_map.GetNextAssoc(pos, strKey, ptrList);
  589. if (ptrList)
  590. ptrList->RefreshLineMarks(nRowFrom, nRowTo, nRefreshType);
  591. }
  592. }
  593. /////////////////////////////////////////////////////////////////////////////
  594. CXTPSyntaxEditLineMarksManager::CXTPSyntaxEditLineMarksManager()
  595. {
  596. }
  598. CXTPSyntaxEditLineMarksManager::~CXTPSyntaxEditLineMarksManager()
  599. {
  600. }
  602. void CXTPSyntaxEditLineMarksManager::AddRemoveLineMark(int nRow, const XTP_EDIT_LINEMARKTYPE lmType,
  603.   XTP_EDIT_LMPARAM* pParam)
  604. {
  605. if (HasRowMark(nRow, lmType))
  606. {
  607. DeleteLineMark(nRow, lmType);
  608. }
  609. else
  610. {
  611. SetLineMark(nRow, lmType, pParam);
  612. }
  613. }
  615. void CXTPSyntaxEditLineMarksManager::SetLineMark(int nRow, const XTP_EDIT_LINEMARKTYPE lmType,
  616.   XTP_EDIT_LMPARAM* pParam)
  617. {
  618. // prepare data structure
  619. XTP_EDIT_LMDATA lmData;
  620. lmData.m_nRow = nRow;
  621. if (pParam)
  622. {
  623. lmData.m_Param = *pParam;
  624. }
  626. // get corresponding list
  627. CLineMarksListPtr ptrList = m_mapLists.GetList(lmType);
  628. if (!ptrList)
  629. {
  630. // create new list
  631. ptrList = m_mapLists.AddList(lmType);
  632. if (!ptrList)
  633. return; // error happened
  634. }
  636. // set value
  637. ptrList->Add(lmData);
  638. }
  640. void CXTPSyntaxEditLineMarksManager::DeleteLineMark(int nRow, const XTP_EDIT_LINEMARKTYPE lmType)
  641. {
  642. // get corresponding list
  643. CLineMarksListPtr ptrList = m_mapLists.GetList(lmType);
  644. if (ptrList)
  645. {
  646. // delete line mark
  647. ptrList->Remove(nRow);
  649. }
  650. }
  652. BOOL CXTPSyntaxEditLineMarksManager::HasRowMark(int nRow, const XTP_EDIT_LINEMARKTYPE& lmType,
  653. XTP_EDIT_LMPARAM* pParam)
  654. {
  655. // get corresponding list
  656. CLineMarksListPtr ptrList = m_mapLists.GetList(lmType);
  657. if (ptrList)
  658. {
  659. // Find line data
  660. POSITION pos = ptrList->FindAt(nRow);
  661. XTP_EDIT_LMDATA* pData = ptrList->GetLineMarkAt(pos);
  662. if (pData)
  663. {
  664. ASSERT(pData->m_nRow == nRow);
  665. if (pParam)
  666. {
  667. *pParam = pData->m_Param;
  668. }
  669. return TRUE;
  670. }
  671. }
  673. return FALSE;
  674. }
  676. POSITION CXTPSyntaxEditLineMarksManager::GetLastLineMark(const XTP_EDIT_LINEMARKTYPE lmType)
  677. {
  678. int nRow = INT_MAX - 1;
  679. return FindPrevLineMark(nRow, lmType);
  680. }
  682. POSITION CXTPSyntaxEditLineMarksManager::FindPrevLineMark(int& nRow, const XTP_EDIT_LINEMARKTYPE lmType)
  683. {
  684. int nPrevRow = -1;
  685. POSITION posPrev = NULL;
  687. // get corresponding list
  688. CLineMarksListPtr ptrList = m_mapLists.GetList(lmType);
  689. if (ptrList)
  690. {
  691. // Find line data
  692. posPrev = ptrList->FindPrev(nRow);
  693. XTP_EDIT_LMDATA* pData = ptrList->GetLineMarkAt(posPrev);
  694. if (pData)
  695. {
  696. nPrevRow = pData->m_nRow;
  697. }
  698. }
  700. nRow = nPrevRow;
  701. return posPrev;
  702. }
  704. POSITION CXTPSyntaxEditLineMarksManager::FindNextLineMark(int& nRow, const XTP_EDIT_LINEMARKTYPE lmType)
  705. {
  706. int nNextRow = INT_MAX;
  707. POSITION posNext = NULL;
  709. // get corresponding list
  710. CLineMarksListPtr ptrList = m_mapLists.GetList(lmType);
  711. if (ptrList)
  712. {
  713. // Find line data
  714. posNext = ptrList->FindNext(nRow);
  715. XTP_EDIT_LMDATA* pData = ptrList->GetLineMarkAt(posNext);
  716. if (pData)
  717. {
  718. nNextRow = pData->m_nRow;
  719. }
  720. }
  722. if (nNextRow == INT_MAX)
  723. {
  724. nNextRow = -1;
  725. }
  727. nRow = nNextRow;
  728. return posNext;
  729. }
  731. POSITION CXTPSyntaxEditLineMarksManager::GetFirstLineMark(const XTP_EDIT_LINEMARKTYPE lmType)
  732. {
  733. // get corresponding list
  734. CLineMarksListPtr ptrList = m_mapLists.GetList(lmType);
  735. return ptrList ? ptrList->GetFirstLineMark() : NULL;
  736. }
  738. XTP_EDIT_LMDATA* CXTPSyntaxEditLineMarksManager::GetNextLineMark(POSITION& pos, const XTP_EDIT_LINEMARKTYPE lmType)
  739. {
  740. CLineMarksListPtr ptrList = m_mapLists.GetList(lmType);
  741. return ptrList ? ptrList->GetNextLineMark(pos) : NULL;
  742. }
  744. void CXTPSyntaxEditLineMarksManager::RefreshLineMarks(int nRowFrom, int nRowTo, int nRefreshType)
  745. {
  746. m_mapLists.RefreshLineMarks(nRowFrom, nRowTo, nRefreshType);
  747. }
  749. void CXTPSyntaxEditLineMarksManager::RemoveAll(const XTP_EDIT_LINEMARKTYPE lmType)
  750. {
  751. // get corresponding list
  752. CLineMarksListPtr ptrList = m_mapLists.GetList(lmType);
  753. if (ptrList)
  754. ptrList->RemoveAll();
  755. }
  757. XTP_EDIT_LMDATA* CXTPSyntaxEditLineMarksManager::GetLineMarkAt(const POSITION pos, const XTP_EDIT_LINEMARKTYPE lmType)
  758. {
  759. // get corresponding list
  760. CLineMarksListPtr ptrList = m_mapLists.GetList(lmType);
  761. return ptrList ? ptrList->GetLineMarkAt(pos) : NULL;
  762. }
  764. int CXTPSyntaxEditLineMarksManager::GetCount(const XTP_EDIT_LINEMARKTYPE lmType)
  765. {
  766. // get corresponding list
  767. CLineMarksListPtr ptrList = m_mapLists.GetList(lmType);
  768. return ptrList ? ptrList->GetCount() : 0;
  769. }