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

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

对话框与窗口

开发平台：

Visual C++

XTPCalendarControl.cpp：源码内容
  1. // XTPCalendarControl.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"
  22. #include "Resource.h"
  24. #include "Common/XTPResourceManager.h"
  25. #include "Common/XTPVC50Helpers.h"
  26. #include "Common/XTPImageManager.h"
  27. #include "Common/XTPSystemHelpers.h"
  29. #include "Common/XTPMarkupRender.h"
  30. #include "Common/XTPOffice2007Image.h"
  32. #include "XTPTopLevelWndMsgNotifier.h"
  33. #include "XTPCalendarUtils.h"
  35. #include "XTPCalendarPaintManager.h"
  36. #include "XTPCalendarNotifications.h"
  38. #include "XTPCalendarDayView.h"
  39. #include "XTPCalendarWeekView.h"
  40. #include "XTPCalendarMonthView.h"
  42. #include "XTPCalendarControl.h"
  43. #include "XTPCalendarResource.h"
  45. #include "XTPCalendarData.h"
  46. #include "XTPCalendarMemoryDataProvider.h"
  47. #include "XTPCalendarDatabaseDataProvider.h"
  48. #include "XTPCalendarMAPIDataProvider.h"
  49. #include "XTPCalendarCustomDataProvider.h"
  51. #include "XTPCalendarRemindersManager.h"
  52. #include "XTPCalendarOccurSeriesChooseDlg.h"
  54. #include "XTPCalendarTheme.h"
  55. #include "XTPCalendarThemeOffice2007.h"
  57. #ifdef _DEBUG
  58. #define new DEBUG_NEW
  59. #undef THIS_FILE
  60. static char THIS_FILE[] = __FILE__;
  61. #endif
  63. /////////////////////////////////////////////////////////////////////////////
  64. // CXTPCalendarControl
  66. #define XTP_CALENDAR_POPULATE_REQUEST_TIMEOUT   200
  67. #define XTP_CALENDAR_REDRAW_REQUEST_TIMEOUT     200
  69. #define XTP_CALENDAR_REFRESHMETRICS_REQUEST_TIMERID   1
  70. #define XTP_CALENDAR_REFRESHMETRICS_REQUEST_TIMEOUT   250
  72. #define XTP_CALENDAR_FIRST_DYN_TIMERID          10
  74. //#ifdef _DEBUG
  75. //  const COleDateTimeSpan cspRemindersUpdatePeriod(0, 0,15,0);
  76. //#else
  77. const COleDateTimeSpan cspRemindersUpdatePeriod(0, 2,0,0);
  78. //#endif
  80. /////////////////////////////////////////////////////////////////////////////
  81. BOOL IsEventExists(CXTPCalendarData* pData, CXTPCalendarEvent* pEvent)
  82. {
  83. if (pEvent->GetRecurrenceState() == xtpCalendarRecurrenceNotRecurring)
  84. {
  85. DWORD dwEventID = pEvent->GetEventID();
  86. CXTPCalendarEventPtr ptrEv = pData->GetEvent(dwEventID);
  87. return ptrEv != NULL;
  88. }
  89. else
  90. {
  91. DWORD dwPatternID = pEvent->GetRecurrencePatternID();
  92. CXTPCalendarRecurrencePatternPtr ptrPat = pData->GetRecurrencePattern(dwPatternID);
  93. return ptrPat != NULL;
  94. }
  95. }
  97. /////////////////////////////////////////////////////////////////////////////
  98. CXTPCalendarControl::CXTPCalendarControl()
  99. {
  100. RegisterWindowClass();
  102. m_pConnect = new CXTPNotifyConnection();
  104. m_bChanged = TRUE;
  105. m_nLockUpdateCount = m_nLockAdjustCount = 0;
  106. m_bAdjustScrollBar = FALSE;
  108. m_pActiveView = NULL;
  110. m_lcidActiveLocale = CXTPCalendarUtils::GetActiveLCID();
  112. m_pPaintManager = new CXTPCalendarPaintManager();
  113. if (m_pPaintManager)
  114. m_pPaintManager->SetControl(this);
  116. m_pTheme = NULL;
  118. m_mouseMode = xtpCalendarMouseNothing;
  119. m_nRowsPerWheel = 1;
  121. m_uNextTimerID = XTP_CALENDAR_FIRST_DYN_TIMERID;
  122. //---------------------------------------------------------------------------
  123. m_strUndoUIText = _T("&UndotAlt+BackSpace, Ctrl+Z");
  124. m_strRedoUIText = _T("&RedotAlt+BackSpace, Ctrl+Z");
  125. //---------------------------------------------------------------------------
  127. m_pMonthView = 0;
  128. m_pWeekView = 0;
  129. m_pDayView = 0;
  131. m_bDeleteOnFinalRelease = FALSE;
  132. m_bDisableRedraw = FALSE;
  134. m_bEnableToolTips = TRUE;
  135. m_bEnableSendNotifications = TRUE;
  137. m_uPopulateRequest_TimerID = 0;
  138. m_uRedrawRequest_TimerID = 0;
  140. m_bUpdateWhenEventChangedNotify = TRUE;
  142. m_pRemindersManager = NULL;
  143. m_cnidOnReminders = 0;
  144. m_spRemindersUpdatePeriod = cspRemindersUpdatePeriod;
  146. m_pOptions = new CXTPCalendarOptions();
  147. m_pResourcesNf = new CXTPCalendarResourcesNf();
  149. //By default add one resource with memory DataProvider
  150. SetDataProvider(xtpCalendarDataProviderMemory);
  151. ASSERT(GetDataProvider()->IsOpen());
  153. //EnableReminders(TRUE);
  155. m_pMarkupContext = NULL;
  157. //-----------------------------------------------------------------------
  158. if (XTPGetTopLevelWndMsgNotifier())
  159. {
  160. XTPGetTopLevelWndMsgNotifier()->Advise(this, WM_TIMECHANGE);
  161. XTPGetTopLevelWndMsgNotifier()->Advise(this, XTP_WM_TIME_ZONE_CHANGED);
  162. }
  164. //  CXTPCalendarThemeOffice2007* pTheme2007 = new CXTPCalendarThemeOffice2007();
  165. //  SetTheme(pTheme2007);
  167. //*** TEST of customization ***
  169. // EXAMPLE: customize root settings
  171. //  pTheme2007->GetEventPartX()->m_fcsetSelected.clrBorder = RGB(0, 230, 0);
  172. //  pTheme2007->GetEventPartX()->m_fcsetSelected.fcsetSubject.clrColor = RGB(255, 0, 0);
  173. //  pTheme2007->GetEventPartX()->m_fcsetSelected.fcsetLocation.clrColor = RGB(0, 255, 0);
  175. //  // customize particular settings
  176. //  pTheme2007->GetDayViewPartX()->GetDayPartX()->GetGroupPartX()->GetSingleDayEventPartX()->m_fcsetSelected.clrBorder = RGB(255, 100, 230);
  177. /*
  179. LOGFONT lf;
  180. pTheme2007->GetDayViewPartX()->GetHeaderPartX()->m_TextLeft.fcsetTodaySelected.fntFont->GetLogFont(&lf);
  181. lf.lfHeight *= 2;
  182. //pTheme2007->GetDayViewPartX()->GetHeaderPartX()->m_TextLeft.fcsetTodaySelected.fntFont.SetCustomValue(&lf);
  184. lf.lfHeight = lf.lfHeight * 3 / 2;
  185. lf.lfItalic = 1;
  186. //pTheme2007->GetDayViewPartX()->GetDayPartX()->GetGroupPartX()->GetSingleDayEventPartX()->m_fcsetNormal.fcsetSubject.fntFont.SetCustomValue(&lf);
  188. //pTheme2007->GetDayViewPartX()->GetTimeScalePart()->m_fcsetAMPM.clrColor = RGB(200, 33, 12);
  190. pTheme2007->RefreshMetrics();
  191. */
  192. // end EXAMPLE.
  193. }
  195. CXTPCalendarControl::~CXTPCalendarControl()
  196. {
  197. //---------------------------------------------------------------------------
  198. if (XTPGetTopLevelWndMsgNotifier())
  199. {
  200. XTPGetTopLevelWndMsgNotifier()->Unadvise(this);
  201. }
  203. m_cnidOnReminders = 0;
  204. //m_Sink_DP.UnadviseAll();
  206. CMDTARGET_RELEASE(m_pResourcesNf);
  208. CMDTARGET_RELEASE(m_pActiveView);
  210. CMDTARGET_RELEASE(m_pDayView);
  211. CMDTARGET_RELEASE(m_pWeekView);
  212. CMDTARGET_RELEASE(m_pMonthView);
  214. CMDTARGET_RELEASE(m_pPaintManager);
  215. CMDTARGET_RELEASE(m_pTheme);
  217. CMDTARGET_RELEASE(m_pConnect);
  218. CMDTARGET_RELEASE(m_pRemindersManager);
  220. CMDTARGET_RELEASE(m_pOptions);
  222. XTPMarkupReleaseContext(m_pMarkupContext);
  224. if (::IsWindow(m_wndTip.GetSafeHwnd()))
  225. {
  226. m_wndTip.DestroyWindow();
  227. }
  229. if (::IsWindow(GetSafeHwnd()))
  230. {
  231. DestroyWindow();
  232. }
  233. }
  235. CScrollBar* CXTPCalendarControl::GetScrollBarCtrl(int nBar) const
  236. {
  237. if (DYNAMIC_DOWNCAST(CView, GetParent()))
  238. return GetParent()->GetScrollBarCtrl(nBar);
  240. return 0;
  241. }
  244. void CXTPCalendarControl::OnDestroy()
  245. {
  246. OnBeforeDestroy();
  248. CWnd::OnDestroy();
  249. }
  251. void CXTPCalendarControl::OnBeforeDestroy()
  252. {
  253. if (m_pActiveView)
  254. {
  255. m_pActiveView->OnBeforeDestroy();
  256. }
  258. if (m_pDayView)
  259. {
  260. m_pDayView->OnBeforeDestroy();
  261. }
  262. if (m_pWeekView)
  263. {
  264. m_pWeekView->OnBeforeDestroy();
  265. }
  266. if (m_pMonthView)
  267. {
  268. m_pMonthView->OnBeforeDestroy();
  269. }
  270. }
  272. BOOL CXTPCalendarControl::RegisterWindowClass(HINSTANCE hInstance /*= NULL*/)
  273. {
  274. return XTPDrawHelpers()->RegisterWndClass(hInstance,
  275. XTPCALENDARCTRL_CLASSNAME, CS_DBLCLKS | CS_HREDRAW | CS_VREDRAW);
  276. }
  278. BOOL CXTPCalendarControl::Create(DWORD dwStyle, const RECT& rect, CWnd* pParentWnd, UINT nID)
  279. {
  280. if (!CWnd::Create(XTPCALENDARCTRL_CLASSNAME, NULL, dwStyle, rect, pParentWnd, nID))
  281. return FALSE;
  283. return TRUE;
  284. }
  286. void CXTPCalendarControl::PreSubclassWindow()
  287. {
  288. _InitCalendarView();
  289. }
  291. void CXTPCalendarControl::_InitCalendarView()
  292. {
  293. //-----------------------------------------------------------------------
  294. SetActiveView(GetDayView());
  296. CXTPCalendarDayView* pDayView = DYNAMIC_DOWNCAST(CXTPCalendarDayView, GetDayView());
  297. if (!pDayView)
  298. {
  299. return;
  300. }
  302. COleDateTime dtStartDate = CXTPCalendarUtils::GetCurrentTime();
  303. pDayView->ResetSelection();
  304. pDayView->ShowDay(dtStartDate);
  306. pDayView->ScrollToWorkDayBegin();
  307. }
  309. void CXTPCalendarControl::LockUpdate()
  310. {
  311. m_nLockUpdateCount++;
  312. }
  314. void CXTPCalendarControl::UnlockUpdate()
  315. {
  316. m_nLockUpdateCount--;
  318. if (m_nLockUpdateCount == 0 && m_bChanged)
  319. {
  320. RedrawControl();
  321. }
  322. }
  324. void CXTPCalendarControl::BeginUpdate()
  325. {
  326. m_nLockUpdateCount++;
  327. }
  329. void CXTPCalendarControl::EndUpdate()
  330. {
  331. m_bChanged = TRUE;
  332. m_nLockUpdateCount--;
  334. if (m_nLockUpdateCount == 0)
  335. {
  336. RedrawControl();
  337. }
  338. }
  340. void CXTPCalendarControl::BeginAdjust(BOOL bWithScrollBar)
  341. {
  342. if (m_nLockAdjustCount == 0)
  343. {
  344. m_bAdjustScrollBar = FALSE;
  345. }
  346. m_nLockAdjustCount++;
  347. m_bAdjustScrollBar |= bWithScrollBar;
  348. }
  350. void CXTPCalendarControl::EndAdjust(BOOL bWithScrollBar)
  351. {
  352. m_bChanged = TRUE;
  353. m_nLockAdjustCount--;
  354. m_bAdjustScrollBar |= bWithScrollBar;
  356. if (m_nLockAdjustCount == 0)
  357. {
  358. AdjustLayout();
  359. if (m_bAdjustScrollBar)
  360. {
  361. AdjustScrollBar();
  362. }
  364. m_bAdjustScrollBar = FALSE;
  365. }
  366. }
  368. BEGIN_MESSAGE_MAP(CXTPCalendarControl, CWnd)
  369. //{{AFX_MSG_MAP(CXTPCalendarControl)
  370. ON_WM_PAINT()
  371. ON_MESSAGE(WM_PRINTCLIENT, OnPrintClient)
  372. ON_WM_ERASEBKGND()
  373. ON_WM_SIZE()
  374. ON_WM_LBUTTONDOWN()
  375. ON_WM_RBUTTONDOWN()
  376. ON_WM_RBUTTONUP()
  377. ON_WM_LBUTTONUP()
  378. ON_WM_LBUTTONDBLCLK()
  379. ON_WM_CONTEXTMENU()
  380. ON_WM_MOUSEMOVE()
  381. ON_WM_MOUSEWHEEL()
  382. ON_WM_CHAR()
  383. ON_WM_KEYDOWN()
  384. ON_WM_SYSKEYDOWN()
  385. ON_WM_CAPTURECHANGED()
  386. ON_WM_VSCROLL()
  387. ON_WM_HSCROLL()
  388. ON_WM_SETCURSOR()
  389. ON_WM_TIMER()
  390. ON_WM_DESTROY()
  391. ON_WM_GETDLGCODE()
  392. ON_WM_ENABLE()
  394. ON_WM_SETFOCUS()
  395. ON_WM_KILLFOCUS()
  397. ON_WM_TIMECHANGE()
  398. ON_REGISTERED_MESSAGE(XTP_WM_TIME_ZONE_CHANGED, OnTimeZoneChanged)
  399. ON_WM_SYSCOLORCHANGE()
  401. ON_REGISTERED_MESSAGE(xtp_wm_SwitchView, OnSwitchView)
  402. ON_REGISTERED_MESSAGE(xtp_wm_UserAction, OnUserAction)
  404. ON_COMMAND(ID_EDIT_UNDO, OnUndo)
  405. ON_COMMAND(ID_EDIT_CUT, OnCut)
  406. ON_COMMAND(ID_EDIT_COPY, OnCopy)
  407. ON_COMMAND(ID_EDIT_PASTE, OnPaste)
  409. ON_UPDATE_COMMAND_UI(ID_EDIT_UNDO, OnUpdateUndo)
  410. ON_UPDATE_COMMAND_UI(ID_EDIT_CUT, OnUpdateCut)
  411. ON_UPDATE_COMMAND_UI(ID_EDIT_COPY, OnUpdateCopy)
  412. ON_UPDATE_COMMAND_UI(ID_EDIT_PASTE, OnUpdatePaste)
  414. //  ON_CONTROL_REFLECT(ID_EDIT_UNDO, OnUndo)
  415. //  ON_UPDATE_COMMAND_UI_REFLECT(OnUpdateUndo)
  416. //}}AFX_MSG_MAP
  418. END_MESSAGE_MAP()
  421. /////////////////////////////////////////////////////////////////////////////
  422. // CXTPCalendarControl message handlers
  424. void CXTPCalendarControl::OnPaint()
  425. {
  426. CPaintDC dc(this); // device context for painting
  428. CRect rc;
  429. GetClientRect(&rc);
  431. if (rc.IsRectEmpty())
  432. return;
  434. // Check cached bitmap
  435. if ((!m_bChanged || m_bDisableRedraw) && m_bmpCache.GetSafeHandle() != 0)
  436. {
  437. CXTPCompatibleDC memDC(&dc, &m_bmpCache);
  438. dc.BitBlt(0, 0, rc.right, rc.bottom, &memDC, 0, 0, SRCCOPY);
  439. }
  440. else
  441. {
  442. CDC memDC;
  443. memDC.CreateCompatibleDC(&dc);
  445. if (!m_bmpCache.m_hObject)
  446. {
  447. m_bmpCache.CreateCompatibleBitmap(&dc, rc.Width(), rc.Height());
  448. }
  450. CBitmap* pOldBitmap = memDC.SelectObject(&m_bmpCache);
  451. memDC.FillSolidRect(rc, 0xFF);
  453. OnDraw(&memDC);
  455. if (!IsWindowEnabled())
  456. {
  457. XTPImageManager()->DisableBitmap(memDC, rc, XTP_CALENDAR_DISABLED_COLOR_LIGHT, XTP_CALENDAR_DISABLED_COLOR_DARK);
  458. }
  460. dc.BitBlt(0, 0, rc.right, rc.bottom, &memDC, 0, 0, SRCCOPY);
  462. memDC.SelectObject(pOldBitmap);
  464. // update flag
  465. m_bChanged = FALSE;
  466. }
  467. }
  469. LRESULT CXTPCalendarControl::OnPrintClient(WPARAM wParam, LPARAM /*lParam*/)
  470. {
  471. CDC* pDC = CDC::FromHandle((HDC)wParam);
  472. if (pDC)
  473. {
  474. if (m_bmpCache.GetSafeHandle() == 0)
  475. OnDraw(pDC);
  476. else
  477. {
  478. CXTPCompatibleDC memDC(pDC, &m_bmpCache);
  479. CXTPClientRect rc(this);
  480. pDC->BitBlt(0, 0, rc.right, rc.bottom, &memDC, 0, 0, SRCCOPY);
  481. }
  482. }
  484. return TRUE;
  485. }
  487. BOOL CXTPCalendarControl::OnEraseBkgnd(CDC* /*pDC*/)
  488. {
  489. return TRUE;
  490. }
  492. void CXTPCalendarControl::OnSize(UINT nType, int cx, int cy)
  493. {
  494. if (m_bmpCache.m_hObject)
  495. {
  496. m_bmpCache.DeleteObject();
  497. }
  499. CWnd::OnSize(nType, cx, cy);
  501. if (::IsWindow(GetSafeHwnd()) && cx > 0 && cy > 0)
  502. {
  503. AdjustLayout();
  504. AdjustScrollBar();
  505. }
  506. }
  508. void CXTPCalendarControl::AdjustScrollBar(int nSBType)
  509. {
  510. if (!::IsWindow(GetSafeHwnd()) || !m_pActiveView)
  511. return;
  513. BeginUpdate();
  515. if (nSBType == SB_VERT || nSBType == -1)
  516. {
  517. AdjustScrollBarEx(SB_VERT);
  518. }
  520. if (nSBType == SB_HORZ || nSBType == -1)
  521. {
  522. AdjustScrollBarEx(SB_HORZ);
  523. }
  525. AdjustLayout();
  527. EndUpdate();
  528. }
  530. void CXTPCalendarControl::AdjustScrollBarEx(int nSBType)
  531. {
  532. ASSERT(nSBType == SB_VERT || nSBType == SB_HORZ);
  534. if (!m_pActiveView)
  535. {
  536. return;
  537. }
  539. SCROLLINFO  si ;
  540. si.cbSize = sizeof(SCROLLINFO);
  541. si.nMin = 0 ;
  542. si.nMax = 1;
  543. si.fMask = SIF_PAGE | SIF_RANGE | SIF_POS;
  544. si.nPage = 1;
  545. si.nPos = 0;
  547. BOOL bEnabled = FALSE;
  548. if (nSBType == SB_VERT)
  549. {
  550. bEnabled = m_pActiveView->GetScrollBarInfoV(&si);
  551. }
  552. else if (nSBType == SB_HORZ)
  553. {
  554. bEnabled = m_pActiveView->GetScrollBarInfoH(&si);
  555. }
  556. else
  557. {
  558. ASSERT(FALSE);
  559. return;
  560. }
  562. if (si.nPos > si.nMax + 1 - (int)si.nPage)
  563. {
  564. int nPos_raw = si.nPos;
  566. si.nPos = si.nMax + 1 - (int)si.nPage;
  567. if (nSBType == SB_VERT)
  568. {
  569. m_pActiveView->ScrollV(si.nPos, nPos_raw);
  570. }
  571. else if (nSBType == SB_HORZ)
  572. {
  573. m_pActiveView->ScrollH(si.nPos, nPos_raw);
  574. }
  575. else
  576. {
  577. ASSERT(FALSE);
  578. return;
  579. }
  580. }
  582. if (bEnabled)
  583. {
  584. SetScrollInfo(nSBType, &si) ;
  585. }
  586. EnableScrollBarCtrl(nSBType, bEnabled);
  588. ::EnableScrollBar(m_hWnd, nSBType, (bEnabled && IsWindowEnabled()) ? ESB_ENABLE_BOTH : ESB_DISABLE_BOTH);
  589. }
  592. void CXTPCalendarControl::AdjustLayout()
  593. {
  594. if (!::IsWindow(GetSafeHwnd()))
  595. return;
  597. if (m_lcidActiveLocale != CXTPCalendarUtils::GetActiveLCID())
  598. {
  599. m_lcidActiveLocale = CXTPCalendarUtils::GetActiveLCID();
  601. XTP_SAFE_CALL1(m_pPaintManager, RefreshMetrics());
  602. XTP_SAFE_CALL1(m_pTheme, RefreshMetrics());
  603. }
  605. CClientDC dc(this);
  606. CXTPClientRect rcView(this);
  608. // horizontal scrolling support.
  609. SCROLLINFO si;
  610. if (m_pActiveView && m_pActiveView->GetScrollBarInfoH(&si))
  611. {
  612. ASSERT(m_pActiveView == m_pDayView);
  613. if (m_pActiveView == m_pDayView)
  614. {
  615. rcView.left -= si.nPos; //m_pDayView->m_nScrollOffsetX;
  616. rcView.right = rcView.left + si.nMax + 1 + m_pDayView->_GetTimeScaleWith();
  617. }
  618. }
  620. AdjustLayout(&dc, rcView);
  621. }
  623. void CXTPCalendarControl::AdjustLayout(CDC* pDC, const CRect& rcView)
  624. {
  625. if (m_pActiveView && !rcView.IsRectEmpty())
  626. {
  627. if (GetTheme())
  628. {
  629. m_pActiveView->AdjustLayout2(pDC, rcView, TRUE);
  630. }
  631. else
  632. {
  633. m_pActiveView->AdjustLayout(pDC, rcView, TRUE);
  634. }
  635. }
  636. }
  638. void CXTPCalendarControl::RedrawControl(BOOL bForce)
  639. {
  640. m_bChanged = TRUE;
  642. if (GetSafeHwnd() &&
  643. (bForce || (m_nLockUpdateCount == 0)))
  644. {
  645. Invalidate(FALSE);
  646. if (bForce)
  647. UpdateWindow();
  648. }
  649. }
  651. void CXTPCalendarControl::OnLButtonDown(UINT nFlags, CPoint point)
  652. {
  653. CXTPSmartPtrInternalT<CCmdTarget> ptrThisLock(this, TRUE);
  655. CUpdateContext updateContext(this, xtpCalendarUpdateRedrawIfNeed);
  657. BOOL bStartEditing = FALSE;
  658. if (IsToolTipVisible())
  659. {
  660. CRect rcTip = m_wndTip.GetHoverRect();
  661. ScreenToClient(&rcTip);
  663. HideToolTip();
  664. bStartEditing = m_wndTip.IsAdvancedMode() && rcTip.PtInRect(point);
  665. }
  667. SetCapture();
  668. SetFocus();
  670. if (m_pActiveView)
  671. {
  672. m_pActiveView->OnLButtonDown(nFlags, point);
  673. if (bStartEditing)
  674. {
  675. m_pActiveView->StartEditNewEventInplace(_T(""));
  676. }
  677. }
  679. CWnd::OnLButtonDown(nFlags, point);
  681. // forward message to subscriber
  682. DWORD dwPoint = MAKELONG(point.x, point.y);
  683. SendNotification(XTP_NC_CALENDARLBUTTONDOWN, dwPoint, 0);
  684. }
  686. void CXTPCalendarControl::OnRButtonDown(UINT nFlags, CPoint point)
  687. {
  688. CXTPSmartPtrInternalT<CCmdTarget> ptrThisLock(this, TRUE);
  690. CUpdateContext updateContext(this, xtpCalendarUpdateRedrawIfNeed);
  692. CWnd::OnRButtonDown(nFlags, point);
  694. // forward message to subscriber
  695. DWORD dwPoint = MAKELONG(point.x, point.y);
  696. SendNotification(XTP_NC_CALENDARRBUTTONDOWN, dwPoint, 0);
  697. }
  699. void CXTPCalendarControl::OnRButtonUp(UINT nFlags, CPoint point)
  700. {
  701. CXTPSmartPtrInternalT<CCmdTarget> ptrThisLock(this, TRUE);
  703. CUpdateContext updateContext(this, xtpCalendarUpdateRedrawIfNeed);
  705. // forward message to subscriber
  706. DWORD dwPoint = MAKELONG(point.x, point.y);
  707. SendNotification(XTP_NC_CALENDARRBUTTONUP, dwPoint, 0);
  709. CWnd::OnRButtonUp(nFlags, point); // OnContextMenu will be called.
  710. }
  712. void CXTPCalendarControl::OnLButtonUp(UINT nFlags, CPoint point)
  713. {
  714. CXTPSmartPtrInternalT<CCmdTarget> ptrThisLock(this, TRUE);
  716. CUpdateContext updateContext(this, xtpCalendarUpdateRedrawIfNeed);
  718. if (GetCapture() == this)
  719. ReleaseCapture();
  721. if (m_pActiveView)
  722. {
  723. m_pActiveView->OnLButtonUp(nFlags, point);
  724. }
  726. CWnd::OnLButtonUp(nFlags, point);
  728. // forward message to subscriber
  729. DWORD dwPoint = MAKELONG(point.x, point.y);
  730. SendNotification(XTP_NC_CALENDARLBUTTONUP, dwPoint, 0);
  731. }
  733. void CXTPCalendarControl::OnLButtonDblClk(UINT nFlags, CPoint point)
  734. {
  735. CXTPSmartPtrInternalT<CCmdTarget> ptrThisLock(this, TRUE);
  737. CUpdateContext updateContext(this, xtpCalendarUpdateRedrawIfNeed);
  739. if (m_pActiveView)
  740. {
  741. m_pActiveView->OnLButtonDblClk(nFlags, point);
  742. }
  744. CWnd::OnLButtonDblClk(nFlags, point);
  746. // forward message to subscriber
  747. DWORD dwPoint = MAKELONG(point.x, point.y);
  748. SendNotification(XTP_NC_CALENDARLBUTTONDBLCLICK, dwPoint, 0);
  749. }
  751. void CXTPCalendarControl::OnMouseMove(UINT nFlags, CPoint point)
  752. {
  753. CXTPSmartPtrInternalT<CCmdTarget> ptrThisLock(this, TRUE);
  755. CUpdateContext updateContext(this, xtpCalendarUpdateRedrawIfNeed);
  757. m_mouseMode = xtpCalendarMouseNothing;
  759. if (m_pActiveView)
  760. {
  761. m_pActiveView->OnMouseMove(nFlags, point);
  762. }
  764. CWnd::OnMouseMove(nFlags, point);
  766. // forward message to subscriber
  767. DWORD dwPoint = MAKELONG(point.x, point.y);
  768. SendNotification(XTP_NC_CALENDARMOUSEMOVE, dwPoint, 0);
  769. }
  771. void CXTPCalendarControl::OnCaptureChanged(CWnd* pWnd)
  772. {
  773. CWnd::OnCaptureChanged(pWnd);
  774. }
  776. void CXTPCalendarControl::OnVScroll(UINT nSBCode, UINT nPos, CScrollBar* pScrollBar)
  777. {
  778. CUpdateContext updateContext(this, xtpCalendarUpdateRedrawIfNeed);
  779. CViewChangedContext viewChanged(this, xtpCalendarViewChangedLock);
  781. if (pScrollBar != NULL)
  782. {
  783. CWnd::OnVScroll(nSBCode, nPos, pScrollBar);
  784. return;
  785. }
  787. if (!m_pActiveView)
  788. {
  789. return;
  790. }
  792. SCROLLINFO si;
  793. m_pActiveView->GetScrollBarInfoV(&si);
  795. int nCurPos = si.nPos;
  796. int nCurPos_raw = si.nPos;
  797. int nLimit = GetScrollLimit(SB_VERT);
  799. // decide what to do for each different scroll event
  800. switch (nSBCode)
  801. {
  802. case SB_TOP:
  803. nCurPos = nCurPos_raw = 0;
  804. break;
  805. case SB_BOTTOM:
  806. nCurPos = nCurPos_raw = nLimit;
  807. break;
  808. case SB_LINEUP:
  809. nCurPos = max(nCurPos - 1, 0);
  810. nCurPos_raw--;
  811. break;
  812. case SB_LINEDOWN:
  813. nCurPos = min(nCurPos + 1, nLimit);
  814. nCurPos_raw++;
  815. break;
  816. case SB_PAGEUP:
  817. nCurPos = max(nCurPos - (int)si.nPage, 0);
  818. nCurPos_raw -= (int)si.nPage;
  819. break;
  820. case SB_PAGEDOWN:
  821. nCurPos = min(nCurPos + (int)si.nPage, nLimit);
  822. nCurPos_raw += (int)si.nPage;
  823. break;
  824. case SB_THUMBTRACK:
  825. case SB_THUMBPOSITION:
  826. nCurPos = nCurPos_raw = nPos;
  827. break;
  828. }
  830. m_pActiveView->ScrollV(nCurPos, nCurPos_raw);
  832. SetScrollPos(SB_VERT, nCurPos, FALSE);
  833. AdjustScrollBar();
  834. }
  836. void CXTPCalendarControl::OnHScroll(UINT nSBCode, UINT nPos, CScrollBar* pScrollBar)
  837. {
  838. CUpdateContext updateContext(this, xtpCalendarUpdateRedrawIfNeed);
  839. CViewChangedContext viewChanged(this, xtpCalendarViewChangedLock);
  841. if (pScrollBar != NULL)
  842. {
  843. CWnd::OnHScroll(nSBCode, nPos, pScrollBar);
  844. return;
  845. }
  847. if (!m_pActiveView)
  848. {
  849. return;
  850. }
  852. SCROLLINFO si;
  853. int nScrollStep = 1;
  854. m_pActiveView->GetScrollBarInfoH(&si, &nScrollStep);
  856. int nCurPos = si.nPos;
  857. int nCurPos_raw = si.nPos;
  858. int nLimit = GetScrollLimit(SB_HORZ);
  860. // decide what to do for each different scroll event
  861. switch (nSBCode)
  862. {
  863. case SB_LEFT:
  864. nCurPos = nCurPos_raw = 0;
  865. break;
  866. case SB_RIGHT:
  867. nCurPos = nCurPos_raw = nLimit;
  868. break;
  869. case SB_LINELEFT:
  870. nCurPos = max(nCurPos - nScrollStep, 0);
  871. nCurPos_raw--;
  872. break;
  873. case SB_LINERIGHT:
  874. nCurPos = min(nCurPos + nScrollStep, nLimit);
  875. nCurPos_raw++;
  876. break;
  877. case SB_PAGELEFT:
  878. nCurPos = max(nCurPos - (int)si.nPage, 0);
  879. nCurPos_raw -= (int)si.nPage;
  880. break;
  881. case SB_PAGERIGHT:
  882. nCurPos = min(nCurPos + (int)si.nPage, nLimit);
  883. nCurPos_raw += (int)si.nPage;
  884. break;
  885. case SB_THUMBTRACK:
  886. case SB_THUMBPOSITION:
  887. nCurPos = nCurPos_raw = nPos;
  888. break;
  889. }
  891. m_pActiveView->ScrollH(nCurPos, nCurPos_raw);
  893. SetScrollPos(SB_HORZ, nCurPos, FALSE);
  894. AdjustScrollBar();
  895. }
  897. void CXTPCalendarControl::OnDraw(CDC* pDC)
  898. {
  899. ASSERT(m_pActiveView && pDC);
  900. if (m_pActiveView && pDC)
  901. m_pActiveView->OnDraw(pDC);
  902. }
  904. void CXTPCalendarControl::Populate()
  905. {
  906. if (IsToolTipVisible())
  907. {
  908. HideToolTip();
  909. }
  911. if (!m_pActiveView)
  912. return;
  914. if (::IsWindow(GetSafeHwnd()))
  915. {
  916. CUpdateContext updateContext(this, xtpCalendarUpdateRedrawIfNeed);
  917. CViewChangedContext viewChanged(this, xtpCalendarViewChangedLock);
  919. CUpdateContext updateContext2(this, xtpCalendarUpdateAll);
  921. m_pActiveView->Populate();
  922. }
  923. else
  924. {
  925. m_pActiveView->Populate();
  926. }
  927. }
  929. BOOL CXTPCalendarControl::UpdateMouseCursor()
  930. {
  931. if (!AfxGetApp())
  932. {
  933. return FALSE;
  934. }
  936. switch (m_mouseMode)
  937. {
  938. case xtpCalendarMouseEventPreResizeV:
  939. case xtpCalendarMouseEventResizingV:
  940. SetCursor(AfxGetApp()->LoadStandardCursor(IDC_SIZENS));
  941. TRACE_DRAGGING(_T("UpdateMouseCursor():: ResizingVn"));
  942. break;
  943. case xtpCalendarMouseEventPreResizeH:
  944. case xtpCalendarMouseEventResizingH:
  945. SetCursor(AfxGetApp()->LoadStandardCursor(IDC_SIZEWE));
  946. TRACE_DRAGGING(_T("UpdateMouseCursor():: ResizingHn"));
  947. break;
  948. case xtpCalendarMouseEventPreDrag:
  949. SetCursor(AfxGetApp()->LoadStandardCursor(IDC_SIZEALL));
  950. TRACE_DRAGGING(_T("UpdateMouseCursor():: PreDragn"));
  951. break;
  952. case xtpCalendarMouseEventDragCopy:
  953. SetCursor(XTPResourceManager()->LoadCursor(XTP_IDC_CALENDAR_DRAGCOPY));
  954. TRACE_DRAGGING(_T("UpdateMouseCursor():: DragCopyn"));
  955. break;
  956. case xtpCalendarMouseEventDragMove:
  957. SetCursor(XTPResourceManager()->LoadCursor(XTP_IDC_CALENDAR_DRAGMOVE));
  958. TRACE_DRAGGING(_T("UpdateMouseCursor():: DragCopyn"));
  959. break;
  960. case xtpCalendarMouseEventDraggingOut:
  961. SetCursor(AfxGetApp()->LoadStandardCursor(IDC_NO));
  962. TRACE_DRAGGING(_T("UpdateMouseCursor():: Dragging OUTn"));
  964. break;
  965. case xtpCalendarMouseNothing:
  966. default:
  967. TRACE_DRAGGING(_T("UpdateMouseCursor():: Nothingn"));
  968. return FALSE;
  969. }
  970. return TRUE;
  971. }
  973. BOOL CXTPCalendarControl::OnSetCursor(CWnd* pWnd, UINT nHitTest, UINT message)
  974. {
  975. if (nHitTest == HTCLIENT)
  976. {
  977. if (UpdateMouseCursor())
  978. return TRUE;
  979. }
  981. return CWnd::OnSetCursor(pWnd, nHitTest, message);
  982. }
  984. BOOL CXTPCalendarControl::OnMouseWheel(UINT nFlags, short zDelta, CPoint pt)
  985. {
  986. UINT uiMsg;
  987. int nScrollsCount = 0;
  988. // calculate what should be sent
  989. if (m_nRowsPerWheel == -1)
  990. {
  991. // A m_nRowsPerWheel value less than 0 indicates that the mouse wheel scrolls whole pages, not just lines.
  992. int nPagesScrolled = zDelta / 120;
  993. uiMsg = nPagesScrolled > 0 ? SB_PAGEUP : SB_PAGEDOWN;
  994. nScrollsCount = nPagesScrolled > 0 ? nPagesScrolled : -nPagesScrolled;
  995. }
  996. else
  997. {
  998. int nRowsScrolled = m_nRowsPerWheel * zDelta / 120;
  999. uiMsg = nRowsScrolled > 0 ? SB_LINEUP : SB_LINEDOWN;
  1000. nScrollsCount = nRowsScrolled > 0 ? nRowsScrolled : -nRowsScrolled;
  1001. }
  1002. // send scroll messages
  1003. for (int i = 0; i < nScrollsCount; i++)
  1004. {
  1005. PostMessage(WM_VSCROLL, uiMsg, 0);
  1006. }
  1008. // prevent parent from scrolling while calendar scroll pos is not min or max.
  1009. //
  1010. if (m_pActiveView)
  1011. {
  1012. SCROLLINFO  si;
  1013. ::ZeroMemory(&si, sizeof(si));
  1014. si.cbSize = sizeof(SCROLLINFO);
  1016. BOOL bScrollEnabled = m_pActiveView->GetScrollBarInfoV(&si);
  1018. if (bScrollEnabled)
  1019. {
  1020. int nViewType = m_pActiveView->GetViewType();
  1022. if (nViewType == xtpCalendarDayView ||
  1023. nViewType == xtpCalendarWorkWeekView)
  1024. {
  1025. INT nPosMin, nPosMax;
  1026. GetScrollRange(SB_VERT, &nPosMin, &nPosMax);
  1027. nPosMax = GetScrollLimit(SB_VERT);
  1029. int nPos = GetScrollPos(SB_VERT);
  1031. if (zDelta > 0 && nPos > nPosMin || zDelta < 0 && nPos < nPosMax)
  1032. {
  1033. return TRUE;
  1034. }
  1035. }
  1036. else
  1037. {
  1038. return TRUE;
  1039. }
  1040. }
  1041. }
  1043. return CWnd::OnMouseWheel(nFlags, zDelta, pt);
  1044. }
  1046. //////////////////////////////////////////////////////////////////////////
  1047. // View related
  1048. //
  1049. CXTPCalendarView* CXTPCalendarControl::GetActiveView()
  1050. {
  1051. return m_pActiveView;
  1052. }
  1054. CXTPCalendarView* CXTPCalendarControl::GetDayView()
  1055. {
  1056. if (m_pDayView == 0)
  1057. {
  1058. m_pDayView = new CXTPCalendarDayView(this);
  1059. }
  1061. return m_pDayView;
  1062. }
  1064. CXTPCalendarView* CXTPCalendarControl::GetWeekView()
  1065. {
  1066. if (m_pWeekView == 0)
  1067. {
  1068. m_pWeekView = new CXTPCalendarWeekView(this);
  1069. }
  1071. return m_pWeekView;
  1073. }
  1075. CXTPCalendarView* CXTPCalendarControl::GetMonthView()
  1076. {
  1077. if (m_pMonthView == 0)
  1078. {
  1079. m_pMonthView = new CXTPCalendarMonthView(this);
  1080. }
  1082. return m_pMonthView;
  1083. }
  1086. void CXTPCalendarControl::SetActiveView(CXTPCalendarView* pView)
  1087. {
  1088. CViewChangedContext viewChanged(this);
  1090. CMDTARGET_ADDREF(pView);
  1092. CXTPCalendarView* pInactiveView = m_pActiveView;
  1093. if (pInactiveView)
  1094. {
  1095. pInactiveView->OnActivateView(FALSE, pView, pInactiveView);
  1096. }
  1098. m_pActiveView = pView;
  1100. if (m_pActiveView)
  1101. {
  1102. m_pActiveView->OnActivateView(TRUE, m_pActiveView, pInactiveView);
  1103. }
  1105. CMDTARGET_RELEASE(pInactiveView);
  1107. }
  1109. void CXTPCalendarControl::SwitchActiveView(XTPCalendarViewType eViewType)
  1110. {
  1111. CUpdateContext updateContext(this, xtpCalendarUpdateRedrawIfNeed);
  1112. CViewChangedContext viewChanged(this, xtpCalendarViewChangedLock);
  1114. CUpdateContext updateContext2(this, xtpCalendarUpdateRedraw | xtpCalendarUpdateLayout);
  1116. CXTPCalendarView* pPrevView = GetActiveView();
  1117. CXTPCalendarViewEventsPtr ptrSelEvents;
  1119. COleDateTime dtSelStartDate, dtSelDay, dtSelDay2, dtSelEvent;
  1120. COleDateTimeSpan spSelDayDuration(0.);
  1121. BOOL bSelDay = FALSE;
  1122. BOOL bSelAllDay = FALSE;
  1124. if (pPrevView)
  1125. {
  1126. bSelDay = pPrevView->GetSelection(&dtSelDay, &dtSelDay2, &bSelAllDay);
  1127. if (bSelDay)
  1128. {
  1129. spSelDayDuration = CXTPCalendarUtils::ResetTime(dtSelDay2) - CXTPCalendarUtils::ResetTime(dtSelDay);
  1130. if (bSelAllDay && spSelDayDuration.GetTotalDays() >= 1)
  1131. {
  1132. spSelDayDuration -= COleDateTimeSpan(1, 0, 0, 0);
  1133. }
  1134. }
  1136. ptrSelEvents = pPrevView->GetSelectedEvents();
  1138. dtSelEvent.SetDate(9999, 1, 1);
  1139. int nCount = ptrSelEvents ? ptrSelEvents->GetCount() : 0;
  1140. for (int i = 0; i < nCount; i++)
  1141. {
  1142. COleDateTime dtEvent = XTP_SAFE_GET3(ptrSelEvents, GetAt(i), GetEvent(), GetStartTime(), (DATE)0);
  1143. dtSelEvent = min(dtSelEvent, dtEvent);
  1144. }
  1146. dtSelStartDate = nCount ? dtSelEvent : (bSelDay ? dtSelDay : COleDateTime::GetCurrentTime());
  1147. }
  1149. COleDateTime dtWDStartTime = XTP_SAFE_GET1(GetCalendarOptions(), dtWorkDayStartTime, (DATE)0);
  1151. if (eViewType == xtpCalendarDayView)
  1152. {
  1153. SetActiveView(GetDayView());
  1155. CXTPCalendarDayView* pDayView = DYNAMIC_DOWNCAST(CXTPCalendarDayView, GetDayView());
  1156. if (!pDayView)
  1157. {
  1158. return;
  1159. }
  1161. pDayView->ResetSelection();
  1162. pDayView->ShowDay(dtSelStartDate);
  1164. COleDateTime dtSelBegin = CXTPCalendarUtils::UpdateTime(dtSelStartDate, dtWDStartTime);
  1165. COleDateTime dtSelEnd = dtSelBegin + pDayView->GetCellDuration();
  1167. pDayView->SetSelection(dtSelBegin, dtSelEnd, FALSE);
  1168. }
  1169. else if (eViewType == xtpCalendarWorkWeekView)
  1170. {
  1171. SetActiveView(GetDayView());
  1173. CXTPCalendarDayView* pDayView = DYNAMIC_DOWNCAST(CXTPCalendarDayView, GetDayView());
  1174. if (!pDayView)
  1175. {
  1176. return;
  1177. }
  1179. pDayView->ShowWorkingDays(dtSelStartDate);
  1180. pDayView->ResetSelection();
  1182. COleDateTime dtSelBegin = CXTPCalendarUtils::UpdateTime(pDayView->GetViewDayDate(0), dtWDStartTime);
  1183. COleDateTime dtSelEnd = dtSelBegin + pDayView->GetCellDuration();
  1185. pDayView->SetSelection(dtSelBegin, dtSelEnd, FALSE);
  1186. }
  1187. else if (eViewType == xtpCalendarFullWeekView)
  1188. {
  1189. SetActiveView(GetDayView());
  1191. CXTPCalendarDayView* pDayView = DYNAMIC_DOWNCAST(CXTPCalendarDayView, GetDayView());
  1192. if (!pDayView)
  1193. {
  1194. return;
  1195. }
  1197. COleDateTime dtWeekDay(dtSelStartDate);
  1198. int nFirstWeekDay = GetFirstDayOfWeek();
  1199. // adjust beginning of the week iteration period to the FirstDayOfWeek
  1200. while (dtWeekDay.GetDayOfWeek() != nFirstWeekDay)
  1201. dtWeekDay -= COleDateTimeSpan(1);
  1203. pDayView->ShowDays(dtWeekDay, dtWeekDay + COleDateTimeSpan(6));
  1204. pDayView->ResetSelection();
  1206. COleDateTime dtSelBegin = CXTPCalendarUtils::UpdateTime(pDayView->GetViewDayDate(0), dtWDStartTime);
  1207. COleDateTime dtSelEnd = dtSelBegin + pDayView->GetCellDuration();
  1209. pDayView->SetSelection(dtSelBegin, dtSelEnd, FALSE);
  1210. }
  1211. else if (eViewType == xtpCalendarWeekView)
  1212. {
  1213. SetActiveView(GetWeekView());
  1215. CXTPCalendarWeekView* pWeekView = DYNAMIC_DOWNCAST(CXTPCalendarWeekView, GetWeekView());
  1216. if (!pWeekView)
  1217. {
  1218. return;
  1219. }
  1221. pWeekView->ResetSelection();
  1222. pWeekView->ShowDay(dtSelStartDate);
  1224. COleDateTime dtSel = CXTPCalendarUtils::ResetTime(dtSelStartDate);
  1225. COleDateTime dtSel2 = dtSel + spSelDayDuration;
  1227. pWeekView->SetSelection(dtSel, dtSel2, TRUE);
  1228. }
  1229. else if (eViewType == xtpCalendarMonthView)
  1230. {
  1231. SetActiveView(GetMonthView());
  1233. CXTPCalendarMonthView* pMonthView = DYNAMIC_DOWNCAST(CXTPCalendarMonthView, GetMonthView());
  1234. if (!pMonthView || !pMonthView->GetGrid())
  1235. {
  1236. return;
  1237. }
  1238. COleDateTime dtFirstOfMonth(dtSelStartDate.GetYear(), dtSelStartDate.GetMonth(), 1, 0, 0, 0);
  1240. pMonthView->ResetSelection();
  1241. pMonthView->ShowDay(dtFirstOfMonth);
  1243. int nWCount = pMonthView->GetGrid()->GetWeeksCount();
  1244. if (nWCount < 5)
  1245. {
  1246. pMonthView->GetGrid()->SetWeeksCount(5);
  1247. }
  1249. COleDateTime dtMaxDate = pMonthView->GetViewDayDate(pMonthView->GetViewDayCount()-1);
  1251. COleDateTime dtSel = CXTPCalendarUtils::ResetTime(dtSelStartDate);
  1252. if (dtSel > dtMaxDate)
  1253. {
  1254. dtSel = pMonthView->GetViewDayDate(0);
  1255. }
  1256. COleDateTime dtSel2 = dtSel + spSelDayDuration;
  1258. pMonthView->SetSelection(dtSel, dtSel2, TRUE);
  1259. }
  1260. else
  1261. {
  1262. ASSERT(FALSE);
  1263. return;
  1264. }
  1266. CXTPCalendarView* pActiveView = GetActiveView();
  1267. if (pActiveView)
  1268. {
  1269. pActiveView->UnselectAllEvents();
  1270. }
  1272. //------------------------------------------------------------------------
  1273. Populate();
  1275. if (::IsWindow(GetSafeHwnd()) && IsWindowVisible())
  1276. {
  1277. AdjustScrollBar();
  1278. }
  1279. //------------------------------------------------------------------------
  1280. if (pActiveView && ptrSelEvents)
  1281. {
  1282. int nCount = ptrSelEvents->GetCount();
  1283. for (int i = 0; i < nCount; i++)
  1284. {
  1285. if (ptrSelEvents->GetAt(i))
  1286. {
  1287. pActiveView->SelectEvent(ptrSelEvents->GetAt(i)->GetEvent());
  1288. }
  1289. }
  1290. }
  1291. }
  1293. UINT CXTPCalendarControl::SetTimer(UINT uTimeOut_ms)
  1294. {
  1295. UINT uTimerID = m_uNextTimerID;
  1297. if (!::IsWindow(GetSafeHwnd()))
  1298. return 0;
  1300. UINT nRes = (UINT)CWnd::SetTimer(uTimerID, uTimeOut_ms, NULL);
  1302. if (!nRes)
  1303. {
  1304. ASSERT(FALSE);
  1305. return 0;
  1306. }
  1307. m_uNextTimerID++;
  1309. if (m_uNextTimerID < XTP_CALENDAR_FIRST_DYN_TIMERID)
  1310. {
  1311. m_uNextTimerID = XTP_CALENDAR_FIRST_DYN_TIMERID;
  1312. }
  1314. return uTimerID;
  1315. }
  1317. void CXTPCalendarControl::OnTimer(UINT_PTR uTimerID)
  1318. {
  1319. ASSERT(m_pActiveView);
  1321. if (uTimerID == m_uPopulateRequest_TimerID)
  1322. {
  1323. KillTimer(m_uPopulateRequest_TimerID);
  1324. m_uPopulateRequest_TimerID = 0;
  1326. Populate();
  1328. return;
  1329. }
  1330. else if (uTimerID == m_uRedrawRequest_TimerID)
  1331. {
  1332. KillTimer(m_uRedrawRequest_TimerID);
  1333. m_uRedrawRequest_TimerID = 0;
  1335. CUpdateContext updateContext(this, xtpCalendarUpdateRedraw);
  1337. return;
  1338. }
  1339. else if (uTimerID == XTP_CALENDAR_REFRESHMETRICS_REQUEST_TIMERID)
  1340. {
  1341. KillTimer(XTP_CALENDAR_REFRESHMETRICS_REQUEST_TIMERID);
  1343. CUpdateContext updateContext(this, xtpCalendarUpdateAll);
  1345. if (GetTheme())
  1346. {
  1347. GetTheme()->RefreshMetrics();
  1348. }
  1349. else if (m_pPaintManager)
  1350. {
  1351. m_pPaintManager->RefreshMetrics();
  1352. }
  1353. return;
  1354. }
  1357. if (m_pActiveView)
  1358. {
  1359. m_pActiveView->OnTimer(uTimerID);
  1360. DBG_TRACE_TIMER(_T("on Timer: ID=%d  n"), uTimerID);
  1361. }
  1362. }
  1364. void CXTPCalendarControl::OnOptionsChanged(int nOptionRelation)
  1365. {
  1366. SendNotification(XTP_NC_CALENDAROPTIONSWASCHANGED, nOptionRelation, 0);
  1368. KillTimer(XTP_CALENDAR_REFRESHMETRICS_REQUEST_TIMERID);
  1369. CWnd::SetTimer(XTP_CALENDAR_REFRESHMETRICS_REQUEST_TIMERID, XTP_CALENDAR_REFRESHMETRICS_REQUEST_TIMEOUT, NULL);
  1370. }
  1372. ///////////////////////////////////////////////////////////////////////////
  1373. // Data part
  1374. //
  1376. CString CXTPCalendarControl::DataSourceFromConStr(LPCTSTR lpszConnectionString)
  1377. {
  1378. ASSERT(lpszConnectionString);
  1380. if (!lpszConnectionString || 0 == _tcslen(lpszConnectionString))
  1381. {
  1382. return _T("");
  1383. }
  1385. CString strConnStr_lower = lpszConnectionString;
  1386. strConnStr_lower.MakeLower();
  1388. int nIndex = strConnStr_lower.Find(_T("data source="));
  1389. if (nIndex != -1)
  1390. {
  1391. CString strDataSource = strConnStr_lower.Mid(nIndex + 12);
  1392. if (strDataSource.IsEmpty())
  1393. return _T("");
  1395. if ((strDataSource[0] == _T(''') || strDataSource[0] == _T('"')) && strDataSource.GetLength() > 2)
  1396. {
  1397. TCHAR chQuot = strDataSource[0];
  1399. DELETE_S(strDataSource, 0);
  1401. int nQuot2Idx = FIND_S(strDataSource, chQuot, 0);
  1403. if (nQuot2Idx >= 0)
  1404. {
  1405. DELETE_S(strDataSource, nQuot2Idx, strDataSource.GetLength() - nQuot2Idx);
  1406. }
  1407. }
  1409. return strDataSource;
  1410. }
  1412. return strConnStr_lower;
  1413. }
  1415. XTPCalendarDataProvider CXTPCalendarControl::DataProviderTypeFromConStr(
  1416. LPCTSTR lpszConnectionString,
  1417. XTPCalendarDataProvider eDPDefault)
  1418. {
  1419. ASSERT(lpszConnectionString);
  1421. if (!lpszConnectionString)
  1422. {
  1423. return eDPDefault;
  1424. }
  1426. CString strConnStr_lower(lpszConnectionString);
  1427. strConnStr_lower.MakeLower();
  1429. BOOL bProviderCustom = strConnStr_lower.Find(_T("provider=custom")) != -1;
  1430. if (bProviderCustom)
  1431. {
  1432. return xtpCalendarDataProviderCustom;
  1433. }
  1435. BOOL bProviderMAPI   = strConnStr_lower.Find(_T("provider=mapi"))   != -1;
  1436. if (bProviderMAPI)
  1437. {
  1438. return xtpCalendarDataProviderMAPI;
  1439. }
  1441. BOOL bProviderXML   = strConnStr_lower.Find(_T("provider=xml")) != -1;
  1442. if (bProviderXML)
  1443. {
  1444. return xtpCalendarDataProviderMemory;
  1445. }
  1447. BOOL bProvider = strConnStr_lower.Find(_T("provider=")) != -1;
  1448. BOOL bDSN      = strConnStr_lower.Find(_T("dsn="))      != -1;
  1449. if (bProvider || bDSN)
  1450. {
  1451. return xtpCalendarDataProviderDatabase;
  1452. }
  1454. return eDPDefault;
  1455. }
  1457. CXTPCalendarData* CXTPCalendarControl::CreateDataProvider(LPCTSTR lpszConnectionString)
  1458. {
  1459. ASSERT(lpszConnectionString);
  1461. if (!lpszConnectionString)
  1462. {
  1463. return NULL;
  1464. }
  1466. XTPCalendarDataProvider eDPType = DataProviderTypeFromConStr(lpszConnectionString, xtpCalendarDataProviderMemory);
  1468. CXTPCalendarData* pDataProvider = CreateDataProvider(eDPType);
  1470. if (pDataProvider)
  1471. {
  1472. pDataProvider->SetConnectionString(lpszConnectionString);
  1473. }
  1474. return pDataProvider;
  1475. }
  1477. CXTPCalendarData* CXTPCalendarControl::CreateDataProvider(XTPCalendarDataProvider eDataProvider)
  1478. {
  1479. CXTPCalendarData* pDataProvider = NULL;
  1480. switch (eDataProvider)
  1481. {
  1482. case xtpCalendarDataProviderMemory:
  1483. pDataProvider = new CXTPCalendarMemoryDataProvider();
  1484. break;
  1485. case xtpCalendarDataProviderDatabase:
  1486. pDataProvider = new CXTPCalendarDatabaseDataProvider();
  1487. break;
  1488. case xtpCalendarDataProviderMAPI:
  1489. pDataProvider = new CXTPCalendarMAPIDataProvider();
  1490. break;
  1491. case xtpCalendarDataProviderCustom:
  1492. pDataProvider = new CXTPCalendarCustomDataProvider();
  1493. break;
  1494. default:
  1495. ASSERT(FALSE);
  1496. }
  1498. return pDataProvider;
  1499. }
  1501. void CXTPCalendarControl::_SetDataProvider(CXTPCalendarData* pDataProvider,
  1502.   BOOL bCloseDataProviderWhenDestroy)
  1503. {
  1504. if (m_pRemindersManager)
  1505. {
  1506. VERIFY( m_pRemindersManager->StopMonitoring() );
  1507. }
  1509. CMDTARGET_ADDREF(pDataProvider);
  1511. if (m_pOptions)
  1512. {
  1513. m_pOptions->SetDataProvider(pDataProvider);
  1514. }
  1516. // set current DP
  1517. if (m_pResourcesNf)
  1518. {
  1519. m_pResourcesNf->RemoveAll();
  1521. CXTPCalendarResource* pRC = new CXTPCalendarResource(this);
  1522. if (pRC)
  1523. {
  1524. m_pResourcesNf->Add(pRC);
  1525. pRC->SetDataProvider(pDataProvider, bCloseDataProviderWhenDestroy);
  1526. }
  1527. }
  1528. CMDTARGET_RELEASE(pDataProvider);
  1529. }
  1531. void CXTPCalendarControl::SetDataProvider(CXTPCalendarData* pDataProvider,
  1532.   BOOL bCloseDataProviderWhenDestroy)
  1533. {
  1534. _SetDataProvider(pDataProvider, bCloseDataProviderWhenDestroy);
  1536. AdviseToDataProvider();
  1537. }
  1539. void CXTPCalendarControl::SetDataProvider(LPCTSTR lpszConnectionString)
  1540. {
  1541. ASSERT(lpszConnectionString);
  1542. if (!lpszConnectionString)
  1543. {
  1544. return;
  1545. }
  1547. CXTPCalendarData* pDataProvider = CreateDataProvider(lpszConnectionString);
  1548. if (pDataProvider)
  1549. {
  1550. _SetDataProvider(pDataProvider, TRUE);
  1551. CMDTARGET_RELEASE(pDataProvider);
  1552. }
  1553. AdviseToDataProvider();
  1554. }
  1556. void CXTPCalendarControl::SetDataProvider(
  1557. XTPCalendarDataProvider eDataProvider, LPCTSTR lpszConnectionString)
  1558. {
  1559. CXTPCalendarData* pDataProvider = CreateDataProvider(eDataProvider);
  1560. if (pDataProvider)
  1561. {
  1562. if (lpszConnectionString)
  1563. {
  1564. pDataProvider->SetConnectionString(lpszConnectionString);
  1565. }
  1566. if (eDataProvider == xtpCalendarDataProviderMemory && !lpszConnectionString)
  1567. {
  1568. VERIFY(pDataProvider->Open());
  1569. }
  1571. _SetDataProvider(pDataProvider, TRUE);
  1572. CMDTARGET_RELEASE(pDataProvider);
  1573. }
  1574. AdviseToDataProvider();
  1575. }
  1577. CXTPCalendarData* CXTPCalendarControl::GetDataProvider()
  1578. {
  1579. ASSERT(this);
  1581. if (this && m_pResourcesNf && m_pResourcesNf->GetCount() && m_pResourcesNf->GetAt(0))
  1582. {
  1583. return m_pResourcesNf->GetAt(0)->GetDataProvider();
  1584. }
  1585. return NULL;
  1586. }
  1588. CXTPCalendarResources* CXTPCalendarControl::GetResources()
  1589. {
  1590. ASSERT(this);
  1591. return this ? m_pResourcesNf : NULL;
  1592. }
  1594. void CXTPCalendarControl::SetResources(CXTPCalendarResources* pResources,
  1595.    CXTPCalendarData* pOptionsDataProvider)
  1596. {
  1597. if (!m_pResourcesNf || !pResources || pResources->GetCount() == 0)
  1598. {
  1599. ASSERT(FALSE);
  1600. return;
  1601. }
  1603. if (!pOptionsDataProvider)
  1604. {
  1605. pOptionsDataProvider = XTP_SAFE_GET2(pResources, GetAt(0), GetDataProvider(), NULL);
  1606. }
  1607. if (m_pOptions)
  1608. {
  1609. m_pOptions->SetDataProvider(pOptionsDataProvider);
  1610. }
  1612. // copy data to allow using self as input parameter
  1613. CXTPCalendarResources arRes;
  1614. arRes.Append(pResources);
  1616. m_pResourcesNf->RemoveAll();
  1617. m_pResourcesNf->Append(&arRes);
  1619. // reset view's configurations
  1620. XTP_SAFE_CALL1(m_pDayView,   SetResources(NULL));
  1621. XTP_SAFE_CALL1(m_pMonthView, SetResources(NULL));
  1622. XTP_SAFE_CALL1(m_pWeekView,  SetResources(NULL));
  1624. AdviseToDataProvider();
  1625. }
  1628. void CXTPCalendarControl::AdviseToDataProvider()
  1629. {
  1630. m_Sink_DP.UnadviseAll();
  1631. m_cnidOnReminders = 0;
  1633. if (m_pResourcesNf)
  1634. {
  1635. CXTPNotifyConnection* pDPConn = m_pResourcesNf->GetConnection();
  1636. ASSERT(pDPConn);
  1637. if (pDPConn)
  1638. {
  1639. m_Sink_DP.Advise(pDPConn, XTP_NC_CALENDAROPTIONSWASCHANGED, &CXTPCalendarControl::OnEvent_FromDataProvider);
  1641. m_Sink_DP.Advise(pDPConn, XTP_NC_CALENDAREVENTWASADDED, &CXTPCalendarControl::OnEvent_FromDataProvider);
  1642. m_Sink_DP.Advise(pDPConn, XTP_NC_CALENDAREVENTWASDELETED, &CXTPCalendarControl::OnEvent_FromDataProvider);
  1643. m_Sink_DP.Advise(pDPConn, XTP_NC_CALENDAREVENTWASCHANGED, &CXTPCalendarControl::OnEvent_FromDataProvider);
  1644. m_Sink_DP.Advise(pDPConn, XTP_NC_CALENDARPATTERNWASADDED, &CXTPCalendarControl::OnEvent_FromDataProvider);
  1645. m_Sink_DP.Advise(pDPConn, XTP_NC_CALENDARPATTERNWASDELETED, &CXTPCalendarControl::OnEvent_FromDataProvider);
  1646. m_Sink_DP.Advise(pDPConn, XTP_NC_CALENDARPATTERNWASCHANGED, &CXTPCalendarControl::OnEvent_FromDataProvider);
  1648. m_Sink_DP.Advise(pDPConn, XTP_NC_CALENDAR_DoRetrieveDayEvents, &CXTPCalendarControl::OnEvent_FromDataProvider);
  1649. m_Sink_DP.Advise(pDPConn, XTP_NC_CALENDAR_DoRemoveAllEvents, &CXTPCalendarControl::OnEvent_FromDataProvider);
  1650. m_Sink_DP.Advise(pDPConn, XTP_NC_CALENDAR_DoRead_Event, &CXTPCalendarControl::OnEvent_FromDataProvider);
  1651. m_Sink_DP.Advise(pDPConn, XTP_NC_CALENDAR_DoRead_RPattern, &CXTPCalendarControl::OnEvent_FromDataProvider);
  1652. m_Sink_DP.Advise(pDPConn, XTP_NC_CALENDAR_DoCreate_Event, &CXTPCalendarControl::OnEvent_FromDataProvider);
  1653. m_Sink_DP.Advise(pDPConn, XTP_NC_CALENDAR_DoUpdate_Event, &CXTPCalendarControl::OnEvent_FromDataProvider);
  1654. m_Sink_DP.Advise(pDPConn, XTP_NC_CALENDAR_DoDelete_Event, &CXTPCalendarControl::OnEvent_FromDataProvider);
  1655. m_Sink_DP.Advise(pDPConn, XTP_NC_CALENDAR_DoCreate_RPattern, &CXTPCalendarControl::OnEvent_FromDataProvider);
  1656. m_Sink_DP.Advise(pDPConn, XTP_NC_CALENDAR_DoUpdate_RPattern, &CXTPCalendarControl::OnEvent_FromDataProvider);
  1657. m_Sink_DP.Advise(pDPConn, XTP_NC_CALENDAR_DoDelete_RPattern, &CXTPCalendarControl::OnEvent_FromDataProvider);
  1658. m_Sink_DP.Advise(pDPConn, XTP_NC_CALENDAR_DoGetAllEvents_raw, &CXTPCalendarControl::OnEvent_FromDataProvider);
  1659. m_Sink_DP.Advise(pDPConn, XTP_NC_CALENDAR_DoGetUpcomingEvents, &CXTPCalendarControl::OnEvent_FromDataProvider);
  1660. }
  1661. m_pResourcesNf->ReBuildInternalData();
  1662. }
  1664. _AdviseToReminders_StartMonitoring();
  1666. SendNotification(XTP_NC_CALENDAR_RESOURCES_WHERE_CHANGED, 0, 0);
  1667. }
  1669. //////////////////////////////////////////////////////////////////////////
  1670. // Reminders
  1672. BOOL CXTPCalendarControl::IsRemindersEnabled() const
  1673. {
  1674. return m_pRemindersManager != NULL;
  1675. }
  1677. void CXTPCalendarControl::EnableReminders(BOOL bEnable)
  1678. {
  1680. if (bEnable && m_pRemindersManager)
  1681. {
  1682. // Already enabled. skip.
  1683. return;
  1684. }
  1686. if (!bEnable && !m_pRemindersManager)
  1687. {
  1688. // Already disabled. skip.
  1689. return;
  1690. }
  1692. // 1. Enable.
  1693. if (bEnable)
  1694. {
  1695. ASSERT(!m_pRemindersManager);
  1696. CMDTARGET_RELEASE(m_pRemindersManager);
  1698. m_pRemindersManager = new CXTPCalendarRemindersManager();
  1700. _AdviseToReminders_StartMonitoring();
  1701. }
  1703. // 2. Disable
  1704. if (!bEnable)
  1705. {
  1706. ASSERT(m_pRemindersManager);
  1707. if (m_pRemindersManager)
  1708. {
  1709. VERIFY( m_pRemindersManager->StopMonitoring() );
  1711. if (m_cnidOnReminders)
  1712. {
  1713. m_Sink_DP.Unadvise(m_cnidOnReminders);
  1714. m_cnidOnReminders = 0;
  1715. }
  1716. }
  1718. CMDTARGET_RELEASE(m_pRemindersManager);
  1719. }
  1720. }
  1722. void CXTPCalendarControl::_AdviseToReminders_StartMonitoring()
  1723. {
  1724. if (m_pRemindersManager && m_pResourcesNf)
  1725. {
  1726. CXTPNotifyConnection* pRMConn = m_pRemindersManager->GetConnection();
  1727. ASSERT(pRMConn);
  1728. if (pRMConn)
  1729. {
  1730. m_cnidOnReminders = m_Sink_DP.Advise(pRMConn, XTP_NC_CALENDAR_ON_REMINDERS, &CXTPCalendarControl::OnEvent_Reminders);
  1731. ASSERT(m_cnidOnReminders);
  1733. VERIFY(m_pRemindersManager->StartMonitoring(m_pResourcesNf,
  1734. m_spRemindersUpdatePeriod) );
  1735. }
  1736. }
  1737. }
  1739. void CXTPCalendarControl::EnableMarkup(BOOL bEnableMarkup)
  1740. {
  1741. if (IsMarkupEnabled() == bEnableMarkup)
  1742. return;
  1745. if (!bEnableMarkup)
  1746. {
  1747. CXTPMarkupContext* pStoredContext = m_pMarkupContext;
  1749. // to disable markup
  1750. m_pMarkupContext = NULL;
  1752. // to destroy all cached markup elements
  1753. Populate();
  1755. XTPMarkupReleaseContext(pStoredContext);
  1756. }
  1757. else
  1758. {
  1759. ASSERT(IsWindow(m_hWnd));
  1760. m_pMarkupContext = XTPMarkupCreateContext(m_hWnd);
  1761. }
  1763. RedrawControl(FALSE);
  1764. }
  1766. void CXTPCalendarControl::OnEnable(BOOL bEnable)
  1767. {
  1768. UNREFERENCED_PARAMETER(bEnable);
  1770. AdjustScrollBar();
  1771. }
  1773. UINT CXTPCalendarControl::OnGetDlgCode()
  1774. {
  1775. return DLGC_WANTARROWS | DLGC_WANTTAB | DLGC_WANTALLKEYS;
  1776. }
  1778. void CXTPCalendarControl::OnChar(UINT nChar, UINT nRepCnt, UINT nFlags)
  1779. {
  1780. CUpdateContext updateContext(this, xtpCalendarUpdateRedrawIfNeed);
  1781. CViewChangedContext viewChanged(this, xtpCalendarViewChangedLock);
  1783. if (m_pActiveView)
  1784. {
  1785. m_pActiveView->OnChar(nChar, nRepCnt, nFlags);
  1786. }
  1787. }
  1789. void CXTPCalendarControl::OnKeyDown(UINT nChar, UINT nRepCnt, UINT nFlags)
  1790. {
  1791. CXTPSmartPtrInternalT<CCmdTarget> ptrThisLock(this, TRUE);
  1793. CUpdateContext updateContext(this, xtpCalendarUpdateRedrawIfNeed);
  1794. CViewChangedContext viewChanged(this, xtpCalendarViewChangedLock);
  1796. #ifdef XTP_CALENDAR_SITENOTIFY_KEY
  1797. if (!XTP_CALENDAR_SITENOTIFY_KEY(this, TRUE, nChar))
  1798. return;
  1799. #endif
  1801. if (nChar == 0)
  1802. {
  1803. return;
  1804. }
  1806. SendNotification(XTP_NC_CALENDARKEYDOWN, (DWORD)nChar, 0);
  1808. if (m_pActiveView)
  1809. {
  1810. m_pActiveView->OnKeyDown(nChar, nRepCnt, nFlags);
  1811. }
  1812. }
  1814. void CXTPCalendarControl::OnSysKeyDown(UINT nChar, UINT nRepCnt, UINT nFlags)
  1815. {
  1816. CXTPSmartPtrInternalT<CCmdTarget> ptrThisLock(this, TRUE);
  1818. #ifdef XTP_CALENDAR_SITENOTIFY_KEY
  1819. if (!XTP_CALENDAR_SITENOTIFY_KEY(this, TRUE, nChar))
  1820. return;
  1821. #endif
  1822. if (nChar == 0)
  1823. {
  1824. return;
  1825. }
  1827. if (m_pActiveView)
  1828. {
  1829. if (m_pActiveView->OnSysKeyDown(nChar, nRepCnt, nFlags))
  1830. {
  1831. return;
  1832. }
  1833. }
  1835. CWnd::OnSysKeyDown(nChar, nRepCnt, nFlags);
  1836. }
  1838. BOOL CXTPCalendarControl::OnWndMsg_Children(UINT message, WPARAM wParam, LPARAM lParam,
  1839. LRESULT* /*pResult*/)
  1840. {
  1841. ASSERT(m_pActiveView);
  1842. if (!m_pActiveView)
  1843. return FALSE;
  1845. if (message == WM_KEYDOWN)
  1846. {
  1847. UINT uRepCnt = LOWORD(lParam);
  1848. UINT uFlags = HIWORD(lParam);
  1850. if (wParam == VK_RETURN || wParam == VK_ESCAPE)
  1851. {
  1852. OnKeyDown((UINT)wParam, uRepCnt, uFlags);
  1853. return TRUE;
  1854. }
  1856. BOOL bEditSubject = m_pActiveView->m_eDraggingMode == xtpCalendaDragModeEditSubject;
  1857. if (bEditSubject && wParam == VK_TAB)
  1858. {
  1859. OnKeyDown((UINT)wParam, uRepCnt, uFlags);
  1860. return TRUE;
  1861. }
  1862. }
  1863. else if (message == WM_MOUSEMOVE)
  1864. {
  1865. if (m_pActiveView->m_eDraggingMode == xtpCalendaDragModeEditSubject)
  1866. {
  1867. m_mouseMode = xtpCalendarMouseNothing;
  1868. m_pActiveView->OnMouseMove((UINT)wParam, CPoint(lParam));
  1869. }
  1870. }
  1872. return FALSE;
  1873. }
  1875. void CXTPCalendarControl::ShowToolTip(const CString& strText, const CRect rcToolTip,
  1876.   CFont* pFont, BOOL bAdvanced)
  1877. {
  1878. if (!m_bEnableToolTips || GetSafeHwnd() == NULL)
  1879. {
  1880. return;
  1881. }
  1883. if (!m_wndTip.GetSafeHwnd())
  1884. {
  1885. m_wndTip.Create(this);
  1886. }
  1888. m_wndTip.SetTheme(GetTheme());
  1889. m_wndTip.SetFont(pFont);
  1890. m_wndTip.SetTooltipText(strText);
  1893. CRect rcTip(rcToolTip);
  1894. if (!bAdvanced)
  1895. {
  1896. rcTip.OffsetRect(7, 0);
  1898. CSize rcNeeded = m_wndTip.CalcToolTipRect();
  1899. rcTip.right = rcTip.left + rcNeeded.cx;
  1900. rcTip.bottom = rcTip.top + rcNeeded.cy;
  1901. }
  1902. else
  1903. {
  1904. rcTip.DeflateRect(0, 0, 7, 0);
  1905. }
  1907. ClientToScreen(rcTip);
  1909. m_wndTip.SetHoverRect(rcTip);
  1911. BOOL bShow = !strText.IsEmpty();
  1912. m_wndTip.Activate(bShow, bAdvanced);
  1914. TRACKMOUSEEVENT tme =
  1915. {
  1916. sizeof(TRACKMOUSEEVENT), TME_LEAVE, GetSafeHwnd(), 0
  1917. };
  1918. _TrackMouseEvent (&tme);
  1919. }
  1921. void CXTPCalendarControl::HideToolTip()
  1922. {
  1923. if (!GetSafeHwnd() || !m_wndTip.GetSafeHwnd())
  1924. {
  1925. return;
  1926. }
  1928. m_wndTip.Activate(FALSE);
  1929. }
  1931. BOOL CXTPCalendarControl::IsToolTipVisible() const
  1932. {
  1933. return (m_wndTip.GetSafeHwnd() != NULL) && m_wndTip.IsWindowVisible();
  1934. }
  1936. void CXTPCalendarControl::SetPaintManager(CXTPCalendarPaintManager* pPaintManager)
  1937. {
  1938. ASSERT(pPaintManager);
  1940. CUpdateContext updateContext(this, xtpCalendarUpdateRedraw);
  1941. CMDTARGET_RELEASE(m_pPaintManager);
  1942. m_pPaintManager = pPaintManager;
  1943. }
  1945. void CXTPCalendarControl::OnSysColorChange()
  1946. {
  1947. CUpdateContext updateContext(this, xtpCalendarUpdateRedraw);
  1949. if (m_pPaintManager)
  1950. {
  1951. m_pPaintManager->RefreshMetrics();
  1952. }
  1954. if (GetTheme())
  1955. {
  1956. GetTheme()->RefreshMetrics();
  1957. }
  1959. AdjustLayout();
  1961. CWnd::OnSysColorChange();
  1962. }
  1964. LRESULT CXTPCalendarControl::OnTimeZoneChanged(WPARAM, LPARAM)
  1965. {
  1966. if (!m_pResourcesNf)
  1967. return 0;
  1969. CXTPCalendarResources* pResByDP = m_pResourcesNf->GetResourcesGroupedByDP();
  1970. ASSERT(pResByDP);
  1971. if (!pResByDP)
  1972. return 0;
  1974. BOOL bDataChanged = FALSE;
  1975. int nCount = pResByDP->GetCount();
  1976. for (int i = 0; i < nCount; i++)
  1977. {
  1978. CXTPCalendarResource* pRC = pResByDP->GetAt(i);
  1979. ASSERT(pRC);
  1980. if (pRC && pRC->GetDataProvider())
  1981. {
  1982. BOOL bChanged = pRC->GetDataProvider()->OnTimeZoneChanged();
  1983. bDataChanged |= bChanged;
  1984. }
  1985. }
  1987. if (bDataChanged)
  1988. {
  1989. CUpdateContext updateContext(this, xtpCalendarUpdateAll);
  1991. AdviseToDataProvider();
  1993. Populate();
  1994. }
  1996. return 0;
  1997. }
  1999. void CXTPCalendarControl::OnTimeChange()
  2000. {
  2001. CUpdateContext updateContext(this, xtpCalendarUpdateAll);
  2002. CWnd::OnTimeChange();
  2003. }
  2005. void CXTPCalendarControl::OnEditCommand(UINT uCommandID)
  2006. {
  2007. if (uCommandID == ID_EDIT_UNDO)
  2008. {
  2009. OnUndo();
  2010. }
  2011. else if (uCommandID == ID_EDIT_CUT)
  2012. {
  2013. OnCut();
  2014. }
  2015. else if (uCommandID == ID_EDIT_COPY)
  2016. {
  2017. OnCopy();
  2018. }
  2019. else if (uCommandID == ID_EDIT_PASTE)
  2020. {
  2021. OnPaste();
  2022. }
  2023. }
  2026. void CXTPCalendarControl::OnUndo()
  2027. {
  2028. if (m_pActiveView)
  2029. {
  2030. if (m_pActiveView->CanUndo())
  2031. {
  2032. m_pActiveView->Undo();
  2033. }
  2034. else if (m_pActiveView->CanRedo())
  2035. {
  2036. m_pActiveView->Redo();
  2037. }
  2038. }
  2039. }
  2041. void CXTPCalendarControl::OnCut()
  2042. {
  2043. if (m_pActiveView)
  2044. {
  2045. CWaitCursor _WC;
  2046. m_pActiveView->Cut();
  2047. }
  2048. }
  2050. void CXTPCalendarControl::OnCopy()
  2051. {
  2052. if (m_pActiveView)
  2053. {
  2054. CWaitCursor _WC;
  2055. m_pActiveView->Copy();
  2056. }
  2057. }
  2059. void CXTPCalendarControl::OnPaste()
  2060. {
  2061. if (m_pActiveView)
  2062. {
  2063. CWaitCursor _WC;
  2064. m_pActiveView->Paste();
  2065. }
  2066. }
  2067. void CXTPCalendarControl::OnUpdateCmdUI(CCmdUI* pCmdUI)
  2068. {
  2069. if (pCmdUI->m_nID == ID_EDIT_UNDO)
  2070. {
  2071. OnUpdateUndo(pCmdUI);
  2072. }
  2073. else if (pCmdUI->m_nID == ID_EDIT_CUT)
  2074. {
  2075. OnUpdateCut(pCmdUI);
  2076. }
  2077. else if (pCmdUI->m_nID == ID_EDIT_COPY)
  2078. {
  2079. OnUpdateCopy(pCmdUI);
  2080. }
  2081. else if (pCmdUI->m_nID == ID_EDIT_PASTE)
  2082. {
  2083. OnUpdatePaste(pCmdUI);
  2084. }
  2085. }
  2087. void CXTPCalendarControl::OnUpdateUndo(CCmdUI* pCmdUI)
  2088. {
  2089. if (pCmdUI->m_nID != ID_EDIT_UNDO || !m_pActiveView)
  2090. {
  2091. ASSERT(FALSE);
  2092. return;
  2093. }
  2095. if (m_pActiveView->CanUndo())
  2096. {
  2097. pCmdUI->Enable(TRUE);
  2098. pCmdUI->SetText(m_strUndoUIText);
  2099. }
  2100. else if (m_pActiveView->CanRedo())
  2101. {
  2102. pCmdUI->Enable(TRUE);
  2103. pCmdUI->SetText(m_strRedoUIText);
  2104. }
  2105. else
  2106. {
  2107. pCmdUI->Enable(FALSE);
  2108. pCmdUI->SetText(m_strUndoUIText);
  2109. }
  2110. }
  2112. void CXTPCalendarControl::OnUpdateCut(CCmdUI* pCmdUI)
  2113. {
  2114. if (pCmdUI->m_nID != ID_EDIT_CUT || !m_pActiveView)
  2115. {
  2116. ASSERT(FALSE);
  2117. return;
  2118. }
  2119. pCmdUI->Enable(m_pActiveView->CanCut());
  2120. }
  2122. void CXTPCalendarControl::OnUpdateCopy(CCmdUI* pCmdUI)
  2123. {
  2124. if (pCmdUI->m_nID != ID_EDIT_COPY || !m_pActiveView)
  2125. {
  2126. ASSERT(FALSE);
  2127. return;
  2128. }
  2129. pCmdUI->Enable(m_pActiveView->CanCopy());
  2130. }
  2131. void CXTPCalendarControl::OnUpdatePaste(CCmdUI* pCmdUI)
  2132. {
  2133. if (pCmdUI->m_nID != ID_EDIT_PASTE || !m_pActiveView)
  2134. {
  2135. ASSERT(FALSE);
  2136. return;
  2137. }
  2138. pCmdUI->Enable(m_pActiveView->CanPaste());
  2139. }
  2141. void CXTPCalendarControl::OnContextMenu(CWnd* /*pWnd*/, CPoint pos)
  2142. {
  2143. if (m_mouseMode != xtpCalendarMouseNothing)
  2144. return;
  2146. CPoint ptClient = pos;
  2147. ScreenToClient(&ptClient);
  2149. // forward message to subscriber
  2150. DWORD dwPoint = MAKELONG(ptClient.x, ptClient.y);
  2151. SendNotification(XTP_NC_CALENDARCONTEXTMENU, dwPoint, 0);
  2152. }
  2154. LRESULT CXTPCalendarControl::OnUserAction(WPARAM dwParam1, LPARAM dwParam2)
  2155. {
  2156. int nButtonMask = xtpCalendarScrollDayButton_DayViewUp | xtpCalendarScrollDayButton_DayViewDown;
  2157. int eButton = (int)(dwParam1 & nButtonMask);
  2159. if ((dwParam1 & xtpCalendarUserAction_OnScrollDay) && eButton && m_pDayView)
  2160. {
  2161. CXTPCalendarDayViewDay* pDVday = m_pDayView->GetViewDay(HIWORD(dwParam2));
  2162. CXTPCalendarDayViewGroup* pDVGroup = pDVday ? pDVday->GetViewGroup(LOWORD(dwParam2)) : NULL;
  2163. ASSERT(pDVGroup);
  2164. if (!pDVGroup || pDVGroup->UserAction_OnScrollDay((XTPCalendarScrollDayButton)eButton))
  2165. return 0;
  2167. CXTPCalendarDayViewEvent* pEVFirst = NULL, *pEVLast = NULL;
  2168. pDVGroup->FindMinMaxGroupDayEvents(pEVFirst, pEVLast);
  2170. if (eButton == xtpCalendarScrollDayButton_DayViewUp)
  2171. {
  2172. ASSERT(pEVFirst);
  2173. if (pEVFirst)
  2174. m_pDayView->EnsureVisible(pEVFirst);
  2175. }
  2176. else if (eButton == xtpCalendarScrollDayButton_DayViewDown)
  2177. {
  2178. ASSERT(pEVLast);
  2179. if (pEVLast)
  2180. m_pDayView->EnsureVisible(pEVLast);
  2181. }
  2182. else {
  2183. ASSERT(FALSE);
  2184. }
  2185. }
  2186. else  if (dwParam1 & xtpCalendarUserAction_OnExpandDay)
  2187. {
  2188. COleDateTime dtDate = (DATE)(LONG)dwParam2;
  2190. nButtonMask = xtpCalendarExpandDayButton_WeekView | xtpCalendarExpandDayButton_MonthView;
  2191. eButton = (int)(dwParam1 & nButtonMask);
  2193. CXTPCalendarViewDay* pActiveDay = XTP_SAFE_GET1(GetActiveView(), _GetViewDay(dtDate), NULL);
  2194. ASSERT(pActiveDay);
  2195. if (!pActiveDay)
  2196. return 0;
  2198. if (pActiveDay->UserAction_OnExpandDay((XTPCalendarExpandDayButton)eButton))
  2199. return 0;
  2201. // default processing
  2202. SwitchActiveView(xtpCalendarDayView);
  2204. CXTPCalendarDayView* pDayView = DYNAMIC_DOWNCAST(CXTPCalendarDayView, GetActiveView());
  2205. if (pDayView)
  2206. {
  2207. pDayView->ResetSelection();
  2208. pDayView->ShowDay(dtDate);
  2209. }
  2210. }
  2211. return 0;
  2212. }
  2214. // for compatibility with previous versions
  2215. LRESULT CXTPCalendarControl::OnSwitchView(WPARAM nDate, LPARAM)
  2216. {
  2217. CXTPSmartPtrInternalT<CCmdTarget> ptrThisLock(this, TRUE);
  2219. SwitchActiveView(xtpCalendarDayView);
  2220. CXTPCalendarDayView* pDayView = DYNAMIC_DOWNCAST(CXTPCalendarDayView, m_pActiveView);
  2221. if (pDayView)
  2222. {
  2223. pDayView->ResetSelection();
  2224. pDayView->ShowDay(COleDateTime((DATE)nDate));
  2225. }
  2226. return 0;
  2227. }
  2229. // for compatibility with previous versions
  2230. void CXTPCalendarControl::QueueDayViewSwitch(DATE dtDate)
  2231. {
  2232. PostMessage(xtp_wm_SwitchView, (UINT)dtDate);
  2233. }
  2235. BOOL CXTPCalendarControl::DoDeleteSelectedEvents(CXTPCalendarViewEvent* pViewEvent)
  2236. {
  2237. CXTPCalendarView* pView = XTP_SAFE_GET3(pViewEvent, GetViewGroup_(), GetViewDay_(), GetView_(), NULL);
  2238. if (!pView)
  2239. {
  2240. ASSERT(FALSE);
  2241. return FALSE;
  2242. }
  2244. //------------------------------------------------------------------------
  2245. if (pView->IsEditingSubject())
  2246. {
  2247. pView->EndEditSubject(xtpCalendarEditSubjectCommit, FALSE);
  2248. }
  2250. //------------------------------------------------------------------------
  2251. CXTPCalendarViewEventsPtr ptrSelEventViews = pView->GetSelectedEvents();
  2252. BOOL bSelExist = ptrSelEventViews && ptrSelEventViews->GetCount();
  2253. BOOL bHandled = FALSE;
  2255. ASSERT(m_pActiveView == pView);
  2256. if (bSelExist && m_pActiveView)
  2257. {
  2258. bHandled = m_pActiveView->OnBeforeEditOperationNotify(xtpCalendarEO_DeleteSelectedEvents, ptrSelEventViews);
  2259. }
  2260. if (bHandled)
  2261. {
  2262. return TRUE;
  2263. }
  2264. //------------------------------------------------------------------------
  2265. if (!bSelExist)
  2266. {
  2267. return DoDeleteEvent(pViewEvent);
  2268. }
  2270. int nCount = ptrSelEventViews ? ptrSelEventViews->GetCount() : 0;
  2271. for (int i = 0; i < nCount; i++)
  2272. {
  2273. CXTPCalendarViewEvent* pEV = ptrSelEventViews->GetAt(i, FALSE);
  2275. if (!DoDeleteEvent(pEV))
  2276. {
  2277. return FALSE;
  2278. }
  2279. }
  2280. return TRUE;
  2281. }
  2283. BOOL CXTPCalendarControl::DoDeleteEvent(CXTPCalendarViewEvent* pViewEvent)
  2284. {
  2285. CXTPCalendarView* pView = XTP_SAFE_GET3(pViewEvent, GetViewGroup_(), GetViewDay_(), GetView_(), m_pActiveView);
  2286. if (!pView)
  2287. {
  2288. ASSERT(FALSE);
  2289. return FALSE;
  2290. }
  2292. CXTPCalendarEvent* pEvent = pViewEvent ? pViewEvent->GetEvent() : NULL;
  2293. CXTPCalendarData* pData = pEvent ? pEvent->GetDataProvider() : NULL;
  2294. if (!pEvent || !pData)
  2295. {
  2296. ASSERT(FALSE);
  2297. return FALSE;
  2298. }
  2300. //------------------------------------------------------------------------
  2301. if (pView->IsEditingSubject())
  2302. {
  2303. pView->EndEditSubject(xtpCalendarEditSubjectCommit, FALSE);
  2304. }
  2306. //- Check is Event Still Exist -------------------------------------------
  2307. if (!::IsEventExists(pData, pEvent))
  2308. {
  2309. return TRUE;
  2310. }
  2312. //------------------------------------------------------------------------
  2313. BOOL bHandled = FALSE;
  2314. if (m_pActiveView)
  2315. {
  2316. bHandled = m_pActiveView->OnBeforeEditOperationNotify(xtpCalendarEO_DeleteEvent, pViewEvent);
  2317. }
  2319. if (bHandled)
  2320. {
  2321. return TRUE;
  2322. }
  2324. //------------------------------------------------------------------------
  2325. CXTPAutoResetValue<BOOL> autoSet_UpdateCtrlNf(m_bUpdateWhenEventChangedNotify);
  2326. autoSet_UpdateCtrlNf = FALSE;
  2328. //------------------------------------------------------------------------
  2329. if (pEvent->GetRecurrenceState() != xtpCalendarRecurrenceNotRecurring)
  2330. {
  2331. CXTPCalendarOccurSeriesChooseDlg dlgOccSer(this, XTP_IDS_CALENDAR_OCURR_SERIES_DELETE);
  2332. dlgOccSer.SetEvent(pEvent);
  2334. if (dlgOccSer.DoModal() != IDOK)
  2335. {
  2336. return TRUE;
  2337. }
  2339. if (!dlgOccSer.m_bOccur)
  2340. {
  2341. // delete series
  2343. CXTPCalendarRecurrencePatternPtr ptrRecPatt = pEvent->GetRecurrencePattern();
  2345. if (!ptrRecPatt)
  2346. {
  2347. ASSERT(FALSE);
  2348. return FALSE;
  2349. }
  2350. CXTPCalendarEventPtr ptrMasterEvent = ptrRecPatt->GetMasterEvent();
  2351. if (ptrMasterEvent)
  2352. {
  2353. return pData->DeleteEvent(ptrMasterEvent);
  2354. }
  2356. ASSERT(FALSE);
  2357. return FALSE;
  2358. }
  2359. }
  2361. return pData->DeleteEvent(pEvent);
  2362. }
  2364. void CXTPCalendarControl::OnSetFocus(CWnd* pOldWnd)
  2365. {
  2366. CXTPSmartPtrInternalT<CCmdTarget> ptrThisLock(this, TRUE);
  2368. CWnd::OnSetFocus(pOldWnd);
  2370. #ifdef XTP_CALENDAR_SITENOTIFY_ONFOCUS
  2371. XTP_CALENDAR_SITENOTIFY_ONFOCUS(this, this, TRUE)
  2372. #endif
  2373. }
  2375. void CXTPCalendarControl::OnKillFocus (CWnd* pNewWnd)
  2376. {
  2377. CXTPSmartPtrInternalT<CCmdTarget> ptrThisLock(this, TRUE);
  2379. CWnd::OnKillFocus(pNewWnd);
  2381. #ifdef XTP_CALENDAR_SITENOTIFY_ONFOCUS
  2382. XTP_CALENDAR_SITENOTIFY_ONFOCUS(this, this, FALSE)
  2383. #endif
  2384. }
  2386. void CXTPCalendarControl::SetTheme(CXTPCalendarTheme* pTheme)
  2387. {
  2388. if (m_pTheme)
  2389. {
  2390. m_pTheme->SetCalendarControl(NULL);
  2391. CMDTARGET_RELEASE(m_pTheme)
  2392. }
  2394. m_pTheme = pTheme;
  2396. if (m_pTheme)
  2397. {
  2398. m_pTheme->SetCalendarControl(this);
  2399. m_pTheme->RefreshMetrics();
  2400. }
  2401. else
  2402. {
  2403. XTP_SAFE_CALL1(GetPaintManager(), RefreshMetrics());
  2404. }
  2406. SendNotification(XTP_NC_CALENDAR_THEME_CHANGED, 0, 0);
  2407. }
  2409. CXTPCalendarOptions* CXTPCalendarControl::GetCalendarOptions() const
  2410. {
  2411. return m_pOptions;
  2412. }
  2414. // calendar settings
  2415. int CXTPCalendarControl::GetWorkWeekMask() const
  2416. {
  2417. CXTPCalendarOptions* pOpt = GetCalendarOptions();
  2418. ASSERT(pOpt);
  2419. if (pOpt)
  2420. {
  2421. return pOpt->nWorkWeekMask;
  2422. }
  2423. return xtpCalendarDayMo_Fr;
  2424. }
  2426. void CXTPCalendarControl::SetWorkWeekMask(const int nMask)
  2427. {
  2428. if (!nMask) // Invalid mask
  2429. return;
  2431. CXTPCalendarOptions* pOpt = GetCalendarOptions();
  2432. ASSERT(pOpt);
  2433. if (pOpt)
  2434. {
  2435. pOpt->nWorkWeekMask = nMask;
  2436. OnOptionsChanged((int)-1);
  2437. }
  2438. }
  2440. int CXTPCalendarControl::GetFirstDayOfWeek() const
  2441. {
  2442. CXTPCalendarOptions* pOpt = GetCalendarOptions();
  2443. ASSERT(pOpt);
  2444. if (pOpt)
  2445. {
  2446. int nFirstDayOfWeek = pOpt->nFirstDayOfTheWeek;
  2447. ASSERT(nFirstDayOfWeek >= 1 && nFirstDayOfWeek <= 7);
  2449. return max(min(7, nFirstDayOfWeek), 1);
  2450. }
  2451. return 1;
  2452. }
  2454. void CXTPCalendarControl::SetFirstDayOfWeek(const int nFirstDayOfWeek)
  2455. {
  2456. CXTPCalendarOptions* pOpt = GetCalendarOptions();
  2457. ASSERT(pOpt);
  2458. if (pOpt)
  2459. {
  2460. ASSERT(nFirstDayOfWeek >= 1 && nFirstDayOfWeek <= 7);
  2461. if (nFirstDayOfWeek >= 1 && nFirstDayOfWeek <= 7)
  2462. {
  2463. pOpt->nFirstDayOfTheWeek = nFirstDayOfWeek;
  2464. }
  2466. OnOptionsChanged((int)-1);
  2467. }
  2468. }
  2470. void CXTPCalendarControl::GetWorkDayStartTime(int& nHour, int& nMin, int& nSec)
  2471. {
  2472. CXTPCalendarOptions* pOpt = GetCalendarOptions();
  2473. ASSERT(pOpt);
  2474. if (pOpt)
  2475. {
  2476. nHour = pOpt->dtWorkDayStartTime.GetHour();
  2477. nMin = pOpt->dtWorkDayStartTime.GetMinute();
  2478. nSec = pOpt->dtWorkDayStartTime.GetSecond();
  2479. }
  2480. }
  2482. void CXTPCalendarControl::GetWorkDayStartTime(COleDateTime& dtTime)
  2483. {
  2484. CXTPCalendarOptions* pOpt = GetCalendarOptions();
  2485. ASSERT(pOpt);
  2486. if (pOpt)
  2487. {
  2488. dtTime = pOpt->dtWorkDayStartTime;
  2489. }
  2490. }
  2492. void CXTPCalendarControl::GetWorkDayEndTime(int& nHour, int& nMin, int& nSec)
  2493. {
  2494. CXTPCalendarOptions* pOpt = GetCalendarOptions();
  2495. ASSERT(pOpt);
  2496. if (pOpt)
  2497. {
  2498. nHour = pOpt->dtWorkDayEndTime.GetHour();
  2499. nMin = pOpt->dtWorkDayEndTime.GetMinute();
  2500. nSec = pOpt->dtWorkDayEndTime.GetSecond();
  2501. }
  2502. }
  2504. void CXTPCalendarControl::GetWorkDayEndTime(COleDateTime& dtTime)
  2505. {
  2506. CXTPCalendarOptions* pOpt = GetCalendarOptions();
  2507. ASSERT(pOpt);
  2508. if (pOpt)
  2509. {
  2510. dtTime = pOpt->dtWorkDayEndTime;
  2511. }
  2512. }
  2514. void CXTPCalendarControl::SetWorkDayStartTime(int nHour, int nMin, int nSec)
  2515. {
  2516. CXTPCalendarOptions* pOpt = GetCalendarOptions();
  2517. ASSERT(pOpt);
  2518. if (pOpt)
  2519. {
  2520. pOpt->dtWorkDayStartTime.SetTime(nHour, nMin, nSec);
  2522. OnOptionsChanged(xtpCalendarDayView);
  2523. }
  2524. }
  2526. void CXTPCalendarControl::SetWorkDayStartTime(const COleDateTime& dtTime)
  2527. {
  2528. CXTPCalendarOptions* pOpt = GetCalendarOptions();
  2529. ASSERT(pOpt);
  2530. if (pOpt)
  2531. {
  2532. pOpt->dtWorkDayStartTime = dtTime;
  2534. OnOptionsChanged(xtpCalendarDayView);
  2535. }
  2536. }
  2538. void CXTPCalendarControl::SetWorkDayEndTime(int nHour, int nMin, int nSec)
  2539. {
  2540. CXTPCalendarOptions* pOpt = GetCalendarOptions();
  2541. ASSERT(pOpt);
  2542. if (pOpt)
  2543. {
  2544. pOpt->dtWorkDayEndTime.SetTime(nHour, nMin, nSec);
  2546. OnOptionsChanged(xtpCalendarDayView);
  2547. }
  2548. }
  2550. void CXTPCalendarControl::SetWorkDayEndTime(const COleDateTime& dtTime)
  2551. {
  2552. CXTPCalendarOptions* pOpt = GetCalendarOptions();
  2553. ASSERT(pOpt);
  2554. if (pOpt)
  2555. {
  2556. pOpt->dtWorkDayEndTime = dtTime;
  2558. OnOptionsChanged(xtpCalendarDayView);
  2559. }
  2560. }
  2562. BOOL CXTPCalendarControl::DayView_IsAutoResetBusyFlag() const
  2563. {
  2564. CXTPCalendarOptions* pOpt = GetCalendarOptions();
  2565. ASSERT(pOpt);
  2566. if (pOpt)
  2567. {
  2568. return pOpt->bDayView_AutoResetBusyFlag;
  2569. }
  2570. return TRUE;
  2571. }
  2573. void CXTPCalendarControl::DayView_SetAutoResetBusyFlag(BOOL bAutoResetBusyFlag)
  2574. {
  2575. CXTPCalendarOptions* pOpt = GetCalendarOptions();
  2576. ASSERT(pOpt);
  2577. if (pOpt)
  2578. {
  2579. pOpt->bDayView_AutoResetBusyFlag = bAutoResetBusyFlag;
  2581. OnOptionsChanged(xtpCalendarDayView);
  2582. }
  2583. }
  2585. BOOL CXTPCalendarControl::MonthView_IsCompressWeekendDays() const
  2586. {
  2587. CXTPCalendarOptions* pOpt = GetCalendarOptions();
  2588. ASSERT(pOpt);
  2589. if (pOpt)
  2590. {
  2591. return pOpt->bMonthView_CompressWeekendDays;
  2592. }
  2593. return TRUE;
  2594. }
  2596. void CXTPCalendarControl::MonthView_SetCompressWeekendDays(BOOL bCompress)
  2597. {
  2598. CXTPCalendarOptions* pOpt = GetCalendarOptions();
  2599. ASSERT(pOpt);
  2600. if (pOpt)
  2601. {
  2602. pOpt->bMonthView_CompressWeekendDays = bCompress;
  2604. OnOptionsChanged(xtpCalendarMonthView);
  2605. }
  2606. }
  2608. BOOL CXTPCalendarControl::MonthView_IsShowEndDate() const
  2609. {
  2610. CXTPCalendarOptions* pOpt = GetCalendarOptions();
  2611. ASSERT(pOpt);
  2612. if (pOpt)
  2613. {
  2614. return pOpt->bMonthView_ShowEndDate;
  2615. }
  2616. return FALSE;
  2617. }
  2619. void CXTPCalendarControl::MonthView_SetShowEndDate(BOOL bShowEnd)
  2620. {
  2621. CXTPCalendarOptions* pOpt = GetCalendarOptions();
  2622. ASSERT(pOpt);
  2623. if (pOpt)
  2624. {
  2625. pOpt->bMonthView_ShowEndDate = bShowEnd;
  2627. OnOptionsChanged(xtpCalendarMonthView);
  2628. }
  2629. }
  2631. BOOL CXTPCalendarControl::MonthView_IsShowTimeAsClocks() const
  2632. {
  2633. CXTPCalendarOptions* pOpt = GetCalendarOptions();
  2634. ASSERT(pOpt);
  2635. if (pOpt)
  2636. {
  2637. return pOpt->bMonthView_ShowTimeAsClocks;
  2638. }
  2639. return FALSE;
  2640. }
  2642. void CXTPCalendarControl::MonthView_SetShowTimeAsClocks(BOOL bShowClocks)
  2643. {
  2644. CXTPCalendarOptions* pOpt = GetCalendarOptions();
  2645. ASSERT(pOpt);
  2646. if (pOpt)
  2647. {
  2648. pOpt->bMonthView_ShowTimeAsClocks = bShowClocks;
  2650. OnOptionsChanged(xtpCalendarMonthView);
  2651. }
  2652. }
  2654. BOOL CXTPCalendarControl::WeekView_IsShowEndDate() const
  2655. {
  2656. CXTPCalendarOptions* pOpt = GetCalendarOptions();
  2657. ASSERT(pOpt);
  2658. if (pOpt)
  2659. {
  2660. return pOpt->bWeekView_ShowEndDate;
  2661. }
  2662. return FALSE;
  2663. }
  2665. void CXTPCalendarControl::WeekView_SetShowEndDate(BOOL bShowEnd)
  2666. {
  2667. CXTPCalendarOptions* pOpt = GetCalendarOptions();
  2668. ASSERT(pOpt);
  2669. if (pOpt)
  2670. {
  2671. pOpt->bWeekView_ShowEndDate = bShowEnd;
  2673. OnOptionsChanged(xtpCalendarWeekView);
  2674. }
  2675. }
  2677. BOOL CXTPCalendarControl::WeekView_IsShowTimeAsClocks() const
  2678. {
  2679. CXTPCalendarOptions* pOpt = GetCalendarOptions();
  2680. ASSERT(pOpt);
  2681. if (pOpt)
  2682. {
  2683. return pOpt->bWeekView_ShowTimeAsClocks;
  2684. }
  2685. return FALSE;
  2686. }
  2688. void CXTPCalendarControl::WeekView_SetShowTimeAsClocks(BOOL bShowClocks)
  2689. {
  2690. CXTPCalendarOptions* pOpt = GetCalendarOptions();
  2691. ASSERT(pOpt);
  2692. if (pOpt)
  2693. {
  2694. pOpt->bWeekView_ShowTimeAsClocks = bShowClocks;
  2696. OnOptionsChanged(xtpCalendarWeekView);
  2697. }
  2698. }
  2700. void CXTPCalendarControl::OnEvent_FromDataProvider(XTP_NOTIFY_CODE Event,
  2701. WPARAM wParam, LPARAM lParam)
  2702. {
  2703. ASSERT(Event == XTP_NC_CALENDAROPTIONSWASCHANGED ||
  2704. Event == XTP_NC_CALENDAREVENTWASADDED ||
  2705. Event == XTP_NC_CALENDAREVENTWASDELETED ||
  2706. Event == XTP_NC_CALENDAREVENTWASCHANGED ||
  2707. Event == XTP_NC_CALENDARPATTERNWASADDED ||
  2708. Event == XTP_NC_CALENDARPATTERNWASDELETED ||
  2709. Event == XTP_NC_CALENDARPATTERNWASCHANGED
  2710. ||
  2711. Event == XTP_NC_CALENDAR_DoRetrieveDayEvents ||
  2712. Event == XTP_NC_CALENDAR_DoRemoveAllEvents ||
  2713. Event == XTP_NC_CALENDAR_DoRead_Event ||
  2714. Event == XTP_NC_CALENDAR_DoRead_RPattern ||
  2715. Event == XTP_NC_CALENDAR_DoCreate_Event ||
  2716. Event == XTP_NC_CALENDAR_DoUpdate_Event ||
  2717. Event == XTP_NC_CALENDAR_DoDelete_Event ||
  2718. Event == XTP_NC_CALENDAR_DoCreate_RPattern ||
  2719. Event == XTP_NC_CALENDAR_DoUpdate_RPattern ||
  2720. Event == XTP_NC_CALENDAR_DoDelete_RPattern ||
  2721. Event == XTP_NC_CALENDAR_DoGetUpcomingEvents ||
  2722. Event == XTP_NC_CALENDAR_DoGetAllEvents_raw );
  2724. SendNotification(Event, wParam, lParam);
  2726. if (Event == XTP_NC_CALENDAROPTIONSWASCHANGED)
  2727. {
  2728. KillTimer(XTP_CALENDAR_REFRESHMETRICS_REQUEST_TIMERID);
  2729. CWnd::SetTimer(XTP_CALENDAR_REFRESHMETRICS_REQUEST_TIMERID, XTP_CALENDAR_REFRESHMETRICS_REQUEST_TIMEOUT, NULL);
  2730. }
  2732. //-----------------------------------------------------------------------
  2733. if (!m_bUpdateWhenEventChangedNotify)
  2734. {
  2735. return;
  2736. }
  2738. if (Event == XTP_NC_CALENDAREVENTWASADDED ||
  2739. Event == XTP_NC_CALENDAREVENTWASDELETED ||
  2740. Event == XTP_NC_CALENDAREVENTWASCHANGED)
  2741. {
  2742. CXTPCalendarEvent* pEvent = (CXTPCalendarEvent*)lParam;
  2743. if (m_pActiveView)
  2744. {
  2745. int nUpdateType = m_pActiveView->OnEventChanged_InDataProvider(Event, pEvent);
  2746. if (nUpdateType == xtpCalendar_Populate)
  2747. {
  2748. if (m_pActiveView->IsEditingSubject())
  2749. {
  2750. m_pActiveView->EndEditSubject(xtpCalendarEditSubjectCancel);
  2751. }
  2752. if (m_pActiveView->GetDraggingEventNew())
  2753. {
  2754. m_pActiveView->CancelDraggingEvent();
  2755. }
  2757. if (m_uPopulateRequest_TimerID)
  2758. {
  2759. KillTimer(m_uPopulateRequest_TimerID);
  2760. }
  2761. m_uPopulateRequest_TimerID = SetTimer(XTP_CALENDAR_POPULATE_REQUEST_TIMEOUT);
  2762. }
  2763. else if (nUpdateType == xtpCalendar_Redraw)
  2764. {
  2765. if (m_uRedrawRequest_TimerID)
  2766. {
  2767. KillTimer(m_uRedrawRequest_TimerID);
  2768. }
  2769. m_uRedrawRequest_TimerID = SetTimer(XTP_CALENDAR_REDRAW_REQUEST_TIMEOUT);
  2770. }
  2771. }
  2772. }
  2773. }
  2775. void CXTPCalendarControl::OnEvent_Reminders(XTP_NOTIFY_CODE Event, WPARAM wParam , LPARAM lParam)
  2776. {
  2777. ASSERT( Event == XTP_NC_CALENDAR_ON_REMINDERS );
  2778. SendNotification(Event, wParam, lParam);
  2779. }
  2781. void CXTPCalendarControl::SendNotification(XTP_NOTIFY_CODE EventCode, WPARAM wParam , LPARAM lParam)
  2782. {
  2783. if (this && m_pConnect && m_bEnableSendNotifications)
  2784. {
  2785. m_pConnect->SendEvent(EventCode, wParam, lParam);
  2786. }
  2787. }
  2789. void CXTPCalendarControl::SendNotificationAlways(XTP_NOTIFY_CODE EventCode, WPARAM wParam , LPARAM lParam)
  2790. {
  2791. if (this && m_pConnect)
  2792. {
  2793. m_pConnect->SendEvent(EventCode, wParam, lParam);
  2794. }
  2795. }
  2797. void CXTPCalendarControl::OnFinalRelease()
  2798. {
  2799. CWnd::OnFinalRelease();
  2801. if (m_bDeleteOnFinalRelease)
  2802. {
  2803. CCmdTarget::OnFinalRelease();
  2804. }
  2805. }
  2807. void CXTPCalendarControl::SetLayoutRTL(BOOL bRightToLeft)
  2808. {
  2809. if (!XTPSystemVersion()->IsLayoutRTLSupported())
  2810. return;
  2812. if (!m_hWnd)
  2813. return;
  2815. ModifyStyleEx(bRightToLeft ? 0 : WS_EX_LAYOUTRTL, !bRightToLeft ? 0 : WS_EX_LAYOUTRTL);
  2816. RedrawControl();
  2817. }
  2819. DWORD CXTPCalendarControl::GetAskItemTextFlags()
  2820. {
  2821. DWORD dwFlags = 0;
  2822. if (GetTheme())
  2823. {
  2824. dwFlags = GetTheme()->GetAskItemTextFlags();
  2825. }
  2826. else
  2827. {
  2828. dwFlags = XTP_SAFE_GET1(GetPaintManager(), GetAskItemTextFlags(), 0);
  2829. }
  2831. return dwFlags;
  2832. }
  2834. XTPCalendarTheme CXTPCalendarControl::GetPaintTheme() const
  2835. {
  2836. if (m_pTheme)
  2837. return m_pTheme->GetPaintTheme();
  2839. ASSERT(m_pPaintManager);
  2840. if (m_pPaintManager)
  2841. return m_pPaintManager->GetPaintTheme();
  2843. return xtpCalendarThemeUnknown;
  2844. }
  2846. void CXTPCalendarControl::SetPaintTheme(XTPCalendarTheme ePaintTheme)
  2847. {
  2848. if (ePaintTheme == GetPaintTheme())
  2849. return;
  2851. BOOL bSendNotification = TRUE;
  2853. if (ePaintTheme == xtpCalendarThemeOffice2007)
  2854. {
  2855. if (!m_pTheme)
  2856. {
  2857. SetTheme(new CXTPCalendarThemeOffice2007());
  2858. bSendNotification = FALSE;
  2859. }
  2860. }
  2861. else
  2862. {
  2863. ASSERT(GetPaintManager());
  2865. if (GetPaintManager())
  2866. GetPaintManager()->SetPaintTheme(ePaintTheme);
  2868. SetTheme(NULL);
  2869. bSendNotification = FALSE;
  2870. }
  2872. if (bSendNotification)
  2873. SendNotification(XTP_NC_CALENDAR_THEME_CHANGED, 0, 0);
  2875. if (m_hWnd)
  2876. {
  2877. CUpdateContext updateContext(this, xtpCalendarUpdateAll);
  2878. }
  2879. }
  2881. CXTPCalendarControl::CViewChanged_ContextData::CViewChanged_ContextData()
  2882. {
  2883. m_nLockCount = 0;
  2884. m_bRequest = FALSE;
  2885. }
  2887. CXTPCalendarControl::CViewChangedContext::CViewChangedContext(
  2888. CXTPCalendarView* pView, int eType)
  2889. {
  2890. if (!pView)
  2891. {
  2892. ASSERT(FALSE);
  2893. return;
  2894. }
  2895. Init(pView->GetCalendarControl(), eType);
  2896. }
  2898. CXTPCalendarControl::CViewChangedContext::CViewChangedContext(CXTPCalendarControl* pControl, int eType)
  2899. {
  2900. Init(pControl, eType);
  2901. }
  2903. void CXTPCalendarControl::CViewChangedContext::Init(CXTPCalendarControl* pControl, int eType)
  2904. {
  2905. if (!pControl)
  2906. {
  2907. ASSERT(FALSE);
  2908. return;
  2909. }
  2911. m_pControl = pControl;
  2912. m_eType = eType;
  2914. m_pControl->m_cntViewChanged.m_nLockCount++;
  2915. }
  2917. CXTPCalendarControl::CViewChangedContext::~CViewChangedContext()
  2918. {
  2919. if (!m_pControl)
  2920. {
  2921. ASSERT(FALSE);
  2922. return;
  2923. }
  2925. if (m_eType == xtpCalendarViewChangedSend)
  2926. {
  2927. m_pControl->m_cntViewChanged.m_bRequest = TRUE;
  2928. }
  2930. ASSERT(m_pControl->m_cntViewChanged.m_nLockCount > 0);
  2932. m_pControl->m_cntViewChanged.m_nLockCount--;
  2934. if (m_pControl->m_cntViewChanged.m_nLockCount == 0 &&
  2935. m_pControl->m_cntViewChanged.m_bRequest)
  2936. {
  2937. m_pControl->m_cntViewChanged.m_bRequest = FALSE;
  2939. m_pControl->SendNotification(XTP_NC_CALENDARVIEWWASCHANGED, 0, 0);
  2940. }
  2941. }