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

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

对话框与窗口

开发平台：

Visual C++

XTPSyntaxEditBufferManager.cpp：源码内容
  1. // XTPSyntaxEditBufferManager.cpp
  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/XTPColorManager.h"
  26. #include "Common/XTPNotifyConnection.h"
  27. #include "Common/XTPSmartPtrInternalT.h"
  28. #include "Common/XTPVC80Helpers.h"
  29. #include "Common/XTPVC50Helpers.h"
  31. // syntax editor includes
  32. #include "XTPSyntaxEditDefines.h"
  33. #include "XTPSyntaxEditStruct.h"
  34. #include "XTPSyntaxEditUndoManager.h"
  35. #include "XTPSyntaxEditLineMarksManager.h"
  36. #include "XTPSyntaxEditLexPtrs.h"
  37. #include "XTPSyntaxEditLexClassSubObjT.h"
  38. #include "XTPSyntaxEditTextIterator.h"
  39. #include "XTPSyntaxEditSectionManager.h"
  40. #include "XTPSyntaxEditLexCfgFileReader.h"
  41. #include "XTPSyntaxEditLexClassSubObjDef.h"
  42. #include "XTPSyntaxEditLexClass.h"
  43. #include "XTPSyntaxEditLexParser.h"
  44. #include "XTPSyntaxEditLexColorFileReader.h"
  45. #include "XTPSyntaxEditBufferManager.h"
  46. #include "XTPSyntaxEditCtrl.h"
  48. #include <malloc.h>
  50. #ifdef _DEBUG
  51. #define new DEBUG_NEW
  52. #undef THIS_FILE
  53. static char THIS_FILE[] = __FILE__;
  54. #endif
  57. IMPLEMENT_DYNCREATE(CXTPSyntaxEditBufferManager, CCmdTarget)
  59. //===========================================================================
  60. // CRLF styles
  61. static const char *g_pcszCRLFStyles[] =
  62. {
  63. "x0Dx0A",         //  DOS/Windows style
  64. "x0Ax0D",         //  UNIX style
  65. "x0A"              //  Macintosh style
  66. };
  68. static const WCHAR *g_pcszCRLFStylesW[] =
  69. {
  70. L"x0Dx0A",        //  DOS/Windows style
  71. L"x0Ax0D",        //  UNIX style
  72. L"x0A"             //  Macintosh style
  73. };
  75. //===========================================================================
  76. // CXTPSyntaxEditBufferManager
  77. //===========================================================================
  78. CXTPSyntaxEditConfigurationManagerPtr CXTPSyntaxEditBufferManager::s_ptrLexConfigurationManager_Default;
  79. LONG CXTPSyntaxEditBufferManager::s_dwLexConfigurationManager_DefaultRefs = 0;
  81. //===========================================================================
  83. template <class _TFileChar>
  84. inline _TFileChar* _T_GetCRLF(int nCRLFLenStyle, _TFileChar c = 0)
  85. {
  86. UNREFERENCED_PARAMETER(c);
  88. _TFileChar** ppStyles = NULL;
  89. if (sizeof(_TFileChar) == 1)
  90. {
  91. ppStyles = (_TFileChar**)g_pcszCRLFStyles;
  92. }
  93. else
  94. {
  95. ASSERT(sizeof(_TFileChar) == 2);
  96. ppStyles = (_TFileChar**)g_pcszCRLFStylesW;
  97. }
  99. if (nCRLFLenStyle < 0 || nCRLFLenStyle >= _countof(g_pcszCRLFStyles))
  100. {
  101. ASSERT(FALSE);
  102. nCRLFLenStyle = 0;
  103. }
  105. return ppStyles[nCRLFLenStyle];
  106. }
  108. template <class _TFileChar>
  109. inline int _T_StrLen(_TFileChar* pStr)
  110. {
  111. if (sizeof(_TFileChar) == 1)
  112. {
  113. return (int)strlen((CHAR*)pStr);
  114. }
  115. ASSERT(sizeof(_TFileChar) == 2);
  116. return (int)wcslen((WCHAR*)pStr);
  117. }
  119. CString GetFileExtention(CFile* pFile)
  120. {
  121. TCHAR szDrive[_MAX_DRIVE], szDir[_MAX_DIR], szFileName[_MAX_FNAME], szExt[_MAX_EXT];
  123. szDrive[0]    = _T('');
  124. szDir[0]      = _T('');
  125. szFileName[0] = _T('');
  126. szExt[0]      = _T('');
  128. SPLITPATH_S(pFile->GetFileName(), szDrive, szDir, szFileName, szExt);
  130. return szExt;
  131. }
  133. //---------------------------------------------------------------------------
  134. int _cdecl _Compare_BYTE(const void* pb1, const void* pb2)
  135. {
  136. if ( *((BYTE*)pb1) > *((BYTE*)pb2) )
  137. return 1;
  138. if ( *((BYTE*)pb2) > *((BYTE*)pb1) )
  139. return -1;
  140. return 0;
  141. }
  143. BOOL _IsUnicodeFile_heuristic(CFile *pFile)
  144. {
  145. pFile->SeekToBegin();
  147. const int cnBufferSize = 1024;
  148. BYTE arData[cnBufferSize];
  150. BYTE arData0[cnBufferSize/2];
  151. BYTE arData1[cnBufferSize/2];
  153. UINT uDataSize = pFile->Read(arData, cnBufferSize);
  155. pFile->SeekToBegin();
  157. UINT uDataXcount = uDataSize / 2;
  159. UINT i;
  160. for (i = 0; i < uDataXcount; i++)
  161. {
  162. arData0[i] = arData[i*2];
  163. arData1[i] = arData[i*2 + 1];
  165. if ((arData0[i] == 0xA || arData0[i] == 0xD) && arData1[i] == 0)
  166. return TRUE;
  167. }
  169. qsort(arData0, uDataXcount, sizeof(BYTE), _Compare_BYTE);
  170. qsort(arData1, uDataXcount, sizeof(BYTE), _Compare_BYTE);
  173. int nVariation0 = 0;
  174. int nVariation1 = 0;
  175. int nSmallNumbers1 = 0;
  177. for (i = 1; i < uDataXcount; i++)
  178. {
  179. if (arData0[i] != arData0[i - 1])
  180. nVariation0++;
  181. }
  183. for (i = 1; i < uDataXcount; i++)
  184. {
  185. if (arData1[i] != arData1[i - 1])
  186. nVariation1++;
  188. if (arData1[i] < 9)
  189. nSmallNumbers1++;
  190. }
  192. if (uDataXcount < 10)
  193. return nVariation0 > nVariation1 || nSmallNumbers1;
  195. int nVariationDiff = nVariation0 * 100 / max(1, nVariation1);
  196. int nSmallNumbersPc = nSmallNumbers1 * 100 / max(1, uDataXcount);
  198. return nVariationDiff > 150 || nSmallNumbersPc > 3;
  199. }
  201. BOOL IsUnicodeFile(CFile *pFile)
  202. {
  203. pFile->SeekToBegin();
  205. WORD wPrefix;
  206. UINT uReaded = pFile->Read(&wPrefix, 2);
  207. if (uReaded == 2 && wPrefix == 0xFEFF)
  208. {
  209. return TRUE;
  210. }
  212. DWORD_PTR dwFileSize = (DWORD_PTR)pFile->GetLength();
  214. if (dwFileSize % 2 == 0)
  215. {
  216. return _IsUnicodeFile_heuristic(pFile);
  217. }
  219. pFile->SeekToBegin();
  220. return FALSE;
  221. }
  223. //===========================================================================
  224. template <class _TFileChar>
  225. inline int _T_GetCRLFStyle(_TFileChar chEOL1, _TFileChar chEOL2, int* pnCRLFLen)
  226. {
  227. int nCRLFLen = 1;
  228. int nCRLFStyle = xtpEditCRLFStyleUnknown;
  230. if (chEOL1 == 13)
  231. {
  232. //ASSERT(chEOL2 == 10); // incorrect text - reversed DOS CRLF style
  233. nCRLFLen = chEOL2 == 10 ? 2 : 1;
  234. nCRLFStyle = xtpEditCRLFStyleDos;
  235. }
  236. else if (chEOL1 == 10)
  237. {
  238. if (chEOL2 == 13)
  239. {
  240. nCRLFLen = 2;
  241. nCRLFStyle = xtpEditCRLFStyleUnix;
  242. }
  243. else
  244. {
  245. nCRLFLen = 1;
  246. nCRLFStyle = xtpEditCRLFStyleMac;
  247. }
  248. }
  250. if (pnCRLFLen)
  251. {
  252. *pnCRLFLen = nCRLFLen;
  253. }
  254. return nCRLFStyle;
  255. }
  257. template <class _TFileChar, int _cnMaxStr2_chars>
  258. inline void _T_StrAdd(CString& rStr, _TFileChar* pStr2, UINT uCodePage)
  259. {
  260. if (sizeof(TCHAR) == 2 && sizeof(_TFileChar) == 1)
  261. {
  262. const int cnBuf2Size = _cnMaxStr2_chars+1;
  264. WCHAR szBuf2[cnBuf2Size];
  265. ::ZeroMemory(szBuf2, sizeof(szBuf2));
  267. int nLen = MultiByteToWideChar(uCodePage, 0, (LPCSTR)pStr2, -1, szBuf2, cnBuf2Size-1);
  268. ASSERT(nLen <= cnBuf2Size-1);
  270. rStr += szBuf2;
  271. }
  272. else
  273. {
  274. //ASSERT(sizeof(TCHAR) == sizeof(_TFileChar));
  275. UNREFERENCED_PARAMETER(uCodePage);
  277. rStr += pStr2;
  278. }
  279. }
  281. //===========================================================================
  282. template <class _TFileChar>
  283. BOOL _T_ReadStringFromFile(CFile *pFile, CString& rstrString, int& rnCRLFStyle,
  284. UINT uCodePage, _TFileChar c = 0)
  285. {
  286. UNREFERENCED_PARAMETER(c);
  287. ASSERT(pFile);
  288. if (!pFile)
  289. return FALSE;
  291. rstrString = _T("");
  292. rnCRLFStyle = -1;
  294. const int cnBuffSize = 128; //512;
  295. _TFileChar pBuff[cnBuffSize+10];
  297. UINT uFileSize = (UINT)pFile->GetLength();
  299. while ((UINT)pFile->GetPosition() < uFileSize)
  300. {
  301. UINT uReadSizeB = (cnBuffSize) * sizeof(_TFileChar);
  302. UINT uBufDataCountB = pFile->Read(pBuff, uReadSizeB);
  303. if (!uBufDataCountB)
  304. {
  305. ASSERT(FALSE);
  306. break;
  307. }
  308. ASSERT(uBufDataCountB%sizeof(_TFileChar) == 0);
  309. int nBufDataLen = uBufDataCountB/sizeof(_TFileChar);
  311. pBuff[nBufDataLen] = _T('');
  312. int nBufStrLen = _T_StrLen(pBuff);
  313. ASSERT(nBufStrLen <= nBufDataLen);
  315. _TFileChar* pEOL = NULL;
  317. if (sizeof(_TFileChar) == 1)
  318. {
  319. #ifdef _MBCS
  320. pEOL = (_TFileChar*)_mbspbrk((BYTE*)pBuff, (BYTE*)"x0Ax0D");
  321. #else
  322. pEOL = (_TFileChar*)strpbrk((char*)pBuff, "x0Ax0D");
  323. #endif
  324. }
  325. else
  326. {
  327. pEOL = (_TFileChar*)wcspbrk((wchar_t*)pBuff, L"x0Ax0D");
  328. }
  330. BOOL bEOL_badFormat = FALSE;
  331. // check bad case: when zero char is rathe then readed buffer end
  332. if (!pEOL && nBufStrLen < nBufDataLen)
  333. {
  334. pEOL = pBuff + nBufStrLen;
  335. bEOL_badFormat = TRUE;
  336. }
  338. //---------------------------------
  339. if (!pEOL)
  340. {
  341. _T_StrAdd<_TFileChar, cnBuffSize>(rstrString, pBuff, uCodePage);
  342. continue;
  343. }
  345. _TFileChar chEOL1 = pEOL[0];
  346. _TFileChar chEOL2 = pEOL[1];
  348. *pEOL = 0;
  349. _T_StrAdd<_TFileChar, cnBuffSize>(rstrString, pBuff, uCodePage);
  351. if (!bEOL_badFormat && chEOL2 == 0 && (chEOL1 == 10 || chEOL1 == 13))
  352. {   // buffer ended on the middle of CRLF ?
  353.     // read one more char to be sure in CRLF style.
  354. if (uReadSizeB == uBufDataCountB && (UINT)pFile->GetPosition() < uFileSize)
  355. {
  356. _TFileChar* pBufTail = pBuff + uBufDataCountB/sizeof(_TFileChar);
  357. UINT uReadedB = pFile->Read(pBufTail, sizeof(_TFileChar));
  358. pBufTail[1] = 0;
  359. chEOL2 = pBufTail[0];
  361. uReadSizeB += uReadedB;
  362. uBufDataCountB += uReadedB;
  363. }
  364. }
  366. int nCRLFLen = 1;
  367. if (!bEOL_badFormat)
  368. {
  369. rnCRLFStyle = _T_GetCRLFStyle<_TFileChar>(chEOL1, chEOL2, &nCRLFLen);
  370. ASSERT(rnCRLFStyle != xtpEditCRLFStyleUnknown);
  371. }
  373. int nEolPos = int(pEOL - pBuff);
  374. int nSeekBack = (nEolPos + nCRLFLen)*sizeof(_TFileChar) - uBufDataCountB;
  375. pFile->Seek(nSeekBack, CFile::current);
  377. return TRUE;
  378. }
  380. return rstrString.GetLength() > 0;
  381. }
  383. //===========================================================================
  384. template <class _TFileChar, class _TFile >
  385. int _T_WriteStringToFile(_TFile *pFile, LPCTSTR pszString, int nCRLFStyle,
  386.    UINT uCodePage, CByteArray* parBuffer = NULL, _TFileChar c = 0)
  387. {
  388. UNREFERENCED_PARAMETER(c);
  390. CByteArray arBufferInt;
  391. if (!parBuffer)
  392. {
  393. parBuffer = &arBufferInt;
  394. }
  396. int nStrLen = (int)_tcslen(pszString);
  398. BYTE* pFileBuffer = NULL;
  399. int nFileBufferLenB = 0;
  401. //------------------------------------------------------------------------
  402. if (sizeof(TCHAR) == sizeof(_TFileChar))
  403. {
  404. pFileBuffer = (BYTE*)pszString;
  405. nFileBufferLenB = nStrLen * sizeof(_TFileChar);
  406. }
  407. else
  408. {
  409. int nNeedBufSizeB = nStrLen * 2 + 30;
  410. if (parBuffer->GetSize() < nNeedBufSizeB)
  411. {
  412. parBuffer->SetSize(nNeedBufSizeB + 256);
  413. }
  415. pFileBuffer = parBuffer->GetData();
  417. ASSERT(parBuffer->GetSize() >= nNeedBufSizeB);
  418. ZeroMemory(pFileBuffer, nNeedBufSizeB);
  420. if (sizeof(TCHAR) == 2 && sizeof(_TFileChar) == 1)
  421. {
  422. int nMBCStextLen = WideCharToMultiByte(uCodePage, 0,
  423. (LPCWSTR)pszString, -1,
  424. (LPSTR)pFileBuffer, nNeedBufSizeB, NULL, NULL);
  426. nFileBufferLenB = max(nMBCStextLen - 1, 0);
  427. }
  428. else if (sizeof(TCHAR) == 1 && sizeof(_TFileChar) == 2)
  429. {
  430. int nWtextLen = MultiByteToWideChar(uCodePage, 0,
  431. (LPCSTR)pszString, -1,
  432. (LPWSTR)pFileBuffer, nNeedBufSizeB/2);
  434. nFileBufferLenB = max(nWtextLen - 1, 0) * 2;
  435. }
  436. else
  437. {
  438. ASSERT(FALSE);
  439. return 0;
  440. }
  441. }
  443. //------------------------------------------------------------------------
  444. if (nFileBufferLenB > 0)
  445. {
  446. pFile->Write(pFileBuffer, nFileBufferLenB);
  447. }
  449. if (nCRLFStyle >= 0)
  450. {
  451. _TFileChar* tszCRLF = _T_GetCRLF<_TFileChar>(nCRLFStyle);
  452. int nCRLFlenB = _T_StrLen(tszCRLF) * sizeof(_TFileChar);
  454. pFile->Write(tszCRLF, nCRLFlenB);
  456. nFileBufferLenB += nCRLFlenB;
  457. }
  459. return nFileBufferLenB;
  460. }
  462. //===========================================================================
  463. AFX_INLINE BOOL ReadStringFromFileEx(CFile *pFile, CString& rstrString, int& rnCRLFStyle,
  464.  UINT uCodePage, BOOL bUnicode)
  465. {
  466. if (bUnicode)
  467. {
  468. return _T_ReadStringFromFile<WCHAR>(pFile, rstrString, rnCRLFStyle, uCodePage);
  469. }
  470. return _T_ReadStringFromFile<CHAR>(pFile, rstrString, rnCRLFStyle, uCodePage);
  471. }
  473. template <class _TFile >
  474. AFX_INLINE int _T_WriteStringToFileEx(_TFile *pFile, LPCTSTR pszString, int nCRLFStyle,
  475.    UINT uCodePage, CByteArray* parBuffer, BOOL bUnicode)
  477. {
  478. if (bUnicode)
  479. {
  480. return _T_WriteStringToFile<WCHAR>(pFile, pszString, nCRLFStyle, uCodePage, parBuffer);
  481. }
  482. return _T_WriteStringToFile<CHAR>(pFile, pszString, nCRLFStyle, uCodePage, parBuffer);
  483. }
  484. //===========================================================================
  486. CXTPSyntaxEditBufferManager::CXTPSyntaxEditBufferManager()
  487. {
  488. m_pConnect = new CXTPNotifyConnection();
  490. m_pLexParser = new CXTPSyntaxEditLexParser();
  492. m_bOverwrite = FALSE;
  493. m_nCodePage = CP_ACP;
  494. m_bUnicodeFileFormat = FALSE;
  496. m_nTabSize = 4;
  497. m_iCRLFStyle = xtpEditCRLFStyleDos;
  499. m_nAverageLineLen = XTP_EDIT_AVELINELEN;
  501. m_pLineMarksManager = new CXTPSyntaxEditLineMarksManager();
  502. m_pUndoRedoManager = new CXTPSyntaxEditUndoRedoManager();
  504. m_bIsParserEnabled = TRUE;
  506. if (!s_ptrLexConfigurationManager_Default)
  507. {
  508. s_ptrLexConfigurationManager_Default = new CXTPSyntaxEditConfigurationManager();
  509. }
  510. if (s_ptrLexConfigurationManager_Default)
  511. {
  512. SetLexConfigurationManager(s_ptrLexConfigurationManager_Default);
  513. s_dwLexConfigurationManager_DefaultRefs++;
  514. }
  516. CWinApp* pWinApp = AfxGetApp();
  517. if (pWinApp)
  518. {
  519. m_nTabSize = pWinApp->GetProfileInt(
  520. XTP_EDIT_REG_SETTINGS, XTP_EDIT_REG_TABSIZE, m_nTabSize);
  521. }
  523. }
  525. CXTPSyntaxEditBufferManager::~CXTPSyntaxEditBufferManager()
  526. {
  527. Close();
  529. if (s_dwLexConfigurationManager_DefaultRefs)
  530. {
  531. s_dwLexConfigurationManager_DefaultRefs--;
  532. if (s_dwLexConfigurationManager_DefaultRefs == 0)
  533. {
  534. s_ptrLexConfigurationManager_Default->Close();
  535. s_ptrLexConfigurationManager_Default = NULL;
  536. }
  537. }
  539. CMDTARGET_RELEASE(m_pLexParser);
  540. CMDTARGET_RELEASE(m_pConnect);
  542. SAFE_DELETE(m_pLineMarksManager);
  543. SAFE_DELETE(m_pUndoRedoManager);
  544. }
  546. void CXTPSyntaxEditBufferManager::Close()
  547. {
  548. m_LexConfigManSinkMT.UnadviseAll();
  549. m_pLexParser->Close();
  551. CleanUp();
  552. }
  554. void CXTPSyntaxEditBufferManager::CleanUp()
  555. {
  556. m_Strings.RemoveAllStrs();
  558. m_pUndoRedoManager->Clear();
  560. //m_strFileExt = _T("");
  561. }
  563. void CXTPSyntaxEditBufferManager::Load(CFile *pFile, LPCTSTR pcszFileExt)
  564. {
  565. CArchive ar(pFile, CArchive::load);
  567. SerializeEx(ar, -1, FALSE, m_nCodePage, pcszFileExt);
  568. }
  570. void CXTPSyntaxEditBufferManager::Serialize(CArchive &ar)
  571. {
  572. BOOL bUnicode = ar.IsStoring() ? m_bUnicodeFileFormat : -1;
  574. SerializeEx(ar, bUnicode, TRUE, m_nCodePage, NULL);
  576. if (ar.IsStoring())
  577. m_pUndoRedoManager->MarkSaved();
  578. }
  580. void CXTPSyntaxEditBufferManager::SerializeEx(CArchive &ar, BOOL bUnicode, BOOL bWriteUnicodeFilePrefix,
  581.   UINT nCodePage, LPCTSTR pcszFileExt, int nDataSizeLimit)
  582. {
  583. if (m_bIsParserEnabled)
  584. {
  585. m_pLexParser->StopParseInThread();
  586. }
  588. if (nCodePage != (UINT)-1)
  589. m_nCodePage = nCodePage;
  591. CFile* pFile = ar.GetFile();
  593. if (ar.IsLoading())
  594. {
  595. CleanUp();
  597. // IsUnicodeFile is take care about start text offset
  598. //pFile->Seek(m_bUnicodeFileFormat ? 2 : 0, CFile::begin);
  599. //
  600. if (bUnicode < 0)
  601. m_bUnicodeFileFormat = IsUnicodeFile(pFile);
  602. else
  603. m_bUnicodeFileFormat = (bUnicode > 0);
  605. CString strString;
  606. int nCRLFStyle = -1;
  607. int nCRLFLastLineStyle = -1;
  608. BOOL bSETeol = TRUE;
  610. int nRow = 1;
  612. while (ReadStringFromFileEx(pFile, strString, nCRLFStyle, m_nCodePage, m_bUnicodeFileFormat))
  613. {
  614. m_Strings.SetAtGrowStr(nRow, strString);
  616. if (bSETeol && nCRLFStyle >= 0)
  617. {
  618. SetCRLFStyle(nCRLFStyle);
  619. bSETeol = FALSE;
  620. }
  621. nCRLFLastLineStyle = nCRLFStyle;
  622. nRow++;
  623. }
  625. if (nCRLFLastLineStyle >= 0)
  626. {
  627. m_Strings.SetAtGrowStr(nRow, _T(""));
  628. }
  630. CString strExt = pcszFileExt ? pcszFileExt : GetFileExtention(pFile);
  631. if (!strExt.IsEmpty())
  632. SetFileExt(strExt);
  633. }
  634. else if (ar.IsStoring())
  635. {
  636. if (bUnicode == -1)
  637. bUnicode = m_bUnicodeFileFormat;
  639. if ((bUnicode) && bWriteUnicodeFilePrefix)
  640. {
  641. ar << (BYTE)255;
  642. ar << (BYTE)254;
  643. }
  645. CByteArray arBuffer;
  647. int nCRLFStyle = GetCurCRLFType();
  649. int nDataSize = 0;
  650. int nRowsCount = m_Strings.GetCount();
  651. for (int i = 1; i < nRowsCount; i++)
  652. {
  653. CString strLine = m_Strings.GetStr(i);
  655. if (i == nRowsCount-1)
  656. { // last line
  657. nCRLFStyle = -1;// do not write CRLF
  658. }
  660. int nWrittenBytes = _T_WriteStringToFileEx(&ar, strLine, nCRLFStyle,
  661. m_nCodePage, &arBuffer, bUnicode);
  663. nDataSize += nWrittenBytes;
  665. if (nDataSizeLimit > 0 && nDataSize > nDataSizeLimit)
  666. break;
  667. }
  669. //---------------
  670. CString strExt = pcszFileExt ? pcszFileExt : GetFileExtention(pFile);
  671. if (!strExt.IsEmpty())
  672. SetFileExt(strExt);
  673. }
  674. }
  676. void CXTPSyntaxEditBufferManager::SetLexConfigurationManager(
  677. CXTPSyntaxEditConfigurationManager* pMan)
  678. {
  679. m_LexConfigManSinkMT.UnadviseAll();
  681. m_ptrLexConfigurationManager.SetPtr(pMan, TRUE);
  683. if (pMan)
  684. {
  685. CXTPNotifyConnection* ptrConn = pMan->GetConnection();
  686. ASSERT(ptrConn);
  687. if (ptrConn)
  688. {
  689. m_LexConfigManSinkMT.Advise(ptrConn, xtpEditClassSchWasChanged, &CXTPSyntaxEditBufferManager::OnLexConfigManEventHandler);
  690. m_LexConfigManSinkMT.Advise(ptrConn, xtpEditThemeWasChanged, &CXTPSyntaxEditBufferManager::OnLexConfigManEventHandler);
  691. m_LexConfigManSinkMT.Advise(ptrConn, xtpEditAllConfigWasChanged, &CXTPSyntaxEditBufferManager::OnLexConfigManEventHandler);
  692. }
  693. }
  694. }
  696. void CXTPSyntaxEditBufferManager::OnLexConfigManEventHandler(XTP_NOTIFY_CODE Event,
  697.   WPARAM wParam, LPARAM lParam)
  698. {
  699. if (!m_bIsParserEnabled)
  700. {
  701. return;
  702. }
  704. if (Event == xtpEditClassSchWasChanged || Event == xtpEditAllConfigWasChanged)
  705. {
  706. CXTPSyntaxEditTextSchema* ptrNewTxtSch = NULL;
  707. BOOL bSetTxtSch = FALSE;
  709. if (Event == xtpEditClassSchWasChanged)
  710. {
  711. // wParam = LPCTSTR - Schema name;
  712. // lParam = CXTPSyntaxEditLexTextSchema* New text schema pointer
  713. //            or NULL if schema was removed.
  715. CXTPSyntaxEditLexTextSchema* pTxtSch = (CXTPSyntaxEditLexTextSchema*)lParam;
  716. if (pTxtSch)
  717. {
  718. if (pTxtSch->IsFileExtSupported(m_strFileExt) )
  719. {
  720. ptrNewTxtSch = pTxtSch;
  721. bSetTxtSch = TRUE;
  722. }
  723. else
  724. {
  725. CXTPSyntaxEditLexTextSchema* ptrTxtSch_current = m_pLexParser->GetTextSchema();
  726. CString strName_current = ptrTxtSch_current ? ptrTxtSch_current->GetSchName() : _T("");
  727. CString strName_New = pTxtSch->GetSchName();
  729. if (strName_current.CompareNoCase(strName_New) == 0)
  730. {
  731. //such file ext is no longer supported by this schema
  732. ptrNewTxtSch = NULL;
  733. bSetTxtSch = TRUE;
  734. }
  735. }
  736. }
  737. else
  738. {
  739. ptrNewTxtSch = GetMasterTextSchema(m_strFileExt);
  740. bSetTxtSch = !ptrNewTxtSch;
  741. }
  742. }
  744. if (Event == xtpEditAllConfigWasChanged)
  745. {
  746. ptrNewTxtSch = GetMasterTextSchema(m_strFileExt);
  747. bSetTxtSch = TRUE;
  748. }
  750. //====================================================================
  751. if (bSetTxtSch)
  752. {
  753. m_pLexParser->SetTextSchema(ptrNewTxtSch);
  755. if (ptrNewTxtSch)
  756. {
  757. XTP_EDIT_LINECOL pos1_0 = {1,0};
  758. BOOL bParseInThread = m_pLexParser->GetSchemaOptions(
  759. GetFileExt())->m_bConfigChangedReparceInSeparateThread;
  760. if (bParseInThread)
  761. {
  763. m_pLexParser->StartParseInThread(this, &pos1_0, NULL, 0, TRUE);
  764. }
  765. else
  766. {
  767. CXTPSyntaxEditLexTextSchema* ptrTextSch = m_pLexParser->GetTextSchema();
  768. if (ptrTextSch)
  769. {
  770. CXTPSyntaxEditTextIterator txtIter(this);
  771. ptrTextSch->RunParseUpdate(TRUE, &txtIter, &pos1_0, NULL);
  772. }
  773. }
  774. }
  776. //----------------------------------------------
  777. m_pConnect->SendEvent(Event, wParam, lParam);
  778. }
  779. }
  781. if (Event == xtpEditThemeWasChanged)
  782. {
  783. // wParam = LPCTSTR - Theme name;
  784. // lParam = CXTPSyntaxEditColorTheme* New theme pointer
  785. //            or NULL if theme was removed.
  787. CXTPSyntaxEditColorTheme* pNewTheme = (CXTPSyntaxEditColorTheme*)lParam;
  789. CXTPSyntaxEditLexTextSchema* ptrTxtSch = m_pLexParser->GetTextSchema();
  790. if (ptrTxtSch)
  791. {
  792. ptrTxtSch->ApplyTheme(pNewTheme);
  794. //----------------------------------------------
  795. m_pConnect->SendEvent(Event, wParam, lParam);
  796. }
  797. }
  798. }
  800. BOOL CXTPSyntaxEditBufferManager::InsertText(LPCTSTR szText, int nRow, int nCol,
  801. BOOL bCanUndo, XTP_EDIT_LINECOL* pFinalLC)
  802. {
  803. int nStrLenB = (int)_tcslen(szText) * sizeof(TCHAR);
  804. CMemFile memFile((BYTE*)szText, nStrLenB);
  805. CString strString;
  806. CString strReplased;
  807. int nLastLineEOLstyle = -1;
  809. CString strRow1, strRow2;
  810. memFile.SeekToBegin();
  812. // process first row (cut and concatenate)
  813. if (_T_ReadStringFromFile<TCHAR>(&memFile, strString, nLastLineEOLstyle, m_nCodePage))
  814. {
  815. strRow1 = m_Strings.GetStr(nRow);
  816. //int nLen = strRow1.GetLength();
  817. int nLenC = (int)_tcsclen(strRow1);
  818. if (nCol-1 < nLenC)
  819. {
  820. int nPosX = (int)_tcsnbcnt(strRow1, nCol-1);
  821. strRow2 = strRow1.Mid(nPosX);
  822. strRow1 = strRow1.Left(nPosX);
  824. strRow1 += strString;
  825. if (m_bOverwrite)
  826. {
  827. int nReplaceLen = min(strString.GetLength(), strRow2.GetLength());
  828. strReplased = strRow2.Left(nReplaceLen);
  829. DELETE_S(strRow2, 0, nReplaceLen);
  830. }
  831. m_Strings.SetAtGrowStr(nRow, strRow1);
  832. }
  833. else
  834. {
  835. m_Strings.InsertText(nRow, nCol-1, strString, TRUE);
  836. }
  837. }
  839. // process middle rows (insert them)
  840. int nCRLFStyleX = -1;
  841. int r = nRow + 1;
  842. while (_T_ReadStringFromFile<TCHAR>(&memFile, strString, nCRLFStyleX, m_nCodePage))
  843. {
  844. m_Strings.InsertStr(r, strString);
  845. r++;
  847. nLastLineEOLstyle = nCRLFStyleX;
  848. }
  850. // process last row (concatenate)
  851. int nRowTo = nRow;
  852. int nColTo = nCol+1;
  854. if (nLastLineEOLstyle >= 0)
  855. {
  856. m_Strings.InsertStr(r, strRow2);
  857. nRowTo = r;
  858. nColTo = (int)_tcsclen(strString) + 1;
  859. }
  860. else
  861. {
  862. strString = m_Strings.GetStr(r-1);
  864. nRowTo = r-1;
  865. nColTo = (int)_tcsclen(strString) + 1;
  867. strString += strRow2;
  868. m_Strings.SetAtGrowStr(r-1, strString);
  870. }
  872. //===========================================================================
  873. if (pFinalLC)
  874. {
  875. pFinalLC->nLine = nRowTo;
  876. pFinalLC->nCol = nColTo;
  877. }
  879. if (bCanUndo)
  880. {
  881. if (!m_bOverwrite || strReplased == "") // By Leva: added 2nd condition to eliminate undo bug
  882. {
  883. m_pUndoRedoManager->AddCommand(new CXTPSyntaxEditInsertStringCommand(this,
  884.  szText,
  885.  XTP_EDIT_LINECOL::MakeLineCol(nRow, nCol),
  886.  XTP_EDIT_LINECOL::MakeLineCol(nRowTo, nColTo)) );
  887. }
  888. else
  889. {
  890. m_pUndoRedoManager->SetGroupInsertMode(FALSE);
  891. m_pUndoRedoManager->AddCommand(new CXTPSyntaxEditReplaceStringCommand(this,
  892. szText, strReplased,
  893. XTP_EDIT_LINECOL::MakeLineCol(nRow, nCol),
  894. XTP_EDIT_LINECOL::MakeLineCol(nRowTo, nColTo)) );
  895. }
  896. }
  898. return TRUE;
  899. }
  901. BOOL CXTPSyntaxEditBufferManager::InsertTextBlock(LPCTSTR szText, int nRow,
  902. int nCol, BOOL bCanUndo, XTP_EDIT_LINECOL* pFinalLC)
  903. {
  904. int nStrLenB = (int)_tcslen(szText) * sizeof(TCHAR);
  905. CMemFile memFile((BYTE*)szText, nStrLenB);
  906. memFile.SeekToBegin();
  908. CString strString;
  909. int nEndPos = 0;
  910. int nCRLFStyleX = -1;
  911. int r = nRow;
  913. int nDispCol = StrPosToCol(nRow, nCol-1);
  915. if (bCanUndo)
  916. {
  917. m_pUndoRedoManager->SetGroupInsertMode(TRUE);
  918. }
  920. while (_T_ReadStringFromFile<TCHAR>(&memFile, strString, nCRLFStyleX, m_nCodePage))
  921. {
  922. CString strRow = m_Strings.GetStr(r);
  924. int nRowLen = (int)_tcsclen(strRow);
  925. int nRowCols = StrPosToCol(r, nRowLen);
  927. int nPos = ColToStrPos(r, nDispCol);
  928. if (nRowCols < nDispCol)
  929. {
  930. nPos = nRowLen + (nDispCol - nRowCols);
  931. }
  933. m_Strings.InsertText(r, nPos, strString, TRUE);
  935. //--------------------------------------------------------------------
  936. nEndPos = nPos + strString.GetLength();
  938. if (bCanUndo)
  939. {
  940. XTP_EDIT_LINECOL posFrom = {r, nPos+1};
  941. XTP_EDIT_LINECOL posTo = {r, nEndPos+1};
  943. m_pUndoRedoManager->AddCommand(new CXTPSyntaxEditInsertStringCommand(this,
  944. strString, posFrom, posTo) );
  945. }
  947. //--------------------------------------------------------------------
  948. r++;
  949. }
  951. if (bCanUndo)
  952. {
  953. m_pUndoRedoManager->SetGroupInsertMode(FALSE);
  954. }
  955. //===========================================================================
  956. if (pFinalLC)
  957. {
  958. pFinalLC->nLine = r-1;
  959. pFinalLC->nCol = nEndPos+1;
  960. }
  962. return TRUE;
  963. }
  965. void CXTPSyntaxEditBufferManager::GetLineText(int nLine, CString& strText,
  966.  BOOL bAddCRLF, int nCRLFStyle)
  967. {
  968. strText = GetLineText(nLine, bAddCRLF, nCRLFStyle);
  969. }
  971. CString CXTPSyntaxEditBufferManager::GetLineText(int nLine, BOOL bAddCRLF, int nCRLFStyle)
  972. {
  973. CString strText = m_Strings.GetStr(nLine);
  974. if (bAddCRLF)
  975. {
  976. strText += GetCRLF(nCRLFStyle);
  977. }
  978. return strText;
  979. }
  981. int CXTPSyntaxEditBufferManager::GetLineTextLength(int nLine, BOOL bAddCRLF, int nCRLFStyle)
  982. {
  983. int nLen = m_Strings.GetStrLen(nLine);
  985. if (bAddCRLF)
  986. {
  987. int nEOLlen = (int)_tcslen(GetCRLF(nCRLFStyle));
  988. nLen += nEOLlen;
  989. }
  990. return nLen;
  991. }
  993. int CXTPSyntaxEditBufferManager::GetLineTextLengthC(int nLine, BOOL bAddCRLF, int nCRLFStyle)
  994. {
  995. int nLen = m_Strings.GetStrLenC(nLine);
  997. if (bAddCRLF)
  998. {
  999. int nEOLlen = (int)_tcsclen(GetCRLF(nCRLFStyle));
  1000. nLen += nEOLlen;
  1001. }
  1002. return nLen;
  1003. }
  1005. int CXTPSyntaxEditBufferManager::GetMaxLineTextLength() const
  1006. {
  1007. return CalcMaxLineTextLength();
  1008. }
  1010. int CXTPSyntaxEditBufferManager::CalcMaxLineTextLength(int nLineFrom, int nLineTo, BOOL bExpandTabs) const
  1011. {
  1012. nLineFrom = min(max(1, nLineFrom), GetRowCount());
  1013. nLineTo = nLineTo < 0 ? GetRowCount() : min(nLineTo, GetRowCount());
  1015. if (nLineFrom >= m_Strings.GetCount() || nLineTo >= m_Strings.GetCount() )
  1016. {
  1017. return 0;
  1018. }
  1020. int nTabSize = GetTabSize();
  1021. int nMAXlen = 0;
  1022. for (int i = nLineFrom; i <= nLineTo; i++)
  1023. {
  1024. CString* pCStrData = m_Strings.GetStrDataC(i);
  1025. if (!pCStrData)
  1026. continue;
  1028. int nLen = pCStrData->GetLength();
  1030. if (bExpandTabs)
  1031. {
  1032. LPCTSTR pcszString = (LPCTSTR)(*pCStrData);
  1034. int nOffset = 0;
  1035. for (int k = 0; k < nLen; k++)
  1036. {
  1037. if (pcszString[k] == _T('t'))
  1038. nOffset += (nTabSize - nOffset % nTabSize);
  1039. else
  1040. nOffset++;
  1041. }
  1043. nLen = nOffset;
  1044. }
  1046. if (nLen > nMAXlen)
  1047. nMAXlen = nLen;
  1048. }
  1050. return nMAXlen;
  1051. }
  1053. BOOL CXTPSyntaxEditBufferManager::DeleteText(int nRowFrom, int nColFrom,
  1054. int nRowTo, int nColTo, BOOL bCanUndo, BOOL bDispCol)
  1055. {
  1056. ASSERT(nColFrom >= 1 && nColTo >= 1);
  1058. if (bCanUndo)
  1059. {
  1060. int nPos1 = bDispCol ? nColFrom : StrPosToCol(nRowFrom, nColFrom - 1); // By Leva: moved -1 into brackets
  1061. int nPos2 = bDispCol ? nColTo : StrPosToCol(nRowTo, nColTo - 1); // By Leva: moved -1 into brackets
  1063. CMemFile file(CalcAveDataSize(nRowFrom, nRowTo));
  1064. if (GetBuffer(nRowFrom, nPos1, nRowTo, nPos2, file))
  1065. {
  1066. TCHAR szNull = NULL;
  1067. file.SeekToEnd();
  1068. file.Write((const BYTE *)&szNull, sizeof(TCHAR));
  1070. BYTE *pBytes = file.Detach();
  1072. m_pUndoRedoManager->AddCommand(new CXTPSyntaxEditDeleteStringCommand(this, (LPCTSTR)pBytes,
  1073. XTP_EDIT_LINECOL::MakeLineCol(nRowFrom, bDispCol ? ColToStrPos(nRowFrom, nColFrom)+1 : nColFrom),
  1074. XTP_EDIT_LINECOL::MakeLineCol(nRowTo, bDispCol ? ColToStrPos(nRowTo, nColTo)+1 : nColTo)) );
  1076. free(pBytes);
  1077. }
  1078. }
  1080. BOOL bResult = FALSE;
  1081. if (nRowFrom < nRowTo)
  1082. {
  1083. // Process nRowFrom
  1084. int nStrLenR1 = m_Strings.GetStrLenC(nRowFrom);
  1085. int nStrPos = bDispCol ? ColToStrPos(nRowFrom, nColFrom) : nColFrom-1;
  1086. int nCount = nStrLenR1 - nStrPos;
  1088. if (nStrLenR1 && nCount > 0)
  1089. {
  1090. ASSERT(nStrPos >=0);
  1091. bResult = m_Strings.DeleteText(nRowFrom, nStrPos, nCount);
  1092. ASSERT(bResult);
  1093. }
  1095. // Process nRowTo
  1096. int nStrLenR2 = m_Strings.GetStrLenC(nRowTo);
  1097. nStrPos = 0;
  1098. nCount = bDispCol ? ColToStrPos(nRowTo, nColTo) : nColTo-1;
  1100. if (nStrLenR2 && nCount > 0)
  1101. {
  1102. ASSERT(nStrPos >=0);
  1103. bResult = m_Strings.DeleteText(nRowTo, nStrPos, nCount);
  1104. ASSERT(bResult);
  1105. }
  1107. // Concatenate row <from> and row <to>
  1108. CString strRowNew = m_Strings.GetStr(nRowFrom);
  1109. CString strRow2 = m_Strings.GetStr(nRowTo);
  1110. strRowNew += strRow2;
  1111. m_Strings.SetAtGrowStr(nRowFrom, strRowNew);
  1113. for (int r = nRowTo; r > nRowFrom; r--)
  1114. {
  1115. bResult = m_Strings.RemoveStr(r);
  1116. //ASSERT(bResult);
  1117. }
  1118. }
  1119. else
  1120. {
  1121. ASSERT(nRowFrom == nRowTo);
  1123. int nPos1 = bDispCol ? ColToStrPos(nRowFrom, nColFrom) : nColFrom-1;
  1124. int nPos2 = bDispCol ? ColToStrPos(nRowTo, nColTo) : nColTo-1;
  1126. int nCount = abs(nPos2 - nPos1); //abs(nColTo - nColFrom);
  1128. if (nCount)
  1129. {
  1130. bResult = m_Strings.DeleteText(nRowFrom, min(nPos1, nPos2), nCount);
  1131. }
  1132. }
  1134. return bResult;
  1135. }
  1137. BOOL CXTPSyntaxEditBufferManager::RemoveLine(int nRow, BOOL bCanUndo, int nRowsCount)
  1138. {
  1139. int nRowEnd = min(GetRowCount() + 1, nRow + nRowsCount);
  1141. if (bCanUndo)
  1142. {
  1143. CMemFile file(CalcAveDataSize(nRow, nRowEnd));
  1145. if (GetBuffer(nRow, 1, nRowEnd, 1, file))
  1146. {
  1147. TCHAR szNull = _T('');
  1148. file.SeekToEnd();
  1149. file.Write((const BYTE *)&szNull, sizeof(TCHAR));
  1151. BYTE *pBytes = file.Detach();
  1153. m_pUndoRedoManager->AddCommand(new CXTPSyntaxEditDeleteStringCommand(this, (LPCTSTR)pBytes,
  1154. XTP_EDIT_LINECOL::MakeLineCol(nRow, 1),
  1155. XTP_EDIT_LINECOL::MakeLineCol(nRowEnd, 1)) );
  1157. free(pBytes);
  1158. }
  1159. }
  1161. BOOL bResult = FALSE;
  1162. for (int r = nRowEnd - 1; r >= nRow; r--)
  1163. {
  1164. BOOL b = m_Strings.RemoveStr(r);
  1165. bResult |= b;
  1166. }
  1168. return bResult;
  1169. }
  1171. BOOL CXTPSyntaxEditBufferManager::GetBuffer(
  1172. int row1, int col1, int row2, int col2,
  1173. CMemFile& file, BOOL bColumnSelection, BOOL bForceDOSStyleCRLF)
  1174. {
  1175. int nTempRow1 = row1, nTempRow2 = row2;
  1176. int nTempCol1 = col1, nTempCol2 = col2;
  1178. if (nTempRow2 < nTempRow1)
  1179. {
  1180. row1 = nTempRow2;
  1181. col1 = nTempCol2;
  1182. row2 = nTempRow1;
  1183. col2 = nTempCol1;
  1184. }
  1185. if (nTempRow1 == nTempRow2 || bColumnSelection)
  1186. {
  1187. col1 = min(nTempCol1, nTempCol2);
  1188. col2 = max(nTempCol1, nTempCol2);
  1189. }
  1191. BOOL bStart = TRUE;
  1192. BOOL bEnd = FALSE;
  1194. int nStartPos = 0, nEndPos = 0;
  1195. int nSizeCopy = 0;
  1197. int nNewCRLFStyle = (bForceDOSStyleCRLF) ? xtpEditCRLFStyleDos : m_iCRLFStyle;
  1198. const CString strCRLF(GetCRLF(nNewCRLFStyle));
  1200. for (int i = row1; i <= row2; i++)
  1201. {
  1202. if (i == row2)
  1203. bEnd = TRUE;
  1205. CString strBuffer;
  1206. GetLineText(i, strBuffer);
  1208. const int nLineLen = (int)_tcslen(strBuffer);
  1210. nStartPos = min(bStart || bColumnSelection ? ColToStrPos(i, col1) : 0, nLineLen);
  1211. nEndPos = min(bEnd || bColumnSelection ? ColToStrPos(i, col2) : nLineLen, nLineLen);
  1213. if (bStart || bColumnSelection)
  1214. nStartPos = (int)_tcsnbcnt(strBuffer, nStartPos);
  1216. if (bEnd || bColumnSelection)
  1217. nEndPos = (int)_tcsnbcnt(strBuffer, nEndPos);
  1219. nSizeCopy = abs(nEndPos - nStartPos) * sizeof(TCHAR);
  1221. if (nSizeCopy > 0)
  1222. file.Write((LPVOID)((LPCTSTR)strBuffer + nStartPos), nSizeCopy);
  1224. if (bColumnSelection)
  1225. {
  1226. // add spaces for the free size of the column block
  1227. int nAddSpaces = abs(col2 - col1) -
  1228. (int)_tcsnccnt((LPCTSTR)strBuffer + nStartPos, abs(nEndPos - nStartPos));
  1229. if (nAddSpaces > 0)
  1230. {
  1231. const CString strSpaces(_T(' '), nAddSpaces);
  1232. file.Write((LPVOID)(LPCTSTR)strSpaces, nAddSpaces * sizeof(TCHAR));
  1233. }
  1234. }
  1235. if (row1 != row2 && i != row2 || bColumnSelection)
  1236. {
  1237. // add end of the line
  1238. file.Write((LPVOID)(LPCTSTR)strCRLF, strCRLF.GetLength() * sizeof(TCHAR));
  1239. }
  1241. bStart = FALSE;
  1242. }
  1244. return TRUE;
  1245. }
  1247. void CXTPSyntaxEditBufferManager::SetOverwriteFlag(BOOL bOverwrite)
  1248. {
  1249. m_bOverwrite = bOverwrite;
  1250. }
  1252. BOOL CXTPSyntaxEditBufferManager::GetOverwriteFlag()
  1253. {
  1254. return m_bOverwrite;
  1255. }
  1258. BOOL CXTPSyntaxEditBufferManager::IsTextCRLF(LPCTSTR szCompText, BOOL bFindReverse)
  1259. {
  1260. CString strCRLF(g_pcszCRLFStyles[m_iCRLFStyle]);
  1261. LPCTSTR szCurCRLF = (LPCTSTR)strCRLF;
  1262. LPCTSTR szTextToCompare = szCompText;
  1263. int nCRLFSize = lstrlen(szCurCRLF);
  1265. if (bFindReverse)
  1266. szTextToCompare = (szCompText - (nCRLFSize - 1));
  1268. BOOL bIsCRLF = (_tcsncmp(szTextToCompare, szCurCRLF, nCRLFSize) == 0);
  1270. return bIsCRLF;
  1271. }
  1273. #ifdef _UNICODE
  1274. BOOL CXTPSyntaxEditBufferManager::IsTextCRLF(LPCSTR szCompText, BOOL bFindReverse)
  1275. {
  1276. LPCSTR szCurCRLF = (LPCSTR)g_pcszCRLFStyles[m_iCRLFStyle];
  1277. LPCSTR szTextToCompare = szCompText;
  1278. int nCRLFSize = (int)strlen(szCurCRLF);
  1280. if (bFindReverse)
  1281. szTextToCompare = (szCompText - (nCRLFSize - 1));
  1283. BOOL bIsCRLF = (strncmp(szTextToCompare, szCurCRLF, nCRLFSize) == 0);
  1285. return bIsCRLF;
  1286. }
  1287. #endif
  1289. CString CXTPSyntaxEditBufferManager::GetCurCRLF() const
  1290. {
  1291. return GetCRLF();
  1292. }
  1294. LPCTSTR CXTPSyntaxEditBufferManager::GetCRLF(int nCRLFStyle) const
  1295. {
  1296. ASSERT(m_iCRLFStyle >= 0 && m_iCRLFStyle < _countof(g_pcszCRLFStyles));
  1298. int nCRLFidx = m_iCRLFStyle;
  1299. if (nCRLFStyle >= 0 && nCRLFStyle < _countof(g_pcszCRLFStyles))
  1300. {
  1301. nCRLFidx = nCRLFStyle;
  1302. }
  1303. return _T_GetCRLF<TCHAR>(nCRLFidx);
  1304. }
  1306. void CXTPSyntaxEditBufferManager::SetCRLFStyle(int nCRLFStyle)
  1307. {
  1309. if (nCRLFStyle >= 0 && nCRLFStyle < _countof(g_pcszCRLFStyles))
  1310. {
  1311. m_iCRLFStyle = nCRLFStyle;
  1312. } else {
  1313. ASSERT(FALSE);
  1314. }
  1315. }
  1317. int CXTPSyntaxEditBufferManager::GetCurCRLFType()
  1318. {
  1319. return m_iCRLFStyle;
  1320. }
  1322. BOOL CXTPSyntaxEditBufferManager::SetTabSize(int nTabSize, BOOL bUpdateReg/*=FALSE*/)
  1323. {
  1324. m_nTabSize = nTabSize;
  1326. if (bUpdateReg)
  1327. {
  1328. CWinApp* pWinApp = AfxGetApp();
  1329. if (pWinApp != NULL)
  1330. {
  1331. if (pWinApp->WriteProfileInt(XTP_EDIT_REG_SETTINGS, XTP_EDIT_REG_TABSIZE, nTabSize))
  1332. return TRUE;
  1333. }
  1334. return FALSE;
  1335. }
  1337. return TRUE;
  1338. }
  1340. int CXTPSyntaxEditBufferManager::GetRowCount() const
  1341. {
  1342. return m_Strings.GetCount() ? ((int)m_Strings.GetCount() - 1) : 0;
  1343. }
  1345. UINT CXTPSyntaxEditBufferManager::GetCodePage()
  1346. {
  1347. return m_nCodePage;
  1348. }
  1350. BOOL CXTPSyntaxEditBufferManager::IsModified()
  1351. {
  1352. return m_pUndoRedoManager->IsModified();
  1353. }
  1355. CString CXTPSyntaxEditBufferManager::GetFileExt()
  1356. {
  1357. return m_strFileExt;
  1358. }
  1360. void CXTPSyntaxEditBufferManager::SetFileExt(const CString& strExt)
  1361. {
  1362. if (m_strFileExt.CompareNoCase(strExt) == 0)
  1363. {
  1364. return;
  1365. }
  1366. m_strFileExt = strExt;
  1368. if (m_bIsParserEnabled)
  1369. {
  1370. CXTPSyntaxEditTextSchema* ptrMasterTxtSch = GetMasterTextSchema(strExt);
  1371. m_pLexParser->SetTextSchema(ptrMasterTxtSch);
  1372. }
  1373. }
  1375. CString CXTPSyntaxEditBufferManager::GetConfigFile()
  1376. {
  1377. if (!m_ptrLexConfigurationManager)
  1378. {
  1379. return _T("");
  1380. }
  1381. return m_ptrLexConfigurationManager->GetConfigFile();
  1382. }
  1384. BOOL CXTPSyntaxEditBufferManager::SetConfigFile(LPCTSTR szPath)
  1385. {
  1386. if (!m_ptrLexConfigurationManager)
  1387. return FALSE;
  1389. CString strCfgFile0 = m_ptrLexConfigurationManager->GetConfigFile();
  1391. if (strCfgFile0.CompareNoCase(szPath) != 0)
  1392. m_ptrLexConfigurationManager->ReloadConfig(szPath);
  1394. return TRUE;
  1395. }
  1397. CXTPSyntaxEditTextSchema* CXTPSyntaxEditBufferManager::GetMasterTextSchema(const CString& strExt)
  1398. {
  1399. if (!m_ptrLexConfigurationManager)
  1400. {
  1401. return NULL;
  1402. }
  1404. CXTPSyntaxEditTextSchemaPtr ptrMasterSch;
  1405. ptrMasterSch = m_ptrLexConfigurationManager->GetTextSchemesManager().FindSchema(strExt);
  1407. return ptrMasterSch;
  1408. }
  1410. UINT CXTPSyntaxEditBufferManager::CalcAveDataSize(int nRowStart, int nRowEnd)
  1411. {
  1412. UINT uSize = m_nAverageLineLen * abs(nRowStart - nRowEnd);
  1413. uSize = (uSize / 1024 + 1) * 1024;
  1414. return uSize;
  1415. }
  1417. BOOL CXTPSyntaxEditBufferManager::IsParserEnabled()
  1418. {
  1419. return m_bIsParserEnabled;
  1420. }
  1422. void CXTPSyntaxEditBufferManager::EnableParser(BOOL bEnable)
  1423. {
  1424. if (m_bIsParserEnabled == bEnable)
  1425. {
  1426. return;
  1427. }
  1428. m_bIsParserEnabled = bEnable;
  1430. if (m_bIsParserEnabled)
  1431. {
  1432. CXTPSyntaxEditTextSchema* ptrMasterTxtSch = GetMasterTextSchema(m_strFileExt);
  1433. m_pLexParser->SetTextSchema(ptrMasterTxtSch);
  1435. XTP_EDIT_LINECOL pos1_0 = {1,0};
  1436. BOOL bParseInThread = m_pLexParser->GetSchemaOptions(
  1437. GetFileExt())->m_bConfigChangedReparceInSeparateThread;
  1438. if (bParseInThread)
  1439. {
  1440. m_pLexParser->StartParseInThread(this, &pos1_0, NULL, 0, TRUE);
  1441. }
  1442. else
  1443. {
  1444. CXTPSyntaxEditLexTextSchema* ptrTextSch = m_pLexParser->GetTextSchema();
  1445. if (ptrTextSch)
  1446. {
  1447. CXTPSyntaxEditTextIterator txtIter(this);
  1448. ptrTextSch->RunParseUpdate(TRUE, &txtIter, &pos1_0, NULL);
  1449. }
  1450. }
  1451. }
  1452. else
  1453. {
  1454. m_pLexParser->SetTextSchema(NULL);
  1455. }
  1456. }
  1458. int CXTPSyntaxEditBufferManager::ColToStrPos(int nLine, int nDispCol) const
  1459. {
  1460. int nStrPos = 0;
  1461. int nCol = 0;
  1463. const CString strText = m_Strings.GetStr(nLine);
  1465. int nChars = (int)_tcsclen(strText);
  1466. LPCTSTR pChar = strText;
  1467. int nTabSize = GetTabSize();
  1469. for (int i = 0; *pChar != 0 && i < nChars && (nCol+1) < nDispCol; i++)
  1470. {
  1471. if (*pChar == _T('t'))
  1472. {
  1473. nCol += nTabSize - (nCol % nTabSize);
  1474. }
  1475. else
  1476. {
  1477. nCol++;
  1478. }
  1480. pChar = _tcsinc(pChar);
  1481. nStrPos++;
  1482. }
  1484. // support VirtualSpace by default
  1485. //m_bVirtualSpace
  1486. if (nCol + 1 < nDispCol)
  1487. nStrPos += nDispCol - nCol - 1;
  1489. return nStrPos;
  1490. }
  1492. int CXTPSyntaxEditBufferManager::StrPosToCol(int nLine, int nStrPos) const
  1493. {
  1494. int nDispCol = 1;
  1496. const CString strText = m_Strings.GetStr(nLine);
  1498. LPCTSTR pChar = strText;
  1499. int nTabSize = GetTabSize();
  1501. int i;
  1502. for (i = 0; *pChar != 0 && i < nStrPos;)
  1503. {
  1504. if (*pChar == _T('t'))
  1505. {
  1506. nDispCol += nTabSize - ((nDispCol-1) % nTabSize);
  1507. }
  1508. else
  1509. {
  1510. nDispCol++;
  1511. }
  1513. pChar = _tcsinc(pChar);
  1516. i++;
  1517. }
  1519. // support VirtualSpace by default
  1520. //m_bVirtualSpace
  1521. if (i < nStrPos)
  1522. nDispCol += nStrPos - i;
  1524. return nDispCol;
  1525. }
  1527. void CXTPSyntaxEditBufferManager::ChangeCase(int nRow, int nDispFrom, int nDispTo, BOOL bUpper, BOOL bCanUndo)
  1528. {
  1529. CString strText(m_Strings.GetStr(nRow));
  1531. int nFrom = (int)_tcsnbcnt(strText, ColToStrPos(nRow, nDispFrom));
  1533. int nTo = strText.GetLength();
  1534. if (nDispTo <= strText.GetLength() * GetTabSize())
  1535.  nTo = (int)_tcsnbcnt(strText, ColToStrPos(nRow, nDispTo));
  1537. CString strOriginal = strText.Mid(nFrom, nTo - nFrom);
  1538. CString strChanged(strOriginal);
  1540. // upper/lower text at row nRow from nFrom to nTo
  1541. if (bUpper)
  1542. strChanged.MakeUpper();
  1543. else
  1544. strChanged.MakeLower();
  1546. for (int i = nFrom; i < nTo; ++i)
  1547. strText.SetAt(i, strChanged[i-nFrom]);
  1549. m_Strings.SetAtGrowStr(nRow, strText);
  1551. if (bCanUndo)
  1552. {
  1553. m_pUndoRedoManager->AddCommand(new CXTPSyntaxEditReplaceStringCommand(this,
  1554. strChanged, strOriginal,
  1555. XTP_EDIT_LINECOL::MakeLineCol(nRow, nFrom + 1),
  1556. XTP_EDIT_LINECOL::MakeLineCol(nRow, nTo + 1)) );
  1557. }
  1558. }
  1560. void CXTPSyntaxEditBufferManager::ChangeTabification(int nRow, int nDispFrom, int nDispTo, BOOL bTabify, BOOL bCanUndo)
  1561. {
  1562. CString strText(m_Strings.GetStr(nRow));
  1563. const int nTextLen = (int)_tcsclen(strText);
  1564. int nFrom = ColToStrPos(nRow, nDispFrom);
  1565. int nTo = ColToStrPos(nRow, nDispTo);
  1566. const int nTabSize = GetTabSize();
  1567. const CString strTab(_T(' '), nTabSize);
  1569. CString strOriginal = strText.Mid(nFrom, nTo - nFrom);
  1570. CString strChanged(strOriginal);
  1571. // upper/lower text at row nRow from nFrom to nTo
  1572. if (bTabify)
  1573. {
  1574. REPLACE_S(strChanged, strTab, _T("x09"));
  1575. }
  1576. else
  1577. {
  1578. REPLACE_S(strChanged, _T("x09"), strTab);
  1579. }
  1581. strText = strText.Left(nFrom) + strChanged + strText.Right(nTextLen - nTo);
  1583. m_Strings.SetAtGrowStr(nRow, strText);
  1585. if (bCanUndo)
  1586. {
  1587. m_pUndoRedoManager->AddCommand(new CXTPSyntaxEditDeleteStringCommand(this,
  1588. strOriginal,
  1589. XTP_EDIT_LINECOL::MakeLineCol(nRow, nFrom + 1),
  1590. XTP_EDIT_LINECOL::MakeLineCol(nRow, nTo + 1)) );
  1591. m_pUndoRedoManager->AddCommand(new CXTPSyntaxEditInsertStringCommand(this,
  1592. strChanged,
  1593. XTP_EDIT_LINECOL::MakeLineCol(nRow, nFrom + 1),
  1594. XTP_EDIT_LINECOL::MakeLineCol(nRow, nFrom + (int)_tcsclen(strChanged) + 1)) );
  1595. }
  1596. }
  1598. ////////////////////////////////////////////////////////////////////////////
  1599. //class CXTPSyntaxEditStringsManager
  1600. CXTPSyntaxEditBufferManager::CXTPSyntaxEditStringsManager::CXTPSyntaxEditStringsManager()
  1601. {
  1602. }
  1604. CXTPSyntaxEditBufferManager::CXTPSyntaxEditStringsManager::~CXTPSyntaxEditStringsManager()
  1605. {
  1606. }
  1608. int CXTPSyntaxEditBufferManager::CXTPSyntaxEditStringsManager::GetCount() const
  1609. {
  1610. return (int)m_arStrings.GetSize();
  1611. }
  1613. CString CXTPSyntaxEditBufferManager::CXTPSyntaxEditStringsManager::GetStr(int nRow) const
  1614. {
  1615. CString* pCStr = GetStrDataC(nRow);
  1617. if (pCStr)
  1618. {
  1619. return *pCStr;
  1620. }
  1621. return _T("");
  1622. }
  1624. int CXTPSyntaxEditBufferManager::CXTPSyntaxEditStringsManager::GetStrLen(int nRow) const
  1625. {
  1626. CString* pCStr = GetStrDataC(nRow);
  1628. if (!pCStr)
  1629. {
  1630. return 0;
  1631. }
  1633. int nLen = pCStr->GetLength();
  1634. return nLen;
  1635. }
  1637. int CXTPSyntaxEditBufferManager::CXTPSyntaxEditStringsManager::GetStrLenC(int nRow) const
  1638. {
  1639. CString* pCStr = GetStrDataC(nRow);
  1641. if (!pCStr)
  1642. {
  1643. return 0;
  1644. }
  1646. int nLenC = (int)_tcsclen(*pCStr);
  1647. return nLenC;
  1648. }
  1651. void CXTPSyntaxEditBufferManager::CXTPSyntaxEditStringsManager::SetAtGrowStr(int nRow, LPCTSTR pcszText)
  1652. {
  1653. CString* pCStr = GetStrData(nRow, TRUE);
  1655. if (!pCStr)
  1656. {
  1657. return;
  1658. }
  1660. *pCStr = pcszText;
  1661. }
  1663. void CXTPSyntaxEditBufferManager::CXTPSyntaxEditStringsManager::SetAtGrowStr(int nRow,
  1664. const CString& strText)
  1665. {
  1666. CString* pCStr = GetStrData(nRow, TRUE);
  1668. if (!pCStr)
  1669. {
  1670. return;
  1671. }
  1673. *pCStr = strText;
  1674. }
  1676. void CXTPSyntaxEditBufferManager::CXTPSyntaxEditStringsManager::InsertStr(int nRow,
  1677.   const CString& strText)
  1678. {
  1679. if (nRow >=0 && nRow < m_arStrings.GetSize() )
  1680. {
  1681. CString* pCStr = new CString(strText);
  1682. m_arStrings.InsertAt(nRow, pCStr);
  1683. }
  1684. else
  1685. {
  1686. SetAtGrowStr(nRow, strText);
  1687. }
  1688. }
  1690. BOOL CXTPSyntaxEditBufferManager::CXTPSyntaxEditStringsManager::RemoveStr(int nRow)
  1691. {
  1692. if (nRow >=0 && nRow < m_arStrings.GetSize() )
  1693. {
  1694. CString* pCStr = m_arStrings[nRow];
  1695. m_arStrings.RemoveAt(nRow);
  1697. if (pCStr)
  1698. {
  1699. delete pCStr;
  1700. }
  1701. return TRUE;
  1702. }
  1703. return FALSE;
  1704. }
  1706. CString* CXTPSyntaxEditBufferManager::CXTPSyntaxEditStringsManager::GetStrDataC(int nRow) const
  1707. {
  1708. CString* pCStr = NULL;
  1710. if (nRow >=0 && nRow < m_arStrings.GetSize() )
  1711. {
  1712. pCStr = m_arStrings[nRow];
  1713. }
  1714. return pCStr;
  1715. }
  1718. CString* CXTPSyntaxEditBufferManager::CXTPSyntaxEditStringsManager::
  1719. GetStrData(int nRow, BOOL bGrowArrayIfNeed)
  1720. {
  1721. CString* pCStr = NULL;
  1723. if (nRow >=0 && nRow < m_arStrings.GetSize() )
  1724. {
  1725. pCStr = m_arStrings[nRow];
  1726. }
  1727. else if (bGrowArrayIfNeed)
  1728. {
  1729. m_arStrings.SetSize(nRow+1);
  1730. }
  1731. else
  1732. {
  1733. return NULL;
  1734. }
  1736. //---------------------------
  1737. if (!pCStr)
  1738. {
  1739. pCStr = new CString();
  1740. m_arStrings[nRow] = pCStr;
  1741. }
  1743. return pCStr;
  1744. }
  1747. BOOL CXTPSyntaxEditBufferManager::CXTPSyntaxEditStringsManager::InsertText(int nRow, int nPos,
  1748. LPCTSTR pcszText, BOOL bGrowArrayIfNeed,
  1749. TCHAR chLeftSpaceFiller)
  1750. {
  1751. ASSERT(nPos >= 0 && pcszText);
  1753. CString* pCStr = GetStrData(nRow, bGrowArrayIfNeed);
  1754. if (!pCStr || !pcszText && nPos < 0)
  1755. {
  1756. return FALSE;
  1757. }
  1759. int nStrLenC = (int)_tcsclen(*pCStr);
  1760. int nFillCount = nPos > nStrLenC ? nPos - nStrLenC : 0;
  1761. int nInsPos = (int)_tcsnbcnt(*pCStr, nPos);
  1763. if (nFillCount)
  1764. {
  1765. if (chLeftSpaceFiller != _T(''))
  1766. {
  1767. CString strFill(chLeftSpaceFiller, nFillCount);
  1768. *pCStr += strFill;
  1769. nInsPos = (int)_tcsnbcnt(*pCStr, nPos);
  1770. }
  1771. else
  1772. {
  1773. nInsPos = pCStr->GetLength();
  1774. }
  1775. }
  1777. INSERT_S(*pCStr, nInsPos, pcszText);
  1778. return TRUE;
  1779. }
  1781. BOOL CXTPSyntaxEditBufferManager::CXTPSyntaxEditStringsManager::
  1782. DeleteText(int nRow, int nPos, int nCount)
  1783. {
  1784. ASSERT(nPos >= 0 && nCount > 0);
  1786. CString* pCStr = GetStrData(nRow, FALSE);
  1787. if (!pCStr || nPos < 0 || nCount <= 0)
  1788. {
  1789. return FALSE;
  1790. }
  1792. int nStrLen0 = pCStr->GetLength();
  1794. int nPosX = (int)_tcsnbcnt(*pCStr, nPos);
  1795. if (nPosX >= nStrLen0)
  1796. {
  1797. return FALSE;
  1798. }
  1800. int nStrLenC = (int)_tcsclen(*pCStr);
  1801. if (nCount > nStrLenC - nPos)
  1802. {
  1803. nCount = nStrLenC - nPos;
  1804. }
  1805. int nCountX = (int)_tcsnbcnt(((LPCTSTR)*pCStr) + nPosX, nCount);
  1807. DELETE_S(*pCStr, nPosX, nCountX);
  1808. return TRUE;
  1809. }
  1811. void CXTPSyntaxEditBufferManager::CXTPSyntaxEditStringsManager::RemoveAllStrs()
  1812. {
  1813. m_arStrings.RemoveAll();
  1814. }
  1816. ////////////////////////////////////////////////////////////////////////////
  1817. //class CStringPtrArray : public CArray<CString*, CString*>
  1818. CXTPSyntaxEditBufferManager::CXTPSyntaxEditStringsManager::
  1819. CStringPtrArray::CStringPtrArray()
  1820. {
  1822. }
  1824. CXTPSyntaxEditBufferManager::CXTPSyntaxEditStringsManager::
  1825. CStringPtrArray::~CStringPtrArray()
  1826. {
  1827. RemoveAll();
  1828. }
  1830. void CXTPSyntaxEditBufferManager::CXTPSyntaxEditStringsManager::
  1831. CStringPtrArray::RemoveAll()
  1832. {
  1833. int nCount = (int)GetSize();
  1834. for (int i = 0; i < nCount; i++)
  1835. {
  1836. CString* pCStr = GetAt(i);
  1837. if (pCStr)
  1838. {
  1839. SetAt(i, NULL);
  1840. delete pCStr;
  1841. }
  1842. }
  1843. TBase::RemoveAll();
  1844. }