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

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

对话框与窗口

开发平台：

Visual C++

XTPSyntaxEditPaintManager.cpp：源码内容
  1. // XTPSyntaxEditPaintManager.cpp : implementation of the CXTPSyntaxEditPaintManager class.
  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/XTPVC80Helpers.h"
  26. #include "Common/XTPDrawHelpers.h"
  27. #include "Common/XTPResourceManager.h"
  28. #include "Common/XTPColorManager.h"
  29. #include "Common/XTPNotifyConnection.h"
  30. #include "Common/XTPSmartPtrInternalT.h"
  31. #include "Common/XTPVC50Helpers.h"
  33. // syntax editor includes
  34. #include "XTPSyntaxEditDefines.h"
  35. #include "XTPSyntaxEditStruct.h"
  36. #include "XTPSyntaxEditUndoManager.h"
  37. #include "XTPSyntaxEditLineMarksManager.h"
  38. #include "XTPSyntaxEditLexPtrs.h"
  39. #include "XTPSyntaxEditLexClassSubObjT.h"
  40. #include "XTPSyntaxEditTextIterator.h"
  41. #include "XTPSyntaxEditSectionManager.h"
  42. #include "XTPSyntaxEditLexCfgFileReader.h"
  43. #include "XTPSyntaxEditLexClassSubObjDef.h"
  44. #include "XTPSyntaxEditLexClass.h"
  45. #include "XTPSyntaxEditLexParser.h"
  46. #include "XTPSyntaxEditLexColorFileReader.h"
  47. #include "XTPSyntaxEditCtrl.h"
  48. #include "XTPSyntaxEditCtrl.h"
  49. #include "XTPSyntaxEditPaintManager.h"
  50. #include "XTPSyntaxEditBufferManager.h"
  52. #include <math.h>
  54. #ifdef _DEBUG
  55. #undef THIS_FILE
  56. static char THIS_FILE[]=__FILE__;
  57. #define new DEBUG_NEW
  58. #endif
  60. //===========================================================================
  61. // CXTPSyntaxEditPaintManager class
  62. //===========================================================================
  63. IMPLEMENT_DYNAMIC(CXTPSyntaxEditPaintManager, CCmdTarget)
  65. //////////////////////////////////////////////////////////////////////
  66. // Construction/Destruction
  67. //////////////////////////////////////////////////////////////////////
  69. CXTPSyntaxEditPaintManager::CXTPSyntaxEditPaintManager()
  70. {
  72. m_hCurLine = XTPResourceManager()->LoadCursor(XTP_IDC_EDIT_BACKARROW);
  73. m_hCurMove = XTPResourceManager()->LoadCursor(XTP_IDC_EDIT_MOVE);
  74. m_hCurCopy = XTPResourceManager()->LoadCursor(XTP_IDC_EDIT_COPY);
  75. m_hCurIBeam = AfxGetApp()->LoadStandardCursor(IDC_IBEAM);
  76. m_hCurArrow = AfxGetApp()->LoadStandardCursor(IDC_ARROW);
  77. m_hCurNO = AfxGetApp()->LoadStandardCursor(IDC_NO);
  79. // get non-client metrics info.
  80. NONCLIENTMETRICS ncm;
  81. ncm.cbSize = sizeof(NONCLIENTMETRICS);
  82. ::SystemParametersInfo(SPI_GETNONCLIENTMETRICS, 0, &ncm, 0);
  84. // create the tooltip font.
  85. VERIFY(SetFontToolTip(&ncm.lfStatusFont));
  87. // construct default fonts.
  88. VERIFY(CreateFontIndirect(NULL, FALSE));
  90. // Initialize metrics
  91. RefreshMetrics();
  92. InitBitmaps();
  95. }
  97. CXTPSyntaxEditPaintManager::~CXTPSyntaxEditPaintManager()
  98. {
  100. }
  102. void CXTPSyntaxEditPaintManager::InitBitmaps()
  103. {
  104. // Check for already initialized bitmaps
  105. m_ilBookmark.DeleteImageList();
  107. // Load bookmarks bitmap
  108. CBitmap bmpBookMarks;       // Regular bookmark image
  110. if (XTPResourceManager()->LoadBitmap(& bmpBookMarks, XTP_IDB_EDIT_BOOKMARKS))
  111. {
  112. BITMAP info;
  113. bmpBookMarks.GetBitmap(&info);
  115. if (m_ilBookmark.Create(20, info.bmHeight,
  116. ILC_COLOR24|ILC_MASK, 0, 1))
  117. {
  118. m_ilBookmark.Add(&bmpBookMarks, RGB(0x00,0xff,0x00));
  119. }
  120. }
  121. }
  123. HCURSOR CXTPSyntaxEditPaintManager::SetMoveCursor(HCURSOR hCurMove)
  124. {
  125. HCURSOR hCurMoveOld = m_hCurMove;
  126. m_hCurMove = hCurMove;
  127. return hCurMoveOld;
  128. }
  130. HCURSOR CXTPSyntaxEditPaintManager::SetCopyCursor(HCURSOR hCurCopy)
  131. {
  132. HCURSOR hCurCopyOld = m_hCurCopy;
  133. m_hCurCopy = hCurCopy;
  134. return hCurCopyOld;
  135. }
  137. HCURSOR CXTPSyntaxEditPaintManager::SetLineSelCursor(HCURSOR hCur)
  138. {
  139. HCURSOR hCurOld = m_hCurLine;
  140. m_hCurLine = hCur;
  141. return hCurOld;
  142. }
  144. AFX_STATIC void GetCustomValue(CWinApp* pWinApp, LPCTSTR lpszRegKey, CXTPPaintManagerColor& pmc)
  145. {
  146. COLORREF color = pWinApp->GetProfileInt(XTP_EDIT_REG_SETTINGS,
  147. lpszRegKey, pmc.GetStandardColor());
  149. if (color != pmc.GetStandardColor())
  150. {
  151. pmc = color;
  152. }
  153. }
  155. void CXTPSyntaxEditPaintManager::RefreshMetrics()
  156. {
  157. // Initialize default colors.
  158. m_clrValues.crText.SetStandardValue(::GetSysColor(COLOR_WINDOWTEXT));
  159. m_clrValues.crBack.SetStandardValue(::GetSysColor(COLOR_WINDOW));
  160. m_clrValues.crReadOnlyBack.SetStandardValue(::GetSysColor(COLOR_3DFACE));
  161. m_clrValues.crHiliteText.SetStandardValue(::GetSysColor(COLOR_HIGHLIGHTTEXT));
  162. m_clrValues.crHiliteBack.SetStandardValue(::GetSysColor(COLOR_HIGHLIGHT));
  163. m_clrValues.crInactiveHiliteText.SetStandardValue(::GetSysColor(COLOR_INACTIVECAPTIONTEXT));
  164. m_clrValues.crInactiveHiliteBack.SetStandardValue(::GetSysColor(COLOR_INACTIVECAPTION));
  165. m_clrValues.crLineNumberText.SetStandardValue(RGB(0x00,0x82,0x84));
  166. m_clrValues.crLineNumberBack.SetStandardValue(::GetSysColor(COLOR_WINDOW));
  168. // Restore user settings from registry.
  169. CWinApp* pWinApp = AfxGetApp();
  170. if (pWinApp != NULL)
  171. {
  172. GetCustomValue(pWinApp, XTP_EDIT_REG_TEXTCOLOR, m_clrValues.crText);
  173. GetCustomValue(pWinApp, XTP_EDIT_REG_BACKCOLOR, m_clrValues.crBack);
  174. GetCustomValue(pWinApp, XTP_EDIT_REG_SELTEXTCOLOR, m_clrValues.crHiliteText);
  175. GetCustomValue(pWinApp, XTP_EDIT_REG_SELBACKCOLOR, m_clrValues.crHiliteBack);
  176. GetCustomValue(pWinApp, XTP_EDIT_REG_INSELTEXTCOLOR, m_clrValues.crInactiveHiliteText);
  177. GetCustomValue(pWinApp, XTP_EDIT_REG_INSELBACKCOLOR, m_clrValues.crInactiveHiliteBack);
  178. GetCustomValue(pWinApp, XTP_EDIT_REG_LINENUMTEXTCOLOR, m_clrValues.crLineNumberText);
  179. GetCustomValue(pWinApp, XTP_EDIT_REG_LINENUMBACKCOLOR, m_clrValues.crLineNumberBack);
  181. UINT nSize = 0;
  182. LPBYTE pbtData = 0;
  183. if (pWinApp->GetProfileBinary(XTP_EDIT_REG_SETTINGS, XTP_EDIT_REG_LOGFONT, &pbtData, &nSize))
  184. {
  185. LOGFONT* pLogFont = reinterpret_cast<LOGFONT*>(pbtData);
  186. CreateFontIndirect(pLogFont);
  187. delete [] pbtData;
  188. }
  189. }
  191. // Initialize gray pen.
  192. if (m_penGray.m_hObject)
  193. m_penGray.DeleteObject();
  194. m_penGray.CreatePen(PS_SOLID, 1, ::GetSysColor(COLOR_3DSHADOW));
  195. }
  197. //////////////////////////////////////////////////////////////////////////
  199. CFont* CXTPSyntaxEditPaintManager::GetFont()
  200. {
  201. return &m_font;
  202. }
  204. BOOL CXTPSyntaxEditPaintManager::CreateFontIndirect(LPLOGFONT pLogfont, BOOL bUpdateReg/*=FALSE*/)
  205. {
  206. LOGFONT lfDefault;
  208. // construct default fonts.
  209. if (!pLogfont)
  210. {
  211. ::ZeroMemory(&lfDefault, sizeof(LOGFONT));
  213. lfDefault.lfCharSet = DEFAULT_CHARSET;
  214. lfDefault.lfWeight = FW_NORMAL;
  215. lfDefault.lfHeight = -13;
  216. STRCPY_S(lfDefault.lfFaceName, LF_FACESIZE, _T("Courier New"));
  218. pLogfont = &lfDefault;
  219. }
  221. if (!SetFont(pLogfont))
  222. return FALSE;
  224. if (!SetFontText(pLogfont))
  225. return FALSE;
  227. if (!SetFontLineNumber(pLogfont))
  228. return FALSE;
  230. if (bUpdateReg)
  231. {
  232. CWinApp* pWinApp = AfxGetApp();
  233. if (pWinApp != NULL)
  234. {
  235. if (pWinApp->WriteProfileBinary(XTP_EDIT_REG_SETTINGS, XTP_EDIT_REG_LOGFONT,
  236. reinterpret_cast<LPBYTE>(pLogfont), sizeof(LOGFONT)))
  237. {
  238. return TRUE;
  239. }
  240. }
  241. return FALSE;
  242. }
  244. return TRUE;
  245. }
  247. BOOL CXTPSyntaxEditPaintManager::SetFont(LPLOGFONT pLogfont)
  248. {
  249. if (m_font.m_hObject)
  250. {
  251. m_font.DeleteObject();
  252. }
  253. return m_font.CreateFontIndirect(pLogfont);
  254. }
  256. CFont* CXTPSyntaxEditPaintManager::GetFontText()
  257. {
  258. return &m_fontText;
  259. }
  261. BOOL CXTPSyntaxEditPaintManager::SetFontText(LPLOGFONT pLogfont)
  262. {
  263. if (m_fontText.m_hObject)
  264. {
  265. m_fontText.DeleteObject();
  266. }
  267. return m_fontText.CreateFontIndirect(pLogfont);
  268. }
  270. CFont* CXTPSyntaxEditPaintManager::GetFontLineNumber()
  271. {
  272. return &m_fontLineNumber;
  273. }
  275. BOOL CXTPSyntaxEditPaintManager::SetFontLineNumber(LPLOGFONT pLogfont)
  276. {
  277. if (m_fontLineNumber.m_hObject)
  278. {
  279. m_fontLineNumber.DeleteObject();
  280. }
  281. return m_fontLineNumber.CreateFontIndirect(pLogfont);
  282. }
  284. CFont* CXTPSyntaxEditPaintManager::GetFontToolTip()
  285. {
  286. return &m_fontToolTip;
  287. }
  289. BOOL CXTPSyntaxEditPaintManager::SetFontToolTip(LPLOGFONT pLogfont)
  290. {
  291. if (m_fontToolTip.m_hObject)
  292. {
  293. m_fontToolTip.DeleteObject();
  294. }
  295. return m_fontToolTip.CreateFontIndirect(pLogfont);
  296. }
  298. //////////////////////////////////////////////////////////////////////////
  300. HCURSOR CXTPSyntaxEditPaintManager::GetCurLine()
  301. {
  302. return m_hCurLine;
  303. }
  305. HCURSOR CXTPSyntaxEditPaintManager::GetCurMove()
  306. {
  307. return m_hCurMove;
  308. }
  310. HCURSOR CXTPSyntaxEditPaintManager::GetCurCopy()
  311. {
  312. return m_hCurCopy;
  313. }
  315. HCURSOR CXTPSyntaxEditPaintManager::GetCurNO()
  316. {
  317. return m_hCurNO;
  318. }
  320. HCURSOR CXTPSyntaxEditPaintManager::GetCurIBeam()
  321. {
  322. return m_hCurIBeam;
  323. }
  325. HCURSOR CXTPSyntaxEditPaintManager::GetCurArrow()
  326. {
  327. return m_hCurArrow;
  328. }
  330. BOOL CXTPSyntaxEditPaintManager::SetTextColor(COLORREF color, BOOL bUpdateReg/*=FALSE*/)
  331. {
  332. m_clrValues.crText = color;
  334. if (bUpdateReg)
  335. {
  336. CWinApp* pWinApp = AfxGetApp();
  337. if (pWinApp != NULL)
  338. {
  339. if (pWinApp->WriteProfileInt(XTP_EDIT_REG_SETTINGS, XTP_EDIT_REG_TEXTCOLOR, (int)color))
  340. return TRUE;
  341. }
  342. return FALSE;
  343. }
  345. return TRUE;
  346. }
  348. BOOL CXTPSyntaxEditPaintManager::SetBackColor(COLORREF color, BOOL bUpdateReg/*=FALSE*/)
  349. {
  350. m_clrValues.crBack = color;
  352. if (bUpdateReg)
  353. {
  354. CWinApp* pWinApp = AfxGetApp();
  355. if (pWinApp != NULL)
  356. {
  357. if (pWinApp->WriteProfileInt(XTP_EDIT_REG_SETTINGS, XTP_EDIT_REG_BACKCOLOR, (int)color))
  358. return TRUE;
  359. }
  360. return FALSE;
  361. }
  363. return TRUE;
  364. }
  366. BOOL CXTPSyntaxEditPaintManager::SetReadOnlyBackColor(COLORREF color, BOOL bUpdateReg/*=FALSE*/)
  367. {
  368. m_clrValues.crReadOnlyBack = color;
  370. if (bUpdateReg)
  371. {
  372. CWinApp* pWinApp = AfxGetApp();
  373. if (pWinApp != NULL)
  374. {
  375. if (pWinApp->WriteProfileInt(XTP_EDIT_REG_SETTINGS, XTP_EDIT_REG_READONLYBACKCOLOR, (int)color))
  376. return TRUE;
  377. }
  378. return FALSE;
  379. }
  381. return TRUE;
  382. }
  385. BOOL CXTPSyntaxEditPaintManager::SetHiliteTextColor(COLORREF color, BOOL bUpdateReg/*=FALSE*/)
  386. {
  387. m_clrValues.crHiliteText = color;
  389. if (bUpdateReg)
  390. {
  391. CWinApp* pWinApp = AfxGetApp();
  392. if (pWinApp != NULL)
  393. {
  394. if (pWinApp->WriteProfileInt(XTP_EDIT_REG_SETTINGS, XTP_EDIT_REG_SELTEXTCOLOR, (int)color))
  395. return TRUE;
  396. }
  397. return FALSE;
  398. }
  400. return TRUE;
  401. }
  403. BOOL CXTPSyntaxEditPaintManager::SetHiliteBackColor(COLORREF color, BOOL bUpdateReg/*=FALSE*/)
  404. {
  405. m_clrValues.crHiliteBack = color;
  407. if (bUpdateReg)
  408. {
  409. CWinApp* pWinApp = AfxGetApp();
  410. if (pWinApp != NULL)
  411. {
  412. if (pWinApp->WriteProfileInt(XTP_EDIT_REG_SETTINGS, XTP_EDIT_REG_SELBACKCOLOR, (int)color))
  413. return TRUE;
  414. }
  415. return FALSE;
  416. }
  418. return TRUE;
  419. }
  421. BOOL CXTPSyntaxEditPaintManager::SetInactiveHiliteTextColor(COLORREF color, BOOL bUpdateReg/*=FALSE*/)
  422. {
  423. m_clrValues.crInactiveHiliteText = color;
  425. if (bUpdateReg)
  426. {
  427. CWinApp* pWinApp = AfxGetApp();
  428. if (pWinApp != NULL)
  429. {
  430. if (pWinApp->WriteProfileInt(XTP_EDIT_REG_SETTINGS, XTP_EDIT_REG_INSELTEXTCOLOR, (int)color))
  431. return TRUE;
  432. }
  433. return FALSE;
  434. }
  436. return TRUE;
  437. }
  439. BOOL CXTPSyntaxEditPaintManager::SetInactiveHiliteBackColor(COLORREF color, BOOL bUpdateReg/*=FALSE*/)
  440. {
  441. m_clrValues.crInactiveHiliteBack = color;
  443. if (bUpdateReg)
  444. {
  445. CWinApp* pWinApp = AfxGetApp();
  446. if (pWinApp != NULL)
  447. {
  448. if (pWinApp->WriteProfileInt(XTP_EDIT_REG_SETTINGS, XTP_EDIT_REG_INSELBACKCOLOR, (int)color))
  449. return TRUE;
  450. }
  451. return FALSE;
  452. }
  454. return TRUE;
  455. }
  457. BOOL CXTPSyntaxEditPaintManager::SetLineNumberTextColor(COLORREF color, BOOL bUpdateReg/*=FALSE*/)
  458. {
  459. m_clrValues.crLineNumberText = color;
  461. if (bUpdateReg)
  462. {
  463. CWinApp* pWinApp = AfxGetApp();
  464. if (pWinApp != NULL)
  465. {
  466. if (pWinApp->WriteProfileInt(XTP_EDIT_REG_SETTINGS, XTP_EDIT_REG_LINENUMTEXTCOLOR, (int)color))
  467. return TRUE;
  468. }
  469. return FALSE;
  470. }
  472. return TRUE;
  473. }
  475. BOOL CXTPSyntaxEditPaintManager::SetLineNumberBackColor(COLORREF color, BOOL bUpdateReg/*=FALSE*/)
  476. {
  477. m_clrValues.crLineNumberBack = color;
  479. if (bUpdateReg)
  480. {
  481. CWinApp* pWinApp = AfxGetApp();
  482. if (pWinApp != NULL)
  483. {
  484. if (pWinApp->WriteProfileInt(XTP_EDIT_REG_SETTINGS, XTP_EDIT_REG_LINENUMBACKCOLOR, (int)color))
  485. return TRUE;
  486. }
  487. return FALSE;
  488. }
  490. return TRUE;
  491. }
  493. //////////////////////////////////////////////////////////////////////////
  494. CImageList* CXTPSyntaxEditPaintManager::GetBookmarks()
  495. {
  496. return &m_ilBookmark;
  497. }
  499. //////////////////////////////////////////////////////////////////////////
  501. BOOL CXTPSyntaxEditPaintManager::UpdateTextFont(CXTPSyntaxEditCtrl* pEditCtrl, const XTP_EDIT_FONTOPTIONS& lf)
  502. {
  503. LOGFONT lfOpt;
  504. m_font.GetLogFont(&lfOpt);
  506. if (pEditCtrl && pEditCtrl->GetSyntaxColor())
  507. {
  508. if (lf.lfItalic != XTP_EDIT_FONTOPTIONS_UNSPEC_OPTION)
  509. {
  510. lfOpt.lfItalic = lf.lfItalic;
  511. }
  512. if (lf.lfWeight != XTP_EDIT_FONTOPTIONS_UNSPEC_OPTION)
  513. {
  514. lfOpt.lfWeight = lf.lfWeight;
  515. }
  516. if (lf.lfUnderline != XTP_EDIT_FONTOPTIONS_UNSPEC_OPTION)
  517. {
  518. lfOpt.lfUnderline = lf.lfUnderline;
  519. }
  520. }
  522. return SetFontText(&lfOpt);
  523. }
  525. void CXTPSyntaxEditPaintManager::DrawLineNumber(CDC *pDC, const CRect& rcRect, int nTextRow, CXTPSyntaxEditCtrl* pEditCtrl)
  526. {
  527. if (!pEditCtrl)
  528. return;
  530. if (nTextRow < 1)
  531. return;
  533. if (!pDC->IsPrinting())
  534. {
  535. COLORREF clrBk = m_clrValues.crLineNumberBack;
  536. if (m_clrValues.crLineNumberBack.IsStandardValue() && pEditCtrl->IsReadOnly())
  537. clrBk = m_clrValues.crReadOnlyBack;
  539. pDC->FillSolidRect(&rcRect, clrBk);
  540. }
  542. CXTPFontDC fontDC(pDC, GetFontLineNumber(), m_clrValues.crLineNumberText);
  544. CRect rcLineNum(rcRect);
  545. rcLineNum.right -= 2;
  547. if (nTextRow <= pEditCtrl->GetRowCount())
  548. {
  549. // Print line number
  550. CString strLineNum;
  551. strLineNum.Format(_T("%d"), nTextRow);
  553. pDC->DrawText(strLineNum, &rcLineNum, DT_VCENTER|DT_RIGHT);
  554. }
  556. if (!pDC->IsPrinting())
  557. DrawLineNumbersBorder(pDC, rcLineNum, m_clrValues.crLineNumberText);
  558. }
  560. void CXTPSyntaxEditPaintManager::DrawLineNumbersBorder(CDC *pDC, const CRect& rcLineNum, const COLORREF clrBorder)
  561. {
  562. int nDotLineX = rcLineNum.right+1;
  564. for (int y = rcLineNum.top; y < rcLineNum.bottom; y++)
  565. {
  566. if (y % 2)
  567. {
  568. pDC->SetPixelV(nDotLineX, y, clrBorder);
  569. }
  570. }
  571. }
  573. void CXTPSyntaxEditPaintManager::DrawLineNodeBackground(CDC *pDC, const CRect& rcNodeFull,
  574. DWORD dwType, int nTextRow, CXTPSyntaxEditCtrl* pEditCtrl)
  575. {
  576. UNREFERENCED_PARAMETER(dwType); UNREFERENCED_PARAMETER(nTextRow);
  578. pDC->FillSolidRect(&rcNodeFull, m_clrValues.GetBackColorEx(pEditCtrl));
  579. }
  581. void CXTPSyntaxEditPaintManager::DrawLineNode(CDC *pDC, const CRect& rcNode, const CRect& rcNodeFull,
  582. DWORD dwType, int nTextRow, CXTPSyntaxEditCtrl* pEditCtrl)
  583. {
  584. if (!pEditCtrl || !pEditCtrl->m_bDrawNodes)
  585. return;
  587. // fill node background
  588. DrawLineNodeBackground(pDC, rcNodeFull, dwType, nTextRow, pEditCtrl);
  590. // draw node picture
  591. if (dwType != XTP_EDIT_ROWNODE_NOTHING)
  592. {
  593. CXTPPenDC penGray(pDC, &m_penGray);
  595. if (dwType & XTP_EDIT_ROWNODE_NODEUP)
  596. {
  597. // draw up line
  598. CPoint ptEnd(rcNode.CenterPoint().x, rcNodeFull.top);
  599. pDC->MoveTo(ptEnd);
  600. ptEnd.y += rcNodeFull.Height() / 2;
  601. pDC->LineTo(ptEnd);
  602. }
  604. if (dwType & XTP_EDIT_ROWNODE_NODEDOWN)
  605. {
  606. // draw down line
  607. CPoint ptEnd(rcNode.CenterPoint().x, rcNodeFull.bottom);
  608. pDC->MoveTo(ptEnd);
  609. ptEnd.y -= rcNodeFull.Height() / 2 + 2;
  610. pDC->LineTo(ptEnd);
  611. }
  613. if (dwType & XTP_EDIT_ROWNODE_ENDMARK)
  614. {
  615. // draw down line
  616. CPoint ptEnd(rcNode.CenterPoint());
  617. pDC->MoveTo(ptEnd);
  618. ptEnd.x += rcNodeFull.Width() / 2;
  619. pDC->LineTo(ptEnd);
  620. }
  622. if (dwType & XTP_EDIT_ROWNODE_COLLAPSED ||
  623. dwType & XTP_EDIT_ROWNODE_EXPANDED)
  624. {
  625. // draw collapsed sign
  626. pDC->Rectangle(&rcNode);
  627. CPoint ptSign(rcNode.CenterPoint());
  628. ptSign.x -= 2;
  629. pDC->MoveTo(ptSign);
  630. ptSign.x += 5;
  631. pDC->LineTo(ptSign);
  632. }
  634. if (dwType & XTP_EDIT_ROWNODE_COLLAPSED)
  635. {
  636. // draw vertical line of the expanded sign
  637. CPoint ptSign(rcNode.CenterPoint());
  638. ptSign.y -= 2;
  639. pDC->MoveTo(ptSign);
  640. ptSign.y += 5;
  641. pDC->LineTo(ptSign);
  643. }
  644. }
  645. }
  647. void CXTPSyntaxEditPaintManager::DrawCollapsedTextMarks(CXTPSyntaxEditCtrl* pEditCtrl, CDC *pDC)
  648. {
  649. COLORREF clrFrame = GetSysColor(COLOR_BTNSHADOW);
  650. COLORREF crText = GetSysColor(COLOR_BTNSHADOW);
  652. CXTPFontDC fontDC(pDC, GetFont());
  654. const XTP_EDIT_COLLAPSEDBLOCK* pCoDrawBlk = NULL;
  655. XTP_EDIT_LMPARAM LMCoParam;
  656. int nActualRow = 0;
  658. for (int i = 0; i < pEditCtrl->m_nCollapsedTextRowsCount; i++)
  659. {
  660. // get next collapsed row
  661. int nRow = pEditCtrl->m_arCollapsedTextRows[i];
  663. if (nRow <= nActualRow)
  664. {
  665. continue;
  666. }
  668. if (!pEditCtrl->HasRowMark(nRow, xtpEditLMT_Collapsed, &LMCoParam))
  669. {
  670. continue;
  671. }
  673. // get count of collapsed rows under this row
  674. int nHiddenRows = 0;
  675. if (!pEditCtrl->GetCollapsedBlockLen(nRow, nHiddenRows))
  676. {
  677. continue;
  678. }
  680. nActualRow = nRow + nHiddenRows;
  682. // get collapsed block pointer
  683. pCoDrawBlk = (XTP_EDIT_COLLAPSEDBLOCK*)LMCoParam.GetPtr();
  685. if (!pCoDrawBlk)
  686. {
  687. ASSERT(FALSE);
  688. continue;
  689. }
  691. CString strText = pCoDrawBlk->collBlock.strCollapsedText; // "[..]"
  692. CRect rcFrame(pCoDrawBlk->rcCollMark);
  693. rcFrame.InflateRect(0, 0, 0, 1);
  695. CRect rcText = pCoDrawBlk->rcCollMark;
  696. rcText.DeflateRect(1, 0, 1, 0);
  698. COLORREF clrBack = pEditCtrl->IsReadOnly() ? (COLORREF)m_clrValues.crReadOnlyBack :
  699.  (COLORREF)m_clrValues.crBack;
  700. pDC->FillSolidRect(&rcText, clrBack);
  702. pDC->SetTextColor(crText);
  703. pDC->SetBkColor(clrBack);
  705. pDC->DrawText(strText, &rcText, 0);
  707. pDC->Draw3dRect(&rcFrame, clrFrame, clrFrame);
  708. }
  709. }
  711. void CXTPSyntaxEditPaintManager::DrawLineCalcSel(const XTP_EDIT_TEXTBLOCK& txtBlk,
  712.   int nSelStartX, int nSelEndX,
  713.   XTP_EDIT_TEXTBLOCK (&arTxtBlk)[4], BOOL (&bUseBlk)[4] )
  714. {
  715. ASSERT(nSelStartX < nSelEndX);
  717. if (txtBlk.nPos < nSelStartX && txtBlk.nNextBlockPos-1 >= nSelStartX &&
  718. txtBlk.nNextBlockPos <= nSelEndX)
  719. {
  720. arTxtBlk[1] = arTxtBlk[2] = txtBlk;
  722. arTxtBlk[1].nNextBlockPos = nSelStartX;
  723. arTxtBlk[2].nPos = nSelStartX;
  725. bUseBlk[1] = bUseBlk[2] = TRUE;
  726. }
  727. else if (txtBlk.nPos >= nSelStartX && txtBlk.nPos < nSelEndX &&
  728. txtBlk.nNextBlockPos > nSelEndX)
  729. {
  730. arTxtBlk[2] = arTxtBlk[3] = txtBlk;
  732. arTxtBlk[2].nNextBlockPos = nSelEndX;
  733. arTxtBlk[3].nPos = nSelEndX;
  735. bUseBlk[2] = bUseBlk[3] = TRUE;
  736. }
  737. else if (txtBlk.nPos >= nSelStartX && txtBlk.nNextBlockPos <= nSelEndX)
  738. {
  739. arTxtBlk[2] = txtBlk;
  740. bUseBlk[2] = TRUE;
  741. }
  742. else if (txtBlk.nPos < nSelStartX && txtBlk.nNextBlockPos > nSelEndX)
  743. {
  744. arTxtBlk[1] = arTxtBlk[2] = arTxtBlk[3] = txtBlk;
  746. arTxtBlk[1].nNextBlockPos = nSelStartX;
  747. arTxtBlk[2].nPos = nSelStartX;
  748. arTxtBlk[2].nNextBlockPos = nSelEndX;
  749. arTxtBlk[3].nPos = nSelEndX;
  751. bUseBlk[1] = bUseBlk[2] = bUseBlk[3] = TRUE;
  752. }
  753. else
  754. {
  755. ASSERT(txtBlk.nPos >= nSelEndX || txtBlk.nNextBlockPos <= nSelStartX);
  757. arTxtBlk[1] = txtBlk;
  758. bUseBlk[1] = TRUE;
  759. }
  760. }
  762. void CXTPSyntaxEditPaintManager::DrawLineMark(CXTPSyntaxEditCtrl* pEditCtrl, XTP_EDIT_SENMBOOKMARK* pBookmark)
  763. {
  764. enum { bookMark, bookMarkSel, breakpoint };
  766. POINT ptStart;
  767. ptStart.x = pBookmark->rcBookmark.left;
  768. ptStart.y = pBookmark->rcBookmark.top;
  770. SIZE szRect;
  771. szRect.cx = pBookmark->rcBookmark.right - pBookmark->rcBookmark.left;
  772. szRect.cy = pBookmark->rcBookmark.bottom - pBookmark->rcBookmark.top;
  774. CDC *pDC = CDC::FromHandle(pBookmark->hDC);
  776. IMAGEINFO bmpInfo;
  777. ZeroMemory(&bmpInfo, sizeof(bmpInfo));
  779. if (pEditCtrl->HasRowMark(pBookmark->nRow, xtpEditLMT_Bookmark))
  780. {
  781. int iImage = (pEditCtrl->GetCurrentDocumentRow() == pBookmark->nRow)? bookMarkSel: bookMark;
  782. if (GetBookmarks()->GetImageInfo(iImage, &bmpInfo))
  783. {
  784. CRect rcBmp(bmpInfo.rcImage);
  785. szRect.cx = min(szRect.cx, rcBmp.Width());
  786. szRect.cy = min(szRect.cy, rcBmp.Height());
  787. }
  789. IMAGELISTDRAWINDIRECT_S(GetBookmarks(), pDC, iImage, ptStart, szRect);
  790. }
  792. if (pEditCtrl->HasRowMark(pBookmark->nRow, xtpEditLMT_Breakpoint))
  793. {
  794. if (GetBookmarks()->GetImageInfo(breakpoint, &bmpInfo))
  795. {
  796. CRect rcBmp(bmpInfo.rcImage);
  797. szRect.cx = min(szRect.cx, rcBmp.Width());
  798. szRect.cy = min(szRect.cy, rcBmp.Height());
  799. }
  801. IMAGELISTDRAWINDIRECT_S(GetBookmarks(), pDC, breakpoint, ptStart, szRect);
  803. pEditCtrl->SetRowBkColor(pBookmark->nRow, RGB(128,0,0));
  804. pEditCtrl->SetRowColor(pBookmark->nRow, RGB(255,255,255));
  805. }
  806. }
  808. void CXTPSyntaxEditPaintManager::DrawLineMarks(CDC *pDC, const CRect& rcRect, int nTextRow, CXTPSyntaxEditCtrl* pEditCtrl)
  809. {
  810. // NMHDR codes
  811. XTP_EDIT_SENMBOOKMARK bookmark;
  812. bookmark.nmhdr.code = XTP_EDIT_NM_DRAWBOOKMARK;
  813. bookmark.nmhdr.hwndFrom = pEditCtrl->GetSafeHwnd();
  814. bookmark.nmhdr.idFrom = 0;
  816. bookmark.hDC = pDC->GetSafeHdc();
  818. bookmark.rcBookmark = rcRect;
  819. bookmark.nRow = nTextRow;
  821. CRect rcLine = bookmark.rcBookmark;
  822. rcLine.left = rcLine.right-1;
  824. pDC->SetBkColor(::GetSysColor(COLOR_WINDOW));
  825. pDC->SetTextColor(::GetSysColor(COLOR_BTNFACE));
  826. pDC->FillRect(&bookmark.rcBookmark, pDC->GetHalftoneBrush());
  827. pDC->FillSolidRect(rcLine, ::GetSysColor(COLOR_3DSHADOW));
  829. BOOL bHandled = FALSE;
  830. CWnd *pParent = pEditCtrl->GetParent();
  831. if (pParent)
  832. {
  833. bHandled = (BOOL)pParent->SendMessage(WM_NOTIFY, 0, (LPARAM)&bookmark);
  834. }
  836. if (!bHandled)
  837. {
  838. DrawLineMark(pEditCtrl, &bookmark);
  839. }
  840. }
  844. int CXTPSyntaxEditPaintManager::DrawLineTextEx(CDC *pDC, const CRect& rcTextLine, int nTextRow,
  845.   int nLine, CXTPSyntaxEditCtrl* pEditCtrl)
  846. {
  847. int nRowHeight = 0;
  849. ASSERT(pDC && pEditCtrl);
  850. if (!pDC || !pEditCtrl)
  851. return nRowHeight;
  853. CXTPSyntaxEditDrawTextProcessor& drawTxtProc = pEditCtrl->GetDrawTextProcessor();
  855. drawTxtProc.ResetRowInfo(nLine);
  857. if (nTextRow <= 0)
  858. return nRowHeight;
  860. const CString& strText = pEditCtrl->GetLineText(nTextRow);
  861. int nTextLenC = (int)_tcsclen(strText);
  862. CString strDispText;
  864. drawTxtProc.ExpandChars(strText, strDispText, 0, pEditCtrl->IsEnabledWhiteSpace());
  865. drawTxtProc.SetRowTabPositions(nLine, strText);
  867. COLORREF crBreakText;
  868. BOOL bBreakText = pEditCtrl->m_mapRowColor.Lookup(nTextRow, crBreakText);
  870. COLORREF crBreakBack;
  871. BOOL bBreakBack  = pEditCtrl->m_mapRowBkColor.Lookup(nTextRow, crBreakBack);
  873. if (!bBreakBack)
  874. crBreakBack = m_clrValues.GetBackColorEx(pEditCtrl);
  876. if (!pDC->IsPrinting())
  877. pDC->FillSolidRect(&rcTextLine, crBreakBack);
  879. if (nTextRow > pEditCtrl->GetRowCount())
  880. return nRowHeight;
  882. pDC->SetBkMode(OPAQUE);
  883. pDC->SetTextColor(m_clrValues.crText);
  885. CXTPSyntaxEditTextBlockList blocks;
  887. pEditCtrl->GetRowColors(nTextRow, 0, -1, m_clrValues, &blocks);
  890. if (blocks.GetCount() == 0)
  891. {
  892. XTP_EDIT_TEXTBLOCK defBlk;
  893. defBlk.nPos = 0;
  894. defBlk.nNextBlockPos = nTextLenC;
  895. defBlk.clrBlock = m_clrValues;
  896. blocks.AddTail(defBlk);
  897. }
  899. // draw text
  901. //=======================================================================
  902. BOOL bCoBlkDrawn = FALSE;
  903. XTP_EDIT_COLLAPSEDBLOCK* pCoDrawBlk = NULL;
  904. XTP_EDIT_LMPARAM LMCoParam;
  905. if (pEditCtrl->HasRowMark(nTextRow, xtpEditLMT_Collapsed, &LMCoParam))
  906. {
  907. pCoDrawBlk = (XTP_EDIT_COLLAPSEDBLOCK*)LMCoParam.GetPtr();
  908. ASSERT(pCoDrawBlk);
  909. }
  911. //---------------------------------------------------------------
  912. BOOL bInfinitSelEnd = FALSE;
  913. int nSelStart = pEditCtrl->m_Selection.GetSelStartForRow_str(nTextRow, nLine);
  914. int nSelEnd = pEditCtrl->m_Selection.GetSelEndForRow_str(nTextRow, nLine, &bInfinitSelEnd);
  916. //---------------------------------------------------------------
  917. POSITION pos = blocks.GetHeadPosition();
  918. while (pos)
  919. {
  920. const XTP_EDIT_TEXTBLOCK& txtBlk = blocks.GetNext(pos);
  922. // draw [...] if needed
  923. if (pCoDrawBlk)
  924. {
  925. CRect rcCoBlk = rcTextLine;
  926. rcCoBlk.left += drawTxtProc.GetRowWidth(nLine) - drawTxtProc.GetScrollXOffset();
  927. rcCoBlk.left = max(rcCoBlk.left, rcTextLine.left);
  928. rcCoBlk.left = min(rcCoBlk.left, rcTextLine.right);
  930. bCoBlkDrawn = pEditCtrl->ProcessCollapsedTextEx(pDC, pCoDrawBlk, txtBlk, rcCoBlk);
  931. if (bCoBlkDrawn)
  932. {
  933. break;
  934. }
  935. }
  937. // define default colors.
  938. COLORREF crBack = m_clrValues.GetBackColorEx(pEditCtrl);
  939. COLORREF crText    = m_clrValues.crText;
  940. COLORREF crHiliteBack = m_clrValues.crHiliteBack;
  941. COLORREF crHiliteText = m_clrValues.crHiliteText;
  943. // if syntax coloring is enabled use defined colors.
  944. //      if (pEditCtrl->GetSyntaxColor())
  945. //      {
  946. crBack    = txtBlk.clrBlock.crBack;
  947. crText    = txtBlk.clrBlock.crText;
  948. crHiliteBack = txtBlk.clrBlock.crHiliteBack;
  949. crHiliteText = txtBlk.clrBlock.crHiliteText;
  950. //      }
  952. if (bBreakBack)
  953. crBack = crBreakBack;
  955. if (bBreakText)
  956. crText = crBreakText;
  958. //--------------------------------------------------------------
  959. if (crBack == (COLORREF)m_clrValues.crBack)
  960. crBack = m_clrValues.GetBackColorEx(pEditCtrl);
  962. //if (crBack == m_clrValues.crBack.GetStandardColor())
  963. //          crBack = m_clrValues.crBack;
  965. //      if (crText == m_clrValues.crText.GetStandardColor())
  966. //          crText = m_clrValues.crText;
  968. //--------------------------------------------------------------
  969. if (!pEditCtrl->IsActive())
  970. {
  971. if (crHiliteBack == m_clrValues.crHiliteBack.GetStandardColor())
  972. crHiliteBack = m_clrValues.crInactiveHiliteBack;
  974. if (crHiliteText == m_clrValues.crHiliteText.GetStandardColor())
  975. crHiliteText = m_clrValues.crInactiveHiliteText;
  976. }
  978. //--------------------------------------------------------------
  979. XTP_EDIT_TEXTBLOCK arTxtBlk[4];
  980. BOOL bUseBlk[4] = {FALSE, FALSE, FALSE, FALSE};
  982. if (pEditCtrl->m_Selection.IsIntersectSel_str(nTextRow, txtBlk.nPos/* + 1*/, txtBlk.nNextBlockPos) &&
  983. !pDC->IsPrinting() && nTextLenC && nSelStart < nSelEnd)
  984. {
  985. DrawLineCalcSel(txtBlk, nSelStart, nSelEnd, arTxtBlk, bUseBlk);
  986. }
  987. else if (nTextLenC)
  988. {
  989. arTxtBlk[1] = txtBlk;
  990. bUseBlk[1] = TRUE;
  991. }
  993. //**************************************************
  994. for (int i = 1; i <= 3; i++)
  995. {
  996. if (!bUseBlk[i])
  997. continue;
  999. pDC->SetTextColor((i%2) ? crText : crHiliteText);
  1000. pDC->SetBkColor((i%2) ? crBack : crHiliteBack);
  1002. int nOutStrPos = drawTxtProc.StrPosToDispPos(nLine, arTxtBlk[i].nPos);
  1003. int nNextOutStrPos = drawTxtProc.StrPosToDispPos(nLine, arTxtBlk[i].nNextBlockPos);
  1004. int nOutStrLen = nNextOutStrPos - nOutStrPos;
  1005. //LPCTSTR pText = (LPCTSTR)strDispText + nOutStrPos;
  1006. LPCTSTR pText = _tcsninc((LPCTSTR)strDispText, nOutStrPos);
  1008. UpdateTextFont(pEditCtrl, arTxtBlk[i].lf);
  1009. CXTPFontDC fontDC(pDC, GetFontText());
  1011. if (!pDC->IsPrinting())
  1012. {
  1013. drawTxtProc.DrawRowPart(pDC, nLine, pText, nOutStrLen);
  1014. }
  1015. else
  1016. {
  1017. int nOffsetY = rcTextLine.top - drawTxtProc.GetTextRect().top;
  1018. nRowHeight = drawTxtProc.PrintRowPart(pDC, nTextRow, nOffsetY, 0,
  1019.   pText, nOutStrLen, 0);//int *pnPrintedTextLen)
  1020. }
  1021. }
  1023. if (!pDC->IsPrinting())
  1024. {
  1025. // draw selection for virtual space, after line text end)
  1026. if (!pos && ((nSelStart < nSelEnd && nSelEnd > nTextLenC) || bInfinitSelEnd))
  1027. {
  1028. CRect rcSel = rcTextLine;
  1029. rcSel.left += drawTxtProc.GetRowWidth(nLine) - drawTxtProc.GetScrollXOffset();
  1031. if (!bInfinitSelEnd || nSelStart > nTextLenC)
  1032. {
  1033. if (nSelStart > nTextLenC)
  1034. rcSel.left += drawTxtProc.GetSpaceWidth() * (nSelStart - nTextLenC);
  1036. if (!bInfinitSelEnd)
  1037. rcSel.right = rcSel.left + drawTxtProc.GetSpaceWidth() * abs(nSelEnd - max(nTextLenC, nSelStart));
  1038. }
  1040. rcSel.left = max(min(rcSel.left, rcTextLine.right), rcTextLine.left);
  1041. rcSel.right = max(min(rcSel.right, rcTextLine.right), rcTextLine.left);
  1043. pDC->FillSolidRect(rcSel, crHiliteBack);
  1044. }
  1045. }
  1046. }
  1048. //===========================================================================
  1049. // draw [...] if needed and not yet
  1050. if (pCoDrawBlk && !bCoBlkDrawn)
  1051. {
  1052. CRect rcCoBlk = rcTextLine;
  1053. rcCoBlk.left += drawTxtProc.GetRowWidth(nLine) - drawTxtProc.GetScrollXOffset();
  1054. rcCoBlk.left = max(rcCoBlk.left, rcTextLine.left);
  1055. rcCoBlk.left = min(rcCoBlk.left, rcTextLine.right);
  1057. pEditCtrl->ProcessCollapsedText(pDC, pCoDrawBlk, rcCoBlk);
  1058. }
  1060. pDC->SetTextColor(m_clrValues.crText);
  1062. return nRowHeight;
  1063. }
  1066. int CXTPSyntaxEditPaintManager::PrintLineTextEx(CDC *pDC, const CRect& rcTextLine, int nTextRow,
  1067. int nLine, CXTPSyntaxEditCtrl* pEditCtrl, int nFlags)
  1068. {
  1069. ASSERT(pDC && pEditCtrl);
  1070. if (!pDC || !pEditCtrl)
  1071. return 0;
  1073. CXTPSyntaxEditDrawTextProcessor& drawTxtProc = pEditCtrl->GetDrawTextProcessor();
  1075. int nRowHeight = drawTxtProc.GetRowHeight();
  1077. const CString& strText = pEditCtrl->GetLineText(nTextRow);
  1078. int nTextLenC = (int)_tcsclen(strText);
  1079. CString strDispText;
  1080. drawTxtProc.ExpandChars(strText, strDispText, 0, pEditCtrl->IsEnabledWhiteSpace());
  1082. drawTxtProc.ResetRowInfo(nLine);
  1083. drawTxtProc.SetRowTabPositions(nLine, strText);
  1085. COLORREF crBreakText;
  1086. BOOL bBreakText = pEditCtrl->m_mapRowColor.Lookup(nTextRow, crBreakText);
  1088. COLORREF crBreakBack;
  1089. BOOL bBreakBack  = pEditCtrl->m_mapRowBkColor.Lookup(nTextRow, crBreakBack);
  1091. CXTPSyntaxEditLexTextSchema* ptrTxtSch = pEditCtrl->m_pBuffer->GetLexParser()->GetTextSchema();
  1093. if (!bBreakBack)
  1094. crBreakBack = m_clrValues.crBack;
  1096. if (nTextRow > pEditCtrl->GetRowCount())
  1097. return 0;
  1099. pDC->SetBkMode(OPAQUE);
  1100. pDC->SetTextColor(m_clrValues.crText);
  1102. CXTPSyntaxEditTextBlockList blocks;
  1104. if (ptrTxtSch)
  1105. {
  1106. CXTPSyntaxEditLexTextBlock* pScreenSchFirstTB = pEditCtrl->GetOnScreenSch(nTextRow);
  1107. if (pScreenSchFirstTB)
  1108. {
  1109. CXTPSyntaxEditTextIterator txtIter(pEditCtrl->GetEditBuffer());
  1110. ptrTxtSch->GetRowColors(&txtIter, nTextRow, 0, -1,
  1111. m_clrValues, &blocks,
  1112. NULL, pScreenSchFirstTB);
  1113. }
  1114. }
  1116. if (blocks.GetCount() == 0)
  1117. {
  1118. XTP_EDIT_TEXTBLOCK defBlk;
  1119. defBlk.nPos = 0;
  1120. defBlk.nNextBlockPos = nTextLenC;
  1121. defBlk.clrBlock = m_clrValues;
  1122. blocks.AddTail(defBlk);
  1123. }
  1125. // draw text
  1127. //=======================================================================
  1128. BOOL bCoBlkDrawn = FALSE;
  1129. XTP_EDIT_COLLAPSEDBLOCK* pCoDrawBlk = NULL;
  1130. XTP_EDIT_LMPARAM LMCoParam;
  1131. if (pEditCtrl->HasRowMark(nTextRow, xtpEditLMT_Collapsed, &LMCoParam))
  1132. {
  1133. pCoDrawBlk = (XTP_EDIT_COLLAPSEDBLOCK*)LMCoParam.GetPtr();
  1134. ASSERT(pCoDrawBlk);
  1135. }
  1137. //---------------------------------------------------------------
  1138. POSITION pos = blocks.GetHeadPosition();
  1139. while (pos)
  1140. {
  1141. const XTP_EDIT_TEXTBLOCK& txtBlk = blocks.GetNext(pos);
  1143. // draw [...] if needed
  1144. if (pCoDrawBlk)
  1145. {
  1146. CRect rcCoBlk = rcTextLine;
  1147. rcCoBlk.left += drawTxtProc.GetRowWidth(nLine) - drawTxtProc.GetScrollXOffset();
  1148. rcCoBlk.left = max(rcCoBlk.left, rcTextLine.left);
  1149. rcCoBlk.left = min(rcCoBlk.left, rcTextLine.right);
  1151. bCoBlkDrawn = pEditCtrl->ProcessCollapsedTextEx(pDC, pCoDrawBlk, txtBlk, rcCoBlk);
  1152. if (bCoBlkDrawn)
  1153. {
  1154. break;
  1155. }
  1156. }
  1158. // define default colors.
  1159. COLORREF crBack    = m_clrValues.crBack.GetStandardColor();
  1160. COLORREF crText    = m_clrValues.crText.GetStandardColor();
  1162. // if syntax coloring is enabled use defined colors.
  1163. if (pEditCtrl->GetSyntaxColor())
  1164. {
  1165. crBack = txtBlk.clrBlock.crBack;
  1166. crText = txtBlk.clrBlock.crText;
  1167. }
  1169. if (bBreakBack)
  1170. crBack = crBreakBack;
  1172. if (bBreakText)
  1173. crText = crBreakText;
  1175. //--------------------------------------------------------------
  1176. if (crBack == m_clrValues.crBack.GetStandardColor())
  1177. crBack = m_clrValues.crBack;
  1179. if (crText == m_clrValues.crText.GetStandardColor())
  1180. crText = m_clrValues.crText;
  1182. //**************************************************
  1183. pDC->SetTextColor(crText);
  1184. pDC->SetBkColor(crBack);
  1186. int nOutStrPos = drawTxtProc.StrPosToDispPos(nLine, txtBlk.nPos);
  1187. int nNextOutStrPos = drawTxtProc.StrPosToDispPos(nLine, txtBlk.nNextBlockPos);
  1188. int nOutStrLen = nNextOutStrPos - nOutStrPos;
  1189. //LPCTSTR pText = (LPCTSTR)strDispText + nOutStrPos;
  1190. LPCTSTR pText = _tcsninc((LPCTSTR)strDispText, nOutStrPos);
  1192. UpdateTextFont(pEditCtrl, txtBlk.lf);
  1193. CXTPFontDC fontDC(pDC, GetFontText());
  1195. int nPrintedTextLen = 0;
  1196. int nOffsetY = rcTextLine.top - drawTxtProc.GetTextRect().top;
  1197. nRowHeight = drawTxtProc.PrintRowPart(pDC, nTextRow, nOffsetY, nFlags,
  1198.   pText, nOutStrLen, &nPrintedTextLen);
  1200. if (nPrintedTextLen < nOutStrLen)
  1201. {
  1202. if ((nFlags & DT_SINGLELINE) == 0)
  1203. {
  1204. nRowHeight = -1;
  1205. pDC->FillSolidRect(&rcTextLine, pDC->GetBkColor());
  1206. }
  1208. break;
  1209. }
  1210. }
  1212. //===========================================================================
  1213. // draw [...] if needed and not yet
  1214. if (pCoDrawBlk && !bCoBlkDrawn)
  1215. {
  1216. CRect rcCoBlk = rcTextLine;
  1217. rcCoBlk.left += drawTxtProc.GetRowWidth(nLine) - drawTxtProc.GetScrollXOffset();
  1218. rcCoBlk.left = max(rcCoBlk.left, rcTextLine.left);
  1219. rcCoBlk.left = min(rcCoBlk.left, rcTextLine.right);
  1221. pEditCtrl->ProcessCollapsedText(pDC, pCoDrawBlk, rcCoBlk);
  1222. }
  1224. pDC->SetTextColor(m_clrValues.crText);
  1226. return nRowHeight;
  1227. }