XTPSyntaxEditLexParser.h
上传用户:szled88
上传日期:2015-04-09
资源大小:43957k
文件大小:48k
源码类别:

对话框与窗口

开发平台:

Visual C++

  1. // XTPSyntaxEditLexParser.h
  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. //////////////////////////////////////////////////////////////////////
  20. //{{AFX_CODEJOCK_PRIVATE
  21. #if !defined(__XTPSYNTAXEDITLEXPARSER_H__)
  22. #define __XTPSYNTAXEDITLEXPARSER_H__
  23. //}}AFX_CODEJOCK_PRIVATE
  24. #if _MSC_VER > 1000
  25. #pragma once
  26. #endif // _MSC_VER > 1000
  27. class CXTPSyntaxEditColorTheme;
  28. ////////////////////////////////////////////////////////////////////////////
  29. //{{AFX_CODEJOCK_PRIVATE
  30. typedef CList<XTP_EDIT_TEXTBLOCK, XTP_EDIT_TEXTBLOCK> CXTPSyntaxEditTextBlockList;
  31. typedef CArray<XTP_EDIT_TEXTBLOCK, XTP_EDIT_TEXTBLOCK&> CXTPSyntaxEditTextBlockArray;
  32. //}}AFX_CODEJOCK_PRIVATE
  33. namespace XTPSyntaxEditLexAnalyser
  34. {
  35. class CXTPSyntaxEditLexObj_ActiveTags;
  36. class CXTPSyntaxEditLexClass;
  37. class CXTPSyntaxEditLexClassInfoArray;
  38. class CXTPSyntaxEditLexOnScreenParseCnt;
  39. //========================================================================
  40. // Summary:
  41. //      This enum describes set of edit actions.
  42. //========================================================================
  43. enum XTPSyntaxEditEditAction
  44. {
  45. xtpEditActInsert    = 1,    // Edit action insert text.
  46. xtpEditActDelete    = 2,    // Edit action delete text.
  47. };
  48. //========================================================================
  49. // Summary:
  50. //      Enumerates flags which indicate results of parse functions calls.
  51. // See also:
  52. //      CXTPSyntaxEditLexClass, CXTPSyntaxEditLexTextSchema
  53. //========================================================================
  54. enum XTPSyntaxEditLexParseResult
  55. {
  56. xtpEditLPR_Unknown      = 0,     // Undefined value.
  57. xtpEditLPR_StartFound   = 0x001, // Start text block was found
  58. xtpEditLPR_EndFound     = 0x002, // End text block was found
  59. xtpEditLPR_Iterated     = 0x010, // Indicate that current text position has already moved to the next char inside a function call.
  60. xtpEditLPR_TBpop1       = 0x020, // Indicate that new found text block should be inserted before previous one and as a parent of it.
  61. xtpEditLPR_Error        = 0x100, // Iterated parse process breaked due to some error. See trace for details.
  62. xtpEditLPR_RunFinished  = 0x200, // Run iterated parse process (or some big part of it) is finished.
  63. xtpEditLPR_RunBreaked   = 0x400, // Run iterated parse process (or some big part of it) is breaked.
  64. xtpEditLPR_RunRestart   = 0x800, // Restart run children from the beginning.
  65. //xtpEditLPR_NeedFullReparse = 0x1000, // Cannot reparse only specified piece of text. Full reparse is necessary.
  66. };
  67. //========================================================================
  68. // Summary:
  69. //      This class is designed to store coordinates of text region.
  70. // See also:
  71. //      XTP_EDIT_LINECOL
  72. //========================================================================
  73. class _XTP_EXT_CLASS CXTPSyntaxEditTextRegion
  74. {
  75. public:
  76. XTP_EDIT_LINECOL m_posStart; // start position in document coordinates.
  77. XTP_EDIT_LINECOL m_posEnd; // end position in document coordinates.
  78. //--------------------------------------------------------------------
  79. // Summary:
  80. //      Clears coordinates.
  81. //--------------------------------------------------------------------
  82. void Clear();
  83. //--------------------------------------------------------------------
  84. // Summary:
  85. //      Sets coordinates.
  86. // Parameters:
  87. //      pLCStart    : [in] start position in document coordinates.
  88. //      pLCEnd      : [in] end position in document coordinates.
  89. //--------------------------------------------------------------------
  90. void Set(const XTP_EDIT_LINECOL* pLCStart, const XTP_EDIT_LINECOL* pLCEnd);
  91. };
  92. //{{AFX_CODEJOCK_PRIVATE
  93. typedef CArray<CXTPSyntaxEditTextRegion, const CXTPSyntaxEditTextRegion&> CXTPSyntaxEditInvalidZoneArray;
  94. //}}AFX_CODEJOCK_PRIVATE
  95. //===========================================================================
  96. // Summary:
  97. //      This class stores tokens definition: a list of tokens and corresponding
  98. //      lists of start and end tokens separators.
  99. //===========================================================================
  100. class _XTP_EXT_CLASS CXTPSyntaxEditLexTokensDef
  101. {
  102. public:
  103. //-----------------------------------------------------------------------
  104. // Summary:
  105. //      Default object constructor.
  106. //-----------------------------------------------------------------------
  107. CXTPSyntaxEditLexTokensDef(){};
  108. //-----------------------------------------------------------------------
  109. // Summary:
  110. //      Copy object constructor.
  111. // Parameters:
  112. //      rSrc : [in] Reference to source CXTPSyntaxEditLexTokensDef object.
  113. //-----------------------------------------------------------------------
  114. CXTPSyntaxEditLexTokensDef(const CXTPSyntaxEditLexTokensDef& rSrc);
  115. //-----------------------------------------------------------------------
  116. // Summary:
  117. //      Object destructor. Handles clean up and deallocations.
  118. //-----------------------------------------------------------------------
  119. virtual ~CXTPSyntaxEditLexTokensDef();
  120. //-----------------------------------------------------------------------
  121. // Summary:
  122. //      Assignment operator for class.
  123. // Parameters:
  124. //      rSrc : [in] Reference to source CXTPSyntaxEditLexTokensDef object.
  125. // Returns:
  126. //      Reference to CXTPSyntaxEditLexTokensDef object.
  127. //-----------------------------------------------------------------------
  128. const CXTPSyntaxEditLexTokensDef& operator=(const CXTPSyntaxEditLexTokensDef& rSrc);
  129. CStringArray m_arTokens;        // Stores list of tokens.
  130. CStringArray m_arStartSeps;     // Stores list of start separators.
  131. CStringArray m_arEndSeps;       // Stores list of end separators.
  132. };
  133. //{{AFX_CODEJOCK_PRIVATE
  134. typedef CArray<CXTPSyntaxEditLexTokensDef, const CXTPSyntaxEditLexTokensDef&> CXTPSyntaxEditLexTokensDefArray;
  135. //}}AFX_CODEJOCK_PRIVATE
  136. //========================================================================
  137. // Summary:
  138. //      This class is designed to easily manipulate parser options.
  139. //========================================================================
  140. class _XTP_EXT_CLASS CXTPSyntaxEditLexParserSchemaOptions : public CXTPCmdTarget
  141. {
  142. public:
  143. //-----------------------------------------------------------------------
  144. // Summary:
  145. //      Default object constructor.
  146. //-----------------------------------------------------------------------
  147. CXTPSyntaxEditLexParserSchemaOptions();
  148. //-----------------------------------------------------------------------
  149. // Summary:
  150. //      Object constructor.
  151. // Parameters:
  152. //      rSrc : [in] Reference to source CXTPSyntaxEditLexParserSchemaOptions.
  153. //-----------------------------------------------------------------------
  154. CXTPSyntaxEditLexParserSchemaOptions(const CXTPSyntaxEditLexParserSchemaOptions& rSrc);
  155. //-----------------------------------------------------------------------
  156. // Summary:
  157. //      Overloaded equals operator.
  158. // Parameters:
  159. //      rSrc : [in] Reference to source CXTPSyntaxEditLexParserSchemaOptions.
  160. //-----------------------------------------------------------------------
  161. const CXTPSyntaxEditLexParserSchemaOptions& operator=(const CXTPSyntaxEditLexParserSchemaOptions& rSrc);
  162. //global:
  163. BOOL    m_bFirstParseInSeparateThread;              // {0,1} default=1
  164. BOOL    m_bEditReparceInSeparateThread;             // {0,1} default=1
  165. BOOL    m_bConfigChangedReparceInSeparateThread;    // {0,1} default=1
  166. DWORD   m_dwMaxBackParseOffset;                     // default=100; maximum back buffer size. Some times parser look back for the text from current position.
  167. DWORD   m_dwEditReparceTimeout_ms;                  // default=500 ms; time out for start reparse after last key was pressed.
  168. DWORD   m_dwOnScreenSchCacheLifeTime_sec;           // default=180 sec; time out for on screen parsed pices of text. for memory using optimization.
  169. DWORD   m_dwParserThreadIdleLifeTime_ms;            // default=60 sec; time out for existing of parser thread when parser idle (no parse requests).
  170. };
  171. //{{AFX_CODEJOCK_PRIVATE
  172. //=======================================================================
  173. // Summary:
  174. //
  175. //=======================================================================
  176. class _XTP_EXT_CLASS CXTPSyntaxEditLexClassSchema : public CXTPCmdTarget
  177. {
  178. friend class CXTPSyntaxEditLexTextSchema;
  179. public:
  180. //-----------------------------------------------------------------------
  181. // Summary:
  182. //      Default object constructor.
  183. //-----------------------------------------------------------------------
  184. CXTPSyntaxEditLexClassSchema();
  185. //-----------------------------------------------------------------------
  186. // Summary:
  187. //      Object destructor. Handles clean up and deallocations.
  188. //-----------------------------------------------------------------------
  189. virtual ~CXTPSyntaxEditLexClassSchema();
  190. virtual void AddPreBuildClass(CXTPSyntaxEditLexClass* pClass);
  191. virtual BOOL Build();
  192. virtual BOOL Copy(CXTPSyntaxEditLexClassSchema* pDest);
  193. virtual void Close();
  194. virtual void RemoveAll();
  195. virtual CXTPSyntaxEditLexClassPtrArray* GetClasses(BOOL bShortSch);
  196. virtual CXTPSyntaxEditLexClassPtrArray* GetPreBuildClasses();
  197. virtual CXTPSyntaxEditLexClass* GetPreBuildClass(const CString& strName);
  198. virtual CXTPSyntaxEditLexClass* GetNewClass(BOOL bForFile);
  199. virtual CXTPSyntaxEditLexObj_ActiveTags* GetActiveTagsFor(CXTPSyntaxEditLexClass* pTopClass);
  200. //virtual CXTPSyntaxEditLexObj_ActiveTags* GetActiveTags(BOOL bShortSch);
  201. protected:
  202. virtual BOOL Build_ChildrenFor(BOOL bDynamic, CXTPSyntaxEditLexClass* pCBase,
  203. CStringArray& rarAdded, int& rnNextClassID,
  204. int nLevel = 0);
  205. virtual CXTPSyntaxEditLexClassPtrArray* GetChildrenFor(CXTPSyntaxEditLexClass* pClass, BOOL& rbSelfChild);
  206. virtual CXTPSyntaxEditLexClassPtrArray* GetDynChildrenFor(CXTPSyntaxEditLexClass* pClass, BOOL& rbSelfChild);
  207. virtual void GetDynParentsList(CXTPSyntaxEditLexClass* pClass, CStringArray& rarDynParents,
  208. CStringArray& rarProcessedClasses);
  209. virtual int CanBeParentDynForChild(CString strParentName, CXTPSyntaxEditLexClass* pCChild);
  210. virtual BOOL Build_ShortTree();
  211. virtual BOOL PostBuild_Step(CXTPSyntaxEditLexClassPtrArray* pArClasses);
  212. virtual BOOL CopyChildrenFor(BOOL bShort, CXTPSyntaxEditLexClass* pCDest,
  213. CXTPSyntaxEditLexClass* pCSrc, int nLevel);
  214. CXTPSyntaxEditLexClassPtrArray  m_arPreBuildClassesList;
  215. CXTPSyntaxEditLexClassPtrArray  m_arClassesTreeShort;
  216. CXTPSyntaxEditLexClassPtrArray  m_arClassesTreeFull;
  217. //CXTPSyntaxEditLexObj_ActiveTags   m_arAllActiveTagsShort;
  218. //CXTPSyntaxEditLexObj_ActiveTags   m_arAllActiveTagsFull;
  219. };
  220. //}}AFX_CODEJOCK_PRIVATE
  221. //===========================================================================
  222. // Summary:
  223. //      CXTPSyntaxEditLexTextBlock class represents a pice (block) of text which
  224. //      corresponds some lex class in a text schema.
  225. //      It stores start position, end position, pointer to the lex class
  226. //      object in a class schema and some other information.
  227. //      Text blocks organized as a bidirectional list and as tree structure.
  228. //===========================================================================
  229. class _XTP_EXT_CLASS CXTPSyntaxEditLexTextBlock : public CXTPCmdTarget
  230. {
  231. //{{AFX_CODEJOCK_PRIVATE
  232. friend class CXTPSyntaxEditLexTextSchema;
  233. friend class CXTPSyntaxEditLexClass;
  234. friend class CXTPSyntaxEditLexClass_file;
  235. //}}AFX_CODEJOCK_PRIVATE
  236. public:
  237. //-----------------------------------------------------------------------
  238. // Summary:
  239. //      Default object constructor.
  240. //-----------------------------------------------------------------------
  241. CXTPSyntaxEditLexTextBlock();
  242. //-----------------------------------------------------------------------
  243. // Summary:
  244. //      Object destructor. Handles clean up and deallocations.
  245. //-----------------------------------------------------------------------
  246. virtual ~CXTPSyntaxEditLexTextBlock();
  247. CXTPSyntaxEditLexClassPtr       m_ptrLexClass;  // Pointer to the LexClass object.
  248. CXTPSyntaxEditLexTextBlockPtr   m_ptrParent;    // Pointer to the parent block object.
  249. CXTPSyntaxEditLexTextBlockPtr   m_ptrPrev;      // Pointer to the previous block.
  250. CXTPSyntaxEditLexTextBlockPtr   m_ptrNext;      // Pointer to the next block.
  251. XTP_EDIT_LINECOL    m_PosStartLC;   // Text block start position.
  252. XTP_EDIT_LINECOL    m_PosEndLC;     // Text block start position.
  253. BOOL                m_bEndByParent; // Text block ended when the parent block ended.
  254. //--------------------------------------------------------------------
  255. // Summary:
  256. //      Get Text block end position.
  257. // Parameters:
  258. //      bMaxIfInvalid - [in] If TRUE returns XTP_EDIT_LINECOL::MAXPOS for
  259. //                      invalid position. If FALSE returns
  260. //                      XTP_EDIT_LINECOL::MINPOS for invalid position.
  261. // Returns:
  262. //      Value of m_PosEndLC if it is valid, otherwise maximum or minimum
  263. //      value depends on parameter bMaxIfInvalid.
  264. // See Also:
  265. //      XTP_EDIT_LINECOL, m_PosEndLC, m_PosStartLC.
  266. //--------------------------------------------------------------------
  267. XTP_EDIT_LINECOL    GetPosEndLC(BOOL bMaxIfInvalid = TRUE);
  268. //--------------------------------------------------------------------
  269. // Summary:
  270. //      Get text block start tag end position in the text.
  271. // Returns:
  272. //      Text block start tag end position in XLC form.
  273. // See Also:
  274. //      XTP_EDIT_LINECOL::GetXLC(), XTP_EDIT_XLC() macros.
  275. //--------------------------------------------------------------------
  276. DWORD GetStartTagEndXLC();
  277. //--------------------------------------------------------------------
  278. // Summary:
  279. //      Get text block end tag begin position in the text.
  280. // Returns:
  281. //      Text block end tag begin position in XLC form.
  282. // See Also:
  283. //      XTP_EDIT_LINECOL::GetXLC(), XTP_EDIT_XLC() macros.
  284. //--------------------------------------------------------------------
  285. DWORD GetEndTagBeginXLC();
  286. //--------------------------------------------------------------------
  287. // Summary:
  288. //      Get text block end tag end position in the text.
  289. // Returns:
  290. //      Text block end tag end position in XLC form.
  291. // See Also:
  292. //      XTP_EDIT_LINECOL::GetXLC(), XTP_EDIT_XLC() macros.
  293. //--------------------------------------------------------------------
  294. DWORD GetEndTagEndXLC();
  295. //--------------------------------------------------------------------
  296. // Summary:
  297. //      Release references to other objects.
  298. // Remarks:
  299. //      This method is used in text schema destruction process.
  300. // See Also:
  301. //      CXTPSyntaxEditLexTextSchema::Close().
  302. //--------------------------------------------------------------------
  303. virtual void Close();
  304. //virtual void Close(BOOL bWithPrev = FALSE, BOOL bWithNext = FALSE);
  305. //--------------------------------------------------------------------
  306. // Summary:
  307. //      This methods compare lex classes names for 2 text blocks.
  308. // Parameters:
  309. //      pTB2 - [in] Second text block to compare.
  310. // Returns:
  311. //      TRUE if lex classes names for 2 text blocks are equal,
  312. //      FALSE otherwise.
  313. //--------------------------------------------------------------------
  314. virtual BOOL IsEqualLexClasses(CXTPSyntaxEditLexTextBlock* pTB2) const;
  315. //--------------------------------------------------------------------
  316. // Summary:
  317. //      This method determine is the specified text block included
  318. //      in the current text block.
  319. // Parameters:
  320. //      pTB2 - [in] Text block pointer.
  321. // Returns:
  322. //      TRUE if the specified text block included in the current text
  323. //      block, FALSE otherwise.
  324. //--------------------------------------------------------------------
  325. virtual BOOL IsInclude(CXTPSyntaxEditLexTextBlock* pTB2) const;
  326. //--------------------------------------------------------------------
  327. // Summary:
  328. //      This method determine is text block look like closed or
  329. //      partly closed.
  330. // Returns:
  331. //      TRUE if some or all references to other objects are NULL,
  332. //      FALSE otherwise.
  333. //----------------------------------------------------------------
  334. virtual BOOL IsLookLikeClosed() const;
  335. //--------------------------------------------------------------------
  336. // Summary:
  337. //      This method set end position to not ended children blocks.
  338. // Parameters:
  339. //      pTxtSch - [in] Text schema pointer to send notifications.
  340. // Returns:
  341. //      Ended children blocks count.
  342. //----------------------------------------------------------------
  343. virtual int EndChildren(CXTPSyntaxEditLexTextSchema* pTxtSch = NULL, BOOL bEndByParent = TRUE);
  344. //--------------------------------------------------------------------
  345. // Summary:
  346. //      This method searches previous child block for the specified
  347. //      child. This block is parent.
  348. // Parameters:
  349. //      pChild      - [in] Child block pointer.
  350. //      bWithAddRef : [in]  If TRUE - InternalAddRef() is called before
  351. // Returns:
  352. //      Previous child block pointer or NULL.
  353. //----------------------------------------------------------------
  354. virtual CXTPSyntaxEditLexTextBlock* GetPrevChild(CXTPSyntaxEditLexTextBlock* pChild, BOOL bWithAddRef);
  355. #ifdef _DEBUG
  356. virtual void Dump(CDumpContext& dc) const;
  357. #endif
  358. protected:
  359. int m_nStartTagLen;     // Start tag length.
  360. int m_nEndTagXLCLen;    // End tag length in XLC form.
  361. CXTPSyntaxEditLexTextBlockPtr   m_ptrLastChild; // for internal use only. not always contains correct value
  362. };
  363. //===========================================================================
  364. // Summary:
  365. //      CXTPSyntaxEditLexTextSchema class is used to store data which necessary to
  366. //      parse a text and parsing results. It also contains methods to run
  367. //      lex classes from a class schema, methods to update text schema
  368. //      when text is edited, methods to reparse text, to get information
  369. //      which is necessary to draw colorized text and other helper methods.
  370. //===========================================================================
  371. class _XTP_EXT_CLASS CXTPSyntaxEditLexTextSchema : public CXTPCmdTarget
  372. {
  373. //{{AFX_CODEJOCK_PRIVATE
  374. friend class CXTPSyntaxEditLexClass;
  375. friend class CXTPSyntaxEditLexClass_file;
  376. friend class CXTPSyntaxEditLexTextBlock;
  377. friend class CXTPSyntaxEditLexParser;
  378. //}}AFX_CODEJOCK_PRIVATE
  379. public:
  380. //-----------------------------------------------------------------------
  381. // Summary:
  382. //      Default object constructor.
  383. // Parameters:
  384. //      pcszSchName - [in] Schema name.
  385. //-----------------------------------------------------------------------
  386. CXTPSyntaxEditLexTextSchema(LPCTSTR pcszSchName);
  387. //-----------------------------------------------------------------------
  388. // Summary:
  389. //      Object destructor. Handles clean up and deallocations.
  390. //-----------------------------------------------------------------------
  391. virtual ~CXTPSyntaxEditLexTextSchema();
  392. //-----------------------------------------------------------------------
  393. // Summary:
  394. //      Get text schema name.
  395. // Returns:
  396. //      Text schema name string.
  397. //-----------------------------------------------------------------------
  398. virtual CString GetSchName() const;
  399. //-----------------------------------------------------------------------
  400. // Summary:
  401. //      Destroy all interlocked objects references and free all
  402. //      stored objects.
  403. // Remarks:
  404. //      Call this method to delete schema.
  405. // See Also:
  406. //      RemoveAll(), CXTPSyntaxEditLexClassSchema::Close().
  407. //-----------------------------------------------------------------------
  408. virtual void Close();
  409. //-----------------------------------------------------------------------
  410. // Summary:
  411. //      Destroy text blocks list.
  412. // Parameters:
  413. //      pFirst - A pointer to the first element in the list to destroy.
  414. // Remarks:
  415. //      This helper method is called to destroy separately stored text
  416. //      blocks list (text schema).
  417. // See Also:
  418. //      CXTPSyntaxEditLexTextBlock::Close().
  419. //-----------------------------------------------------------------------
  420. static void AFX_CDECL Close(CXTPSyntaxEditLexTextBlock* pFirst);
  421. //-----------------------------------------------------------------------
  422. // Summary:
  423. //      Remove all text block from the schema.
  424. // Remarks:
  425. //      Schema object is not destroyed, just only blocks are removed.
  426. // See Also:
  427. //      RemoveAll(), CXTPSyntaxEditLexClassSchema::Close().
  428. //-----------------------------------------------------------------------
  429. virtual void RemoveAll();
  430. //-----------------------------------------------------------------------
  431. // Summary:
  432. //      Create a new text schema object and init its internal
  433. //      infrastructure (like class schema) from the current schema.
  434. // Remarks:
  435. //      Text blocks are not copied. The class schema is copied.
  436. // Returns:
  437. //      A new text schema object.
  438. //-----------------------------------------------------------------------
  439. virtual CXTPSyntaxEditLexTextSchema* Clone();
  440. //-----------------------------------------------------------------------
  441. // Summary:
  442. //      Returns notification connection.
  443. // Returns:
  444. //      CXTPNotifyConnectionPtr pointer.
  445. //-----------------------------------------------------------------------
  446. virtual CXTPNotifyConnection* GetConnection();
  447. //-----------------------------------------------------------------------
  448. // Summary:
  449. //      This method run parse for the text.
  450. // Parameters:
  451. //      bShort              - [in] If TRUE the short (global blocks only)
  452. //                            class schema is used, otherwise full
  453. //                            (global and onscreen blocks) class schema
  454. //                            is used.
  455. //      pTxtIter            - [in] Text iterator object.
  456. //      pLCStart            - [in] Start text position for parse/reparse.
  457. //      pLCEnd              - [in] End text position for parse/reparse.
  458. //      bSendProgressEvents - [in] If TRUE the progress parsing events
  459. //                            will be sent using connection object.
  460. // Remarks:
  461. //  Special parameters values:
  462. //      pLCStart = NULL, pLCEnd = NULL
  463. //          - parse from the last parsed block to the end of the text
  464. //
  465. //      pLCStart = XTP_EDIT_LINECOL::Pos1, pLCEnd = NULL
  466. //          - parse (reparse) all text from the begin
  467. // Returns:
  468. //      Parse result as flag from enum XTPSyntaxEditLexParseResult.
  469. //-----------------------------------------------------------------------
  470. virtual int RunParseUpdate(BOOL bShort, CTextIter* pTxtIter,
  471. const XTP_EDIT_LINECOL* pLCStart = NULL,
  472. const XTP_EDIT_LINECOL* pLCEnd = NULL,
  473. BOOL bSendProgressEvents = FALSE);
  474. //-----------------------------------------------------------------------
  475. // Summary:
  476. //      Returns text region for which schema was updated during last
  477. //      parse/reparse operation.
  478. // Returns:
  479. //      CXTPSyntaxEditTextRegion object.
  480. //-----------------------------------------------------------------------
  481. virtual const CXTPSyntaxEditTextRegion& GetUpdatedTextRegion() const;
  482. //-----------------------------------------------------------------------
  483. // Summary:
  484. //      This method run parse for the text on screen.
  485. // Parameters:
  486. //      pTxtIter             - [in] Text iterator object.
  487. //      nRowStart            - [in] Start row for parse.
  488. //      nRowEnd              - [in] End row for parse.
  489. //      rPtrScreenSchFirstTB - [out] Reference to store first text
  490. //                             block of text schema which is built.
  491. // Remarks:
  492. //      This method perform full parsing for the specified text region
  493. //      using previously parsed short text schema (or global blocks schema).
  494. // Returns:
  495. //      TRUE if successful, FALSE otherwise
  496. //-----------------------------------------------------------------------
  497. virtual BOOL RunParseOnScreen(CTextIter* pTxtIter,
  498. int nRowStart, int nRowEnd,
  499. CXTPSyntaxEditLexTextBlockPtr& rPtrScreenSchFirstTB );
  500. //-----------------------------------------------------------------------
  501. // Summary:
  502. //      This method get row as list of blocks with different colors
  503. //      to draw.
  504. // Parameters:
  505. //      pTxtIter            - [in] Text iterator object.
  506. //      nRow                - [in] Row number.
  507. //      nColFrom            - [in] Row col to get colors from.
  508. //      nColTo              - [in] Row col to get colors to.
  509. //      clrDefault          - [in] Default colors.
  510. //      rBlocks             - [out] List of color blocks.
  511. //      pptrTBStartCache    - [in out] Cached text block to start search.
  512. //                            May be NULL.
  513. //      pFirstSchTB         - [in] External text schema first block or NULL.
  514. //                            Used for OnScreen schemas.
  515. // Remarks:
  516. //      This method build list of color blocks for the specified row
  517. //      using external or internal text schema.
  518. //-----------------------------------------------------------------------
  519. virtual void GetRowColors(CTextIter* pTxtIter, int nRow,
  520. int nColFrom, int nColTo,
  521. const XTP_EDIT_COLORVALUES& clrDefault,
  522. CXTPSyntaxEditTextBlockList* rBlocks,
  523. CXTPSyntaxEditLexTextBlockPtr* pptrTBStartCache = NULL,
  524. CXTPSyntaxEditLexTextBlock* pFirstSchTB = NULL);
  525. //-----------------------------------------------------------------------
  526. // Summary:
  527. //      This method get row as list of collapsible blocks which
  528. //      include this row.
  529. // Parameters:
  530. //      nRow                - [in] Row number. By Leva: passing nRow < 0 will cause
  531. //                            to return block for all rows
  532. //      rArBlocks           - [out] List of collapsible blocks which
  533. //                            include this row.
  534. //      pptrTBStartCache    - [in out] Cached text block to start search.
  535. //                            May be NULL.
  536. // Remarks:
  537. //      This method build list of collapsible blocks which include
  538. //      the specified row using external or internal text schema.
  539. //-----------------------------------------------------------------------
  540. virtual void GetCollapsableBlocksInfo(int nRow, CXTPSyntaxEditRowsBlockArray& rArBlocks,
  541. CXTPSyntaxEditLexTextBlockPtr* pptrTBStartCache = NULL);
  542. //-----------------------------------------------------------------------
  543. // Summary:
  544. //      This helper method read attributes of the text from lex class
  545. //      of specified text block.
  546. // Parameters:
  547. //      rTB         - [out] Draw text block object to fill text attributes.
  548. //      pTextBlock  - [in] Text block object.
  549. //-----------------------------------------------------------------------
  550. virtual void GetTextAttributes(XTP_EDIT_TEXTBLOCK& rTB, CXTPSyntaxEditLexTextBlock* pTextBlock);
  551. //-----------------------------------------------------------------------
  552. // Summary:
  553. //      Apply color theme to the text schema.
  554. // Parameters:
  555. //      pTheme  - [in] A pointer to Color Theme object.
  556. //-----------------------------------------------------------------------
  557. virtual void ApplyTheme(CXTPSyntaxEditColorTheme* pTheme);
  558. //--------------------------------------------------------------------
  559. // Summary:
  560. //      Load class schema.
  561. // Parameters:
  562. //      arClassInfo  - [in] A reference to CXTPSyntaxEditLexClassInfoArray array.
  563. // Returns:
  564. //      TRUE if successful, FALSE otherwise
  565. //--------------------------------------------------------------------
  566. BOOL LoadClassSchema(CXTPSyntaxEditLexClassInfoArray* arClassInfo);
  567. //--------------------------------------------------------------------
  568. // Summary:
  569. //      Determine is this schema support specified file extension.
  570. // Parameters:
  571. //      strExt  - [in] Extension string.
  572. // Remarks:
  573. //      Extension string format: ".ext"
  574. //      For example: ".cpp"
  575. // Returns:
  576. //      TRUE if specified file extension is supported, FALSE otherwise.
  577. //--------------------------------------------------------------------
  578. BOOL IsFileExtSupported(const CString& strExt);
  579. //--------------------------------------------------------------------
  580. // Summary:
  581. //      Call this member function before using schema object.
  582. // Remarks:
  583. //      To make edit control startup faster - schemas do not built
  584. //      during loading. This member function build the schema if necessary
  585. //      (or do nothing).
  586. //--------------------------------------------------------------------
  587. void BuildIfNeed();
  588. //--------------------------------------------------------------------
  589. // Summary:
  590. //      Get top lex class for specified file extension.
  591. // Parameters:
  592. //      strExt  - [in] Extension string.
  593. // Remarks:
  594. //      Extension string format: ".ext"
  595. //      For example: ".cpp"
  596. //      InternalAddRef() is called for the returned object.
  597. // Returns:
  598. //      Pointer to the lex class or NULL.
  599. //--------------------------------------------------------------------
  600. CXTPSyntaxEditLexClass* GetTopClassForFileExt(const CString& strExt);
  601. //--------------------------------------------------------------------
  602. // Summary:
  603. //      Get text block by ID. Used together with xtpEditOnTextBlockParsed
  604. //      notification.
  605. // Parameters:
  606. //      dwID - [in] ID from xtpEditOnTextBlockParsed notification.
  607. // Remarks:
  608. //      InternalAddRef() is called for the returned object.
  609. // Returns:
  610. //      Pointer to the text block or NULL.
  611. //--------------------------------------------------------------------
  612. virtual CXTPSyntaxEditLexTextBlock* GetLastParsedBlock(WPARAM dwID = 0);
  613. //--------------------------------------------------------------------
  614. // Summary:
  615. //      Get first text schema block..
  616. // Remarks:
  617. //      InternalAddRef() is called for the returned object.
  618. // Returns:
  619. //      Pointer to the text block or NULL.
  620. //--------------------------------------------------------------------
  621. CXTPSyntaxEditLexTextBlock* GetBlocks();
  622. //--------------------------------------------------------------------
  623. // Summary:
  624. //      Get critical section object to lock schema data (text blocks and others).
  625. // Returns:
  626. //      Pointer to the critical section object.
  627. //--------------------------------------------------------------------
  628. CMutex* GetDataLoker();
  629. //--------------------------------------------------------------------
  630. // Summary:
  631. //      Get critical section object to lock class schema.
  632. // Returns:
  633. //      Pointer to the critical section object.
  634. //--------------------------------------------------------------------
  635. CMutex* GetClassSchLoker();
  636. //--------------------------------------------------------------------
  637. // Summary:
  638. //      Get event object to break parsing process.
  639. // Returns:
  640. //      Pointer to the event object.
  641. //--------------------------------------------------------------------
  642. CEvent*             GetBreakParsingEvent();
  643. //{{AFX_CODEJOCK_PRIVATE
  644. static void AFX_CDECL TraceClrBlocks(CXTPSyntaxEditTextBlockArray& arBlocks);
  645. void TraceTxtBlocks(BOOL bFull); // for DEBUG only
  646. //}}AFX_CODEJOCK_PRIVATE
  647. protected:
  648. //========================================================================
  649. // Summary:
  650. //      This enum describes set of UpdateTextBlocks() return results.
  651. //========================================================================
  652. enum XTPSyntaxEditUpdateTBRes
  653. {
  654. xtpEditUTBNothing           = 0,        // void result
  655. xtpEditUTBError             = 0x0001,   // Error result.
  656. xtpEditUTBReparse           = 0x0002,   // one or few global blocks changed and reparse is need.
  657. xtpEditUTBNearestUpdated    = 0x0100,   // This flag returned from UpdateTBNearest() only.
  658. };
  659. //--------------------------------------------------------------------
  660. // Summary:
  661. //      Get Class Schema for this text schema..
  662. // Remarks:
  663. //      InternalAddRef() is called for the returned object.
  664. // Returns:
  665. //      Pointer to the Class Schema object.
  666. //--------------------------------------------------------------------
  667. CXTPSyntaxEditLexClassSchema* GetClassSchema();
  668. //-----------------------------------------------------------------------
  669. // Summary:
  670. //      Apply color theme to specified lex classes.
  671. // Parameters:
  672. //      pTheme      - [in] A pointer to Color Theme object.
  673. //      ptrClasses  - [in] A pointer to lex classes array.
  674. // See Also:
  675. //      ApplyTheme().
  676. //-----------------------------------------------------------------------
  677. virtual void ApplyThemeRecursive(CXTPSyntaxEditColorTheme* pTheme,
  678. CXTPSyntaxEditLexClassPtrArray* ptrClasses);
  679. //-----------------------------------------------------------------------
  680. // Summary:
  681. //      Update text schema positions after editing action.
  682. // Parameters:
  683. //      posFrom     - [in] Start editing position.
  684. //      posTo       - [in] End editing position.
  685. //      eEditAction - [in] Edit action. See XTPSyntaxEditEditAction.
  686. // Returns:
  687. //      Update result - values from enum XTPSyntaxEditUpdateTBRes.
  688. //-----------------------------------------------------------------------
  689. int UpdateTextBlocks(XTP_EDIT_LINECOL posFrom, XTP_EDIT_LINECOL posTo,
  690. int eEditAction);
  691. //{{AFX_CODEJOCK_PRIVATE
  692. virtual int RunChildren(CTextIter* pTxtIter,
  693. CXTPSyntaxEditLexTextBlockPtr ptrTxtBlock,
  694. CXTPSyntaxEditLexClass* pBase,
  695. CXTPSyntaxEditLexOnScreenParseCnt* pOnScreenRunCnt = NULL);
  696. virtual CXTPSyntaxEditLexTextBlock* GetPrevBlock(BOOL bWithAddRef = TRUE);
  697. virtual CXTPSyntaxEditLexTextBlock* GetNewBlock();
  698. //}}AFX_CODEJOCK_PRIVATE
  699. private:
  700. int UpdateTBNearest(CXTPSyntaxEditLexTextBlock* pNarestTB1,
  701. int nLineDiff, int nColDiff,
  702. XTP_EDIT_LINECOL posFrom, XTP_EDIT_LINECOL posTo,
  703. int eEditAction );
  704. //-------------------------------
  705. CXTPSyntaxEditLexTextBlock* FindNearestTextBlock(XTP_EDIT_LINECOL posText);
  706. virtual BOOL InitScreenSch(CTextIter* pTxtIter, int nRowStart, int nRowEnd,
  707. CXTPSyntaxEditLexTextBlockPtr& rPtrScreenSchFirstTB,
  708. CXTPSyntaxEditLexTextBlockPtr& rPtrTBParentToRun);
  709. virtual CXTPSyntaxEditLexTextBlockPtr InitScreenSch_RunTopClass(CTextIter* pTxtIter);
  710. virtual CXTPSyntaxEditLexTextBlock* CopyShortTBtoFull(CXTPSyntaxEditLexTextBlock* pTB);
  711. virtual CXTPSyntaxEditLexClass* FindLexClassByID(CXTPSyntaxEditLexClassPtrArray* pClassesAr,
  712. int nClassID);
  713. virtual int Run_OnScreenTBStack(CTextIter* pTxtIter,
  714. CXTPSyntaxEditLexTextBlock* pTBParentToRun,
  715. CXTPSyntaxEditLexOnScreenParseCnt* pRunCnt);
  716. virtual void UpdateLastSchBlock(CXTPSyntaxEditLexTextBlock* pLastTB, BOOL bPermanently = FALSE);
  717. virtual CXTPSyntaxEditLexTextBlock* GetLastSchBlock(BOOL bWithAddRef = TRUE);
  718. virtual UINT SendEvent_OnTextBlockParsed(CXTPSyntaxEditLexTextBlock* pTB);
  719. virtual int Run_ParseUpdate0(BOOL bShort, CTextIter* pTxtIter,
  720.  const XTP_EDIT_LINECOL* pLCStart,
  721.  const XTP_EDIT_LINECOL* pLCEnd,
  722.  BOOL bSendProgressEvents);
  723. virtual int Run_ClassesUpdate1(CTextIter* pTxtIter,
  724. CXTPSyntaxEditLexTextBlockPtr ptrStartTB,
  725. BOOL bStarted);
  726. virtual int Run_ClassesUpdate2(CTextIter* pTxtIter,
  727. CXTPSyntaxEditLexClassPtrArray* pArClasses,
  728. CXTPSyntaxEditLexTextBlockPtr ptrParentTB,
  729. CXTPSyntaxEditLexOnScreenParseCnt* pOnScreenRunCnt = NULL);
  730. virtual BOOL IsBlockStartStillHere(CTextIter* pTxtIter, CXTPSyntaxEditLexTextBlock* pTB);
  731. virtual void FinishNewChain(BOOL bByBreak, BOOL bEOF);
  732. virtual void UpdateNewChainParentsChildren();
  733. virtual void EndBlocksByParent(CXTPSyntaxEditLexTextBlock* pTBStart, CXTPSyntaxEditLexTextBlock* pTBEnd);
  734. virtual void SeekNextEx(CTextIter* pTxtIter,
  735. CXTPSyntaxEditLexClass* pRunClass = NULL,
  736. CXTPSyntaxEditLexOnScreenParseCnt* pOnScreenRunCnt = NULL,
  737. int nChars = 1
  738. );
  739. static void AFX_CDECL AddClrBlock(XTP_EDIT_TEXTBLOCK& rClrB, CXTPSyntaxEditTextBlockArray& arBlocks);
  740. //==== Run parse update context members ====
  741. CXTPSyntaxEditTextRegion        m_curInvalidZone;
  742. CXTPSyntaxEditLexTextBlockPtr m_ptrNewChainTB1;
  743. CXTPSyntaxEditLexTextBlockPtr m_ptrNewChainTB2;
  744. CXTPSyntaxEditLexTextBlockPtr m_ptrOldChainTBFirst;
  745. typedef CMap<WPARAM, WPARAM, CXTPSyntaxEditLexTextBlockPtr, CXTPSyntaxEditLexTextBlockPtr&>
  746. CXTPSyntaxEditLexID2TBmap;
  747. CXTPSyntaxEditLexID2TBmap       m_mapLastParsedBlocks;
  748. CXTPSyntaxEditLexTextBlockPtr m_ptrLastParsedBlock;
  749. BOOL                m_bSendProgressEvents;
  750. int     m_nNoEndedClassesCount;
  751. //==== END Run parse update context members ====
  752. private:
  753. //CCriticalSection m_csData;
  754. //CCriticalSection m_csClassSch;
  755. CMutex m_lockData;
  756. CMutex m_lockClassSch;
  757. CEvent           m_evBreakParsing;
  758. CXTPSyntaxEditLexClassSchema* m_pClassSchema;
  759. CXTPSyntaxEditLexTextBlockPtr   m_ptrFirstBlock;
  760. CXTPSyntaxEditLexTextBlockPtr   m_ptrLastSchBlock;
  761. int m_nSeekNext_TagWaitChars;
  762. CString m_strSchName;
  763. CXTPNotifyConnectionMT* m_pConnectMT;
  764. };
  765. //===========================================================================
  766. // Summary:
  767. //      This class used to 'run' lex schema parsing in separate thread.
  768. //      It also control this working thread and provide interthread interaction.
  769. //===========================================================================
  770. class _XTP_EXT_CLASS CXTPSyntaxEditLexParser : public CXTPCmdTarget
  771. {
  772. public:
  773. //-----------------------------------------------------------------------
  774. // Summary:
  775. //      Default object constructor.
  776. //-----------------------------------------------------------------------
  777. CXTPSyntaxEditLexParser();
  778. //-----------------------------------------------------------------------
  779. // Summary:
  780. //      Object destructor. Handles clean up and deallocations.
  781. //-----------------------------------------------------------------------
  782. virtual ~CXTPSyntaxEditLexParser();
  783. //-------------------------------------------------------------------------
  784. // Summary:
  785. //      Use this member function to stop parsing, destroy working thread and
  786. //      unadvise from all events.
  787. // See Also: CloseParseThread, StopParseInThread
  788. //-------------------------------------------------------------------------
  789. virtual void Close();
  790. //-------------------------------------------------------------------------
  791. // Summary:
  792. //      Use this member function to stop parsing, destroy working thread.
  793. // See Also: Close, StopParseInThread
  794. //-------------------------------------------------------------------------
  795. virtual void CloseParseThread();
  796. //-----------------------------------------------------------------------
  797. // Summary:
  798. //      Use this member function to start parsing of specified text range
  799. //      in separate (working) thread. If parser already running and parse
  800. //      other text range, the new range added to a queue.
  801. // Parameters:
  802. //      pBuffer     - A pointer to CXTPSyntaxEditBufferManager object.
  803. //      pLCStart    - Start text position to reparse or NULL to start from begin.
  804. //      pLCEnd      - End text position to reparse or NULL to parse until end.
  805. //      eEdinAction - Zero (0) or value from XTPSyntaxEditEditAction enum.
  806. //      bRunWithoutWait - Start parse immediately or wait a timeout specified
  807. //                        in global schema options.
  808. // See Also: StopParseInThread, CloseParseThread
  809. //-----------------------------------------------------------------------
  810. virtual void StartParseInThread(CXTPSyntaxEditBufferManager* pBuffer,
  811.   const XTP_EDIT_LINECOL* pLCStart = NULL,
  812.   const XTP_EDIT_LINECOL* pLCEnd = NULL,
  813.   int eEdinAction = 0,
  814.   BOOL bRunWithoutWait = FALSE);
  815. //-------------------------------------------------------------------------
  816. // Summary:
  817. //      Use this member function to stop parsing.
  818. // See Also: Close, StartParseInThread
  819. //-------------------------------------------------------------------------
  820. virtual void StopParseInThread();
  821. //-------------------------------------------------------------------------
  822. // Summary:
  823. //      Use this member function to stop parsing in thread before call
  824. //      OnEditChanged.
  825. // See Also: OnEditChanged
  826. //-------------------------------------------------------------------------
  827. virtual void OnBeforeEditChanged();
  828. //-----------------------------------------------------------------------
  829. // Summary:
  830. //      Use this member function to reparse text after editing.
  831. // Parameters:
  832. //      posFrom     - Start position for edit action.
  833. //      posTo       - End position for edit action.
  834. //      eEditAction - Value from XTPSyntaxEditEditAction enum.
  835. //      pBuffer     - A pointer to CXTPSyntaxEditBufferManager object.
  836. // See Also: OnBeforeEditChanged
  837. //-----------------------------------------------------------------------
  838. virtual void OnEditChanged(const XTP_EDIT_LINECOL& posFrom,
  839. const XTP_EDIT_LINECOL& posTo, int eEditAction,
  840. CXTPSyntaxEditBufferManager* pBuffer);
  841. //-----------------------------------------------------------------------
  842. // Summary:
  843. //      Use this member function to get active text shema.
  844. // Returns:
  845. //      A pointer to CXTPSyntaxEditLexTextSchema.
  846. // See Also: SetTextSchema
  847. //-----------------------------------------------------------------------
  848. virtual CXTPSyntaxEditLexTextSchema* GetTextSchema();
  849. //-----------------------------------------------------------------------
  850. // Summary:
  851. //      Use this member function to set active text shema.
  852. // Parameters:
  853. //      pTextSchema - A pointer to CXTPSyntaxEditLexTextSchema.
  854. // See Also: GetTextSchema
  855. //-----------------------------------------------------------------------
  856. virtual void SetTextSchema(CXTPSyntaxEditLexTextSchema* pTextSchema);
  857. //-----------------------------------------------------------------------
  858. // Summary:
  859. //      Use this member function to get text shema global options.
  860. // Parameters:
  861. //      strExt - A file extension to lookup schema.
  862. // Returns:
  863. //      A pointer to CXTPSyntaxEditLexParserSchemaOptions.
  864. //-----------------------------------------------------------------------
  865. virtual const CXTPSyntaxEditLexParserSchemaOptions* GetSchemaOptions(const CString& strExt);
  866. //-----------------------------------------------------------------------
  867. // Summary:
  868. //      Get priority for a working thread.
  869. // Returns:
  870. //      A working thread priority.
  871. // See Also: SetParseThreadPriority, CWinThread::GetThreadPriority
  872. //-----------------------------------------------------------------------
  873. virtual int GetParseThreadPriority();
  874. //-----------------------------------------------------------------------
  875. // Summary:
  876. //      Set priority for a working thread.
  877. // Parameters:
  878. //      nPriority - A new working thread priority.
  879. // Returns:
  880. //      TRUE if successful, FALSE otherwise.
  881. // See Also:
  882. //      GetParseThreadPriority, CWinThread::GetThreadPriority
  883. //-----------------------------------------------------------------------
  884. virtual BOOL SetParseThreadPriority(int nPriority);
  885. //-----------------------------------------------------------------------
  886. // Summary:
  887. //      Use this member function to get Auto Complete words for active
  888. //      text shema.
  889. // Parameters:
  890. //      rArTokens   - An array to store Auto Complete words.
  891. //      bAppend     - If this parameter TRUE - array will be appended,
  892. //                    otherwise previous items will be removed from array.
  893. // Returns:
  894. //      TRUE if successful, FALSE otherwise.
  895. //-----------------------------------------------------------------------
  896. virtual BOOL GetTokensForAutoCompleate(CXTPSyntaxEditLexTokensDefArray& rArTokens, BOOL bAppend);
  897. //-----------------------------------------------------------------------
  898. // Summary:
  899. //      Returns notification connection.
  900. // Returns:
  901. //      CXTPNotifyConnectionPtr pointer.
  902. //-----------------------------------------------------------------------
  903. virtual CXTPNotifyConnection* GetConnection();
  904. protected:
  905. //{{AFX_CODEJOCK_PRIVATE
  906. class CXTPSyntaxEditParseThreadParams
  907. {
  908. public:
  909. CXTPSyntaxEditParseThreadParams();
  910. void AddParseZone(const CXTPSyntaxEditTextRegion& rZone);
  911. //---------------------------------
  912. CMutex lockThreadParams;
  913. CXTPSyntaxEditBufferManager* ptrBuffer;
  914. CXTPSyntaxEditInvalidZoneArray arInvalidZones;
  915. CEvent      evParseRun;
  916. CEvent      evRunWithoutWait;
  917. CEvent      evExitThread;
  918. };
  919. virtual CXTPSyntaxEditParseThreadParams* GetParseInThreadParams();
  920. //}}AFX_CODEJOCK_PRIVATE
  921. //{{AFX_CODEJOCK_PRIVATE
  922. virtual void SelfCloseParseThread();
  923. static UINT AFX_CDECL ThreadParseProc(LPVOID);
  924. CCriticalSection m_csParserData;
  925. CWinThread* m_pParseThread;
  926. int         m_nParseThreadPriority; // Saved priority to the parse thread
  927. CXTPSyntaxEditParseThreadParams m_PThreadParams;
  928. CXTPSyntaxEditLexTextSchema*    m_ptrTextSchema;
  929. typedef CMap<CString, LPCTSTR, CXTPSyntaxEditLexParserSchemaOptions*, CXTPSyntaxEditLexParserSchemaOptions*>
  930. CXTPSyntaxEditLexParserSchemaOptionsMap;
  931. CXTPSyntaxEditLexParserSchemaOptionsMap m_mapSchOptions;
  932. CXTPSyntaxEditLexParserSchemaOptions*   m_pSchOptions_default;
  933. CXTPNotifyConnection* m_pConnect;
  934. DECLARE_XTP_SINK_MT(CXTPSyntaxEditLexParser, m_SinkMT)
  935. //}}AFX_CODEJOCK_PRIVATE
  936. //{{AFX_CODEJOCK_PRIVATE
  937. virtual void OnParseEvent_NotificationHandler(XTP_NOTIFY_CODE Event,
  938.   WPARAM wParam, LPARAM lParam);
  939. virtual void GetStrsFromLVArray(CXTPSyntaxEditLexVariant* pLVArray, CStringArray& rArStrs) const;
  940. virtual BOOL ReadSchemaOptions(const CString& strExt,
  941. CXTPSyntaxEditLexTextSchema* pTextSchema,
  942. CXTPSyntaxEditLexParserSchemaOptions* pOpt);
  943. //}}AFX_CODEJOCK_PRIVATE
  944. private:
  945. void RemoveAllOptions();
  946. };
  947. //}}AFX_CODEJOCK_PRIVATE
  948. ////////////////////////////////////////////////////////////////////////////
  949. AFX_INLINE const CXTPSyntaxEditTextRegion& CXTPSyntaxEditLexTextSchema::GetUpdatedTextRegion() const {
  950. return m_curInvalidZone;
  951. }
  952. AFX_INLINE CMutex* CXTPSyntaxEditLexTextSchema::GetDataLoker() {
  953. return &m_lockData;
  954. }
  955. AFX_INLINE CMutex* CXTPSyntaxEditLexTextSchema::GetClassSchLoker() {
  956. return &m_lockClassSch;
  957. }
  958. AFX_INLINE CEvent* CXTPSyntaxEditLexTextSchema::GetBreakParsingEvent() {
  959. return  &m_evBreakParsing;
  960. }
  961. AFX_INLINE XTP_EDIT_LINECOL    CXTPSyntaxEditLexTextBlock::GetPosEndLC(BOOL bMaxIfInvalid)
  962. {
  963. if(!m_PosEndLC.IsValidData()) {
  964. return bMaxIfInvalid ? XTP_EDIT_LINECOL::MAXPOS : XTP_EDIT_LINECOL::MINPOS;
  965. }
  966. return m_PosEndLC;
  967. }
  968. AFX_INLINE DWORD CXTPSyntaxEditLexTextBlock::GetStartTagEndXLC() {
  969. return m_PosStartLC.GetXLC() + m_nStartTagLen;
  970. }
  971. AFX_INLINE DWORD CXTPSyntaxEditLexTextBlock::GetEndTagBeginXLC() {
  972. return m_PosEndLC.GetXLC() - (m_nEndTagXLCLen > 0 ? m_nEndTagXLCLen : 0);
  973. }
  974. AFX_INLINE DWORD CXTPSyntaxEditLexTextBlock::GetEndTagEndXLC() {
  975. return m_PosEndLC.GetXLC() - (m_nEndTagXLCLen < 0 ? m_nEndTagXLCLen : 0);
  976. }
  977. }
  978. ////////////////////////////////////////////////////////////////////////////
  979. //#pragma warning(pop)
  980. ////////////////////////////////////////////////////////////////////////////
  981. #endif // !defined(__XTPSYNTAXEDITLEXPARSER_H__)