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

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

对话框与窗口

开发平台：

Visual C++

XTPSyntaxEditLexColorFileReader.cpp：源码内容
  1. // XTPSyntaxEditLexColorFileReader.cpp: implementation of the CXTLexColorFileReader class.
  2. //
  3. // This file is a part of the XTREME TOOLKIT PRO MFC class library.
  4. // (c)1998-2008 Codejock Software, All Rights Reserved.
  5. //
  6. // THIS SOURCE FILE IS THE PROPERTY OF CODEJOCK SOFTWARE AND IS NOT TO BE
  7. // RE-DISTRIBUTED BY ANY MEANS WHATSOEVER WITHOUT THE EXPRESSED WRITTEN
  8. // CONSENT OF CODEJOCK SOFTWARE.
  9. //
  10. // THIS SOURCE CODE CAN ONLY BE USED UNDER THE TERMS AND CONDITIONS OUTLINED
  11. // IN THE XTREME SYNTAX EDIT LICENSE AGREEMENT. CODEJOCK SOFTWARE GRANTS TO
  12. // YOU (ONE SOFTWARE DEVELOPER) THE LIMITED RIGHT TO USE THIS SOFTWARE ON A
  13. // SINGLE COMPUTER.
  14. //
  15. // CONTACT INFORMATION:
  16. // support@codejock.com
  17. // http://www.codejock.com
  18. //
  19. //////////////////////////////////////////////////////////////////////
  21. #include "stdafx.h"
  23. // common includes
  24. #include "Common/XTPColorManager.h"
  25. #include "Common/XTPNotifyConnection.h"
  26. #include "Common/XTPSmartPtrInternalT.h"
  27. #include "Common/XTPVC80Helpers.h"
  29. // syntax editor includes
  30. #include "XTPSyntaxEditDefines.h"
  31. #include "XTPSyntaxEditStruct.h"
  32. #include "XTPSyntaxEditLexPtrs.h"
  33. #include "XTPSyntaxEditLexClassSubObjT.h"
  34. #include "XTPSyntaxEditTextIterator.h"
  35. #include "XTPSyntaxEditLexCfgFileReader.h"
  36. #include "XTPSyntaxEditLexClassSubObjDef.h"
  37. #include "XTPSyntaxEditLexClass.h"
  38. #include "XTPSyntaxEditLexParser.h"
  39. #include "XTPSyntaxEditSectionManager.h"
  40. #include "XTPSyntaxEditLexColorFileReader.h"
  41. #include "XTPSyntaxEditCtrl.h"
  42. #include "XTPSyntaxEditSectionManager.h"
  44. #ifdef _DEBUG
  45. #define new DEBUG_NEW
  46. #undef THIS_FILE
  47. static char THIS_FILE[] = __FILE__;
  48. #endif
  50. #define XTP_EMPTY_STRING        _T("")
  52. namespace XTPSyntaxEditLexAnalyser
  53. {
  54. extern void AddIfNeed_noCase(CStringArray& rarData, LPCTSTR strNew);
  55. extern BOOL IsEventSet(HANDLE hEvent);
  56. }
  58. //////////////////////////////////////////////////////////////////////
  59. // Construction/Destruction
  60. //////////////////////////////////////////////////////////////////////
  61. using namespace XTPSyntaxEditLexAnalyser;
  63. CXTPSyntaxEditColorInfo::CXTPSyntaxEditColorInfo(CXTPSyntaxEditColorTheme* pTheme) :
  64. m_pTheme(pTheme)
  65. {
  66. }
  68. CXTPSyntaxEditColorInfo::CXTPSyntaxEditColorInfo(const CString& strClassName,
  69.    CXTPSyntaxEditColorTheme* pTheme) :
  70. m_strClassName(strClassName), m_pTheme(pTheme)
  71. {
  72. }
  74. CXTPSyntaxEditColorInfo::~CXTPSyntaxEditColorInfo ()
  75. {
  76. }
  78. void CXTPSyntaxEditColorInfo::AddParam(const CString& strName, const CString& strValue)
  79. {
  80. CString strLowerName(strName);
  81. strLowerName.MakeLower();
  82. // save param-value pair
  83. m_mapParams[strLowerName] = strValue;
  84. }
  86. const CString CXTPSyntaxEditColorInfo::GetParam(const CString& strName,
  87.  BOOL bDynamic)
  88. {
  89. CString strLowerName(strName);
  90. strLowerName.MakeLower();
  92. CString strValue;
  93. if (!m_mapParams.Lookup(strLowerName, strValue) && bDynamic)
  94. {
  95. // do not search parent for main section parameters
  96. if (!m_strClassName.CompareNoCase(XTP_EDIT_LEXPARSER_SECTION_MAIN))
  97. {
  98. return strValue;
  99. }
  100. // try to get value from the parent schema
  101. CXTPSyntaxEditColorTheme* pParentTheme = m_pTheme ? m_pTheme->GetParentTheme() : NULL;
  102. if (m_pTheme && pParentTheme)
  103. {
  104. CXTPSyntaxEditColorInfo* pParentColorInfo = pParentTheme->GetColorInfo(m_strClassName, m_pTheme->GetFileName());
  105. if (pParentColorInfo)
  106. {
  107. strValue = pParentColorInfo->GetParam(strName);
  108. }
  109. }
  110. }
  111. return strValue;
  112. }
  114. DWORD CXTPSyntaxEditColorInfo::GetHexParam(const CString& strName, BOOL bDynamic)
  115. {
  116. // get hex value if exists
  117. DWORD dwHex = 0;
  118. SCANF_S(GetParam(strName, bDynamic), _T("%x"), &dwHex);
  119. return dwHex;
  120. }
  122. POSITION CXTPSyntaxEditColorInfo::GetFirstParamNamePosition()
  123. {
  124. return m_mapParams.GetStartPosition();
  125. }
  127. const CString CXTPSyntaxEditColorInfo::GetNextParamName(POSITION& pos)
  128. {
  129. CString strName, strValue;
  130. m_mapParams.GetNextAssoc(pos, strName, strValue);
  132. return strName;
  133. }
  134. /////////////////////////////////////////////////////////////////////////////
  135. //
  137. CXTPSyntaxEditColorTheme::CXTPSyntaxEditColorTheme(CXTPSyntaxEditColorThemesManager* pThemesManager) :
  138. m_pThemesManager(pThemesManager)
  139. {
  140. }
  142. CXTPSyntaxEditColorTheme::~CXTPSyntaxEditColorTheme()
  143. {
  144. Cleanup();
  145. }
  147. void CXTPSyntaxEditColorTheme::Cleanup()
  148. {
  149. // cleanup color info map
  150. POSITION pos = m_mapLexColorInfo.GetStartPosition();
  151. CString strKey;
  152. CXTPSyntaxEditColorInfo* pInf = NULL;
  153. while (pos != NULL)
  154. {
  155. m_mapLexColorInfo.GetNextAssoc(pos, strKey, pInf);
  156. if (pInf)
  157. delete pInf;
  158. }
  159. m_mapLexColorInfo.RemoveAll();
  160. }
  162. void CXTPSyntaxEditColorTheme::Load(const CString& csFileName)
  163. {
  164. Cleanup();
  165. m_csFileName = csFileName;
  167. // get sections list
  168. CStringArray arSections;
  169. CXTPSyntaxEditSectionManager().GetSectionNames(arSections, m_csFileName);
  171. if (arSections.GetSize() == 0)
  172. return;
  174. for (int i = 0; i < arSections.GetSize(); ++i)
  175. {
  176. CString csSection = arSections[i];
  177. csSection.MakeLower();
  179. CXTPSyntaxEditColorInfo* pOld = m_mapLexColorInfo[csSection];
  180. if (pOld)
  181. {
  182. delete pOld;
  183. }
  184. m_mapLexColorInfo[csSection] = ParseSection(csSection);
  185. }
  186. }
  188. BOOL CXTPSyntaxEditColorTheme::WriteCfgFile(CString strParentThemeName,
  189. CXTPSyntaxEditColorInfoArray* pColorInfoArray_new)
  190. {
  191. if (!pColorInfoArray_new)
  192. {
  193. ASSERT(FALSE);
  194. return FALSE;
  195. }
  196. CString strFileName = GetFileName();
  197. CString strFileName_new = strFileName + _T(".tmp");
  199. ::SetFileAttributes(strFileName_new, FILE_ATTRIBUTE_NORMAL);
  200. ::DeleteFile(strFileName_new);
  202. if (!::CopyFile(strFileName, strFileName_new,  FALSE))
  203. {
  204. TRACE(_T("ERROR! CXTPSyntaxEditColorTheme::WriteCfgFile() - Cannot copy file '%s' to '%s' n"), (LPCTSTR)strFileName, (LPCTSTR)strFileName_new);
  205. return FALSE;
  206. }
  208. CMapStringToPtr mapSaved_ClsProp;
  209. const CString cstrCNDelim = _T("-xtpEdit_ColorThemeClassPropDelimeter_xtpEdit-");
  210. void* pVoid = NULL;
  212. //---------------------------------------------------------------------------
  214. // (0) Update main section - parent schema property
  215. LPCTSTR pcszString = NULL;
  216. if (!strParentThemeName.IsEmpty())
  217. {
  218. pcszString = strParentThemeName;
  219. }
  220. BOOL bRes = ::WritePrivateProfileString(XTP_EDIT_LEXPARSER_SECTION_MAIN, XTP_EDIT_LEXPARSER_PARENT_SCHEMA,
  221. pcszString, strFileName_new);
  223. CString strSavedKey = XTP_EDIT_LEXPARSER_SECTION_MAIN + cstrCNDelim + XTP_EDIT_LEXPARSER_PARENT_SCHEMA;
  224. strSavedKey.MakeLower();
  225. ASSERT(mapSaved_ClsProp.Lookup(strSavedKey, pVoid) == FALSE);
  226. mapSaved_ClsProp.SetAt(strSavedKey, NULL);
  227. BOOL bClassPropRepeated_DbgAssertWas = FALSE;
  229. if (!bRes)
  230. {
  231. return FALSE;
  232. }
  234. // (1) Update Existing and add new properties
  235. int nCount = (int)pColorInfoArray_new->GetSize();
  236. for (int i = 0; i < nCount; i++)
  237. {
  238. CXTPSyntaxEditColorInfo* pClrInf_new = pColorInfoArray_new->GetAt(i);
  239. if (!pClrInf_new)
  240. {
  241. ASSERT(FALSE);
  242. continue;
  243. }
  244. CString csSection = pClrInf_new->GetClassName();
  246. POSITION posParam = pClrInf_new->GetFirstParamNamePosition();
  247. while (posParam)
  248. {
  249. CString strPrmName = pClrInf_new->GetNextParamName(posParam);
  250. CString strPrmValue = pClrInf_new->GetParam(strPrmName,  FALSE);
  252. if (!strPrmName.IsEmpty() && !strPrmValue.IsEmpty())
  253. {
  254. bRes = ::WritePrivateProfileString(csSection, strPrmName,
  255. strPrmValue, strFileName_new);
  256. if (!bRes)
  257. {
  258. return FALSE;
  259. }
  260. strSavedKey = csSection + cstrCNDelim + strPrmName;
  261. strSavedKey.MakeLower();
  263. if (mapSaved_ClsProp.Lookup(strSavedKey, pVoid))
  264. {
  265. if (!bClassPropRepeated_DbgAssertWas)
  266. {
  267. ASSERT(FALSE);
  268. bClassPropRepeated_DbgAssertWas = TRUE;
  269. }
  270. TRACE(_T("WARNING! Color theme class property repeated: %s->%s. n"), (LPCTSTR)csSection, (LPCTSTR)strPrmName);
  271. }
  273. mapSaved_ClsProp.SetAt(strSavedKey, NULL);
  274. }
  275. }
  276. }
  278. //===========================================================================
  279. // (2) Remove old properties
  280. POSITION posClrInfo_old = m_mapLexColorInfo.GetStartPosition();
  281. CString strClassName;
  282. CXTPSyntaxEditColorInfo* pClrInf_old = NULL;
  283. while (posClrInfo_old)
  284. {
  285. m_mapLexColorInfo.GetNextAssoc(posClrInfo_old, strClassName, pClrInf_old);
  287. if (!pClrInf_old)
  288. {
  289. ASSERT(FALSE);
  290. continue;
  291. }
  293. CString csSection = pClrInf_old->GetClassName();
  295. POSITION posParam = pClrInf_old->GetFirstParamNamePosition();
  296. while (posParam)
  297. {
  298. CString strPrmName = pClrInf_old->GetNextParamName(posParam);
  300. strSavedKey = csSection + cstrCNDelim + strPrmName;
  301. strSavedKey.MakeLower();
  303. if (!mapSaved_ClsProp.Lookup(strSavedKey, pVoid))
  304. {
  305. VERIFY( ::WritePrivateProfileString(csSection, strPrmName,
  306. NULL, strFileName_new) );
  307. }
  308. }
  309. }
  311. //===========================================================================
  312. CString strFileName_prev = strFileName + _T(".old");
  313. ::SetFileAttributes(strFileName_prev, FILE_ATTRIBUTE_NORMAL);
  314. ::DeleteFile(strFileName_prev);
  316. #ifdef _DEBUG
  317. //::MoveFile(strFileName, strFileName_prev);
  318. #endif
  320. ::SetFileAttributes(strFileName, FILE_ATTRIBUTE_NORMAL);
  321. ::DeleteFile(strFileName);
  323. if (!::MoveFile(strFileName_new, strFileName))
  324. {
  325. TRACE(_T("ERROR! CXTPSyntaxEditColorTheme::WriteCfgFile() - Cannot rename file '%s' to '%s' n"), (LPCTSTR)strFileName_new, (LPCTSTR)strFileName);
  326. return FALSE;
  327. }
  329. return TRUE;
  330. }
  332. CXTPSyntaxEditColorInfo* CXTPSyntaxEditColorTheme::ParseSection(const CString& csSection)
  333. {
  334. CXTPSyntaxEditColorInfo* pColorInfo = new CXTPSyntaxEditColorInfo(csSection, this);
  336. CXTPSyntaxEditSchemaFileInfoList infoList;
  337. CXTPSyntaxEditSectionManager().GetSectionKeyList(infoList, m_csFileName, csSection);
  339. for (POSITION pos = infoList.GetHeadPosition(); pos;)
  340. {
  341. XTP_EDIT_SCHEMAFILEINFO& info = infoList.GetNext(pos);
  342. pColorInfo->AddParam(info.csName, info.csValue);
  343. }
  345. return pColorInfo;
  346. }
  348. const CString CXTPSyntaxEditColorTheme::GetParentThemeName()
  349. {
  350. CXTPSyntaxEditColorInfo* pInfo = NULL;
  351. if (m_mapLexColorInfo.Lookup(XTP_EDIT_LEXPARSER_SECTION_MAIN, pInfo) && pInfo)
  352. {
  353. return pInfo->GetParam(XTP_EDIT_LEXPARSER_PARENT_SCHEMA);
  354. }
  355. return _T("");
  356. }
  358. CXTPSyntaxEditColorTheme* CXTPSyntaxEditColorTheme::GetParentTheme()
  359. {
  360. return m_pThemesManager ? m_pThemesManager->GetTheme(GetParentThemeName()) : NULL;
  361. }
  363. CXTPSyntaxEditColorInfo* CXTPSyntaxEditColorTheme::GetColorInfo(
  364. const CString& strLexClass,
  365. const CString& strThemeFilename,
  366. BOOL bDynamic)
  367. {
  368. CXTPSyntaxEditColorInfo* pInfo = NULL;
  369. CString strLexClass_lower = strLexClass;
  370. strLexClass_lower.MakeLower();
  371. if (!m_mapLexColorInfo.Lookup(strLexClass_lower, pInfo) && bDynamic)
  372. {
  373. // lookup color info on parent themes
  374. CXTPSyntaxEditColorTheme* pParentTheme = GetParentTheme();
  375. if (pParentTheme && pParentTheme->GetFileName().CompareNoCase(strThemeFilename))
  376. {
  377. pInfo = pParentTheme->GetColorInfo(strLexClass_lower, strThemeFilename, TRUE);
  378. }
  379. }
  380. return pInfo;
  381. }
  383. /////////////////////////////////////////////////////////////////////////////
  384. // CXTPSyntaxEditColorThemesManager
  386. CXTPSyntaxEditColorThemesManager::CXTPSyntaxEditColorThemesManager()
  387. {
  388. }
  390. CXTPSyntaxEditColorThemesManager::~CXTPSyntaxEditColorThemesManager()
  391. {
  392. RemoveAll();
  393. }
  395. void CXTPSyntaxEditColorThemesManager::LoadTheme(const CString& strThemeName,
  396. const CString& strThemeFilename)
  397. {
  398. // delete old theme
  399. CXTPSyntaxEditColorTheme* pTheme = NULL;
  400. if (m_mapThemes.Lookup(strThemeName, pTheme) && pTheme)
  401. {
  402. delete pTheme;
  403. // delete its name
  404. for (int i = 0; i < m_arThemeNames.GetSize(); i++)
  405. {
  406. if (!m_arThemeNames.GetAt(i).CompareNoCase(strThemeName))
  407. {
  408. m_arThemeNames.RemoveAt(i);
  409. break;
  410. }
  411. }
  412. }
  414. // create and load new theme
  415. pTheme = new CXTPSyntaxEditColorTheme(this);
  416. pTheme->Load(strThemeFilename);
  418. m_mapThemes[strThemeName] = pTheme;
  419. m_arThemeNames.Add(strThemeName);
  421. CString strTFNameLower = strThemeFilename;
  422. strTFNameLower.MakeLower();
  423. m_mapFileToTheme[strTFNameLower] = strThemeName;
  424. }
  426. void CXTPSyntaxEditColorThemesManager::AddThemeInfo(const CString& strThemeName,
  427.    const CString& strThemeFilename)
  428. {
  429. CString strTFNameLower = strThemeFilename;
  430. strTFNameLower.MakeLower();
  432. m_mapFileToTheme[strTFNameLower] = strThemeName;
  433. }
  435. CXTPSyntaxEditColorTheme* CXTPSyntaxEditColorThemesManager::GetTheme(const CString& strThemeName)
  436. {
  437. CXTPSyntaxEditColorTheme* pTheme = NULL;
  438. m_mapThemes.Lookup(strThemeName, pTheme);
  439. return pTheme;
  440. }
  442. CStringArray& CXTPSyntaxEditColorThemesManager::GetThemes()
  443. {
  444. return m_arThemeNames;
  445. }
  447. CString CXTPSyntaxEditColorThemesManager::ReloadFile(const CString& csFileName,
  448. int nCfgFlags)
  449. {
  450. CString strThemeName;
  451. // iterate all themes
  452. POSITION pos = m_mapThemes.GetStartPosition();
  453. CString strKey;
  454. CXTPSyntaxEditColorTheme* pTheme = NULL;
  455. while (pos != NULL)
  456. {
  457. m_mapThemes.GetNextAssoc(pos, strKey, pTheme);
  458. if (pTheme && !pTheme->GetFileName().CompareNoCase(csFileName))
  459. {
  460. strThemeName = strKey;
  461. if (nCfgFlags & xtpEditCfgFileRemove)
  462. {
  463. delete pTheme;
  464. m_mapThemes.RemoveKey(strKey);
  465. }
  466. else
  467. {
  468. pTheme->Load(csFileName);
  469. }
  470. return strThemeName;
  471. }
  472. }
  474. //------------------------------------------------------------------------
  475. if (nCfgFlags & xtpEditCfgFileAdd)
  476. {
  477. CString strTFileLower = csFileName;
  478. strTFileLower.MakeLower();
  480. if (m_mapFileToTheme.Lookup(strTFileLower, strThemeName))
  481. {
  482. LoadTheme(strThemeName, csFileName);
  483. }
  484. else
  485. {
  486. strThemeName.Empty();
  487. //ASSERT(FALSE);
  488. }
  489. }
  491. //------------------------------------------------------------------------
  492. return strThemeName;
  493. }
  495. void CXTPSyntaxEditColorThemesManager::RemoveAll()
  496. {
  497. m_arThemeNames.RemoveAll();
  498. m_mapFileToTheme.RemoveAll();
  500. // cleanup themes map
  501. POSITION pos = m_mapThemes.GetStartPosition();
  502. CString strKey;
  503. CXTPSyntaxEditColorTheme* pTheme = NULL;
  504. while (pos != NULL)
  505. {
  506. m_mapThemes.GetNextAssoc(pos, strKey, pTheme);
  507. if (pTheme)
  508. delete pTheme;
  509. }
  510. m_mapThemes.RemoveAll();
  511. }
  512. /////////////////////////////////////////////////////////////////////////////
  513. // CXTPSyntaxEditTextSchemesManager
  515. CXTPSyntaxEditTextSchemesManager::CXTPSyntaxEditTextSchemesManager()
  516. {
  517. }
  519. CXTPSyntaxEditTextSchemesManager::~CXTPSyntaxEditTextSchemesManager()
  520. {
  521. }
  523. void CXTPSyntaxEditTextSchemesManager::LoadTextScheme(XTP_EDIT_SCHEMAFILEINFO& info)
  524. {
  525. CString strSchemeNameLower(info.csName);
  526. strSchemeNameLower.MakeLower();
  528. CSingleLock lockReadFile(&m_csReadFile,  TRUE);
  530. if (info.uValue != (UINT)-1)
  531. XTPSyntaxEditLexConfig()->ReadSource(info.uValue);
  532. else
  533. XTPSyntaxEditLexConfig()->ReadSource(info.csValue, TRUE);
  535. CXTPSyntaxEditLexClassInfoArray& arLexClassInfo = XTPSyntaxEditLexConfig()->GetLexClassInfoArray();
  536. CXTPSyntaxEditTextSchemaPtr ptrTxtSch(new CXTPSyntaxEditTextSchema(info.csName));
  537. if (ptrTxtSch)
  538. {
  539. ptrTxtSch->LoadClassSchema(&arLexClassInfo);
  541. m_mapSchemes[strSchemeNameLower] = ptrTxtSch;
  543. AddTextSchemeInfo(info);
  544. }
  545. }
  547. void CXTPSyntaxEditTextSchemesManager::AddTextSchemeInfo(XTP_EDIT_SCHEMAFILEINFO& info)
  548. {
  549. if (GetSchemaFileName(info.csName).IsEmpty())
  550. m_listSchemes.AddHead(info);
  551. XTPSyntaxEditLexAnalyser::AddIfNeed_noCase(m_arSchemeNames, info.csName);
  552. }
  554. CXTPSyntaxEditTextSchemaPtr CXTPSyntaxEditTextSchemesManager::GetSchema(const CString& strSchemeName)
  555. {
  556. CString strSchemeNameLower(strSchemeName);
  557. strSchemeNameLower.MakeLower();
  559. CXTPSyntaxEditTextSchemaPtr ptrScheme;
  560. m_mapSchemes.Lookup(strSchemeNameLower, ptrScheme);
  561. return ptrScheme;
  562. }
  564. CXTPSyntaxEditTextSchemaPtr CXTPSyntaxEditTextSchemesManager::FindSchema(const CString& strFileExt)
  565. {
  566. // iterate all text schemes
  567. CString strSchemaName;
  568. CXTPSyntaxEditTextSchemaPtr ptrScheme;
  570. if (!strFileExt.IsEmpty())
  571. {
  572. POSITION pos = m_mapSchemes.GetStartPosition();
  573. while (pos != NULL)
  574. {
  575. m_mapSchemes.GetNextAssoc(pos, strSchemaName, ptrScheme);
  576. if (ptrScheme && ptrScheme->IsFileExtSupported(strFileExt))
  577. {
  578. return ptrScheme;
  579. }
  580. }
  581. }
  582. return NULL;
  583. }
  585. void CXTPSyntaxEditTextSchemesManager::SetTheme(CXTPSyntaxEditColorTheme* pTheme)
  586. {
  587. // iterate all text schemes
  588. CString strSchemaName;
  589. CXTPSyntaxEditTextSchemaPtr ptrScheme;
  590. POSITION pos = m_mapSchemes.GetStartPosition();
  591. while (pos != NULL)
  592. {
  593. m_mapSchemes.GetNextAssoc(pos, strSchemaName, ptrScheme);
  594. if (ptrScheme)
  595. {
  596. ptrScheme->ApplyTheme(pTheme);
  597. }
  598. }
  599. }
  601. const CString CXTPSyntaxEditTextSchemesManager::GetSchemaName(const CString& csFileName)
  602. {
  603. XTP_EDIT_SCHEMAFILEINFO info;
  604. if (m_listSchemes.LookupValue(csFileName, info))
  605. {
  606. return info.csName;
  607. }
  608. return _T("");
  609. }
  611. const CString CXTPSyntaxEditTextSchemesManager::GetSchemaFileName(const CString& strSchemeName)
  612. {
  613. XTP_EDIT_SCHEMAFILEINFO info;
  614. if (m_listSchemes.LookupName(strSchemeName, info))
  615. {
  616. return info.csValue;
  617. }
  619. return _T("");
  620. }
  622. BOOL CXTPSyntaxEditTextSchemesManager::ReloadFile(const CString& csFileName, int nCfgFlags)
  623. {
  624. XTP_EDIT_SCHEMAFILEINFO info;
  625. if (m_listSchemes.LookupValue(csFileName, info))
  626. {
  627. CString csSchemaName = info.csName;
  628. csSchemaName.MakeLower();
  629. m_mapSchemes.RemoveKey(csSchemaName);
  631. if ((nCfgFlags & xtpEditCfgFileRemove) == 0)
  632. {
  633. LoadTextScheme(info);
  634. }
  636. return TRUE;
  637. }
  639. return FALSE;
  640. }
  642. void CXTPSyntaxEditTextSchemesManager::RemoveAll()
  643. {
  644. m_mapSchemes.RemoveAll();
  645. m_listSchemes.RemoveAll();
  646. m_arSchemeNames.RemoveAll();
  647. }
  650. /////////////////////////////////////////////////////////////////////////////
  651. // CXTPSyntaxEditConfigurationManager
  653. CXTPSyntaxEditConfigurationManager::CXTPSyntaxEditConfigurationManager()
  654. {
  655. m_pConnectMT = new CXTPNotifyConnectionMT();
  656. m_hReloadThread = NULL;
  657. m_pBreakReloadEvent = NULL;
  659. m_strCurrentThemeName = XTP_EDIT_LEXPARSER_DEFTHEME;
  660. m_FolderMonitor.SetConfigurationManager(this);
  662. }
  664. CXTPSyntaxEditConfigurationManager::~CXTPSyntaxEditConfigurationManager()
  665. {
  666. Close();
  668. CMDTARGET_RELEASE(m_pConnectMT);
  669. }
  671. void CXTPSyntaxEditConfigurationManager::Close()
  672. {
  673. m_FolderMonitor.StopMonitoring();
  675. if (m_hReloadThread)
  676. {
  677. ASSERT(m_pBreakReloadEvent);
  678. if (m_pBreakReloadEvent)
  679. {
  680. m_pBreakReloadEvent->SetEvent();
  681. }
  682. DWORD dwThreadRes = ::WaitForSingleObject(m_hReloadThread, 30*1000);
  684. if (dwThreadRes == WAIT_TIMEOUT)
  685. {
  686. ::TerminateThread(m_hReloadThread, 0);
  687. TRACE(_T("ERROR! Configuration Manager reload thread was not ended by normal way. It was terminated. n"));
  688. }
  689. }
  690. m_hReloadThread = NULL;
  692. if (m_pBreakReloadEvent)
  693. {
  694. delete m_pBreakReloadEvent;
  695. m_pBreakReloadEvent = NULL;
  696. }
  698. m_FolderMonitor.StopMonitoring();
  700. m_ColorThemeManager.RemoveAll();
  701. m_TextSchemesManager.RemoveAll();
  702. }
  704. CString CXTPSyntaxEditConfigurationManager::GetConfigFile() const
  705. {
  706. return m_strMainIniFilename;
  707. }
  709. void CXTPSyntaxEditConfigurationManager::ReloadConfig(const CString& strConfigFilePath)
  710. {
  711. CSingleLock singleLock(&m_DataLockerCS, TRUE);
  713. m_strMainIniFilename = strConfigFilePath;
  714. ReloadConfig();
  715. }
  717. void CXTPSyntaxEditConfigurationManager::ReloadConfig()
  718. {
  719. CSingleLock singleLock(&m_DataLockerCS, TRUE);
  721. TRACE(_T("LOAD/reload configuration: %s n"), (LPCTSTR)m_strMainIniFilename);
  722. // restart folder monitor
  723. m_FolderMonitor.StopMonitoring();
  725. // Remove previous data
  726. m_ColorThemeManager.RemoveAll();
  727. m_TextSchemesManager.RemoveAll();
  729. if (!m_FolderMonitor.AddMonitorFile(m_strMainIniFilename, xtpEditCfgObjMainConfig))
  730. {
  731. m_pConnectMT->SendEvent(xtpEditAllConfigWasChanged, 0, 0);
  733. // start monitoring config files
  734. m_FolderMonitor.StartMonitoring();
  736. return;
  737. }
  739. CString strMainIniFolder;
  740. int nFLs = m_strMainIniFilename.ReverseFind(_T('\'));
  741. if (nFLs > 0)
  742. {
  743. strMainIniFolder = m_strMainIniFilename.Mid(0, nFLs + 1);
  744. }
  746. m_FolderMonitor.SetDefaultFolder(strMainIniFolder);
  748. CXTPSyntaxEditSchemaFileInfoList listThemes;
  749. CXTPSyntaxEditSectionManager().GetSectionKeyList(listThemes, m_strMainIniFilename, XTP_EDIT_LEXPARSER_SECTION_THEMES);
  751. for (POSITION posThemes = listThemes.GetHeadPosition(); posThemes;)
  752. {
  753. XTP_EDIT_SCHEMAFILEINFO& info = listThemes.GetNext(posThemes);
  755. if (m_hReloadThread && m_pBreakReloadEvent)
  756. {
  757. if (XTPSyntaxEditLexAnalyser::IsEventSet(*m_pBreakReloadEvent))
  758. {
  759. TRACE(_T("BREAK config reloading. n"));
  760. return;
  761. }
  762. }
  764. TRACE(_T("LOAD Theme: %s - %sn"), (LPCTSTR)info.csName, (LPCTSTR)info.csValue);
  766. if (m_FolderMonitor.AddMonitorFile(info.csValue, xtpEditCfgObjThemeMan))
  767. {
  768. m_ColorThemeManager.LoadTheme(info.csName, info.csValue);
  769. }
  770. else
  771. {
  772. m_ColorThemeManager.AddThemeInfo(info.csName, info.csValue);
  773. }
  774. }
  776. // load all schemes config files
  778. CXTPSyntaxEditSchemaFileInfoList listSchemes;
  779. CXTPSyntaxEditSectionManager().GetSectionKeyList(listSchemes, m_strMainIniFilename, XTP_EDIT_LEXPARSER_SECTION_SCHEMES);
  781. for (POSITION posSchemes = listSchemes.GetHeadPosition(); posSchemes;)
  782. {
  783. XTP_EDIT_SCHEMAFILEINFO& info = listSchemes.GetNext(posSchemes);
  785. if (m_hReloadThread && m_pBreakReloadEvent)
  786. {
  787. if (XTPSyntaxEditLexAnalyser::IsEventSet(*m_pBreakReloadEvent))
  788. {
  789. TRACE(_T("BREAK config reloading. n"));
  790. return;
  791. }
  792. }
  794. TRACE(_T("LOAD Scheme: %s - %sn"), (LPCTSTR)info.csName, (LPCTSTR)info.csValue);
  796. if (m_FolderMonitor.AddMonitorFile(info.csValue, xtpEditCfgObjSchMan))
  797. {
  798. m_TextSchemesManager.LoadTextScheme(info);
  799. }
  800. else
  801. {
  802. m_TextSchemesManager.AddTextSchemeInfo(info);
  803. }
  804. }
  806. // set default theme
  807. SetTheme(m_strCurrentThemeName);
  809. //========================================================================
  810. if (m_hReloadThread && m_pBreakReloadEvent)
  811. {
  812. if (XTPSyntaxEditLexAnalyser::IsEventSet(*m_pBreakReloadEvent))
  813. {
  814. TRACE(_T("BREAK config reloading. n"));
  815. return;
  816. }
  817. }
  818. //========================================================================
  820. m_pConnectMT->SendEvent(xtpEditAllConfigWasChanged, 0, 0);
  822. // start monitoring config files
  823. m_FolderMonitor.StartMonitoring();
  824. }
  826. void CXTPSyntaxEditConfigurationManager::ReloadFile(CString csFileName,
  827.    DWORD dwOwnerFlags,
  828.    int nCfgFlags)
  829. {
  830. CSingleLock singleLock(&m_DataLockerCS, TRUE);
  832. CString strItemName;
  834. // if file is color theme definition
  835. if ((dwOwnerFlags & xtpEditCfgObjThemeMan) || dwOwnerFlags == 0)
  836. {
  837. TRACE(_T("Reload Theme: %s n"), (LPCTSTR)csFileName);
  839. strItemName = m_ColorThemeManager.ReloadFile(csFileName, nCfgFlags);
  840. if (!strItemName.IsEmpty())
  841. {
  842. // Re-apply current theme after reloading
  843. if (!strItemName.CompareNoCase(m_strCurrentThemeName))
  844. {
  845. SetTheme(m_strCurrentThemeName);
  846. }
  848. CXTPSyntaxEditColorTheme* pTheme = m_ColorThemeManager.GetTheme(strItemName);
  849. m_pConnectMT->SendEvent(xtpEditThemeWasChanged,
  850. (WPARAM)(LPCTSTR)strItemName, (LPARAM)pTheme);
  851. return;
  852. }
  853. }
  855. // if file is lex text schema definition
  856. if ((dwOwnerFlags & xtpEditCfgObjSchMan) || dwOwnerFlags == 0)
  857. {
  858. TRACE(_T("Reload Scheme: %s n"), (LPCTSTR)csFileName);
  860. if (m_TextSchemesManager.ReloadFile(csFileName, nCfgFlags))
  861. {
  862. CString strSchName = m_TextSchemesManager.GetSchemaName(csFileName);
  863. CXTPSyntaxEditTextSchemaPtr ptrTxtSch;
  864. ptrTxtSch = m_TextSchemesManager.GetSchema(strSchName);
  866. CXTPSyntaxEditColorTheme* pTheme = m_ColorThemeManager.GetTheme(m_strCurrentThemeName);
  867. if (pTheme && ptrTxtSch)
  868. {
  869. ptrTxtSch->ApplyTheme(pTheme);
  870. }
  872. m_pConnectMT->SendEvent(xtpEditClassSchWasChanged, (WPARAM)(LPCTSTR)strSchName,
  873. (LPARAM)(CXTPSyntaxEditTextSchema*)ptrTxtSch);
  874. return;
  875. }
  876. }
  878. // else - file is the main schema definition
  879. if ((dwOwnerFlags & xtpEditCfgObjMainConfig) || dwOwnerFlags == 0)
  880. {
  881. ReloadConfigAsync();
  882. }
  883. }
  887. void CXTPSyntaxEditConfigurationManager::SetTheme(const CString& strThemeName,
  888.  CXTPSyntaxEditTextSchema* pActiveSch)
  889. {
  890. CSingleLock singleLock(&m_DataLockerCS, TRUE);
  892. CXTPSyntaxEditColorTheme* pTheme = m_ColorThemeManager.GetTheme(strThemeName);
  893. //if (!pTheme) {
  894. //  return;
  895. //}
  897. m_strCurrentThemeName = strThemeName;
  899. m_TextSchemesManager.SetTheme(pTheme);
  901. if (pActiveSch)
  902. {
  903. pActiveSch->ApplyTheme(pTheme);
  904. }
  905. }
  907. void CXTPSyntaxEditConfigurationManager::ReloadConfigAsync(int nAsyncThreadPriority)
  908. {
  909. InternalAddRef();
  911. CSingleLock singleLock(&m_DataLockerCS, TRUE);
  912. ASSERT(m_pBreakReloadEvent == NULL);
  913. m_pBreakReloadEvent = new CEvent(FALSE, TRUE);
  915. CWinThread* pThread = AfxBeginThread(ReloadConfigAsync_Proc, this, nAsyncThreadPriority);
  916. if (pThread)
  917. {
  918. ASSERT(m_hReloadThread == NULL);
  919. m_hReloadThread = pThread->m_hThread;
  920. }
  921. else
  922. {
  923. if (m_pBreakReloadEvent)
  924. {
  925. delete m_pBreakReloadEvent;
  926. m_pBreakReloadEvent = NULL;
  927. }
  928. }
  929. }
  931. UINT CXTPSyntaxEditConfigurationManager::ReloadConfigAsync_Proc(LPVOID pThis)
  932. {
  933. CXTPSyntaxEditConfigurationManager* pMan = (CXTPSyntaxEditConfigurationManager*)pThis;
  934. ASSERT(pMan);
  935. if (pMan)
  936. {
  937. pMan->ReloadConfig();
  939. pMan->m_hReloadThread = NULL;
  940. pMan->InternalRelease();
  941. }
  942. return 0;
  943. }