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

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

对话框与窗口

开发平台：

Visual C++

XTPCalendarController.cpp：源码内容
  1. // XTPCalendarController.cpp : implementation file
  2. //
  3. // This file is a part of the XTREME CALENDAR MFC class library.
  4. // (c)1998-2008 Codejock Software, All Rights Reserved.
  5. //
  6. // THIS SOURCE FILE IS THE PROPERTY OF CODEJOCK SOFTWARE AND IS NOT TO BE
  7. // RE-DISTRIBUTED BY ANY MEANS WHATSOEVER WITHOUT THE EXPRESSED WRITTEN
  8. // CONSENT OF CODEJOCK SOFTWARE.
  9. //
  10. // THIS SOURCE CODE CAN ONLY BE USED UNDER THE TERMS AND CONDITIONS OUTLINED
  11. // IN THE XTREME TOOLKIT PRO LICENSE AGREEMENT. CODEJOCK SOFTWARE GRANTS TO
  12. // YOU (ONE SOFTWARE DEVELOPER) THE LIMITED RIGHT TO USE THIS SOFTWARE ON A
  13. // SINGLE COMPUTER.
  14. //
  15. // CONTACT INFORMATION:
  16. // support@codejock.com
  17. // http://www.codejock.com
  18. //
  19. /////////////////////////////////////////////////////////////////////////////
  21. #include "stdafx.h"
  23. #include "Common/XTPVC50Helpers.h"
  24. #include "Common/XTPMacros.h"
  26. #include "Common/XTPNotifyConnection.h"
  28. #include "XTPCalendarControl.h"
  29. #include "XTPCalendarView.h"
  30. #include "XTPCalendarWeekView.h"
  31. #include "XTPCalendarMonthView.h"
  32. #include "XTPCalendarDayView.h"
  33. #include "XTPCalendarData.h"
  34. #include "XTPCalendarResource.h"
  35. #include "XTPCalendarNotifications.h"
  37. #include "XTPDatePickerItemMonth.h"
  38. #include "XTPDatePickerItemDay.h"
  39. #include "XTPDatePickerControl.h"
  40. #include "XTPDatePickerPaintManager.h"
  41. #include "XTPDatePickerNotifications.h"
  43. #include "XTPCalendarController.h"
  45. #ifdef _DEBUG
  46. #define new DEBUG_NEW
  47. #undef THIS_FILE
  48. static char THIS_FILE[] = __FILE__;
  49. #endif
  51. // DBG
  52. #define DBG_TRACE_DP_NF
  53. #define DBG_TRACE_DP_TIMER
  55. //#define DBG_TRACE_DP_NF  TRACE
  56. //#define DBG_TRACE_DP_TIMER     TRACE
  57. // DBG
  59. /////////////////////////////////////////////////////////////////////////////
  60. #define XTP_CC_DONT_SCROLL_DP 1234567890
  62. #define XTP_CC_REFRESH_DAYS_STEP_TIMER_MS 120
  63. #define XTP_CC_REFRESH_DAYS_STEP_DAYS     3
  65. /////////////////////////////////////////////////////////////////////////////
  66. // CXTPCalendarController
  68. const int nXTPMaxDayViewDays = 6;
  70. ////////////////////////////////////////////////////////////////////////////
  71. CXTPCalendarController::CXTPDayInfoCache::CXTPMapTimers CXTPCalendarController::CXTPDayInfoCache::m_mapTimers;
  73. IMPLEMENT_DYNCREATE(CXTPCalendarController, CCmdTarget)
  74. //////////////////////////////////////////////////////////////////////////
  75. CXTPCalendarController::CXTPDayInfoCache::CXTPDayInfoCache()
  76. {
  77. // 37, 53, 79 , 101, 127, 199, 503, 1021, 1511, 2003, 3001, 4001, 5003, 6007, 8009, 12007, 16001
  78. m_mapDaysInfo.InitHashTable(503, FALSE);
  79. m_mapDaysToRefresh.InitHashTable(503, FALSE);
  81. m_pOwner = NULL;
  83. m_uTimerID = 0;
  84. m_dwLastRedrawTime = 0;
  85. m_dwLastSelfClearTime = 0;
  86. m_dwWaitingDataTime = 0;
  88. m_uActivePriority = 1;
  89. }
  91. CXTPCalendarController::CXTPDayInfoCache::~CXTPDayInfoCache()
  92. {
  93. KillTimer();
  94. }
  96. void CXTPCalendarController::CXTPDayInfoCache::KillTimer()
  97. {
  98. if (m_uTimerID)
  99. {
  100. ::KillTimer(NULL, m_uTimerID);
  101. m_mapTimers.RemoveKey(m_uTimerID);
  102. m_uTimerID = 0;
  103. }
  104. }
  106. BOOL CXTPCalendarController::CXTPDayInfoCache::HasEvents(DATE dtDay)
  107. {
  108. XTPDayInfo tmpDI;
  109. if (m_mapDaysInfo.Lookup((long)dtDay, tmpDI))
  110. {
  111. UpdateDayInfo(dtDay, tmpDI.bHasEvents);
  112. return tmpDI.bHasEvents;
  113. }
  114. else
  115. {
  116. _RequestToRefreshDays(dtDay, dtDay, m_uActivePriority);
  117. }
  118. return FALSE;
  119. }
  121. void CXTPCalendarController::CXTPDayInfoCache::Init(CXTPCalendarController* pOwner)
  122. {
  123. ASSERT(pOwner);
  124. m_pOwner = pOwner;
  125. }
  127. void CXTPCalendarController::CXTPDayInfoCache::Clear()
  128. {
  129. m_mapDaysInfo.RemoveAll();
  130. m_mapDaysToRefresh.RemoveAll();
  131. m_uActivePriority = 1;
  133. DBG_TRACE_DP_TIMER(_T("XTPCalendarController::DayInfoCache - CLEAR n"));
  134. }
  136. UINT CXTPCalendarController::CXTPDayInfoCache::UpActivePriority()
  137. {
  138. return ++m_uActivePriority;
  139. }
  141. void CXTPCalendarController::CXTPDayInfoCache::UpdateDayInfo(DATE dtDay, BOOL bHasEvents)
  142. {
  143. XTPDayInfo tmpDI = {bHasEvents, (DATE)CXTPCalendarUtils::GetCurrentTime()};
  144. m_mapDaysInfo[(long)dtDay] = tmpDI;
  145. }
  147. void CXTPCalendarController::CXTPDayInfoCache::ClearDays(COleDateTime dtDayFrom, COleDateTime dtDayTo)
  148. {
  149. long nDay = min((long)dtDayFrom, (long)dtDayTo);
  150. long nDay2 = max((long)dtDayFrom, (long)dtDayTo);
  151. for (; nDay <= nDay2; nDay++)
  152. {
  153. m_mapDaysInfo.RemoveKey(nDay);
  154. }
  156. DBG_TRACE_DP_TIMER(_T("XTPCalendarController::DayInfoCache - Clear days (%s - %s) n"), (LPCTSTR)dtDayFrom.Format(), (LPCTSTR)dtDayTo.Format());
  157. }
  159. void CXTPCalendarController::CXTPDayInfoCache::RequestToRefreshDays(COleDateTime dtDayFrom, COleDateTime dtDayTo)
  160. {
  161. m_uActivePriority++;
  163. DBG_TRACE_DP_TIMER(_T("XTPCalendarController::DayInfoCache - RequestToRefreshDays (%s - %s). ActivePriority = %d n"),
  164.    (LPCTSTR)dtDayFrom.Format(), (LPCTSTR)dtDayTo.Format(), m_uActivePriority);
  166. _RequestToRefreshDays(dtDayFrom, dtDayTo, m_uActivePriority);
  167. }
  169. void CXTPCalendarController::CXTPDayInfoCache::_RequestToRefreshDays(COleDateTime dtDayFrom, COleDateTime dtDayTo, UINT uPriority)
  170. {
  171. ASSERT(m_pOwner);
  172. if (!m_pOwner)
  173. {
  174. return;
  175. }
  177. long nDay = min((long)dtDayFrom, (long)dtDayTo);
  178. long nDay2 = max((long)dtDayFrom, (long)dtDayTo);
  180. // WARNING! - Ooo... The days range is too large!
  181. ASSERT(nDay2 - nDay < 10*1000);
  183. for (; nDay <= nDay2; nDay++)
  184. {
  185. m_mapDaysToRefresh[nDay] = uPriority;
  186. }
  188. if (m_mapDaysToRefresh.GetCount() && m_uTimerID == 0)
  189. {
  190. UINT uTimeOut = (UINT)m_pOwner->m_nBoldDaysIdleStepTime_ms;
  192. m_uTimerID = ::SetTimer(NULL, 0, uTimeOut, OnTimerCallback);
  193. m_mapTimers[m_uTimerID] = this;
  195. DBG_TRACE_DP_TIMER(_T("XTPCalendarController::DayInfoCache - _RequestToRefreshDays, SetTimer (ID = %d) n"), m_uTimerID);
  196. }
  197. }
  199. void CXTPCalendarController::CXTPDayInfoCache::OnRefreshDays(int nDaysCountToRefresh)
  200. {
  201. ASSERT(m_pOwner);
  203. if (!XTP_SAFE_GET1(m_pOwner, m_pResourcesNf, NULL))
  204. {
  205. if (!m_dwWaitingDataTime)
  206. {
  207. m_dwWaitingDataTime = GetTickCount();
  208. DBG_TRACE_DP_TIMER(_T("XTPCalendarController::DayInfoCache - OnRefreshDays, Start Wait for datan"));
  209. }
  211. if (abs((long)(GetTickCount() - m_dwWaitingDataTime)) >= 5000)
  212. {
  213. m_dwWaitingDataTime = 0;
  215. if (m_uTimerID)
  216. {
  217. DBG_TRACE_DP_TIMER(_T("XTPCalendarController::DayInfoCache - OnRefreshDays, KillTimer (ID = %d) n"), m_uTimerID);
  218. DBG_TRACE_DP_TIMER(_T("XTPCalendarController::DayInfoCache - OnRefreshDays, end Wait for datan"));
  220. KillTimer();
  222. OnSelfClearOld();
  223. }
  224. }
  225. return;
  226. }
  227. else
  228. {
  229. if (m_dwWaitingDataTime)
  230. {
  231. DBG_TRACE_DP_TIMER(_T("XTPCalendarController::DayInfoCache - OnRefreshDays, end Wait for datan"));
  232. }
  233. m_dwWaitingDataTime = 0;
  234. }
  236. //***************************************************
  237. for (int i = 0; i < nDaysCountToRefresh; i++)
  238. {
  239. long nDay_min = LONG_MAX;
  240. UINT uPriority_max = 0;
  242. POSITION pos = m_mapDaysToRefresh.GetStartPosition();
  243. while (pos)
  244. {
  245. long nDay = 0;
  246. UINT uPriority = 0;
  247. m_mapDaysToRefresh.GetNextAssoc(pos, nDay, uPriority);
  249. if (uPriority == uPriority_max && nDay < nDay_min ||
  250. uPriority > uPriority_max)
  251. {
  252. uPriority_max = uPriority;
  253. nDay_min = nDay;
  254. }
  255. }
  257. if (nDay_min < LONG_MAX)
  258. {
  259. m_mapDaysToRefresh.RemoveKey(nDay_min);
  261. COleDateTime dtDay((DATE)nDay_min);
  262. BOOL bHasEvents = XTP_SAFE_GET1(m_pOwner, _HasEvents(dtDay), FALSE);
  264. UpdateDayInfo(dtDay, bHasEvents);
  265. }
  266. }
  267. //***************************************************
  269. if (m_mapDaysToRefresh.GetCount() == 0 && m_uTimerID)
  270. {
  271. DBG_TRACE_DP_TIMER(_T("XTPCalendarController::DayInfoCache - OnRefreshDays, KillTimer (ID = %d) n"), m_uTimerID);
  272. DBG_TRACE_DP_TIMER(_T("XTPCalendarController::DayInfoCache - Days In Cache %d n"), m_mapDaysInfo.GetCount());
  274. KillTimer();
  276. OnSelfClearOld();
  277. }
  279. if (abs((long)(GetTickCount() - m_dwLastRedrawTime)) >= 500 || m_uTimerID == 0)
  280. {
  281. XTP_SAFE_CALL2(m_pOwner, m_pDatePickerCtrl, RedrawControl());
  282. m_dwLastRedrawTime = GetTickCount();
  283. }
  284. }
  285. void CXTPCalendarController::CXTPDayInfoCache::OnSelfClearOld()
  286. {
  288. #ifdef _DEBUG
  289. int nUpdateTime_ms = 20 * 1000;
  290. COleDateTimeSpan spCachePeriod(0, 0, 1, 0); // 1 min
  291. #else
  292. int nUpdateTime_ms = 5 * 60 * 1000; // 5 min
  293. COleDateTimeSpan spCachePeriod(0, 1, 0, 0); // 1 hour
  294. #endif
  296. if (abs((long)(GetTickCount() - m_dwLastSelfClearTime)) < nUpdateTime_ms)
  297. {
  298. return;
  299. }
  300. m_dwLastSelfClearTime = ::GetTickCount();
  302. COleDateTime dtOldTime = CXTPCalendarUtils::GetCurrentTime();
  303. dtOldTime -= spCachePeriod;
  305. DBG_TRACE_DP_TIMER(_T("XTPCalendarController::DayInfoCache - OnSelfClear, Start. Days In Cache %d n"), m_mapDaysInfo.GetCount());
  307. POSITION pos = m_mapDaysInfo.GetStartPosition();
  308. while (pos)
  309. {
  310. long nDay = 0;
  311. XTPDayInfo tmpDI;
  313. m_mapDaysInfo.GetNextAssoc(pos, nDay, tmpDI);
  314. if (tmpDI.dtLastAccessTime < dtOldTime)
  315. {
  316. m_mapDaysInfo.RemoveKey(nDay);
  317. }
  318. }
  320. DBG_TRACE_DP_TIMER(_T("XTPCalendarController::DayInfoCache - OnSelfClear, End. Days In Cache %d n"), m_mapDaysInfo.GetCount());
  321. }
  323. VOID CALLBACK CXTPCalendarController::CXTPDayInfoCache::OnTimerCallback(HWND hwnd, UINT uMsg, UINT_PTR idEvent, DWORD dwTime)
  324. {
  325. UNREFERENCED_PARAMETER(hwnd);
  326. UNREFERENCED_PARAMETER(uMsg);
  327. UNREFERENCED_PARAMETER(dwTime);
  329.  CXTPDayInfoCache* pThis = m_mapTimers[idEvent];
  330.  ASSERT(pThis && pThis->m_pOwner);
  332.  if (pThis && pThis->m_pOwner)
  333.  {
  334. //***********************
  335. SAFE_MANAGE_STATE(pThis->m_pOwner->m_pModuleState);
  336. //***********************
  338.  pThis->OnRefreshDays(pThis->m_pOwner->m_nBoldDaysPerIdleStep);
  339.  }
  340. }
  343. //////////////////////////////////////////////////////////////////////////
  345. CXTPCalendarController::CXTPCalendarController()
  346. {
  347. m_pCalendarCtrl = NULL;
  348. m_pDatePickerCtrl = NULL;
  349. m_bAdjustingView = FALSE;
  351. m_bBoldDaysWithEvents = TRUE;
  353. m_bBoldDaysOnIdle = TRUE;
  354. m_nBoldDaysPerIdleStep = XTP_CC_REFRESH_DAYS_STEP_DAYS;
  355. m_nBoldDaysIdleStepTime_ms = XTP_CC_REFRESH_DAYS_STEP_TIMER_MS;
  357. m_bUseActiveViewResoucesForBold = FALSE;
  359. m_pResourcesNf = NULL;
  360. m_eLastActiveView = -1;
  362. m_cnidEventAdded = 0;
  363. m_cnidEventChanged = 0;
  364. m_cnidEventDeleted = 0;
  366. m_DayInfoCache.Init(this);
  367. }
  369. CXTPCalendarController::~CXTPCalendarController()
  370. {
  371. CMDTARGET_RELEASE(m_pCalendarCtrl);
  372. CMDTARGET_RELEASE(m_pDatePickerCtrl);
  373. CMDTARGET_RELEASE(m_pResourcesNf);
  374. }
  377. /////////////////////////////////////////////////////////////////////////////
  378. // CXTPCalendarController message handlers
  380. void CXTPCalendarController::AdviseToNotifications()
  381. {
  382. m_Sink.UnadviseAll();
  384. m_cnidEventAdded = 0;
  385. m_cnidEventChanged = 0;
  386. m_cnidEventDeleted = 0;
  388. CMDTARGET_RELEASE(m_pResourcesNf);
  390. // Advise to Calendar notifications
  391. if (m_pCalendarCtrl)
  392. {
  393. CXTPNotifyConnection* ptrDPConn = m_pCalendarCtrl ? m_pCalendarCtrl->GetConnection() : NULL;
  394. ASSERT(ptrDPConn);
  396. if (!ptrDPConn)
  397. {
  398. return;
  399. }
  401. m_Sink.Advise(ptrDPConn, XTP_NC_CALENDARVIEWWASCHANGED, &CXTPCalendarController::OnEvent_CalendarView);
  402. m_Sink.Advise(ptrDPConn, XTP_NC_CALENDAROPTIONSWASCHANGED, &CXTPCalendarController::OnEvent_CalendarOptionsChanged);
  403. m_Sink.Advise(ptrDPConn, XTP_NC_CALENDAR_RESOURCES_WHERE_CHANGED, &CXTPCalendarController::OnEvent_CalendarResourcesChanged);
  404. m_Sink.Advise(ptrDPConn, XTP_NC_CALENDAR_THEME_CHANGED, &CXTPCalendarController::OnEvent_CalendarThemeChanged);
  405. }
  407. // Advise to Date Picker notifications
  408. if (m_pDatePickerCtrl)
  409. {
  410. CXTPNotifyConnection* ptrDPConn = m_pDatePickerCtrl ? m_pDatePickerCtrl->GetConnection() : NULL;
  411. ASSERT(ptrDPConn);
  413. if (!ptrDPConn)
  414. {
  415. return;
  416. }
  418. m_Sink.Advise(ptrDPConn, XTP_NC_DATEPICKERBUTTONCLICKED, &CXTPCalendarController::OnEvent_DatePicker);
  419. m_Sink.Advise(ptrDPConn, XTP_NC_DATEPICKERSELECTIONCHANGED, &CXTPCalendarController::OnEvent_DatePicker);
  420. m_Sink.Advise(ptrDPConn, XTP_NC_DATEPICKERBEFOREGOMODAL, &CXTPCalendarController::OnEvent_DatePicker);
  421. m_Sink.Advise(ptrDPConn, XTP_NC_DATEPICKERMONTHCHANGED, &CXTPCalendarController::OnEvent_DatePicker);
  422. m_Sink.Advise(ptrDPConn, XTP_NC_DATEPICKERGETDAYMETRICS, &CXTPCalendarController::OnEvent_DtPickGetItemMetrics);
  423. }
  424. }
  426. void CXTPCalendarController::_AdviseToDataChanged()
  427. {
  428. ASSERT(m_pResourcesNf);
  429. if (!m_pResourcesNf)
  430. {
  431. return;
  432. }
  434. CXTPNotifyConnection* ptrDPConn = m_pResourcesNf->GetConnection();
  435. ASSERT(ptrDPConn);
  437. if (!ptrDPConn)
  438. {
  439. return;
  440. }
  442. m_cnidEventAdded = m_Sink.Advise(ptrDPConn, XTP_NC_CALENDAREVENTWASADDED, &CXTPCalendarController::OnEvent_CalendarDataChanged);
  443. m_cnidEventChanged = m_Sink.Advise(ptrDPConn, XTP_NC_CALENDAREVENTWASCHANGED, &CXTPCalendarController::OnEvent_CalendarDataChanged);
  444. m_cnidEventDeleted = m_Sink.Advise(ptrDPConn, XTP_NC_CALENDAREVENTWASDELETED, &CXTPCalendarController::OnEvent_CalendarDataChanged);
  445. }
  447. void CXTPCalendarController::_UnadviseFromDataChanged()
  448. {
  449. if (m_cnidEventAdded)
  450. {
  451. m_Sink.Unadvise(m_cnidEventAdded);
  452. }
  454. if (m_cnidEventChanged)
  455. {
  456. m_Sink.Unadvise(m_cnidEventChanged);
  457. }
  459. if (m_cnidEventDeleted)
  460. {
  461. m_Sink.Unadvise(m_cnidEventDeleted);
  462. }
  464. m_cnidEventAdded = 0;
  465. m_cnidEventChanged = 0;
  466. m_cnidEventDeleted = 0;
  467. }
  469. BOOL CXTPCalendarController::IsFirstDayOfWeekShifted_FromSun2Mon()
  470. {
  471. if (!m_pCalendarCtrl || !m_pCalendarCtrl->GetActiveView())
  472. {
  473. return FALSE;
  474. }
  476. int nViewType = m_pCalendarCtrl->GetActiveView()->GetViewType();
  477. if (nViewType == xtpCalendarMonthView || nViewType == xtpCalendarWeekView)
  478. {
  479. int nFirstDayOfWeekIndex = m_pCalendarCtrl->GetFirstDayOfWeek();
  481. int bCompress = (nViewType == xtpCalendarWeekView) ||
  482. m_pCalendarCtrl->MonthView_IsCompressWeekendDays();
  484. if (bCompress && nFirstDayOfWeekIndex == 1)
  485. {
  486. return TRUE;
  487. }
  488. }
  489. return FALSE;
  490. }
  492. void CXTPCalendarController::OnEvent_CalendarView(XTP_NOTIFY_CODE Event, WPARAM /*wParam*/, LPARAM lParam)
  493. {
  494. if (!XTP_NC_CALENDARVIEWWASCHANGED == Event)
  495. {
  496. ASSERT(FALSE);
  497. return;
  498. }
  499. if (m_bAdjustingView)
  500. {
  501. return;
  502. }
  504. if (m_pDatePickerCtrl && m_pCalendarCtrl)
  505. {
  506. CXTPCalendarView* pView = m_pCalendarCtrl->GetActiveView();
  507. if (!pView)
  508. return;
  510. //--------------------------------------------------------
  511. int nViewTypeX = pView->GetViewType();
  512. if (nViewTypeX == xtpCalendarWorkWeekView)
  513. {
  514. nViewTypeX = xtpCalendarDayView;
  515. }
  517. if (m_eLastActiveView != nViewTypeX)
  518. {
  519. m_eLastActiveView = nViewTypeX;
  520. CMDTARGET_RELEASE(m_pResourcesNf);
  521. _UnadviseFromDataChanged();
  523. if (m_bBoldDaysOnIdle)
  524. {
  525. COleDateTime dtFirstVisibleDay, dtLastVisibleDay;
  526. if (m_pDatePickerCtrl->GetVisibleRange(dtFirstVisibleDay, dtLastVisibleDay))
  527. {
  528. m_DayInfoCache.RequestToRefreshDays(dtFirstVisibleDay, dtLastVisibleDay);
  529. }
  530. }
  531. }
  533. //--------------------------------------------------------
  534. COleDateTimeSpan spCompressCorrector(0 , 0, 0, 0);
  535. if (IsFirstDayOfWeekShifted_FromSun2Mon())
  536. {
  537. spCompressCorrector.SetDateTimeSpan(-1, 0, 0, 0);
  538. }
  540. int nCount = pView->GetViewDayCount();
  541. if (nCount > 0)
  542. {
  543. COleDateTime dtDay = m_pCalendarCtrl->GetActiveView()->GetViewDayDate(0);
  544. dtDay += spCompressCorrector;
  546. m_pDatePickerCtrl->SetSelRange(dtDay, dtDay);
  547. }
  549. for (int i = 1; i < nCount; i++)
  550. {
  551. COleDateTime dtDay = m_pCalendarCtrl->GetActiveView()->GetViewDayDate(i);
  552. dtDay += spCompressCorrector;
  553. m_pDatePickerCtrl->Select(dtDay);
  554. }
  556. if (lParam != XTP_CC_DONT_SCROLL_DP)
  557. m_pDatePickerCtrl->EnsureVisibleSelection();
  559. if (::IsWindow(m_pDatePickerCtrl->GetSafeHwnd()))
  560. {
  561. m_pDatePickerCtrl->RedrawControl();
  562. m_pDatePickerCtrl->UpdateWindow();
  563. }
  564. }
  565. }
  567. void CXTPCalendarController::OnEvent_DatePicker(XTP_NOTIFY_CODE Event, WPARAM wParam, LPARAM /*lParam*/)
  568. {
  569. wParam;
  571. switch (Event)
  572. {
  573. case XTP_NC_DATEPICKERBEFOREGOMODAL:
  574. if (m_pDatePickerCtrl && m_pCalendarCtrl)
  575. {
  576. OnEvent_CalendarView(XTP_NC_CALENDARVIEWWASCHANGED, 0, 0);
  577. }
  578. break;
  579. case XTP_NC_DATEPICKERBUTTONCLICKED:
  580. DBG_TRACE_DP_NF(_T("OnEvent: DatePickerButtonClicked - ID = %u.     {CalendarController}. n"), wParam);
  581. break;
  582. case XTP_NC_DATEPICKERMONTHCHANGED:
  583. m_DayInfoCache.UpActivePriority();
  584. break;
  585. case XTP_NC_DATEPICKERSELECTIONCHANGED:
  586. DBG_TRACE_DP_NF(_T("OnEvent: XTP_NC_DATEPICKERSELECTIONCHANGED.     {CalendarController}. n"));
  587. if (m_pDatePickerCtrl && m_pCalendarCtrl && m_pCalendarCtrl->GetActiveView())
  588. {
  589. BOOL bChanged = FALSE;
  591. COleDateTime dtFrom;
  592. COleDateTime dtTo;
  593. if (m_pDatePickerCtrl->GetSelRange(dtFrom, dtTo))
  594. {
  595. int nFirstDayOfWeekIndex = m_pDatePickerCtrl->GetFirstDayOfWeek();
  597. CXTPCalendarControl::CUpdateContext updateContext(m_pCalendarCtrl);
  599. int nSelRangeDays = GETTOTAL_DAYS_DTS(dtTo - dtFrom)+1;
  600. // count selected days
  601. int nSelDays = 0;
  602. COleDateTimeSpan spDay(1, 0, 0, 0);
  603. for (COleDateTime dtDay = dtFrom; dtDay <= dtTo; dtDay += spDay)
  604. {
  605. if (m_pDatePickerCtrl->IsSelected(dtDay))
  606. {
  607. nSelDays++;
  608. }
  609. }
  611. // Day view
  612. if (nSelRangeDays <= nXTPMaxDayViewDays || nSelRangeDays != nSelDays ||
  613. dtFrom.GetDayOfWeek() != nFirstDayOfWeekIndex && nSelRangeDays <= 8
  614.  )
  615. {
  616. m_bAdjustingView = TRUE;
  618. // to save WorkWeek view mode
  619. int eViewMode = XTP_SAFE_GET2(m_pCalendarCtrl, GetActiveView(), GetViewType(), xtpCalendarDayView);
  621. if (eViewMode != xtpCalendarWorkWeekView || nSelDays != 1)
  622. {
  623. eViewMode = xtpCalendarDayView;
  624. }
  626. // WorkWeekView - set visible days
  627. if (eViewMode == xtpCalendarWorkWeekView)
  628. {
  629. CXTPCalendarDayView* pDayView = DYNAMIC_DOWNCAST(CXTPCalendarDayView, m_pCalendarCtrl->GetActiveView());
  630. if (pDayView)
  631. {
  632. pDayView->UnselectAllEvents();
  634. COleDateTime dtWWStart;
  635. m_pCalendarCtrl->GetWorkDayStartTime(dtWWStart);
  636. dtWWStart = CXTPCalendarUtils::UpdateDate(dtWWStart, dtFrom);
  638. pDayView->SetSelection(dtWWStart, dtWWStart + pDayView->GetCellDuration());
  639. }
  640. }
  642. //*** switch calendar view
  643. m_pCalendarCtrl->SwitchActiveView((XTPCalendarViewType)eViewMode);
  644. //***
  646. CXTPCalendarDayView* pDayView = DYNAMIC_DOWNCAST(CXTPCalendarDayView, m_pCalendarCtrl->GetActiveView());
  648. // DayView - set visible days
  649. if (pDayView && eViewMode == xtpCalendarDayView)
  650. {
  651. COleDateTime dtSelStart, dtSelEnd;
  652. BOOL bAllDay = FALSE;
  653. BOOL bSel = pDayView->GetSelection(&dtSelStart, &dtSelEnd, &bAllDay);
  654. if (bSel)
  655. {
  656. COleDateTimeSpan spSel = dtSelEnd - dtSelStart;
  657. COleDateTimeSpan spSelMin = pDayView->GetCellDuration();
  658. if (spSel < spSelMin)
  659. {
  660. bSel = FALSE;
  661. }
  662. }
  663. if (!bSel)
  664. {
  665. m_pCalendarCtrl->GetWorkDayStartTime(dtSelStart);
  666. dtSelEnd = dtSelStart + pDayView->GetCellDuration();
  667. bAllDay = FALSE;
  668. }
  669. dtSelStart = CXTPCalendarUtils::UpdateDate(dtSelStart, dtFrom);
  670. dtSelEnd = CXTPCalendarUtils::UpdateDate(dtSelEnd, dtFrom);
  672. pDayView->ShowDay(dtFrom);
  674. pDayView->SetSelection(dtSelStart, dtSelEnd, bAllDay);
  676. // add other selected days to calendar view
  677. for (COleDateTime dtDay(dtFrom + spDay); dtDay <= dtTo; dtDay += spDay)
  678. {
  679. if (m_pDatePickerCtrl->IsSelected(dtDay))
  680. {
  681. // add it to Calendar View
  682. pDayView->AddDay(dtDay);
  683. }
  684. }
  685. m_pCalendarCtrl->Populate();
  686. }
  688. m_bAdjustingView = FALSE;
  690. bChanged = TRUE;
  691. }
  692. // Week view
  693. else if (nSelRangeDays == 7 && nSelRangeDays == nSelDays)
  694. {
  695. COleDateTime dtBegin = dtFrom;
  696. if (IsFirstDayOfWeekShifted_FromSun2Mon())
  697. {
  698. dtBegin += spDay;
  699. }
  701. m_bAdjustingView = TRUE;
  703. m_pCalendarCtrl->SwitchActiveView(xtpCalendarWeekView);
  704. CXTPCalendarWeekView* pWeekView = DYNAMIC_DOWNCAST(CXTPCalendarWeekView, m_pCalendarCtrl->GetActiveView());
  705. if (pWeekView)
  706. {
  707. pWeekView->SetBeginDate(dtBegin);
  709. m_pCalendarCtrl->Populate();
  710. }
  712. m_bAdjustingView = FALSE;
  714. bChanged = TRUE;
  715. }
  716. // Month view
  717. else
  718. {
  719. ASSERT(nSelRangeDays == nSelDays && nSelRangeDays > 7);
  721. m_bAdjustingView = TRUE;
  723. m_pCalendarCtrl->SwitchActiveView(xtpCalendarMonthView);
  724. CXTPCalendarMonthView* pMonthView = DYNAMIC_DOWNCAST(CXTPCalendarMonthView, m_pCalendarCtrl->GetActiveView());
  725. if (pMonthView)
  726. {
  727. CXTPCalendarControl::CViewChangedContext viewChanged(m_pCalendarCtrl, xtpCalendarViewChangedLock);
  729. COleDateTime dtBegin = dtFrom;
  730. if (IsFirstDayOfWeekShifted_FromSun2Mon())
  731. {
  732. dtBegin += spDay;
  733. }
  735. // Calculate weeks count
  736. COleDateTime dtWeekFromBegin = pMonthView->GetGrid()->ShiftDateToCell_00(dtFrom);
  737. COleDateTime dtWeekToEnd = pMonthView->GetGrid()->ShiftDateToCell_00(dtTo);
  738. dtWeekToEnd += COleDateTimeSpan(7, 0, 0, 0);
  739. int nSelectedWeeksRange = GETTOTAL_DAYS_DTS(dtWeekToEnd - dtWeekFromBegin);
  741. int nWeeks = nSelectedWeeksRange / 7;
  742. nWeeks = max(XTP_CALENDAR_MONTHVIEW_SHOW_WEEKS_MIN, nWeeks);
  743. nWeeks = min(XTP_CALENDAR_MONTHVIEW_SHOW_WEEKS_MAX, nWeeks);
  745. pMonthView->GetGrid()->SetBeginDate(dtBegin);
  746. pMonthView->GetGrid()->SetWeeksCount(nWeeks);
  748. m_pCalendarCtrl->Populate();
  749. }
  751. m_bAdjustingView = FALSE;
  753. bChanged = TRUE;
  754. }
  756. if (bChanged)
  757. {
  758. OnEvent_CalendarView(XTP_NC_CALENDARVIEWWASCHANGED, 0, XTP_CC_DONT_SCROLL_DP);
  760. if (m_pDatePickerCtrl->IsModal())
  761. {
  762. m_pCalendarCtrl->Invalidate(FALSE);
  763. m_pCalendarCtrl->RedrawControl();
  764. }
  765. }
  766. }
  767. }
  768. break;
  769. default:
  770. ASSERT(FALSE);
  771. }
  772. }
  775. void CXTPCalendarController::OnEvent_CalendarOptionsChanged(XTP_NOTIFY_CODE Event, WPARAM wParam, LPARAM /*lParam*/)
  776. {
  777. if (Event != XTP_NC_CALENDAROPTIONSWASCHANGED)
  778. {
  779. ASSERT(FALSE);
  780. return;
  781. }
  783. if ((int)wParam < 0)
  784. {
  785. SetFirstDayOfWeekToDatePicker();
  786. }
  787. }
  789. void CXTPCalendarController::OnEvent_CalendarResourcesChanged(XTP_NOTIFY_CODE Event, WPARAM /*wParam*/, LPARAM /*lParam*/)
  790. {
  791. if (Event != XTP_NC_CALENDARDATAPROVIDERWASCHANGED)
  792. {
  793. ASSERT(FALSE);
  794. return;
  795. }
  797. CMDTARGET_RELEASE(m_pResourcesNf);
  798. _UnadviseFromDataChanged();
  800. m_DayInfoCache.Clear();
  801. }
  803. void CXTPCalendarController::OnEvent_CalendarThemeChanged(XTP_NOTIFY_CODE Event, WPARAM /*wParam*/, LPARAM /*lParam*/)
  804. {
  805. if (Event != XTP_NC_CALENDAR_THEME_CHANGED)
  806. {
  807. ASSERT(FALSE);
  808. return;
  809. }
  811. if (m_pCalendarCtrl && m_pDatePickerCtrl)
  812. {
  813. if (m_pDatePickerCtrl->GetPaintTheme() != m_pCalendarCtrl->GetPaintTheme())
  814. {
  815. m_pDatePickerCtrl->SetPaintTheme(m_pCalendarCtrl->GetPaintTheme());
  816. }
  817. }
  819. }
  821. void CXTPCalendarController::OnEvent_CalendarDataChanged(XTP_NOTIFY_CODE Event, WPARAM /*wParam*/, LPARAM lParam)
  822. {
  823. if (!m_pDatePickerCtrl)
  824. {
  825. return;
  826. }
  828. if (Event != XTP_NC_CALENDAREVENTWASADDED &&
  829. Event != XTP_NC_CALENDAREVENTWASCHANGED&&
  830. Event != XTP_NC_CALENDAREVENTWASDELETED)
  831. {
  832. ASSERT(FALSE);
  833. return;
  834. }
  836. //-------------------------------------
  837. COleDateTime dtFirstVisibleDay, dtLastVisibleDay;
  839. BOOL bRes = m_pDatePickerCtrl->GetVisibleRange(dtFirstVisibleDay, dtLastVisibleDay);
  840. if (!bRes)
  841. {
  842. return;
  843. }
  845. CXTPCalendarEvent* pEvent = (CXTPCalendarEvent*)lParam;
  846. if (!pEvent)
  847. {
  848. return;
  849. }
  851. if (Event == XTP_NC_CALENDAREVENTWASADDED ||
  852. Event == XTP_NC_CALENDAREVENTWASDELETED)
  853. {
  854. if (CXTPCalendarUtils::ResetTime(pEvent->GetStartTime()) > dtLastVisibleDay ||
  855. CXTPCalendarUtils::ResetTime(pEvent->GetEndTime()) < dtFirstVisibleDay )
  856. {
  857. return; // xtpCalendar_Skip;
  858. }
  860. if (m_bBoldDaysOnIdle)
  861. {
  862. m_DayInfoCache.ClearDays(pEvent->GetStartTime(), pEvent->GetEndTime());
  863. }
  864. }
  865. else
  866. {
  867. if (m_bBoldDaysOnIdle)
  868. {
  869. m_DayInfoCache.RequestToRefreshDays(dtFirstVisibleDay, dtLastVisibleDay);
  871. COleDateTime dtFom = max(dtFirstVisibleDay, pEvent->GetStartTime());
  872. COleDateTime dtTo = min(dtLastVisibleDay, pEvent->GetEndTime());
  873. m_DayInfoCache.RequestToRefreshDays(dtFom, dtTo);
  874. }
  875. }
  877. m_pDatePickerCtrl->_RedrawControl(FALSE);
  878. }
  880. void CXTPCalendarController::SetFirstDayOfWeekToDatePicker()
  881. {
  882. if (m_pDatePickerCtrl && m_pCalendarCtrl)
  883. {
  884. int nFirstDayOfWeekIndex = m_pCalendarCtrl->GetFirstDayOfWeek();
  886. m_pDatePickerCtrl->SetFirstDayOfWeek(nFirstDayOfWeekIndex);
  887. }
  888. }
  890. void CXTPCalendarController::OnEvent_DtPickGetItemMetrics(XTP_NOTIFY_CODE Event, WPARAM wParam, LPARAM lParam)
  891. {
  892. if (Event != XTP_NC_DATEPICKERGETDAYMETRICS)
  893. {
  894. ASSERT(FALSE);
  895. return;
  896. }
  897. if (!m_bBoldDaysWithEvents)
  898. {
  899. return;
  900. }
  902. const COleDateTime dtDay = (DATE)(XTP_DATE_VALUE)wParam;
  903. XTP_DAYITEM_METRICS* pDayItemMetrics = (XTP_DAYITEM_METRICS*)lParam;
  904. ASSERT(pDayItemMetrics);
  906. if (!pDayItemMetrics || !m_pCalendarCtrl || !m_pDatePickerCtrl)
  907. {
  908. return;
  909. }
  910. //--------------------------------------------------------------------
  911. if (!m_pResourcesNf)
  912. {
  913. m_pResourcesNf = new CXTPCalendarResourcesNf();
  914. if (!m_pResourcesNf)
  915. {
  916. return;
  917. }
  918. CXTPCalendarResources* pRC0 = m_pCalendarCtrl->GetResources();
  919. if (m_bUseActiveViewResoucesForBold)
  920. {
  921. pRC0 = m_pCalendarCtrl->GetActiveView()->GetResources();
  922. }
  924. m_pResourcesNf->Append(pRC0);
  926. _AdviseToDataChanged();
  928. m_pResourcesNf->ReBuildInternalData();
  929. }
  931. //--------------------------------------------------------------------
  932. BOOL bHasEvents = FALSE;
  934. if (m_bBoldDaysOnIdle)
  935. {
  936. bHasEvents = m_DayInfoCache.HasEvents(dtDay);
  937. }
  938. else
  939. {
  940. // check whether specified day has events
  941. bHasEvents = _HasEvents(dtDay);
  942. }
  944. // make the day with events as bold
  945. if (bHasEvents)
  946. {
  947. // set bold to day metrics
  948. pDayItemMetrics->SetFont(m_pDatePickerCtrl->GetPaintManager()->GetDayTextFontBold());
  949. }
  950. }
  951. BOOL CXTPCalendarController::_HasEvents(COleDateTime dtDay)
  952. {
  953. ASSERT(m_pResourcesNf);
  954. if (!m_pResourcesNf)
  955. {
  956. return FALSE;
  957. }
  959. CXTPCalendarResources* pRCx = m_pResourcesNf->GetResourcesGroupedByDP();
  960. int nRCCount = pRCx ? pRCx->GetCount() : 0;
  962. for (int i = 0; i < nRCCount; i++)
  963. {
  964. CXTPCalendarResource* pRC = pRCx->GetAt(i);
  965. ASSERT(pRC);
  966. CXTPCalendarEventsPtr ptrEvents = pRC ? pRC->RetrieveDayEvents(dtDay) : NULL;
  967. if (ptrEvents && ptrEvents->GetCount() > 0)
  968. {
  969. return TRUE;
  970. }
  971. }
  973. return FALSE;
  974. }
  977. void CXTPCalendarController::SetCalendar(CXTPCalendarControl* pCalendarCtrl)
  978. {
  979. m_Sink.UnadviseAll();
  981. if (m_pCalendarCtrl)
  982. {
  983. m_pCalendarCtrl->InternalRelease();
  984. }
  985. m_pCalendarCtrl = pCalendarCtrl;
  986. if (m_pCalendarCtrl)
  987. {
  988. m_pCalendarCtrl->InternalAddRef();
  990. AdviseToNotifications();
  992. SetFirstDayOfWeekToDatePicker();
  994. OnEvent_CalendarThemeChanged(XTP_NC_CALENDAR_THEME_CHANGED, 0, 0);
  995. }
  997. if (m_pCalendarCtrl && m_pDatePickerCtrl)
  998. {
  999. m_eLastActiveView = -1; // to ensure update
  1000. OnEvent_CalendarView(XTP_NC_CALENDARVIEWWASCHANGED, 0, 0);
  1001. }
  1002. }
  1004. void CXTPCalendarController::SetDatePicker(CXTPDatePickerControl* pDatePickerCtrl)
  1005. {
  1006. m_Sink.UnadviseAll();
  1008. if (m_pDatePickerCtrl)
  1009. {
  1010. m_pDatePickerCtrl->InternalRelease();
  1011. }
  1012. m_pDatePickerCtrl = pDatePickerCtrl;
  1013. if (m_pDatePickerCtrl)
  1014. {
  1015. m_pDatePickerCtrl->InternalAddRef();
  1017. m_pDatePickerCtrl->SetMaxSelCount(XTP_CALENDAR_MONTHVIEW_SHOW_WEEKS_MAX * 7);
  1019. AdviseToNotifications();
  1021. SetFirstDayOfWeekToDatePicker();
  1023. OnEvent_CalendarThemeChanged(XTP_NC_CALENDAR_THEME_CHANGED, 0, 0);
  1024. }
  1026. if (m_pCalendarCtrl && m_pDatePickerCtrl)
  1027. {
  1028. m_eLastActiveView = -1; // to ensure update
  1029. OnEvent_CalendarView(XTP_NC_CALENDARVIEWWASCHANGED, 0, 0);
  1030. }
  1031. }
  1033. CXTPCalendarControl* CXTPCalendarController::GetCalendar() const
  1034. {
  1035. return m_pCalendarCtrl;
  1036. }
  1038. CXTPDatePickerControl* CXTPCalendarController::GetDatePicker() const
  1039. {
  1040. return m_pDatePickerCtrl;
  1041. }
  1043. void CXTPCalendarController::SetBoldDaysWithEvents(BOOL bBold)
  1044. {
  1045. m_bBoldDaysWithEvents = bBold;
  1047. if (m_pResourcesNf && !m_bBoldDaysWithEvents)
  1048. {
  1049. CMDTARGET_RELEASE(m_pResourcesNf);
  1050. m_eLastActiveView = -1;
  1051. _UnadviseFromDataChanged();
  1053. m_DayInfoCache.Clear();
  1054. }
  1055. }