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

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

对话框与窗口

开发平台：

Visual C++

XTRegistryManager.cpp：源码内容
  1. // XTRegistryManager.cpp : implementation file
  2. //
  3. // This file is a part of the XTREME CONTROLS 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"
  23. #include "Common/XTPVC80Helpers.h"
  24. #include "XTRegistryManager.h"
  26. #ifdef _DEBUG
  27. #define new DEBUG_NEW
  28. #undef THIS_FILE
  29. static char THIS_FILE[] = __FILE__;
  30. #endif
  32. /////////////////////////////////////////////////////////////////////////////
  33. // CHKey - helper automatically closes open HKEY
  35. class CXTRegistryManager::CHKey
  36. {
  37. public:
  38. CHKey(HKEY hKey = NULL) : m_hKey(hKey)
  39. {
  40. }
  42. ~CHKey()
  43. {
  44. if (m_hKey != NULL)
  45. {
  46. ::RegCloseKey(m_hKey);
  47. }
  48. }
  50. HKEY& operator=(HKEY hKey)
  51. {
  52. if (m_hKey != NULL)
  53. {
  54. ::RegCloseKey(m_hKey);
  55. }
  57. m_hKey = hKey;
  58. return m_hKey;
  59. }
  61. BOOL operator==(HKEY hKey)
  62. {
  63. return m_hKey == hKey;
  64. }
  66. operator HKEY() const
  67. {
  68. return m_hKey;
  69. }
  71. operator PHKEY()
  72. {
  73. return &m_hKey;
  74. }
  76. private:
  77. HKEY m_hKey;
  78. };
  80. /////////////////////////////////////////////////////////////////////////////
  81. // CXTRegistryManager
  83. CString CXTRegistryManager::m_strINIFileName = _T("");
  85. CXTRegistryManager::CXTRegistryManager(HKEY hKeyBase/*= HKEY_CURRENT_USER*/)
  86. : m_pszRegistryKey(NULL)
  87. , m_pszProfileName(NULL)
  88. , m_lResult(ERROR_SUCCESS)
  89. {
  90. ASSERT(hKeyBase == HKEY_CURRENT_USER || hKeyBase == HKEY_LOCAL_MACHINE);
  91. m_hKeyBase = hKeyBase;
  92. }
  94. CXTRegistryManager::~CXTRegistryManager()
  95. {
  97. }
  99. BOOL CXTRegistryManager::GetProfileInfo()
  100. {
  101. if (m_pszRegistryKey == NULL || m_pszProfileName == NULL)
  102. {
  103. CWinApp* pWinApp = AfxGetApp();
  104. if (pWinApp != NULL)
  105. {
  106. m_pszRegistryKey = pWinApp->m_pszRegistryKey;
  107. m_pszProfileName = pWinApp->m_pszProfileName;
  108. }
  110. // If this fails, you need to call SetRegistryKey(...); in your
  111. // applications CWinApp::InitInstance() override, or you have called
  112. // this method before you call SetRegistryKey..  Calling SetRegistryKey
  113. // will initialize m_pszProfileName and m_pszRegistryKey for CWinApp.
  115. // NOTE: If you want to write to an INI file instead of the system
  116. // registry, call CXTRegistryManager::SetINIFileName(...) prior to
  117. // making this call.
  119. if (m_pszRegistryKey == NULL || m_pszProfileName == NULL)
  120. {
  121. return FALSE;
  122. }
  123. }
  125. return TRUE;
  126. }
  128. /////////////////////////////////////////////////////////////////////////////
  130. HKEY CXTRegistryManager::GetAppRegistryKey(REGSAM samDesired)
  131. {
  132. if (!GetProfileInfo())
  133. return 0;
  135. HKEY hAppKey = NULL;
  136. CHKey hSoftKey;
  137. CHKey hCompanyKey;
  139. m_lResult = ::RegOpenKeyEx(m_hKeyBase, _T("Software"), 0,
  140. samDesired, hSoftKey);
  142. if (m_lResult != ERROR_SUCCESS)
  143. return NULL;
  145. DWORD dw = 0;
  146. m_lResult = ::RegCreateKeyEx(hSoftKey, m_pszRegistryKey, 0, REG_NONE,
  147. REG_OPTION_NON_VOLATILE, samDesired, NULL, hCompanyKey, &dw);
  149. if (m_lResult != ERROR_SUCCESS)
  150. return NULL;
  152. m_lResult = ::RegCreateKeyEx(hCompanyKey, m_pszProfileName, 0, REG_NONE,
  153. REG_OPTION_NON_VOLATILE, samDesired, NULL, &hAppKey, &dw);
  155. if (m_lResult != ERROR_SUCCESS)
  156. return NULL;
  158. return hAppKey;
  159. }
  161. HKEY CXTRegistryManager::GetSectionKey(LPCTSTR lpszSection, REGSAM samDesired)
  162. {
  163. ASSERT(lpszSection != NULL);
  164. if (!lpszSection)
  165. return 0;
  167. HKEY hSectionKey = NULL;
  168. CHKey hAppKey(GetAppRegistryKey(samDesired));
  170. if (hAppKey == NULL)
  171. return NULL;
  173. DWORD dw = 0;
  174. m_lResult = ::RegCreateKeyEx(hAppKey, lpszSection, 0, REG_NONE,
  175. REG_OPTION_NON_VOLATILE, samDesired, NULL, &hSectionKey, &dw);
  177. if (m_lResult != ERROR_SUCCESS)
  178. return NULL;
  180. return hSectionKey;
  181. }
  183. BOOL CXTRegistryManager::WriteProfileInt(LPCTSTR lpszSection, LPCTSTR lpszEntry, int nValue)
  184. {
  185. ASSERT(lpszSection != NULL);
  186. ASSERT(lpszEntry != NULL);
  187. if (!lpszSection)
  188. return 0;
  190. if (m_strINIFileName.IsEmpty())
  191. {
  192. if (!GetProfileInfo())
  193. return FALSE;
  195. CHKey hSecKey(GetSectionKey(lpszSection));
  196. if (hSecKey == NULL)
  197. return FALSE;
  199. m_lResult = ::RegSetValueEx(hSecKey, lpszEntry, NULL,
  200. REG_DWORD, (LPBYTE)&nValue, sizeof(nValue));
  202. if (m_lResult != ERROR_SUCCESS)
  203. return FALSE;
  205. return TRUE;
  206. }
  207. else
  208. {
  209. ASSERT(m_strINIFileName.IsEmpty() == FALSE);
  211. TCHAR szT[16];
  212. wsprintf(szT, _T("%d"), nValue);
  213. return ::WritePrivateProfileString(lpszSection, lpszEntry, szT,
  214. m_strINIFileName);
  215. }
  216. }
  218. BOOL CXTRegistryManager::WriteProfileBinary(LPCTSTR lpszSection, LPCTSTR lpszEntry, LPBYTE pData, UINT nBytes)
  219. {
  220. ASSERT(lpszSection != NULL);
  221. ASSERT(lpszEntry != NULL);
  223. if (m_strINIFileName.IsEmpty())
  224. {
  225. if (!GetProfileInfo())
  226. return FALSE;
  228. CHKey hSecKey(GetSectionKey(lpszSection));
  229. if (hSecKey == NULL)
  230. return FALSE;
  232. m_lResult = ::RegSetValueEx(hSecKey, lpszEntry, NULL, REG_BINARY,
  233. pData, nBytes);
  235. if (m_lResult != ERROR_SUCCESS)
  236. return FALSE;
  238. return TRUE;
  239. }
  241. // convert to string and write out
  242. LPTSTR lpsz = new TCHAR[nBytes * 2 + 1];
  243. UINT i;
  244. for (i = 0; i < nBytes; i++)
  245. {
  246. lpsz[i * 2] = (TCHAR)((pData[i] & 0x0F) + 'A'); //low nibble
  247. lpsz[i * 2 + 1] = (TCHAR)(((pData[i] >> 4) & 0x0F) + 'A'); //high nibble
  248. }
  249. lpsz[i * 2] = 0;
  251. ASSERT(m_strINIFileName.IsEmpty() == FALSE);
  253. BOOL bResult = WriteProfileString(lpszSection, lpszEntry, lpsz);
  254. delete[] lpsz;
  255. return bResult;
  256. }
  258. BOOL CXTRegistryManager::WriteProfileString(LPCTSTR lpszSection, LPCTSTR lpszEntry, LPCTSTR lpszValue)
  259. {
  260. ASSERT(lpszSection != NULL);
  261. if (!lpszSection)
  262. return 0;
  264. if (m_strINIFileName.IsEmpty())
  265. {
  266. if (!GetProfileInfo())
  267. return FALSE;
  269. if (lpszEntry == NULL) //delete whole section
  270. {
  271. CHKey hAppKey(GetAppRegistryKey(FALSE));
  272. if (hAppKey == NULL)
  273. return FALSE;
  275. m_lResult = ::RegDeleteKey(hAppKey, lpszSection);
  277. if (m_lResult != ERROR_SUCCESS)
  278. return FALSE;
  279. }
  280. else if (lpszValue == NULL)
  281. {
  282. CHKey hSecKey(GetSectionKey(lpszSection));
  283. if (hSecKey == NULL)
  284. return FALSE;
  286. // necessary to cast away const below
  287. m_lResult = ::RegDeleteValue(hSecKey, (LPTSTR)lpszEntry);
  289. if (m_lResult != ERROR_SUCCESS)
  290. return FALSE;
  291. }
  292. else
  293. {
  294. CHKey hSecKey(GetSectionKey(lpszSection));
  295. if (hSecKey == NULL)
  296. return FALSE;
  298. m_lResult = ::RegSetValueEx(hSecKey, lpszEntry, NULL, REG_SZ,
  299. (LPBYTE)lpszValue, (lstrlen(lpszValue)+1)*sizeof(TCHAR));
  301. if (m_lResult != ERROR_SUCCESS)
  302. return FALSE;
  303. }
  305. return TRUE;
  306. }
  307. else
  308. {
  309. ASSERT(m_strINIFileName.IsEmpty() == FALSE);
  310. ASSERT(m_strINIFileName.GetLength() < 4095); // can't read in bigger
  311. return ::WritePrivateProfileString(lpszSection, lpszEntry, lpszValue,
  312. m_strINIFileName);
  313. }
  314. }
  316. UINT CXTRegistryManager::GetProfileInt(LPCTSTR lpszSection, LPCTSTR lpszEntry, int nDefault)
  317. {
  318. ASSERT(lpszSection != NULL);
  319. ASSERT(lpszEntry != NULL);
  320. if (!lpszSection || !lpszEntry)
  321. return 0;
  323. if (m_strINIFileName.IsEmpty()) // use registry
  324. {
  325. if (!GetProfileInfo())
  326. return nDefault;
  328. CHKey hSecKey(GetSectionKey(lpszSection, KEY_READ));
  329. if (hSecKey == NULL)
  330. return nDefault;
  332. DWORD dwValue;
  333. DWORD dwType;
  334. DWORD dwCount = sizeof(DWORD);
  336. m_lResult = ::RegQueryValueEx(hSecKey, (LPTSTR)lpszEntry, NULL, &dwType,
  337. (LPBYTE)&dwValue, &dwCount);
  339. if (m_lResult != ERROR_SUCCESS)
  340. return nDefault;
  342. ASSERT(dwType == REG_DWORD);
  343. ASSERT(dwCount == sizeof(dwValue));
  345. return (UINT)dwValue;
  346. }
  347. else
  348. {
  349. ASSERT(m_strINIFileName.IsEmpty() == FALSE);
  350. return ::GetPrivateProfileInt(lpszSection, lpszEntry, nDefault,
  351. m_strINIFileName);
  352. }
  353. }
  355. BOOL CXTRegistryManager::GetProfileBinary(LPCTSTR lpszSection, LPCTSTR lpszEntry, BYTE** ppData, UINT* pBytes)
  356. {
  357. ASSERT(lpszSection != NULL);
  358. ASSERT(lpszEntry != NULL);
  359. ASSERT(ppData != NULL);
  360. ASSERT(pBytes != NULL);
  361. if (!ppData || !pBytes)
  362. return FALSE;
  364. *ppData = NULL;
  365. *pBytes = 0;
  367. if (m_strINIFileName.IsEmpty())
  368. {
  369. if (!GetProfileInfo())
  370. return FALSE;
  372. CHKey hSecKey(GetSectionKey(lpszSection, KEY_READ));
  373. if (hSecKey == NULL)
  374. return FALSE;
  376. DWORD dwType, dwCount;
  377. m_lResult = ::RegQueryValueEx(hSecKey, (LPTSTR)lpszEntry, NULL, &dwType,
  378. NULL, &dwCount);
  380. if (m_lResult != ERROR_SUCCESS)
  381. return FALSE;
  383. *pBytes = dwCount;
  384. *ppData = new BYTE[*pBytes];
  385. ASSERT(dwType == REG_BINARY);
  387. m_lResult = ::RegQueryValueEx(hSecKey, (LPTSTR)lpszEntry, NULL, &dwType,
  388. *ppData, &dwCount);
  390. if (m_lResult != ERROR_SUCCESS)
  391. {
  392. SAFE_DELETE_AR(*ppData);
  393. return FALSE;
  394. }
  396. ASSERT(dwType == REG_BINARY);
  397. return TRUE;
  398. }
  399. else
  400. {
  401. ASSERT(m_strINIFileName.IsEmpty() == FALSE);
  403. CString str = GetProfileString(lpszSection, lpszEntry, NULL);
  404. if (str.IsEmpty())
  405. return FALSE;
  406. ASSERT(str.GetLength()%2 == 0);
  407. int nLen = str.GetLength();
  408. *pBytes = nLen/2;
  409. *ppData = new BYTE[*pBytes];
  410. int i;
  411. for (i = 0; i < nLen; i += 2)
  412. {
  413. (*ppData)[i/2] = (BYTE)
  414. (((str[i + 1] - 'A') << 4) + (str[i] - 'A'));
  415. }
  416. return TRUE;
  417. }
  418. }
  420. CString CXTRegistryManager::GetProfileString(LPCTSTR lpszSection, LPCTSTR lpszEntry, LPCTSTR lpszDefault)
  421. {
  422. ASSERT(lpszSection != NULL);
  423. ASSERT(lpszEntry != NULL);
  424. if (m_strINIFileName.IsEmpty())
  425. {
  426. if (!GetProfileInfo())
  427. return lpszDefault;
  429. CHKey hSecKey(GetSectionKey(lpszSection, KEY_READ));
  430. if (hSecKey == NULL)
  431. return lpszDefault;
  433. CString strValue;
  434. DWORD dwType, dwCount;
  436. m_lResult = ::RegQueryValueEx(hSecKey, (LPTSTR)lpszEntry, NULL, &dwType,
  437. NULL, &dwCount);
  439. if (m_lResult != ERROR_SUCCESS)
  440. return lpszDefault;
  442. ASSERT(dwType == REG_SZ);
  443. m_lResult = ::RegQueryValueEx(hSecKey, (LPTSTR)lpszEntry, NULL, &dwType,
  444. (LPBYTE)strValue.GetBuffer(dwCount/sizeof(TCHAR)), &dwCount);
  445. strValue.ReleaseBuffer();
  447. if (m_lResult != ERROR_SUCCESS)
  448. return lpszDefault;
  450. ASSERT(dwType == REG_SZ);
  451. return strValue;
  452. }
  453. else
  454. {
  455. TCHAR chNil = '';
  457. ASSERT(m_strINIFileName.IsEmpty() == FALSE);
  459. if (lpszDefault == NULL)
  460. {
  461. lpszDefault = &chNil;    // don't pass in NULL
  462. }
  464. TCHAR szT[4096];
  465. DWORD dw = ::GetPrivateProfileString(lpszSection, lpszEntry,
  466. lpszDefault, szT, _countof(szT), m_strINIFileName);
  467. ASSERT(dw < 4095);
  468. return szT;
  469. }
  470. }
  472. int CXTRegistryManager::EnumValues(LPCTSTR lpszSection, CMap<CString, LPCTSTR, DWORD, DWORD&>* mapItems,
  473. CStringArray * arrayNames)
  474. {
  475. ASSERT(lpszSection != NULL);
  477. CHKey hKey(GetSectionKey(lpszSection, KEY_READ));
  478. if (hKey == NULL)
  479. return 0;
  481. int index = 0;
  483. TCHAR szValue[512];
  484. DWORD dwLen = 512;
  485. DWORD dwType;
  487. while (::RegEnumValue(hKey, index++, szValue, &dwLen,
  488. NULL, &dwType, NULL, NULL) == ERROR_SUCCESS)
  489. {
  490. if (mapItems) mapItems->SetAt(szValue, dwType);
  491. if (arrayNames) arrayNames->Add(szValue);
  492. dwLen = 512;
  493. }
  495. return --index;
  496. }
  498. int CXTRegistryManager::EnumKeys(LPCTSTR lpszSection, CStringArray & arrayKeys)
  499. {
  500. ASSERT(lpszSection != NULL);
  502. CHKey hKey(GetSectionKey(lpszSection, KEY_READ));
  503. if (hKey == NULL)
  504. return 0;
  506. int index = 0;
  508. TCHAR szValue[512];
  509. DWORD dwLen = 512;
  511. while (::RegEnumKeyEx(hKey, index++, szValue, &dwLen,
  512. NULL, NULL, NULL, NULL) == ERROR_SUCCESS)
  513. {
  514. arrayKeys.Add(szValue);
  515. dwLen = 512;
  516. }
  518. return --index;
  519. }
  521. LONG CXTRegistryManager::RecurseDeleteKey(HKEY hKey, LPCTSTR lpszKey)
  522. {
  523. CHKey hSubKey;
  524. LONG lRes = ::RegOpenKeyEx(hKey, lpszKey, 0, KEY_READ | KEY_WRITE, hSubKey);
  525. if (lRes != ERROR_SUCCESS)
  526. return lRes;
  528. FILETIME time;
  529. DWORD dwSize = 256;
  530. TCHAR szBuffer[256];
  532. while (::RegEnumKeyEx(hSubKey, 0, szBuffer, &dwSize, NULL, NULL, NULL,
  533. &time) == ERROR_SUCCESS)
  534. {
  535. lRes = RecurseDeleteKey(hSubKey, szBuffer);
  536. if (lRes != ERROR_SUCCESS)
  537. return lRes;
  539. dwSize = 256;
  540. }
  542. m_lResult = ::RegDeleteKey(hKey, lpszKey);
  543. return m_lResult;
  544. }
  546. bool CXTRegistryManager::DeleteKey(LPCTSTR lpszSection, LPCTSTR lpszKey)
  547. {
  548. CHKey hSectionKey(GetSectionKey(lpszSection));
  549. if (hSectionKey == NULL)
  550. return false;
  552. return (RecurseDeleteKey(hSectionKey, lpszKey) == ERROR_SUCCESS);
  553. }
  555. bool CXTRegistryManager::DeleteValue(LPCTSTR lpszSection, LPCTSTR lpszValue)
  556. {
  557. CHKey hSecKey(GetSectionKey(lpszSection, KEY_ALL_ACCESS));
  558. if (hSecKey == NULL)
  559. return false;
  561. m_lResult = ::RegDeleteValue(hSecKey, (LPTSTR)lpszValue);
  562. return (m_lResult == ERROR_SUCCESS);
  563. }
  565. BOOL CXTRegistryManager::WriteProfilePoint(LPCTSTR lpszSection, LPCTSTR lpszEntry, CPoint* pValue)
  566. {
  567. ASSERT(lpszSection != NULL);
  568. if (m_strINIFileName.IsEmpty())
  569. {
  570. if (!GetProfileInfo())
  571. return FALSE;
  573. CHKey hSecKey(GetSectionKey(lpszSection));
  574. if (hSecKey == NULL)
  575. return FALSE;
  577. m_lResult = ::RegSetValueEx(hSecKey, lpszEntry, NULL, REG_BINARY,
  578. (LPBYTE)pValue, sizeof(CPoint));
  580. if (m_lResult != ERROR_SUCCESS)
  581. return FALSE;
  583. return TRUE;
  584. }
  586. ASSERT(m_strINIFileName.IsEmpty() == FALSE);
  588. CString str;
  589. str.Format(_T("%i,%i"), pValue->x, pValue->y);
  591. BOOL bResult = WriteProfileString(lpszSection, lpszEntry, str);
  593. return bResult;
  594. }
  596. BOOL CXTRegistryManager::GetProfilePoint(LPCTSTR lpszSection, LPCTSTR lpszEntry, CPoint* ptResult)
  597. {
  598. ASSERT(lpszSection != NULL);
  599. ASSERT(lpszEntry != NULL);
  601. if (m_strINIFileName.IsEmpty())
  602. {
  603. if (!GetProfileInfo())
  604. return FALSE;
  606. CHKey hSecKey(GetSectionKey(lpszSection, KEY_READ));
  607. if (hSecKey == NULL)
  608. return FALSE;
  610. DWORD dwType, dwCount;
  611. m_lResult = ::RegQueryValueEx(hSecKey, (LPTSTR)lpszEntry, NULL, &dwType,
  612. NULL, &dwCount);
  614. if (m_lResult != ERROR_SUCCESS)
  615. return FALSE;
  617. ASSERT(dwType == REG_BINARY);
  618. m_lResult = ::RegQueryValueEx(hSecKey, (LPTSTR)lpszEntry, NULL, &dwType,
  619. (LPBYTE)ptResult, &dwCount);
  621. if (m_lResult != ERROR_SUCCESS)
  622. return FALSE;
  624. ASSERT(dwType == REG_BINARY);
  625. return TRUE;
  626. }
  627. else
  628. {
  629. ASSERT(m_strINIFileName.IsEmpty() == FALSE);
  631. CString str = GetProfileString(lpszSection, lpszEntry, NULL);
  632. if (str.IsEmpty())
  633. return FALSE;
  635. SCANF_S(str, _T("%ld,%ld"), &ptResult->x, &ptResult->y);
  636. return TRUE;
  637. }
  638. }
  640. BOOL CXTRegistryManager::WriteProfileRect(LPCTSTR lpszSection, LPCTSTR lpszEntry, CRect* pValue)
  641. {
  642. ASSERT(lpszSection != NULL);
  643. if (m_strINIFileName.IsEmpty())
  644. {
  645. if (!GetProfileInfo())
  646. return FALSE;
  648. CHKey hSecKey(GetSectionKey(lpszSection));
  649. if (hSecKey == NULL)
  650. return FALSE;
  652. m_lResult = ::RegSetValueEx(hSecKey, lpszEntry, NULL, REG_BINARY,
  653. (LPBYTE)pValue, sizeof(CRect));
  655. if (m_lResult != ERROR_SUCCESS)
  656. return FALSE;
  658. return TRUE;
  659. }
  661. CString str;
  662. str.Format(_T("%i,%i,%i,%i"), pValue->left, pValue->top, pValue->right, pValue->bottom);
  664. BOOL bResult = WriteProfileString(lpszSection, lpszEntry, str);
  666. return bResult;
  667. }
  669. BOOL CXTRegistryManager::GetProfileRect(LPCTSTR lpszSection, LPCTSTR lpszEntry, CRect* rcResult)
  670. {
  671. ASSERT(lpszSection != NULL);
  672. ASSERT(lpszEntry != NULL);
  674. if (m_strINIFileName.IsEmpty())
  675. {
  676. if (!GetProfileInfo())
  677. return FALSE;
  679. CHKey hSecKey(GetSectionKey(lpszSection, KEY_READ));
  680. if (hSecKey == NULL)
  681. return FALSE;
  683. DWORD dwType, dwCount;
  684. m_lResult = ::RegQueryValueEx(hSecKey, (LPTSTR)lpszEntry, NULL, &dwType,
  685. NULL, &dwCount);
  687. if (m_lResult != ERROR_SUCCESS)
  688. return FALSE;
  690. ASSERT(dwType == REG_BINARY);
  691. m_lResult = ::RegQueryValueEx(hSecKey, (LPTSTR)lpszEntry, NULL, &dwType,
  692. (LPBYTE)rcResult, &dwCount);
  694. if (m_lResult != ERROR_SUCCESS)
  695. return FALSE;
  697. return TRUE;
  698. }
  699. else
  700. {
  702. ASSERT(m_strINIFileName.IsEmpty() == FALSE);
  704. // convert to string and write out
  705. CString str = GetProfileString(lpszSection, lpszEntry, NULL);
  706. if (str.IsEmpty())
  707. return FALSE;
  709. SCANF_S(str, _T("%ld,%ld,%ld,%ld"), &rcResult->left, &rcResult->top, &rcResult->right, &rcResult->bottom);
  710. return TRUE;
  711. }
  712. }
  714. BOOL CXTRegistryManager::WriteProfileSize(LPCTSTR lpszSection, LPCTSTR lpszEntry, CSize* pValue)
  715. {
  716. ASSERT(lpszSection != NULL);
  717. if (m_strINIFileName.IsEmpty())
  718. {
  719. if (!GetProfileInfo())
  720. return FALSE;
  722. CHKey hSecKey(GetSectionKey(lpszSection));
  723. if (hSecKey == NULL)
  724. return FALSE;
  726. m_lResult = ::RegSetValueEx(hSecKey, lpszEntry, NULL, REG_BINARY,
  727. (LPBYTE)pValue, sizeof(CSize));
  729. if (m_lResult != ERROR_SUCCESS)
  730. return FALSE;
  732. return TRUE;
  733. }
  735. CString str;
  736. str.Format(_T("%i,%i"), pValue->cx, pValue->cy);
  738. BOOL bResult = WriteProfileString(lpszSection, lpszEntry, str);
  739. return bResult;
  740. }
  742. BOOL CXTRegistryManager::GetProfileSize(LPCTSTR lpszSection, LPCTSTR lpszEntry, CSize* szResult)
  743. {
  744. ASSERT(lpszSection != NULL);
  745. ASSERT(lpszEntry != NULL);
  747. if (m_strINIFileName.IsEmpty())
  748. {
  749. if (!GetProfileInfo())
  750. return FALSE;
  752. CHKey hSecKey(GetSectionKey(lpszSection, KEY_READ));
  753. if (hSecKey == NULL)
  754. return FALSE;
  756. DWORD dwType, dwCount;
  757. m_lResult = ::RegQueryValueEx(hSecKey, (LPTSTR)lpszEntry, NULL, &dwType,
  758. NULL, &dwCount);
  760. if (m_lResult != ERROR_SUCCESS)
  761. return FALSE;
  763. ASSERT(dwType == REG_BINARY);
  764. m_lResult = ::RegQueryValueEx(hSecKey, (LPTSTR)lpszEntry, NULL, &dwType,
  765. (LPBYTE)szResult, &dwCount);
  767. if (m_lResult != ERROR_SUCCESS)
  768. return FALSE;
  770. ASSERT(dwType == REG_BINARY);
  771. return TRUE;
  772. }
  773. else
  774. {
  775. ASSERT(m_strINIFileName.IsEmpty() == FALSE);
  777. // convert to string and write out
  778. CString str = GetProfileString(lpszSection, lpszEntry, NULL);
  779. if (str.IsEmpty())
  780. return FALSE;
  782. SCANF_S(str, _T("%i,%i"), &szResult->cx, &szResult->cy);
  783. return TRUE;
  784. }
  785. }
  787. BOOL CXTRegistryManager::WriteProfileDouble(LPCTSTR lpszSection, LPCTSTR lpszEntry, double* pValue)
  788. {
  789. ASSERT(lpszSection != NULL);
  790. if (m_strINIFileName.IsEmpty())
  791. {
  792. if (!GetProfileInfo())
  793. return FALSE;
  795. CHKey hSecKey(GetSectionKey(lpszSection));
  796. if (hSecKey == NULL)
  797. return FALSE;
  799. m_lResult = ::RegSetValueEx(hSecKey, lpszEntry, NULL, REG_BINARY,
  800. (LPBYTE)pValue, sizeof(*pValue));
  802. if (m_lResult != ERROR_SUCCESS)
  803. return FALSE;
  805. return TRUE;
  806. }
  808. LPBYTE pData = (LPBYTE) pValue;
  809. UINT nBytes = sizeof(double);
  810. LPTSTR lpsz = new TCHAR[nBytes * 2 + 1];
  811. UINT i;
  812. for (i = 0; i < nBytes; i++)
  813. {
  814. lpsz[i * 2] = (TCHAR)((pData[i] & 0x0F) + 'A'); //low nibble
  815. lpsz[i * 2 + 1] = (TCHAR)(((pData[i] >> 4) & 0x0F) + 'A'); //high nibble
  816. }
  817. lpsz[i * 2] = 0;
  819. ASSERT(m_strINIFileName.IsEmpty() == FALSE);
  821. BOOL bResult = WriteProfileString(lpszSection, lpszEntry, lpsz);
  822. delete[] lpsz;
  823. return bResult;
  825. }
  827. BOOL CXTRegistryManager::GetProfileDouble(LPCTSTR lpszSection, LPCTSTR lpszEntry, double* dResult)
  828. {
  829. ASSERT(lpszSection != NULL);
  830. ASSERT(lpszEntry != NULL);
  832. if (m_strINIFileName.IsEmpty())
  833. {
  834. if (!GetProfileInfo())
  835. return FALSE;
  837. CHKey hSecKey(GetSectionKey(lpszSection, KEY_READ));
  838. if (hSecKey == NULL)
  839. return FALSE;
  841. DWORD dwType, dwCount;
  842. m_lResult = ::RegQueryValueEx(hSecKey, (LPTSTR)lpszEntry, NULL, &dwType,
  843. NULL, &dwCount);
  845. if (m_lResult != ERROR_SUCCESS)
  846. return FALSE;
  848. ASSERT(dwType == REG_BINARY);
  849. m_lResult = ::RegQueryValueEx(hSecKey, (LPTSTR)lpszEntry, NULL, &dwType,
  850. (LPBYTE)dResult, &dwCount);
  852. if (m_lResult != ERROR_SUCCESS)
  853. return FALSE;
  855. ASSERT(dwType == REG_BINARY);
  856. return TRUE;
  857. }
  858. else
  859. {
  860. ASSERT(m_strINIFileName.IsEmpty() == FALSE);
  862. CString str = GetProfileString(lpszSection, lpszEntry, NULL);
  863. if (str.IsEmpty())
  864. return FALSE;
  866. ASSERT(str.GetLength()%2 == 0);
  867. int nLen = str.GetLength();
  869. LPBYTE pData = (LPBYTE) dResult;
  871. int i;
  872. for (i = 0; i < nLen; i += 2)
  873. {
  874. (pData)[i/2] = (BYTE)
  875. (((str[i + 1] - 'A') << 4) + (str[i] - 'A'));
  876. }
  878. return TRUE;
  879. }
  880. }
  882. BOOL CXTRegistryManager::WriteProfileDword(LPCTSTR lpszSection, LPCTSTR lpszEntry, DWORD* pValue)
  883. {
  884. ASSERT(lpszSection != NULL);
  885. if (m_strINIFileName.IsEmpty())
  886. {
  887. if (!GetProfileInfo())
  888. return FALSE;
  890. CHKey hSecKey(GetSectionKey(lpszSection));
  891. if (hSecKey == NULL)
  892. return FALSE;
  894. m_lResult = ::RegSetValueEx(hSecKey, lpszEntry, NULL, REG_DWORD,
  895. (LPBYTE)pValue, sizeof(*pValue));
  897. if (m_lResult != ERROR_SUCCESS)
  898. return FALSE;
  900. return TRUE;
  901. }
  904. BOOL bResult = WriteProfileInt(lpszSection, lpszEntry, int(*pValue));
  905. return bResult;
  906. }
  908. BOOL CXTRegistryManager::GetProfileDword(LPCTSTR lpszSection, LPCTSTR lpszEntry, DWORD* dwResult)
  909. {
  910. ASSERT(lpszSection != NULL);
  911. ASSERT(lpszEntry != NULL);
  913. if (m_strINIFileName.IsEmpty())
  914. {
  915. if (!GetProfileInfo())
  916. return FALSE;
  918. CHKey hSecKey(GetSectionKey(lpszSection, KEY_READ));
  919. if (hSecKey == NULL)
  920. return FALSE;
  922. DWORD dwType, dwCount;
  923. m_lResult = ::RegQueryValueEx(hSecKey, (LPTSTR)lpszEntry, NULL, &dwType,
  924. NULL, &dwCount);
  926. if (m_lResult != ERROR_SUCCESS)
  927. return FALSE;
  929. ASSERT(dwType == REG_DWORD);
  930. m_lResult = ::RegQueryValueEx(hSecKey, (LPTSTR)lpszEntry, NULL, &dwType,
  931. (LPBYTE)dwResult, &dwCount);
  933. if (m_lResult != ERROR_SUCCESS)
  934. return FALSE;
  936. ASSERT(dwType == REG_DWORD);
  937. return TRUE;
  938. }
  939. else
  940. {
  941. ASSERT(m_strINIFileName.IsEmpty() == FALSE);
  943. CString str = GetProfileString(lpszSection, lpszEntry, NULL);
  944. if (str.IsEmpty())
  945. return FALSE;
  947. *dwResult = (DWORD)GetProfileInt(lpszSection, lpszEntry, 0);
  948. return TRUE;
  949. }
  950. }
  952. BOOL CXTRegistryManager::WriteProfileColor(LPCTSTR lpszSection, LPCTSTR lpszEntry, COLORREF* pValue)
  953. {
  954. return WriteProfileDword(lpszSection, lpszEntry, pValue);
  955. }
  957. BOOL CXTRegistryManager::GetProfileColor(LPCTSTR lpszSection, LPCTSTR lpszEntry, COLORREF* rgbResult)
  958. {
  959. return GetProfileDword(lpszSection, lpszEntry, rgbResult);
  960. }
  962. CString CXTRegistryManager::GetErrorMessage() const
  963. {
  964. LPVOID lpMsgBuf = 0;
  966. ::FormatMessage(
  967. FORMAT_MESSAGE_ALLOCATE_BUFFER |
  968. FORMAT_MESSAGE_FROM_SYSTEM |
  969. FORMAT_MESSAGE_IGNORE_INSERTS,
  970. NULL,
  971. GetErrorCode(),
  972. MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT), // Default language
  973. (LPTSTR) &lpMsgBuf,
  974. 0,
  975. NULL
  976. );
  978. CString csMessage((LPCTSTR)lpMsgBuf);
  980. // Free the buffer.
  981. ::LocalFree( lpMsgBuf );
  983. return csMessage;
  984. }