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

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

对话框与窗口

开发平台：

Visual C++

XTPCalendarTimeZoneHelper.cpp：源码内容
  1. // XTPCalendarTimeZoneHelper.cpp: implementation of Time Zone Helper classes.
  2. //
  3. // This file is a part of the XTREME CALENDAR 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 "Common/XTPSystemHelpers.h"
  26. #include "XTPCalendarTimeZoneHelper.h"
  27. #include "XTPCalendarDefines.h"
  29. #ifdef _DEBUG
  30. #undef THIS_FILE
  31. static char THIS_FILE[] = __FILE__;
  32. #define new DEBUG_NEW
  33. #endif
  35. //================================================================
  38. IMPLEMENT_DYNAMIC(CXTPCalendarTimeZone, CCmdTarget)
  39. IMPLEMENT_DYNAMIC(CXTPCalendarTimeZones, CCmdTarget)
  42. CXTPCalendarTimeZone::CXTPCalendarTimeZone(const TIME_ZONE_INFORMATION* pTZInfo)
  43. {
  44. if (pTZInfo)
  45. {
  46. *((TIME_ZONE_INFORMATION*)this) = *pTZInfo;
  47. }
  48. else
  49. {
  50. ::ZeroMemory((void*)((TIME_ZONE_INFORMATION*)this), sizeof(TIME_ZONE_INFORMATION));
  51. }
  53. m_dwIndex = 0;
  55. }
  57. CXTPCalendarTimeZone::CXTPCalendarTimeZone(const CXTPCalendarTimeZone* pTZInfoEx)
  58. {
  59. *this = *pTZInfoEx;
  61. }
  63. CXTPCalendarTimeZone::~CXTPCalendarTimeZone()
  64. {
  65. }
  67. const CXTPCalendarTimeZone&
  68. CXTPCalendarTimeZone::operator=(const CXTPCalendarTimeZone& rTZInfo)
  69. {
  70. *((TIME_ZONE_INFORMATION*)this) = *((TIME_ZONE_INFORMATION*)&rTZInfo);
  72. m_strDisplayString = rTZInfo.GetDisplayString();
  73. m_dwIndex = rTZInfo.GetIndex();
  75. return *this;
  76. }
  78. CString CXTPCalendarTimeZone::GetDisplayString() const
  79. {
  80. return m_strDisplayString;
  81. }
  83. DWORD CXTPCalendarTimeZone::GetIndex() const
  84. {
  85. return m_dwIndex;
  86. }
  88. BOOL CXTPCalendarTimeZone::IsEqual(const TIME_ZONE_INFORMATION* pTZI2) const
  89. {
  90. if (!pTZI2)
  91. {
  92. ASSERT(FALSE);
  93. return FALSE;
  94. }
  96. const int cnChSize_name = _countof(StandardName);
  98. if (_wcsnicmp(StandardName, pTZI2->StandardName, cnChSize_name) == 0)
  99. {
  100. return TRUE;
  101. }
  103. return FALSE;
  104. }
  106. CXTPCalendarTimeZonePtr CXTPCalendarTimeZone::GetTimeZoneInfo(
  107. const TIME_ZONE_INFORMATION* pTZIdata)
  108. {
  109. if (!pTZIdata)
  110. {
  111. ASSERT(FALSE);
  112. return NULL;
  113. }
  115. CXTPCalendarTimeZones arXTP_TZI;
  117. if (!arXTP_TZI.InitFromRegistry())
  118. {
  119. return NULL;
  120. }
  122. CXTPCalendarTimeZone* pTZI2Info = arXTP_TZI.Find(pTZIdata);
  123. if (pTZI2Info)
  124. {
  125. CXTPCalendarTimeZone* pTZI2;
  126. pTZI2 = new CXTPCalendarTimeZone(pTZI2Info);
  127. //to update "biases" and names values
  128. if (pTZI2)
  129. {
  130. *((TIME_ZONE_INFORMATION*)pTZI2) = *pTZIdata;
  131. }
  132. CXTPCalendarTimeZonePtr ptrTZI2(pTZI2, FALSE);
  133. return ptrTZI2;
  134. }
  136. return NULL;
  137. }
  140. /////////////////////////////////////////////////////////////////////////////
  141. //class CXTPCalendarTimeZones : public CCmdTarget
  142. CXTPCalendarTimeZones::CXTPCalendarTimeZones()
  143. {
  144. }
  146. CXTPCalendarTimeZones::~CXTPCalendarTimeZones()
  147. {
  148. }
  150. BOOL CXTPCalendarTimeZones::GetRegBSTR(HKEY hKey, LPCWSTR pcszValueNameW,
  151.    BSTR& rbstrValue)
  152. {
  153. if (rbstrValue)
  154. {
  155. ::SysFreeString(rbstrValue);
  156. rbstrValue = NULL;
  157. }
  159. //------------------------------------------------------------
  160. if (CXTPCalendarUtils::IsWin9x())
  161. {
  162. CString strValueName(pcszValueNameW);
  163. CString strValue;
  164. if (GetRegStr(hKey, strValueName, strValue))
  165. {
  166. rbstrValue = strValue.AllocSysString();
  167. }
  168. return rbstrValue != NULL;
  169. }
  171. //------------------------------------------------------------
  172. const DWORD cdwDataSize = 4 * 1024;
  173. BYTE arData[cdwDataSize];
  174. ::ZeroMemory(arData, sizeof(arData));
  175. DWORD dwType = 0, dwDataSize = sizeof(arData)-2;
  177. LONG lRes = ::RegQueryValueExW(hKey, pcszValueNameW, NULL, &dwType,
  178. arData, &dwDataSize);
  180. if (lRes != ERROR_SUCCESS)
  181. {
  182. return FALSE;
  183. }
  185. if (dwType == REG_SZ || dwType == REG_EXPAND_SZ || dwType == REG_MULTI_SZ)
  186. {
  187. ASSERT(dwType != REG_MULTI_SZ); // WARMING!
  189. rbstrValue = ::SysAllocString((LPCWSTR)arData);
  190. return rbstrValue != NULL;
  191. }
  193. return FALSE;
  194. }
  196. BOOL CXTPCalendarTimeZones::GetRegStr(HKEY hKey, LPCTSTR pcszValueName, CString& rstrValue)
  197. {
  198. rstrValue.Empty();
  200. const DWORD cdwDataSize = 4 * 1024;
  201. BYTE arData[cdwDataSize];
  202. ::ZeroMemory(arData, sizeof(arData));
  203. DWORD dwType = 0, dwDataSize = sizeof(arData)-2;
  205. LONG lRes = ::RegQueryValueEx(hKey, pcszValueName, NULL, &dwType,
  206. arData, &dwDataSize);
  208. if (lRes != ERROR_SUCCESS)
  209. {
  210. return FALSE;
  211. }
  213. if (dwType == REG_SZ || dwType == REG_EXPAND_SZ || dwType == REG_MULTI_SZ)
  214. {
  215. ASSERT(dwType != REG_MULTI_SZ); // WARMING!
  217. rstrValue = (LPCTSTR)arData;
  218. return TRUE;
  219. }
  221. return FALSE;
  222. }
  224. BOOL CXTPCalendarTimeZones::GetRegDWORD(HKEY hKey, LPCTSTR pcszValueName, DWORD& rdwValue)
  225. {
  226. rdwValue = 0;
  228. const DWORD cdwDataSize = 16;
  229. BYTE arData[cdwDataSize];
  230. ::ZeroMemory(arData, sizeof(arData));
  231. DWORD dwType = 0, dwDataSize = sizeof(arData);
  233. LONG lRes = ::RegQueryValueEx(hKey, pcszValueName, NULL, &dwType,
  234. arData, &dwDataSize);
  236. if (lRes != ERROR_SUCCESS)
  237. {
  238. return FALSE;
  239. }
  241. if (dwType == REG_DWORD || dwType == REG_DWORD_BIG_ENDIAN || dwType == REG_BINARY)
  242. {
  243. rdwValue = *((DWORD*)arData);
  244. return TRUE;
  245. }
  247. return FALSE;
  248. }
  250. BOOL CXTPCalendarTimeZones::GetRegTZI(HKEY hKey, LPCTSTR pcszValueName,
  251. CXTPCalendarTimeZones::REGISTRY_TIMEZONE_INFORMATION& rRegTZI)
  252. {
  253. ::ZeroMemory(&rRegTZI, sizeof(rRegTZI));
  255. const DWORD cdwDataSize = sizeof(rRegTZI)*2;
  256. BYTE arData[cdwDataSize];
  257. ::ZeroMemory(arData, sizeof(arData));
  258. DWORD dwType = 0, dwDataSize = sizeof(arData);
  260. LONG lRes = ::RegQueryValueEx(hKey, pcszValueName, NULL, &dwType,
  261. arData, &dwDataSize);
  263. if (lRes != ERROR_SUCCESS)
  264. {
  265. return FALSE;
  266. }
  268. if (dwType == REG_BINARY && dwDataSize == sizeof(rRegTZI))
  269. {
  270. rRegTZI = *((REGISTRY_TIMEZONE_INFORMATION*)arData);
  271. return TRUE;
  272. }
  274. ASSERT(FALSE);
  275. return FALSE;
  276. }
  278. BOOL CXTPCalendarTimeZones::InitFromRegistry()
  279. {
  280. m_arTZInfo.RemoveAll();
  282. CString strTZIRootKey = XTP_CALENDAR_TIMEZONESKEY_NT;
  284. HKEY hkTZIRoot = NULL;
  285. BOOL bUseIndex = !XTPSystemVersion()->IsWinXPOrGreater();
  287. // Try NT information first
  288. LONG lRes = ::RegOpenKeyEx(HKEY_LOCAL_MACHINE, strTZIRootKey, 0, KEY_READ, &hkTZIRoot);
  289. if (lRes != ERROR_SUCCESS)
  290. {
  291. // try Win9x information
  292. strTZIRootKey = XTP_CALENDAR_TIMEZONESKEY_9X;
  293. bUseIndex = FALSE;
  295. lRes = ::RegOpenKeyEx(HKEY_LOCAL_MACHINE, strTZIRootKey, 0, KEY_READ, &hkTZIRoot);
  296. if (lRes != ERROR_SUCCESS)
  297. {
  298. TRACE(_T("Cannot open Time Zones information registry key. err = %d n"), lRes);
  299. return FALSE;
  300. }
  301. }
  303. const DWORD cdwKeyBufSize = 1024;
  304. TCHAR szTZIKey[cdwKeyBufSize + 1];
  306. BSTR bstrStandardName = NULL;
  307. BSTR bstrDaylightName = NULL;
  309. lRes = ERROR_SUCCESS;
  310. for (DWORD dwEnumKey = 0; lRes == ERROR_SUCCESS; dwEnumKey++)
  311. {
  312. ::ZeroMemory(szTZIKey, sizeof(szTZIKey));
  314. lRes = ::RegEnumKey (hkTZIRoot, dwEnumKey, szTZIKey, cdwKeyBufSize);
  316. if (lRes != ERROR_SUCCESS)
  317. {
  318. ASSERT(lRes == ERROR_NO_MORE_ITEMS);
  319. break;
  320. }
  322. //===================================================================
  323. CString strTZIKey = strTZIRootKey + _T("\") + szTZIKey;
  325. HKEY hkTZIdata = NULL;
  326. LONG lRes2 = ::RegOpenKeyEx(HKEY_LOCAL_MACHINE, strTZIKey, 0, KEY_READ, &hkTZIdata);
  327. if (lRes2 != ERROR_SUCCESS)
  328. {
  329. TRACE(_T("Cannot open registry key 'HKEY_LOCAL_MACHINE\%s'. err = %d n"), (LPCTSTR)strTZIKey, lRes2);
  330. continue;
  331. }
  333. CString strDisplayStr, strStandardName, strDaylightName;
  334. DWORD dwIndex;
  335. REGISTRY_TIMEZONE_INFORMATION regTZI;
  337. if (!GetRegStr(hkTZIdata, XTP_CALENDAR_TZIRegValName_DisplayStr, strDisplayStr))
  338. {
  339. TRACE(_T("Cannot get value from registry: 'HKEY_LOCAL_MACHINE\%s\%s'n"), (LPCTSTR)strTZIKey, XTP_CALENDAR_TZIRegValName_DisplayStr);
  340. continue;
  341. }
  342. if (!GetRegBSTR(hkTZIdata, XTP_CALENDAR_TZIRegValName_StandardNameW, bstrStandardName))
  343. {
  344. TRACE(_T("Cannot get value from registry: 'HKEY_LOCAL_MACHINE\%s\%s'n"), (LPCTSTR)strTZIKey, XTP_CALENDAR_TZIRegValName_StandardName);
  345. continue;
  346. }
  347. if (!GetRegBSTR(hkTZIdata, XTP_CALENDAR_TZIRegValName_DaylightNameW, bstrDaylightName))
  348. {
  349. TRACE(_T("Cannot get value from registry: 'HKEY_LOCAL_MACHINE\%s\%s'n"), (LPCTSTR)strTZIKey, XTP_CALENDAR_TZIRegValName_DaylightName);
  350. continue;
  351. }
  353. if (!GetRegTZI(hkTZIdata, XTP_CALENDAR_TZIRegValName_DATA, regTZI))
  354. {
  355. TRACE(_T("Cannot get value from registry: 'HKEY_LOCAL_MACHINE\%s\%s'n"), (LPCTSTR)strTZIKey, XTP_CALENDAR_TZIRegValName_DATA);
  356. continue;
  357. }
  359. if (!GetRegDWORD(hkTZIdata, XTP_CALENDAR_TZIRegValName_Index, dwIndex))
  360. {
  361. if (bUseIndex)
  362. {
  363. TRACE(_T("Cannot get value from registry: 'HKEY_LOCAL_MACHINE\%s\%s'n"), (LPCTSTR)strTZIKey, XTP_CALENDAR_TZIRegValName_Index);
  364. }
  365. dwIndex = 0;
  366. }
  368. //=================================================
  369. CXTPCalendarTimeZone* pXTP_TZI;
  370. pXTP_TZI = new CXTPCalendarTimeZone();
  371. if (!pXTP_TZI)
  372. {
  373. AfxThrowOleException(E_OUTOFMEMORY);
  374. }
  376. pXTP_TZI->Bias = regTZI.Bias;
  378. WCSNCPY_S(pXTP_TZI->StandardName, bstrStandardName, 32);
  379. pXTP_TZI->StandardName[_countof(pXTP_TZI->StandardName)-1] = L'';
  381. pXTP_TZI->StandardDate = regTZI.StandardDate;
  382. pXTP_TZI->StandardBias = regTZI.StandardBias;
  384. WCSNCPY_S(pXTP_TZI->DaylightName, bstrDaylightName, 32);
  385. pXTP_TZI->DaylightName[_countof(pXTP_TZI->DaylightName)-1] = L'';
  387. pXTP_TZI->DaylightDate = regTZI.DaylightDate;
  388. pXTP_TZI->DaylightBias = regTZI.DaylightBias;
  390. pXTP_TZI->m_strDisplayString = strDisplayStr;
  391. pXTP_TZI->m_dwIndex = dwIndex;
  393. m_arTZInfo.Add(pXTP_TZI, FALSE);
  394. }
  396. //-----------------------------------------------
  397. if (bstrStandardName)
  398. {
  399. ::SysFreeString(bstrStandardName);
  400. }
  401. if (bstrDaylightName)
  402. {
  403. ::SysFreeString(bstrDaylightName);
  404. }
  406. //-----------------------------------------------
  407. int nCount = m_arTZInfo.GetCount();
  408. for (int i = 0; i < nCount; i++)
  409. {
  410. for (int j = i + 1; j < nCount; j++)
  411. {
  412. CXTPCalendarTimeZonePtr ptrElem1, ptrElem2;
  413. ptrElem1 = m_arTZInfo.GetAt(i, TRUE);
  414. ptrElem2 = m_arTZInfo.GetAt(j, TRUE);
  416. if (CompareTZI(ptrElem1, ptrElem2, bUseIndex) > 0)
  417. {
  418. m_arTZInfo.SetAt(i, ptrElem2.Detach());
  419. m_arTZInfo.SetAt(j, ptrElem1.Detach());
  420. }
  421. }
  422. }
  424. return TRUE;
  425. }
  427. int CXTPCalendarTimeZones::GetDigit(TCHAR ch) const
  428. {
  429. int nD = ch - _T('0');
  430. return (nD >= 0 && nD <= 9) ? nD : -1;
  431. }
  433. void CXTPCalendarTimeZones::ParseDisplayStr(LPCTSTR str, int& rnOffset, CString& rstrPlace) const
  434. {
  435. // (GMT + 02:00) Athens, ...
  436. // (GMT-02:00) place, ...
  437. //----------------------------------------------
  438. //  (GMT - 02 : 00) place, ...
  439. //0 1      2    3  4 5
  440. //----------------------------------------------
  442. rnOffset = 0;
  443. rstrPlace.Empty();
  445. int nSign = 0, nHr = 0, nMin = 0;
  446. int nState = 0;
  448. for (const TCHAR* pCh = (LPCTSTR)str; pCh && *pCh != 0; pCh = _tcsinc(pCh))
  449. {
  450. if (nState == 0 && *pCh == _T('('))
  451. {
  452. nState = 1;
  453. }
  454. else if (nState == 1)
  455. {
  456. if (*pCh == _T('+'))
  457. {
  458. nSign = 1;
  459. nState = 2;
  460. }
  461. else if (*pCh == _T('-'))
  462. {
  463. nSign = -1;
  464. nState = 2;
  465. }
  466. }
  467. else if (nState == 2)
  468. {
  469. if (GetDigit(*pCh) >= 0)
  470. {
  471. nHr *= 10;
  472. nHr += GetDigit(*pCh);
  473. }
  474. else if (*pCh == _T(':'))
  475. {
  476. nState = 3;
  477. }
  478. }
  479. else if (nState == 3)
  480. {
  481. if (GetDigit(*pCh) >= 0)
  482. {
  483. nMin *= 10;
  484. nMin += GetDigit(*pCh);
  485. }
  486. else if (*pCh == _T(')'))
  487. {
  488. nState = 4;
  489. }
  490. }
  491. else if (nState == 4)
  492. {
  493. if (*pCh != _T(' '))
  494. {
  495. rstrPlace = pCh;
  496. break;
  497. }
  498. }
  499. }
  500. //---------------------------------------
  501. rnOffset = nSign * (nHr * 60 + nMin);
  502. }
  504. int CXTPCalendarTimeZones::CompareTZI(const CXTPCalendarTimeZone* pTZI1,
  505.   const CXTPCalendarTimeZone* pTZI2,
  506.   BOOL bUseIndex) const
  507. {
  508. if (bUseIndex)
  509. {
  510. return XTPCompare(pTZI1->m_dwIndex, pTZI2->m_dwIndex);
  511. }
  513. int nOffset1, nOffset2;
  514. CString strPlace1, strPlace2;
  516. ParseDisplayStr(pTZI1->GetDisplayString(), nOffset1, strPlace1);
  517. ParseDisplayStr(pTZI2->GetDisplayString(), nOffset2, strPlace2);
  519. int nCmpRes = XTPCompare(nOffset1, nOffset2);
  520. if (nCmpRes)
  521. {
  522. return nCmpRes;
  523. }
  525. return XTPCompare(strPlace1, strPlace2);
  526. }
  528. int CXTPCalendarTimeZones::GetCount() const
  529. {
  530. return m_arTZInfo.GetCount();
  531. }
  533. CXTPCalendarTimeZone* CXTPCalendarTimeZones::GetAt(long nIndex) const
  534. {
  535. if (nIndex < 0 || nIndex >= m_arTZInfo.GetCount())
  536. {
  537. ASSERT(FALSE);
  538. return NULL;
  539. }
  541. CXTPCalendarTimeZone* pTZI = m_arTZInfo.GetAt(nIndex, FALSE);
  542. return pTZI;
  543. }
  545. CXTPCalendarTimeZone* CXTPCalendarTimeZones::Find(const TIME_ZONE_INFORMATION* pTZI2) const
  546. {
  547. if (!pTZI2)
  548. {
  549. ASSERT(FALSE);
  550. return NULL;
  551. }
  553. int nCount = GetCount();
  554. for (int i = 0; i < nCount; i++)
  555. {
  556. CXTPCalendarTimeZone* pTZI = GetAt(i);
  557. if (!pTZI)
  558. {
  559. ASSERT(FALSE);
  560. continue;
  561. }
  562. if (pTZI->IsEqual(pTZI2))
  563. {
  564. return pTZI;
  565. }
  566. }
  567. return NULL;
  568. }