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

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

对话框与窗口

开发平台：

Visual C++

XTPPropExchange.cpp：源码内容
  1. // XTPPropExchange.cpp: implementation of the CXTPPropExchange 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 TOOLKIT PRO 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 "XTPMacros.h"
  23. #include "XTPPropExchange.h"
  24. #include "XTPVC80Helpers.h"
  25. #include "XTPVC50Helpers.h"
  26. #include "XTPResourceManager.h"
  28. #ifdef _DEBUG
  29. #undef THIS_FILE
  30. static char THIS_FILE[] = __FILE__;
  31. #define new DEBUG_NEW
  32. #endif
  34. #pragma warning(disable : 4310)
  36. #ifdef _UNICODE
  37. #define CT2BSTR(x) (BSTR)(LPCWSTR)x
  38. #else
  39. #define CT2BSTR(x) (BSTR)XTP_CT2CW(x)
  40. #endif
  42. enum VARTYPE_EX
  43. {
  44. VT_EX_RECT = 100,
  45. VT_EX_SIZE = 101
  46. };
  48. LCID CXTPPropExchange::m_lcidDateTime = XTP_LOCALE_ISO8601;
  50. /////////////////////////////////////////////////////////////////////////////
  51. BOOL ParseDateTimeISO8601(COleDateTime& rDT, LPCTSTR pcszDateTime)
  52. {
  53. SYSTEMTIME st;
  54. ZeroMemory(&st, sizeof(SYSTEMTIME));
  56. int nResult = SCANF_S(pcszDateTime, _T("%hu-%hu-%huT%hu:%hu:%hu"),
  57. &st.wYear, &st.wDay, &st.wMonth, &st.wHour, &st.wMinute, &st.wSecond);
  59. if (nResult == 3 || nResult == 5 || nResult == 6)
  60. {
  61. COleDateTime dtTemp(st);
  62. if (dtTemp.GetStatus() != COleDateTime::valid)
  63. return FALSE;
  65. rDT = dtTemp;
  66. return TRUE;
  67. }
  69. ZeroMemory(&st, sizeof(SYSTEMTIME));
  71. nResult = SCANF_S(pcszDateTime, _T("%hu:%hu:%hu"),
  72. &st.wHour, &st.wMinute, &st.wSecond);
  74. if (nResult == 2 || nResult == 3)
  75. {
  76. double dblTime = (((long)st.wHour * 3600L) +  // hrs in seconds
  77. ((long)st.wMinute * 60L) +  // mins in seconds
  78. ((long)st.wSecond)) / 86400.;
  80. rDT = dblTime;
  81. return TRUE;
  82. }
  84. return FALSE;
  85. }
  87. CString FormatDateTimeISO8601(const COleDateTime& dt)
  88. {
  89. ASSERT(dt.m_status == COleDateTime::valid);
  91. CString strValue;
  93. if ((DWORD)dt == 0)
  94. {
  95. strValue = dt.Format(_T("%H:%M:%S"));
  96. }
  97. else if ((double)(DWORD)(dt) == (double)dt)
  98. {
  99. strValue = dt.Format(_T("%Y-%d-%m"));
  100. }
  101. else
  102. {
  103. strValue = dt.Format(_T("%Y-%d-%mT%H:%M:%S"));
  104. }
  106. return strValue;
  107. }
  108. //////////////////////////////////////////////////////////////////////////
  109. // CXTPPropExchangeEnumerator
  111. CXTPPropExchangeEnumerator::CXTPPropExchangeEnumerator(CXTPPropExchange* pContainer, LPCTSTR lpszSection)
  112. {
  113. m_pContainer = pContainer;
  114. m_strSectionName = lpszSection;
  115. m_nCount = 0;
  116. }
  118. CXTPPropExchangeEnumerator::~CXTPPropExchangeEnumerator()
  119. {
  121. }
  123. POSITION CXTPPropExchangeEnumerator::GetPosition(DWORD dwCount /*= 0*/, BOOL bCompactMode /*= TRUE*/)
  124. {
  125. m_nCount = dwCount;
  127. if (!m_pContainer)
  128. return NULL;
  130. if (!bCompactMode)
  131. {
  132. PX_DWord(m_pContainer, _T("Count"), m_nCount, 0);
  133. }
  134. else
  135. {
  136. if (m_pContainer->IsStoring())
  137. m_pContainer->WriteCount(m_nCount);
  138. else
  139. m_nCount = m_pContainer->ReadCount();
  140. }
  142. return m_nCount == 0 ? NULL : (POSITION)1;
  143. }
  145. CXTPPropExchange* CXTPPropExchangeEnumerator::GetNext(POSITION& pos)
  146. {
  147. CString strSection;
  148. strSection.Format(_T("%s%i"), (LPCTSTR)m_strSectionName, (DWORD)(DWORD_PTR)pos - 1);
  150. CXTPPropExchange* pSection = m_pContainer->GetSection(strSection);
  152. pos++;
  153. if ((DWORD)(DWORD_PTR)pos > m_nCount) pos = NULL;
  155. return pSection;
  156. }
  158. //////////////////////////////////////////////////////////////////////
  159. // Construction/Destruction
  160. //////////////////////////////////////////////////////////////////////
  162. IMPLEMENT_DYNAMIC(CXTPPropExchange, CCmdTarget)
  164. CXTPPropExchange::CXTPPropExchange()
  165. {
  166. m_bLoading = FALSE;
  167. m_dwData = 0;
  168. m_pOwner = NULL;
  169. m_nSchema = _XTP_SCHEMA_CURRENT;
  170. m_bChildSection = FALSE;
  171. m_bInitialized = FALSE;
  172. m_bEmptySection = FALSE;
  173. m_bUseDefaultOnLoad = TRUE;
  174. m_bUseDefaultOnSave = TRUE;
  176. }
  178. CXTPPropExchange::~CXTPPropExchange()
  179. {
  181. }
  183. void CXTPPropExchange::InitSection(CXTPPropExchange* pRootSection)
  184. {
  185. ASSERT(m_bLoading == pRootSection->m_bLoading);
  187. m_bChildSection = TRUE;
  188. m_nSchema = pRootSection->m_nSchema;
  189. m_dwData = pRootSection->m_dwData;
  190. m_bEmptySection = pRootSection->m_bEmptySection;
  191. m_bUseDefaultOnLoad = pRootSection->m_bUseDefaultOnLoad;
  192. m_bUseDefaultOnSave = pRootSection->m_bUseDefaultOnSave;
  193. }
  197. void CXTPPropExchange::EmptySection()
  198. {
  199. m_bEmptySection = TRUE;
  200. }
  203. DWORD CXTPPropExchange::GetSizeOfVarType(VARTYPE vt)
  204. {
  205. switch (vt)
  206. {
  207. case VT_BOOL: return sizeof(BOOL);
  208. case VT_UI1: return sizeof(BYTE);
  209. case VT_I2: return 2;
  210. case VT_I4: return 4;
  211. case VT_R4:
  212. ASSERT(sizeof(float) == 4);
  213. return 4;
  214. case VT_R8:
  215. ASSERT(sizeof(double) == 8);
  216. return 8;
  217. case VT_EX_RECT: return sizeof(RECT);
  218. case VT_EX_SIZE: return sizeof(SIZE);
  219. case VT_CY: return sizeof(CURRENCY);
  220. case VT_BSTR:return sizeof(BSTR);
  221. case VT_VARIANT: return sizeof(VARIANT);
  222. case VT_DATE: return sizeof(COleDateTime);
  223. }
  225. return 0;
  226. }
  228. void CXTPPropExchange::Write (LPCTSTR pszPropName, const void* lpBuf, UINT nCount)
  229. {
  230. ASSERT(IsStoring());
  231. ASSERT(lpBuf != NULL);
  232. ExchangeBlobProp(pszPropName, (BYTE*&)lpBuf, (DWORD&)nCount);
  233. }
  235. UINT CXTPPropExchange::Read (LPCTSTR pszPropName, void* lpBuf, UINT nCount)
  236. {
  237. ASSERT(IsLoading());
  238. ASSERT(lpBuf != NULL);
  239. if (!ExchangeBlobProp(pszPropName, (BYTE*&)lpBuf, (DWORD&)nCount))
  240. return 0;
  242. return nCount;
  243. }
  245. AFX_INLINE int REPLACEW_S(BSTR& strReplace, LPCWSTR lpszOld, LPCWSTR lpszNew)
  246. {
  247. int nOldLength = (strReplace == NULL) ? 0 : (int)wcslen(strReplace);
  248. int nSourceLen = (lpszOld == NULL) ? 0 : (int)wcslen(lpszOld);
  250. if (nSourceLen == 0 || nOldLength == 0)
  251. return 0;
  253. int nReplacementLen = (lpszNew == NULL) ? 0 : (int)wcslen(lpszNew);
  255. // loop once to figure out the size of the result string
  256. int nCount = 0;
  257. LPWSTR lpszStart = strReplace;
  258. LPWSTR lpszTarget;
  260. while ((lpszTarget = wcsstr(lpszStart, lpszOld)) != NULL)
  261. {
  262. nCount++;
  263. lpszStart = lpszTarget + nSourceLen;
  264. }
  267. // if any changes were made, make them
  268. if (nCount > 0)
  269. {
  270. int nNewLength = nOldLength + (nReplacementLen-nSourceLen)*nCount;
  271. ASSERT(nNewLength <= nOldLength); // not implemented
  273. lpszStart = strReplace;
  275. // loop again to actually do the work
  276. while ((lpszTarget = wcsstr(lpszStart, lpszOld)) != NULL)
  277. {
  278. int nBalance = nOldLength - int(lpszTarget - strReplace + nSourceLen);
  279. MEMMOVE_S(lpszTarget + nReplacementLen, lpszTarget + nSourceLen,
  280. nBalance * sizeof(WORD));
  281. MEMCPY_S(lpszTarget, lpszNew, nReplacementLen*sizeof(WORD));
  282. lpszStart = lpszTarget + nReplacementLen;
  283. lpszStart[nBalance] = '';
  284. nOldLength += (nReplacementLen - nSourceLen);
  285. }
  287. ASSERT(strReplace[nNewLength] == '');
  288. }
  290. return nCount;
  291. }
  293. void CXTPPropExchange::PreformatString(BSTR bstrValue)
  294. {
  295. ASSERT(bstrValue && m_bLoading);
  297. REPLACEW_S(bstrValue, L"\\", L"0101");
  298. REPLACEW_S(bstrValue, L"\n", L"n");
  299. REPLACEW_S(bstrValue, L"\r", L"r");
  300. REPLACEW_S(bstrValue, L"\t", L"t");
  301. REPLACEW_S(bstrValue, L"0101", L"\");
  302. }
  304. void CXTPPropExchange::PreformatString(CString& strValue, BOOL bLoading)
  305. {
  306. if (bLoading)
  307. {
  308. if (strValue.Find(_T('\')) == -1)
  309. return;
  311. REPLACE_S(strValue, _T("\\"), _T("0101"));
  312. REPLACE_S(strValue, _T("\n"), _T("n"));
  313. REPLACE_S(strValue, _T("\r"), _T("r"));
  314. REPLACE_S(strValue, _T("\t"), _T("t"));
  315. REPLACE_S(strValue, _T("0101"), _T("\"));
  316. }
  317. else
  318. {
  319. REPLACE_S(strValue, _T("\"), _T("\\"));
  320. REPLACE_S(strValue, _T("n"), _T("\n"));
  321. REPLACE_S(strValue, _T("r"), _T("\r"));
  322. REPLACE_S(strValue, _T("t"), _T("\t"));
  323. }
  324. }
  326. void CXTPPropExchange::PreformatString(CString& strValue)
  327. {
  328. PreformatString(strValue, m_bLoading);
  329. }
  331. BOOL CXTPPropExchange::ExchangePropDateHelper(CString& strValue, COleDateTime& dt)
  332. {
  333. if (m_lcidDateTime == XTP_LOCALE_ISO8601)
  334. {
  335. if (m_bLoading)
  336. {
  337. return ParseDateTimeISO8601(dt, strValue);
  338. }
  339. else
  340. {
  341. strValue = FormatDateTimeISO8601(dt);
  342. }
  344. return TRUE;
  346. }
  348. if (m_bLoading)
  349. {
  350. if (!dt.ParseDateTime(strValue, 0, m_lcidDateTime))
  351. return FALSE;
  353. }
  354. else
  355. {
  356. TRY
  357. {
  358. strValue = dt.Format(0, m_lcidDateTime);
  359. }
  360. CATCH_ALL(e)
  361. {
  362. VERIFY(strValue.LoadString(AFX_IDS_INVALID_DATETIME));
  363. }
  364. END_CATCH_ALL
  366. }
  368. return TRUE;
  369. }
  372. BOOL CXTPPropExchange::ExchangePropStringHelper(CString& strValue, VARTYPE vtProp,
  373. void* pvProp, const void* pvDefault)
  374. {
  375. if (m_bLoading)
  376. {
  377. switch (vtProp)
  378. {
  379. case VT_UI1:
  380. case VT_I2:
  381. case VT_I4:
  382. case VT_BOOL:
  383. {
  384. int dwValue = _ttoi(strValue);
  385. return CopyPropValue(vtProp, pvProp, &dwValue);
  386. }
  387. case VT_R4:
  388. {
  389. TCHAR* pChar = NULL;
  390. float fValue = (float)_tcstod(strValue, &pChar);
  391. return CopyPropValue(vtProp, pvProp, &fValue);
  392. }
  393. case VT_R8:
  394. {
  395. TCHAR* pChar = NULL;
  396. double fValue = _tcstod(strValue, &pChar);
  397. return CopyPropValue(vtProp, pvProp, &fValue);
  398. }
  399. case VT_DATE:
  400. {
  401. COleDateTime dt;
  403. if (!ExchangePropDateHelper(strValue, dt))
  404. return FALSE;
  406. *(COleDateTime*)pvProp = dt;
  407. return TRUE;
  408. }
  410. case VT_BSTR:
  411. ASSERT(FALSE);
  412. return FALSE;
  414. case VT_LPSTR:
  415. case VT_EX_SIZE:
  416. case VT_EX_RECT:
  417. {
  418. if (vtProp == VT_EX_SIZE)
  419. {
  420. SIZE sz = {0, 0};
  421. if (SCANF_S(strValue, _T("%i, %i"), &sz.cx, &sz.cy) != 2)
  422. return CopyPropValue(vtProp, pvProp, pvDefault);
  424. *((LPSIZE)pvProp) = sz;
  425. }
  426. else if (vtProp == VT_EX_RECT)
  427. {
  428. RECT rc = {0, 0, 0, 0};
  429. if (SCANF_S(strValue, _T("%i, %i, %i, %i"), &rc.left, &rc.top, &rc.right, &rc.bottom) != 4)
  430. return CopyPropValue(vtProp, pvProp, pvDefault);
  432. *((LPRECT)pvProp) = rc;
  433. }
  434. else
  435. {
  436. PreformatString(strValue);
  437. *(CString*)pvProp = strValue;
  438. }
  439. return TRUE;
  440. }
  441. case VT_VARIANT:
  442. {
  443. COleVariant varValue(strValue);
  444. if (m_lcidDateTime == XTP_LOCALE_ISO8601)
  445. {
  446. COleDateTime dt;
  447. if (ParseDateTimeISO8601(dt, strValue))
  448. {
  449. varValue = dt;
  450. }
  451. }
  452. return CopyPropValue(vtProp, pvProp, &varValue);
  453. }
  454. }
  456. }
  457. else
  458. {
  459. switch (vtProp)
  460. {
  461. case VT_UI1:
  462. case VT_I2:
  463. case VT_I4:
  464. case VT_BOOL:
  465. {
  466. int nValue = 0;
  467. memcpy(&nValue, pvProp, GetSizeOfVarType(vtProp));
  469. strValue.Format(_T("%i"), nValue);
  471. }
  472. return TRUE;
  474. case VT_BSTR:
  475. ASSERT(FALSE);
  476. return FALSE;
  478. case VT_LPSTR:
  479. {
  480. strValue = *(CString*)pvProp;
  481. PreformatString(strValue);
  482. }
  483. return TRUE;
  485. case VT_DATE:
  486. {
  487. COleDateTime& dt = *(COleDateTime*)pvProp;
  488. ExchangePropDateHelper(strValue, dt);
  489. }
  490. return TRUE;
  492. case VT_R4:
  493. {
  494. double d = (double) *(float*)pvProp;
  495. strValue.Format(_T("%g"), d);
  496. return TRUE;
  497. }
  499. case VT_R8:
  501. strValue.Format(_T("%g"), *(double*)pvProp);
  502. return TRUE;
  504. case VT_EX_SIZE:
  505. {
  506. strValue.Format(_T("%i, %i"), ((LPSIZE)pvProp)->cx, ((LPSIZE)pvProp)->cy);
  507. }
  508. return TRUE;
  510. case VT_EX_RECT:
  511. {
  512. strValue.Format(_T("%i, %i, %i, %i"), ((LPRECT)pvProp)->left, ((LPRECT)pvProp)->top, ((LPRECT)pvProp)->right, ((LPRECT)pvProp)->bottom);
  513. }
  514. return TRUE;
  516. case VT_VARIANT:
  518. LCID lcidID = m_lcidDateTime;
  519. COleVariant& varProp = *((COleVariant*)pvProp);
  521. if (lcidID == XTP_LOCALE_ISO8601 && varProp.vt == VT_DATE)
  522. {
  523. strValue = FormatDateTimeISO8601(varProp.date);
  524. return TRUE;
  525. }
  526. if (lcidID == XTP_LOCALE_ISO8601)
  527. {
  528. lcidID = LOCALE_NEUTRAL;
  529. }
  530. COleVariant var;
  531. HRESULT hr = VariantChangeTypeEx(&var, &varProp, lcidID, 0, VT_BSTR);
  533. if (FAILED(hr) || var.vt != VT_BSTR)
  534. return FALSE;
  536. strValue = var.bstrVal;
  538. return TRUE;
  539. }
  540. }
  541. return FALSE;
  542. }
  546. BOOL CXTPPropExchange::ExchangeBlobProp(LPCTSTR pszPropName, BYTE*& pData, DWORD& nBytes)
  547. {
  548. if (IsStoring())
  549. {
  550. CString str;
  551. if (nBytes > 0)
  552. {
  553. LPTSTR lpsz = new TCHAR[nBytes * 2 + 1];
  554. for (UINT i = 0; i < nBytes; i++)
  555. {
  556. lpsz[i * 2] = (TCHAR)((pData[i] & 0x0F) + 'A'); //low nibble
  557. lpsz[i * 2 + 1] = (TCHAR)(((pData[i] >> 4) & 0x0F) + 'A'); //high nibble
  558. }
  559. lpsz[nBytes * 2] = 0;
  561. str = lpsz;
  562. delete[] lpsz;
  563. }
  564. PX_String(this, pszPropName, str, _T(""));
  565. }
  566. else
  567. {
  568. CString str;
  569. if (!PX_String(this, pszPropName, str))
  570. return FALSE;
  572. if (str.GetLength() > 0)
  573. {
  574. int nLen = str.GetLength();
  575. if ((nLen == 0) || (nLen % 2 != 0))
  576. return FALSE;
  578. DWORD nCount = nLen/2;
  579. if (pData == NULL)
  580. {
  581. pData = (BYTE*)malloc(nCount);
  582. nBytes = nCount;
  583. }
  584. if (pData == NULL)
  585. return FALSE;
  587. if (nBytes < nCount)
  588. return FALSE;
  590. for (int i = 0; i < nLen; i += 2)
  591. {
  592. (pData)[i/2] = (BYTE)
  593. (((str[i + 1] - 'A') << 4) + (str[i] - 'A'));
  594. }
  595. }
  596. }
  597. return TRUE;
  599. }
  602. BOOL CXTPPropExchange::IsSamePropValue(VARTYPE vtProp, const void* pv1, const void* pv2)
  603. {
  604. if (pv1 == pv2)
  605. return TRUE;
  607. if ((pv1 == NULL) || (pv2 == NULL))
  608. return FALSE;
  610. BOOL bSame = FALSE;
  612. switch (vtProp)
  613. {
  614. case VT_BSTR:
  615. bSame = wcscmp(*(BSTR*)pv1, (BSTR)pv2) == 0;
  616. break;
  618. case VT_LPSTR:
  619. bSame = ((CString*)pv1)->Compare((LPCTSTR)pv2) == 0;
  620. break;
  622. case VT_BOOL:
  623. case VT_UI1:
  624. case VT_I2:
  625. case VT_I4:
  626. case VT_CY:
  627. case VT_R4:
  628. case VT_R8:
  629. case VT_EX_RECT:
  630. case VT_EX_SIZE:
  631. bSame = memcmp(pv1, pv2, GetSizeOfVarType(vtProp)) == 0;
  632. break;
  634. case VT_VARIANT:
  635. bSame = *((COleVariant*)pv1) == *((COleVariant*)pv2);
  636. break;
  638. case VT_DATE:
  639. bSame = *((COleDateTime*)pv1) == *((COleDateTime*)pv2);
  640. break;
  641. }
  643. return bSame;
  644. }
  646. BOOL CXTPPropExchange::CopyPropValue(VARTYPE vtProp, void* pvDest, const void* pvSrc)
  647. {
  648. ASSERT(AfxIsValidAddress(pvDest, 1));
  650. if (pvSrc != NULL)
  651. {
  652. ASSERT(AfxIsValidAddress(pvSrc, 1, FALSE));
  654. switch (vtProp)
  655. {
  656. case VT_UI1:
  657. *(BYTE*)pvDest = *(BYTE*)pvSrc;
  658. break;
  660. case VT_I2:
  661. *(short*)pvDest = *(short*)pvSrc;
  662. break;
  664. case VT_I4:
  665. *(long*)pvDest = *(long*)pvSrc;
  666. break;
  668. case VT_BOOL:
  669. *(BOOL*)pvDest = *(BOOL*)pvSrc;
  670. break;
  672. case VT_BSTR:
  673. *(BSTR*)pvDest = SysAllocString((BSTR)pvSrc);
  674. break;
  676. case VT_LPSTR:
  677. *(CString*)pvDest = (LPCTSTR)pvSrc;
  678. break;
  680. case VT_CY:
  681. *(CY*)pvDest = *(CY*)pvSrc;
  682. break;
  684. case VT_R4:
  685. *(float*)pvDest = *(float*)pvSrc;
  686. break;
  688. case VT_R8:
  689. *(double*)pvDest = *(double*)pvSrc;
  690. break;
  692. case VT_EX_RECT:
  693. *(RECT*)pvDest = *(RECT*)pvSrc;
  694. break;
  696. case VT_EX_SIZE:
  697. *(SIZE*)pvDest = *(SIZE*)pvSrc;
  698. break;
  700. case VT_DATE:
  701. *(COleDateTime*)pvDest = *(COleDateTime*)pvSrc;
  702. break;
  704. case VT_VARIANT:
  705. TRY
  706. {
  707. *(COleVariant*)pvDest = *(COleVariant*)pvSrc;
  708. }
  709. CATCH_ALL(e)
  710. {
  711. return FALSE;
  712. }
  713. END_CATCH_ALL
  715. return TRUE;
  717. default:
  718. return FALSE;
  719. }
  720. }
  721. return pvSrc != NULL;
  722. }
  724. CRuntimeClass* CXTPPropExchange::FindRuntimeClass(LPCSTR szClassName)
  725. {
  727. CRuntimeClass* pClass;
  728. // search app specific classes
  729. AFX_MODULE_STATE* pModuleState = AfxGetModuleState();
  731. for (pClass = pModuleState->m_classList; pClass != NULL;
  732. pClass = pClass->m_pNextClass)
  733. {
  734. if (lstrcmpA(szClassName, pClass->m_lpszClassName) == 0)
  735. {
  736. return pClass;
  737. }
  738. }
  740. #ifdef _AFXDLL
  741. // search classes in shared DLLs
  742. for (CDynLinkLibrary* pDLL = pModuleState->m_libraryList; pDLL != NULL;
  743. pDLL = pDLL->m_pNextDLL)
  744. {
  745. for (pClass = pDLL->m_classList; pClass != NULL;
  746. pClass = pClass->m_pNextClass)
  747. {
  748. if (lstrcmpA(szClassName, pClass->m_lpszClassName) == 0)
  749. {
  750. return pClass;
  751. }
  752. }
  753. }
  754. #endif
  755. ASSERT(FALSE);
  756. return 0;
  757. }
  759. BOOL CXTPPropExchange::ExchangeRuntimeClass(LPCTSTR pszPropName, CRuntimeClass*& pClass, CRuntimeClass* pDefaultClass)
  760. {
  761. CString strClassName;
  763. if (!IsLoading())
  764. {
  765. strClassName = CString(pClass->m_lpszClassName);
  766. PX_String(this, pszPropName, strClassName, CString(pDefaultClass->m_lpszClassName));
  767. }
  768. else
  769. {
  770. if (!PX_String(this, pszPropName, strClassName))
  771. {
  772. pClass = pDefaultClass;
  773. return TRUE;
  774. }
  776. pClass = FindRuntimeClass(XTP_CT2CA(strClassName));
  777. if (!pClass)
  778. return FALSE;
  779. }
  780. return TRUE;
  781. }
  783. BOOL CXTPPropExchange::ExchangeObjectInstance(CObject*& pObject, CRuntimeClass* pObjectRuntime)
  784. {
  785. if (!IsLoading())
  786. {
  787. CRuntimeClass* pClass = pObject->GetRuntimeClass();
  788. PX_RuntimeClass(this, _T("Class"), pClass, pObjectRuntime);
  789. }
  790. else
  791. {
  792. CRuntimeClass* pClass = NULL;
  793. PX_RuntimeClass(this, _T("Class"), pClass, pObjectRuntime);
  794. if (!pClass)
  795. return FALSE;
  797. pObject = (CObject*)AfxDynamicDownCast(pObjectRuntime, pClass->CreateObject());
  798. if (!pObject)
  799. return FALSE;
  800. }
  801. return TRUE;
  802. }
  803. void CXTPPropExchange::WriteCount (DWORD dwCount)
  804. {
  805. PX_DWord(this, _T("Count"), dwCount, 0);
  806. }
  808. DWORD CXTPPropExchange::ReadCount()
  809. {
  810. DWORD nCount = 0;
  811. PX_DWord(this, _T("Count"), nCount, 0);
  812. return nCount;
  813. }
  815. CArchive* CXTPPropExchange::GetArchive(LPCTSTR pszPropName)
  816. {
  817. if (IsStoring())
  818. {
  820. CMemFile* pMemFile = new CMemFile();
  821. CArchive* pArchive = new CArchive(pMemFile, CArchive::store);
  823. return pArchive;
  824. }
  826. DWORD nBytes = 0;
  827. BYTE* pData = NULL;
  828. PX_Blob(this, pszPropName, pData, nBytes);
  830. if (nBytes == 0)
  831. return NULL;
  833. CMemFile* pMemFile = new CMemFile(pData, nBytes);
  834. CArchive* pArchive = new CArchive(pMemFile, CArchive::load);
  836. return pArchive;
  837. }
  839. void CXTPPropExchange::ReleaseArchive(LPCTSTR pszPropName, CArchive* pArchive)
  840. {
  841. ASSERT(pArchive);
  842. if (!pArchive)
  843. return;
  845. CMemFile* pFile = DYNAMIC_DOWNCAST(CMemFile, pArchive->GetFile());
  846. ASSERT(pFile);
  847. if (!pFile)
  848. return;
  850. BYTE* pData = NULL;
  851. if (IsStoring())
  852. {
  853. pArchive->Flush();
  855. DWORD nBytes = (DWORD)pFile->GetPosition();
  856. pData = pFile->Detach();
  857. PX_Blob(this, pszPropName, pData, nBytes);
  859. }
  860. else
  861. {
  862. pData = pFile->Detach();
  863. }
  865. pArchive->Abort();
  866. pFile->Close();
  867. free(pData);
  869. delete pFile;
  870. delete pArchive;
  871. }
  873. void CXTPPropExchange::ExchangeSchema()
  874. {
  875. PX_Long(this, _T("Schema"), (long&)m_nSchema, _XTP_SCHEMA_CURRENT);
  876. }
  878. void CXTPPropExchange::ExchangeSchemaSafe()
  879. {
  880. PX_Long(this, _T("Schema"), (long&)m_nSchema, _XTP_SCHEMA_1122);
  881. }
  883. void CXTPPropExchange::ExchangeLocale()
  884. {
  885. PX_DWord(this, _T("Locale"), (DWORD&)CXTPPropExchange::m_lcidDateTime, XTP_LOCALE_ISO8601);
  886. }
  890. CXTPPropExchangeEnumerator* CXTPPropExchange::GetEnumerator(LPCTSTR lpszSection)
  891. {
  892. return new CXTPPropExchangeEnumerator(this, lpszSection);
  893. }
  895. //////////////////////////////////////////////////////////////////////////
  896. // CXTPPropExchangeArchive
  898. IMPLEMENT_DYNAMIC(CXTPPropExchangeArchive, CXTPPropExchange)
  900. CXTPPropExchangeArchive::CXTPPropExchangeArchive(CArchive& ar) :
  901. m_ar((CSelfArchive&)ar)
  902. {
  903. ASSERT_POINTER(&ar, CArchive);
  904. m_bLoading = m_ar.IsLoading();
  906. }
  908. CXTPPropExchange* CXTPPropExchangeArchive::GetSection(LPCTSTR /*pszSection*/)
  909. {
  910. CXTPPropExchangeArchive* pSection = new CXTPPropExchangeArchive(m_ar);
  911. pSection->InitSection(this);
  912. return pSection;
  913. }
  916. BOOL CXTPPropExchangeArchive::ExchangeRuntimeClass(LPCTSTR /*pszPropName*/, CRuntimeClass*& pClass, CRuntimeClass* pDefaultClass)
  917. {
  918. if (!OnBeforeExchange())
  919. return FALSE;
  921. if (!IsLoading())
  922. {
  923. m_ar.WriteClass(pClass);
  924. }
  925. else
  926. {
  927. pClass = m_ar.ReadClass(pDefaultClass, &m_nSchema);
  929. if (!pClass)
  930. return FALSE;
  931. }
  932. return TRUE;
  933. }
  935. BOOL CXTPPropExchangeArchive::ExchangeObjectInstance(CObject*& pObject, CRuntimeClass* pObjectRuntime)
  936. {
  937. if (!CXTPPropExchange::ExchangeObjectInstance(pObject, pObjectRuntime))
  938. return FALSE;
  940. if (IsLoading())
  941. {
  942. m_ar.CheckCount();
  943. m_ar.m_pLoadArray->InsertAt(m_ar.m_nMapCount++, pObject);
  944. }
  945. else
  946. {
  947. m_ar.MapObject(NULL);
  948. m_ar.CheckCount();
  949. m_ar.m_pStoreMap->SetAt(pObject, (LPVOID)(DWORD_PTR)m_ar.m_nMapCount++);
  951. }
  953. return TRUE;
  954. }
  956. BOOL CXTPPropExchangeArchive::ExchangeProp(LPCTSTR /*pszPropName*/, VARTYPE vtProp,
  957. void* pvProp, const void* pvDefault)
  958. {
  959. if (!OnBeforeExchange())
  960. return FALSE;
  962. UNUSED(pvDefault);       // unused in release builds
  964. ASSERT(AfxIsValidAddress(pvProp, 1, FALSE));
  965. ASSERT((pvDefault == NULL) || AfxIsValidAddress(pvDefault, 1, FALSE));
  967. if (m_bLoading)
  968. {
  969. switch (vtProp)
  970. {
  971. case VT_UI1:
  972. m_ar >> *(BYTE*)pvProp;
  973. break;
  974. case VT_I2:
  975. m_ar >> *(WORD*)pvProp;
  976. break;
  977. case VT_I4:
  978. m_ar >> *(long*)pvProp;
  979. break;
  980. case VT_BOOL:
  981. m_ar >> *(BOOL*)pvProp;
  982. break;
  983. case VT_BSTR:
  984. ASSERT(FALSE);
  985. break;
  986. case VT_LPSTR:
  987. m_ar >> *(CString*)pvProp;
  988. break;
  989. case VT_CY:
  990. m_ar >> ((CY*)pvProp)->Lo;
  991. m_ar >> ((CY*)pvProp)->Hi;
  992. break;
  993. case VT_R4:
  994. m_ar >> *(float*)pvProp;
  995. break;
  996. case VT_R8:
  997. m_ar >> *(double*)pvProp;
  998. break;
  999. case VT_EX_RECT:
  1000. m_ar >> *(RECT*)pvProp;
  1001. break;
  1002. case VT_EX_SIZE:
  1003. m_ar >> *(SIZE*)pvProp;
  1004. break;
  1005. case VT_VARIANT:
  1006. m_ar >> *(COleVariant*)pvProp;
  1007. break;
  1008. case VT_DATE:
  1009. m_ar >> *(COleDateTime*)pvProp;
  1010. break;
  1011. }
  1012. }
  1013. else
  1014. {
  1015. switch (vtProp)
  1016. {
  1017. case VT_UI1:
  1018. m_ar << *(BYTE*)pvProp;
  1019. break;
  1020. case VT_I2:
  1021. m_ar << *(WORD*)pvProp;
  1022. break;
  1023. case VT_I4:
  1024. m_ar << *(long*)pvProp;
  1025. break;
  1026. case VT_BOOL:
  1027. m_ar << *(BOOL*)pvProp;
  1028. break;
  1029. case VT_BSTR:
  1030. ASSERT(FALSE);
  1031. break;
  1032. case VT_LPSTR:
  1033. m_ar << *(CString*)pvProp;
  1034. break;
  1035. case VT_CY:
  1036. m_ar << ((CY*)pvProp)->Lo;
  1037. m_ar << ((CY*)pvProp)->Hi;
  1038. break;
  1039. case VT_R4:
  1040. m_ar << *(float*)pvProp;
  1041. break;
  1042. case VT_R8:
  1043. m_ar << *(double*)pvProp;
  1044. break;
  1045. case VT_EX_RECT:
  1046. m_ar << *(RECT*)pvProp;
  1047. break;
  1048. case VT_EX_SIZE:
  1049. m_ar << *(SIZE*)pvProp;
  1050. break;
  1051. case VT_VARIANT:
  1052. m_ar << *(COleVariant*)pvProp;
  1053. break;
  1054. case VT_DATE:
  1055. m_ar << *(COleDateTime*)pvProp;
  1056. break;
  1057. }
  1058. }
  1060. return TRUE;
  1061. }
  1063. void CXTPPropExchangeArchive::WriteCount (DWORD dwCount)
  1064. {
  1065. m_ar.WriteCount(dwCount);
  1066. }
  1067. DWORD CXTPPropExchangeArchive::ReadCount()
  1068. {
  1069. return (DWORD)m_ar.ReadCount();
  1070. }
  1071. void CXTPPropExchangeArchive::Write (LPCTSTR /*pszPropName*/, const void* lpBuf, UINT nCount)
  1072. {
  1073. ASSERT(lpBuf);
  1074. m_ar.Write(lpBuf, nCount);
  1075. }
  1077. UINT CXTPPropExchangeArchive::Read (LPCTSTR /*pszPropName*/, void* lpBuf, UINT nCount)
  1078. {
  1079. ASSERT(lpBuf);
  1080. return m_ar.Read(lpBuf, nCount);
  1081. }
  1083. BOOL CXTPPropExchangeArchive::ExchangeBlobProp(LPCTSTR /*pszPropName*/, BYTE*& pData, DWORD& nBytes)
  1084. {
  1085. if (!OnBeforeExchange())
  1086. return FALSE;
  1088. if (IsStoring())
  1089. {
  1090. WriteCount(nBytes);
  1091. m_ar.Write(pData, nBytes);
  1092. }
  1093. else
  1094. {
  1095. DWORD nCount = ReadCount();
  1097. if (pData == NULL)
  1098. {
  1099. pData = (BYTE*)malloc(nCount);
  1100. nBytes = nCount;
  1101. }
  1103. if (nBytes < nCount)
  1104. return FALSE;
  1106. return m_ar.Read(pData, nCount) == nCount;
  1107. }
  1109. return TRUE;
  1110. }
  1112. CArchive* CXTPPropExchangeArchive::GetArchive(LPCTSTR /*pszPropName*/)
  1113. {
  1114. return &m_ar;
  1115. }
  1117. void CXTPPropExchangeArchive::ReleaseArchive(LPCTSTR /*pszPropName*/, CArchive* /*pArchive*/)
  1118. {
  1120. }
  1122. void CXTPPropExchangeArchive::ExchangeSchemaSafe()
  1123. {
  1124. DWORD dwSafe = 0xFF0ADBF;
  1126. if (IsStoring())
  1127. {
  1128. m_ar << dwSafe;
  1129. m_ar << m_nSchema;
  1130. }
  1131. else
  1132. {
  1133. if (m_ar.m_lpBufCur + sizeof(DWORD) > m_ar.m_lpBufMax)
  1134. m_ar.FillBuffer(sizeof(DWORD));
  1136. DWORD dw = *(DWORD*)m_ar.m_lpBufCur;
  1138. if (dw == dwSafe)
  1139. {
  1140. m_ar >> dwSafe;
  1141. m_ar >> m_nSchema;
  1142. }
  1143. else
  1144. {
  1145. m_nSchema = _XTP_SCHEMA_100;
  1146. }
  1147. }
  1148. }
  1151. //////////////////////////////////////////////////////////////////////////
  1152. // CXTPPropExchangeRegistry
  1154. IMPLEMENT_DYNAMIC(CXTPPropExchangeRegistry, CXTPPropExchange)
  1156. CXTPPropExchangeRegistry::CXTPPropExchangeRegistry(BOOL bLoading, HKEY hParentKey, LPCTSTR lpszSection)
  1157. {
  1158. ASSERT(lpszSection != NULL);
  1159. if (hParentKey == 0)
  1160. {
  1161. m_hParentKey = AfxGetApp()->GetAppRegistryKey();
  1162. m_bCloseParentKey = TRUE;
  1163. }
  1164. else
  1165. {
  1166. m_hParentKey = hParentKey;
  1167. m_bCloseParentKey = FALSE;
  1168. }
  1170. m_bLoading = bLoading;
  1171. m_strSectionName = lpszSection;
  1172. m_hSectionKey = NULL;
  1174. }
  1176. CXTPPropExchangeRegistry::~CXTPPropExchangeRegistry()
  1177. {
  1178. if (m_hSectionKey)
  1179. {
  1180. RegCloseKey(m_hSectionKey);
  1181. }
  1182. if (m_bCloseParentKey && m_hParentKey)
  1183. {
  1184. RegCloseKey(m_hParentKey);
  1185. }
  1186. }
  1188. CXTPPropExchange* CXTPPropExchangeRegistry::GetSection(LPCTSTR lpszSection)
  1189. {
  1190. OnBeforeExchange();
  1192. CXTPPropExchangeRegistry* pSection = new CXTPPropExchangeRegistry(IsLoading(), m_hSectionKey, lpszSection);
  1193. pSection->InitSection(this);
  1194. return pSection;
  1195. }
  1197. BOOL CXTPPropExchangeRegistry::IsPropertyExists(LPCTSTR pszPropName)
  1198. {
  1199. if (!OnBeforeExchange())
  1200. return FALSE;
  1202. return RegQueryValueEx(m_hSectionKey, (LPTSTR)pszPropName, NULL, NULL, NULL, NULL) == ERROR_SUCCESS;
  1203. }
  1205. BOOL CXTPPropExchangeRegistry::IsSectionExists(LPCTSTR lpszSection)
  1206. {
  1207. if (!OnBeforeExchange())
  1208. return FALSE;
  1210. HKEY hSectionKey = 0;
  1212. if (RegOpenKeyEx(m_hSectionKey, lpszSection, 0, m_bLoading ? KEY_READ : KEY_WRITE, &hSectionKey) == ERROR_SUCCESS)
  1213. {
  1214. RegCloseKey(hSectionKey);
  1215. return TRUE;
  1216. }
  1218. return FALSE;
  1219. }
  1222. BOOL CXTPPropExchangeRegistry::OnBeforeExchange()
  1223. {
  1224. if (m_hParentKey == NULL)
  1225. return FALSE;
  1227. if (!m_bInitialized)
  1228. {
  1229. ASSERT(m_hSectionKey == 0);
  1231. VERIFY(RegCreateKeyEx(m_hParentKey, m_strSectionName, 0, REG_NONE, REG_OPTION_NON_VOLATILE, m_bLoading ? KEY_READ : KEY_WRITE, NULL, &m_hSectionKey, NULL) == ERROR_SUCCESS);
  1233. m_bInitialized = TRUE;
  1234. }
  1235. return m_hSectionKey != NULL;
  1236. }
  1238. void CXTPPropExchangeRegistry::EmptySection()
  1239. {
  1240. CXTPPropExchange::EmptySection();
  1242. if (m_hSectionKey)
  1243. {
  1244. RegCloseKey(m_hSectionKey);
  1245. m_hSectionKey = 0;
  1246. }
  1248. AfxDelRegTreeHelper(m_hParentKey, m_strSectionName);
  1249. m_bInitialized = FALSE;
  1250. }
  1253. BOOL CXTPPropExchangeRegistry::ExchangeProp(LPCTSTR pszPropName, VARTYPE vtProp,
  1254. void* pvProp, const void* pvDefault /*= NULL*/)
  1255. {
  1256. if (m_bLoading)
  1257. {
  1258. if (!m_bUseDefaultOnLoad)
  1259. pvDefault = NULL;
  1261. if (!OnBeforeExchange())
  1262. return CopyPropValue(vtProp, pvProp, pvDefault);
  1264. ASSERT(m_hSectionKey);
  1266. switch (vtProp)
  1267. {
  1268. case VT_R4:
  1269. case VT_R8:
  1270. case VT_DATE:
  1271. case VT_BSTR:
  1272. ASSERT(FALSE); // Not Implemented
  1273. return FALSE;
  1275. case VT_VARIANT:
  1276. return FALSE; // Not Implemented
  1278. case VT_UI1:
  1279. case VT_I2:
  1280. case VT_I4:
  1281. case VT_BOOL:
  1282. {
  1284. DWORD dwValue;
  1285. DWORD dwType;
  1286. DWORD dwCount = sizeof(DWORD);
  1287. LONG lResult = RegQueryValueEx(m_hSectionKey, (LPTSTR)pszPropName, NULL, &dwType,
  1288. (LPBYTE)&dwValue, &dwCount);
  1290. if (lResult == ERROR_SUCCESS)
  1291. {
  1292. ASSERT(dwType == REG_DWORD);
  1293. ASSERT(dwCount == sizeof(DWORD));
  1295. return CopyPropValue(vtProp, pvProp, &dwValue);
  1297. }
  1298. else
  1299. {
  1300. return CopyPropValue(vtProp, pvProp, pvDefault);
  1301. }
  1302. }
  1303. case VT_LPSTR:
  1304. case VT_EX_SIZE:
  1305. case VT_EX_RECT:
  1306. {
  1307. CString strValue;
  1308. DWORD dwType, dwCount;
  1309. LONG lResult = RegQueryValueEx(m_hSectionKey, (LPTSTR)pszPropName, NULL, &dwType,
  1310. NULL, &dwCount);
  1311. if (lResult == ERROR_SUCCESS)
  1312. {
  1313. ASSERT(dwType == REG_SZ);
  1314. lResult = RegQueryValueEx(m_hSectionKey, (LPTSTR)pszPropName, NULL, &dwType,
  1315. (LPBYTE)strValue.GetBuffer(dwCount/sizeof(TCHAR)), &dwCount);
  1316. strValue.ReleaseBuffer();
  1317. }
  1318. if (lResult == ERROR_SUCCESS)
  1319. {
  1320. ASSERT(dwType == REG_SZ);
  1322. if (vtProp == VT_EX_SIZE)
  1323. {
  1324. SIZE sz = {0, 0};
  1325. if (SCANF_S(strValue, _T("%i, %i"), &sz.cx, &sz.cy) != 2)
  1326. return CopyPropValue(vtProp, pvProp, pvDefault);
  1328. *((LPSIZE)pvProp) = sz;
  1329. }
  1330. else if (vtProp == VT_EX_RECT)
  1331. {
  1332. RECT rc = {0, 0, 0, 0};
  1333. if (SCANF_S(strValue, _T("%i, %i, %i, %i"), &rc.left, &rc.top, &rc.right, &rc.bottom) != 4)
  1334. return CopyPropValue(vtProp, pvProp, pvDefault);
  1336. *((LPRECT)pvProp) = rc;
  1337. }
  1338. else
  1339. {
  1340. *(CString*)pvProp = strValue;
  1341. }
  1343. }
  1344. else
  1345. {
  1346. return CopyPropValue(vtProp, pvProp, pvDefault);
  1347. }
  1348. return TRUE;
  1349. }
  1350. }
  1351. }
  1352. else
  1353. {
  1354. if (!m_bUseDefaultOnSave)
  1355. pvDefault = NULL;
  1357. if (!OnBeforeExchange())
  1358. return FALSE;
  1360. if (IsSamePropValue(vtProp, pvProp, pvDefault))
  1361. {
  1362. if (m_hSectionKey && !m_bEmptySection)
  1363. RegDeleteValue(m_hSectionKey, pszPropName);
  1364. return TRUE;
  1365. }
  1367. LONG lResult = -1;
  1369. switch (vtProp)
  1370. {
  1371. case VT_UI1:
  1372. case VT_I2:
  1373. case VT_I4:
  1374. case VT_BOOL:
  1375. {
  1376. DWORD dwValue = 0;
  1377. CopyPropValue(vtProp, &dwValue, pvProp);
  1378. lResult = RegSetValueEx(m_hSectionKey, pszPropName, NULL, REG_DWORD, (LPBYTE)&dwValue, sizeof(DWORD));
  1379. }
  1380. break;
  1382. case VT_LPSTR:
  1383. {
  1384. CString& strValue = *(CString*)pvProp;
  1385. lResult = RegSetValueEx(m_hSectionKey, pszPropName, NULL, REG_SZ,
  1386. (LPBYTE)(LPCTSTR)strValue, (strValue.GetLength() + 1) * sizeof(TCHAR));
  1387. }
  1388. break;
  1390. case VT_R4:
  1391. case VT_R8:
  1392. lResult = RegSetValueEx(m_hSectionKey, pszPropName, NULL, REG_BINARY, (LPBYTE)pvProp, GetSizeOfVarType(vtProp));
  1393. break;
  1395. case VT_DATE:
  1396. case VT_VARIANT:
  1397. case VT_BSTR:
  1398. ASSERT(FALSE); // Not Implemented
  1399. break;
  1401. case VT_EX_SIZE:
  1402. {
  1403. CString strValue;
  1404. strValue.Format(_T("%i, %i"), ((LPSIZE)pvProp)->cx, ((LPSIZE)pvProp)->cy);
  1405. lResult = RegSetValueEx(m_hSectionKey, pszPropName, NULL, REG_SZ,
  1406. (LPBYTE)(LPCTSTR)strValue, (strValue.GetLength() + 1) * sizeof(TCHAR));
  1407. }
  1408. break;
  1410. case VT_EX_RECT:
  1411. CString strValue;
  1412. strValue.Format(_T("%i, %i, %i, %i"), ((LPRECT)pvProp)->left, ((LPRECT)pvProp)->top, ((LPRECT)pvProp)->right, ((LPRECT)pvProp)->bottom);
  1413. lResult = RegSetValueEx(m_hSectionKey, pszPropName, NULL, REG_SZ,
  1414. (LPBYTE)(LPCTSTR)strValue, (strValue.GetLength() + 1) * sizeof(TCHAR));
  1415. break;
  1417. }
  1419. return lResult == ERROR_SUCCESS;
  1420. }
  1422. return FALSE;
  1423. }
  1425. BOOL CXTPPropExchangeRegistry::ExchangeBlobProp(LPCTSTR pszPropName, BYTE*& pData, DWORD& nBytes)
  1426. {
  1427. if (!OnBeforeExchange())
  1428. return FALSE;
  1430. ASSERT(m_hSectionKey != 0);
  1432. if (IsStoring())
  1433. {
  1434. LONG lResult = ::RegSetValueEx(m_hSectionKey, pszPropName, NULL, REG_BINARY,
  1435. pData, nBytes);
  1436. return lResult == ERROR_SUCCESS;
  1438. }
  1439. else
  1440. {
  1441. DWORD dwType, dwCount;
  1442. LONG lResult = RegQueryValueEx(m_hSectionKey, (LPTSTR)pszPropName, NULL, &dwType,
  1443. NULL, &dwCount);
  1445. if (lResult != ERROR_SUCCESS)
  1446. return FALSE;
  1448. ASSERT(dwType == REG_BINARY);
  1451. if (pData == NULL)
  1452. {
  1453. pData = (BYTE*)malloc(dwCount);
  1454. nBytes = dwCount;
  1455. }
  1457. if (nBytes < dwCount)
  1458. return FALSE;
  1460. lResult = RegQueryValueEx(m_hSectionKey, (LPTSTR)pszPropName, NULL, &dwType,
  1461. (LPBYTE)pData, &dwCount);
  1463. if (lResult != ERROR_SUCCESS)
  1464. return FALSE;
  1465. }
  1467. return TRUE;
  1468. }
  1471. //////////////////////////////////////////////////////////////////////////
  1472. // CXTPPropExchangeXMLNode
  1474. #ifndef _XTP_EXCLUDE_XML
  1476. IMPLEMENT_DYNAMIC(CXTPPropExchangeXMLNode, CXTPPropExchange)
  1478. CXTPPropExchangeXMLNode::CXTPPropExchangeXMLNode(BOOL bLoading, CXTPDOMNodePtr xmlParentNode, LPCTSTR lpszSection)
  1479. {
  1480. m_bLoading = bLoading;
  1481. m_strSectionName = lpszSection;
  1482. m_xmlParentNode = xmlParentNode;
  1483. m_xmlSectionNode = NULL;
  1484. m_bCompactMode = TRUE;
  1486. if (xmlParentNode)
  1487. {
  1488. xmlParentNode->get_ownerDocument(&m_xmlDocPtr);
  1490. if (m_xmlDocPtr == 0)
  1491. {
  1492. m_xmlDocPtr = xmlParentNode;
  1493. }
  1494. }
  1496. m_strEncoding = _T("UTF-8");
  1498. }
  1500. BOOL CXTPPropExchangeXMLNode::IsXMLSupported()
  1501. {
  1502. CXTPDOMDocumentPtr xmlDocPtr;
  1504. if (!SUCCEEDED(xmlDocPtr.CreateInstance(CLSID_XTPDOMDocument)))
  1505. {
  1506. return FALSE;
  1507. }
  1508. return TRUE;
  1509. }
  1511. BOOL CXTPPropExchangeXMLNode::CreateDocumentInstance()
  1512. {
  1513. if (m_xmlDocPtr == NULL)
  1514. {
  1515. if (!SUCCEEDED(m_xmlDocPtr.CreateInstance(CLSID_XTPDOMDocument)))
  1516. {
  1517. TRACE(_T("Warning: CreateDocumentInstance failed in CXTPPropExchangeXMLNode --n"));
  1518. TRACE(_T("tperhaps AfxOleInit() has not been called, or msxml3.dll not found."));
  1520. return FALSE;
  1521. }
  1523. m_xmlDocPtr->put_preserveWhiteSpace(VARIANT_TRUE);
  1525. }
  1526. return TRUE;
  1527. }
  1529. void CXTPPropExchangeXMLNode::TraceParseError()
  1530. {
  1531. #ifdef _DEBUG
  1532. XTPXML::IXMLDOMParseErrorPtr parseError = 0;
  1533. if (FAILED(m_xmlDocPtr->get_parseError(&parseError)))
  1534. return;
  1536. BSTR bstrReason = 0;
  1537. if (FAILED(parseError->get_reason(&bstrReason)))
  1538. return;
  1540. CString strReason(bstrReason);
  1541. TRACE(_T("Warning: CXTPPropExchangeXMLNode::LoadFromString failed. ParseError.Reason = %s"), (LPCTSTR)strReason);
  1543. SysFreeString(bstrReason);
  1544. #endif
  1545. }
  1547. BOOL CXTPPropExchangeXMLNode::LoadFromString(LPCSTR lpszState)
  1548. {
  1549. if (!lpszState)
  1550. return FALSE;
  1552. if (!CreateDocumentInstance())
  1553. return FALSE;
  1555. ASSERT(m_xmlDocPtr != 0);
  1557. VARIANT_BOOL bResult;
  1559. VARIANT va;
  1560. va.vt = VT_ARRAY | VT_UI1;
  1562. ULONG nLen = (ULONG)strlen(lpszState);
  1563. va.parray = SafeArrayCreateVector(VT_UI1, 0, nLen);
  1564. MEMCPY_S(va.parray->pvData, lpszState, nLen);
  1566. HRESULT hr = m_xmlDocPtr->load(va, &bResult);
  1567. VariantClear(&va);
  1569. if (FAILED(hr) || bResult == VARIANT_FALSE)
  1570. {
  1571. TraceParseError();
  1572. return FALSE;
  1573. }
  1575. m_xmlParentNode = m_xmlDocPtr;
  1576. m_xmlSectionNode = NULL;
  1577. m_bInitialized = FALSE;
  1579. return TRUE;
  1580. }
  1582. BOOL CXTPPropExchangeXMLNode::LoadFromString(LPCWSTR lpszState)
  1583. {
  1584. return LoadFromString((BSTR)lpszState);
  1585. }
  1587. BOOL CXTPPropExchangeXMLNode::LoadFromString(BSTR lpszState)
  1588. {
  1589. if (!CreateDocumentInstance())
  1590. return FALSE;
  1592. ASSERT(m_xmlDocPtr != 0);
  1594. VARIANT_BOOL bResult;
  1595. HRESULT hr = m_xmlDocPtr->loadXML(lpszState, &bResult);
  1596. if (FAILED(hr) || bResult == VARIANT_FALSE)
  1597. {
  1598. TraceParseError();
  1599. return FALSE;
  1600. }
  1602. m_xmlParentNode = m_xmlDocPtr;
  1603. m_xmlSectionNode = NULL;
  1604. m_bInitialized = FALSE;
  1606. return TRUE;
  1607. }
  1609. BOOL CXTPPropExchangeXMLNode::LoadFromResource(HINSTANCE hInstance, LPCTSTR lpszResourceName, LPCTSTR lpszResourceType)
  1610. {
  1611. HRSRC hRsrc = ::FindResource(hInstance, lpszResourceName, lpszResourceType);
  1612. if (hRsrc == NULL)
  1613. return FALSE;
  1615. HGLOBAL hGlobal = LoadResource(hInstance, hRsrc);
  1616. if (hGlobal == NULL)
  1617. return FALSE;
  1619. LPCSTR pData = (LPCSTR)LockResource(hGlobal);
  1620. if (pData == NULL)
  1621. return FALSE;
  1623. DWORD dwSize = (DWORD)SizeofResource(hInstance, hRsrc);
  1624. if (dwSize == 0)
  1625. return FALSE;
  1627. LPSTR lpstr = (LPSTR)malloc(dwSize + 1);
  1628. if (!lpstr)
  1629. return FALSE;
  1631. MEMCPY_S(lpstr, pData, dwSize);
  1632. lpstr[dwSize] = 0;
  1634. BOOL bResult = LoadFromString(lpstr);
  1636. UnlockResource(hGlobal);
  1637. FreeResource(hGlobal);
  1639. free(lpstr);
  1641. return bResult;
  1642. }
  1645. BOOL CXTPPropExchangeXMLNode::LoadFromFile(LPCTSTR strFileName)
  1646. {
  1647. if (!FILEEXISTS_S(strFileName))
  1648. return FALSE;
  1650. if (!CreateDocumentInstance())
  1651. return FALSE;
  1653. ASSERT(m_xmlDocPtr != 0);
  1655. VARIANT_BOOL bResult;
  1656. HRESULT hr = m_xmlDocPtr->load(COleVariant(strFileName), &bResult);
  1657. if (FAILED(hr) || bResult == VARIANT_FALSE)
  1658. {
  1659. TraceParseError();
  1660. return FALSE;
  1661. }
  1663. m_xmlParentNode = m_xmlDocPtr;
  1664. m_xmlSectionNode = NULL;
  1665. m_bInitialized = FALSE;
  1667. return TRUE;
  1668. }
  1670. CString CXTPPropExchangeXMLNode::GetXML(BOOL bFormatted)
  1671. {
  1672. const LPCTSTR lpszCrLf = _T("rn");
  1674. #define ADDINDENT(str, i, strOffset)
  1675. INSERT_S(str, i, lpszCrLf);
  1676. INSERT_S(str, i + 2, strOffset);
  1677. i += strOffset.GetLength() + 2;
  1679. CString str;
  1680. if (!OnBeforeExchange())
  1681. return str;
  1683. ASSERT(m_xmlDocPtr != 0);
  1685. BSTR bstrXML = 0;
  1687. if (IsRootSection())
  1688. {
  1689. if (FAILED(m_xmlDocPtr->get_xml(&bstrXML)))
  1690. return str;
  1691. }
  1692. else
  1693. {
  1694. if (FAILED(m_xmlSectionNode->get_xml(&bstrXML)))
  1695. return str;
  1696. }
  1698. str = bstrXML;
  1699. SysFreeString(bstrXML);
  1701. if (bFormatted)
  1702. {
  1703. CString strOffset(_T('t'));
  1705. for (int i = 1; i < str.GetLength(); i++)
  1706. {
  1707. if (((str[i] == _T('>')) && (str[i - 1] == _T('/'))) || ((str[i] == _T('<')) && (str[i + 1] == _T('/'))))
  1708. {
  1709. DELETE_S(strOffset, strOffset.GetLength() - 1);
  1710. if (str[i] == _T('<') && str[i - 1] == _T('>'))
  1711. {
  1712. ADDINDENT(str, i, strOffset);
  1713. }
  1714. }
  1715. else if (str[i] == _T('<'))
  1716. {
  1717. ADDINDENT(str, i, strOffset);
  1718. strOffset += _T('t');
  1720. }
  1721. }
  1722. }
  1724. return str;
  1726. }
  1730. void CXTPPropExchangeXMLNode::FormatFile(LPCTSTR lpszFileName)
  1731. {
  1732. const LPCSTR lpszCrLf = "rn";
  1733. const LPCSTR lpszOffset = "t";
  1735. #define WRITEINDENT
  1736. file.Write(lpszBegin, int(lpszCurrent - lpszBegin) - nWhiteSpace);
  1737. file.Write(lpszCrLf, 2);
  1738. for (int j = 0; j < nOffset; j++) file.Write(lpszOffset, 1);
  1739. lpszBegin = lpszCurrent
  1742. CFile file;
  1743. if (!file.Open(lpszFileName, CFile::modeRead))
  1744. return;
  1746. DWORD dwLength = (DWORD)file.GetLength();
  1748. if (dwLength < 3)
  1749. return;
  1751. BYTE* lpszBuffer = new BYTE[dwLength + 1];
  1753. file.Read(lpszBuffer, dwLength);
  1754. lpszBuffer[dwLength] = 0;
  1755. file.Close();
  1757. if (!file.Open(lpszFileName, CFile::modeWrite | CFile::modeCreate))
  1758. {
  1759. delete[] lpszBuffer;
  1760. return;
  1761. }
  1763. int nOffset = 1, nWhiteSpace = 0;
  1764. if (dwLength > 2 && lpszBuffer[dwLength - 2] == 'r')
  1765. lpszBuffer[dwLength - 2] = 0;
  1767. BYTE *lpszCurrent = lpszBuffer + 1, *lpszBegin = lpszBuffer;
  1769. while (*lpszCurrent++)
  1770. {
  1771. BYTE& chCurrent = *lpszCurrent;
  1773. if (((chCurrent == _T('>')) && (*(lpszCurrent - 1) == '/' || *(lpszCurrent - 1) == '?'))
  1774. || ((chCurrent == _T('<')) && (*(lpszCurrent + 1) == '/')))
  1775. {
  1776. nOffset--;
  1777. if (chCurrent == '<' && *(lpszCurrent - 1 - nWhiteSpace) == '>')
  1778. {
  1779. WRITEINDENT;
  1780. }
  1781. }
  1782. else if (chCurrent == '<')
  1783. {
  1784. WRITEINDENT;
  1785. nOffset++;
  1786. }
  1788. nWhiteSpace = (chCurrent == 'r' || chCurrent == 'n' || chCurrent == 't') ? nWhiteSpace + 1 : 0;
  1789. }
  1791. file.Write(lpszBegin, int(lpszCurrent - lpszBegin) - 1);
  1792. file.Write(lpszCrLf, 2);
  1794. file.Close();
  1795. delete[] lpszBuffer;
  1796. }
  1798. HRESULT CXTPPropExchangeXMLNode::SaveToFile(LPCTSTR strFileName, BOOL bFormatted)
  1799. {
  1800. CString str;
  1801. if (!OnBeforeExchange())
  1802. return E_FAIL;
  1804. ASSERT(m_xmlDocPtr != 0);
  1806. CString strInstruction = _T("version="1.0" encoding="") + m_strEncoding + _T(""");
  1808. BOOL bInstructionExists = FALSE;
  1810. CXTPDOMNodePtr ptrBaseInstruction = 0;
  1811. if (SUCCEEDED(m_xmlDocPtr->selectSingleNode(L"/node()", &ptrBaseInstruction)) && ptrBaseInstruction != 0)
  1812. {
  1813. BSTR bstrNodeName = 0;
  1814. ptrBaseInstruction->get_nodeName(&bstrNodeName);
  1816. if (wcscmp(bstrNodeName, L"xml") == 0)
  1817. {
  1818. bInstructionExists = TRUE;
  1819. }
  1821. SysFreeString(bstrNodeName);
  1822. }
  1824. XTPXML::IXMLDOMProcessingInstructionPtr ptrInstruction = 0;
  1825. if (!bInstructionExists && SUCCEEDED(m_xmlDocPtr->createProcessingInstruction(L"xml", CT2BSTR(strInstruction), &ptrInstruction)))
  1826. {
  1827. CXTPDOMNodePtr xmlNodePtr;
  1828. if (SUCCEEDED(m_xmlDocPtr->selectSingleNode(L"/node()", &xmlNodePtr)))
  1829. {
  1830. m_xmlDocPtr->insertBefore(ptrInstruction, _variant_t(xmlNodePtr.GetInterfacePtr()), 0);
  1831. }
  1832. }
  1834. HRESULT hr = m_xmlDocPtr->save(COleVariant(strFileName));
  1835. if (FAILED(hr))
  1836. return hr;
  1838. if (bFormatted)
  1839. {
  1840. FormatFile(strFileName);
  1841. }
  1843. return S_OK;
  1844. }
  1846. CXTPPropExchange* CXTPPropExchangeXMLNode::GetSection(LPCTSTR lpszSection)
  1847. {
  1848. OnBeforeExchange();
  1850. CXTPPropExchangeXMLNode* pSection = new CXTPPropExchangeXMLNode(IsLoading(), m_xmlSectionNode, lpszSection);
  1851. pSection->m_bCompactMode = m_bCompactMode;
  1852. pSection->InitSection(this);
  1853. return pSection;
  1854. }
  1856. BOOL CXTPPropExchangeXMLNode::OnBeforeExchange()
  1857. {
  1858. if (!m_bInitialized)
  1859. {
  1860. m_bInitialized = TRUE;
  1862. if (m_xmlDocPtr == NULL && IsRootSection())
  1863. {
  1864. ASSERT(m_xmlParentNode == 0);
  1866. if (!CreateDocumentInstance())
  1867. return FALSE;
  1869. if (m_xmlDocPtr == 0)
  1870. return FALSE;
  1872. m_xmlParentNode = m_xmlDocPtr;
  1873. ASSERT(m_xmlParentNode != 0);
  1874. }
  1876. if ((m_xmlDocPtr == NULL) || (m_xmlParentNode == NULL))
  1877. return FALSE;
  1879. ASSERT(m_xmlSectionNode == 0);
  1881. m_xmlSectionNode = GetProfileNode(m_strSectionName);
  1883. if (m_xmlSectionNode != NULL && IsRootSection())
  1884. {
  1885. PX_Bool(this, _T("CompactMode"), m_bCompactMode, FALSE);
  1886. }
  1887. }
  1889. if ((m_xmlDocPtr == NULL) || (m_xmlParentNode == NULL))
  1890. return FALSE;
  1892. return m_xmlSectionNode != NULL;
  1893. }
  1895. void CXTPPropExchangeXMLNode::EmptySection()
  1896. {
  1897. CXTPPropExchange::EmptySection();
  1899. OnBeforeExchange();
  1901. if (m_xmlSectionNode != 0 && m_xmlParentNode != 0)
  1902. {
  1903. m_xmlParentNode->removeChild(m_xmlSectionNode, NULL);
  1904. m_xmlSectionNode = 0;
  1905. m_bInitialized = FALSE;
  1906. }
  1907. }
  1909. void CXTPPropExchangeXMLNode::SetCompactMode(BOOL bCompactMode)
  1910. {
  1911. m_bCompactMode = bCompactMode;
  1912. }
  1915. CXTPDOMNodePtr CXTPPropExchangeXMLNode::GetProfileNode(LPCTSTR strSection)
  1916. {
  1917. ASSERT(m_xmlParentNode != 0);
  1918. CXTPDOMNodePtr xmlNodePtr;
  1919. CXTPDOMElementPtr xmlElementPtr;
  1921. HRESULT hr = m_xmlParentNode->selectSingleNode(CT2BSTR(strSection), &xmlNodePtr);
  1923. if (FAILED(hr) || xmlNodePtr == NULL)
  1924. {
  1925. m_xmlDocPtr->createElement(CT2BSTR(strSection), &xmlElementPtr);
  1926. ASSERT(xmlElementPtr != 0);
  1927. if (xmlElementPtr)
  1928. {
  1929. m_xmlParentNode->appendChild(xmlElementPtr, &xmlNodePtr);
  1930. }
  1931. }
  1933. return xmlNodePtr;
  1934. }
  1936. CXTPDOMNodePtr CXTPPropExchangeXMLNode::GetEntryNode(LPCTSTR lpszEntry, BOOL bCreate)
  1937. {
  1938. ASSERT(m_xmlSectionNode != 0);
  1940. CXTPDOMNodePtr xmlNodeEntryPtr;
  1942. if (lpszEntry == 0 || _tcslen(lpszEntry) == 0)
  1943. return m_xmlSectionNode;
  1945. if (m_bCompactMode)
  1946. {
  1947. XTPXML::IXMLDOMNamedNodeMapPtr map;
  1948. m_xmlSectionNode->get_attributes(&map);
  1949. HRESULT hr = map->getNamedItem(CT2BSTR(lpszEntry), &xmlNodeEntryPtr);
  1951. if (FAILED(hr) || xmlNodeEntryPtr == NULL)
  1952. {
  1953. if (bCreate)
  1954. {
  1955. XTPXML::IXMLDOMAttributePtr xmlElementPtr;
  1956. m_xmlDocPtr->createAttribute(CT2BSTR(lpszEntry), &xmlElementPtr);
  1957. if (xmlElementPtr)
  1958. {
  1959. map->setNamedItem(xmlElementPtr, &xmlNodeEntryPtr);
  1960. }
  1961. }
  1962. else
  1963. {
  1964. return 0;
  1965. }
  1966. }
  1967. }
  1968. else
  1969. {
  1970. CXTPDOMNodePtr xmlNodeSectionPtr = m_xmlSectionNode;
  1972. HRESULT hr = xmlNodeSectionPtr->selectSingleNode(CT2BSTR(lpszEntry), &xmlNodeEntryPtr);
  1973. if (FAILED(hr) || xmlNodeEntryPtr == NULL)
  1974. {
  1975. if (bCreate)
  1976. {
  1978. CXTPDOMElementPtr xmlElementPtr;
  1979. m_xmlDocPtr->createElement(CT2BSTR(lpszEntry), &xmlElementPtr);
  1980. ASSERT(xmlElementPtr != 0);
  1981. if (xmlElementPtr)
  1982. {
  1983. xmlNodeSectionPtr->appendChild(xmlElementPtr, &xmlNodeEntryPtr);
  1984. }
  1985. }
  1986. else
  1987. {
  1988. return 0;
  1989. }
  1990. }
  1992. }
  1993. ASSERT(xmlNodeEntryPtr != 0);
  1994. return xmlNodeEntryPtr;
  1995. }
  1997. CString CXTPPropExchangeXMLNode::BstrToString(BSTR bstrVal)
  1998. {
  1999. return CString(XTP_CW2CT(bstrVal));
  2000. }
  2002. BOOL CXTPPropExchangeXMLNode::ExchangeProp(LPCTSTR pszPropName, VARTYPE vtProp,
  2003. void* pvProp, const void* pvDefault)
  2004. {
  2005. if (m_bLoading)
  2006. {
  2007. if (!m_bUseDefaultOnLoad)
  2008. pvDefault = NULL;
  2010. if (!OnBeforeExchange())
  2011. return CopyPropValue(vtProp, pvProp, pvDefault);
  2013. CXTPDOMNodePtr xmlEntryPtr = GetEntryNode(pszPropName, FALSE);
  2014. if (xmlEntryPtr == 0)
  2015. return CopyPropValue(vtProp, pvProp, pvDefault);
  2017. BSTR bstrValue = NULL;
  2018. xmlEntryPtr->get_text(&bstrValue);
  2020. if (vtProp == VT_BSTR)
  2021. {
  2022. PreformatString(bstrValue);
  2023. *(BSTR*)pvProp = bstrValue;
  2024. return TRUE;
  2025. }
  2027. CString strValue(BstrToString(bstrValue));
  2028. if (bstrValue) SysFreeString(bstrValue);
  2030. return ExchangePropStringHelper(strValue, vtProp, pvProp, pvDefault);
  2031. }
  2032. else
  2033. {
  2034. if (!m_bUseDefaultOnSave)
  2035. pvDefault = NULL;
  2037. if (IsSamePropValue(vtProp, pvProp, pvDefault))
  2038. return TRUE;
  2040. if (!OnBeforeExchange())
  2041. return FALSE;
  2043. CXTPDOMNodePtr xmlEntryPtr = GetEntryNode(pszPropName, TRUE);
  2044. ASSERT(xmlEntryPtr != 0);
  2046. if (vtProp == VT_BSTR)
  2047. {
  2048. xmlEntryPtr->put_text(*(BSTR*)pvProp);
  2049. return TRUE;
  2050. }
  2052. CString strValue;
  2053. if (!ExchangePropStringHelper(strValue, vtProp, pvProp, pvDefault))
  2054. return FALSE;
  2056. xmlEntryPtr->put_text(CT2BSTR(strValue));
  2057. }
  2058. return TRUE;
  2060. }
  2061. CString CXTPPropExchangeXMLNode::GetSectionName()
  2062. {
  2063. if (!OnBeforeExchange())
  2064. return _T("");
  2066. BSTR bstrValue = NULL;
  2067. m_xmlSectionNode->get_nodeName(&bstrValue);
  2069. CString strValue(bstrValue);
  2070. if (bstrValue) SysFreeString(bstrValue);
  2072. return strValue;
  2073. }
  2075. BOOL CXTPPropExchangeXMLNode::IsSectionExists(LPCTSTR lpszSection)
  2076. {
  2077. if (!OnBeforeExchange())
  2078. return FALSE;
  2080. CXTPDOMNodePtr xmlNodePtr;
  2082. HRESULT hr = m_xmlSectionNode->selectSingleNode(CT2BSTR(lpszSection), &xmlNodePtr);
  2084. if (FAILED(hr) || xmlNodePtr == NULL)
  2085. return FALSE;
  2087. return TRUE;
  2088. }
  2090. BOOL CXTPPropExchangeXMLNode::PutSection(CXTPPropExchangeXMLNode* pNode)
  2091. {
  2092. if (!pNode)
  2093. return FALSE;
  2095. if (!OnBeforeExchange())
  2096. return FALSE;
  2098. if (!pNode || !pNode->OnBeforeExchange())
  2099. return FALSE;
  2101. ASSERT(m_xmlSectionNode != 0);
  2103. if (FAILED(m_xmlSectionNode->appendChild(pNode->m_xmlSectionNode, NULL)))
  2104. return FALSE;
  2106. return TRUE;
  2107. }
  2109. void CXTPPropExchangeXMLNode::SetLoading(BOOL bLoading)
  2110. {
  2111. m_bLoading = bLoading;
  2112. }
  2114. BOOL CXTPPropExchangeXMLNode::IsPropertyExists(LPCTSTR pszPropName)
  2115. {
  2116. if (!OnBeforeExchange())
  2117. return FALSE;
  2119. if (GetEntryNode(pszPropName, FALSE) != NULL)
  2120. return TRUE;
  2122. return FALSE;
  2123. }
  2126. class CXTPPropExchangeXMLNode::CXMLEnumerator : public CXTPPropExchangeEnumerator
  2127. {
  2128. public:
  2129. CXMLEnumerator::CXMLEnumerator(CXTPPropExchangeXMLNode* pContainer, LPCTSTR lpszSection)
  2130. : CXTPPropExchangeEnumerator(pContainer, lpszSection)
  2131. {
  2132. }
  2134. public:
  2135. CXTPDOMNodePtr GetProfileNode(POSITION pos)
  2136. {
  2137. CXTPDOMNodePtr xmlNodePtr;
  2139. CString strNode;
  2140. strNode.Format(_T("%s[%i]"), m_strSectionName.IsEmpty() ? _T("*") : (LPCTSTR)m_strSectionName, (int)(INT_PTR)pos);
  2142. if (SUCCEEDED(((CXTPPropExchangeXMLNode*)m_pContainer)->m_xmlSectionNode->selectSingleNode(CT2BSTR(strNode), &xmlNodePtr)))
  2143. return xmlNodePtr;
  2145. return 0;
  2147. }
  2149. POSITION GetPosition(DWORD dwCount = 0, BOOL /*bCompactMode*/ = TRUE)
  2150. {
  2151. m_nCount = dwCount;
  2153. if (!m_pContainer)
  2154. return NULL;
  2156. if (m_pContainer->IsLoading())
  2157. {
  2158. if (!m_pContainer->OnBeforeExchange())
  2159. return NULL;
  2161. m_xmNextNode = GetProfileNode(0);
  2162. if (m_xmNextNode == 0)
  2163. return NULL;
  2164. }
  2166. return (POSITION)1;
  2167. }
  2169. CXTPPropExchange* GetNext(POSITION& pos)
  2170. {
  2171. CXTPPropExchangeXMLNode* pSection = (CXTPPropExchangeXMLNode*)m_pContainer->GetSection(m_strSectionName);
  2173. CXTPDOMNodePtr xmlNodePtr;
  2174. CXTPDOMElementPtr xmlElementPtr;
  2177. if (m_pContainer->IsStoring())
  2178. {
  2179. ASSERT((DWORD)(DWORD_PTR)pos <= m_nCount);
  2181. pSection->m_xmlDocPtr->createElement(CT2BSTR(m_strSectionName), &xmlElementPtr);
  2182. ASSERT(xmlElementPtr != 0);
  2183. if (xmlElementPtr)
  2184. {
  2185. ((CXTPPropExchangeXMLNode*)m_pContainer)->m_xmlSectionNode->appendChild(xmlElementPtr, &xmlNodePtr);
  2186. }
  2188. pos++;
  2189. if ((DWORD)(DWORD_PTR)pos > m_nCount) pos = NULL;
  2190. }
  2191. else
  2192. {
  2193. ASSERT(m_xmNextNode != NULL);
  2195. xmlNodePtr = m_xmNextNode;
  2197. m_xmNextNode = GetProfileNode(pos);
  2198. if (m_xmNextNode == NULL)
  2199. pos = NULL;
  2200. else
  2201. pos++;
  2203. }
  2205. pSection->m_bInitialized = TRUE;
  2206. pSection->m_xmlSectionNode = xmlNodePtr;
  2208. return pSection;
  2209. }
  2210. protected:
  2211. CXTPDOMNodePtr m_xmNextNode;
  2212. };
  2216. CXTPPropExchangeEnumerator* CXTPPropExchangeXMLNode::GetEnumerator(LPCTSTR lpszSection)
  2217. {
  2218. if (IsStoring() || !IsPropertyExists(_T("Count")))
  2219. return new CXMLEnumerator(this, lpszSection);
  2221. return new CXTPPropExchangeEnumerator(this, lpszSection);
  2222. }
  2224. void CXTPPropExchangeXMLNode::SetEncoding(LPCTSTR lpszEncoding)
  2225. {
  2226. m_strEncoding = lpszEncoding;
  2227. }
  2229. #endif
  2231. //////////////////////////////////////////////////////////////////////////
  2232. // CXTPPropExchangeIniFile
  2234. IMPLEMENT_DYNAMIC(CXTPPropExchangeIniFile, CXTPPropExchange)
  2236. CXTPPropExchangeIniFile::CXTPPropExchangeIniFile(BOOL bLoading, LPCTSTR lpszParentSection, LPCTSTR lpszSection)
  2237. {
  2238. ASSERT(lpszSection != NULL);
  2240. m_bLoading = bLoading;
  2241. m_bTempFile = TRUE;
  2242. m_bEmptySection = TRUE;
  2244. if (lpszParentSection == NULL)
  2245. {
  2246. m_strSectionName = lpszSection;
  2247. }
  2248. else
  2249. {
  2250. m_strSectionName = CString(lpszParentSection) + _T("\") + CString(lpszSection);
  2251. }
  2253. }
  2255. CXTPPropExchangeIniFile::~CXTPPropExchangeIniFile()
  2256. {
  2257. if (IsRootSection() && !m_strFileName.IsEmpty() && m_bTempFile)
  2258. {
  2259. ::DeleteFile((LPTSTR)(LPCTSTR)m_strFileName);
  2260. }
  2262. }
  2265. void CXTPPropExchangeIniFile::EmptySection()
  2266. {
  2267. if (m_bEmptySection || m_strSectionName.IsEmpty())
  2268. return;
  2270. CXTPPropExchange::EmptySection();
  2272. size_t nLength = (size_t)m_strSectionName.GetLength();
  2273. LPTSTR lpszBuffer = 0;
  2274. int nSize = 8000;
  2276. do
  2277. {
  2278. lpszBuffer = new TCHAR[nSize];
  2279. int nResult = GetPrivateProfileSectionNames(lpszBuffer, nSize, m_strFileName);
  2281. if (nResult == 0)
  2282. {
  2283. delete[] lpszBuffer;
  2284. return;
  2285. }
  2287. if (nResult == nSize - 2)
  2288. {
  2289. nSize = nSize * 2;
  2290. delete[] lpszBuffer;
  2291. lpszBuffer = 0;
  2292. }
  2293. }
  2294. while (lpszBuffer == 0);
  2296. LPTSTR lpszSection = lpszBuffer;
  2297. size_t nSectionLen = _tcslen(lpszSection);
  2299. while (nSectionLen > 0)
  2300. {
  2301. if (nLength <= nSectionLen &&
  2302. (memcmp((LPCTSTR)m_strSectionName, lpszSection, nLength * sizeof(TCHAR)) == 0) &&
  2303. (nLength == nSectionLen || lpszSection[nLength] == _T('\')))
  2304. {
  2305. WritePrivateProfileString(lpszSection, NULL, NULL, m_strFileName);
  2306. }
  2308. lpszSection = lpszSection + nSectionLen + 1;
  2309. nSectionLen = _tcslen(lpszSection);
  2310. }
  2313. delete[] lpszBuffer;
  2314. }
  2316. CXTPPropExchange* CXTPPropExchangeIniFile::GetSection(LPCTSTR lpszSection)
  2317. {
  2318. OnBeforeExchange();
  2320. CXTPPropExchangeIniFile* pSection = new CXTPPropExchangeIniFile(IsLoading(), m_strSectionName, lpszSection);
  2321. pSection->InitSection(this);
  2322. pSection->m_strFileName = m_strFileName;
  2323. pSection->m_bTempFile = m_bTempFile;
  2324. return pSection;
  2325. }
  2327. BOOL CXTPPropExchangeIniFile::OnBeforeExchange()
  2328. {
  2329. if (!m_bInitialized)
  2330. {
  2331. if (m_strFileName.IsEmpty())
  2332. {
  2333. TCHAR lpszTempPath[MAX_PATH];
  2334. TCHAR lpszTempFileName[MAX_PATH];
  2336. if (GetTempPath(MAX_PATH, lpszTempPath) == 0)
  2337. return FALSE;
  2339. if (GetTempFileName(lpszTempPath, _T("xtp"), 0, lpszTempFileName) == 0)
  2340. return FALSE;
  2342. m_strFileName = lpszTempFileName;
  2343. m_bTempFile = TRUE;
  2344. }
  2346. m_bInitialized = TRUE;
  2347. }
  2348. return !m_strFileName.IsEmpty();
  2349. }
  2352. BOOL CXTPPropExchangeIniFile::ExchangeProp(LPCTSTR pszPropName, VARTYPE vtProp,
  2353. void* pvProp, const void* pvDefault /*= NULL*/)
  2354. {
  2355. if (m_bLoading)
  2356. {
  2357. if (!m_bUseDefaultOnLoad)
  2358. pvDefault = NULL;
  2360. if (!OnBeforeExchange())
  2361. return CopyPropValue(vtProp, pvProp, pvDefault);
  2363. CString strValue;
  2365. DWORD dwSize = GetPrivateProfileString(m_strSectionName, pszPropName, NULL, strValue.GetBuffer(256), 256, m_strFileName);
  2367. if (dwSize == 0)
  2368. return CopyPropValue(vtProp, pvProp, pvDefault);
  2370. if (dwSize == 256 - 1)
  2371. {
  2372. dwSize = GetPrivateProfileString(m_strSectionName, pszPropName, NULL, strValue.GetBuffer(16000), 16000, m_strFileName);
  2373. ASSERT(dwSize < 16000 - 1);
  2374. }
  2376. strValue.ReleaseBuffer(dwSize);
  2378. return ExchangePropStringHelper(strValue, vtProp, pvProp, pvDefault);
  2379. }
  2380. else
  2381. {
  2382. if (!m_bUseDefaultOnSave)
  2383. pvDefault = NULL;
  2385. if (!OnBeforeExchange())
  2386. return FALSE;
  2388. if (IsSamePropValue(vtProp, pvProp, pvDefault))
  2389. {
  2390. if (!m_bEmptySection)
  2391. WritePrivateProfileString (m_strSectionName, pszPropName, NULL, m_strFileName);
  2393. return TRUE;
  2394. }
  2396. CString strValue;
  2397. if (!ExchangePropStringHelper(strValue, vtProp, pvProp, pvDefault))
  2398. return FALSE;
  2400. if (!WritePrivateProfileString (m_strSectionName, pszPropName, strValue, m_strFileName))
  2401. return FALSE;
  2402. }
  2404. return TRUE;
  2405. }
  2408. void CXTPPropExchangeIniFile::SaveToFile(LPCTSTR strFileName)
  2409. {
  2410. ASSERT(IsRootSection() && IsStoring());
  2412. if (m_strFileName.Compare(strFileName) != 0 && !m_strFileName.IsEmpty())
  2413. {
  2414. ::DeleteFile(strFileName);
  2415. ::CopyFile(m_strFileName, strFileName, FALSE);
  2416. }
  2417. }
  2419. BOOL CXTPPropExchangeIniFile::LoadFromFile(LPCTSTR strFileName)
  2420. {
  2421. ASSERT(IsRootSection() && IsLoading());
  2423. if (!FILEEXISTS_S(strFileName))
  2424. return FALSE;
  2426. if (!OnBeforeExchange())
  2427. return FALSE;
  2429. return ::CopyFile(strFileName, m_strFileName, FALSE);
  2430. }
  2432. void CXTPPropExchangeIniFile::AssignFile(LPCTSTR strFileName)
  2433. {
  2434. m_strFileName = strFileName;
  2435. m_bTempFile = FALSE;
  2436. m_bEmptySection = FALSE;
  2437. }
  2440. /////////////////////////////////////////////////////////////////////////////
  2441. // PX_ functions
  2443. BOOL AFX_CDECL PX_Byte(CXTPPropExchange* pPX, LPCTSTR pszPropName, BYTE& nValue, BYTE nDefault)
  2444. {
  2445. ASSERT_POINTER(pPX, CXTPPropExchange);
  2446. ASSERT_POINTER(&nValue, short);
  2447. if (!pPX)
  2448. return FALSE;
  2450. return  pPX->ExchangeProp(pszPropName, VT_UI1, &nValue, &nDefault);
  2451. }
  2453. BOOL AFX_CDECL PX_Short(CXTPPropExchange* pPX, LPCTSTR pszPropName, short& sValue)
  2454. {
  2455. ASSERT_POINTER(pPX, CXTPPropExchange);
  2456. ASSERT_POINTER(&sValue, short);
  2457. if (!pPX)
  2458. return FALSE;
  2460. return  pPX->ExchangeProp(pszPropName, VT_I2, &sValue);
  2461. }
  2463. BOOL AFX_CDECL PX_Short(CXTPPropExchange* pPX, LPCTSTR pszPropName, short& sValue,
  2464. short sDefault)
  2465. {
  2466. ASSERT_POINTER(pPX, CXTPPropExchange);
  2467. ASSERT_POINTER(&sValue, short);
  2468. if (!pPX)
  2469. return FALSE;
  2471. return pPX->ExchangeProp(pszPropName, VT_I2, &sValue, &sDefault);
  2472. }
  2474. BOOL AFX_CDECL PX_UShort(CXTPPropExchange* pPX, LPCTSTR pszPropName, USHORT& usValue)
  2475. {
  2476. ASSERT_POINTER(pPX, CXTPPropExchange);
  2477. ASSERT_POINTER(&usValue, USHORT);
  2478. if (!pPX)
  2479. return FALSE;
  2481. return pPX->ExchangeProp(pszPropName, VT_I2, &usValue);
  2482. }
  2484. BOOL AFX_CDECL PX_UShort(CXTPPropExchange* pPX, LPCTSTR pszPropName, USHORT& usValue,
  2485. USHORT usDefault)
  2486. {
  2487. ASSERT_POINTER(pPX, CXTPPropExchange);
  2488. ASSERT_POINTER(&usValue, USHORT);
  2489. if (!pPX)
  2490. return FALSE;
  2492. return pPX->ExchangeProp(pszPropName, VT_I2, &usValue, &usDefault);
  2493. }
  2495. BOOL AFX_CDECL PX_Long(CXTPPropExchange* pPX, LPCTSTR pszPropName, long& lValue)
  2496. {
  2497. ASSERT_POINTER(pPX, CXTPPropExchange);
  2498. ASSERT_POINTER(&lValue, long);
  2499. if (!pPX)
  2500. return FALSE;
  2502. return pPX->ExchangeProp(pszPropName, VT_I4, &lValue);
  2503. }
  2505. BOOL AFX_CDECL PX_Long(CXTPPropExchange* pPX, LPCTSTR pszPropName, long& lValue,
  2506. long lDefault)
  2507. {
  2508. ASSERT_POINTER(pPX, CXTPPropExchange);
  2509. ASSERT_POINTER(&lValue, long);
  2510. if (!pPX)
  2511. return FALSE;
  2513. return pPX->ExchangeProp(pszPropName, VT_I4, &lValue, &lDefault);
  2514. }
  2516. BOOL AFX_CDECL PX_DWord(CXTPPropExchange* pPX, LPCTSTR pszPropName, DWORD& dwValue)
  2517. {
  2518. ASSERT_POINTER(pPX, CXTPPropExchange);
  2519. ASSERT_POINTER(&dwValue, DWORD);
  2520. if (!pPX)
  2521. return FALSE;
  2523. return pPX->ExchangeProp(pszPropName, VT_I4, &dwValue);
  2524. }
  2526. BOOL AFX_CDECL PX_DWord(CXTPPropExchange* pPX, LPCTSTR pszPropName, DWORD& dwValue,
  2527. DWORD dwDefault)
  2528. {
  2529. ASSERT_POINTER(pPX, CXTPPropExchange);
  2530. ASSERT_POINTER(&dwValue, DWORD);
  2531. if (!pPX)
  2532. return FALSE;
  2534. return pPX->ExchangeProp(pszPropName, VT_I4, &dwValue, &dwDefault);
  2535. }
  2537. BOOL AFX_CDECL PX_UI8(CXTPPropExchange* pPX, LPCTSTR pszPropName,
  2538. ULONGLONG& ullValue, ULONGLONG ullDefault)
  2539. {
  2540. POINT ptData64 = {(LONG)(DWORD)(ullValue >> 32), (LONG)(DWORD)ullValue};
  2541. POINT ptDefault = {(LONG)(DWORD)(ullDefault >> 32), (LONG)(DWORD)ullDefault};
  2543. BOOL bResult = PX_Point(pPX, pszPropName, ptData64, ptDefault);
  2545. if (bResult && pPX->IsLoading())
  2546. {
  2547. ullValue = (DWORD)ptData64.x;
  2548. ullValue = ullValue << 32;
  2549. ullValue += (DWORD)ptData64.y;
  2550. }
  2552. return bResult;
  2553. }
  2555. BOOL AFX_CDECL PX_Int(CXTPPropExchange* pPX, LPCTSTR pszPropName, int& nValue)
  2556. {
  2557. ASSERT_POINTER(pPX, CXTPPropExchange);
  2558. ASSERT_POINTER(&nValue, int);
  2559. if (!pPX)
  2560. return FALSE;
  2562. return pPX->ExchangeProp(pszPropName, VT_I4, &nValue);
  2563. }
  2565. BOOL AFX_CDECL PX_Int(CXTPPropExchange* pPX, LPCTSTR pszPropName, int& nValue,
  2566. int nDefault)
  2567. {
  2568. ASSERT_POINTER(pPX, CXTPPropExchange);
  2569. ASSERT_POINTER(&nValue, int);
  2570. if (!pPX)
  2571. return FALSE;
  2573. return pPX->ExchangeProp(pszPropName, VT_I4, &nValue, &nDefault);
  2574. }
  2576. BOOL AFX_CDECL PX_ULong(CXTPPropExchange* pPX, LPCTSTR pszPropName, ULONG& ulValue)
  2577. {
  2578. ASSERT_POINTER(pPX, CXTPPropExchange);
  2579. ASSERT_POINTER(&ulValue, ULONG);
  2580. if (!pPX)
  2581. return FALSE;
  2583. return pPX->ExchangeProp(pszPropName, VT_I4, &ulValue);
  2584. }
  2586. BOOL AFX_CDECL PX_ULong(CXTPPropExchange* pPX, LPCTSTR pszPropName, ULONG& ulValue,
  2587. ULONG ulDefault)
  2588. {
  2589. ASSERT_POINTER(pPX, CXTPPropExchange);
  2590. ASSERT_POINTER(&ulValue, ULONG);
  2591. if (!pPX)
  2592. return FALSE;
  2594. return pPX->ExchangeProp(pszPropName, VT_I4, &ulValue, &ulDefault);
  2595. }
  2597. BOOL AFX_CDECL PX_Bool(CXTPPropExchange* pPX, LPCTSTR pszPropName, BOOL& bValue)
  2598. {
  2599. ASSERT_POINTER(pPX, CXTPPropExchange);
  2600. ASSERT_POINTER(&bValue, BOOL);
  2601. if (!pPX)
  2602. return FALSE;
  2604. return pPX->ExchangeProp(pszPropName, VT_BOOL, &bValue);
  2605. }
  2607. BOOL AFX_CDECL PX_Bool(CXTPPropExchange* pPX, LPCTSTR pszPropName, BOOL& bValue,
  2608. BOOL bDefault)
  2609. {
  2610. ASSERT_POINTER(pPX, CXTPPropExchange);
  2611. ASSERT_POINTER(&bValue, BOOL);
  2612. if (!pPX)
  2613. return FALSE;
  2615. return pPX->ExchangeProp(pszPropName, VT_BOOL, &bValue, &bDefault);
  2616. }
  2618. BOOL AFX_CDECL PX_String(CXTPPropExchange* pPX, LPCTSTR pszPropName, CString& strValue)
  2619. {
  2620. ASSERT_POINTER(pPX, CXTPPropExchange);
  2621. ASSERT_POINTER(&strValue, CString);
  2622. if (!pPX)
  2623. return FALSE;
  2625. return pPX->ExchangeProp(pszPropName, VT_LPSTR, &strValue);
  2626. }
  2628. BOOL AFX_CDECL PX_String(CXTPPropExchange* pPX, LPCTSTR pszPropName, CString& strValue,
  2629. LPCTSTR lpszDefault)
  2630. {
  2631. ASSERT_POINTER(pPX, CXTPPropExchange);
  2632. ASSERT_POINTER(&strValue, CString);
  2633. if (!pPX)
  2634. return FALSE;
  2636. return pPX->ExchangeProp(pszPropName, VT_LPSTR, &strValue, lpszDefault);
  2637. }
  2639. BOOL AFX_CDECL PX_Bstr(CXTPPropExchange* pPX, LPCTSTR pszPropName, BSTR& lpszValue,
  2640. BSTR lpszDefault)
  2641. {
  2642. ASSERT_POINTER(pPX, CXTPPropExchange);
  2643. ASSERT_POINTER(&lpszValue, BSTR);
  2644. if (!pPX)
  2645. return FALSE;
  2647. return pPX->ExchangeProp(pszPropName, VT_BSTR, &lpszValue, lpszDefault);
  2648. }
  2650. BOOL AFX_CDECL PX_Float(CXTPPropExchange* pPX, LPCTSTR pszPropName, float& floatValue)
  2651. {
  2652. ASSERT_POINTER(pPX, CXTPPropExchange);
  2653. ASSERT_POINTER(&floatValue, float);
  2654. if (!pPX)
  2655. return FALSE;
  2657. return pPX->ExchangeProp(pszPropName, VT_R4, &floatValue);
  2658. }
  2660. BOOL AFX_CDECL PX_Float(CXTPPropExchange* pPX, LPCTSTR pszPropName, float& floatValue,
  2661. float floatDefault)
  2662. {
  2663. ASSERT_POINTER(pPX, CXTPPropExchange);
  2664. ASSERT_POINTER(&floatValue, float);
  2665. if (!pPX)
  2666. return FALSE;
  2668. return pPX->ExchangeProp(pszPropName, VT_R4, &floatValue, &floatDefault);
  2669. }
  2671. BOOL AFX_CDECL PX_Double(CXTPPropExchange* pPX, LPCTSTR pszPropName, double& doubleValue)
  2672. {
  2673. ASSERT_POINTER(pPX, CXTPPropExchange);
  2674. ASSERT_POINTER(&doubleValue, double);
  2675. if (!pPX)
  2676. return FALSE;
  2678. return pPX->ExchangeProp(pszPropName, VT_R8, &doubleValue);
  2679. }
  2681. BOOL AFX_CDECL PX_DateTime(CXTPPropExchange* pPX, LPCTSTR pszPropName, COleDateTime& dtValue)
  2682. {
  2683. ASSERT_POINTER(pPX, CXTPPropExchange);
  2684. ASSERT_POINTER(&dtValue, COleDateTime);
  2685. if (!pPX)
  2686. return FALSE;
  2688. return pPX->ExchangeProp(pszPropName, VT_DATE, &dtValue);
  2689. }
  2691. BOOL AFX_CDECL PX_Double(CXTPPropExchange* pPX, LPCTSTR pszPropName, double& doubleValue,
  2692. double doubleDefault)
  2693. {
  2694. ASSERT_POINTER(pPX, CXTPPropExchange);
  2695. ASSERT_POINTER(&doubleValue, double);
  2696. if (!pPX)
  2697. return FALSE;
  2699. return pPX->ExchangeProp(pszPropName, VT_R8, &doubleValue, &doubleDefault);
  2700. }
  2702. BOOL AFX_CDECL PX_Size(CXTPPropExchange* pPX, LPCTSTR pszPropName, SIZE& szValue, SIZE szDefault)
  2703. {
  2704. ASSERT_POINTER(pPX, CXTPPropExchange);
  2705. if (!pPX)
  2706. return FALSE;
  2708. return pPX->ExchangeProp(pszPropName, VT_EX_SIZE, &szValue, &szDefault);
  2709. }
  2711. BOOL AFX_CDECL PX_Point(CXTPPropExchange* pPX, LPCTSTR pszPropName, POINT& ptValue, POINT ptDefault)
  2712. {
  2713. ASSERT_POINTER(pPX, CXTPPropExchange);
  2714. ASSERT(sizeof(POINT) == sizeof(SIZE));
  2715. if (!pPX)
  2716. return FALSE;
  2718. return pPX->ExchangeProp(pszPropName, VT_EX_SIZE, &ptValue, &ptDefault);
  2719. }
  2721. BOOL AFX_CDECL PX_Rect(CXTPPropExchange* pPX, LPCTSTR pszPropName, RECT& rcValue, RECT rcDefault)
  2722. {
  2723. ASSERT_POINTER(pPX, CXTPPropExchange);
  2724. if (!pPX)
  2725. return FALSE;
  2727. return pPX->ExchangeProp(pszPropName, VT_EX_RECT, &rcValue, &rcDefault);
  2728. }
  2730. BOOL AFX_CDECL PX_Variant(CXTPPropExchange* pPX, LPCTSTR pszPropName, COleVariant& variant, COleVariant variantDefault)
  2731. {
  2732. ASSERT_POINTER(pPX, CXTPPropExchange);
  2733. if (!pPX)
  2734. return FALSE;
  2736. return pPX->ExchangeProp(pszPropName, VT_VARIANT, &variant, &variantDefault);
  2737. }
  2740. BOOL AFX_CDECL PX_RuntimeClass(CXTPPropExchange* pPX, LPCTSTR pszPropName, CRuntimeClass*& pClass, CRuntimeClass* pDefaultClass)
  2741. {
  2742. if (!pPX)
  2743. return FALSE;
  2745. return pPX->ExchangeRuntimeClass(pszPropName, pClass, pDefaultClass);
  2746. }
  2748. BOOL AFX_CDECL PX_Blob(CXTPPropExchange* pPX, LPCTSTR pszPropName, BYTE*& pData, DWORD& nBytes)
  2749. {
  2750. if (!pPX)
  2751. return FALSE;
  2753. return pPX->ExchangeBlobProp(pszPropName, pData, nBytes);
  2754. }
  2757. BOOL AFX_CDECL PX_Serialize(CXTPPropExchange* pPX, LPCTSTR pszPropName, CObject* pObject)
  2758. {
  2759. if (!pPX)
  2760. return FALSE;
  2762. CArchive* pArchive = pPX->GetArchive(pszPropName);
  2764. if (!pArchive)
  2765. return FALSE;
  2767. BOOL bResult = FALSE;
  2768. try
  2769. {
  2770. pObject->Serialize(*pArchive);
  2771. bResult = TRUE;
  2772. }
  2773. catch (COleException* pEx)
  2774. {
  2775. pEx->Delete ();
  2777. }
  2778. catch (CArchiveException* pEx)
  2779. {
  2780. pEx->Delete ();
  2781. }
  2783. pPX->ReleaseArchive(pszPropName, pArchive);
  2785. return bResult;
  2786. }