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

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

对话框与窗口

开发平台：

Visual C++

XTDateTimeCtrl.cpp：源码内容
  1. // XTDateTimeCtrl.cpp : implementation of the CXTDateTimeCtrl class.
  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"
  22. #include "Common/XTPVC80Helpers.h"  // Visual Studio 2005 helper functions
  23. #include "Common/XTPVC50Helpers.h"  // Visual Studio 2005 helper functions
  25. #include "XTDefines.h"
  26. #include "XTGlobal.h"
  27. #include "XTDateTimeCtrl.h"
  29. #include <math.h>
  31. #ifdef _DEBUG
  32. #define new DEBUG_NEW
  33. #undef THIS_FILE
  34. static char THIS_FILE[] = __FILE__;
  35. #endif
  38. static BOOL GetAsSystemTime(const CTime& tm, SYSTEMTIME& timeDest)
  39. {
  40. struct tm ttm;
  41. struct tm *ptm = tm.GetLocalTm(&ttm);
  43. if (!ptm)
  44. return FALSE;
  46. timeDest.wYear = (WORD) (1900 + ptm->tm_year);
  47. timeDest.wMonth = (WORD) (1 + ptm->tm_mon);
  48. timeDest.wDayOfWeek = (WORD) ptm->tm_wday;
  49. timeDest.wDay = (WORD) ptm->tm_mday;
  50. timeDest.wHour = (WORD) ptm->tm_hour;
  51. timeDest.wMinute = (WORD) ptm->tm_min;
  52. timeDest.wSecond = (WORD) ptm->tm_sec;
  53. timeDest.wMilliseconds = 0;
  55. return TRUE;
  56. }
  58. static BOOL GetAsSystemTime(const CTime* ptm, SYSTEMTIME& timeDest)
  59. {
  60. return GetAsSystemTime(*ptm, timeDest);
  61. }
  63. static BOOL GetAsSystemTime(const COleDateTime& dtm, SYSTEMTIME& sysTime)
  64. {
  65. #if _MSC_VER < 1200
  66. return CXTPDateTimeHelper::GetAsSystemTime(dtm, sysTime);
  67. #else
  68. return dtm.GetAsSystemTime(sysTime);
  69. #endif
  70. }
  72. static BOOL GetAsSystemTime(const COleDateTime* pdtm, SYSTEMTIME& sysTime)
  73. {
  74. return GetAsSystemTime(*pdtm, sysTime);
  75. }
  77. /////////////////////////////////////////////////////////////////////////////
  78. // CXTDateTimeCtrl class
  79. /////////////////////////////////////////////////////////////////////////////
  80. BOOL CXTDateTimeCtrl::Create(DWORD dwStyle, const RECT& rect, CWnd* pParentWnd, UINT nID)
  81. {
  82. #if (_MSC_VER <= 1100) // Using Visual C++ 5.0
  84. // initialize common controls
  85. INITCOMMONCONTROLSEX icex;
  86. icex.dwSize = sizeof(icex);
  87. icex.dwICC = ICC_DATE_CLASSES;
  88. VERIFY(InitCommonControlsEx(&icex));
  90. #else
  92. // initialize common controls
  93. VERIFY(AfxDeferRegisterClass(AFX_WNDCOMMCTL_DATE_REG));
  95. #endif//#if (_MSC_VER <= 1100)
  97. CWnd* pWnd = this;
  98. return pWnd->Create(DATETIMEPICK_CLASS, NULL, dwStyle, rect, pParentWnd, nID);
  99. }
  101. DWORD CXTDateTimeCtrl::GetRange(CTime* pMinTime, CTime* pMaxTime) const
  102. {
  103. ASSERT(::IsWindow(m_hWnd));
  104. SYSTEMTIME sysTimes[2];
  105. memset(sysTimes, 0, sizeof(sysTimes));
  107. //IA64: Assume retval of DTM_GETRANGE is still 32-bit
  108. DWORD dwResult = (DWORD)::SendMessage(m_hWnd, DTM_GETRANGE, 0, (LPARAM) &sysTimes);
  110. if (pMinTime != NULL)
  111. {
  112. if (dwResult & GDTR_MIN)
  113. *pMinTime = CTime(sysTimes[0]);
  114. }
  116. if (pMaxTime != NULL)
  117. {
  118. if (dwResult & GDTR_MAX)
  119. *pMaxTime = CTime(sysTimes[1]);
  120. }
  122. return dwResult;
  124. }
  126. DWORD CXTDateTimeCtrl::GetRange(COleDateTime* pMinTime, COleDateTime* pMaxTime) const
  127. {
  128. ASSERT(::IsWindow(m_hWnd));
  130. SYSTEMTIME sysTimes[2];
  131. memset(sysTimes, 0, sizeof(sysTimes));
  133. DWORD dwResult = (DWORD)::SendMessage(m_hWnd, DTM_GETRANGE, 0, (LPARAM) &sysTimes);
  134. if (pMinTime != NULL)
  135. {
  136. if (dwResult & GDTR_MIN)
  137. *pMinTime = COleDateTime(sysTimes[0]);
  138. else
  139. pMinTime->SetStatus(COleDateTime::null);
  140. }
  142. if (pMaxTime != NULL)
  143. {
  144. if (dwResult & GDTR_MAX)
  145. *pMaxTime = COleDateTime(sysTimes[1]);
  146. else
  147. pMaxTime->SetStatus(COleDateTime::null);
  148. }
  150. return dwResult;
  151. }
  153. BOOL CXTDateTimeCtrl::SetRange(const CTime* pMinTime, const CTime* pMaxTime)
  154. {
  155. ASSERT(::IsWindow(m_hWnd));
  157. SYSTEMTIME sysTimes[2];
  159. WPARAM wFlags = 0;
  160. if (pMinTime != NULL && GetAsSystemTime(pMinTime, sysTimes[0]))
  161. wFlags |= GDTR_MIN;
  163. if (pMaxTime != NULL && GetAsSystemTime(pMaxTime, sysTimes[1]))
  164. wFlags |= GDTR_MAX;
  166. return (BOOL) ::SendMessage(m_hWnd, DTM_SETRANGE, wFlags, (LPARAM) &sysTimes);
  167. }
  169. BOOL CXTDateTimeCtrl::SetRange(const COleDateTime* pMinTime, const COleDateTime* pMaxTime)
  170. {
  171. ASSERT(::IsWindow(m_hWnd));
  172. ASSERT(pMinTime == NULL || pMinTime->GetStatus() != COleDateTime::invalid);
  173. ASSERT(pMaxTime == NULL || pMaxTime->GetStatus() != COleDateTime::invalid);
  175. SYSTEMTIME sysTime[2];
  177. WPARAM wFlags = 0;
  178. if (pMinTime != NULL && pMinTime->GetStatus() != COleDateTime::null)
  179. {
  180. if (GetAsSystemTime(pMinTime, sysTime[0]))
  181. wFlags |= GDTR_MIN;
  182. }
  184. if (pMaxTime != NULL && pMaxTime->GetStatus() != COleDateTime::null)
  185. {
  186. if (GetAsSystemTime(pMaxTime, sysTime[1]))
  187. wFlags |= GDTR_MAX;
  188. }
  190. return (BOOL) ::SendMessage(m_hWnd, DTM_SETRANGE, wFlags, (LPARAM) &sysTime);
  191. }
  193. BOOL CXTDateTimeCtrl::SetTime(LPSYSTEMTIME pTimeNew /* = NULL */)
  194. {
  195. ASSERT(::IsWindow(m_hWnd));
  196. WPARAM wParam = (pTimeNew == NULL) ? GDT_NONE : GDT_VALID;
  197. return (BOOL) ::SendMessage(m_hWnd, DTM_SETSYSTEMTIME,
  198. wParam, (LPARAM) pTimeNew);
  199. }
  201. BOOL CXTDateTimeCtrl::SetTime(const COleDateTime& timeNew)
  202. {
  203. BOOL bRetVal = FALSE;
  205. // make sure the time isn't invalid
  206. ASSERT(timeNew.GetStatus() != COleDateTime::invalid);
  207. ASSERT(::IsWindow(m_hWnd));
  209. SYSTEMTIME sysTime;
  210. WPARAM wParam = GDT_NONE;
  211. if (timeNew.GetStatus() == COleDateTime::valid &&
  212. GetAsSystemTime(timeNew, sysTime))
  213. {
  214. wParam = GDT_VALID;
  215. }
  217. bRetVal = (BOOL) ::SendMessage(m_hWnd,
  218. DTM_SETSYSTEMTIME, wParam, (LPARAM) &sysTime);
  220. return bRetVal;
  221. }
  223. BOOL CXTDateTimeCtrl::SetTime(const CTime* pTimeNew)
  224. {
  225. BOOL bRetVal = FALSE;
  227. // make sure the time isn't invalid
  228. ASSERT(::IsWindow(m_hWnd));
  230. SYSTEMTIME sysTime;
  231. WPARAM wParam = GDT_NONE;
  232. if (pTimeNew != NULL && GetAsSystemTime(pTimeNew, sysTime))
  233. {
  234. wParam = GDT_VALID;
  235. }
  237. bRetVal = (BOOL) ::SendMessage(m_hWnd,
  238. DTM_SETSYSTEMTIME, wParam, (LPARAM) &sysTime);
  240. return bRetVal;
  241. }
  243. BOOL CXTDateTimeCtrl::GetTime(COleDateTime& timeDest) const
  244. {
  245. SYSTEMTIME sysTime;
  246. BOOL bRetVal = TRUE;
  248. LRESULT result = ::SendMessage(m_hWnd, DTM_GETSYSTEMTIME, 0, (LPARAM) &sysTime);
  249. if (result == GDT_VALID)
  250. {
  251. timeDest = COleDateTime(sysTime);
  252. bRetVal = TRUE;
  253. ASSERT(timeDest.GetStatus() == COleDateTime::valid);
  254. }
  255. else if (result == GDT_NONE)
  256. {
  257. timeDest.SetStatus(COleDateTime::null);
  258. bRetVal = TRUE;
  259. }
  260. else
  261. timeDest.SetStatus(COleDateTime::invalid);
  262. return bRetVal;
  263. }
  265. DWORD CXTDateTimeCtrl::GetTime(CTime& timeDest) const
  266. {
  267. SYSTEMTIME sysTime;
  268. DWORD dwResult = (DWORD)
  269. ::SendMessage(m_hWnd, DTM_GETSYSTEMTIME, 0, (LPARAM) &sysTime);
  271. if (dwResult == GDT_VALID)
  272. timeDest = CTime(sysTime);
  274. return dwResult;
  275. }
  277. CXTDateTimeCtrl::~CXTDateTimeCtrl()
  278. {
  279. DestroyWindow();
  280. }
  282. /////////////////////////////////////////////////////////////////////////////
  283. // CXTMonthCalCtrl class
  284. /////////////////////////////////////////////////////////////////////////////
  285. BOOL CXTMonthCalCtrl::Create(DWORD dwStyle, const RECT& rect, CWnd* pParentWnd, UINT nID)
  286. {
  287. #if (_MSC_VER <= 1100) // Using Visual C++ 5.0
  289. // initialize common controls
  290. INITCOMMONCONTROLSEX icex;
  291. icex.dwSize = sizeof(icex);
  292. icex.dwICC = ICC_DATE_CLASSES;
  293. VERIFY(InitCommonControlsEx(&icex));
  295. #else
  297. // initialize common controls
  298. VERIFY(AfxDeferRegisterClass(AFX_WNDCOMMCTL_DATE_REG));
  300. #endif//#if (_MSC_VER <= 1100)
  302. CWnd* pWnd = this;
  303. return pWnd->Create(MONTHCAL_CLASS, NULL, dwStyle, rect, pParentWnd, nID);
  304. }
  306. BOOL CXTMonthCalCtrl::Create(DWORD dwStyle, const POINT& pt, CWnd* pParentWnd, UINT nID)
  307. {
  308. BOOL bWasVisible = (dwStyle & WS_VISIBLE);
  309. dwStyle &= ~WS_VISIBLE;
  311. CRect rect(pt.x, pt.y, 0, 0);
  313. BOOL bRetVal = FALSE;
  314. if (Create(dwStyle, rect, pParentWnd, nID))
  315. {
  316. if (SizeMinReq())
  317. {
  318. if (bWasVisible)
  319. ShowWindow(SW_SHOWNA);
  320. bRetVal = TRUE;
  321. }
  322. else
  323. DestroyWindow();
  324. }
  326. return bRetVal;
  327. }
  329. BOOL CXTMonthCalCtrl::SizeMinReq(BOOL bRepaint /* = TRUE */)
  330. {
  331. CRect rect;
  332. BOOL bRetVal = FALSE;
  333. if (GetMinReqRect(rect))
  334. {
  335. DWORD dwFlags = SWP_NOZORDER | SWP_NOREPOSITION | SWP_NOMOVE | SWP_NOACTIVATE;
  336. if (!bRepaint)
  337. dwFlags |= SWP_NOREDRAW;
  338. SetWindowPos(NULL, 0, 0, rect.Width(), rect.Height(), dwFlags);
  339. bRetVal = TRUE;
  340. }
  342. return bRetVal;
  343. }
  345. void CXTMonthCalCtrl::SetToday(const COleDateTime& refTime)
  346. {
  347. ASSERT_VALID(this);
  349. // make sure the time isn't invalid
  350. ASSERT(refTime.GetStatus() != COleDateTime::invalid);
  351. ASSERT(::IsWindow(m_hWnd));
  353. SYSTEMTIME sysTime;
  354. LPSYSTEMTIME pSysTime = NULL;
  355. WPARAM wParam = GDT_NONE;
  357. // if the passed time is null or out of range,
  358. // we'll set the control to NULL
  360. if (GetAsSystemTime(refTime, sysTime))
  361. {
  362. pSysTime = &sysTime;
  363. wParam = GDT_VALID;
  364. }
  366. if (::IsWindow(m_hWnd))
  367. ::SendMessage(m_hWnd, MCM_SETTODAY, wParam, (LPARAM) pSysTime);
  368. }
  370. void CXTMonthCalCtrl::SetToday(const CTime* pDateTime)
  371. {
  372. ASSERT(::IsWindow(m_hWnd));
  373. ASSERT_VALID(this);
  375. // if the passed time is NULL, we'll set the
  376. // control to NULL
  378. WPARAM wParam = GDT_NONE;
  379. LPSYSTEMTIME pSysTime = NULL;
  380. SYSTEMTIME sysTime;
  382. if (pDateTime != NULL && GetAsSystemTime(pDateTime, sysTime))
  383. {
  384. wParam = GDT_VALID;
  385. pSysTime = &sysTime;
  386. }
  388. if (::IsWindow(m_hWnd))
  389. ::SendMessage(m_hWnd, MCM_SETTODAY, wParam, (LPARAM) pSysTime);
  390. }
  392. BOOL CXTMonthCalCtrl::SetCurSel(const COleDateTime& refTime)
  393. {
  394. ASSERT(::IsWindow(m_hWnd));
  396. SYSTEMTIME sysTime;
  397. BOOL bRetVal = FALSE;
  399. // if the passed time is null or out of range,
  400. // we'll set the control to NULL
  402. if (GetAsSystemTime(refTime, sysTime) &&
  403. refTime.GetStatus() == COleDateTime::valid)
  404. {
  405. bRetVal = (BOOL)
  406. ::SendMessage(m_hWnd, MCM_SETCURSEL, 0, (LPARAM) &sysTime);
  407. }
  409. return bRetVal;
  410. }
  412. BOOL CXTMonthCalCtrl::SetCurSel(const CTime& refTime)
  413. {
  414. ASSERT(::IsWindow(m_hWnd));
  416. SYSTEMTIME sysTime;
  417. BOOL bRetVal = FALSE;
  419. if (GetAsSystemTime(refTime, sysTime))
  420. {
  421. bRetVal = (BOOL)
  422. ::SendMessage(m_hWnd, MCM_SETCURSEL, 0, (LPARAM) &sysTime);
  423. }
  425. return bRetVal;
  426. }
  428. BOOL CXTMonthCalCtrl::GetCurSel(COleDateTime& refTime) const
  429. {
  430. ASSERT(::IsWindow(m_hWnd));
  432. // can't use this method on multiple selection controls
  433. ASSERT(!(GetStyle() & MCS_MULTISELECT));
  435. SYSTEMTIME sysTime;
  436. BOOL bResult = GetCurSel(&sysTime);
  438. if (bResult)
  439. refTime = COleDateTime(sysTime);
  441. return bResult;
  442. }
  444. BOOL CXTMonthCalCtrl::GetToday(COleDateTime& refTime) const
  445. {
  446. ASSERT(::IsWindow(m_hWnd));
  448. // can't use this method on multiple selection controls
  449. ASSERT(!(GetStyle() & MCS_MULTISELECT));
  451. SYSTEMTIME sysTime;
  452. BOOL bResult = (BOOL)
  453. ::SendMessage(m_hWnd, MCM_GETTODAY, 0, (LPARAM) &sysTime);
  455. if (bResult)
  456. refTime = COleDateTime(sysTime);
  458. return bResult;
  459. }
  461. BOOL CXTMonthCalCtrl::GetCurSel(CTime& refTime) const
  462. {
  463. ASSERT(::IsWindow(m_hWnd));
  465. // can't use this method on multiple selection controls
  466. ASSERT(!(GetStyle() & MCS_MULTISELECT));
  468. SYSTEMTIME sysTime;
  469. BOOL bResult = GetCurSel(&sysTime);
  471. if (bResult)
  472. refTime = CTime(sysTime);
  474. return bResult;
  475. }
  477. BOOL CXTMonthCalCtrl::GetToday(CTime& refTime) const
  478. {
  479. ASSERT(::IsWindow(m_hWnd));
  481. // can't use this method on multiple selection controls
  482. ASSERT(!(GetStyle() & MCS_MULTISELECT));
  484. SYSTEMTIME sysTime;
  485. BOOL bResult = (BOOL)
  486. ::SendMessage(m_hWnd, MCM_GETTODAY, 0, (LPARAM) &sysTime);
  488. if (bResult)
  489. refTime = CTime(sysTime);
  491. return bResult;
  492. }
  494. CXTMonthCalCtrl::~CXTMonthCalCtrl()
  495. {
  496. DestroyWindow();
  497. }
  499. int CXTMonthCalCtrl::GetFirstDayOfWeek(BOOL* pbLocal /* = NULL */) const
  500. {
  501. ASSERT(::IsWindow(m_hWnd));
  502. DWORD dwResult;
  503. dwResult = (DWORD) ::SendMessage(m_hWnd, MCM_GETFIRSTDAYOFWEEK, 0, 0);
  505. // set *pbLocal to reflect if the first day of week
  506. // matches current locale setting
  508. if (pbLocal)
  509. *pbLocal = HIWORD(dwResult);
  510. return LOWORD(dwResult);
  511. }
  513. BOOL CXTMonthCalCtrl::SetFirstDayOfWeek(int iDay, int* lpnOld /* = NULL */)
  514. {
  515. ASSERT(::IsWindow(m_hWnd));
  516. DWORD dwResult;
  517. dwResult = (DWORD) ::SendMessage(m_hWnd, MCM_SETFIRSTDAYOFWEEK, 0, (WPARAM) iDay);
  519. if (lpnOld != NULL)
  520. *lpnOld = LOWORD(dwResult);
  522. return (BOOL) HIWORD(dwResult);
  523. }
  525. BOOL CXTMonthCalCtrl::SetDayState(int nMonths, LPMONTHDAYSTATE pStates)
  526. {
  527. ASSERT(::IsWindow(m_hWnd));
  528. ASSERT(GetStyle()&MCS_DAYSTATE);
  529. ASSERT(AfxIsValidAddress(pStates, nMonths * sizeof(MONTHDAYSTATE), FALSE));
  530. return (BOOL) ::SendMessage(m_hWnd, MCM_SETDAYSTATE, (WPARAM) nMonths, (LPARAM) pStates);
  531. }
  533. BOOL CXTMonthCalCtrl::SetRange(const COleDateTime* pMinRange, const COleDateTime* pMaxRange)
  534. {
  535. ASSERT(::IsWindow(m_hWnd));
  536. ASSERT(pMinRange == NULL || pMinRange->GetStatus() != COleDateTime::invalid);
  537. ASSERT(pMaxRange == NULL || pMaxRange->GetStatus() != COleDateTime::invalid);
  539. SYSTEMTIME sysTimes[2];
  540. WPARAM wFlags = 0;
  542. if (pMinRange != NULL && pMinRange->GetStatus() != COleDateTime::null)
  543. {
  544. if (GetAsSystemTime(pMinRange, sysTimes[0]))
  545. wFlags |= GDTR_MIN;
  546. }
  548. if (pMaxRange != NULL && pMaxRange->GetStatus() != COleDateTime::null)
  549. {
  550. if (GetAsSystemTime(pMaxRange, sysTimes[1]))
  551. wFlags |= GDTR_MAX;
  552. }
  554. return (BOOL)
  555. ::SendMessage(m_hWnd, MCM_SETRANGE, wFlags, (LPARAM) &sysTimes);
  556. }
  558. BOOL CXTMonthCalCtrl::SetRange(const LPSYSTEMTIME pMinRange, const LPSYSTEMTIME pMaxRange)
  559. {
  560. ASSERT(::IsWindow(m_hWnd));
  562. SYSTEMTIME sysTimes[2];
  563. WPARAM wFlags = 0;
  565. if (pMinRange != NULL)
  566. {
  567. MEMCPY_S(&sysTimes[0], pMinRange, sizeof(SYSTEMTIME));
  568. wFlags |= GDTR_MIN;
  569. }
  571. if (pMaxRange != NULL)
  572. {
  573. MEMCPY_S(&sysTimes[1], pMaxRange, sizeof(SYSTEMTIME));
  574. wFlags |= GDTR_MAX;
  575. }
  577. return (BOOL)
  578. ::SendMessage(m_hWnd, MCM_SETRANGE, wFlags, (LPARAM) &sysTimes);
  579. }
  581. DWORD CXTMonthCalCtrl::GetRange(COleDateTime* pMinRange, COleDateTime* pMaxRange) const
  582. {
  583. ASSERT(::IsWindow(m_hWnd));
  585. SYSTEMTIME sysTimes[2];
  586. memset(sysTimes, 0, sizeof(sysTimes));
  588. DWORD dwRanges = (DWORD)
  589. ::SendMessage(m_hWnd, MCM_GETRANGE, 0, (LPARAM) &sysTimes);
  591. if (dwRanges & GDTR_MIN && pMinRange)
  592. *pMinRange = COleDateTime(sysTimes[0]);
  594. if (dwRanges & GDTR_MAX && pMaxRange)
  595. *pMaxRange = COleDateTime(sysTimes[1]);
  597. return dwRanges;
  598. }
  600. DWORD CXTMonthCalCtrl::GetRange(LPSYSTEMTIME pMinRange, LPSYSTEMTIME pMaxRange) const
  601. {
  602. ASSERT(::IsWindow(m_hWnd));
  604. SYSTEMTIME sysTimes[2];
  605. memset(sysTimes, 0, sizeof(sysTimes));
  607. DWORD dwRanges = (DWORD)
  608. ::SendMessage(m_hWnd, MCM_GETRANGE, 0, (LPARAM) &sysTimes);
  610. if (dwRanges & GDTR_MIN && pMinRange)
  611. {
  612. MEMCPY_S(pMinRange, &sysTimes[0], sizeof(SYSTEMTIME));
  613. }
  615. if (dwRanges & GDTR_MAX && pMaxRange)
  616. {
  617. MEMCPY_S(pMaxRange, &sysTimes[1], sizeof(SYSTEMTIME));
  618. }
  620. return dwRanges;
  621. }
  623. BOOL CXTMonthCalCtrl::SetRange(const CTime* pMinRange, const CTime* pMaxRange)
  624. {
  625. ASSERT(::IsWindow(m_hWnd));
  627. SYSTEMTIME sysTimes[2];
  628. WPARAM wFlags = 0;
  629. if (pMinRange != NULL && GetAsSystemTime(pMinRange, sysTimes[0]))
  630. wFlags |= GDTR_MIN;
  632. if (pMaxRange != NULL && GetAsSystemTime(pMaxRange, sysTimes[1]))
  633. wFlags |= GDTR_MAX;
  635. return (BOOL)
  636. ::SendMessage(m_hWnd, MCM_SETRANGE, wFlags, (LPARAM) &sysTimes);
  637. }
  639. DWORD CXTMonthCalCtrl::GetRange(CTime* pMinRange, CTime* pMaxRange) const
  640. {
  641. ASSERT(::IsWindow(m_hWnd));
  643. SYSTEMTIME sysTimes[2];
  644. memset(sysTimes, 0, sizeof(sysTimes));
  646. DWORD dwRanges = (DWORD)
  647. ::SendMessage(m_hWnd, MCM_GETRANGE, 0, (LPARAM) &sysTimes);
  649. if (dwRanges & GDTR_MIN && pMinRange)
  650. *pMinRange = CTime(sysTimes[0]);
  652. if (dwRanges & GDTR_MAX && pMaxRange)
  653. *pMaxRange = CTime(sysTimes[1]);
  655. return dwRanges;
  656. }
  658. int CXTMonthCalCtrl::GetMonthRange(COleDateTime& refMinRange, COleDateTime& refMaxRange, DWORD dwFlags) const
  659. {
  660. ASSERT(::IsWindow(m_hWnd));
  661. ASSERT(dwFlags == GMR_DAYSTATE || dwFlags == GMR_VISIBLE);
  663. SYSTEMTIME sysTimes[2];
  664. memset(sysTimes, 0, sizeof(sysTimes));
  665. int nCount = (int) ::SendMessage(m_hWnd, MCM_GETMONTHRANGE,
  666. (WPARAM) dwFlags, (LPARAM) &sysTimes);
  668. refMinRange = COleDateTime(sysTimes[0]);
  669. refMaxRange = COleDateTime(sysTimes[1]);
  671. return nCount;
  672. }
  674. int CXTMonthCalCtrl::GetMonthRange(LPSYSTEMTIME pMinRange, LPSYSTEMTIME pMaxRange, DWORD dwFlags) const
  675. {
  676. ASSERT(::IsWindow(m_hWnd));
  677. ASSERT_POINTER(pMinRange, SYSTEMTIME);
  678. ASSERT_POINTER(pMaxRange, SYSTEMTIME);
  680. SYSTEMTIME sysTimes[2];
  682. int nCount = (int) ::SendMessage(m_hWnd, MCM_GETMONTHRANGE,
  683. (WPARAM) dwFlags, (LPARAM) &sysTimes);
  685. MEMCPY_S(pMinRange, &sysTimes[0], sizeof(SYSTEMTIME));
  686. MEMCPY_S(pMaxRange, &sysTimes[1], sizeof(SYSTEMTIME));
  688. return nCount;
  689. }
  691. int CXTMonthCalCtrl::GetMonthRange(CTime& refMinRange, CTime& refMaxRange, DWORD dwFlags) const
  692. {
  693. ASSERT(::IsWindow(m_hWnd));
  694. ASSERT(dwFlags == GMR_DAYSTATE || dwFlags == GMR_VISIBLE);
  696. SYSTEMTIME sysTimes[2];
  697. memset(sysTimes, 0, sizeof(sysTimes));
  698. int nCount = (int) ::SendMessage(m_hWnd, MCM_GETMONTHRANGE,
  699. (WPARAM) dwFlags, (LPARAM) &sysTimes);
  701. refMinRange = CTime(sysTimes[0]);
  702. refMaxRange = CTime(sysTimes[1]);
  704. return nCount;
  705. }
  707. BOOL CXTMonthCalCtrl::GetSelRange(LPSYSTEMTIME pMinRange, LPSYSTEMTIME pMaxRange) const
  708. {
  709. ASSERT(m_hWnd != NULL);
  710. if (!m_hWnd)
  711. return FALSE;
  712. ASSERT((GetStyle() & MCS_MULTISELECT));
  714. ASSERT_POINTER(pMinRange, SYSTEMTIME);
  715. ASSERT_POINTER(pMaxRange, SYSTEMTIME);
  717. SYSTEMTIME sysTimes[2];
  718. BOOL bReturn = (BOOL) ::SendMessage(m_hWnd, MCM_GETSELRANGE,
  719. 0, (LPARAM) &sysTimes);
  721. if (bReturn)
  722. {
  723. MEMCPY_S(pMinRange, &sysTimes[0], sizeof(SYSTEMTIME));
  724. MEMCPY_S(pMaxRange, &sysTimes[1], sizeof(SYSTEMTIME));
  725. }
  727. return bReturn;
  728. }
  730. BOOL CXTMonthCalCtrl::SetSelRange(const LPSYSTEMTIME pMinRange, const LPSYSTEMTIME pMaxRange)
  731. {
  732. ASSERT(m_hWnd != NULL);
  733. if (!m_hWnd)
  734. return FALSE;
  735. ASSERT((GetStyle() & MCS_MULTISELECT));
  737. ASSERT_POINTER(pMinRange, SYSTEMTIME);
  738. ASSERT_POINTER(pMaxRange, SYSTEMTIME);
  740. SYSTEMTIME sysTimes[2];
  741. MEMCPY_S(&sysTimes[0], pMinRange, sizeof(SYSTEMTIME));
  742. MEMCPY_S(&sysTimes[1], pMaxRange, sizeof(SYSTEMTIME));
  744. return (BOOL) ::SendMessage(m_hWnd, MCM_SETSELRANGE,
  745. 0, (LPARAM) &sysTimes);
  746. }
  748. BOOL CXTMonthCalCtrl::SetSelRange(const COleDateTime& refMinRange, const COleDateTime& refMaxRange)
  749. {
  750. // control must have multiple select
  751. ASSERT((GetStyle() & MCS_MULTISELECT));
  752. ASSERT(::IsWindow(m_hWnd));
  754. SYSTEMTIME sysTimes[2];
  755. BOOL bResult = FALSE;
  757. if (refMinRange.GetStatus() == COleDateTime::valid &&
  758. refMinRange.GetStatus() == COleDateTime::valid)
  759. {
  760. if (GetAsSystemTime(refMinRange, sysTimes[0]) &&
  761. GetAsSystemTime(refMaxRange, sysTimes[1]))
  762. {
  763. bResult = (BOOL)
  764. ::SendMessage(m_hWnd, MCM_SETSELRANGE, 0, (LPARAM)sysTimes);
  765. }
  766. }
  768. return bResult;
  769. }
  771. BOOL CXTMonthCalCtrl::GetSelRange(COleDateTime& refMinRange, COleDateTime& refMaxRange) const
  772. {
  773. // control must have multiple select
  774. ASSERT((GetStyle() & MCS_MULTISELECT));
  775. ASSERT(::IsWindow(m_hWnd));
  777. SYSTEMTIME sysTimes[2];
  778. memset(sysTimes, 0, sizeof(sysTimes));
  779. BOOL bResult = (BOOL)
  780. ::SendMessage(m_hWnd, MCM_GETSELRANGE, 0, (LPARAM) &sysTimes);
  782. if (bResult)
  783. {
  784. refMinRange = COleDateTime(sysTimes[0]);
  785. refMaxRange = COleDateTime(sysTimes[1]);
  786. }
  787. return bResult;
  788. }
  790. BOOL CXTMonthCalCtrl::SetSelRange(const CTime& refMinRange, const CTime& refMaxRange)
  791. {
  792. // control must have multiple select
  793. ASSERT((GetStyle() & MCS_MULTISELECT));
  794. ASSERT(::IsWindow(m_hWnd));
  796. SYSTEMTIME sysTimes[2];
  797. BOOL bResult = FALSE;
  799. if (GetAsSystemTime(refMinRange, sysTimes[0]) &&
  800. GetAsSystemTime(refMaxRange, sysTimes[1]))
  801. {
  802. bResult = (BOOL)
  803. ::SendMessage(m_hWnd, MCM_SETSELRANGE, 0, (LPARAM)sysTimes);
  804. }
  806. return bResult;
  807. }
  809. BOOL CXTMonthCalCtrl::GetSelRange(CTime& refMinRange, CTime& refMaxRange) const
  810. {
  811. // control must have multiple select
  812. ASSERT((GetStyle() & MCS_MULTISELECT));
  813. ASSERT(::IsWindow(m_hWnd));
  815. SYSTEMTIME sysTimes[2];
  816. memset(sysTimes, 0, sizeof(sysTimes));
  817. BOOL bResult = (BOOL)
  818. ::SendMessage(m_hWnd, MCM_GETSELRANGE, 0, (LPARAM) &sysTimes);
  820. if (bResult)
  821. {
  822. refMinRange = CTime(sysTimes[0]);
  823. refMaxRange = CTime(sysTimes[1]);
  824. }
  825. return bResult;
  826. }
  827. /////////////////////////////////////////////////////////////////////////////
  828. // DDX_ routines
  829. /////////////////////////////////////////////////////////////////////////////
  830. _XTP_EXT_CLASS void AFXAPI DDX_XTDateTimeCtrl(CDataExchange* pDX, int nIDC, COleDateTime& value)
  831. {
  832. HWND hWndCtrl = pDX->PrepareCtrl(nIDC);
  833. CXTDateTimeCtrl* pWnd = (CXTDateTimeCtrl*) CWnd::FromHandle(hWndCtrl);
  835. if (pDX->m_bSaveAndValidate)
  836. pWnd->GetTime(value);
  837. else
  838. pWnd->SetTime(value);
  839. }
  841. _XTP_EXT_CLASS void AFXAPI DDX_XTDateTimeCtrl(CDataExchange* pDX, int nIDC, CTime& value)
  842. {
  843. HWND hWndCtrl = pDX->PrepareCtrl(nIDC);
  844. CXTDateTimeCtrl* pWnd = (CXTDateTimeCtrl*) CWnd::FromHandle(hWndCtrl);
  846. if (pDX->m_bSaveAndValidate)
  847. pWnd->GetTime(value);
  848. else
  849. pWnd->SetTime(&value);
  850. }
  852. _XTP_EXT_CLASS void AFXAPI DDX_XTMonthCalCtrl(CDataExchange* pDX, int nIDC,
  853. COleDateTime& value)
  854. {
  855. HWND hWndCtrl = pDX->PrepareCtrl(nIDC);
  856. CXTMonthCalCtrl* pWnd = (CXTMonthCalCtrl*) CWnd::FromHandle(hWndCtrl);
  858. if (pDX->m_bSaveAndValidate)
  859. pWnd->GetCurSel(value);
  860. else
  861. pWnd->SetCurSel(value);
  862. }
  864. _XTP_EXT_CLASS void AFXAPI DDX_XTMonthCalCtrl(CDataExchange* pDX, int nIDC, CTime& value)
  865. {
  866. HWND hWndCtrl = pDX->PrepareCtrl(nIDC);
  867. CXTMonthCalCtrl* pWnd = (CXTMonthCalCtrl*) CWnd::FromHandle(hWndCtrl);
  869. if (pDX->m_bSaveAndValidate)
  870. pWnd->GetCurSel(value);
  871. else
  872. pWnd->SetCurSel(value);
  873. }
  874. /////////////////////////////////////////////////////////////////////////////
  875. // DDV_ routines
  876. /////////////////////////////////////////////////////////////////////////////
  877. _XTP_EXT_CLASS void AFXAPI DDV_XTMinMaxDateTime(CDataExchange* pDX, CTime& refValue,
  878. const CTime* pMinRange, const CTime* pMaxRange)
  879. {
  880. ASSERT(pMinRange == NULL || pMaxRange == NULL || *pMinRange <= *pMaxRange);
  881. #if _MSC_VER > 1200 //MFC 7.0
  882. CXTDateTimeCtrl* pWnd =
  883. (CXTDateTimeCtrl*) pDX->m_pDlgWnd->GetDlgItem(pDX->m_idLastControl);
  884. #else
  885. CXTDateTimeCtrl* pWnd =
  886. (CXTDateTimeCtrl*) CWnd::FromHandle(pDX->m_hWndLastControl);
  887. #endif //MFC 7.0
  889. if (!pDX->m_bSaveAndValidate)
  890. {
  891. if ((pMinRange != NULL && *pMinRange > refValue) ||
  892. (pMaxRange != NULL && *pMaxRange < refValue))
  893. {
  894. #if _MSC_VER > 1200 // MFC 7.0
  895. TRACE(traceAppMsg, 0, "Warning: initial dialog data is out of range in "
  896. "control ID %d.n", pDX->m_idLastControl);
  897. #else
  898. #ifdef _DEBUG
  899. int nIDC = GetWindowLong(pDX->m_hWndLastControl, GWL_ID);
  900. TRACE1("Warning: initial dialog data is out of range in control ID %d.n", nIDC);
  901. #endif
  902. #endif//MFC 7.0
  903. return;     // don't stop now
  904. }
  905. }
  907. pWnd->SetRange(pMinRange, pMaxRange);
  908. }
  910. _XTP_EXT_CLASS void AFXAPI DDV_XTMinMaxDateTime(CDataExchange* pDX, COleDateTime& refValue,
  911. const COleDateTime* pMinRange, const COleDateTime* pMaxRange)
  912. {
  913. ASSERT(pMinRange == NULL || pMaxRange == NULL || *pMinRange <= *pMaxRange);
  914. #if _MSC_VER > 1200 //MFC 7.0
  915. CXTDateTimeCtrl* pWnd =
  916. (CXTDateTimeCtrl*) pDX->m_pDlgWnd->GetDlgItem(pDX->m_idLastControl);
  917. #else
  918. CXTDateTimeCtrl* pWnd =
  919. (CXTDateTimeCtrl*) CWnd::FromHandle(pDX->m_hWndLastControl);
  920. #endif //MFC 7.0
  922. if (!pDX->m_bSaveAndValidate)
  923. {
  924. if ((pMinRange != NULL && *pMinRange > refValue) ||
  925. (pMaxRange != NULL && *pMaxRange < refValue))
  926. {
  927. #if _MSC_VER > 1200 //MFC 7.0
  928. TRACE(traceAppMsg, 0, "Warning: initial dialog data is out of range in "
  929. "control ID %d.n", pDX->m_idLastControl);
  930. #else
  931. #ifdef _DEBUG
  932. int nIDC = GetWindowLong(pDX->m_hWndLastControl, GWL_ID);
  933. TRACE1("Warning: initial dialog data is out of range in control ID %d.n", nIDC);
  934. #endif
  935. #endif //MFC 7.0
  936. return;     // don't stop now
  937. }
  938. }
  940. pWnd->SetRange(pMinRange, pMaxRange);
  941. }
  943. _XTP_EXT_CLASS void AFXAPI DDV_XTMinMaxMonth(CDataExchange* pDX, CTime& refValue,
  944. const CTime* pMinRange, const CTime* pMaxRange)
  945. {
  946. ASSERT(pMinRange == NULL || pMaxRange == NULL || *pMinRange <= *pMaxRange);
  947. #if _MSC_VER > 1200 //MFC 7.0
  948. CXTMonthCalCtrl* pWnd =
  949. (CXTMonthCalCtrl*) pDX->m_pDlgWnd->GetDlgItem(pDX->m_idLastControl);
  950. #else
  951. CXTMonthCalCtrl* pWnd =
  952. (CXTMonthCalCtrl*) CWnd::FromHandle(pDX->m_hWndLastControl);
  953. #endif //MFC 7.0
  955. if (!pDX->m_bSaveAndValidate)
  956. {
  957. if ((pMinRange != NULL && *pMinRange > refValue) ||
  958. (pMaxRange != NULL && *pMaxRange < refValue))
  959. {
  960. #if _MSC_VER > 1200 //MFC 7.0
  961. TRACE(traceAppMsg, 0, "Warning: initial dialog data is out of range in "
  962. "control ID %d.n", pDX->m_idLastControl);
  963. #else
  964. #ifdef _DEBUG
  965. int nIDC = GetWindowLong(pDX->m_hWndLastControl, GWL_ID);
  966. TRACE1("Warning: initial dialog data is out of range in control ID %d.n", nIDC);
  967. #endif
  968. #endif //MFC 7.0
  969. return;     // don't stop now
  970. }
  971. }
  973. pWnd->SetRange(pMinRange, pMaxRange);
  974. }
  976. _XTP_EXT_CLASS void AFXAPI DDV_XTMinMaxMonth(CDataExchange* pDX, COleDateTime& refValue,
  977. const COleDateTime* pMinRange, const COleDateTime* pMaxRange)
  978. {
  979. ASSERT(pMinRange == NULL || pMaxRange == NULL || *pMinRange <= *pMaxRange);
  980. #if _MSC_VER > 1200 //MFC 7.0
  981. CXTMonthCalCtrl* pWnd =
  982. (CXTMonthCalCtrl*) pDX->m_pDlgWnd->GetDlgItem(pDX->m_idLastControl);
  983. #else
  984. CXTMonthCalCtrl* pWnd =
  985. (CXTMonthCalCtrl*) CWnd::FromHandle(pDX->m_hWndLastControl);
  986. #endif //MFC 7.0
  988. if (!pDX->m_bSaveAndValidate)
  989. {
  990. if ((pMinRange != NULL && *pMinRange > refValue) ||
  991. (pMaxRange != NULL && *pMaxRange < refValue))
  992. {
  993. #if _MSC_VER > 1200 //MFC 7.0
  994. TRACE(traceAppMsg, 0, "Warning: initial dialog data is out of range in "
  995. "control ID %d.n", pDX->m_idLastControl);
  996. #else
  997. #ifdef _DEBUG
  998. int nIDC = GetWindowLong(pDX->m_hWndLastControl, GWL_ID);
  999. TRACE1("Warning: initial dialog data is out of range in control ID %d.n", nIDC);
  1000. #endif
  1001. #endif //MFC 7.0
  1002. return;     // don't stop now
  1003. }
  1004. }
  1006. pWnd->SetRange(pMinRange, pMaxRange);
  1007. }
  1009. IMPLEMENT_DYNAMIC(CXTDateTimeCtrl, CWnd)
  1011. IMPLEMENT_DYNAMIC(CXTMonthCalCtrl, CWnd)