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

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

对话框与窗口

开发平台：

Visual C++

XTPDatePickerControl.cpp：源码内容
  1. // XTPDatePickerControl.cpp: implementation of the CXTPDatePickerControl class.
  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"
  22. #include "Resource.h"
  24. #include "Common/XTPDrawHelpers.h"
  25. #include "Common/XTPVC50Helpers.h"
  26. #include "Common/XTPImageManager.h"
  27. #include "Common/XTPSystemHelpers.h"
  29. #include "XTPTopLevelWndMsgNotifier.h"
  30. #include "XTPCalendarUtils.h"
  31. #include "XTPDatePickerItemMonth.h"
  32. #include "XTPDatePickerPaintManager.h"
  33. #include "XTPDatePickerDaysCollection.h"
  34. #include "XTPDatePickerList.h"
  35. #include "XTPDatePickerItemDay.h"
  36. #include "XTPDatePickerControl.h"
  37. #include "XTPDatePickerNotifications.h"
  39. #ifdef _DEBUG
  40. #define new DEBUG_NEW
  41. #undef THIS_FILE
  42. static char THIS_FILE[] = __FILE__;
  43. #endif
  45. #pragma warning(disable: 4571) // warning C4571: catch(...) blocks compiled with /EHs do not catch or re-throw Structured Exceptions
  47. // Custom class name for the Date Picker control window
  48. const TCHAR XTP_DATEPICKERCTRL_CLASSNAME[] = _T("XTPDatePicker");
  50. //////////////////////////////////////////////////////////////////////////
  51. // CXTPDatePickerButtons
  53. int CXTPDatePickerButtons::GetVisibleButtonCount() const
  54. {
  55. int nCount = 0;
  56. for (int i = 0; i < (int)GetSize(); i++)
  57. {
  58. if (GetAt(i)->m_bVisible) nCount++;
  59. }
  60. return nCount;
  61. }
  62. CXTPDatePickerButton* CXTPDatePickerButtons::Find(int nID) const
  63. {
  64. for (int i = 0; i < (int)GetSize(); i++)
  65. {
  66. if (GetAt(i)->m_nID == nID)
  67. return GetAt(i);
  68. }
  69. return NULL;
  70. }
  71. CXTPDatePickerButton* CXTPDatePickerButtons::HitTest(CPoint point) const
  72. {
  73. for (int i = 0; i < (int)GetSize(); i++)
  74. {
  75. if (GetAt(i)->m_bVisible && GetAt(i)->m_rcButton.PtInRect(point))
  76. return GetAt(i);
  77. }
  78. return NULL;
  80. }
  82. //////////////////////////////////////////////////////////////////////////
  83. // XTP_DAYITEM_METRICS
  85. XTP_DAYITEM_METRICS::XTP_DAYITEM_METRICS()
  86. {
  88. clrForeground = 0;
  89. clrBackground = 0;
  90. }
  92. CFont* XTP_DAYITEM_METRICS::GetFont()
  93. {
  94. return &m_fntText;
  95. }
  97. void XTP_DAYITEM_METRICS::SetFont(CFont* pFont)
  98. {
  99. ASSERT_VALID(pFont);
  100. if (!pFont)
  101. return;
  102. // set new font
  103. LOGFONT lf;
  104. pFont->GetLogFont(&lf);
  105. m_fntText.DeleteObject();
  106. m_fntText.CreateFontIndirect(&lf);
  107. }
  110. CXTPDatePickerButton::CXTPDatePickerButton()
  111. {
  112. m_rcButton.SetRectEmpty();
  113. m_bVisible = TRUE;
  114. m_bPressed = FALSE;
  115. m_bHighlight = FALSE;
  116. m_nID = 0;
  117. }
  119. CString CXTPDatePickerButton::GetCaption()
  120. {
  121. if (m_strCaption.IsEmpty())
  122. return CXTPCalendarUtils::LoadString(m_nID);
  124. return m_strCaption;
  125. }
  127. void CXTPDatePickerButton::SetCaption(LPCTSTR pcszCaption)
  128. {
  129. m_strCaption = pcszCaption;
  130. }
  132. //////////////////////////////////////////////////////////////////////////////
  133. // CXTPDatePickerControl
  135. CXTPDatePickerControl::CXTPDatePickerControl()
  136. {
  137. m_pConnect = new CXTPNotifyConnection;
  139. RegisterWindowClass();
  141. m_pfnCallback = NULL;
  142. m_pCallbackParam = NULL;
  143. m_nLockUpdateCount = 0;
  145. m_lcidActiveLocale = CXTPCalendarUtils::GetActiveLCID();
  147. m_pPaintManager = NULL;
  148. SetTheme(NULL);// set default paint manager
  149. //SetTheme(new CXTPDatePickerThemeOffice2007());
  151. m_bAutoSize = TRUE;
  152. m_mouseMode = mouseNothing;
  153. m_nTimerID = 0;
  154. m_bIsModal = FALSE;
  155. m_nMaxSelectionDays = XTP_SELECTION_INFINITE;
  156. m_bSelectWeek = FALSE;
  157. m_bRightToLeft = FALSE;
  159. m_bShowWeekNumbers = FALSE;
  160. m_nRows = 1;
  161. m_nColumns = 1;
  162. m_nFirstDayOfWeek = 2;
  163. m_nFirstWeekOfYearDays = 1;
  164. m_nMonthDelta = 0;
  165. m_bHighlightToday = TRUE;
  166. m_bChanged = TRUE;
  167. m_dtToday = COleDateTime::GetCurrentTime();
  168. m_dtFirstMonth.SetDate(m_dtToday.GetYear(), m_dtToday.GetMonth(), 1);
  169. m_dtMinRange.SetStatus(COleDateTime::null);
  170. m_dtMaxRange.SetStatus(COleDateTime::null);
  172. m_rcControl.SetRectEmpty();
  173. m_rcGrid.SetRectEmpty();
  174. m_bShowNonMonthDays = TRUE;
  175. m_borderStyle = xtpDatePickerBorder3D;
  177. m_pButtonCaptured = NULL;
  179. AddButton(XTP_IDS_DATEPICKER_TODAY);
  180. AddButton(XTP_IDS_DATEPICKER_NONE);
  182. m_pListControl = NULL;
  184. m_pSelectedDays = new CXTPDatePickerDaysCollection(this);
  186. m_arMonthNames = new CString[12];
  187. m_arDayOfWeekNames = new CString[7];
  189. m_bAllowNoncontinuousSelection = TRUE;
  190. m_bMultiSelectionMode = FALSE;
  192. m_bDeleteOnFinalRelease = FALSE;
  194. InitNames();
  196. ClearFocus();
  198. Populate();
  199. //-----------------------------------------------------------------------
  200. XTPGetTopLevelWndMsgNotifier()->Advise(this, WM_TIMECHANGE);
  201. }
  203. CXTPDatePickerControl::~CXTPDatePickerControl()
  204. {
  205. XTPGetTopLevelWndMsgNotifier()->Unadvise(this);
  207. ClearMonths();
  209. if (m_pPaintManager)
  210. m_pPaintManager->SetControl(NULL);
  211. CMDTARGET_RELEASE(m_pPaintManager);
  213. if (m_pListControl)
  214. {
  215. m_pListControl->DestroyWindow();
  216. delete m_pListControl;
  217. }
  219. CMDTARGET_RELEASE(m_pSelectedDays);
  221. if (m_nTimerID != 0 && m_hWnd)
  222. KillTimer(m_nTimerID);
  224. DestroyWindow();
  226. for (int i = 0; i < GetButtonCount(); i++)
  227. delete m_arrButtons[i];
  229. delete[] m_arDayOfWeekNames;
  230. delete[] m_arMonthNames;
  232. CMDTARGET_RELEASE(m_pConnect);
  233. }
  235. void CXTPDatePickerControl::OnDestroy()
  236. {
  237. if (m_bIsModal)
  238. {
  239. if (ContinueModal()) // skip if EndModalLoop has already called
  240. {
  241. EndModalLoop(IDABORT);
  242. }
  243. }
  244. CWnd::OnDestroy();
  245. }
  247. void CXTPDatePickerControl::AddButton(UINT nID)
  248. {
  249. CXTPDatePickerButton* pButton = new CXTPDatePickerButton();
  251. pButton->m_nID = nID;
  253. m_arrButtons.Add(pButton);
  254. }
  256. BOOL CXTPDatePickerControl::IsTodayButtonVisible()
  257. {
  258. CXTPDatePickerButton* pButton = m_arrButtons.Find(XTP_IDS_DATEPICKER_TODAY);
  259. return pButton ? pButton->m_bVisible : FALSE;
  260. }
  262. BOOL CXTPDatePickerControl::IsNoneButtonVisible()
  263. {
  264. CXTPDatePickerButton* pButton = m_arrButtons.Find(XTP_IDS_DATEPICKER_NONE);
  265. return pButton ? pButton->m_bVisible : FALSE;
  266. }
  268. void CXTPDatePickerControl::SetTheme(CXTPDatePickerPaintManager* pPaintManager)
  269. {
  270. // set default
  271. if (!pPaintManager)
  272. pPaintManager = new CXTPDatePickerPaintManager();
  274. if (m_pPaintManager)
  275. m_pPaintManager->SetControl(NULL);
  277. CMDTARGET_RELEASE(m_pPaintManager);
  278. m_pPaintManager = pPaintManager;
  280. if (m_pPaintManager)
  281. {
  282. m_pPaintManager->SetControl(this);
  283. m_pPaintManager->RefreshMetrics();
  284. }
  286. _RedrawControl(FALSE);
  287. }
  289. void CXTPDatePickerControl::RedrawControl()
  290. {
  291. _RedrawControl(TRUE);
  292. }
  294. void CXTPDatePickerControl::_RedrawControl(BOOL bUpdateNow)
  295. {
  296. m_bChanged = TRUE;
  298. if (GetSafeHwnd() && (m_nLockUpdateCount == 0))
  299. {
  300. Invalidate(FALSE);
  301. if (bUpdateNow)
  302. {
  303. UpdateWindow();
  304. }
  305. }
  306. }
  308. BEGIN_MESSAGE_MAP(CXTPDatePickerControl, CWnd)
  309. //{{AFX_MSG_MAP(CXTPDatePickerControl)
  310. ON_WM_CREATE()
  311. ON_WM_ERASEBKGND()
  312. ON_WM_PAINT()
  313. ON_MESSAGE(WM_PRINTCLIENT, OnPrintClient)
  314. ON_WM_LBUTTONDOWN()
  315. ON_WM_LBUTTONUP()
  316. ON_WM_LBUTTONDBLCLK()
  317. ON_WM_CAPTURECHANGED()
  318. ON_WM_CANCELMODE()
  319. ON_WM_MOUSEMOVE()
  320. ON_WM_TIMER()
  321. ON_WM_TIMECHANGE()
  322. ON_WM_SIZE()
  323. ON_WM_SYSCOLORCHANGE()
  324. ON_WM_KEYDOWN()
  325. ON_WM_SETCURSOR()
  327. ON_WM_SETFOCUS()
  328. ON_WM_KILLFOCUS()
  329. ON_WM_GETDLGCODE()
  330. ON_WM_DESTROY()
  331. ON_WM_ENABLE()
  332. //}}AFX_MSG_MAP
  333. ON_MESSAGE_VOID(WM_MOUSELEAVE, OnMouseLeave)
  334. END_MESSAGE_MAP()
  337. /////////////////////////////////////////////////////////////////////////////
  338. // CXTPDatePickerControl message handlers
  340. BOOL CXTPDatePickerControl::OnEraseBkgnd(CDC* /*pDC*/)
  341. {
  342. return TRUE;
  343. }
  345. int CXTPDatePickerControl::OnCreate(LPCREATESTRUCT lp)
  346. {
  347. int nRet = CWnd::OnCreate(lp);
  349. CXTPClientRect rc(this);
  350. AdjustLayout(rc);
  352. if (m_bRightToLeft)
  353. {
  354. SetLayoutRTL(TRUE);
  355. }
  357. return nRet;
  358. }
  360. void CXTPDatePickerControl::PreSubclassWindow()
  361. {
  362. CXTPClientRect rc(this);
  363. AdjustLayout(rc);
  364. }
  366. BOOL CXTPDatePickerControl::GoModal(const RECT& rect, CWnd* pParentWnd)
  367. {
  368. if (!pParentWnd)
  369. pParentWnd = AfxGetMainWnd();
  371. CRect rcScreen(rect);
  373. if (!::IsWindow(m_hWnd) && !CreateEx(WS_EX_TOOLWINDOW, XTP_DATEPICKERCTRL_CLASSNAME, NULL, pParentWnd ? WS_CHILD : WS_POPUP, rcScreen, pParentWnd, 0))
  374. return FALSE;
  376. // Enable this window
  377. EnableWindow(TRUE);
  379. CWnd* pFocusWnd = SetFocus();
  381. if (pParentWnd)
  382. {
  383. SetWindowLongPtr(m_hWnd, GWLP_HWNDPARENT, 0);
  384. ModifyStyle(WS_CHILD, WS_POPUP);
  385. SetWindowLongPtr(m_hWnd, GWLP_HWNDPARENT, (LONG_PTR)pParentWnd->m_hWnd);
  386. }
  388. SetWindowPos(&CWnd::wndTopMost, rcScreen.left, rcScreen.top, rcScreen.Width(), rcScreen.Height(), SWP_SHOWWINDOW | SWP_NOACTIVATE | SWP_NOOWNERZORDER);
  390. SetCapture();
  392. SendNotification(XTP_NC_DATEPICKERBEFOREGOMODAL);
  393. SendMessageToParent(XTP_NC_DATEPICKERBEFOREGOMODAL);
  395. m_bIsModal = TRUE;
  397. m_nFlags |= WF_CONTINUEMODAL;
  398. int nResult = m_nModalResult;
  399. if (ContinueModal())
  400. {
  401. // enter modal loop
  402. DWORD dwFlags = MLF_SHOWONIDLE;
  403. if (GetStyle() & DS_NOIDLEMSG)
  404. dwFlags |= MLF_NOIDLEMSG;
  405. nResult = RunModalLoop(dwFlags);
  406. }
  408. ReleaseCapture();
  409. DestroyWindow();
  411. m_bIsModal = FALSE;
  413. if (pFocusWnd && ::IsWindow(pFocusWnd->GetSafeHwnd()))
  414. pFocusWnd->SetFocus();
  416. return (nResult == IDOK);
  417. }
  419. CSize CXTPDatePickerControl::SetGridDimentions(CRect rcClient)
  420. {
  421. CWindowDC dc(GetOwner());
  422. CSize szMonth(m_pPaintManager->CalcMonthRect(&dc));
  424. szMonth.cy += 2;
  426. m_nRows = max(1, rcClient.Height() / szMonth.cy);
  427. m_nColumns = max(1, rcClient.Width() / szMonth.cx);
  429. if (m_dtMaxRange.GetStatus() == COleDateTime::valid)
  430. {
  431. int nMaxRangeMonths = (m_dtMaxRange.GetYear() * 12 + m_dtMaxRange.GetMonth()) -
  432. (m_dtFirstMonth.GetYear() * 12 + m_dtFirstMonth.GetMonth()) + 1;
  434. if (m_dtMinRange.GetStatus() == COleDateTime::valid)
  435. {
  436. int nTotalMaxRangeMonths = (m_dtMaxRange.GetYear() * 12 + m_dtMaxRange.GetMonth()) -
  437. (m_dtMinRange.GetYear() * 12 + m_dtMinRange.GetMonth()) + 1;
  438. while (m_nRows * m_nColumns > nTotalMaxRangeMonths)
  439. {
  440. if (m_nRows > 1)
  441. m_nRows--;
  442. else if (m_nColumns > 1)
  443. m_nColumns--;
  444. else
  445. break;
  446. }
  447. }
  449. if (m_nRows * m_nColumns > nMaxRangeMonths)
  450. {
  451. ShiftDate(m_dtFirstMonth, nMaxRangeMonths - m_nRows * m_nColumns);
  452. }
  454. if (m_dtMinRange.GetStatus() == COleDateTime::valid &&
  455. m_dtFirstMonth < m_dtMinRange)
  456. {
  457. m_dtFirstMonth = m_dtMinRange;
  458. while (m_nRows * m_nColumns > nMaxRangeMonths)
  459. {
  460. if (m_nRows > 1)
  461. m_nRows--;
  462. else if (m_nColumns > 1)
  463. m_nColumns--;
  464. else
  465. break;
  466. }
  467. }
  468. }
  469. return szMonth;
  470. }
  472. void CXTPDatePickerControl::AdjustLayout(CRect rcClient)
  473. {
  474. if (!GetSafeHwnd())
  475. return;
  477. if (m_lcidActiveLocale != CXTPCalendarUtils::GetActiveLCID())
  478. {
  479. m_lcidActiveLocale = CXTPCalendarUtils::GetActiveLCID();
  481. InitNames();
  482. }
  484. m_dtToday = COleDateTime::GetCurrentTime();
  486. m_rcControl = rcClient;
  488. CSize szMonth(0, 0);
  489. CRect rcMonth(0, 0, 0, 0);
  491. //get button size
  492. CSize szButton(CalcButtonSize());
  494. m_rcGrid.CopyRect(&m_rcControl);
  496. m_pPaintManager->DrawBorder(0, this, m_rcGrid, FALSE);
  498. if (m_arrButtons.GetVisibleButtonCount() > 0)
  499. m_rcGrid.bottom -= szButton.cy;
  501. if (!m_bAutoSize)
  502. {
  503. szMonth.cx = m_rcGrid.Width() / m_nColumns;
  504. szMonth.cy = m_rcGrid.Height() / m_nRows;
  505. }
  506. else
  507. {
  508. szMonth = SetGridDimentions(m_rcGrid);
  509. CSize szGrid (szMonth.cx * m_nColumns, szMonth.cy * m_nRows);
  511. int nXOffset = max(0, (m_rcGrid.left + m_rcGrid.right - szGrid.cx) / 2);
  512. int nYOffset = max(0, (m_rcGrid.top + m_rcGrid.bottom - szGrid.cy) / 2);
  514. m_rcGrid = CRect(CPoint(nXOffset, nYOffset), szGrid);
  516. ClearMonths();
  517. CreateMonthArray();
  519. } // else auto end
  521. CalcButtonBandRect();
  522. int nIndex = 0;
  523. for (int nRow = 0; nRow < m_nRows; nRow++)
  524. {
  525. for (int nCol = 0; nCol < m_nColumns; nCol++)
  526. {
  527. rcMonth = CRect(CPoint(m_rcGrid.left + nCol * szMonth.cx, m_rcGrid.top + nRow * szMonth.cy), szMonth);
  528. rcMonth.DeflateRect(1, 1);
  530. // get next month item
  531. CXTPDatePickerItemMonth* pMonth = m_arrMonths.GetAt(nIndex);
  532. nIndex++;
  533. // adjust internal month layout
  534. pMonth->AdjustLayout(rcMonth, !m_bAutoSize);
  535. }
  536. }
  538. m_bChanged = TRUE;
  539. }
  541. void CXTPDatePickerControl::OnPaint()
  542. {
  543. CPaintDC dc(this); // device context for painting
  545. CXTPClientRect rc(this);
  547. // Check cached bitmap
  548. if (!m_bChanged && m_bmpCache.GetSafeHandle() != 0)
  549. {
  550. CXTPCompatibleDC memDC(&dc, &m_bmpCache);
  551. dc.BitBlt(0, 0, rc.right, rc.bottom, &memDC, 0, 0, SRCCOPY);
  552. }
  553. else
  554. {
  555. CDC memDC;
  556. memDC.CreateCompatibleDC(&dc);
  558. m_bmpCache.DeleteObject();
  559. m_bmpCache.CreateCompatibleBitmap(&dc, rc.Width(), rc.Height());
  561. CBitmap* pOldBitmap = memDC.SelectObject(&m_bmpCache);
  563. OnDraw(&memDC);
  565. if (!IsWindowEnabled())
  566. {
  567. XTPImageManager()->DisableBitmap(memDC, rc, XTP_CALENDAR_DISABLED_COLOR_LIGHT, XTP_CALENDAR_DISABLED_COLOR_DARK);
  568. }
  570. dc.BitBlt(0, 0, rc.right, rc.bottom, &memDC, 0, 0, SRCCOPY);
  572. memDC.SelectObject(pOldBitmap);
  574. // update flag
  575. m_bChanged = FALSE;
  576. }
  577. }
  579. LRESULT CXTPDatePickerControl::OnPrintClient(WPARAM wParam, LPARAM /*lParam*/)
  580. {
  581. CDC* pDC = CDC::FromHandle((HDC)wParam);
  582. if (pDC)
  583. {
  584. OnDraw(pDC);
  585. }
  587. return TRUE;
  588. }
  590. void CXTPDatePickerControl::OnDraw(CDC* pDC)
  591. {
  592. CXTPClientRect rcClient(this);
  594. // draw background
  595. m_pPaintManager->DrawBackground(pDC, rcClient);
  597. // draw all month items in the collection
  598. int nMonthCount = (int)m_arrMonths.GetSize();
  599. for (int nIndex = 0; nIndex < nMonthCount; nIndex++)
  600. {
  601. // get next month item
  602. CXTPDatePickerItemMonth* pMonth = m_arrMonths.GetAt(nIndex);
  603. // draw it
  604. pMonth->Draw(pDC);
  605. }
  607. // draw today/none buttons
  608. DrawButtons(pDC);
  610. // draw border
  611. m_pPaintManager->DrawBorder(pDC, this, rcClient, TRUE);
  612. }
  614. UINT CXTPDatePickerControl::OnGetDlgCode()
  615. {
  616. return DLGC_WANTARROWS /*| DLGC_WANTTAB | DLGC_WANTALLKEYS*/;
  617. }
  619. void CXTPDatePickerControl::OnKeyDown(UINT nChar, UINT nRepCnt, UINT nFlags)
  620. {
  621. #ifdef XTP_DATEPICKER_SITENOTIFY_KEY
  622. if (!XTP_DATEPICKER_SITENOTIFY_KEY(this, TRUE, nChar))
  623. return;
  624. #endif
  625. if (nChar == 0)
  626. return;
  628. if (nChar == VK_RETURN || nChar == VK_ESCAPE)
  629. {
  630. if (m_bIsModal)
  631. {
  632. if (ContinueModal()) // skip if EndModalLoop has already called
  633. {
  634. EndModalLoop(nChar == VK_RETURN ? IDOK : IDCANCEL);
  635. }
  636. return;
  637. }
  638. }
  639. else if (nChar == VK_LEFT || nChar == VK_RIGHT || nChar == VK_UP ||
  640. nChar == VK_DOWN || nChar == VK_PRIOR || nChar == VK_NEXT ||
  641. nChar == VK_HOME || nChar == VK_END ||
  642. nChar == VK_SPACE)
  643. {
  644. CXTPSelectionHelper _selector(this);
  646. BOOL bIsShift = (::GetKeyState(VK_SHIFT) & 0x8000) != 0;
  647. BOOL bIsCtrl = (::GetKeyState(VK_CONTROL) & 0x8000) != 0 || IsMultiSelectionMode();
  648. XTPDrawHelpers()->KeyToLayout(this, nChar);
  650. if (nChar == VK_RIGHT)
  651. {
  652. _selector.MoveFocus(stepDay, dirNext, bIsShift, bIsCtrl);
  653. }
  654. else if (nChar == VK_DOWN)
  655. {
  656. _selector.MoveFocus(stepWeek, dirNext, bIsShift, bIsCtrl);
  657. }
  658. else if (nChar == VK_NEXT && !bIsCtrl)
  659. {
  660. _selector.MoveFocus(stepMonth, dirNext, FALSE, FALSE);
  661. }
  662. else if (nChar == VK_NEXT && bIsCtrl)
  663. {
  664. _selector.MoveFocus(stepYear, dirNext, FALSE, FALSE);
  665. }
  666. //*****
  667. else if (nChar == VK_LEFT)
  668. {
  669. _selector.MoveFocus(stepDay, dirPrev, bIsShift, bIsCtrl);
  670. }
  671. else if (nChar == VK_UP)
  672. {
  673. _selector.MoveFocus(stepWeek, dirPrev, bIsShift, bIsCtrl);
  674. }
  675. else if (nChar == VK_PRIOR && !bIsCtrl)
  676. {
  677. _selector.MoveFocus(stepMonth, dirPrev, FALSE, FALSE);
  678. }
  679. else if (nChar == VK_PRIOR && bIsCtrl)
  680. {
  681. _selector.MoveFocus(stepYear, dirPrev, FALSE, FALSE);
  682. }
  683. //***
  684. else if (nChar == VK_HOME && !bIsCtrl)
  685. {
  686. _selector.MoveFocus(stepWeekBE, dirPrev, FALSE, FALSE);
  687. }
  688. else if (nChar == VK_HOME && bIsCtrl)
  689. {
  690. _selector.MoveFocus(stepMonthBE, dirPrev, FALSE, FALSE);
  691. }
  692. //***
  693. else if (nChar == VK_END && !bIsCtrl)
  694. {
  695. _selector.MoveFocus(stepWeekBE, dirNext, FALSE, FALSE);
  696. }
  697. else if (nChar == VK_END && bIsCtrl)
  698. {
  699. _selector.MoveFocus(stepMonthBE, dirNext, FALSE, FALSE);
  700. }
  701. //***
  702. else if (nChar == VK_SPACE && bIsCtrl)
  703. {
  704. _selector.SelUnselFocus();
  705. }
  707. //***
  708. _selector._TmpSaveFocus();
  709. m_nLockUpdateCount++;
  711. // fire selection changed
  712. SendNotification(XTP_NC_DATEPICKERSELECTIONCHANGED);
  713. SendMessageToParent(XTP_NC_DATEPICKER_SELECTION_CHANGED);
  714. //***
  715. _selector._TmpRestoreFocus();
  716. m_nLockUpdateCount--;
  718. //-------------------
  719. EnsureVisibleFocus();
  721. //--------------
  722. RedrawControl();
  723. }
  725. CWnd::OnKeyDown(nChar, nRepCnt, nFlags);
  726. }
  728. void CXTPDatePickerControl::OnLButtonDown(UINT nFlags, CPoint point)
  729. {
  730. if (m_bIsModal && !m_rcControl.PtInRect(point))
  731. {
  732. if (ContinueModal()) // skip if EndModalLoop has already called
  733. {
  734. EndModalLoop(IDCANCEL);
  735. }
  736. return;
  737. }
  738. if (!m_bIsModal)
  739. {
  740. SetCapture();
  741. }
  742. SetFocus();
  744. CXTPDatePickerItemMonth* pMonth = HitTest(point);
  745. if (pMonth)
  746. {
  747. pMonth->OnLButtonDown(nFlags, point);
  748. }
  750. // process buttons
  751. m_pButtonCaptured = m_arrButtons.HitTest(point);
  753. ProcessButtons(point);
  755. CWnd::OnLButtonDown(nFlags, point);
  756. }
  758. void CXTPDatePickerControl::OnLButtonDblClk(UINT nFlags, CPoint point)
  759. {
  760. CXTPDatePickerItemMonth* pMonth = HitTest(point);
  761. if (pMonth)
  762. {
  763. pMonth->OnLButtonDown(nFlags, point);
  764. }
  766. m_pButtonCaptured = m_arrButtons.HitTest(point);
  767. ProcessButtons(point);
  769. CWnd::OnLButtonDblClk(nFlags, point);
  770. }
  772. void CXTPDatePickerControl::OnLButtonUp(UINT nFlags, CPoint point)
  773. {
  774. // kill timer
  775. if (m_nTimerID != 0)
  776. {
  777. KillTimer(m_nTimerID);
  778. m_nTimerID = 0;
  779. }
  781. // logic message processing
  782. if (m_mouseMode == mouseTrackingHeaderList)
  783. {
  784. // reset mouse mode
  785. m_mouseMode = mouseNothing;
  787. if (m_pListControl)
  788. {
  789. int nDelta = m_pListControl->GetMonthInterval();
  790. // destroy list control
  791. m_pListControl->DestroyWindow();
  792. delete m_pListControl;
  793. m_pListControl = NULL;
  794. // scroll on selected months count
  795. if (nDelta < 0)
  796. ScrollLeft(-nDelta);
  797. else if (nDelta > 0)
  798. ScrollRight(nDelta);
  799. }
  800. }
  801. else
  802. {
  803. // forward message to appropriate month
  804. CXTPDatePickerItemMonth* pMonth = HitTest(point);
  805. if (pMonth)
  806. {
  807. pMonth->OnLButtonUp(nFlags, point);
  808. }
  810. // Update selection
  811. BOOL bSelecting = m_mouseMode == mouseSelecting;
  812. BOOL bDeselecting = m_mouseMode == mouseDeselecting;
  813. if (bSelecting || bDeselecting)
  814. {
  815. int nDay = (m_dtLastClicked - m_dtFirstClicked).GetDays();
  816. for (; abs(nDay) >= 0; nDay += nDay > 0 ? -1 : 1)
  817. {
  818. COleDateTime dtSelect(m_dtFirstClicked);
  819. dtSelect += nDay;
  820. if (bDeselecting)
  821. {
  822. m_pSelectedDays->Remove(dtSelect);
  823. }
  824. else if (bSelecting && IsSelected(dtSelect))
  825. {
  826. m_pSelectedDays->Add(dtSelect);
  827. }
  829. if (nDay == 0)
  830. break;
  831. }
  833. // reset mouse mode
  834. m_mouseMode = mouseNothing;
  836. // fire selection changed
  837. SendNotification(XTP_NC_DATEPICKERSELECTIONCHANGED);
  838. SendMessageToParent(XTP_NC_DATEPICKER_SELECTION_CHANGED);
  839. _EndModalIfNeed();
  840. }
  841. }
  843. //release resources
  844. if (!m_bIsModal)
  845. ReleaseCapture();
  848. // process buttons
  849. m_pButtonCaptured = NULL;
  850. ProcessButtons(point);
  853. // reset mouse mode
  854. m_mouseMode = mouseNothing;
  856. CWnd::OnLButtonUp(nFlags, point);
  857. }
  859. void CXTPDatePickerControl::OnCaptureChanged(CWnd* pWnd)
  860. {
  861. // kill timer
  862. if (m_nTimerID != 0)
  863. {
  864. KillTimer(m_nTimerID);
  865. m_nTimerID = 0;
  866. }
  868. // logic message processing
  869. if (m_mouseMode == mouseTrackingHeaderList)
  870. {
  871. // reset mouse mode
  872. m_mouseMode = mouseNothing;
  874. if (m_pListControl)
  875. {
  876. if (m_pListControl->GetSafeHwnd())
  877. m_pListControl->DestroyWindow();
  878. delete m_pListControl;
  879. m_pListControl = NULL;
  880. }
  881. }
  882. m_pButtonCaptured = NULL;
  884. if (m_bIsModal)
  885. {
  886. if (ContinueModal()) // skip if EndModalLoop has already called
  887. {
  888. EndModalLoop(IDOK);
  889. }
  890. }
  892. CWnd::OnCaptureChanged(pWnd);
  893. }
  895. void CXTPDatePickerControl::OnCancelMode()
  896. {
  897. CWnd::OnCancelMode();
  898. }
  900. void CXTPDatePickerControl::OnMouseLeave()
  901. {
  902. TRACKMOUSEEVENT tre;
  903. tre.dwFlags = TME_CANCEL;
  904. tre.hwndTrack = this->m_hWnd;
  905. tre.dwHoverTime = HOVER_DEFAULT;
  906. tre.cbSize = sizeof(tre);
  908. _TrackMouseEvent(&tre);
  910. ProcessButtons(CPoint(-1, -1));
  911. }
  914. void CXTPDatePickerControl::OnMouseMove(UINT nFlags, CPoint point)
  915. {
  916. if (m_mouseMode == mouseTrackingHeaderList)
  917. {
  918. if (m_pListControl)
  919. {
  920. m_pListControl->OnMouseMove(nFlags, point);
  921. }
  922. }
  923. else
  924. {
  925. // forward message to appropriate month
  926. CXTPDatePickerItemMonth* pMonth = HitTest(point);
  927. if (pMonth)
  928. pMonth->OnMouseMove(nFlags, point);
  929. }
  931. ProcessButtons(point);
  934. // standard processing
  935. CWnd::OnMouseMove(nFlags, point);
  937. TRACKMOUSEEVENT tre;
  938. tre.dwFlags = TME_LEAVE;
  939. tre.hwndTrack = this->m_hWnd;
  940. tre.dwHoverTime = HOVER_DEFAULT;
  941. tre.cbSize = sizeof(tre);
  943. _TrackMouseEvent(&tre);
  945. // fire mouse move
  946. DWORD dwPoint = MAKELONG(point.x, point.y);
  947. SendNotification(XTP_NC_DATEPICKERMOUSEMOVE, dwPoint);
  948. }
  950. BOOL CXTPDatePickerControl::RegisterWindowClass(HINSTANCE hInstance /*= NULL*/)
  951. {
  952. WNDCLASS wndcls;
  953. if (hInstance == NULL) hInstance = AfxGetInstanceHandle();
  955. if (!(::GetClassInfo(hInstance, XTP_DATEPICKERCTRL_CLASSNAME, &wndcls)))
  956. {
  957. // otherwise we need to register a new class
  958. wndcls.style = CS_DBLCLKS | CS_HREDRAW | CS_VREDRAW;
  959. wndcls.lpfnWndProc = ::DefWindowProc;
  960. wndcls.cbClsExtra = wndcls.cbWndExtra = 0;
  961. wndcls.hInstance = hInstance;
  962. wndcls.hIcon = NULL;
  963. wndcls.hCursor = AfxGetApp()->LoadStandardCursor(IDC_ARROW);
  964. wndcls.hbrBackground = (HBRUSH) (COLOR_3DFACE + 1);
  965. wndcls.lpszMenuName = NULL;
  966. wndcls.lpszClassName = XTP_DATEPICKERCTRL_CLASSNAME;
  968. if (!AfxRegisterClass(&wndcls))
  969. {
  970. AfxThrowResourceException();
  971. return FALSE;
  972. }
  973. }
  975. return TRUE;
  976. }
  978. BOOL CXTPDatePickerControl::Create(DWORD dwStyle, const RECT& rect, CWnd* pParentWnd, UINT nID, CCreateContext* pContext)
  979. {
  980. if (!CWnd::Create(XTP_DATEPICKERCTRL_CLASSNAME, NULL, dwStyle, rect, pParentWnd, nID, pContext))
  981. return FALSE;
  983. return TRUE;
  984. }
  986. void CXTPDatePickerControl::OnSize(UINT nType, int cx, int cy)
  987. {
  988. CWnd::OnSize(nType, cx, cy);
  990. CXTPClientRect rc(this);
  992. CRect rcClient(0, 0, 0, 0);
  993. this->GetClientRect(&rcClient);
  995. AdjustLayout(rcClient);
  996. }
  998. void CXTPDatePickerControl::ClearMonths()
  999. {
  1000. // cleanup old month array
  1001. int nOldMonthCount = (int)m_arrMonths.GetSize();
  1002. for (int nMonth = 0; nMonth < nOldMonthCount; nMonth++)
  1003. {
  1004. CXTPDatePickerItemMonth* pMonth = m_arrMonths.GetAt(nMonth);
  1005. pMonth->InternalRelease();
  1006. }
  1007. m_arrMonths.RemoveAll();
  1008. }
  1010. void CXTPDatePickerControl::CreateMonthArray()
  1011. {
  1012. COleDateTime dtNextMonth(m_dtFirstMonth);
  1013. for (int nRow = 0; nRow < m_nRows; nRow++)
  1014. {
  1015. for (int nCol = 0; nCol < m_nColumns; nCol++)
  1016. {
  1017. //int nIndex = nRow * m_nRows + nCol;
  1018. // create next month item
  1019. CXTPDatePickerItemMonth* pMonth = new CXTPDatePickerItemMonth(this, dtNextMonth, nRow, nCol);
  1021. // add it to the array
  1022. m_arrMonths.Add(pMonth);
  1024. // go to the next month
  1025. if (dtNextMonth.GetMonth() < 12)
  1026. dtNextMonth.SetDate(dtNextMonth.GetYear(), dtNextMonth.GetMonth() + 1, 1);
  1027. else
  1028. dtNextMonth.SetDate(dtNextMonth.GetYear() + 1, 1, 1);
  1029. }
  1030. }
  1032. // set first month and last month defaults
  1033. int nMonthCount = (int)m_arrMonths.GetSize();
  1034. if (nMonthCount > 0)
  1035. {
  1036. CXTPDatePickerItemMonth* pFirstMonth = m_arrMonths.GetAt(0);
  1037. CXTPDatePickerItemMonth* pLastMonth = m_arrMonths.GetAt(nMonthCount - 1);
  1038. // by default set show previous days for first month and show following days for last month
  1039. pFirstMonth->SetShowDaysBefore(m_bShowNonMonthDays);
  1040. pLastMonth->SetShowDaysAfter(m_bShowNonMonthDays);
  1041. // set triangles showing
  1042. pFirstMonth->SetShowScrolling(TRUE, pFirstMonth->GetShowRightScroll());
  1043. CXTPDatePickerItemMonth* pLastMonthTopRow = m_arrMonths.GetAt(m_nColumns - 1);
  1044. pLastMonthTopRow->SetShowScrolling(pLastMonthTopRow->GetShowLeftScroll(), TRUE);
  1045. }
  1047. }
  1049. void CXTPDatePickerControl::Populate()
  1050. {
  1051. // cleanup old month array
  1052. ClearMonths();
  1054. // add all month items in the grid to the array
  1055. // and set first month and last month defaults
  1056. CreateMonthArray();
  1058. // redraw control image
  1059. if (!m_rcControl.IsRectEmpty())
  1060. AdjustLayout(m_rcControl);
  1061. _RedrawControl(FALSE);
  1063. SendNotification(XTP_NC_DATEPICKERMONTHCHANGED);
  1064. SendMessageToParent(XTP_NC_DATEPICKERMONTHCHANGED);
  1065. }
  1067. void CXTPDatePickerControl::GetDayMetrics(COleDateTime& dtDay, XTP_DAYITEM_METRICS* pDayMetics)
  1068. {
  1069. WPARAM wprmDay = (XTP_DATE_VALUE)(DATE)dtDay;
  1070. SendNotification(XTP_NC_DATEPICKERGETDAYMETRICS, wprmDay, (LPARAM)pDayMetics);
  1072. if (m_pfnCallback)
  1073. {
  1074. try
  1075. {
  1076. m_pfnCallback(this, dtDay, pDayMetics, m_pCallbackParam);
  1077. }
  1078. catch(...)
  1079. {
  1080. ASSERT(FALSE);
  1081. }
  1082. }
  1083. }
  1085. void CXTPDatePickerControl::SetGridSize(int nRows, int nCols)
  1086. {
  1087. m_nRows = nRows;
  1088. m_nColumns = nCols;
  1089. Populate();
  1090. }
  1092. void CXTPDatePickerControl::SetHighlightToday(BOOL bValue)
  1093. {
  1094. m_bHighlightToday = bValue;
  1095. _RedrawControl(FALSE);
  1096. }
  1098. void CXTPDatePickerControl::SetShowWeekNumbers(BOOL bValue)
  1099. {
  1100. m_bShowWeekNumbers = bValue;
  1101. AdjustLayout(m_rcControl);
  1102. _RedrawControl(FALSE);
  1103. }
  1105. CSize CXTPDatePickerControl::CalcButtonSize() const
  1106. {
  1107. // get button size
  1108. CWindowDC dc(GetDesktopWindow());
  1109. CXTPFontDC fnt(&dc, m_pPaintManager->GetButtonFont());
  1111. CSize szButton(0, 0);
  1113. for (int i = 0; i < GetButtonCount(); i++)
  1114. {
  1115. CSize sz = dc.GetTextExtent(GetButton(i)->GetCaption());
  1117. szButton.cx = max(szButton.cx, sz.cx + 12);
  1118. szButton.cy = max(szButton.cy, sz.cy + 6);
  1119. }
  1121. return szButton;
  1122. }
  1124. void CXTPDatePickerControl::SetButtonRect()
  1125. {
  1126. CSize szButton(CalcButtonSize());
  1128. int nGap = 10;
  1130. int nButtonLen = szButton.cx + nGap;
  1131. int nVisibleCount = m_arrButtons.GetVisibleButtonCount();
  1133. int nLeft = m_rcGrid.CenterPoint().x - (nButtonLen * nVisibleCount - nGap)/2;
  1135. for (int i = 0; i < GetButtonCount(); i++)
  1136. {
  1137. CXTPDatePickerButton* pButton = GetButton(i);
  1138. if (!pButton->m_bVisible) continue;
  1140. pButton->m_rcButton = CRect(CPoint(nLeft, m_rcGrid.bottom + 1), szButton);
  1141. nLeft += nButtonLen;
  1142. }
  1143. }
  1145. void CXTPDatePickerControl::CalcButtonBandRect()
  1146. {
  1147. SetButtonRect();
  1148. }
  1150. void CXTPDatePickerControl::DrawButtons(CDC* pDC)
  1151. {
  1152. for (int i = 0; i < GetButtonCount(); i++)
  1153. {
  1154. CXTPDatePickerButton* pButton = GetButton(i);
  1155. if (pButton->m_bVisible)
  1156. m_pPaintManager->DrawButton(pDC, pButton->m_rcButton, pButton->GetCaption(), pButton->m_bPressed, pButton->m_bHighlight);
  1157. }
  1158. }
  1160. CXTPDatePickerItemMonth* CXTPDatePickerControl::HitTest(CPoint ptMouse)
  1161. {
  1162. // enumerate all month items in the collection
  1163. int nMonthCount = (int)m_arrMonths.GetSize();
  1164. for (int nIndex = 0; nIndex < nMonthCount; nIndex++)
  1165. {
  1166. CXTPDatePickerItemMonth* pMonth = m_arrMonths.GetAt(nIndex);
  1167. if (pMonth && pMonth->m_rcMonth.PtInRect(ptMouse))
  1168. return pMonth;
  1169. }
  1170. return NULL;
  1171. }
  1173. void CXTPDatePickerControl::ScrollLeft(int nMonthCount)
  1174. {
  1175. int nYearNew = m_dtFirstMonth.GetYear() - nMonthCount / 12;
  1176. int nMonthNew = m_dtFirstMonth.GetMonth() - nMonthCount % 12;
  1177. if (nMonthNew < 1)
  1178. {
  1179. nMonthNew += 12;
  1180. nYearNew--;
  1181. }
  1182. ASSERT(nMonthNew >= 1 && nMonthNew <= 12);
  1184. if (m_dtMinRange.GetStatus() == COleDateTime::valid)
  1185. {
  1186. if (nYearNew < m_dtMinRange.GetYear())
  1187. {
  1188. nYearNew = m_dtMinRange.GetYear();
  1189. nMonthNew = m_dtMinRange.GetMonth();
  1190. }
  1192. if (m_dtMinRange.GetYear() == nYearNew)
  1193. {
  1194. if (nMonthNew < m_dtMinRange.GetMonth())
  1195. nMonthNew = m_dtMinRange.GetMonth();
  1196. }
  1197. }
  1199. m_dtFirstMonth.SetDate(nYearNew, nMonthNew, 1);
  1201. Populate();
  1202. }
  1204. void CXTPDatePickerControl::ScrollRight(int nMonthCount)
  1205. {
  1206. int nYearNew = m_dtFirstMonth.GetYear() + nMonthCount / 12;
  1207. int nMonthNew = m_dtFirstMonth.GetMonth() + nMonthCount % 12;
  1208. if (nMonthNew > 12)
  1209. {
  1210. nMonthNew -= 12;
  1211. nYearNew++;
  1212. }
  1214. if (m_dtMaxRange.GetStatus() == COleDateTime::valid)
  1215. {
  1216. int nLeftMonth = m_dtMaxRange.GetMonth() - m_nRows * m_nColumns + 1;
  1217. int nLeftYear = m_dtMaxRange.GetYear();
  1218. if (nLeftMonth < 1)
  1219. {
  1220. nLeftYear -= (-nLeftMonth) / 12 + 1;
  1221. nLeftMonth = -(((-nLeftMonth) % 12) - 12);
  1222. }
  1224. if (nYearNew > nLeftYear)
  1225. {
  1226. nYearNew = nLeftYear;
  1227. nMonthNew = nLeftMonth;
  1228. }
  1230. if (nLeftYear == nYearNew)
  1231. {
  1232. if (nMonthNew > nLeftMonth)
  1233. nMonthNew = nLeftMonth;
  1234. }
  1235. }
  1237. m_dtFirstMonth.SetDate(nYearNew, nMonthNew, 1);
  1239. ScrollLeft(0); // adjust also scrolling left before calling Populate();
  1240. }
  1243. void CXTPDatePickerControl::OnTimeChange()
  1244. {
  1245. CWnd::OnTimeChange();
  1246. m_dtToday = CXTPCalendarUtils::GetCurrentTime();
  1247. _RedrawControl(FALSE);
  1248. }
  1250. void CXTPDatePickerControl::OnTimer(UINT_PTR nIDEvent)
  1251. {
  1252. if (nIDEvent == XTP_DATEPICKER_TIMERID)
  1253. {
  1254. if (m_mouseMode == mouseScrollingLeft)
  1255. ScrollLeft(GetMonthDelta());
  1256. else if (m_mouseMode == mouseScrollingRight)
  1257. ScrollRight(GetMonthDelta());
  1259. if ((m_mouseMode == mouseTrackingHeaderList) &&
  1260. (m_pListControl != NULL))
  1261. {
  1262. m_pListControl->OnTimer(nIDEvent);
  1263. }
  1264. }
  1266. CWnd::OnTimer(nIDEvent);
  1267. }
  1269. void CXTPDatePickerControl::ShowListHeader(CRect rcHeader, COleDateTime dtMonth)
  1270. {
  1271. // make sure that the list is not already created
  1272. ASSERT(!m_pListControl);
  1273. if (m_pListControl)
  1274. {
  1275. m_pListControl->DestroyWindow();
  1276. delete m_pListControl;
  1277. m_pListControl = NULL;
  1278. }
  1280. if (!m_bIsModal)
  1281. SetCapture();
  1283. // create list
  1284. m_pListControl = new CXTPDatePickerList(this, dtMonth);
  1285. if (!m_pListControl)
  1286. throw (new CMemoryException());
  1288. // create control
  1289. m_pListControl->Create(rcHeader);
  1291. m_nTimerID = (UINT)SetTimer(XTP_DATEPICKER_TIMERID, 2 * XTP_DATEPICKER_TIMER_INTERVAL / 3, NULL);
  1293. m_mouseMode = mouseTrackingHeaderList;
  1294. }
  1296. void CXTPDatePickerControl::Select(const COleDateTime& dtDay)
  1297. {
  1298. ClearFocus();
  1299. if (m_nMaxSelectionDays == XTP_SELECTION_INFINITE ||
  1300. m_nMaxSelectionDays > m_pSelectedDays->GetSelectedDaysCount())
  1301. {
  1302. m_pSelectedDays->Add(dtDay);
  1303. }
  1304. }
  1306. void CXTPDatePickerControl::Deselect(const COleDateTime& dtDay)
  1307. {
  1308. ClearFocus();
  1309. m_pSelectedDays->Remove(dtDay);
  1310. }
  1312. BOOL CXTPDatePickerControl::IsSelected(const COleDateTime& dtDay) const
  1313. {
  1314. BOOL bSelected = m_pSelectedDays->Contains(dtDay);
  1316. if (m_mouseMode == mouseSelecting ||
  1317. m_mouseMode == mouseDeselecting)
  1318. {
  1319. BOOL bBetween = FALSE;
  1320. if (m_dtFirstClicked <= m_dtLastClicked &&
  1321. m_dtFirstClicked <= dtDay && m_dtLastClicked >= dtDay)
  1322. {
  1323. bBetween = TRUE;
  1324. }
  1325. if (m_dtFirstClicked >= m_dtLastClicked &&
  1326. m_dtFirstClicked >= dtDay && m_dtLastClicked <= dtDay)
  1327. {
  1328. bBetween = TRUE;
  1329. }
  1330. if (bBetween && m_mouseMode == mouseSelecting)
  1331. {
  1332. COleDateTimeSpan spDays = dtDay - m_dtFirstClicked;
  1333. int nDays = abs(spDays.GetDays());
  1334. if (m_nMaxSelectionDays == XTP_SELECTION_INFINITE ||
  1335. m_pSelectedDays->GetSelectedDaysCount() + nDays < m_nMaxSelectionDays)
  1336. {
  1337. bSelected = TRUE;
  1338. }
  1339. }
  1340. if (bBetween && m_mouseMode == mouseDeselecting)
  1341. bSelected = FALSE;
  1342. }
  1343. return bSelected;
  1344. }
  1346. BOOL CXTPDatePickerControl::IsFocused(const COleDateTime& dtDay) const
  1347. {
  1348. if (m_dtFocused.GetStatus() != COleDateTime::valid)
  1349. {
  1350. return FALSE;
  1351. }
  1353. return CXTPCalendarUtils::IsEqual(CXTPCalendarUtils::ResetTime(m_dtFocused),
  1354.   CXTPCalendarUtils::ResetTime(dtDay));
  1355. }
  1357. void CXTPDatePickerControl::ClearFocus()
  1358. {
  1359. CXTPSelectionHelper _selector(this);
  1360. _selector.RemoveFocus();
  1361. }
  1363. void CXTPDatePickerControl::OnButtonClick(UINT nID)
  1364. {
  1365. XTP_NC_DATEPICKER_BUTTON nm;
  1366. nm.nID = nID;
  1368. SendNotification(XTP_NC_DATEPICKERBUTTONCLICKED, nID);
  1369. SendMessageToParent(XTP_NC_DATEPICKER_BUTTON_CLICK, (NMHDR*)&nm);
  1371. switch (nID)
  1372. {
  1373. case XTP_IDS_DATEPICKER_TODAY:
  1374. {
  1375. // behavior: change selection to today
  1376. ClearFocus();
  1377. m_pSelectedDays->Clear();
  1378. COleDateTime dt;
  1379. GetToday(dt);
  1380. EnsureVisible(dt);
  1381. Select(dt);
  1382. SendNotification(XTP_NC_DATEPICKERSELECTIONCHANGED);
  1383. SendMessageToParent(XTP_NC_DATEPICKER_SELECTION_CHANGED);
  1384. _EndModalIfNeed();
  1385. }
  1386. break;
  1388. case XTP_IDS_DATEPICKER_NONE:
  1389. {
  1390. // behavior: change selection
  1391. ClearFocus();
  1392. m_pSelectedDays->Clear();
  1393. SendNotification(XTP_NC_DATEPICKERSELECTIONCHANGED);
  1394. SendMessageToParent(XTP_NC_DATEPICKER_SELECTION_CHANGED);
  1395. _EndModalIfNeed();
  1396. }
  1397. break;
  1398. }
  1399. }
  1401. void CXTPDatePickerControl::ProcessButtons(CPoint point)
  1402. {
  1403. for (int i = 0; i < GetButtonCount(); i++)
  1404. {
  1405. CXTPDatePickerButton* pButton = GetButton(i);
  1406. BOOL bHighlight = pButton->m_rcButton.PtInRect(point);
  1408. if (pButton == m_pButtonCaptured)
  1409. {
  1410. if (bHighlight != pButton->m_bPressed)
  1411. {
  1412. pButton->m_bPressed = bHighlight;
  1413. _RedrawControl(FALSE);
  1414. }
  1415. }
  1416. else if (pButton->m_bPressed)
  1417. {
  1418. pButton->m_bPressed = FALSE;
  1419.  if (bHighlight)
  1420.  OnButtonClick(pButton->m_nID);
  1421. _RedrawControl(FALSE);
  1422. }
  1424. bHighlight = pButton->m_bHighlight;
  1426. pButton->m_bHighlight = ((m_pButtonCaptured == pButton) ||
  1427. (!m_pButtonCaptured && pButton->m_rcButton.PtInRect(point)));
  1429. if (pButton->m_bHighlight != bHighlight)
  1430. {
  1431. _RedrawControl(FALSE);
  1432. }
  1433. }
  1434. }
  1437. LRESULT CXTPDatePickerControl::SendMessageToParent(int nMessage, NMHDR* pNMHDR)
  1438. {
  1439. if (!IsWindow(m_hWnd))
  1440. return 0;
  1442. NMHDR nmhdr;
  1443. if (pNMHDR == NULL)
  1444. pNMHDR = &nmhdr;
  1446. pNMHDR->hwndFrom = GetSafeHwnd();
  1447. pNMHDR->idFrom = GetDlgCtrlID();
  1448. pNMHDR->code = nMessage;
  1450. CWnd *pOwner = GetOwner();
  1451. LRESULT res = 0;
  1452. if (pOwner && IsWindow(pOwner->m_hWnd))
  1453. res = pOwner->SendMessage(WM_NOTIFY, pNMHDR->idFrom, (LPARAM)pNMHDR);
  1455. return res;
  1456. }
  1458. void CXTPDatePickerControl::_EndModalIfNeed()
  1459. {
  1460. BOOL bSingleDaySel = (::GetKeyState(VK_CONTROL) & 0x8000) != 0 || IsMultiSelectionMode();
  1461. if (m_bIsModal && !bSingleDaySel)
  1462. {
  1463. if (ContinueModal()) // skip if EndModalLoop has already called
  1464. {
  1465. EndModalLoop(IDOK);
  1466. }
  1467. }
  1469. }
  1471. void CXTPDatePickerControl::SetButtonsVisible(BOOL bShowToday, BOOL bShowNone)
  1472. {
  1473. m_arrButtons.Find(XTP_IDS_DATEPICKER_TODAY)->m_bVisible = bShowToday;
  1474. m_arrButtons.Find(XTP_IDS_DATEPICKER_NONE)->m_bVisible = bShowNone;
  1476. if (!m_rcControl.IsRectEmpty())
  1477. {
  1478. AdjustLayout(m_rcControl);
  1479. _RedrawControl(FALSE);
  1480. }
  1481. }
  1483. void CXTPDatePickerControl::EnsureVisible(const COleDateTime& dtDate)
  1484. {
  1485. int nYear = dtDate.GetYear();
  1486. int nMonth = dtDate.GetMonth();
  1487. // enumerate all month items in the collection
  1488. int nMonthCount = (int)m_arrMonths.GetSize();
  1489. for (int nIndex = 0; nIndex < nMonthCount; nIndex++)
  1490. {
  1491. CXTPDatePickerItemMonth* pMonth = m_arrMonths.GetAt(nIndex);
  1492. if (pMonth)
  1493. {
  1494. if (pMonth->GetMonth().GetMonth() == nMonth && pMonth->GetMonth().GetYear() == nYear)
  1495. return;
  1496. }
  1497. }
  1498. m_dtFirstMonth.SetDate(nYear, nMonth, 1);
  1499. Populate();
  1500. }
  1502. AFX_INLINE int GetEqualLeftSymbols(const CString& str1, const CString& str2)
  1503. {
  1504. int nCount = min(str1.GetLength(), str2.GetLength());
  1506. for (int i = 0; i < nCount; i++)
  1507. {
  1508. if (str1.GetAt(i) != str2.GetAt(i))
  1509. return i;
  1510. }
  1511. return nCount;
  1512. }
  1514. void CXTPDatePickerControl::InitNames()
  1515. {
  1516. // initialize month names
  1517. for (int nMonth = 0; nMonth < 12; nMonth++)
  1518. {
  1519. CString strMonth = CXTPCalendarUtils::GetLocaleString(LOCALE_SMONTHNAME1 + nMonth, 255) ;
  1521. m_arMonthNames[nMonth] = strMonth;
  1522. }
  1524. int nEqualLeftSymbols = 255, nDay;
  1526. // initialize day names
  1527. for (nDay = 0; nDay < 7; nDay++)
  1528. {
  1529. CString strDayName = CXTPCalendarUtils::GetLocaleString(LOCALE_SABBREVDAYNAME1 + nDay, 255);
  1531. int nOleDayOfWeek = (nDay + 1) % 7;
  1532. m_arDayOfWeekNames[nOleDayOfWeek] = strDayName;
  1534. if (nDay > 0 && nEqualLeftSymbols > 0)
  1535. {
  1536. nEqualLeftSymbols = min(nEqualLeftSymbols, GetEqualLeftSymbols(strDayName, m_arDayOfWeekNames[1]));
  1537. }
  1538. }
  1540. // If first symbols equal, remove them.
  1541. if (nEqualLeftSymbols > 0)
  1542. {
  1543. for (nDay = 0; nDay < 7; nDay++)
  1544. {
  1545. DELETE_S(m_arDayOfWeekNames[nDay], 0, nEqualLeftSymbols);
  1546. }
  1547. }
  1548. }
  1550. void CXTPDatePickerControl::SetShowNonMonthDays(BOOL bShow)
  1551. {
  1552. if (bShow != m_bShowNonMonthDays)
  1553. {
  1554. m_bShowNonMonthDays = bShow;
  1555. // set first month and last month defaults
  1556. int nMonthCount = (int)m_arrMonths.GetSize();
  1557. if (nMonthCount > 0)
  1558. {
  1559. CXTPDatePickerItemMonth* pFirstMonth = m_arrMonths.GetAt(0);
  1560. CXTPDatePickerItemMonth* pLastMonth = m_arrMonths.GetAt(nMonthCount - 1);
  1561. // by default set show previous days for first month and show following days for last month
  1562. pFirstMonth->SetShowDaysBefore(bShow);
  1563. pLastMonth->SetShowDaysAfter(bShow);
  1564. }
  1565. _RedrawControl(FALSE);
  1566. }
  1567. }
  1569. void CXTPDatePickerControl::AllowNoncontinuousSelection(BOOL bAllow /*= TRUE*/)
  1570. {
  1571. m_bAllowNoncontinuousSelection = bAllow;
  1572. if (!m_bAllowNoncontinuousSelection && m_pSelectedDays->GetSelectedBlocksCount() > 1)
  1573. {
  1574. m_pSelectedDays->Clear();
  1575. _RedrawControl(FALSE);
  1576. }
  1577. }
  1580. void CXTPDatePickerControl::SetMaxSelCount(int nMax)
  1581. {
  1582. m_nMaxSelectionDays = nMax;
  1583. int nCurrentSelectedDays = m_pSelectedDays->GetSelectedDaysCount();
  1585. // clear extra days
  1586. if (nCurrentSelectedDays > m_nMaxSelectionDays)
  1587. {
  1588. m_pSelectedDays->Clear();
  1589. _RedrawControl(FALSE);
  1590. }
  1591. }
  1593. BOOL CXTPDatePickerControl::GetSelRange(COleDateTime& refMinRange, COleDateTime& refMaxRange) const
  1594. {
  1595. return m_pSelectedDays->GetMinMaxRange(refMinRange, refMaxRange);
  1596. }
  1598. BOOL CXTPDatePickerControl::SetSelRange(const COleDateTime& dtMinRange, const COleDateTime& dtMaxRange)
  1599. {
  1600. ClearFocus();
  1601. m_pSelectedDays->SelectRange(dtMinRange, dtMaxRange);
  1602. m_dtFirstClicked = dtMinRange;
  1603. m_dtLastClicked = dtMaxRange;
  1605. return TRUE;
  1606. }
  1608. BOOL CXTPDatePickerControl::SizeMinReq(BOOL bRepaint /* = TRUE */)
  1609. {
  1610. CRect rect;
  1611. BOOL bRetVal = FALSE;
  1612. if (GetMinReqRect(rect))
  1613. {
  1614. DWORD dwFlags = SWP_NOZORDER | SWP_NOREPOSITION | SWP_NOMOVE | SWP_NOACTIVATE;
  1615. if (!bRepaint)
  1616. dwFlags |= SWP_NOREDRAW;
  1617. SetWindowPos(NULL, 0, 0, rect.Width(), rect.Height(), dwFlags);
  1618. bRetVal = TRUE;
  1619. }
  1621. return bRetVal;
  1622. }
  1624. BOOL CXTPDatePickerControl::GetMinReqRect(RECT* pRect) const
  1625. {
  1626. return GetMinReqRect(pRect, 1, 1);
  1627. }
  1630. BOOL CXTPDatePickerControl::GetMinReqRect(RECT* pRect, int nRows, int nCols) const
  1631. {
  1632. CWindowDC dc(GetDesktopWindow());
  1633. CSize szMonth(m_pPaintManager->CalcMonthRect(&dc));
  1635. pRect->left = pRect->top = 0;
  1636. pRect->right = szMonth.cx * nCols;
  1637. pRect->bottom = szMonth.cy * nRows;
  1639. CRect rcBorder(0, 0, 0, 0);
  1640. m_pPaintManager->DrawBorder(0, this, rcBorder, FALSE);
  1642. pRect->right += rcBorder.left - rcBorder.right;
  1643. pRect->bottom += rcBorder.top - rcBorder.bottom;
  1645. if (m_arrButtons.GetVisibleButtonCount() > 0)
  1646. {
  1647. CSize szButton(CalcButtonSize());
  1648. pRect->bottom += szButton.cy;
  1649. }
  1651. return TRUE;
  1652. }
  1654. BOOL CXTPDatePickerControl::GetCurSel(COleDateTime& refDateTime) const
  1655. {
  1656. return m_pSelectedDays->GetMinMaxRange(refDateTime, refDateTime);
  1657. }
  1659. BOOL CXTPDatePickerControl::SetCurSel(const COleDateTime& refDateTime)
  1660. {
  1661. return SetSelRange(refDateTime, refDateTime);
  1662. }
  1664. void CXTPDatePickerControl::SetToday(const COleDateTime& refDateTime)
  1665. {
  1666. m_dtToday = refDateTime;
  1667. _RedrawControl(FALSE);
  1668. }
  1670. DWORD CXTPDatePickerControl::GetRange(COleDateTime* pMinRange, COleDateTime* pMaxRange) const
  1671. {
  1672. DWORD dwRes = 0;
  1673. if (pMinRange && m_dtMinRange.GetStatus() == COleDateTime::valid)
  1674. {
  1675. *pMinRange = m_dtMinRange;
  1676. dwRes |= GDTR_MIN;
  1677. }
  1678. if (pMaxRange && m_dtMaxRange.GetStatus() == COleDateTime::valid)
  1679. {
  1680. *pMaxRange = m_dtMaxRange;
  1681. dwRes |= GDTR_MAX;
  1682. }
  1683. return dwRes;
  1684. }
  1686. BOOL CXTPDatePickerControl::SetRange(const COleDateTime* pMinRange, const COleDateTime* pMaxRange)
  1687. {
  1688. if (pMinRange)
  1689. {
  1690. m_dtMinRange = *pMinRange;
  1691. ScrollLeft(0);
  1692. }
  1693. if (pMaxRange)
  1694. {
  1695. m_dtMaxRange = *pMaxRange;
  1696. ScrollRight(0);
  1697. }
  1698. return TRUE;
  1699. }
  1701. int CXTPDatePickerControl::GetMonthRange(COleDateTime& refMinRange, COleDateTime& refMaxRange, DWORD dwFlags) const
  1702. {
  1703. refMinRange = m_dtFirstMonth;
  1704. refMaxRange = m_dtFirstMonth;
  1705. int nMonthCount = m_nRows * m_nColumns;
  1706. ShiftDate(refMaxRange, nMonthCount);
  1708. //if (GMR_DAYSTATE == dwFlags)
  1709. // do nothing
  1711. if (GMR_VISIBLE == dwFlags)
  1712. {
  1713. nMonthCount = (int)m_arrMonths.GetSize();
  1714. if (nMonthCount > 0)
  1715. {
  1716. CXTPDatePickerItemMonth* pLastMonth = m_arrMonths.GetAt(nMonthCount - 1);
  1717. if (pLastMonth)
  1718. {
  1719. CXTPDatePickerItemDay* pLastDay = pLastMonth->m_arrDays.GetAt(XTP_MAX_WEEKS * XTP_WEEK_DAYS - 1);
  1720. if (pLastDay->GetDate().GetMonth() != refMaxRange.GetMonth())
  1721. {
  1722. ShiftDate(refMaxRange, 1);
  1723. nMonthCount++;
  1724. }
  1725. }
  1727. CXTPDatePickerItemMonth* pFirstMonth = m_arrMonths.GetAt(0);
  1728. if (pFirstMonth)
  1729. {
  1730. CXTPDatePickerItemDay* pFirstDay = pFirstMonth->m_arrDays.GetAt(0);
  1731. if (pFirstDay->GetDate().GetMonth() != refMinRange.GetMonth())
  1732. {
  1733. ShiftDate(refMinRange, -1);
  1734. nMonthCount++;
  1735. }
  1736. }
  1737. }
  1738. }
  1739. return nMonthCount;
  1740. }
  1742. BOOL CXTPDatePickerControl::ShiftDate(COleDateTime &refDate, int nMonthCount)
  1743. {
  1744. int nYearNew = refDate.GetYear();
  1745. int nMonthNew = refDate.GetMonth();
  1746. int nInc = abs(nMonthCount) / nMonthCount;
  1747. for (int nItem = 0; nItem < abs(nMonthCount); nItem++)
  1748. {
  1749. nMonthNew += nInc;
  1750. if (nMonthNew < 1)
  1751. {
  1752. nMonthNew = 12;
  1753. nYearNew--;
  1754. }
  1755. if (nMonthNew > 12)
  1756. {
  1757. nMonthNew = 1;
  1758. nYearNew++;
  1759. }
  1760. }
  1761. return 0 == refDate.SetDate(nYearNew, nMonthNew, 1);
  1762. }
  1764. void XTPGetAsSystemTime(const COleDateTime& dateTime, SYSTEMTIME& st)
  1765. {
  1766. #if _MSC_VER < 1200
  1767. UNREFERENCED_PARAMETER(dateTime);
  1768. UNREFERENCED_PARAMETER(st);
  1769. ASSERT(FALSE);
  1770. #else
  1771. dateTime.GetAsSystemTime(st);
  1772. #endif
  1773. }
  1775. DWORD CXTPDatePickerControl::HitTest(PMCHITTESTINFO pMCHitTest)
  1776. {
  1777. // check structure
  1778. if (!pMCHitTest)
  1779. return 0;
  1781. ASSERT(sizeof(MCHITTESTINFO) == pMCHitTest->cbSize);
  1783. // default result
  1784. pMCHitTest->uHit = MCHT_NOWHERE;
  1786. // start checking
  1787. CPoint ptHit(pMCHitTest->pt);
  1789. CXTPDatePickerItemMonth* pHitMonth = HitTest(ptHit);
  1790. if (pHitMonth)
  1791. {
  1792. CXTPDatePickerItemDay* pHitDay = pHitMonth->HitTest(ptHit);
  1793. if (pHitDay)
  1794. {
  1795. // MCHT_CALENDARDATE
  1796. pMCHitTest->uHit = MCHT_CALENDARDATE;
  1797. XTPGetAsSystemTime(pHitDay->GetDate(), pMCHitTest->st);
  1799. // MCHT_CALENDARDATEPREV
  1800. if (pHitMonth->GetShowDaysBefore() &&
  1801. pHitMonth->GetMonth().GetMonth() < pHitDay->GetDate().GetMonth())
  1802. {
  1803. pMCHitTest->uHit = MCHT_CALENDARDATEPREV;
  1804. }
  1805. else
  1806. // MCHT_CALENDARDATENEXT
  1807. if (pHitMonth->GetShowDaysAfter() &&
  1808. pHitMonth->GetMonth().GetMonth() > pHitDay->GetDate().GetMonth())
  1809. {
  1810. pMCHitTest->uHit = MCHT_CALENDARDATENEXT;
  1811. }
  1812. }
  1813. else
  1814. {
  1815. XTPGetAsSystemTime(pHitMonth->GetMonth(), pMCHitTest->st);
  1817. // MCHT_CALENDARDAY
  1818. if (pHitMonth->m_rcDaysOfWeek.PtInRect(ptHit))
  1819. {
  1820. pMCHitTest->uHit = MCHT_CALENDARDAY;
  1821. // The SYSTEMTIME structure at lpMCHitTest>st is set to the corresponding date in the top row.
  1822. CPoint ptTopRow(ptHit.x, pHitMonth->m_rcDaysOfWeek.bottom + 1);
  1823. CXTPDatePickerItemDay* pDay = pHitMonth->HitTest(ptTopRow);
  1824. if (pDay)
  1825. {
  1826. XTPGetAsSystemTime(pDay->GetDate(), pMCHitTest->st);
  1827. }
  1828. }
  1829. else
  1830. // MCHT_CALENDARWEEKNUM
  1831. if (pHitMonth->m_rcWeekNumbers.PtInRect(ptHit))
  1832. {
  1833. pMCHitTest->uHit = MCHT_CALENDARWEEKNUM;
  1834. // The SYSTEMTIME structure at lpMCHitTest>st is set to the corresponding date in the leftmost column
  1835. CPoint ptLeftRow(pHitMonth->m_rcWeekNumbers.right + 1, ptHit.y);
  1836. CXTPDatePickerItemDay* pDay = pHitMonth->HitTest(ptLeftRow);
  1837. if (pDay)
  1838. {
  1839. XTPGetAsSystemTime(pDay->GetDate(), pMCHitTest->st);
  1840. }
  1841. }
  1842. else
  1843. // MCHT_TITLEMONTH
  1844. if (pHitMonth->m_rcHeader.PtInRect(ptHit))
  1845. {
  1846. pMCHitTest->uHit = MCHT_TITLEMONTH;
  1847. }
  1848. else
  1849. // MCHT_TITLEBTNNEXT
  1850. if (pHitMonth->GetShowRightScroll() &&
  1851. pHitMonth->m_rcRightScroll.PtInRect(ptHit))
  1852. {
  1853. pMCHitTest->uHit = MCHT_TITLEBTNNEXT;
  1854. }
  1855. else
  1856. // MCHT_TITLEBTNPREV
  1857. if (pHitMonth->GetShowLeftScroll() &&
  1858. pHitMonth->m_rcLeftScroll.PtInRect(ptHit))
  1859. {
  1860. pMCHitTest->uHit = MCHT_TITLEBTNPREV;
  1861. }
  1862. }
  1863. }
  1864. else
  1865. {
  1866. // MCHT_CALENDARBK
  1867. pMCHitTest->uHit = MCHT_CALENDARBK;
  1868. }
  1870. return pMCHitTest->uHit;
  1871. }
  1873. void CXTPDatePickerControl::SetBorderStyle(XTPDatePickerBorderStyle borderStyle)
  1874. {
  1875. m_borderStyle = borderStyle;
  1876. AdjustLayout(m_rcControl);
  1877. _RedrawControl(FALSE);
  1878. }
  1880. void CXTPDatePickerControl::SetAutoSize(BOOL bAuto)
  1881. {
  1882. m_bAutoSize = bAuto;
  1883. AdjustLayout(m_rcControl);
  1884. _RedrawControl(FALSE);
  1885. }
  1887. void CXTPDatePickerControl::OnSysColorChange()
  1888. {
  1889. m_pPaintManager->RefreshMetrics();
  1890. AdjustLayout(m_rcControl);
  1891. _RedrawControl(FALSE);
  1892. }
  1894. BOOL CXTPDatePickerControl::OnSetCursor(CWnd* pWnd, UINT nHitTest, UINT message)
  1895. {
  1896. if (nHitTest == HTCLIENT)
  1897. {
  1898. CPoint point;
  1899. ::GetCursorPos(&point);
  1900. ScreenToClient(&point);
  1901. CXTPDatePickerItemMonth* pMonth = HitTest(point);
  1902. if (pMonth)
  1903. {
  1904. BOOL bRet = pMonth->OnSetCursor(point);
  1905. if (bRet)
  1906. return bRet;
  1907. }
  1908. }
  1909. return CWnd::OnSetCursor(pWnd, nHitTest, message);
  1910. }
  1912. void CXTPDatePickerControl::OnSetFocus(CWnd* pOldWnd)
  1913. {
  1914. CWnd::OnSetFocus(pOldWnd);
  1916. RedrawControl();
  1918. #ifdef XTP_DATEPICKER_SITENOTIFY_ONFOCUS
  1919. XTP_DATEPICKER_SITENOTIFY_ONFOCUS(this, this, TRUE)
  1920. #endif
  1921. }
  1923. void CXTPDatePickerControl::OnKillFocus (CWnd* pNewWnd)
  1924. {
  1925. CWnd::OnKillFocus(pNewWnd);
  1927. RedrawControl();
  1929. #ifdef XTP_DATEPICKER_SITENOTIFY_ONFOCUS
  1930. XTP_DATEPICKER_SITENOTIFY_ONFOCUS(this, this, FALSE)
  1931. #endif
  1932. }
  1934. void CXTPDatePickerControl::OnFinalRelease()
  1935. {
  1936. CWnd::OnFinalRelease();
  1938. if (m_bDeleteOnFinalRelease)
  1939. {
  1940. CCmdTarget::OnFinalRelease();
  1941. }
  1942. }
  1944. void CXTPDatePickerControl::OnEnable(BOOL bEnable)
  1945. {
  1946. UNREFERENCED_PARAMETER(bEnable);
  1948. _RedrawControl(FALSE);
  1949. }
  1951. BOOL CXTPDatePickerControl::GetVisibleRange(COleDateTime& refFirstVisibleDay,
  1952. COleDateTime& refLastVisibleDay) const
  1953. {
  1954. int nCount = (int)m_arrMonths.GetSize();
  1955. if (!nCount || !m_arrMonths[0] || !m_arrMonths[nCount-1])
  1956. {
  1957. return FALSE;
  1958. }
  1959. if (!m_arrMonths[0]->GetDay(0))
  1960. {
  1961. ASSERT(FALSE);
  1962. return FALSE;
  1963. }
  1964. refFirstVisibleDay = m_arrMonths[0]->GetDay(0)->GetDate();
  1966. if (!m_arrMonths[0]->GetShowDaysBefore())
  1967. {
  1968. int nFirstMnDCount = m_arrMonths[0]->GetDayCount();
  1969. for (int i = 1; i < nFirstMnDCount; i++)
  1970. {
  1971. if (refFirstVisibleDay.GetMonth() == m_arrMonths[0]->GetMonth().GetMonth())
  1972. {
  1973. break;
  1974. }
  1975. refFirstVisibleDay = m_arrMonths[0]->GetDay(i)->GetDate();
  1976. }
  1977. ASSERT(refFirstVisibleDay.GetMonth() == m_arrMonths[0]->GetMonth().GetMonth());
  1978. }
  1980. int nLastMnDCount = m_arrMonths[nCount-1]->GetDayCount();
  1981. if (!nLastMnDCount || !m_arrMonths[nCount-1]->GetDay(nLastMnDCount-1))
  1982. {
  1983. ASSERT(FALSE);
  1984. return FALSE;
  1985. }
  1986. refLastVisibleDay = m_arrMonths[nCount-1]->GetDay(nLastMnDCount-1)->GetDate();
  1988. if (!m_arrMonths[nCount-1]->GetShowDaysAfter())
  1989. {
  1990. for (int i = nLastMnDCount-2; i > 0 ; i--)
  1991. {
  1992. if (refLastVisibleDay.GetMonth() == m_arrMonths[nCount-1]->GetMonth().GetMonth())
  1993. {
  1994. break;
  1995. }
  1996. refLastVisibleDay = m_arrMonths[nCount-1]->GetDay(i)->GetDate();
  1997. }
  1998. ASSERT(refLastVisibleDay.GetMonth() == m_arrMonths[nCount-1]->GetMonth().GetMonth());
  1999. }
  2001. return TRUE;
  2002. }
  2004. void CXTPDatePickerControl::EnsureVisibleSelection()
  2005. {
  2006. COleDateTime dtFirstSelDay, dtLastSelDay;
  2007. COleDateTime dtFirstVisibleDay, dtLastVisibleDay;
  2009. BOOL bRes1 = GetVisibleRange(dtFirstVisibleDay, dtLastVisibleDay);
  2010. BOOL bRes2 = GetSelRange(dtFirstSelDay, dtLastSelDay);
  2011. if (bRes1 && bRes2)
  2012. {
  2013. if (dtFirstSelDay > dtLastVisibleDay)
  2014. {
  2015. int nMonths = CXTPCalendarUtils::GetDiff_Months(dtFirstSelDay, dtLastVisibleDay);
  2016. nMonths += CXTPCalendarUtils::GetDiff_Months(dtLastSelDay, dtFirstSelDay);
  2017. nMonths = max(nMonths, 1);
  2018. ScrollRight(nMonths);
  2019. }
  2020. else if (dtLastSelDay > dtLastVisibleDay)
  2021. {
  2022. int nMonths = CXTPCalendarUtils::GetDiff_Months(dtLastSelDay, dtLastVisibleDay);
  2023. nMonths = max(nMonths, 1);
  2024. ScrollRight(nMonths);
  2025. }
  2027. //---------------------------
  2028. bRes1 = GetVisibleRange(dtFirstVisibleDay, dtLastVisibleDay);
  2029. bRes2 = GetSelRange(dtFirstSelDay, dtLastSelDay);
  2030. if (bRes1 && bRes2)
  2031. {
  2032. if (dtFirstSelDay < dtFirstVisibleDay || dtLastSelDay > dtLastVisibleDay)
  2033. {
  2034. EnsureVisible(dtLastSelDay);
  2035. EnsureVisible(dtFirstSelDay);
  2036. }
  2037. }
  2038. }
  2039. }
  2041. void CXTPDatePickerControl::SetLayoutRTL(BOOL bRightToLeft)
  2042. {
  2043. if (!XTPSystemVersion()->IsLayoutRTLSupported())
  2044. return;
  2046. m_bRightToLeft = bRightToLeft;
  2048. if (!m_hWnd)
  2049. return;
  2051. ModifyStyleEx(bRightToLeft ? 0 : WS_EX_LAYOUTRTL, !bRightToLeft ? 0 : WS_EX_LAYOUTRTL);
  2052. RedrawControl();
  2053. }
  2057. void CXTPDatePickerControl::EnsureVisibleFocus()
  2058. {
  2059. if (m_dtFocused.GetStatus() != COleDateTime::valid)
  2060. {
  2061. return;
  2062. }
  2063. COleDateTime dtFirstVisibleDay, dtLastVisibleDay;
  2065. BOOL bRes1 = GetVisibleRange(dtFirstVisibleDay, dtLastVisibleDay);
  2066. if (bRes1)
  2067. {
  2068. if (m_dtFocused > dtLastVisibleDay)
  2069. {
  2070. int nMonths = CXTPCalendarUtils::GetDiff_Months(m_dtFocused, dtLastVisibleDay);
  2071. nMonths = max(nMonths, 1);
  2072. ScrollRight(nMonths);
  2073. }
  2075. //---------------------------
  2076. bRes1 = GetVisibleRange(dtFirstVisibleDay, dtLastVisibleDay);
  2077. if (bRes1)
  2078. {
  2079. if (m_dtFocused < dtFirstVisibleDay || m_dtFocused > dtLastVisibleDay)
  2080. {
  2081. EnsureVisible(m_dtFocused);
  2082. }
  2083. }
  2084. }
  2085. }
  2087. XTPCalendarTheme CXTPDatePickerControl::GetPaintTheme() const
  2088. {
  2089. if (m_pPaintManager)
  2090. return m_pPaintManager->GetPaintTheme();
  2092. return xtpCalendarThemeUnknown;
  2093. }
  2095. void CXTPDatePickerControl::SetPaintTheme(XTPCalendarTheme ePaintTheme)
  2096. {
  2097. if (ePaintTheme == xtpCalendarThemeOffice2007)
  2098. {
  2099. SetTheme(new CXTPDatePickerThemeOffice2007());
  2100. }
  2101. else
  2102. {
  2103. SetTheme(NULL);
  2104. if (m_pPaintManager)
  2105. m_pPaintManager->SetPaintTheme(ePaintTheme);
  2106. }
  2107. }
  2109. /////////////////////////////////////////////////////////////////////////////
  2110. //class CXTPSelectionHelper
  2111. CXTPDatePickerControl::CXTPSelectionHelper::CXTPSelectionHelper(CXTPDatePickerControl* pControl)
  2112. {
  2113. ASSERT(pControl);
  2114. m_pDP = pControl;
  2115. }
  2117. void CXTPDatePickerControl::CXTPSelectionHelper::InitFocusIfNeed()
  2118. {
  2119. if (m_pDP->m_dtFocused.GetStatus() != COleDateTime::valid)
  2120. {
  2121. COleDateTime dtSel0, dtSel1;
  2122. BOOL bSelExists = m_pDP->GetSelectedDays()->GetMinMaxRange(dtSel0, dtSel1);
  2123. if (!bSelExists)
  2124. {
  2125. dtSel0.SetDate(m_pDP->m_dtFirstMonth.GetYear(), m_pDP->m_dtFirstMonth.GetMonth(), 1);
  2126. }
  2127. m_pDP->m_dtFocused = dtSel0;
  2129. if (m_pDP->m_dtFirstClicked.GetStatus() == COleDateTime::valid &&
  2130. m_pDP->m_dtFirstClicked >= dtSel0 && m_pDP->m_dtFirstClicked <= dtSel1)
  2131. {
  2132. m_pDP->m_dtFSelBase = m_pDP->m_dtFirstClicked;
  2133. }
  2134. else
  2135. {
  2136. m_pDP->m_dtFSelBase = dtSel0;
  2137. }
  2138. }
  2139. }
  2141. void CXTPDatePickerControl::CXTPSelectionHelper::RemoveFocus()
  2142. {
  2143. m_pDP->m_dtFocused.SetStatus(COleDateTime::null);
  2144. m_pDP->m_dtFSelBase.SetStatus(COleDateTime::null);
  2145. }
  2148. void CXTPDatePickerControl::CXTPSelectionHelper::_TmpSaveFocus()
  2149. {
  2150. m_dtFocusedTmp = m_pDP->m_dtFocused;
  2151. m_dtFSelBaseTmp = m_pDP->m_dtFSelBase;
  2152. }
  2154. void CXTPDatePickerControl::CXTPSelectionHelper::_TmpRestoreFocus()
  2155. {
  2156. m_pDP->m_dtFocused = m_dtFocusedTmp;
  2157. m_pDP->m_dtFSelBase = m_dtFSelBaseTmp;
  2158. }
  2160. void CXTPDatePickerControl::CXTPSelectionHelper::MoveFocus(int eStep, int eDirection,
  2161. BOOL bContinuouse, BOOL bSaveSel)
  2162. {
  2163. ASSERT(eDirection == 1 || eDirection == -1);
  2164. if (bContinuouse)
  2165. {
  2166. bSaveSel = FALSE;
  2167. }
  2169. InitFocusIfNeed();
  2171. _MoveFocus(eStep, eDirection);
  2173. if (bContinuouse)
  2174. {
  2175. COleDateTime dtSel0 = m_pDP->m_dtFocused;
  2176. COleDateTime dtSel1 = m_pDP->m_dtFSelBase;
  2178. BOOL bBackSel = dtSel0 > dtSel1;
  2180. if (bBackSel)
  2181. {
  2182. dtSel1 = m_pDP->m_dtFocused;
  2183. dtSel0 = m_pDP->m_dtFSelBase;
  2184. }
  2186. int nDays = (int)dtSel1 - (int)dtSel0;
  2187. int nMaxSel = m_pDP->GetMaxSelCount();
  2188. if (nMaxSel == XTP_SELECTION_INFINITE)
  2189. {
  2190. nMaxSel = INT_MAX;
  2191. }
  2193. if (nDays > nMaxSel)
  2194. {
  2195. if (bBackSel)
  2196. {
  2197. dtSel1 = (double)dtSel0 + nMaxSel;
  2198. }
  2199. else
  2200. {
  2201. dtSel0 = (double)dtSel1 - nMaxSel;
  2202. }
  2203. }
  2205. m_pDP->GetSelectedDays()->Clear();
  2206. m_pDP->GetSelectedDays()->SelectRange(dtSel0, dtSel1);
  2207. }
  2208. else
  2209. {
  2210. //int nSelDays = m_pDP->GetSelectedDays()->GetSelectedDaysCount();
  2212. if (!bSaveSel)
  2213. {
  2214. m_pDP->GetSelectedDays()->Clear();
  2215. }
  2217. if (!bSaveSel /*|| nSelDays == 0*/)
  2218. {
  2219. m_pDP->GetSelectedDays()->Add(m_pDP->m_dtFocused);
  2220. }
  2222. m_pDP->m_dtFSelBase = m_pDP->m_dtFocused;
  2223. }
  2224. }
  2226. void CXTPDatePickerControl::CXTPSelectionHelper::SelUnselFocus()
  2227. {
  2228. InitFocusIfNeed();
  2230. BOOL bSelected = m_pDP->GetSelectedDays()->Contains(m_pDP->m_dtFocused);
  2232. if (bSelected)
  2233. {
  2234. m_pDP->GetSelectedDays()->Remove(m_pDP->m_dtFocused);
  2235. }
  2236. else
  2237. {
  2238. int nSelDays = m_pDP->GetSelectedDays()->GetSelectedDaysCount();
  2239. int nMaxSel = m_pDP->GetMaxSelCount();
  2240. if (nMaxSel == XTP_SELECTION_INFINITE)
  2241. {
  2242. nMaxSel = INT_MAX;
  2243. }
  2245. if (nSelDays < nMaxSel)
  2246. {
  2247. m_pDP->GetSelectedDays()->Add(m_pDP->m_dtFocused);
  2248. }
  2249. }
  2250. }
  2252. void CXTPDatePickerControl::CXTPSelectionHelper::_MoveFocus(int eStep, int eDirection)
  2253. {
  2254. ASSERT(eDirection == 1 || eDirection == -1);
  2256. InitFocusIfNeed();
  2258. COleDateTime dtNew = m_pDP->m_dtFocused;
  2260. if (eStep == stepDay || eStep == stepWeek)
  2261. {
  2262. dtNew = (double)dtNew + eDirection * (eStep == stepDay ? 1 : 7);
  2263. }
  2264. else if (eStep == stepMonth || eStep == stepYear)
  2265. {
  2266. int nMonths = eDirection * (eStep == stepMonth ? 1 : 12);
  2267. CXTPCalendarUtils::ShiftDate_Month(dtNew, nMonths, dtNew.GetDay());
  2268. }
  2269. else if (eStep == stepWeekBE)
  2270. {
  2271. int nFWD = m_pDP->GetFirstDayOfWeek();
  2273. int nShift = -1 * ((dtNew.GetDayOfWeek() - nFWD + 7) % 7);
  2275. if (eDirection == dirNext)
  2276. {
  2277. nShift += 6;
  2278. }
  2280. dtNew = (double)dtNew + nShift;
  2281. }
  2282. else if (eStep == stepMonthBE)
  2283. {
  2284. CXTPCalendarUtils::UpdateMonthDay(dtNew, eDirection == dirPrev ? 1 : 31);
  2285. }
  2286. else
  2287. {
  2288. ASSERT(FALSE);
  2289. }
  2291. m_pDP->m_dtFocused = dtNew;
  2292. }