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

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

对话框与窗口

开发平台：

Visual C++

XTPCalendarView.cpp：源码内容
  1. // XTPCalendarView.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/XTPPropExchange.h"
  24. #include "Common/XTPVC50Helpers.h"
  26. #include "XTPCalendarView.h"
  27. #include "XTPCalendarViewEvent.h"
  28. #include "XTPCalendarViewDay.h"
  29. #include "XTPCalendarControl.h"
  30. #include "XTPCalendarData.h"
  31. #include "XTPCalendarThemeOffice2007.h"
  33. #include <math.h>
  35. #pragma warning(disable: 4571) // warning C4571: catch(...) blocks compiled with /EHs do not catch or re-throw Structured Exceptions
  37. #ifdef _DEBUG
  38. #define new DEBUG_NEW
  39. #undef THIS_FILE
  40. static char THIS_FILE[] = __FILE__;
  41. #endif
  43. #define XTP_CLIPBOARD_EVENTS_DATA_VER 2
  45. //===========================================================================
  46. IMPLEMENT_DYNAMIC(CXTPCalendarWMHandler, CCmdTarget)
  47. IMPLEMENT_DYNAMIC(CXTPCalendarView, CXTPCalendarWMHandler)
  49. /////////////////////////////////////////////////////////////////////////////
  51. /////////////////////////////////////////////////////////////////////////////
  52. // CXTPCalendarView
  54. CXTPCalendarView::CXTPCalendarView(CXTPCalendarControl* pCalendarControl) :
  55. m_pControl(pCalendarControl)
  56. {
  57. m_rcView.SetRectEmpty();
  58. m_rcTooltip.SetRectEmpty();
  60. m_Layout.m_nRowHeight = 18;
  62. m_eDraggingMode = xtpCalendaDragModeUnknown;
  63. m_ptStartDragging.x = m_ptStartDragging.y = LONG_MAX;
  64. m_bStartedClickInside = FALSE;
  66. m_nTimerID_StartEditSubject = 0;
  67. m_nTimerID_ShowToolTip = 0;
  69. m_eUndoMode = xtpCalendarUndoModeUnknown;
  70. m_bResetUndoBuffer = FALSE;
  72. m_nKeyStateTimerID = 0;
  74. m_pSelectedEvents = new CXTPCalendarViewEvents();
  75. m_pResources = NULL;
  77. _CalculateEventTimeFormat();
  79. m_bScrollV_Disabled = FALSE;
  80. m_bScrollH_Disabled = FALSE;
  82. }
  84. CXTPCalendarView::~CXTPCalendarView()
  85. {
  86. CMDTARGET_RELEASE(m_pSelectedEvents);
  87. CMDTARGET_RELEASE(m_pResources);
  88. ASSERT(m_nTimerID_StartEditSubject == 0);
  89. ASSERT(m_nTimerID_ShowToolTip == 0);
  92. }
  94. void CXTPCalendarView::OnBeforeDestroy()
  95. {
  96. // --- Kill Subject editor
  97. if (IsEditingSubject())
  98. {
  99. TRACE_EDIT_SUBJECT(_T("Edit SUBJECT - EndEditSubject(commit) [CXTPCalendarView::OnBeforeDestroy]"));
  100. EndEditSubject(xtpCalendarEditSubjectCommit, FALSE);
  101. }
  103. if (m_ptrDraggingEventNew)
  104. {
  105. BOOL bChanged = CommitDraggingEvent();
  106. TRACE_DRAGGING(_T("Dragging - CommitDraggingEvent() = %d. [CXTPCalendarView::OnBeforeDestroy] n"), bChanged);
  107. }
  109. // --- Kill tooltip (and timer inside)
  110. ShowToolTip(FALSE);
  112. // --- Clear selected events collection
  113. if (m_pSelectedEvents)
  114. {
  115. m_pSelectedEvents->RemoveAll();
  116. }
  118. // === Call base cleanup code
  119. TBase::OnBeforeDestroy();
  120. }
  122. void CXTPCalendarView::OnActivateView(BOOL bActivate,
  123. CXTPCalendarView* pActivateView,
  124. CXTPCalendarView* pInactiveView)
  125. {
  126. UNREFERENCED_PARAMETER(pActivateView);
  127. UNREFERENCED_PARAMETER(pInactiveView);
  129. if (!bActivate && IsEditingSubject())
  130. {
  131. TRACE_EDIT_SUBJECT(_T("Edit SUBJECT - EndEditSubject(commit) [CXTPCalendarView::OnActivateView(FALSE)] n"));
  132. EndEditSubject(xtpCalendarEditSubjectCommit, FALSE);
  133. }
  134. }
  136. void CXTPCalendarView::RedrawControl()
  137. {
  138. ASSERT(m_pControl);
  139. if (m_pControl)
  140. {
  141. m_pControl->RedrawControl();
  142. }
  143. }
  145. void CXTPCalendarView::Populate()
  146. {
  147. if (IsEditingSubject())
  148. {
  149. EndEditSubject(xtpCalendarEditSubjectCommit);
  150. }
  152. int nCount = GetViewDayCount();
  153. for (int i = 0; i < nCount; i++)
  154. {
  155. CXTPCalendarViewDay* pViewDay = GetViewDay_(i);
  156. COleDateTime dtDay = GetViewDayDate(i);
  157. ASSERT(pViewDay);
  158. if (pViewDay)
  159. {
  160. pViewDay->Populate(dtDay);
  161. }
  162. }
  164. _ReSelectSelectEvents();
  165. }
  167. BOOL CXTPCalendarView::OnLButtonDown(UINT nFlags, CPoint point)
  168. {
  169. CXTPCalendarControl::CUpdateContext updateContext(m_pControl, xtpCalendarUpdateRedrawIfNeed);
  170. CSelectionChangedContext selChanged(this);
  172. TRACE_MOUSE(_T("OnLButtonDown - [CXTPCalendarView] (nFlags =%x, point.x =%d, point.y =%d) n"), nFlags, point.x, point.y);
  173. m_bStartedClickInside = TRUE;
  175. //---------------------------------------------------------------------------
  176. TBase::OnLButtonDown(nFlags, point);
  178. //= kill timeout request to edit subject=====================================
  179. if (m_nTimerID_StartEditSubject)
  180. {
  181. TRACE_EDIT_SUBJECT(_T("Edit SUBJECT - KillTimer() [CXTPCalendarView::OnLButtonDown(%d, %d)] n"), point.x, point.y);
  183. KillTimer(m_nTimerID_StartEditSubject);
  184. m_nTimerID_StartEditSubject = 0;
  185. m_ptrEditingViewEvent = NULL;
  186. }
  188. //---------------------------------------------------------------------------
  189. XTP_CALENDAR_HITTESTINFO hitInfo;
  190. if (HitTest(point, &hitInfo))
  191. {
  192. if (hitInfo.uHitCode & xtpCalendarHitTestDay_Mask)
  193. {
  194. CXTPCalendarControl::CUpdateContext updateContext1(m_pControl, xtpCalendarUpdateRedraw);
  195. ProcessDaySelection(&hitInfo, nFlags);
  196. }
  197. else
  198. if (hitInfo.uHitCode & xtpCalendarHitTestEvent_Mask)
  199. {
  200. CXTPCalendarControl::CUpdateContext updateContext1(m_pControl, xtpCalendarUpdateRedraw);
  201. ProcessEventSelection(&hitInfo, nFlags);
  203. // set request to start dragging when OnMouseMove()
  204. m_ptStartDragging = point;
  206. TRACE_DRAGGING(_T("Dragging REQUEST point(%d, %d) n"), point.x, point.y);
  207. }
  208. }
  210. //---------------------------------------------------------------------------
  211. BOOL bResetUndoLocal = TRUE;
  212. if (IsEditingSubject())
  213. {
  214. if (!GetSubjectEditorRect().PtInRect(point))
  215. {
  216. TRACE_EDIT_SUBJECT(_T("Edit SUBJECT - EndEditSubject(commit) [CXTPCalendarView::OnLButtonDown(%d, %d)] n"), point.x, point.y);
  218. bResetUndoLocal = m_eDraggingMode != xtpCalendaDragModeEditSubject;
  219. EndEditSubject(xtpCalendarEditSubjectCommit);
  220. }
  221. }
  222. m_bResetUndoBuffer = bResetUndoLocal;
  224. //---------------------------------------------------------------------------
  225. CXTPCalendarThemeOffice2007* pThemeX = DYNAMIC_DOWNCAST(CXTPCalendarThemeOffice2007, GetTheme());
  226. if (pThemeX)
  227. {
  228. XTP_SAFE_CALL1(pThemeX->GetPrevNextEventControllerPartX(), OnLButtonDown(this, nFlags, point));
  229. }
  231. return TRUE;
  232. }
  234. BOOL CXTPCalendarView::OnLButtonUp(UINT nFlags, CPoint point)
  235. {
  236. TRACE_MOUSE(_T("OnLButtonUp - [CXTPCalendarView] (nFlags =%x, point.x =%d, point.y =%d) n"), nFlags, point.x, point.y);
  237. {
  238. CXTPCalendarControl::CUpdateContext updateContext(m_pControl, xtpCalendarUpdateRedrawIfNeed);
  239. CSelectionChangedContext selChanged(this);
  241. TBase::OnLButtonUp(nFlags, point);
  243. //---------------------------------------------------------------------------
  244. m_ptStartDragging.x = m_ptStartDragging.y = LONG_MAX;
  246. XTP_CALENDAR_HITTESTINFO hitInfo;
  247. BOOL bHitTest = HitTest(point, &hitInfo);
  248. int nDragMode = m_eDraggingMode;
  250. if (!OnEndDragging(point, &hitInfo))
  251. {
  252. TRACE_DRAGGING(_T("Dragging ENDED. point(%d, %d). [CXTPCalendarView::OnLButtonUp] n"), point.x, point.y);
  254. if (bHitTest)
  255. {
  256. UINT uESmask = xtpCalendarHitTestEventTextArea | xtpCalendarHitTestEventResizeArea_Mask;
  257. if ((hitInfo.uHitCode & uESmask) && !IsEditingSubject() &&
  258. hitInfo.pViewEvent && hitInfo.pViewEvent->IsSelected())
  259. {
  260. BOOL bEnabled = XTP_SAFE_GET2(GetCalendarControl(), GetCalendarOptions(), bEnableInPlaceEditEventSubject_ByMouseClick, FALSE);
  261. bEnabled = bEnabled && IsSingleEventSelected();
  262. if (bEnabled)
  263. {
  264. bEnabled = !OnBeforeEditOperationNotify(xtpCalendarEO_EditSubject_ByMouseClick, hitInfo.pViewEvent);
  265. }
  266. if (bEnabled)
  267. {
  268. ASSERT(!m_ptrEditingViewEvent);
  270. m_ptrEditingViewEvent = hitInfo.pViewEvent;
  271. m_ptrEditingViewEvent->InternalAddRef();
  273. if (m_nTimerID_StartEditSubject == 0)
  274. {
  275. UINT uTimeOut_ms = GetStartEditSubjectTimeOut();
  276. m_nTimerID_StartEditSubject = SetTimer(uTimeOut_ms);
  277. ASSERT(m_nTimerID_StartEditSubject);
  278. DBG_TRACE_TIMER(_T("SET Timer: ID =%d, m_nTimerID_StartEditSubject, CXTPCalendarView.OnLButtonUp() n"), m_nTimerID_StartEditSubject);
  280. TRACE_EDIT_SUBJECT(_T("Edit SUBJECT - StartEditSubject REQUEST. [CXTPCalendarView::OnLButtonUp(%d, %d)] n"), point.x, point.y);
  281. }
  282. }
  283. }
  284. }
  285. }
  287. //---------------------------------------------------------------------------
  288. if (_IsDragModeCopyMove(nDragMode) && bHitTest && hitInfo.pViewDay)
  289. {
  290. UnselectAllEvents();
  291. SelectDay(hitInfo.pViewDay, hitInfo.nGroup);
  292. }
  294. if (GetCalendarControl())
  295. {
  296. GetCalendarControl()->m_mouseMode = xtpCalendarMouseNothing;
  297. }
  298. m_bStartedClickInside = FALSE;
  299. }
  300. OnMouseMove(nFlags, point);
  302. return TRUE;
  303. }
  305. void CXTPCalendarView::OnMouseMove(UINT nFlags, CPoint point)
  306. {
  308. TRACE_MOUSE(_T("OnMouseMove - [CXTPCalendarView] (point.x =%d, point.y =%d) n"),
  309. point.x, point.y);
  311. CXTPCalendarControl::CUpdateContext updateContext(m_pControl, xtpCalendarUpdateRedrawIfNeed);
  312. CSelectionChangedContext selChanged(this);
  314. //---------------------------------------------------------------------------
  315. CXTPCalendarThemeOffice2007* pThemeX = DYNAMIC_DOWNCAST(CXTPCalendarThemeOffice2007, GetTheme());
  316. if (pThemeX)
  317. {
  318. XTP_SAFE_CALL1(pThemeX->GetPrevNextEventControllerPartX(), OnMouseMove(this, nFlags, point));
  319. }
  320. //---------------------------------------------------------------------------
  322. TBase::OnMouseMove(nFlags, point);
  324. //---------------------------------------------------------------------------
  325. XTP_CALENDAR_HITTESTINFO hitInfo;
  326. BOOL bHitTest = HitTest(point, &hitInfo);
  328. if (bHitTest && hitInfo != m_LastHitInfo)
  329. {
  330. m_LastHitInfo = hitInfo;
  332. if (nFlags & MK_LBUTTON && m_bStartedClickInside)
  333. {
  334. const int cEpsilon = 2;
  335. if (m_ptStartDragging.x == LONG_MAX || m_ptStartDragging.y == LONG_MAX ||
  336. abs(point.x - m_ptStartDragging.x) >= cEpsilon ||
  337. abs(point.y - m_ptStartDragging.y) >= cEpsilon)
  338. {
  339. if (!m_ptrDraggingEventNew && !m_ptrDraggingEventOrig &&
  340. m_eDraggingMode == xtpCalendaDragModeUnknown)
  341. {
  342. XTP_CALENDAR_HITTESTINFO hitInfoSD;
  343. if (HitTest(m_ptStartDragging, &hitInfoSD))
  344. {
  345. if (hitInfoSD.uHitCode & xtpCalendarHitTestEvent_Mask)
  346. {
  347. int eDragMode = _GetDraggingMode(&hitInfoSD);
  348. if (!IsEditOperationDisabledNotify(_DragMod2Operation(eDragMode), hitInfoSD.pViewEvent))
  349. {
  350. TRACE_DRAGGING(_T("Dragging will START. point(%d, %d). [CXTPCalendarView::OnMouseMove] n"), point.x, point.y);
  352. OnStartDragging(m_ptStartDragging, &hitInfoSD);
  353. }
  354. }
  355. }
  356. }
  357. m_ptStartDragging.x = m_ptStartDragging.y = LONG_MAX;
  359. BOOL bDragging = m_ptrDraggingEventNew && m_eDraggingMode != xtpCalendaDragModeEditSubject;
  361. if (bDragging)
  362. {
  363. CXTPCalendarEventPtr ptrDragEventPrev = m_ptrDraggingEventNew->CloneEvent();
  364. BOOL bDragged = OnDragging(point, &hitInfo);
  366. if (bDragged)
  367. {
  368. XTP_EVENT_DRAG_OPERATION_PARAMS opParamsDrag;
  369. ::ZeroMemory(&opParamsDrag, sizeof(opParamsDrag));
  371. opParamsDrag.eOperation = _DragMod2Operation(m_eDraggingMode);
  372. opParamsDrag.pDraggingEvent = ptrDragEventPrev;
  373. opParamsDrag.pDraggingEventNew = m_ptrDraggingEventNew;
  375. BOOL bHandled = FALSE;
  376. if (m_pControl)
  377. {
  378. m_pControl->SendNotification(XTP_NC_CALENDAR_BEFORE_EVENT_EDIT_OPERATION,
  379. (WPARAM)&opParamsDrag, (LPARAM)&bHandled);
  380. }
  382. if (bHandled)
  383. {
  384. //rollback
  385. m_ptrDraggingEventNew = ptrDragEventPrev;
  386. }
  387. else
  388. {
  389. TRACE_DRAGGING(_T("Dragging OnDragging change event. point(%d, %d). [CXTPCalendarView::OnMouseMove] n"), point.x, point.y);
  390. }
  392. XTP_SAFE_CALL1(GetCalendarControl(), Populate());
  393. CXTPCalendarControl::CUpdateContext updateContext1(m_pControl, xtpCalendarUpdateLayout | xtpCalendarUpdateRedraw);
  395. if (m_ptrDraggingEventNew && m_ptrDraggingEventOrig &&
  396. (!m_ptrDraggingEventNew->IsEqualStartEnd(m_ptrDraggingEventOrig) ||
  397.  m_ptrDraggingEventNew->GetScheduleID() != m_ptrDraggingEventOrig->GetScheduleID())
  398. )
  399. {
  400. SelectEvent(m_ptrDraggingEventNew);
  401. }
  402. }
  403. }
  404. }
  406. if (m_eDraggingMode == xtpCalendaDragModeUnknown &&
  407. hitInfo.uHitCode & (xtpCalendarHitTestDay_Mask | xtpCalendarHitTestEvent_Mask))
  409. {
  410. if ((hitInfo.uHitCode & xtpCalendarHitTestEvent_Mask) &&
  411. hitInfo.pViewEvent && hitInfo.pViewEvent->IsSelected())
  412. {}
  413. else
  414. {
  415. CXTPCalendarControl::CUpdateContext updateContext1(m_pControl, xtpCalendarUpdateRedraw);
  417. ProcessDaySelection(&hitInfo, nFlags | MK_SHIFT);
  418. }
  419. }
  420. }
  421. // process tooltip events (only when no buttons pressed)
  422. if (0 == nFlags)
  423. {
  424. CRect rcTooltip(GetTooltipRect(point, hitInfo));
  425. if (m_rcTooltip != rcTooltip)
  426. {
  427. // -- kill waiting and hide a tooltip because we switched to another cell
  428. ShowToolTip(FALSE);
  430. // -- start waiting for mouse under regular empty cell
  431. //    (to show later "click to add appointment" button)
  432. UINT uTimeOut_ms = GetShowToolTipTimeOut();
  433. m_nTimerID_ShowToolTip = SetTimer(uTimeOut_ms);
  434. m_rcTooltip = rcTooltip;
  435. ASSERT(m_nTimerID_ShowToolTip);
  436. }
  437. }
  438. }
  439. else if (!bHitTest)
  440. {
  441. XTP_CALENDAR_HITTESTINFO hitInfoEmpty;
  442. m_LastHitInfo = hitInfoEmpty;
  443. }
  445. //===========================================================================
  446. if (GetCalendarControl())
  447. {
  448. if (_IsDragModeCopyMove(m_eDraggingMode) &&
  449. GetCalendarControl()->m_mouseMode != xtpCalendarMouseEventDraggingOut)
  450. {
  451. GetCalendarControl()->m_mouseMode = m_eDraggingMode == xtpCalendaDragModeCopy ?
  452. xtpCalendarMouseEventDragCopy : xtpCalendarMouseEventDragMove;
  454. GetCalendarControl()->UpdateMouseCursor();
  455. }
  456. }
  457. }
  459. void CXTPCalendarView::OnChar(UINT nChar, UINT nRepCnt, UINT nFlags)
  460. {
  461. CXTPCalendarControl::CUpdateContext updateContext(m_pControl, xtpCalendarUpdateRedrawIfNeed);
  462. CSelectionChangedContext selChanged(this);
  464. TRACE_KEYBOARD(_T("OnChar - [CXTPCalendarView] (nChar =%d, nRepCnt =%d, nFlags =%x) n"), nChar, nRepCnt, nFlags);
  466. TBase::OnChar(nChar, nRepCnt, nFlags);
  468. //========================================================================
  469. BOOL bEnable = XTP_SAFE_GET2(GetCalendarControl(), GetCalendarOptions(), bEnableInPlaceCreateEvent, FALSE);
  470. if (nChar >= _T(' ') && bEnable)
  471. {
  472. CString strInitialSubj((TCHAR)nChar);
  473. if (!OnInPlaceCreateEvent(strInitialSubj))
  474. {
  475. StartEditNewEventInplace(strInitialSubj);
  476. }
  477. }
  478. }
  480. void CXTPCalendarView::OnKeyDown(UINT nChar, UINT nRepCnt, UINT nFlags)
  481. {
  482. CXTPCalendarControl::CUpdateContext updateContext(m_pControl, xtpCalendarUpdateRedrawIfNeed);
  483. CSelectionChangedContext selChanged(this);
  485. TRACE_KEYBOARD(_T("OnKeyDown - [CXTPCalendarView] (nChar =%d, nRepCnt =%d, nFlags =%x) n"), nChar, nRepCnt, nFlags);
  487. TBase::OnKeyDown(nChar, nRepCnt, nFlags);
  489. //---------------------------------------------------------------------------
  490. if (nChar == VK_RETURN || nChar == VK_ESCAPE)
  491. {
  492. if (IsEditingSubject())
  493. {
  494. TRACE_EDIT_SUBJECT(_T("Edit SUBJECT - EndEditSubject(). [CXTPCalendarView::OnKeyDown] n"));
  496. CXTPCalendarEventPtr ptrEditingEvent(m_ptrDraggingEventOrig, TRUE);
  498. EndEditSubject((nChar == VK_RETURN) ? xtpCalendarEditSubjectCommit : xtpCalendarEditSubjectCancel);
  500. if (nChar == VK_ESCAPE && ptrEditingEvent)
  501. {
  502. _Undo(ptrEditingEvent);
  503. m_UndoBuffer.Set(m_PrevUndoBuffer);
  504. }
  505. }
  507. if (nChar == VK_ESCAPE && m_ptrDraggingEventNew)
  508. {
  509. CXTPCalendarEventPtr ptrEditingEvent(m_ptrDraggingEventOrig, TRUE);
  511. CancelDraggingEvent();
  513. BOOL bControlUpdated = FALSE;
  514. if (ptrEditingEvent && !m_bResetUndoBuffer)
  515. {
  516. bControlUpdated = _Undo(ptrEditingEvent);
  517. m_UndoBuffer.Set(m_PrevUndoBuffer);
  518. }
  520. if (!bControlUpdated && GetCalendarControl())
  521. {
  522. CXTPCalendarControl::CUpdateContext updateContext1(GetCalendarControl(), xtpCalendarUpdateLayout | xtpCalendarUpdateRedraw);
  523. GetCalendarControl()->Populate();
  524. }
  525. }
  526. }
  527. else if (nChar == VK_F2)
  528. {
  529. if (IsEditingSubject())
  530. {
  531. return;
  532. }
  534. CXTPCalendarViewEvent* pViewEvent = GetLastSelectedViewEvent();
  535. BOOL bEnabled = XTP_SAFE_GET2(GetCalendarControl(), GetCalendarOptions(), bEnableInPlaceEditEventSubject_ByF2, FALSE);
  536. bEnabled = bEnabled && m_eDraggingMode == xtpCalendaDragModeUnknown && pViewEvent;
  538. if (bEnabled)
  539. {
  540. bEnabled = !OnBeforeEditOperationNotify(xtpCalendarEO_EditSubject_ByF2, pViewEvent);
  541. }
  542. if (bEnabled)
  543. {
  544. ASSERT(!m_ptrDraggingEventOrig && !m_ptrDraggingEventNew && !m_ptrEditingViewEvent);
  546. if (pViewEvent)
  547. {
  548. CXTPCalendarControl::CUpdateContext updateContext1(m_pControl, xtpCalendarUpdateRedraw);
  550. EmptyUndoBuffer();
  552. StartEditSubject(pViewEvent);
  553. }
  554. }
  555. }
  556. else if (nChar == VK_DELETE)
  557. {
  558. if (m_eDraggingMode == xtpCalendaDragModeUnknown && !m_ptrEditingViewEvent)
  559. {
  560. ASSERT(!m_ptrDraggingEventOrig && !m_ptrDraggingEventNew && !m_ptrEditingViewEvent);
  562. CXTPCalendarViewEvent* pViewEvent = GetLastSelectedViewEvent();
  564. if (m_selectedBlock.dtEnd.GetStatus() == COleDateTime::valid &&
  565. GetCalendarControl() && pViewEvent && pViewEvent->IsSelected())
  566. {
  567. CXTPCalendarControl::CUpdateContext updateContext1(GetCalendarControl(), xtpCalendarUpdateRedraw | xtpCalendarUpdateLayout);
  569. VERIFY(GetCalendarControl()->DoDeleteSelectedEvents(pViewEvent));
  571. GetCalendarControl()->Populate();
  572. }
  573. }
  574. }
  575. else if (nChar == VK_TAB)
  576. {
  577. if (m_eDraggingMode == xtpCalendaDragModeUnknown ||
  578. m_eDraggingMode == xtpCalendaDragModeEditSubject)
  579. {
  580. BOOL bShift = (::GetKeyState(VK_SHIFT) & 0x8000) != 0;
  582. CXTPCalendarControl::CUpdateContext updateContext1(m_pControl, xtpCalendarUpdateRedraw);
  583. if (IsEditingSubject())
  584. {
  585. EndEditSubject(xtpCalendarEditSubjectCommit);
  586. }
  588. COleDateTime dtMinStart = GetNextTimeEditByTAB();
  590. CXTPCalendarViewEvent* pViewEvent = GetLastSelectedViewEvent();
  591. CXTPCalendarEvent* pLastEvent = pViewEvent ? pViewEvent->GetEvent() : NULL;
  593. const int cLoopMax = 5000;
  594. int i;
  595. for (i = 0; i < cLoopMax; i++) // to prevent infinite looping
  596. {
  597. pViewEvent = FindEventToEditByTAB(dtMinStart, bShift, pLastEvent);
  598. pLastEvent = pViewEvent ? pViewEvent->GetEvent() : NULL;
  599. if (!pViewEvent || pViewEvent && pViewEvent->IsVisible())
  600. {
  601. break;
  602. }
  603. }
  604. ASSERT(i < cLoopMax); // probably infinite looping ???
  607. UnselectAllEvents();
  608. if (pViewEvent && pViewEvent->IsVisible() && pViewEvent->GetEvent())
  609. {
  610. dtMinStart = pViewEvent->GetEvent()->GetStartTime();
  611. UpdateNextTimeEditByTAB(dtMinStart, bShift);
  613. EmptyUndoBuffer();
  615. BOOL bEnabled = XTP_SAFE_GET2(GetCalendarControl(), GetCalendarOptions(), bEnableInPlaceEditEventSubject_ByTab, FALSE);
  616. if (bEnabled)
  617. {
  618. bEnabled = !OnBeforeEditOperationNotify(xtpCalendarEO_EditSubject_ByTab, pViewEvent);
  619. }
  621. if (bEnabled)
  622. {
  623. StartEditSubject(pViewEvent);
  624. }
  625. else
  626. {
  627. SelectEvent(pViewEvent->GetEvent());
  628. }
  630. SelectDay(XTP_SAFE_GET2(pViewEvent, GetViewGroup_(), GetViewDay_(), NULL),
  631.   XTP_SAFE_GET2(pViewEvent, GetViewGroup_(), GetGroupIndex(), -1));
  632. }
  633. else
  634. {
  635. dtMinStart = GetViewDayDate(bShift ? GetViewDayCount()-1 : 0);
  636. UpdateNextTimeEditByTAB(dtMinStart, bShift, TRUE);
  637. }
  638. }
  639. }
  640. }
  642. BOOL CXTPCalendarView::OnSysKeyDown(UINT nChar, UINT nRepCnt, UINT nFlags)
  643. {
  644. CXTPCalendarControl::CUpdateContext updateContext(m_pControl, xtpCalendarUpdateRedrawIfNeed);
  645. CSelectionChangedContext selChanged(this);
  647. TRACE_KEYBOARD(_T("OnSysKeyDown - [CXTPCalendarView] (nChar =%d, nRepCnt =%d, nFlags =%x) n"), nChar, nRepCnt, nFlags);
  649. BOOL bHandled = TBase::OnSysKeyDown(nChar, nRepCnt, nFlags);
  651. //---------------------------------------------------------------------------
  652. UINT uAltBit = (((UINT)1) << 13);
  653. if (nChar == VK_BACK && (nFlags & uAltBit))
  654. {
  655. bHandled = TRUE;
  656. if (CanUndo())
  657. {
  658. Undo();
  659. }
  660. else if (CanRedo())
  661. {
  662. Redo();
  663. }
  664. }
  666. return bHandled;
  667. }
  669. BOOL CXTPCalendarView::SetDraggingEvent(CXTPCalendarEvent* pEventOrig)
  670. {
  671. if (m_ptrDraggingEventOrig || m_ptrDraggingEventNew || !pEventOrig)
  672. {
  673. ASSERT(FALSE); // Dragging Event already set,
  674. return FALSE;  // or CommitDraggingEvent() was not called.
  675. }                  // or invalid parameter
  677. TRACE_DRAGGING(_T("Dragging - SetDraggingEvent. ptr =%x. [CXTPCalendarView::SetDraggingEvent] n"), pEventOrig);
  679. pEventOrig->InternalAddRef();
  680. m_ptrDraggingEventOrig = pEventOrig;
  681. m_ptrDraggingEventNew = pEventOrig->CloneEvent();
  683. if (m_ptrDraggingEventNew &&
  684. m_ptrDraggingEventNew->GetRecurrenceState() == xtpCalendarRecurrenceOccurrence)
  685. {
  686. VERIFY(m_ptrDraggingEventNew->MakeAsRException());
  687. }
  689. return TRUE;
  690. }
  692. CXTPCalendarEvent* CXTPCalendarView::GetDraggingEventOrig()
  693. {
  694. return m_ptrDraggingEventOrig;
  695. }
  697. CXTPCalendarEvent* CXTPCalendarView::GetDraggingEventNew()
  698. {
  699. return m_ptrDraggingEventNew;
  700. }
  702. BOOL CXTPCalendarView::CommitDraggingEvent()
  703. {
  704. ASSERT(m_ptrDraggingEventNew);
  706. if (!GetCalendarControl())
  707. {
  708. return FALSE;
  709. }
  711. CXTPAutoResetValue<BOOL> autoSet_UpdateCtrlNf(GetCalendarControl()->m_bUpdateWhenEventChangedNotify);
  712. autoSet_UpdateCtrlNf = FALSE;
  714. if (m_ptrDraggingEventNew && m_ptrDraggingEventOrig)
  715. {
  716. BOOL bDPdiff = m_ptrDraggingEventNew->GetDataProvider() != m_ptrDraggingEventOrig->GetDataProvider();
  718. BOOL bChanged = !m_ptrDraggingEventNew->IsEqualStartEnd(m_ptrDraggingEventOrig);
  719. bChanged = bChanged || m_ptrDraggingEventNew->GetSubject() != m_ptrDraggingEventOrig->GetSubject();
  720. bChanged = bChanged || m_ptrDraggingEventNew->IsAllDayEvent() != m_ptrDraggingEventOrig->IsAllDayEvent();
  721. bChanged = bChanged || m_ptrDraggingEventNew->GetScheduleID() != m_ptrDraggingEventOrig->GetScheduleID();
  722. bChanged = bChanged || bDPdiff;
  724. if (bChanged || m_eDraggingMode == xtpCalendaDragModeCopy)
  725. {
  726. if (!m_UndoBuffer.IsInUndoBuffer(m_ptrDraggingEventOrig) || m_bResetUndoBuffer)
  727. {
  728. m_PrevUndoBuffer.Set(m_UndoBuffer);
  729. EmptyUndoBuffer();
  730. }
  732. CXTPCalendarData* pDataNew = m_ptrDraggingEventNew->GetDataProvider(); // _GetDataProviderForDraggingEvent(m_ptrDraggingEventNew);
  733. CXTPCalendarData* pDataOrig = m_ptrDraggingEventOrig->GetDataProvider();
  735. if (m_eDraggingMode == xtpCalendaDragModeCopy)
  736. {
  737. if (m_ptrDraggingEventNew->GetRecurrenceState() != xtpCalendarRecurrenceNotRecurring)
  738. {
  739. VERIFY(m_ptrDraggingEventNew->RemoveRecurrence() );
  740. }
  741. if (pDataNew)
  742. {
  743. DBG_DATA_VERIFY(pDataNew->AddEvent(m_ptrDraggingEventNew) );
  744. }
  745. }
  746. else
  747. {
  748. m_UndoBuffer.AddUndoAction(m_ptrDraggingEventOrig, m_ptrDraggingEventNew);
  749. m_eUndoMode = xtpCalendarUndoModeUndo;
  750. m_bResetUndoBuffer = FALSE;
  752. if (pDataNew)
  753. {
  754. if (!bDPdiff)
  755. {
  756. // restore event ID for case when m_ptrDraggingEventNew was recreated
  757. // during dragging between providers
  758. m_ptrDraggingEventNew->SetEventID(m_ptrDraggingEventOrig->GetEventID());
  760. DBG_DATA_VERIFY(pDataNew->ChangeEvent(m_ptrDraggingEventNew) );
  761. }
  762. else
  763. {
  764. if (m_ptrDraggingEventNew->GetRecurrenceState() != xtpCalendarRecurrenceNotRecurring)
  765. {
  766. VERIFY(m_ptrDraggingEventNew->RemoveRecurrence() );
  767. }
  768. if (pDataOrig)
  769. {
  770. DBG_DATA_VERIFY(pDataOrig->DeleteEvent(m_ptrDraggingEventOrig) );
  771. }
  773. DBG_DATA_VERIFY(pDataNew->AddEvent(m_ptrDraggingEventNew));
  774. }
  775. }
  777. // for test only
  778. //VERIFY(pData->DeleteEvent(m_ptrDraggingEventOrig));
  779. //VERIFY(pData->AddEvent(m_ptrDraggingEventNew));
  780. }
  781. }
  783. TRACE_DRAGGING(_T("Dragging - CommitDraggingEvent() = %d. ptr =%x. [CXTPCalendarView] n"), bChanged, (CXTPCalendarEvent*)m_ptrDraggingEventOrig);
  785. m_ptrDraggingEventOrig = NULL;
  786. m_ptrDraggingEventNew = NULL;
  788. return bChanged;
  789. }
  790. else if (m_ptrDraggingEventNew)
  791. {
  792. if (!m_UndoBuffer.IsInUndoBuffer(m_ptrDraggingEventNew) || m_bResetUndoBuffer)
  793. {
  794. m_PrevUndoBuffer.Set(m_UndoBuffer);
  795. EmptyUndoBuffer();
  796. }
  798. CXTPCalendarData* pData = m_ptrDraggingEventNew->GetDataProvider(); //_GetDataProviderForDraggingEvent(m_ptrDraggingEventNew);
  800. ASSERT(m_ptrDraggingEventNew->GetRecurrenceState() == xtpCalendarRecurrenceNotRecurring);
  802. if (pData)
  803. {
  804. DBG_DATA_VERIFY( pData->AddEvent(m_ptrDraggingEventNew) );
  805. }
  807. m_UndoBuffer.AddUndoAction(NULL, m_ptrDraggingEventNew);
  808. m_eUndoMode = xtpCalendarUndoModeUndo;
  809. m_bResetUndoBuffer = FALSE;
  811. m_ptrDraggingEventOrig = NULL;
  812. m_ptrDraggingEventNew = NULL;
  814. return TRUE;
  815. }
  817. return FALSE;
  818. }
  820. void CXTPCalendarView::CancelDraggingEvent()
  821. {
  822. ASSERT(m_ptrDraggingEventNew);
  823. m_eDraggingMode = xtpCalendaDragModeUnknown;
  824. if (GetCalendarControl())
  825. {
  826. GetCalendarControl()->m_mouseMode = xtpCalendarMouseNothing;
  827. GetCalendarControl()->UpdateMouseCursor();
  828. }
  830. m_ptrDraggingEventOrig = NULL;
  831. m_ptrDraggingEventNew = NULL;
  833. m_ptStartDragging.x = m_ptStartDragging.y = LONG_MAX;
  834. m_bStartedClickInside = FALSE;
  835. }
  837. CXTPCalendarEventsPtr CXTPCalendarView::RetrieveDayEvents(CXTPCalendarResource* pRC,
  838.   COleDateTime dtDay)
  839. {
  840. ASSERT(pRC);
  842. dtDay = CXTPCalendarUtils::ResetTime(dtDay);
  844. CXTPCalendarEventsPtr ptrEvents = pRC ? pRC->RetrieveDayEvents(dtDay) : new CXTPCalendarEvents();
  846. if (!m_ptrDraggingEventNew || !ptrEvents || !pRC)
  847. {
  848. return ptrEvents;
  849. }
  851. BOOL bIsDragCopy = m_eDraggingMode == xtpCalendaDragModeCopy;
  853. COleDateTime dtDay1 = CXTPCalendarUtils::ResetTime(m_ptrDraggingEventNew->GetStartTime());
  854. COleDateTime dtDay2 = CXTPCalendarUtils::ResetTime(m_ptrDraggingEventNew->GetEndTime());
  856. UINT uSchID = m_ptrDraggingEventNew->GetScheduleID();
  857. BOOL bNewEventScheduleVisible =
  858. m_ptrDraggingEventNew->GetDataProvider() == pRC->GetDataProvider() &&
  859. pRC->ExistsScheduleID(uSchID);
  861. if (!bIsDragCopy)
  862. {
  863. int nCount = ptrEvents->GetCount();
  864. for (int i = nCount-1; i >= 0; i--)
  865. {
  866. CXTPCalendarEvent* pEvent = ptrEvents->GetAt(i, FALSE);
  867. if (!pEvent)
  868. {
  869. continue;
  870. }
  872. if (m_ptrDraggingEventOrig &&
  873. m_ptrDraggingEventOrig->GetDataProvider() == pEvent->GetDataProvider() &&
  874. m_ptrDraggingEventOrig->IsEqualIDs(pEvent) &&
  875. m_ptrDraggingEventOrig->GetScheduleID() == pEvent->GetScheduleID()
  876.    )
  877. {
  878. ptrEvents->RemoveAt(i);
  879. //break;
  880. }
  881. }
  882. }
  884. if (dtDay >= dtDay1 && dtDay <= dtDay2 && bNewEventScheduleVisible)
  885. {
  886. ptrEvents->Add(m_ptrDraggingEventNew);
  887. }
  889. return ptrEvents;
  890. }
  892. XTPCalendarDraggingMode CXTPCalendarView::_GetDraggingMode(XTP_CALENDAR_HITTESTINFO* pHitTest) const
  893. {
  894. if (!pHitTest)
  895. {
  896. ASSERT(FALSE);
  897. return xtpCalendaDragModeUnknown;
  898. }
  900. if (pHitTest->uHitCode & xtpCalendarHitTestEventResizeArea_Mask)
  901. {
  902. if (pHitTest->uHitCode & xtpCalendarHitTestEventResizeBegin)
  903. {
  904. return xtpCalendaDragModeResizeBegin;
  905. }
  906. else if (pHitTest->uHitCode & xtpCalendarHitTestEventResizeEnd)
  907. {
  908. return xtpCalendaDragModeResizeEnd;
  909. }
  910. }
  911. else
  912. {
  913. BOOL bIsCtrl = (::GetKeyState(VK_CONTROL) & 0x8000) != 0;
  914. return bIsCtrl ? xtpCalendaDragModeCopy : xtpCalendaDragModeMove;
  915. }
  917. return xtpCalendaDragModeUnknown;
  918. }
  920. void CXTPCalendarView::OnStartDragging(CPoint /*point*/, XTP_CALENDAR_HITTESTINFO* pHitTest)
  921. {
  922. if (!pHitTest)
  923. {
  924. ASSERT(FALSE);
  925. return;
  926. }
  928. if ((pHitTest->uHitCode & xtpCalendarHitTestEvent_Mask) == 0)
  929. {
  930. return;
  931. }
  933. //---------------------------------------------------------------------------
  934. if (IsEditingSubject())
  935. {
  936. TRACE_EDIT_SUBJECT(_T("Edit SUBJECT - EndEditSubject(). [CXTPCalendarView::OnStartDragging] n"));
  938. EndEditSubject(xtpCalendarEditSubjectCommit, FALSE);
  939. }
  940. //---------------------------------------------------------------------------
  942. m_spDraggingStartOffset.SetStatus(COleDateTimeSpan::null);
  943. m_eDraggingMode = xtpCalendaDragModeUnknown;
  945. if (!pHitTest->pViewEvent || !pHitTest->pViewEvent->GetEvent())
  946. {
  947. ASSERT(FALSE);
  948. return;
  949. }
  951. m_eDraggingMode = _GetDraggingMode(pHitTest);
  952. ASSERT(m_eDraggingMode != xtpCalendaDragModeUnknown);
  954. if (_IsDragModeCopyMove(m_eDraggingMode))
  955. {
  956. if (pHitTest->bTimePartValid)
  957. {
  958. m_spDraggingStartOffset = pHitTest->dt - pHitTest->pViewEvent->GetEvent()->GetStartTime();
  959. }
  960. else
  961. {
  962. m_spDraggingStartOffset = CXTPCalendarUtils::ResetTime(pHitTest->dt) -
  963.   CXTPCalendarUtils::ResetTime(pHitTest->pViewEvent->GetEvent()->GetStartTime());
  964. }
  966. if (!m_nKeyStateTimerID)
  967. {
  968. m_nKeyStateTimerID = SetTimer(50);
  969. DBG_TRACE_TIMER(_T("SET Timer: ID =%d, m_nKeyStateTimerID, CXTPCalendarView::OnStartDragging() n"), m_nKeyStateTimerID);
  970. }
  971. }
  973. //---------------------------------------------------------------------------
  974. VERIFY(SetDraggingEvent(pHitTest->pViewEvent->GetEvent()));
  975. }
  977. BOOL CXTPCalendarView::OnEndDragging(CPoint point, XTP_CALENDAR_HITTESTINFO* /*phitInfo*/)
  978. {
  979. if (!m_ptrDraggingEventNew || !m_ptrDraggingEventOrig ||
  980. m_eDraggingMode == xtpCalendaDragModeEditSubject)
  981. {
  982. return FALSE;
  983. }
  985. CXTPCalendarEventPtr ptrEventToSelect = m_ptrDraggingEventNew;
  987. BOOL bChanged = CommitDraggingEvent();
  989. int nDragMode = m_eDraggingMode;
  990. m_eDraggingMode = xtpCalendaDragModeUnknown;
  992. TRACE_DRAGGING(_T("Dragging - CommitDraggingEvent() = %d. [CXTPCalendarView::OnEndDragging(%d, %d)] n"), bChanged, point.x, point.y);
  994. if (bChanged && GetCalendarControl())
  995. {
  996. GetCalendarControl()->Populate();
  997. }
  998. UnselectAllEvents();
  1000. //---------------------------------------------------------------------------
  1001. if (_IsDragModeCopyMove(nDragMode))
  1002. {
  1003. EmptyUndoBuffer();
  1004. }
  1005. //---------------------------------------------------------------------------
  1006. if (ptrEventToSelect && (nDragMode == xtpCalendaDragModeResizeBegin || nDragMode == xtpCalendaDragModeResizeEnd))
  1007. {
  1008. CXTPCalendarControl::CUpdateContext updateContext(m_pControl, xtpCalendarUpdateRedraw);
  1010. COleDateTime dtFVDate = CXTPCalendarUtils::ResetTime(ptrEventToSelect->GetStartTime());
  1011. if (nDragMode == xtpCalendaDragModeResizeEnd)
  1012. {
  1013. dtFVDate = CXTPCalendarUtils::RetriveEventEndDate(ptrEventToSelect);
  1014. }
  1016. CXTPCalendarViewEvent* pViewEvent = FindViewEvent(ptrEventToSelect, dtFVDate);
  1017. if (pViewEvent && pViewEvent->GetEvent())
  1018. {
  1019. SelectDay(XTP_SAFE_GET2(pViewEvent, GetViewGroup_(), GetViewDay_(), NULL),
  1020.   XTP_SAFE_GET2(pViewEvent, GetViewGroup_(), GetGroupIndex(), -1));
  1022. BOOL bEnabled = XTP_SAFE_GET2(GetCalendarControl(), GetCalendarOptions(), bEnableInPlaceEditEventSubject_AfterEventResize, FALSE);
  1023. if (bEnabled)
  1024. {
  1025. bEnabled = !OnBeforeEditOperationNotify(xtpCalendarEO_EditSubject_AfterEventResize, pViewEvent);
  1026. }
  1028. if (bEnabled)
  1029. {
  1030. TRACE_EDIT_SUBJECT(_T("Edit SUBJECT - StartEditSubject(). [CXTPCalendarView::OnEndDragging(%d, %d)] n"), point.x, point.y);
  1031. StartEditSubject(pViewEvent);
  1032. }
  1033. else
  1034. {
  1035. SelectEvent(pViewEvent->GetEvent());
  1036. }
  1037. }
  1038. }
  1040. SelectEvent(ptrEventToSelect);
  1042. return TRUE;
  1043. }
  1045. CXTPCalendarViewEvent* CXTPCalendarView::FindViewEvent(CXTPCalendarEvent* pEvent, COleDateTime dtDay)
  1046. {
  1047. if (!pEvent)
  1048. {
  1049. ASSERT(FALSE);
  1050. return NULL;
  1051. }
  1052. dtDay = CXTPCalendarUtils::ResetTime(dtDay);
  1054. CXTPCalendarViewEvent* pFEView = NULL;
  1055. BOOL bFDayProceessed = FALSE;
  1057. int nCount = GetViewDayCount();
  1058. for (int i = 0; i < nCount; i++)
  1059. {
  1060. CXTPCalendarViewDay* pViewDay = GetViewDay_(i);
  1061. if (!pViewDay)
  1062. {
  1063. ASSERT(FALSE);
  1064. continue;
  1065. }
  1067. COleDateTime dtDayDate = pViewDay->GetDayDate();
  1069. int nGroupsCount = pViewDay->GetViewGroupsCount();
  1070. for (int g = 0; g < nGroupsCount; g++)
  1071. {
  1072. CXTPCalendarViewGroup* pViewGroup = pViewDay->GetViewGroup_(g);
  1073. ASSERT(pViewGroup);
  1074. if (!pViewGroup)
  1075. {
  1076. continue;
  1077. }
  1078. int nECount = pViewGroup->GetViewEventsCount();
  1079. for (int j = 0; j < nECount; j++)
  1080. {
  1081. CXTPCalendarViewEvent* pViewEvent = pViewGroup->GetViewEvent_(j);
  1082. CXTPCalendarEvent* pEv = pViewEvent ? pViewEvent->GetEvent() : NULL;
  1083. if (!pEv)
  1084. {
  1085. ASSERT(FALSE);
  1086. continue;
  1087. }
  1088. if (pEvent->IsEqualIDs(pEv) && pEvent->IsEqualStartEnd(pEv))
  1089. {
  1090. if (pViewEvent->IsVisible())
  1091. {
  1092. pFEView = pViewEvent;
  1093. }
  1094. if (CXTPCalendarUtils::IsEqual(dtDay, dtDayDate))
  1095. {
  1096. bFDayProceessed = TRUE;
  1097. }
  1098. if (pFEView && bFDayProceessed)
  1099. {
  1100. return pFEView;
  1101. }
  1102. }
  1103. }
  1104. }
  1105. }
  1106. return NULL;
  1107. }
  1109. BOOL CXTPCalendarView::HasSelectedViewEvent()
  1110. {
  1111. if (!m_pSelectedEvents)
  1112. {
  1113. return FALSE;
  1114. }
  1115. return m_pSelectedEvents->GetCount() > 0;
  1116. }
  1118. CXTPCalendarViewEvents* CXTPCalendarView::GetSelectedViewEvents()
  1119. {
  1120. return m_pSelectedEvents;
  1121. }
  1123. BOOL CXTPCalendarView::IsSingleEventSelected()
  1124. {
  1125. int nCount = m_pSelectedEvents ? m_pSelectedEvents->GetCount() : 0;
  1127. if (nCount == 0)
  1128. return FALSE;
  1130. if (nCount == 1)
  1131. return TRUE;
  1133. CXTPCalendarEvent* pEvent = m_pSelectedEvents->GetAt(0)->GetEvent();
  1135. for (int i = 0; i < nCount; i++)
  1136. {
  1137. CXTPCalendarViewEvent* pViewEvent = m_pSelectedEvents->GetAt(i);
  1138. ASSERT(pViewEvent);
  1139. if (pViewEvent && !pViewEvent->GetEvent()->IsEqualIDs(pEvent))
  1140. return FALSE;
  1141. }
  1143. return TRUE;
  1144. }
  1146. CXTPCalendarViewEventsPtr CXTPCalendarView::GetSelectedEvents()
  1147. {
  1148. CXTPCalendarViewEventsPtr ptrEventsWithViews = new CXTPCalendarViewEvents();
  1149. CXTPCalendarEvents arEvents;
  1151. ASSERT(m_pSelectedEvents);
  1152. if (!ptrEventsWithViews || !m_pSelectedEvents)
  1153. {
  1154. return NULL;
  1155. }
  1157. int nCount = m_pSelectedEvents->GetCount();
  1158. for (int i = 0; i < nCount; i++)
  1159. {
  1160. CXTPCalendarViewEvent* pViewEvent = m_pSelectedEvents->GetAt(i);
  1161. CXTPCalendarEvent* pEvent = pViewEvent ? pViewEvent->GetEvent() : NULL;
  1163. if (pEvent && arEvents.Find(pEvent) < 0)
  1164. {
  1165. arEvents.Add(pEvent, TRUE);
  1166. ptrEventsWithViews->Add(pViewEvent, TRUE);
  1167. }
  1168. }
  1170. return ptrEventsWithViews;
  1171. }
  1173. BOOL CXTPCalendarView::GetSelection(COleDateTime* pBegin, COleDateTime* pEnd,
  1174. BOOL* pbAllDayEvent, int* pnGroupIndex,
  1175. COleDateTimeSpan* pspSelectionResolution)
  1176. {
  1177. if (!m_selectedBlock.IsValid())
  1178. {
  1179. return FALSE;
  1180. }
  1182. if (pspSelectionResolution)
  1183. {
  1184. *pspSelectionResolution = COleDateTimeSpan(1, 0, 0, 0);
  1185. }
  1186. if (pbAllDayEvent)
  1187. {
  1188. *pbAllDayEvent = TRUE;
  1189. }
  1190. if (pnGroupIndex)
  1191. {
  1192. *pnGroupIndex = m_selectedBlock.nGroupIndex;
  1193. }
  1195. //---------------------------------------------------------------------------
  1196. if (pBegin)
  1197. {
  1198. *pBegin = min(m_selectedBlock.dtBegin, m_selectedBlock.dtEnd);
  1199. }
  1200. if (pEnd)
  1201. {
  1202. *pEnd = max(m_selectedBlock.dtBegin, m_selectedBlock.dtEnd) + COleDateTimeSpan(1, 0, 0, 0);
  1203. }
  1205. return TRUE;
  1207. }
  1209. void CXTPCalendarView::SetSelection(const COleDateTime& dtBegin, const COleDateTime& dtEnd,
  1210. BOOL bAllDayEvent, int nGroupIndex)
  1211. {
  1212. m_selectedBlock.dtBegin = dtBegin;
  1213. m_selectedBlock.dtEnd = dtEnd;
  1214. m_selectedBlock.bAllDayEvent = bAllDayEvent;
  1215. m_selectedBlock.nGroupIndex = nGroupIndex;
  1217. CSelectionChangedContext selChanged(this, xtpCalendarSelectionDays);
  1218. }
  1220. void CXTPCalendarView::ResetSelection()
  1221. {
  1222. m_selectedBlock.dtBegin.SetStatus(COleDateTime::null);
  1223. m_selectedBlock.dtEnd.SetStatus(COleDateTime::null);
  1225. m_selectedBlock.bAllDayEvent = FALSE;
  1226. m_selectedBlock.nGroupIndex = -1;
  1228. CSelectionChangedContext selChanged(this, xtpCalendarSelectionDays);
  1229. }
  1231. BOOL CXTPCalendarView::SelectionContains(COleDateTime date, int nGroupIndex, BOOL* pbAllDaySelection)
  1232. {
  1233. COleDateTime dtBegin;
  1234. COleDateTime dtEnd;
  1235. int nSelGroupIndex;
  1237. if (GetSelection(&dtBegin, &dtEnd, pbAllDaySelection, &nSelGroupIndex))
  1238. {
  1239. if (nGroupIndex < 0 || nGroupIndex == nSelGroupIndex)
  1240. {
  1241. return (dtBegin <= date && (double)date <= (double)dtEnd - XTP_HALF_SECOND);
  1242. }
  1243. }
  1245. return FALSE;
  1246. }
  1249. COleDateTime CXTPCalendarView::GetNextTimeEditByTAB()
  1250. {
  1251. ASSERT(GetViewDayCount() != 0);
  1253. COleDateTime dtDay;
  1255. if (m_selectedBlock.dtEnd.GetStatus() == COleDateTime::valid)
  1256. {
  1257. dtDay = m_selectedBlock.dtEnd;
  1258. }
  1259. else
  1260. {
  1261. dtDay = GetViewDayDate(0);
  1262. }
  1264. dtDay = CXTPCalendarUtils::ResetTime(dtDay);
  1265. return dtDay;
  1266. }
  1268. void CXTPCalendarView::UpdateNextTimeEditByTAB(COleDateTime dtNext, BOOL /*bReverse*/, BOOL /*bReset*/)
  1269. {
  1270. COleDateTime dtNextDay = CXTPCalendarUtils::ResetTime(dtNext);
  1271. COleDateTime dtCurrDay = CXTPCalendarUtils::ResetTime(GetNextTimeEditByTAB());
  1272. if (dtNextDay != dtCurrDay)
  1273. {
  1274. SelectDay(dtNextDay);
  1275. }
  1276. }
  1278. CXTPCalendarViewEvent* CXTPCalendarView::FindEventToEditByTAB(COleDateTime dtMinStart,
  1279. BOOL bReverse, CXTPCalendarEvent* pAfterEvent)
  1280. {
  1281. COleDateTime dtMinStartDay = CXTPCalendarUtils::ResetTime(dtMinStart);
  1282. COleDateTime dtMinStart2 = dtMinStartDay + COleDateTimeSpan(1, 0, 0, 0);
  1284. BOOL bAfterEventWas = pAfterEvent == NULL;
  1285. if (pAfterEvent)
  1286. {
  1287. COleDateTime dtAEStartDay = CXTPCalendarUtils::ResetTime(pAfterEvent->GetStartTime());
  1288. if (bReverse ? dtAEStartDay > dtMinStartDay : dtAEStartDay < dtMinStartDay)
  1289. {
  1290. bAfterEventWas = TRUE;
  1291. }
  1292. }
  1294. int nDays = GetViewDayCount();
  1295. for (int nDay = bReverse ? nDays-1 : 0; bReverse ? nDay >= 0 : nDay < nDays;
  1296. bReverse ? nDay-- : nDay++)
  1297. {
  1298. CXTPCalendarViewDay* pVDay = GetViewDay_(nDay);
  1299. if (!pVDay)
  1300. {
  1301. ASSERT(FALSE);
  1302. continue;
  1303. }
  1305. COleDateTime dtDay = pVDay->GetDayDate();
  1307. if (bReverse ? dtDay > dtMinStartDay : dtDay < dtMinStartDay)
  1308. {
  1309. continue;
  1310. }
  1312. int nGroupsCount = pVDay->GetViewGroupsCount();
  1313. for (int nGroup = bReverse ? nGroupsCount - 1 : 0;
  1314.  bReverse ? nGroup >= 0 : nGroup < nGroupsCount;
  1315.  bReverse ? nGroup-- : nGroup++)
  1316. {
  1317. CXTPCalendarViewGroup* pViewGroup = pVDay->GetViewGroup_(nGroup);
  1318. ASSERT(pViewGroup);
  1319. if (!pViewGroup)
  1320. {
  1321. continue;
  1322. }
  1324. int nEvents = pViewGroup->GetViewEventsCount();
  1325. for (int nEvent = bReverse ? nEvents - 1 : 0;
  1326.  bReverse ? nEvent >= 0 : nEvent < nEvents;
  1327.  bReverse ? nEvent-- : nEvent++)
  1328. {
  1329. CXTPCalendarViewEvent* pVEvent = pViewGroup->GetViewEvent_(nEvent);
  1330. if (!pVEvent || !pVEvent->GetEvent())
  1331. {
  1332. ASSERT(FALSE);
  1333. continue;
  1334. }
  1336. if (pAfterEvent)
  1337. {
  1338. if (pAfterEvent->IsEqualIDs(pVEvent->GetEvent()))
  1339. {
  1340. bAfterEventWas = TRUE;
  1341. continue;
  1342. }
  1343. }
  1344. COleDateTime dtES = pVEvent->GetEvent()->GetStartTime();
  1345. COleDateTime dtESDay = CXTPCalendarUtils::ResetTime(dtES);
  1347. if (bReverse ? (dtES > dtMinStart2 || dtESDay != dtDay) :
  1348. (dtES < dtMinStart || dtESDay < dtDay))
  1349. {
  1350. continue;
  1351. }
  1353. if (bAfterEventWas)
  1354. {
  1355. return pVEvent;
  1356. }
  1357. }
  1358. }
  1359. }
  1360. return NULL;
  1361. }
  1363. void CXTPCalendarView::UnselectAllEvents()
  1364. {
  1365. if (!m_pSelectedEvents || !GetCalendarControl())
  1366. {
  1367. return;
  1368. }
  1370. int nCount = m_pSelectedEvents->GetCount();
  1371. m_pSelectedEvents->RemoveAll();
  1373. if (nCount)
  1374. {
  1375. CXTPCalendarControl::CUpdateContext updateContext(GetCalendarControl(), xtpCalendarUpdateRedraw);
  1376. CSelectionChangedContext selChanged(this, xtpCalendarSelectionEvents);
  1377. }
  1378. }
  1380. void CXTPCalendarView::_ReSelectSelectEvents()
  1381. {
  1382. if (!m_pSelectedEvents)
  1383. {
  1384. return;
  1385. }
  1387. CXTPCalendarViewEventsPtr ptrSelEvents = GetSelectedEvents();
  1389. m_pSelectedEvents->RemoveAll();
  1391. if (ptrSelEvents)
  1392. {
  1393. int nCount = ptrSelEvents->GetCount();
  1394. for (int i = 0; i < nCount; i++)
  1395. {
  1396. if (ptrSelEvents->GetAt(i))
  1397. {
  1398. SelectEvent(ptrSelEvents->GetAt(i)->GetEvent());
  1399. }
  1400. }
  1401. }
  1402. }
  1404. void CXTPCalendarView::SelectDays(COleDateTime dtNewSel)
  1405. {
  1406. CXTPCalendarControl::CUpdateContext updateContext(GetCalendarControl(), xtpCalendarUpdateRedraw);
  1407. m_selectedBlock.dtEnd = dtNewSel;
  1409. CSelectionChangedContext selChanged(this, xtpCalendarSelectionDays);
  1410. }
  1412. void CXTPCalendarView::SelectDay(COleDateTime dtSelDay, int nGroupIndex)
  1413. {
  1414. CXTPCalendarControl::CUpdateContext updateContext(GetCalendarControl(), xtpCalendarUpdateRedraw);
  1416. m_selectedBlock.dtBegin = m_selectedBlock.dtEnd = dtSelDay;
  1417. m_selectedBlock.nGroupIndex = nGroupIndex;
  1419. CSelectionChangedContext selChanged(this, xtpCalendarSelectionDays);
  1420. }
  1422. void CXTPCalendarView::SelectDay(CXTPCalendarViewDay* pDay, int nGroupIndex)
  1423. {
  1424. ASSERT(pDay);
  1425. if (pDay)
  1426. {
  1427. SelectDay(pDay->GetDayDate(), nGroupIndex);
  1428. }
  1429. }
  1431. void CXTPCalendarView::SelectViewEvent(CXTPCalendarViewEvent* pViewEvent, BOOL bSelect)
  1432. {
  1433. if (!m_pSelectedEvents || !pViewEvent || !pViewEvent->GetEvent())
  1434. {
  1435. ASSERT(FALSE);
  1436. return;
  1437. }
  1439. m_pSelectedEvents->Remove(pViewEvent->GetEvent());
  1441. if (bSelect)
  1442. {
  1443. pViewEvent->InternalAddRef();
  1444. m_pSelectedEvents->Add(pViewEvent);
  1445. }
  1446. CSelectionChangedContext selChanged(this, xtpCalendarSelectionEvents);
  1447. }
  1449. CXTPCalendarViewEvent* CXTPCalendarView::GetLastSelectedViewEvent()
  1450. {
  1451. if (m_pSelectedEvents && m_pSelectedEvents->GetCount() > 0)
  1452. return m_pSelectedEvents->GetAt(m_pSelectedEvents->GetCount() - 1);
  1454. return NULL;
  1455. }
  1457. void CXTPCalendarView::SelectEvent(CXTPCalendarEvent* pEvent, BOOL bSelect)
  1458. {
  1459. if (!pEvent)
  1460. {
  1461. ASSERT(FALSE);
  1462. return;
  1463. }
  1464. int nCount = GetViewDayCount();
  1465. for (int i = 0; i < nCount; i++)
  1466. {
  1467. CXTPCalendarViewDay* pViewDay = GetViewDay_(i);
  1468. if (!pViewDay)
  1469. {
  1470. ASSERT(FALSE);
  1471. continue;
  1472. }
  1474. int nGroupsCount = pViewDay->GetViewGroupsCount();
  1475. for (int g = 0; g < nGroupsCount; g++)
  1476. {
  1477. CXTPCalendarViewGroup* pViewGroup = pViewDay->GetViewGroup_(g);
  1478. ASSERT(pViewGroup);
  1479. if (!pViewGroup)
  1480. {
  1481. continue;
  1482. }
  1484. int nECount = pViewGroup->GetViewEventsCount();
  1485. for (int j = 0; j < nECount; j++)
  1486. {
  1487. CXTPCalendarViewEvent* pViewEvent = pViewGroup->GetViewEvent_(j);
  1488. CXTPCalendarEvent* pEv = pViewEvent ? pViewEvent->GetEvent() : NULL;
  1489. ASSERT(pEv);
  1490. if (pEv && pEvent->IsEqualIDs(pEv) && pEvent->IsEqualStartEnd(pEv))
  1491. {
  1492. CXTPCalendarControl::CUpdateContext updateContext(GetCalendarControl(), xtpCalendarUpdateRedraw);
  1493. SelectViewEvent(pViewEvent, bSelect);
  1494. }
  1495. }
  1496. }
  1497. }
  1498. }
  1500. BOOL CXTPCalendarView::OnDragging(CPoint /*point*/, XTP_CALENDAR_HITTESTINFO* pHitTest)
  1501. {
  1502. ASSERT(pHitTest);
  1503. if (!pHitTest || !m_ptrDraggingEventNew || m_eDraggingMode == xtpCalendaDragModeEditSubject)
  1504. {
  1505. return FALSE;
  1506. }
  1507. //---------------------------------------------------------------------------
  1508. if (pHitTest->pViewDay)
  1509. {
  1510. if (m_eDraggingMode == xtpCalendaDragModeResizeBegin || m_eDraggingMode == xtpCalendaDragModeResizeEnd)
  1511. {
  1512. SelectDay(pHitTest->pViewDay, pHitTest->nGroup);
  1513. }
  1514. }
  1515. //---------------------------------------------------------------------------
  1516. COleDateTime dtNewTime;
  1518. if (_IsDragModeCopyMove(m_eDraggingMode))
  1519. {
  1520. if (!pHitTest->bTimePartValid)
  1521. {
  1522. dtNewTime = CXTPCalendarUtils::UpdateDate(m_ptrDraggingEventNew->GetStartTime(), pHitTest->dt);
  1523. }
  1524. else
  1525. {
  1526. dtNewTime = pHitTest->dt;
  1527. }
  1528. dtNewTime -= m_spDraggingStartOffset;
  1530. BOOL bChanged = FALSE;
  1531. //------------------------------------
  1532. if (!CXTPCalendarUtils::IsEqual(dtNewTime, m_ptrDraggingEventNew->GetStartTime()))
  1533. {
  1534. m_ptrDraggingEventNew->MoveEvent(dtNewTime);
  1535. bChanged = TRUE;
  1536. }
  1538. //***
  1539. if (bChanged)
  1540. {
  1541. return TRUE;
  1542. }
  1543. }
  1544. else if (m_eDraggingMode == xtpCalendaDragModeResizeBegin)
  1545. {
  1546. dtNewTime = pHitTest->dt;
  1547. COleDateTime dtEventEnd = m_ptrDraggingEventNew->GetEndTime();
  1549. if (!CXTPCalendarUtils::IsEqual(dtNewTime, m_ptrDraggingEventNew->GetStartTime()))
  1550. {
  1551. if (dtNewTime > dtEventEnd)
  1552. {
  1553. dtNewTime = dtEventEnd;
  1554. }
  1556. m_ptrDraggingEventNew->SetStartTime(dtNewTime);
  1558. BOOL bIsZeroStartEnd = CXTPCalendarUtils::IsZeroTime(m_ptrDraggingEventNew->GetStartTime()) &&
  1559. CXTPCalendarUtils::IsZeroTime(m_ptrDraggingEventNew->GetEndTime());
  1561. BOOL bIsZeroLen = CXTPCalendarUtils::IsEqual(m_ptrDraggingEventNew->GetStartTime(),
  1562. m_ptrDraggingEventNew->GetEndTime());
  1564. m_ptrDraggingEventNew->SetAllDayEvent(bIsZeroStartEnd && !bIsZeroLen);
  1566. return TRUE;
  1567. }
  1568. }
  1569. else if (m_eDraggingMode == xtpCalendaDragModeResizeEnd)
  1570. {
  1571. dtNewTime = pHitTest->dt;
  1573. if (!pHitTest->bTimePartValid)
  1574. {
  1575. dtNewTime += COleDateTimeSpan(1, 0, 0, 0);
  1576. }
  1578. COleDateTime dtEventStart = m_ptrDraggingEventNew->GetStartTime();
  1579. if (!CXTPCalendarUtils::IsEqual(dtNewTime, m_ptrDraggingEventNew->GetEndTime()))
  1580. {
  1581. if ((pHitTest->uHitCode & xtpCalendarHitTestDayViewTimeScale) &&
  1582. (pHitTest->pViewDay == NULL))
  1583. {
  1584. dtNewTime.SetDateTime(
  1585. dtEventStart.GetYear(), dtEventStart.GetMonth(), dtEventStart.GetDay(),
  1586. dtNewTime.GetHour(), dtNewTime.GetMinute(), dtNewTime.GetSecond());
  1587. }
  1589. if (dtNewTime < dtEventStart)
  1590. {
  1591. dtNewTime = dtEventStart;
  1592. }
  1594. m_ptrDraggingEventNew->SetEndTime(dtNewTime);
  1596. BOOL bIsZeroStartEnd = CXTPCalendarUtils::IsZeroTime(m_ptrDraggingEventNew->GetStartTime()) &&
  1597. CXTPCalendarUtils::IsZeroTime(m_ptrDraggingEventNew->GetEndTime());
  1599. BOOL bIsZeroLen = CXTPCalendarUtils::IsEqual(m_ptrDraggingEventNew->GetStartTime(),
  1600. m_ptrDraggingEventNew->GetEndTime());
  1602. m_ptrDraggingEventNew->SetAllDayEvent(bIsZeroStartEnd && !bIsZeroLen);
  1604. return TRUE;
  1605. }
  1606. }
  1608. return FALSE;
  1609. }
  1611. COleDateTime CXTPCalendarView::GetLastSelectedDate()
  1612. {
  1613. if (m_selectedBlock.dtEnd.GetStatus() != COleDateTime::valid)
  1614. {
  1615. return GetViewDayDate(GetViewDayCount() / 2);
  1616. }
  1617. return CXTPCalendarUtils::ResetTime(m_selectedBlock.dtEnd);
  1618. }
  1620. int CXTPCalendarView::FindLastSelectedDay()
  1621. {
  1622. COleDateTime dt = GetLastSelectedDate();
  1624. int nCount = GetViewDayCount();
  1625. for (int i = 0; i < nCount; i++)
  1626. {
  1627. CXTPCalendarViewDay* pViewDay = GetViewDay_(i);
  1628. ASSERT(pViewDay);
  1629. if (pViewDay && CXTPCalendarUtils::IsEqual(pViewDay->GetDayDate(), dt))
  1630. return i;
  1631. }
  1632. return -1;
  1633. }
  1635. void CXTPCalendarView::ProcessDaySelection(XTP_CALENDAR_HITTESTINFO* pInfo, UINT nFlags)
  1636. {
  1637. ASSERT(pInfo);
  1638. if (!pInfo)
  1639. {
  1640. UnselectAllEvents();
  1641. return;
  1642. }
  1644. if (nFlags & MK_SHIFT)
  1645. {
  1646. COleDateTime dtNewSelDay = GetViewDayDate(pInfo->nDay);
  1647. SelectDays(dtNewSelDay);
  1648. }
  1649. else
  1650. {
  1651. UnselectAllEvents();
  1653. ASSERT(pInfo->pViewDay);
  1654. if (pInfo->pViewDay)
  1655. {
  1656. pInfo->pViewDay->SetSelected();
  1657. }
  1658. }
  1659. }
  1661. void CXTPCalendarView::ProcessEventSelection(XTP_CALENDAR_HITTESTINFO* pInfo, UINT nFlags)
  1662. {
  1663. ASSERT(pInfo);
  1664. if (!pInfo)
  1665. {
  1666. return;
  1667. }
  1669. BOOL bUnselectEvents = !(nFlags & (MK_SHIFT | MK_CONTROL));
  1670. if (bUnselectEvents)
  1671. UnselectAllEvents();
  1673. ASSERT(pInfo->pViewDay);
  1674. ASSERT(pInfo->pViewEvent);
  1676. if (pInfo->pViewDay)
  1677. {
  1678. pInfo->pViewDay->SetSelected();
  1679. }
  1681. if (pInfo->pViewEvent)
  1682. {
  1684. BOOL bSelect = TRUE;
  1685. if (nFlags & MK_CONTROL)
  1686. {
  1687. bSelect = !pInfo->pViewEvent->IsSelected();
  1688. }
  1689. SelectEvent(pInfo->pViewEvent->GetEvent(), bSelect);
  1690. }
  1691. }
  1693. UINT CXTPCalendarView::SetTimer(UINT uTimeOut_ms)
  1694. {
  1695. if (GetCalendarControl())
  1696. {
  1697. return GetCalendarControl()->SetTimer(uTimeOut_ms);
  1698. }
  1699. return 0;
  1700. }
  1702. void CXTPCalendarView::KillTimer(UINT uTimerID)
  1703. {
  1704. if (GetCalendarControl())
  1705. {
  1706. VERIFY(GetCalendarControl()->KillTimer(uTimerID));
  1707. }
  1708. }
  1710. BOOL CXTPCalendarView::OnTimer(UINT_PTR uTimerID)
  1711. {
  1712. if (TBase::OnTimer(uTimerID))
  1713. {
  1714. return TRUE;
  1715. }
  1717. CXTPCalendarThemeOffice2007* pThemeX = DYNAMIC_DOWNCAST(CXTPCalendarThemeOffice2007, GetTheme());
  1718. if (pThemeX)
  1719. {
  1720. if (pThemeX->OnTimer(uTimerID))
  1721. return TRUE;
  1722. }
  1724. //---------------------------------------------------------------------------
  1725. if (uTimerID == m_nTimerID_StartEditSubject)
  1726. {
  1727. TRACE_EDIT_SUBJECT(_T("Edit SUBJECT - KillTimer() [CXTPCalendarView::OnTimer(ID =%d)] n"), uTimerID);
  1729. KillTimer(m_nTimerID_StartEditSubject);
  1730. m_nTimerID_StartEditSubject = 0;
  1732. ASSERT(m_ptrEditingViewEvent);
  1733. if (m_ptrEditingViewEvent)
  1734. {
  1735. TRACE_EDIT_SUBJECT(_T("Edit SUBJECT - StartEditSubject(). [CXTPCalendarView::OnTimer(ID =%d)] n"), uTimerID);
  1737. EmptyUndoBuffer();
  1738. StartEditSubject(m_ptrEditingViewEvent);
  1739. }
  1740. return TRUE;
  1741. }
  1742. else if (uTimerID == m_nKeyStateTimerID)
  1743. {
  1744. BOOL bIsCtrl = (::GetKeyState(VK_CONTROL) & 0x8000) != 0;
  1745. XTPCalendarDraggingMode eDraggingMode = bIsCtrl ? xtpCalendaDragModeCopy : xtpCalendaDragModeMove;
  1747. BOOL bPopulate = FALSE;
  1749. if (!_IsDragModeCopyMove(m_eDraggingMode))
  1750. {
  1751. KillTimer(m_nKeyStateTimerID);
  1752. m_nKeyStateTimerID = 0;
  1753. }
  1754. else if (m_eDraggingMode != eDraggingMode)
  1755. {
  1756. ASSERT(m_ptrDraggingEventNew);
  1757. if (m_ptrDraggingEventNew)
  1758. {
  1759. CXTPCalendarViewEvent* pEventView = FindViewEvent(m_ptrDraggingEventNew, m_ptrDraggingEventNew->GetStartTime());
  1760. if (!IsEditOperationDisabledNotify(_DragMod2Operation(eDraggingMode), pEventView))
  1761. {
  1762. m_eDraggingMode = eDraggingMode;
  1763. bPopulate = TRUE;
  1764. }
  1765. }
  1766. }
  1768. if (bPopulate && GetCalendarControl())
  1769. {
  1770. GetCalendarControl()->Populate();
  1772. GetCalendarControl()->m_mouseMode = m_eDraggingMode == xtpCalendaDragModeCopy ?
  1773. xtpCalendarMouseEventDragCopy : xtpCalendarMouseEventDragMove;
  1775. GetCalendarControl()->UpdateMouseCursor();
  1776. }
  1777. return TRUE;
  1778. }
  1779. else if (uTimerID == m_nTimerID_ShowToolTip)
  1780. {
  1781. ShowToolTip();
  1782. return TRUE;
  1783. }
  1785. return FALSE;
  1786. }
  1788. BOOL CXTPCalendarView::OnLButtonDblClk(UINT nFlags, CPoint point)
  1789. {
  1790. if (m_nTimerID_StartEditSubject)
  1791. {
  1792. KillTimer(m_nTimerID_StartEditSubject);
  1793. m_nTimerID_StartEditSubject = 0;
  1794. m_ptrEditingViewEvent = NULL;
  1795. }
  1797. TRACE_MOUSE(_T("OnLButtonDblClk - [CXTPCalendarView] (nFlags =%x, point.x =%d, point.y =%d) n"), nFlags, point.x, point.y);
  1799. return TBase::OnLButtonDblClk(nFlags, point);
  1800. }
  1802. void CXTPCalendarView::OnDraw(CDC* pDC)
  1803. {
  1804. if (GetTheme())
  1805. {
  1806. Draw2(pDC);
  1807. }
  1808. else
  1809. {
  1810. Draw(pDC);
  1811. }
  1812. }
  1814. void CXTPCalendarView::AdjustLayout(CDC* pDC, const CRect& rcView, BOOL bCallPostAdjustLayout)
  1815. {
  1816. UNREFERENCED_PARAMETER(pDC);
  1818. //  #pragma  NOTE("for beginning development time. uncomment later.")
  1819. //  ASSERT(!GetTheme());
  1821. m_rcView = rcView;
  1822. _CalculateEventTimeFormat();
  1824. if (bCallPostAdjustLayout)
  1825. {
  1826. OnPostAdjustLayout();
  1827. }
  1828. }
  1830. void CXTPCalendarView::AdjustLayout2(CDC* pDC, const CRect& rcView, BOOL bCallPostAdjustLayout)
  1831. {
  1832. UNREFERENCED_PARAMETER(pDC);
  1833. UNREFERENCED_PARAMETER(bCallPostAdjustLayout);
  1835. ASSERT(GetTheme());
  1837. m_rcView = rcView;
  1838. //_CalculateEventTimeFormat();
  1840. //  if (bCallPostAdjustLayout)
  1841. //  {
  1842. //      OnPostAdjustLayout();
  1843. //  }
  1844. }
  1846. CXTPCalendarViewDay* CXTPCalendarView::_GetViewDay(const COleDateTime& dt)
  1847. {
  1848. COleDateTime dtDay = CXTPCalendarUtils::ResetTime(dt);
  1849. int nDaysCount = GetViewDayCount();
  1851. if (!nDaysCount || !GetViewDay_(0))
  1852. {
  1853. return NULL;
  1854. }
  1856. COleDateTime dtDay0 = GetViewDay_(0)->GetDayDate();
  1858. COleDateTimeSpan spShift = dtDay - dtDay0;
  1860. ASSERT((double)spShift == (double)((int)(double)spShift) );
  1862. int nShift = GETTOTAL_DAYS_DTS(spShift); //(int)(double)spShift
  1864. if (nShift < 0)
  1865. {
  1866. nShift = 0;
  1867. }
  1868. if (nShift >= nDaysCount)
  1869. {
  1870. nShift = nDaysCount - 1;
  1871. }
  1873. if (nShift >= 0 && nShift < nDaysCount)
  1874. {
  1875. return GetViewDay_(nShift);
  1876. }
  1878. return NULL;
  1879. }
  1881. void CXTPCalendarView::StartEditNewEventInplace(LPCTSTR pcszInitialSubject)
  1882. {
  1883. if (m_ptrDraggingEventOrig || m_ptrDraggingEventNew || IsEditingSubject())
  1884. {
  1885. MessageBeep(0);
  1886. return;
  1887. }
  1889. BOOL bAllDayEvent = FALSE;
  1890. //---------------------------------------------------------------------------
  1891. COleDateTime dtSelBegin, dtSelEnd;
  1892. int nGroup = 0;
  1893. if (!GetSelection(&dtSelBegin, &dtSelEnd, &bAllDayEvent, &nGroup))
  1894. {
  1895. return;
  1896. }
  1898. //---------------------------------------------------------------------------
  1899. CXTPCalendarData* pData = NULL; //XTP_SAFE_GET1(GetCalendarControl(), GetDataProvider(), NULL);
  1901. CXTPCalendarViewDay* pViewDay = _GetViewDay(dtSelBegin);
  1902. if (!pViewDay)
  1903. {
  1904. return;
  1905. }
  1906. CXTPCalendarViewGroup* pViewGroup = NULL;
  1907. if (pViewDay && nGroup < pViewDay->GetViewGroupsCount() )
  1908. {
  1909. pViewGroup = pViewDay->GetViewGroup_(nGroup);
  1910. pData = pViewGroup ? pViewGroup->GetDataProvider() : NULL;
  1911. }
  1913. //--------------------
  1914. m_ptrDraggingEventNew = pData ? pData->CreateNewEvent() : NULL;
  1915. if (!m_ptrDraggingEventNew)
  1916. {
  1917. return;
  1918. }
  1920. //---------------------------------------------------------------------------
  1921. UINT uScheduleID = XTP_SAFE_GET1(pViewGroup, GetScheduleID(), 0);
  1922. m_ptrDraggingEventNew->SetScheduleID(uScheduleID);
  1924. m_ptrDraggingEventNew->SetStartTime(min(dtSelBegin, dtSelEnd));
  1925. m_ptrDraggingEventNew->SetEndTime(max(dtSelBegin, dtSelEnd));
  1927. m_ptrDraggingEventNew->SetBusyStatus(bAllDayEvent ? xtpCalendarBusyStatusFree : xtpCalendarBusyStatusBusy);
  1928. m_ptrDraggingEventNew->SetAllDayEvent(bAllDayEvent);
  1930. //===========================================================================
  1931. XTP_SAFE_CALL1(GetCalendarControl(), Populate());
  1932. XTP_SAFE_CALL1(GetCalendarControl(), AdjustLayout());
  1934. //---------------------------------------------------------------------------
  1935. COleDateTime dtEventDay = m_ptrDraggingEventNew->GetStartTime();
  1936. dtEventDay = CXTPCalendarUtils::ResetTime(dtEventDay);
  1938. CXTPCalendarViewEvent* pViewEvent = FindViewEvent(m_ptrDraggingEventNew, dtEventDay);
  1940. if (!pViewEvent)
  1941. {
  1942. CancelDraggingEvent();
  1943. return;
  1944. }
  1946. StartEditSubject(pViewEvent);
  1948. CEdit* pEditor = DYNAMIC_DOWNCAST(CEdit, pViewEvent->GetSubjectEditor());
  1950. if (pEditor)
  1951. {
  1952. pEditor->SetWindowText(pcszInitialSubject);
  1953. int nInitTxtLen = (int)_tcsclen(pcszInitialSubject);
  1954. pEditor->SetSel(nInitTxtLen, nInitTxtLen);
  1955. }
  1956. }
  1958. void CXTPCalendarView::StartEditSubject(CXTPCalendarViewEvent* pViewEvent)
  1959. {
  1960. if (!pViewEvent)
  1961. {
  1962. ASSERT(FALSE);
  1963. return;
  1964. }
  1965. TRACE_EDIT_SUBJECT(_T("Edit SUBJECT - StartEditSubject(). [CXTPCalendarView] n"));
  1967. //---------------------------------------------------------------------------
  1968. if (m_nTimerID_StartEditSubject)
  1969. {
  1970. TRACE_EDIT_SUBJECT(_T("Edit SUBJECT - KillTimer() [CXTPCalendarView::StartEditSubject] n"));
  1972. KillTimer(m_nTimerID_StartEditSubject);
  1973. m_nTimerID_StartEditSubject = 0;
  1974. }
  1975. //---------------------------------------------------------------------------
  1977. m_ptrEditingViewEvent = pViewEvent->StartEditSubject();
  1979. if (!m_ptrEditingViewEvent)
  1980. {
  1981. ASSERT(FALSE);
  1982. return;
  1983. }
  1984. CXTPCalendarControl::CUpdateContext updateContext(m_pControl, xtpCalendarUpdateRedraw);
  1986. m_ptrEditingViewEvent->InternalAddRef();
  1987. m_eDraggingMode = xtpCalendaDragModeEditSubject;
  1989. if (!m_ptrDraggingEventOrig && !m_ptrDraggingEventNew)
  1990. {
  1991. SetDraggingEvent(m_ptrEditingViewEvent->GetEvent());
  1992. }
  1994. SelectEvent(m_ptrDraggingEventNew);
  1995. }
  1997. void CXTPCalendarView::EndEditSubject(XTPCalendarEndEditSubjectAction eAction, BOOL bUpdateControl)
  1998. {
  2000. TRACE_EDIT_SUBJECT(_T("Edit SUBJECT - EndEditSubject(). [CXTPCalendarView] n"));
  2002. m_eDraggingMode = xtpCalendaDragModeUnknown;
  2004. // kill timeout request to edit subject
  2005. if (m_nTimerID_StartEditSubject)
  2006. {
  2007. ASSERT(m_ptrEditingViewEvent && !m_ptrDraggingEventOrig && !m_ptrDraggingEventNew);
  2009. TRACE_EDIT_SUBJECT(_T("Edit SUBJECT - KillTimer() [CXTPCalendarView::EndEditSubject] n"));
  2011. KillTimer(m_nTimerID_StartEditSubject);
  2012. m_nTimerID_StartEditSubject = 0;
  2013. m_ptrEditingViewEvent = NULL;
  2014. return;
  2015. }
  2017. ASSERT(m_ptrEditingViewEvent && m_ptrDraggingEventNew);
  2019. CXTPCalendarEventPtr ptrEventToSelect(m_ptrDraggingEventNew, TRUE);
  2021. BOOL bPopulate = FALSE;
  2022. CString strNewSubject;
  2024. //- end edit subject operation in Event view (kill edit wnd) ----------------
  2025. if (m_ptrEditingViewEvent)
  2026. {
  2027. strNewSubject = m_ptrEditingViewEvent->EndEditSubject();
  2028. }
  2029. m_ptrEditingViewEvent = NULL;
  2031. //---------------------------------------------------------------------------
  2032. if (m_ptrDraggingEventNew)
  2033. {
  2034. if (eAction == xtpCalendarEditSubjectCommit)
  2035. {
  2036. m_ptrDraggingEventNew->SetSubject(strNewSubject);
  2038. bPopulate = CommitDraggingEvent();
  2039. TRACE_DRAGGING(_T("Dragging - CommitDraggingEvent() = %d. [CXTPCalendarView::EndEditSubject] n"), bPopulate);
  2041. }
  2042. else
  2043. if (eAction == xtpCalendarEditSubjectCancel)
  2044. {
  2045. TRACE_DRAGGING(_T("Dragging - CancelDraggingEvent. [CXTPCalendarView::EndEditSubject] n"));
  2047. ptrEventToSelect.SetPtr(m_ptrDraggingEventOrig, TRUE);
  2049. CancelDraggingEvent();
  2050. bPopulate = TRUE;
  2051. }
  2052. else
  2053. {
  2054. ASSERT(FALSE);
  2055. }
  2056. }
  2058. if (bUpdateControl && bPopulate && GetCalendarControl())
  2059. {
  2060. GetCalendarControl()->Populate();
  2062. if (ptrEventToSelect)
  2063. {
  2064. SelectEvent(ptrEventToSelect, TRUE);
  2065. }
  2066. }
  2067. }
  2069. void CXTPCalendarView::OnUpdateEditingSubject(CString strNewSubject)
  2070. {
  2071. TRACE_EDIT_SUBJECT(_T("Edit SUBJECT - OnUpdateEditingSubject('%s'). [CXTPCalendarView] n"), strNewSubject);
  2073. ASSERT(m_ptrEditingViewEvent && m_ptrDraggingEventNew);
  2075. if (m_ptrEditingViewEvent && m_ptrDraggingEventNew)
  2076. {
  2077. m_ptrDraggingEventNew->SetSubject(strNewSubject);
  2078. }
  2079. }
  2081. CRect CXTPCalendarView::GetSubjectEditorRect() const
  2082. {
  2083. ASSERT(m_ptrEditingViewEvent);
  2084. if (m_ptrEditingViewEvent)
  2085. {
  2086. return m_ptrEditingViewEvent->GetSubjectEditorRect();
  2087. }
  2089. return CRect(INT_MAX, INT_MAX, INT_MAX, INT_MAX);
  2090. }
  2092. CRect CXTPCalendarView::GetTooltipRect(const CPoint& ptHit, const XTP_CALENDAR_HITTESTINFO& hitInfo)
  2093. {
  2094. CRect rcTip;
  2095. rcTip.SetRectEmpty();
  2097. if (hitInfo.pViewGroup)
  2098. {
  2099. rcTip = hitInfo.pViewGroup->GetTooltipRect(ptHit, hitInfo);
  2101. CXTPCalendarThemeOffice2007* pThemeX = DYNAMIC_DOWNCAST(CXTPCalendarThemeOffice2007, GetTheme());
  2102. if (pThemeX)
  2103. {
  2104. CRect rcExclude = XTP_SAFE_GET2(pThemeX->GetPrevNextEventControllerPartX(),
  2105. GetNextEventButtonPartX(), GetRect(), CRect(0, 0, 0, 0));
  2106. if (!(rcTip.top > rcExclude.bottom || rcTip.bottom < rcExclude.top) &&
  2107. rcTip.right >= rcExclude.left)
  2108. {
  2109. rcTip.right = rcExclude.left - 1;
  2110. }
  2112. rcExclude = XTP_SAFE_GET2(pThemeX->GetPrevNextEventControllerPartX(),
  2113. GetPrevEventButtonPartX(), GetRect(), CRect(0, 0, 0, 0));
  2115. if (!(rcTip.top > rcExclude.bottom || rcTip.bottom < rcExclude.top) &&
  2116. rcTip.left <= rcExclude.right)
  2117. {
  2118. rcTip.left = rcExclude.right + 1;
  2119. }
  2120. }
  2121. }
  2123. return rcTip;
  2124. }
  2126. void CXTPCalendarView::ShowToolTip(BOOL bShow)
  2127. {
  2128. if (m_nTimerID_ShowToolTip)
  2129. {
  2130. KillTimer(m_nTimerID_ShowToolTip);
  2131. m_nTimerID_ShowToolTip = 0;
  2132. }
  2133. if (!bShow)
  2134. {
  2135. // hide a tooltip
  2136. GetCalendarControl()->HideToolTip();
  2137. return;
  2138. }
  2139. if (GetCalendarControl()->IsToolTipVisible())
  2140. {
  2141. return;
  2142. }
  2144. // Verify whether mouse is still under tooltip rect
  2145. CRect rcTooltip;
  2146. rcTooltip.SetRectEmpty();
  2148. CPoint pt;
  2149. GetCursorPos(&pt);
  2150. GetCalendarControl()->ScreenToClient(&pt);
  2152. XTP_CALENDAR_HITTESTINFO hitInfo;
  2153. BOOL bHitTest = HitTest(pt, &hitInfo);
  2154. if (bHitTest)
  2155. {
  2156. rcTooltip = GetTooltipRect(pt, hitInfo);
  2157. }
  2159. if (m_rcTooltip != rcTooltip)
  2160. m_rcTooltip.SetRectEmpty();
  2162. if (m_rcTooltip.IsRectEmpty())
  2163. return;
  2165. // if we are under event view -- do not show this tooltip
  2166. if (NULL != hitInfo.pViewEvent)
  2167. return;
  2169. // Verify whether tooltip option is enabled
  2170. BOOL bTipEnabled = XTP_SAFE_GET2(GetCalendarControl(), GetCalendarOptions(), bEnableAddNewTooltip, TRUE);
  2171. if (!bTipEnabled)
  2172. return;
  2174. // create tooltip text
  2175. CString strTip = XTP_SAFE_GET2(GetCalendarControl(), GetCalendarOptions(), strTooltipAddNewText, _T("Click to add appointment"));
  2177. // show tooltip window
  2178. CXTPCalendarControl* pCal = GetCalendarControl();
  2179. if (pCal)
  2180. {
  2181. CFont* pFont = &XTP_SAFE_GET2(GetPaintManager(), GetDayViewEventPart(), GetTextFont(), *((CFont*)(NULL)));
  2182. pCal->ShowToolTip(strTip, m_rcTooltip, pFont, TRUE);
  2183. }
  2184. }
  2186. void CXTPCalendarView::_CalculateEventTimeFormat()
  2187. {
  2188. ////////////////////////////////////////////////////////////////////////////
  2189. //  LOCALE_STIME    // time separator
  2190. //
  2191. //  LOCALE_ITLZERO  //leading zeros in time field
  2192. //      0 No leading zeros for hours.
  2193. //      1 Leading zeros for hours.
  2194. //
  2195. //  LOCALE_ITIME    // time format specifier
  2196. //      0 AM / PM 12-hour format.
  2197. //      1 24-hour format.
  2198. //
  2199. //  LOCALE_ITIMEMARKPOSN    // time marker position
  2200. //      0 Use as suffix.
  2201. //      1 Use as prefix.
  2202. //
  2203. //  LOCALE_S1159    // AM designator
  2204. //  LOCALE_S2359    // PM designator
  2205. ////////////////////////////////////////////////////////////////////////////
  2207. CString strTmp;
  2209. CString strTimeSeparator = CXTPCalendarUtils::GetLocaleString(LOCALE_STIME, 16);
  2211. strTmp = CXTPCalendarUtils::GetLocaleString(LOCALE_ITIME, 16);
  2212. BOOL b24_HFormat = _ttoi(strTmp) == 1;
  2214. strTmp = CXTPCalendarUtils::GetLocaleString(LOCALE_ITLZERO, 16);
  2215. BOOL bH_LZero = _ttoi(strTmp) == 1;
  2217. strTmp = CXTPCalendarUtils::GetLocaleString(LOCALE_ITIMEMARKPOSN, 16);
  2218. BOOL bAM_PM_Prefix = _ttoi(strTmp) == 1;
  2220. //---------------------------------------------------------------------------
  2221. CString strTimeFormat;
  2222. strTimeFormat += strTimeSeparator;
  2223. strTimeFormat += _T("mm");
  2225. if (b24_HFormat)
  2226. {
  2227. strTmp = bH_LZero ? _T("HH") : _T("H");
  2228. strTimeFormat = strTmp + strTimeFormat;
  2229. }
  2230. else //12 AM/PM Format
  2231. {
  2232. strTmp = bH_LZero ? _T("hh") : _T("h");
  2233. strTimeFormat = strTmp + strTimeFormat;
  2235. if (bAM_PM_Prefix)
  2236. {
  2237. strTimeFormat = _T("tt ") + strTimeFormat;
  2238. }
  2239. else
  2240. {
  2241. strTimeFormat = strTimeFormat + _T("tt");
  2242. }
  2243. }
  2244. //---------------------------------------------------------------------------
  2245. m_EventTimeFormat.strFormat = strTimeFormat;
  2246. m_EventTimeFormat.b24_HFormat = b24_HFormat;
  2247. m_EventTimeFormat.strAM = CXTPCalendarUtils::GetLocaleString(LOCALE_S1159, 20);
  2248. m_EventTimeFormat.strPM = CXTPCalendarUtils::GetLocaleString(LOCALE_S2359, 20);
  2249. }
  2251. CString CXTPCalendarView::FormatEventTime(COleDateTime dtTime)
  2252. {
  2253. CString strTime;
  2255. SYSTEMTIME st;
  2256. ZeroMemory(&st, sizeof(st));
  2258. if (GETASSYSTEMTIME_DT(dtTime, st))
  2259. {
  2260. strTime = CXTPCalendarUtils::GetTimeFormat(&st, m_EventTimeFormat.strFormat);
  2261. }
  2263. if (strTime.IsEmpty())
  2264. {
  2265. ASSERT(FALSE);
  2266. strTime.Format(_T("%d:%02d"), dtTime.GetHour(), dtTime.GetMinute());
  2267. }
  2269. //- make AM/PM as lower case ---------------------------------------
  2270. if (!m_EventTimeFormat.b24_HFormat)
  2271. {
  2272. CString strAM_lower = m_EventTimeFormat.strAM;
  2273. CString strPM_lower = m_EventTimeFormat.strPM;
  2275. strAM_lower.MakeLower();
  2276. strPM_lower.MakeLower();
  2278. REPLACE_S(strTime, m_EventTimeFormat.strAM, strAM_lower);
  2279. REPLACE_S(strTime, m_EventTimeFormat.strPM, strPM_lower);
  2280. }
  2282. return strTime;
  2283. }
  2285. CString CXTPCalendarView::GetItemTextEventTimeMax()
  2286. {
  2287. COleDateTime dtTestTime;
  2288. dtTestTime.SetTime(23, 59, 59);
  2290. CString strTime = FormatEventTime(dtTestTime);
  2292. DWORD dwFlags = GetCalendarControl()->GetAskItemTextFlags();
  2293. if (dwFlags & (xtpCalendarItemText_EventStartTimeText | xtpCalendarItemText_EventEndTimeText))
  2294. {
  2295. XTP_CALENDAR_GETITEMTEXT_PARAMS objRequest;
  2296. ::ZeroMemory(&objRequest, sizeof(objRequest));
  2298. objRequest.nItem = xtpCalendarItemText_EventStartTimeText /*| xtpCalendarItemText_EventEndTimeText*/;
  2299. objRequest.pstrText = &strTime;
  2301. GetCalendarControl()->SendNotificationAlways(XTP_NC_CALENDAR_GETITEMTEXT, (WPARAM)&objRequest, 0);
  2302. }
  2304. return strTime;
  2305. }
  2308. BOOL CXTPCalendarView::_Undo(CXTPCalendarEvent* pEvent)
  2309. {
  2310. if (IsEditingSubject())
  2311. {
  2312. TRACE_EDIT_SUBJECT(_T("Edit SUBJECT - EndEditSubject(). [CXTPCalendarView::OnKeyDown] n"));
  2313. EndEditSubject(xtpCalendarEditSubjectCommit);
  2314. }
  2316. if (!GetCalendarControl())
  2317. {
  2318. return FALSE;
  2319. }
  2321. CXTPAutoResetValue<BOOL> autoSet_UpdateCtrlNf(GetCalendarControl()->m_bUpdateWhenEventChangedNotify);
  2322. autoSet_UpdateCtrlNf = FALSE;
  2324. //---------------------------------------------------------------------------
  2325. CXTPCalendarEventPtr ptrEventNew;
  2326. CXTPCalendarEventPtr ptrEventOld;
  2328. if (pEvent)
  2329. {
  2330. ptrEventNew = m_UndoBuffer.UndoAllForEvent(pEvent);
  2331. ptrEventOld = m_UndoBuffer.RedoAllForEvent(pEvent);
  2332. }
  2333. else
  2334. {
  2335. CXTPCalendarEventPtr ptrUndoEvent = m_UndoBuffer.GetFirstUndoEvent();
  2336. if (ptrUndoEvent)
  2337. {
  2338. if (m_eUndoMode == xtpCalendarUndoModeUndo)
  2339. {
  2340. ptrEventNew = m_UndoBuffer.UndoAllForEvent(ptrUndoEvent);
  2341. ptrEventOld = m_UndoBuffer.RedoAllForEvent(ptrUndoEvent);
  2342. m_eUndoMode = xtpCalendarUndoModeRedo;
  2343. }
  2344. else
  2345. if (m_eUndoMode == xtpCalendarUndoModeRedo)
  2346. {
  2347. ptrEventNew = m_UndoBuffer.RedoAllForEvent(ptrUndoEvent);
  2348. ptrEventOld = m_UndoBuffer.UndoAllForEvent(ptrUndoEvent);
  2349. m_eUndoMode = xtpCalendarUndoModeUndo;
  2350. }
  2351. else
  2352. {
  2353. ASSERT(FALSE);
  2354. return FALSE;
  2355. }
  2356. }
  2357. }
  2359. //---------------------------------------------------------------------------
  2360. if (ptrEventNew || ptrEventOld)
  2361. {
  2362. CXTPCalendarControl::CUpdateContext updateContext(m_pControl, xtpCalendarUpdateLayout | xtpCalendarUpdateRedraw);
  2364. if (ptrEventNew && ptrEventOld && ptrEventNew->GetDataProvider())
  2365. {
  2366. VERIFY( ptrEventNew->GetDataProvider()->ChangeEvent(ptrEventNew) );
  2367. }
  2368. else if (ptrEventNew && !ptrEventOld && ptrEventNew->GetDataProvider())
  2369. {
  2370. VERIFY( ptrEventNew->GetDataProvider()->AddEvent(ptrEventNew) );
  2371. }
  2372. else if (!ptrEventNew && ptrEventOld && ptrEventOld->GetDataProvider())
  2373. {
  2374. VERIFY( ptrEventOld->GetDataProvider()->DeleteEvent(ptrEventOld) );
  2375. }
  2377. XTP_SAFE_CALL1(GetCalendarControl(), Populate());
  2379. return TRUE;
  2380. }
  2381. return FALSE;
  2382. }
  2384. BOOL CXTPCalendarView::CanUndo()
  2385. {
  2386. if (m_eUndoMode == xtpCalendarUndoModeUndo && m_UndoBuffer.GetCount())
  2387. {
  2388. return TRUE;
  2389. }
  2391. return _CanSubjectEditor(ID_EDIT_UNDO);
  2392. }
  2394. CWnd* CXTPCalendarView::_GetSubjectEditorWnd()
  2395. {
  2396. if (m_ptrEditingViewEvent)
  2397. {
  2398. return m_ptrEditingViewEvent->GetSubjectEditor();
  2399. }
  2400. return NULL;
  2401. }
  2403. BOOL CXTPCalendarView::_CanSubjectEditor(UINT idEditCmd)
  2404. {
  2405. CWnd* pSEditorWnd = _GetSubjectEditorWnd();
  2406. if (!pSEditorWnd)
  2407. {
  2408. return FALSE;
  2409. }
  2410. CEdit* pSEditor = DYNAMIC_DOWNCAST(CEdit, pSEditorWnd);
  2411. if (!pSEditor)
  2412. {
  2413. return FALSE;
  2414. }
  2416. BOOL bSEFocused = CWnd::GetFocus() &&
  2417. CWnd::GetFocus()->GetSafeHwnd() == pSEditorWnd->GetSafeHwnd();
  2418. if (!bSEFocused)
  2419. {
  2420. return FALSE;
  2421. }
  2423. int nSel1 = -1, nSel2 = -1;
  2424. pSEditor->GetSel(nSel1, nSel2);
  2426. switch (idEditCmd)
  2427. {
  2428. case ID_EDIT_UNDO:
  2429. return pSEditor->CanUndo();
  2430. case ID_EDIT_CUT:
  2431. return nSel1 < nSel2;
  2432. case ID_EDIT_COPY:
  2433. return nSel1 < nSel2;
  2434. case ID_EDIT_PASTE:
  2435. return ::IsClipboardFormatAvailable(CF_TEXT);
  2436. }
  2438. return FALSE;
  2439. }
  2441. BOOL CXTPCalendarView::CanRedo()
  2442. {
  2443. return m_eUndoMode == xtpCalendarUndoModeRedo && m_UndoBuffer.GetCount();
  2444. }
  2446. BOOL CXTPCalendarView::Undo()
  2447. {
  2448. ASSERT(m_eUndoMode == xtpCalendarUndoModeUndo || _CanSubjectEditor(ID_EDIT_UNDO));
  2449. return _Undo();
  2450. }
  2452. BOOL CXTPCalendarView::Redo()
  2453. {
  2454. ASSERT(m_eUndoMode == xtpCalendarUndoModeRedo);
  2455. return _Undo();
  2456. }
  2458. CString CXTPCalendarView::_GetMaxWidthFormat(CDC* pDC, CString strFormat, BOOL bMonth)
  2459. {
  2460. if (!pDC)
  2461. {
  2462. ASSERT(FALSE);
  2463. return _T("");
  2464. }
  2466. SYSTEMTIME st;
  2467. ZeroMemory(&st, sizeof(st));
  2468. st.wDay = 20;
  2469. st.wMonth = 1;
  2470. st.wYear = (WORD)CXTPCalendarUtils::GetCurrentTime().GetYear();
  2472. int nMax = 0;
  2473. CString str;
  2475. int nCount = bMonth ? 12 : 7;
  2477. for (int i = 0; i < nCount; i++)
  2478. {
  2479. CString strResult = CXTPCalendarUtils::GetDateFormat(&st, strFormat);
  2481. int nLen = pDC->GetTextExtent(strResult).cx;
  2482. if (nMax < nLen)
  2483. {
  2484. str = strResult;
  2485. nMax = nLen;
  2486. }
  2487. if (bMonth)
  2488. st.wMonth++;
  2489. else
  2490. st.wDay++;
  2491. }
  2492. return str;
  2493. }
  2495. int CXTPCalendarView::_GetMaxWidth(CDC* pDC, CString strFormat)
  2496. {
  2497. if (!pDC)
  2498. {
  2499. ASSERT(FALSE);
  2500. return 1;
  2501. }
  2503. const TCHAR* chFormats[] =
  2504. {
  2505. _T("yyyy"), _T("yyy"), _T("yy"), _T("y"),
  2506. _T("MMMM"), _T("MMM"),
  2507. _T("dddd"), _T("ddd"), _T("dd"), _T("d")
  2508. };
  2510. for (int i = 0; i < _countof(chFormats); i++)
  2511. {
  2512. int nPos = strFormat.Find(chFormats[i]);
  2513. if (nPos >= 0)
  2514. {
  2515. REPLACE_S(strFormat, chFormats[i], _GetMaxWidthFormat(pDC, chFormats[i], i < 2));
  2516. }
  2517. }
  2520. return pDC->GetTextExtent(strFormat).cx;
  2522. }
  2524. void CXTPCalendarView::_RemoveYearPart(CString& strFormat)
  2525. {
  2526. int nStartPos = -1, nEndPos = -1, i;
  2527. BOOL bBracket = FALSE;
  2528. for (i = 0; i < strFormat.GetLength(); i++)
  2529. {
  2530. TCHAR ch = strFormat[i];
  2531. if (ch == _T('''))
  2532. bBracket = !bBracket;
  2533. if (bBracket)
  2534. continue;
  2536. if (ch == _T('m') || ch == _T('M') || ch == _T('D') || ch == _T('d'))
  2537. {
  2538. if (nStartPos == -1)
  2539. nStartPos = i;
  2540. nEndPos = i;
  2541. }
  2542. }
  2544. if (nStartPos != -1 && nEndPos > nStartPos)
  2545. {
  2546. strFormat = strFormat.Mid(nStartPos, nEndPos - nStartPos + 1);
  2547. }
  2548. }
  2550. void CXTPCalendarView::_ReadDefaultHeaderFormats()
  2551. {
  2552. m_strDayHeaderFormatDefaultLong = CXTPCalendarUtils::GetLocaleString(LOCALE_SLONGDATE, 81);
  2554. _RemoveYearPart(m_strDayHeaderFormatDefaultLong);
  2556. m_strDayHeaderFormatDefaultMiddle = m_strDayHeaderFormatDefaultLong;
  2557. REPLACE_S(m_strDayHeaderFormatDefaultMiddle, _T("MMMM"), _T("MMM"));
  2559. m_strDayHeaderFormatDefaultShort = m_strDayHeaderFormatDefaultMiddle;
  2560. REPLACE_S(m_strDayHeaderFormatDefaultShort, _T("dddd"), _T("ddd"));
  2562. m_strDayHeaderFormatDefaultShortest = CXTPCalendarUtils::GetLocaleString(LOCALE_SSHORTDATE, 81);
  2563. _RemoveYearPart(m_strDayHeaderFormatDefaultShortest);
  2564. }
  2566. // nLevel = 0 - Long, 1 - Middle, 2 - Short, 3 - Shortest.
  2567. CString CXTPCalendarView::_GetDayHeaderFormat(int nLevel)
  2568. {
  2569. switch (nLevel)
  2570. {
  2571. case 0:
  2572. return m_strDayHeaderFormatLong.IsEmpty() ? m_strDayHeaderFormatDefaultLong : m_strDayHeaderFormatLong;
  2573. case 1:
  2574. return m_strDayHeaderFormatMiddle.IsEmpty() ? m_strDayHeaderFormatDefaultMiddle : m_strDayHeaderFormatMiddle;
  2575. case 2:
  2576. return m_strDayHeaderFormatShort.IsEmpty() ? m_strDayHeaderFormatDefaultShort : m_strDayHeaderFormatShort;
  2577. case 3:
  2578. return m_strDayHeaderFormatShortest.IsEmpty() ? m_strDayHeaderFormatDefaultShortest : m_strDayHeaderFormatShortest;
  2579. }
  2581. ASSERT(FALSE);
  2582. return _T("");
  2583. }
  2585. void CXTPCalendarView::CalculateHeaderFormat(CDC* pDC, int nWidth, CFont* pTextFont)
  2586. {
  2587. if (!GetCalendarControl() || !pTextFont || !pDC)
  2588. {
  2589. ASSERT(FALSE);
  2590. return;
  2591. }
  2593. _ReadDefaultHeaderFormats();
  2595. CXTPFontDC fnt(pDC, pTextFont);
  2596. int arBorder[] = {40, 35, 20, 0};
  2598. for (int i = 0; i <= 3; i++)
  2599. {
  2600. m_strHeaderFormat = _GetDayHeaderFormat(i);
  2601. int nLen = _GetMaxWidth(pDC, m_strHeaderFormat);
  2603. if (nLen < nWidth - arBorder[i])
  2604. {
  2605. return;
  2606. }
  2607. }
  2608. }
  2611. COleDateTimeSpan CXTPCalendarView::GetEventDurationMin() const
  2612. {
  2613. return COleDateTimeSpan(0.);
  2614. }
  2616. BOOL CXTPCalendarView::CanCut()
  2617. {
  2618. return !IsEditingSubject() && HasSelectedViewEvent() ||
  2619. IsEditingSubject() && _CanSubjectEditor(ID_EDIT_CUT);
  2620. }
  2622. BOOL CXTPCalendarView::CanCopy()
  2623. {
  2624. return !IsEditingSubject() && HasSelectedViewEvent() ||
  2625. IsEditingSubject() && _CanSubjectEditor(ID_EDIT_COPY);
  2626. }
  2628. BOOL CXTPCalendarView::CanPaste()
  2629. {
  2630. if (!GetSelection())
  2631. {
  2632. return FALSE;
  2633. }
  2635. //- Register or get existing Clipboard Format ID -------------------------
  2636. UINT uCF_Event = ::RegisterClipboardFormat(XTPCALENDARCTRL_CF_EVENT);
  2638. BOOL bIsEventInClipboard = ::IsClipboardFormatAvailable(uCF_Event);
  2640. return !IsEditingSubject() && bIsEventInClipboard ||
  2641. IsEditingSubject() && _CanSubjectEditor(ID_EDIT_PASTE);
  2642. }
  2645. BOOL CXTPCalendarView::Cut()
  2646. {
  2647. if (IsEditingSubject() && _GetSubjectEditorWnd())
  2648. {
  2649. if (CanCut())
  2650. {
  2651. _GetSubjectEditorWnd()->SendMessage(WM_CUT);
  2652. return TRUE;
  2653. }
  2654. return FALSE;
  2655. }
  2657. //===========================================================================
  2658. CXTPCalendarViewEventsPtr ptrSelViews = GetSelectedEvents();
  2659. if (!ptrSelViews || !ptrSelViews->GetCount())
  2660. {
  2661. return FALSE;
  2662. }
  2664. if (OnBeforeEditOperationNotify(xtpCalendarEO_Cut, ptrSelViews))
  2665. {
  2666. return FALSE;
  2667. }
  2669. //------------------------------------------------------------------------
  2670. DWORD dwCopyFlags = xtpCalendarCopyFlagCutMask;
  2672. COleDataSource* pData = _CopySelectedEvents(dwCopyFlags);
  2673. if (!pData)
  2674. {
  2675. return FALSE;
  2676. }
  2677. pData->SetClipboard();
  2679. //------------------------------------------------------------------------
  2680. int nCount = ptrSelViews->GetCount();
  2681. for (int i = 0; i < nCount; i++)
  2682. {
  2683. CXTPCalendarViewEvent* pViewEvent = ptrSelViews->GetAt(i, FALSE);
  2684. CXTPCalendarEvent* pEvent = pViewEvent ? pViewEvent->GetEvent() : NULL;
  2686. VERIFY( XTP_SAFE_GET2(pEvent, GetDataProvider(), DeleteEvent(pEvent), FALSE) );
  2687. }
  2688. XTP_SAFE_CALL1(GetCalendarControl(), Populate());
  2690. //---------------------------------------------------------------------------
  2691. return TRUE;
  2692. }
  2694. BOOL CXTPCalendarView::Copy()
  2695. {
  2696. if (IsEditingSubject() && _GetSubjectEditorWnd())
  2697. {
  2698. if (CanCopy())
  2699. {
  2700. _GetSubjectEditorWnd()->SendMessage(WM_COPY);
  2701. return TRUE;
  2702. }
  2703. return FALSE;
  2704. }
  2706. //---------------------------------------------------------------------------
  2707. CXTPCalendarViewEventsPtr ptrSelViews = GetSelectedEvents();
  2708. if (!ptrSelViews || !ptrSelViews->GetCount())
  2709. {
  2710. return FALSE;
  2711. }
  2713. if (OnBeforeEditOperationNotify(xtpCalendarEO_Copy, ptrSelViews))
  2714. {
  2715. return FALSE;
  2716. }
  2718. //===========================================================================
  2719. COleDataSource* pData = _CopySelectedEvents();
  2720. if (!pData)
  2721. {
  2722. return FALSE;
  2723. }
  2725. pData->SetClipboard();
  2726. return TRUE;
  2727. }
  2729. BOOL CXTPCalendarView::Paste()
  2730. {
  2731. if (IsEditingSubject() && _GetSubjectEditorWnd())
  2732. {
  2733. if (CanPaste())
  2734. {
  2735. _GetSubjectEditorWnd()->SendMessage(WM_PASTE);
  2736. return TRUE;
  2737. }
  2738. return FALSE;
  2739. }
  2741. //===========================================================================
  2742. COleDateTime dtSelBegin, dtSelEnd;
  2743. COleDateTimeSpan spSelectionResolution;
  2744. if (!GetSelection(&dtSelBegin, &dtSelEnd, NULL, NULL, &spSelectionResolution))
  2745. {
  2746. return FALSE;
  2747. }
  2748. dtSelBegin = min(dtSelBegin, dtSelEnd);
  2750. // Attach a COleDataObject to the clipboard and paste the data
  2751. COleDataObject objData;
  2752. if (!objData.AttachClipboard())
  2753. {
  2754. return FALSE;
  2755. }
  2757. DWORD dwCopyFlags = 0;
  2758. CXTPCalendarEventsPtr ptrEventsFromCB = _ReadEventsFromClipboard(&objData, &dwCopyFlags);
  2760. if (!ptrEventsFromCB)
  2761. {
  2762. return FALSE;
  2763. }
  2765. if (!GetCalendarControl())
  2766. {
  2767. return FALSE;
  2768. }
  2770. CXTPAutoResetValue<BOOL> autoSet_UpdateCtrlNf(GetCalendarControl()->m_bUpdateWhenEventChangedNotify);
  2771. autoSet_UpdateCtrlNf = FALSE;
  2773. //---------------------------------------------------------------------------
  2774. COleDateTimeSpan spStartShift;
  2776. int nCount = ptrEventsFromCB->GetCount();
  2777. for (int i = 0; i < nCount; i++)
  2778. {
  2779. BOOL bUseChangeEvent = FALSE;
  2781. CXTPCalendarEvent* pNewEvent = ptrEventsFromCB->GetAt(i, FALSE);
  2782. if (!pNewEvent)
  2783. {
  2784. ASSERT(FALSE);
  2785. continue;
  2786. }
  2787. int nRState = pNewEvent->GetRecurrenceState();
  2788. if (nRState == xtpCalendarRecurrenceMaster)
  2789. {
  2790. ASSERT(FALSE); // WARNING. Master event in the clipboard - ???
  2791. VERIFY(pNewEvent->RemoveRecurrence());
  2792. }
  2794. //---------------------------------------------------------------------------
  2795. if (nRState == xtpCalendarRecurrenceOccurrence &&
  2796. dwCopyFlags & xtpCalendarCopyFlagROccurrence2RException)
  2797. {
  2798. VERIFY(pNewEvent->MakeAsRException());
  2799. bUseChangeEvent = TRUE;
  2800. }
  2801. else
  2802. {
  2803. VERIFY(pNewEvent->RemoveRecurrence());
  2804. }
  2805. // Update recurrence state
  2806. nRState = pNewEvent->GetRecurrenceState();
  2807. //---------------------------------------------------------------------------
  2808. if (nRState == xtpCalendarRecurrenceException &&
  2809. dwCopyFlags & xtpCalendarCopyFlagKeepRException)
  2810. {
  2811. CXTPCalendarRecurrencePatternPtr ptrPattern = pNewEvent->GetRecurrencePattern();
  2812. bUseChangeEvent = ptrPattern != NULL;
  2813. }
  2815. if (!bUseChangeEvent && nRState == xtpCalendarRecurrenceException)
  2816. {
  2817. VERIFY( pNewEvent->RemoveRecurrence() );
  2818. }
  2820. //---------------------------------------------------------------------------
  2821. COleDateTime dtEventStart = pNewEvent->GetStartTime();
  2823. if (i == 0)
  2824. {
  2825. spStartShift = dtSelBegin - dtEventStart;
  2826. spStartShift += ((double)spStartShift < 0 ? -1 : 1) * XTP_HALF_SECOND;
  2828. double dCells = (double)spStartShift / (double)spSelectionResolution;
  2830. int nCells = (int)dCells; //+ (dCells >= 0 ? 1 : 0);
  2832. double dCellDrobTime = fabs(dCells - (DWORD)dCells)*(double)spSelectionResolution;
  2833. double dCellDrobTimeLimit = XTP_HALF_SECOND*2*10;
  2835. if (dCells >= 0 && dCellDrobTime > dCellDrobTimeLimit)
  2836. {
  2837. nCells++;
  2838. }
  2839. spStartShift = (double)spSelectionResolution * (double)nCells;
  2840. }
  2841. dtEventStart += spStartShift;
  2843. pNewEvent->MoveEvent(dtEventStart);
  2845. //*******************************************************
  2846. if (OnBeforePasteNotify(pNewEvent, bUseChangeEvent))
  2847. {
  2848. continue;
  2849. }
  2850. //*******************************************************
  2852. //---------------------------------------------------------------------------
  2853. if (bUseChangeEvent)
  2854. {
  2855. VERIFY( XTP_SAFE_GET2(pNewEvent, GetDataProvider(), ChangeEvent(pNewEvent), FALSE) );
  2856. }
  2857. else
  2858. {
  2859. VERIFY( XTP_SAFE_GET2(pNewEvent, GetDataProvider(), AddEvent(pNewEvent), FALSE) );
  2860. }
  2861. }
  2863. //---------------------------------------------------------------------------
  2864. if (dwCopyFlags & xtpCalendarCopyFlagClearCBAfterPaste)
  2865. {
  2866. if (::OpenClipboard(NULL))
  2867. {
  2868. ::EmptyClipboard();
  2869. ::CloseClipboard();
  2870. }
  2871. }
  2872. //---------------------------------------------------------------------------
  2874. XTP_SAFE_CALL1(GetCalendarControl(), Populate());
  2876. return TRUE;
  2877. }
  2879. CXTPCalendarEventsPtr CXTPCalendarView::_ReadEventsFromClipboard(COleDataObject* pData, DWORD* pdwCopyFlags)
  2880. {
  2881. //- Register or get existing Clipboard Format ID -------------------------
  2882. CLIPFORMAT uCF_Event = (CLIPFORMAT)::RegisterClipboardFormat(XTPCALENDARCTRL_CF_EVENT);
  2884. ASSERT(pData);
  2885. if (!pData || !pData->IsDataAvailable(uCF_Event))
  2886. {
  2887. return NULL;
  2888. }
  2890. CXTPCalendarEventsPtr ptrEvents = new CXTPCalendarEvents();
  2891. if (!ptrEvents)
  2892. {
  2893. return NULL;
  2894. }
  2896. const int cErrTextSize = 1024;
  2897. TCHAR szErrText[cErrTextSize + 1];
  2899. try
  2900. {
  2901. HGLOBAL hData = pData->GetGlobalData(uCF_Event);
  2902. if (!hData)
  2903. {
  2904. return NULL;
  2905. }
  2907. CSharedFile fileSahred;
  2908. fileSahred.SetHandle(hData, FALSE);
  2909. CArchive ar(&fileSahred, CArchive::load);
  2911. CXTPPropExchangeArchive px(ar);
  2913. long nSchema = 0;
  2914. DWORD dwCopyFlags = 0;
  2916. PX_Long(&px, _T("Version"), (long&)nSchema);
  2917. px.ExchangeLocale();
  2918. PX_DWord(&px, _T("CopyFlags"), (DWORD&)dwCopyFlags);
  2920. if (nSchema != XTP_CLIPBOARD_EVENTS_DATA_VER)
  2921. {
  2922. ASSERT(FALSE);
  2923. return NULL;
  2924. }
  2926. CXTPPropExchangeSection sec(px.GetSection(_T("Events")));
  2927. CXTPPropExchangeEnumeratorPtr pEnumerator(sec->GetEnumerator(_T("Event")));
  2928. POSITION pos = pEnumerator->GetPosition();
  2930. UINT uScheduleID = 0;
  2931. CXTPCalendarData* pDPsel = _GetDataProviderBySelection(&uScheduleID);
  2933. while (pos)
  2934. {
  2935. CXTPPropExchangeSection secEvent(pEnumerator->GetNext(pos));
  2937. CXTPCalendarData* pDPevent = NULL;
  2939. //-- get data provider --------------------
  2940. CString strDataProvider;
  2941. PX_String(&secEvent, _T("DataProvider_ConnectionString"), strDataProvider, _T(""));
  2943. if (!strDataProvider.IsEmpty())
  2944. {
  2945. pDPevent = _GetDataProviderByConnStr(strDataProvider);
  2946. }
  2947. CXTPCalendarData* pDataProvider = pDPevent ? pDPevent : pDPsel;
  2948. ASSERT(pDataProvider);
  2950. //-- create event and read its data ---------
  2951. CXTPCalendarEventPtr ptrEvent = pDataProvider ? pDataProvider->CreateNewEvent() : NULL;
  2952. if (!ptrEvent)
  2953. {
  2954. return NULL;
  2955. }
  2956. ptrEvent->DoPropExchange(&secEvent);
  2958. //-----------------------------------
  2959. if (!pDPevent || !_IsScheduleVisible(pDPevent, ptrEvent->GetScheduleID()))
  2960. {
  2961. ptrEvent->SetScheduleID(uScheduleID);
  2962. }
  2964. ptrEvents->Add(ptrEvent, TRUE);
  2965. }
  2966. ar.Close(); // detach from file
  2968. //--------------------------------------------------------------------
  2969. if (pdwCopyFlags)
  2970. {
  2971. *pdwCopyFlags = dwCopyFlags;
  2972. }
  2974. return ptrEvents;
  2975. }
  2976. catch(CArchiveException* pE)
  2977. {
  2978. if (pE->GetErrorMessage(szErrText, cErrTextSize))
  2979. {
  2980. TRACE(_T("EXCEPTION: CXTPCalendarView::_ReadEventsFromClipboard() - %sn"), szErrText);
  2981. }
  2982. pE->Delete();
  2983. }
  2984. catch(CFileException* pE)
  2985. {
  2986. if (pE->GetErrorMessage(szErrText, cErrTextSize))
  2987. {
  2988. TRACE(_T("EXCEPTION: CXTPCalendarView::_ReadEventsFromClipboard() - %sn"), szErrText);
  2989. }
  2990. pE->Delete();
  2991. }
  2992. catch(...)
  2993. {
  2994. TRACE(_T("EXCEPTION: CXTPCalendarView::_ReadEventsFromClipboard() - Unhandled Exception!n"));
  2995. }
  2997. ASSERT(FALSE);
  2998. return NULL;
  2999. }
  3001. COleDataSource* CXTPCalendarView::_CopySelectedEvents(DWORD dwCopyFlags)
  3002. {
  3003. CXTPCalendarViewEventsPtr ptrSelViews = GetSelectedEvents();
  3004. if (!ptrSelViews || !ptrSelViews->GetCount())
  3005. {
  3006. return NULL;
  3007. }
  3008. //------------------------------------------------------------------------
  3009. const int cErrTextSize = 1024;
  3010. TCHAR szErrText[cErrTextSize + 1];
  3012. try
  3013. {
  3014. CSharedFile fileSahred(GMEM_MOVEABLE | GMEM_DDESHARE | GMEM_ZEROINIT);
  3015. CArchive ar(&fileSahred, CArchive::store);
  3017. CXTPPropExchangeArchive px(ar);
  3019. long nSchema = XTP_CLIPBOARD_EVENTS_DATA_VER;
  3020. PX_Long(&px, _T("Version"), (long&)nSchema);
  3021. px.ExchangeLocale();
  3022. PX_DWord(&px, _T("CopyFlags"), (DWORD&)dwCopyFlags);
  3024. int nCount = ptrSelViews->GetCount();
  3026. CXTPPropExchangeSection sec(px.GetSection(_T("Events")));
  3027. CXTPPropExchangeEnumeratorPtr pEnumerator(sec->GetEnumerator(_T("Event")));
  3028. POSITION posEnum = pEnumerator->GetPosition((DWORD)nCount);
  3030. for (int i = 0; i < nCount; i++)
  3031. {
  3032. CXTPCalendarViewEvent* pViewEvent = ptrSelViews->GetAt(i, FALSE);
  3033. CXTPCalendarEvent* pEvent = pViewEvent->GetEvent();
  3034. if (!pEvent)
  3035. {
  3036. ASSERT(FALSE);
  3037. continue;
  3038. }
  3040. CXTPPropExchangeSection secEvent(pEnumerator->GetNext(posEnum));
  3042. CString strDataProvider = XTP_SAFE_GET2(pEvent, GetDataProvider(), GetConnectionString(), _T(""));
  3043. PX_String(&secEvent, _T("DataProvider_ConnectionString"), strDataProvider);
  3045. pEvent->DoPropExchange(&secEvent);
  3046. }
  3047. ar.Close(); // perform Flush() and detach from file
  3049. //- Prepare Global data ----------------------------------------------
  3050. DWORD dwDataSize = (DWORD)fileSahred.GetLength();
  3051. HGLOBAL hData = fileSahred.Detach();
  3052. if (!hData)
  3053. {
  3054. ASSERT(FALSE);
  3055. return NULL;
  3056. }
  3058. hData = ::GlobalReAlloc(hData, dwDataSize, GMEM_MOVEABLE | GMEM_DDESHARE | GMEM_ZEROINIT);
  3059. if (!hData)
  3060. {
  3061. ASSERT(FALSE);
  3062. return NULL;
  3063. }
  3065. //- Register Clipboard Format ----------------------------------------
  3066. CLIPFORMAT uCF_Event = (CLIPFORMAT)::RegisterClipboardFormat(XTPCALENDARCTRL_CF_EVENT);
  3068. // Cache data
  3069. COleDataSource* pSource = new COleDataSource();
  3070. if (pSource)
  3071. {
  3072. pSource->CacheGlobalData(uCF_Event, hData);
  3073. }
  3075. return pSource;
  3076. }
  3077. catch(CArchiveException* pE)
  3078. {
  3079. if (pE->GetErrorMessage(szErrText, cErrTextSize))
  3080. {
  3081. TRACE(_T("EXCEPTION: CXTPCalendarView::_CopySelectedEvents() - %sn"), szErrText);
  3082. }
  3083. pE->Delete();
  3084. }
  3085. catch(CFileException* pE)
  3086. {
  3087. if (pE->GetErrorMessage(szErrText, cErrTextSize))
  3088. {
  3089. TRACE(_T("EXCEPTION: CXTPCalendarView::_CopySelectedEvents() - %sn"), szErrText);
  3090. }
  3091. pE->Delete();
  3092. }
  3093. catch(...)
  3094. {
  3095. TRACE(_T("EXCEPTION: CXTPCalendarView::_CopySelectedEvents() - Unhandled Exception!n"));
  3096. }
  3098. ASSERT(FALSE);
  3099. return NULL;
  3100. }
  3102. ////////////////////////////////////////////////////////////////////////////
  3103. CXTPCalendarPaintManager* CXTPCalendarView::GetPaintManager()
  3104. {
  3105. ASSERT(m_pControl);
  3106. return m_pControl ? m_pControl->GetPaintManager() : NULL;
  3107. }
  3109. CXTPCalendarTheme* CXTPCalendarView::GetTheme()
  3110. {
  3111. ASSERT(m_pControl);
  3112. return m_pControl ? m_pControl->GetTheme() : NULL;
  3114. }
  3116. void CXTPCalendarView::SendNotification(XTP_NOTIFY_CODE EventCode, WPARAM wParam , LPARAM lParam)
  3117. {
  3118. if (m_pControl)
  3119. {
  3120. m_pControl->SendNotification(EventCode, wParam, lParam);
  3121. }
  3122. }
  3124. BOOL CXTPCalendarView::IsEditOperationDisabledNotify(XTPCalendarEditOperation eOperation, CXTPCalendarViewEvent* pEventView)
  3125. {
  3126. return _EditOperationNotify(XTP_NC_CALENDAR_IS_EVENT_EDIT_OPERATION_DISABLED,
  3127. eOperation, pEventView);
  3128. }
  3130. BOOL CXTPCalendarView::OnBeforeEditOperationNotify(XTPCalendarEditOperation eOperation, CXTPCalendarViewEvent* pEventView)
  3131. {
  3132. if (IsEditOperationDisabledNotify(eOperation, pEventView))
  3133. {
  3134. return TRUE;
  3135. }
  3137. return _EditOperationNotify(XTP_NC_CALENDAR_BEFORE_EVENT_EDIT_OPERATION,
  3138. eOperation, pEventView);
  3139. }
  3141. BOOL CXTPCalendarView::OnBeforeEditOperationNotify(XTPCalendarEditOperation eOperation, CXTPCalendarViewEvents* pEventViews)
  3142. {
  3143. if (_EditOperationNotify(XTP_NC_CALENDAR_IS_EVENT_EDIT_OPERATION_DISABLED,
  3144. eOperation, NULL, pEventViews))
  3145. {
  3146. return TRUE;
  3147. }
  3149. return _EditOperationNotify(XTP_NC_CALENDAR_BEFORE_EVENT_EDIT_OPERATION,
  3150. eOperation, NULL, pEventViews);
  3151. }
  3153. BOOL CXTPCalendarView::OnBeforePasteNotify(CXTPCalendarEvent* pEvent, BOOL bPasteWillChangeExistingEvent)
  3154. {
  3155. XTP_EVENT_PASTE_OPERATION_PARAMS opPasteParams;
  3156. ::ZeroMemory(&opPasteParams, sizeof(opPasteParams));
  3158. opPasteParams.eOperation = xtpCalendarEO_Paste;
  3160. opPasteParams.pEvent = pEvent;
  3161. opPasteParams.bPasteWillChangeExistingEvent = bPasteWillChangeExistingEvent;
  3163. BOOL bDisabledHandled = FALSE;
  3165. if (m_pControl)
  3166. {
  3167. m_pControl->SendNotification(XTP_NC_CALENDAR_IS_EVENT_EDIT_OPERATION_DISABLED,
  3168. (WPARAM)&opPasteParams, (LPARAM)&bDisabledHandled);
  3169. }
  3171. if (bDisabledHandled)
  3172. {
  3173. return TRUE;
  3174. }
  3176. if (m_pControl)
  3177. {
  3178. m_pControl->SendNotification(XTP_NC_CALENDAR_BEFORE_EVENT_EDIT_OPERATION,
  3179.  (WPARAM)&opPasteParams, (LPARAM)&bDisabledHandled);
  3180. }
  3182. return bDisabledHandled;
  3183. }
  3185. BOOL CXTPCalendarView::OnInPlaceCreateEvent(LPCTSTR pcszInitialSubject)
  3186. {
  3187. XTP_EVENT_IN_PLACE_CREATE_EVENT_OPERATION_PARAMS opCrParams;
  3188. ::ZeroMemory(&opCrParams, sizeof(opCrParams));
  3190. opCrParams.eOperation = xtpCalendarEO_InPlaceCreateEvent;
  3191. opCrParams.pcszInitialSubject = pcszInitialSubject;
  3193. BOOL bDisabledHandled = FALSE;
  3195. if (m_pControl)
  3196. {
  3197. m_pControl->SendNotification(XTP_NC_CALENDAR_IS_EVENT_EDIT_OPERATION_DISABLED,
  3198. (WPARAM)&opCrParams, (LPARAM)&bDisabledHandled);
  3199. }
  3201. if (bDisabledHandled)
  3202. {
  3203. return TRUE;
  3204. }
  3206. if (m_pControl)
  3207. {
  3208. m_pControl->SendNotification(XTP_NC_CALENDAR_BEFORE_EVENT_EDIT_OPERATION,
  3209. (WPARAM)&opCrParams, (LPARAM)&bDisabledHandled);
  3210. }
  3212. return bDisabledHandled;
  3213. }
  3215. BOOL CXTPCalendarView::_EditOperationNotify(XTP_NOTIFY_CODE ncEvent,
  3216. XTPCalendarEditOperation eOperation,
  3217. CXTPCalendarViewEvent* pEventView,
  3218. CXTPCalendarViewEvents* pEventViews)
  3219. {
  3220. ASSERT(pEventView || pEventViews && !(pEventView && pEventViews));
  3222. XTP_EVENT_EDIT_OPERATION_PARAMS opParams;
  3223. ::ZeroMemory(&opParams, sizeof(opParams));
  3225. CXTPCalendarViewEvents arEvents;
  3226. arEvents.Add(pEventView, TRUE);
  3228. opParams.eOperation = eOperation;
  3229. opParams.pEventViews = pEventView ? &arEvents : pEventViews;
  3231. BOOL bDisabledHandled = FALSE;
  3233. if (m_pControl)
  3234. {
  3235. m_pControl->SendNotification(ncEvent, (WPARAM)&opParams, (LPARAM)&bDisabledHandled);
  3236. }
  3238. return bDisabledHandled;
  3239. }
  3241. XTPEnumCalendarUpdateResult CXTPCalendarView::OnEventChanged_InDataProvider(
  3242. XTP_NOTIFY_CODE nfCode, CXTPCalendarEvent* pEvent)
  3243. {
  3244. ASSERT(pEvent);
  3245. if (!pEvent)
  3246. {
  3247. return xtpCalendar_Skip;
  3248. }
  3250. if (nfCode != XTP_NC_CALENDAREVENTWASADDED &&
  3251. nfCode != XTP_NC_CALENDAREVENTWASDELETED &&
  3252. nfCode != XTP_NC_CALENDAREVENTWASCHANGED)
  3253. {
  3254. ASSERT(FALSE);
  3255. return xtpCalendar_Skip;
  3256. }
  3258. int nDaysCount = GetViewDayCount();
  3259. COleDateTime dtFirstDay = nDaysCount ?  XTP_SAFE_GET1(GetViewDay_(0), GetDayDate(), (DATE)0) : (DATE)0;
  3260. COleDateTime dtLastDay = nDaysCount ?  XTP_SAFE_GET1(GetViewDay_(nDaysCount - 1), GetDayDate(), (DATE)0) : (DATE)0;
  3262. if (nfCode == XTP_NC_CALENDAREVENTWASADDED ||
  3263. nfCode == XTP_NC_CALENDAREVENTWASDELETED)
  3264. {
  3265. if (CXTPCalendarUtils::ResetTime(pEvent->GetStartTime()) > dtLastDay ||
  3266. CXTPCalendarUtils::ResetTime(pEvent->GetEndTime()) < dtFirstDay)
  3267. {
  3268. return xtpCalendar_Skip;
  3269. }
  3271. return xtpCalendar_Populate;
  3272. }
  3274. return xtpCalendar_Populate;
  3276. //  *****
  3277. //  An Idea how changing event processing can be optimized
  3278. //  from xtpCalendar_Populate to xtpCalendar_Redraw or even xtpCalendar_Skip.
  3279. //
  3280. //  int nRState_new = pEvent->GetRecurrenceState();
  3281. //  if (nRState_new == xtpCalendarRecurrenceMaster) {
  3282. //      return xtpCalendar_Populate;
  3283. //  }
  3284. //
  3285. //  //-----------------------------------------------------------------------
  3286. //  BOOL bUpdateEvent = FALSE;
  3287. //  int nDays = GetViewDayCount();
  3288. //  for (int nDay = 0; nDay < nDays; nDay++)
  3289. //  {
  3290. //      CXTPCalendarViewDay* pDay = GetViewDay_(nDay);
  3291. //      ASSERT(pDay);
  3292. //      if (!pDay)
  3293. //          continue;
  3294. //
  3295. //
  3296. //      int nEvents = pDay->GetViewEventsCount();
  3297. //      for (int nEvent = 0; nEvent < nEvents; nEvent++)
  3298. //      {
  3299. //          CXTPCalendarViewEvent* pEventView = pDay->GetViewEvent_(nEvent);
  3300. //          if (!pEventView && !pEventView->GetEvent())
  3301. //          {
  3302. //              ASSERT(FALSE);
  3303. //              continue;
  3304. //          }
  3305. //          CXTPCalendarEvent* pEvent_I = pEventView->GetEvent();
  3306. //          if (pEvent_I->GetEventID() == dwEventID)
  3307. //          {
  3308. //              if (!bUpdateEvent)
  3309. //              {
  3310. //                  if (pEvent_I->IsEqualStartEnd(pEvent))
  3311. //                      bUpdateEvent = TRUE;
  3312. //                  else
  3313. //                      return xtpCalendar_Populate;
  3314. //              }
  3315. //
  3316. //              if (bUpdateEvent)
  3317. //              {
  3318. //                  int nRState_I = pEvent_I->GetRecurrenceState();
  3319. //                  //int nRState_new = pEvent->GetRecurrenceState();
  3320. //
  3321. //                  if (nRState_I == xtpCalendarRecurrenceOccurrence)
  3322. //                      pEvent_I->SetRecurrenceState_ExceptionOccurrence(xtpCalendarRecurrenceException);
  3323. //
  3324. //                  pEvent_I->Update(pEvent);
  3325. //
  3326. //                  if (nRState_new == xtpCalendarRecurrenceOccurrence ||
  3327. //                      nRState_new == xtpCalendarRecurrenceException)
  3328. //                  {
  3329. //                      ASSERT(nRState_I == xtpCalendarRecurrenceOccurrence ||
  3330. //                              nRState_I == xtpCalendarRecurrenceException);
  3331. //
  3332. //                      pEvent_I->SetRecurrenceState_ExceptionOccurrence((XTPCalendarEventRecurrenceState)nRState_new);
  3333. //                  }
  3334. //              }
  3335. //          }
  3336. //      }
  3337. //
  3338. //  }
  3339. //
  3340. //  //-----------------------------------------------------------------------
  3341. //  if (!bUpdateEvent &&
  3342. //      !(CXTPCalendarUtils::ResetTime(pEvent->GetStartTime()) > dtLastDay ||
  3343. //        CXTPCalendarUtils::ResetTime(pEvent->GetEndTime()) < dtFirstDay)
  3344. //     )
  3345. //  {
  3346. //      return xtpCalendar_Populate;
  3347. //  }
  3348. //  return bUpdateEvent ? xtpCalendar_Redraw : xtpCalendar_Skip;
  3349. }
  3351. CXTPCalendarData* CXTPCalendarView::_GetDataProviderBySelection(UINT* puScheduleID)
  3352. {
  3353. COleDateTime dtSelBegin;
  3354. int nGroup = 0;
  3355. if (!GetSelection(&dtSelBegin, NULL, NULL, &nGroup))
  3356. {
  3357. return NULL;
  3358. }
  3360. //---------------------------------------------------------------------------
  3361. CXTPCalendarViewDay* pViewDay = _GetViewDay(dtSelBegin);
  3362. if (!pViewDay)
  3363. {
  3364. return NULL;
  3365. }
  3366. CXTPCalendarData* pData = NULL;
  3367. CXTPCalendarViewGroup* pViewGroup = NULL;
  3369. if (pViewDay && nGroup < pViewDay->GetViewGroupsCount() )
  3370. {
  3371. pViewGroup = pViewDay->GetViewGroup_(nGroup);
  3372. if (pViewGroup)
  3373. {
  3374. pData = pViewGroup->GetDataProvider();
  3375. if (puScheduleID)
  3376. {
  3377. *puScheduleID = pViewGroup->GetScheduleID();
  3378. }
  3379. }
  3380. }
  3382. return pData;
  3383. }
  3385. CXTPCalendarData* CXTPCalendarView::_GetDataProviderByConnStr(LPCTSTR pcszConnStr, BOOL bCompareNoCase)
  3386. {
  3387. CXTPCalendarViewDay* pViewDay = GetViewDay_(0);
  3389. COleDateTime dtSelBegin;
  3390. if (GetSelection(&dtSelBegin))
  3391. {
  3392. pViewDay = _GetViewDay(dtSelBegin);
  3393. }
  3395. //---------------------------------------------------------------------------
  3396. if (!pViewDay)
  3397. {
  3398. return NULL;
  3399. }
  3401. int nGCount = pViewDay->GetViewGroupsCount();
  3402. for (int g = 0; g < nGCount; g++)
  3403. {
  3404. CXTPCalendarViewGroup* pViewGroup = pViewDay->GetViewGroup_(g);
  3405. if (pViewGroup)
  3406. {
  3407. CXTPCalendarData* pData = pViewGroup->GetDataProvider();
  3408. if (pData)
  3409. {
  3410. CString strConn_i = pData->GetConnectionString();
  3411. int nCmp = bCompareNoCase ? strConn_i.CompareNoCase(pcszConnStr) : strConn_i.Compare(pcszConnStr);
  3412. if (nCmp == 0)
  3413. {
  3414.  return pData;
  3415. }
  3416. }
  3417. }
  3418. }
  3420. return NULL;
  3421. }
  3423. BOOL CXTPCalendarView::_IsScheduleVisible(CXTPCalendarData* pDataProvider, UINT uScheduleID)
  3424. {
  3425. CXTPCalendarViewDay* pViewDay = GetViewDay_(0);
  3427. COleDateTime dtSelBegin;
  3428. if (GetSelection(&dtSelBegin))
  3429. {
  3430. pViewDay = _GetViewDay(dtSelBegin);
  3431. }
  3433. //---------------------------------------------------------------------------
  3434. if (!pViewDay)
  3435. {
  3436. return FALSE;
  3437. }
  3439. int nGCount = pViewDay->GetViewGroupsCount();
  3440. for (int g = 0; g < nGCount; g++)
  3441. {
  3442. CXTPCalendarViewGroup* pViewGroup = pViewDay->GetViewGroup_(g);
  3444. CXTPCalendarData* pData = pViewGroup ? pViewGroup->GetDataProvider() : NULL;
  3445. if (pData && pData == pDataProvider)
  3446. {
  3448. int nRCCount = XTP_SAFE_GET2(pViewGroup, GetResources(), GetCount(), 0);
  3449. for (int i = 0; i < nRCCount; i++)
  3450. {
  3451. if (XTP_SAFE_GET3(pViewGroup, GetResources(), GetAt(i), ExistsScheduleID(uScheduleID), FALSE))
  3452. {
  3453. return TRUE;
  3454. }
  3455. }
  3456. }
  3457. }
  3459. return FALSE;
  3460. }
  3463. CXTPCalendarWMHandler* CXTPCalendarView::GetChildHandlerAt(int nIndex)
  3464. {
  3465. ASSERT_KINDOF(CXTPCalendarWMHandler, GetViewDay_(nIndex));
  3466. return GetViewDay_(nIndex);
  3467. }
  3469. CXTPCalendarResources* CXTPCalendarView::GetResources()
  3470. {
  3471. ASSERT(this);
  3472. if (m_pResources)
  3473. {
  3474. return m_pResources;
  3475. }
  3477. return GetCalendarControl() ? GetCalendarControl()->GetResources() : NULL;
  3478. }
  3480. void CXTPCalendarView::SetResources(CXTPCalendarResources* pResources)
  3481. {
  3482. BOOL bChanged = TRUE;
  3484. if (!pResources)
  3485. {
  3486. bChanged = m_pResources != NULL;
  3487. CMDTARGET_RELEASE(m_pResources);
  3488. }
  3489. else
  3490. {
  3491. if (!m_pResources)
  3492. {
  3493. m_pResources = new CXTPCalendarResources();
  3494. }
  3495. if (!m_pResources)
  3496. {
  3497. return;
  3498. }
  3500. // copy data to allow using self as input parameter
  3501. CXTPCalendarResources arRes;
  3502. arRes.Append(pResources);
  3504. m_pResources->RemoveAll();
  3505. m_pResources->Append(&arRes);
  3506. }
  3508. if (bChanged)
  3509. {
  3510. SendNotification(XTP_NC_CALENDAR_RESOURCES_WHERE_CHANGED, 1, (LPARAM)this);
  3511. }
  3512. }
  3514. BOOL CXTPCalendarView::IsTodayVisible()
  3515. {
  3516. COleDateTime dtToday = CXTPCalendarUtils::GetCurrentTime();
  3517. dtToday = CXTPCalendarUtils::ResetTime(dtToday);
  3519. int nCount = GetViewDayCount();
  3520. for (int i = 0; i < nCount; i++)
  3521. {
  3522. COleDateTime dtDay = GetViewDayDate(i);
  3523. if (CXTPCalendarUtils::IsEqual(dtDay, dtToday))
  3524. {
  3525. return TRUE;
  3526. }
  3527. }
  3528. return FALSE;
  3529. }
  3531. /////////////////////////////////////////////////////////////////////////////
  3532. CXTPCalendarView::CSelectionChanged_ContextData::CSelectionChanged_ContextData()
  3533. {
  3534. m_nLockCount = 0;
  3535. m_nLockCount_Day = 0;
  3536. m_nLockCount_Event = 0;
  3538. m_bRequest_Day = FALSE;
  3539. m_bRequest_Event = FALSE;
  3540. }
  3542. /////////////////////////////////////////////////////////////////////////////
  3543. //  class CSelectionChangedContext
  3544. //
  3545. CXTPCalendarView::CSelectionChangedContext::CSelectionChangedContext(CXTPCalendarView* pView, int eSelType)
  3546. {
  3547. if (!pView)
  3548. {
  3549. ASSERT(FALSE);
  3550. return;
  3551. }
  3552. m_pView = pView;
  3553. m_eSelType = eSelType;
  3555. m_pView->m_cntSelChanged.m_nLockCount += eSelType == xtpCalendarSelectionUnknown ? 1 : 0;
  3556. m_pView->m_cntSelChanged.m_nLockCount_Day += eSelType == xtpCalendarSelectionDays ? 1 : 0;
  3557. m_pView->m_cntSelChanged.m_nLockCount_Event += eSelType == xtpCalendarSelectionEvents ? 1 : 0;
  3558. }
  3560. CXTPCalendarView::CSelectionChangedContext::~CSelectionChangedContext()
  3561. {
  3562. if (!m_pView)
  3563. {
  3564. ASSERT(FALSE);
  3565. return;
  3566. }
  3567. if (m_eSelType == xtpCalendarSelectionUnknown)
  3568. {
  3569. m_pView->m_cntSelChanged.m_nLockCount--;
  3570. }
  3572. if (m_eSelType == xtpCalendarSelectionDays)
  3573. {
  3574. m_pView->m_cntSelChanged.m_nLockCount_Day--;
  3576. if (m_pView->m_cntSelChanged.m_nLockCount_Day == 0)
  3577. {
  3578. m_pView->m_cntSelChanged.m_bRequest_Day = TRUE;
  3579. }
  3580. }
  3581. if (m_eSelType == xtpCalendarSelectionEvents)
  3582. {
  3583. m_pView->m_cntSelChanged.m_nLockCount_Event--;
  3585. if (m_pView->m_cntSelChanged.m_nLockCount_Event == 0)
  3586. {
  3587. m_pView->m_cntSelChanged.m_bRequest_Event = TRUE;
  3588. }
  3589. }
  3591. if (m_pView->m_cntSelChanged.m_nLockCount == 0 && m_pView->m_cntSelChanged.m_bRequest_Day)
  3592. {
  3593. m_pView->m_cntSelChanged.m_bRequest_Day = FALSE;
  3594. m_pView->SendNotification(XTP_NC_CALENDAR_SELECTION_CHANGED, (WPARAM)xtpCalendarSelectionDays);
  3595. }
  3596. if (m_pView->m_cntSelChanged.m_nLockCount == 0 && m_pView->m_cntSelChanged.m_bRequest_Event)
  3597. {
  3598. m_pView->m_cntSelChanged.m_bRequest_Event = FALSE;
  3599. m_pView->SendNotification(XTP_NC_CALENDAR_SELECTION_CHANGED, (WPARAM)xtpCalendarSelectionEvents);
  3600. }
  3601. }
  3603. /////////////////////////////////////////////////////////////////////////////
  3605. /////////////////////////////////////////////////////////////////////////////
  3606. // CXTPCalendarWMHandler
  3607. CXTPCalendarWMHandler::CXTPCalendarWMHandler()
  3608. {
  3609. }
  3611. int CXTPCalendarWMHandler::GetChildHandlersCount()
  3612. {
  3613. return 0;
  3614. }
  3616. CXTPCalendarWMHandler* CXTPCalendarWMHandler::GetChildHandlerAt(int nIndex)
  3617. {
  3618. UNREFERENCED_PARAMETER(nIndex);
  3619. return NULL;
  3620. }
  3622. BOOL CXTPCalendarWMHandler::OnLButtonDown(UINT nFlags, CPoint point)
  3623. {
  3624. BOOL bHandled = FALSE;
  3626. int nCount = GetChildHandlersCount();
  3627. for (int i = 0; i < nCount; i++)
  3628. {
  3629. CXTPCalendarWMHandler* pChild = GetChildHandlerAt(i);
  3630. if (pChild && pChild->OnLButtonDown(nFlags, point))
  3631. {
  3632. bHandled = TRUE;
  3633. break;
  3634. }
  3635. }
  3637. return bHandled;
  3638. }
  3640. BOOL CXTPCalendarWMHandler::OnLButtonUp(UINT nFlags, CPoint point)
  3641. {
  3642. BOOL bHandled = FALSE;
  3644. int nCount = GetChildHandlersCount();
  3645. for (int i = 0; i < nCount; i++)
  3646. {
  3647. CXTPCalendarWMHandler* pChild = GetChildHandlerAt(i);
  3648. if (pChild && pChild->OnLButtonUp(nFlags, point))
  3649. {
  3650. bHandled = TRUE;
  3651. break;
  3652. }
  3653. }
  3655. return bHandled;
  3656. }
  3658. BOOL CXTPCalendarWMHandler::OnLButtonDblClk(UINT nFlags, CPoint point)
  3659. {
  3660. BOOL bHandled = FALSE;
  3662. int nCount = GetChildHandlersCount();
  3663. for (int i = 0; i < nCount; i++)
  3664. {
  3665. CXTPCalendarWMHandler* pChild = GetChildHandlerAt(i);
  3666. if (pChild && pChild->OnLButtonDblClk(nFlags, point))
  3667. {
  3668. bHandled = TRUE;
  3669. break;
  3670. }
  3671. }
  3673. return bHandled;
  3674. }
  3676. void CXTPCalendarWMHandler::OnMouseMove(UINT nFlags, CPoint point)
  3677. {
  3678. int nCount = GetChildHandlersCount();
  3679. for (int i = 0; i < nCount; i++)
  3680. {
  3681. CXTPCalendarWMHandler* pChild = GetChildHandlerAt(i);
  3682. if (pChild)
  3683. {
  3684. pChild->OnMouseMove(nFlags, point);
  3685. }
  3686. }
  3687. }
  3689. void CXTPCalendarWMHandler::OnChar(UINT nChar, UINT nRepCnt, UINT nFlags)
  3690. {
  3691. int nCount = GetChildHandlersCount();
  3692. for (int i = 0; i < nCount; i++)
  3693. {
  3694. CXTPCalendarWMHandler* pChild = GetChildHandlerAt(i);
  3695. if (pChild)
  3696. {
  3697. pChild->OnChar(nChar, nRepCnt, nFlags);
  3698. }
  3699. }
  3700. }
  3702. void CXTPCalendarWMHandler::OnKeyDown(UINT nChar, UINT nRepCnt, UINT nFlags)
  3703. {
  3704. int nCount = GetChildHandlersCount();
  3705. for (int i = 0; i < nCount; i++)
  3706. {
  3707. CXTPCalendarWMHandler* pChild = GetChildHandlerAt(i);
  3708. if (pChild)
  3709. {
  3710. pChild->OnKeyDown(nChar, nRepCnt, nFlags);
  3711. }
  3712. }
  3713. }
  3715. void CXTPCalendarWMHandler::OnKeyUp(UINT nChar, UINT nRepCnt, UINT nFlags)
  3716. {
  3717. int nCount = GetChildHandlersCount();
  3718. for (int i = 0; i < nCount; i++)
  3719. {
  3720. CXTPCalendarWMHandler* pChild = GetChildHandlerAt(i);
  3721. if (pChild)
  3722. {
  3723. pChild->OnKeyUp(nChar, nRepCnt, nFlags);
  3724. }
  3725. }
  3726. }
  3728. BOOL CXTPCalendarWMHandler::OnSysKeyDown(UINT nChar, UINT nRepCnt, UINT nFlags)
  3729. {
  3730. BOOL bHandled = FALSE;
  3732. int nCount = GetChildHandlersCount();
  3733. for (int i = 0; i < nCount; i++)
  3734. {
  3735. CXTPCalendarWMHandler* pChild = GetChildHandlerAt(i);
  3736. if (pChild && pChild->OnSysKeyDown(nChar, nRepCnt, nFlags))
  3737. {
  3738. bHandled = TRUE;
  3739. break;
  3740. }
  3741. }
  3743. return bHandled;
  3744. }
  3747. BOOL CXTPCalendarWMHandler::OnTimer(UINT_PTR uTimerID)
  3748. {
  3749. int nCount = GetChildHandlersCount();
  3750. for (int i = 0; i < nCount; i++)
  3751. {
  3752. CXTPCalendarWMHandler* pChild = GetChildHandlerAt(i);
  3753. if (pChild && pChild->OnTimer(uTimerID))
  3754. {
  3755. return TRUE;
  3756. }
  3757. }
  3758. return FALSE;
  3759. }
  3761. void CXTPCalendarWMHandler::OnPostAdjustLayout()
  3762. {
  3763. int nCount = GetChildHandlersCount();
  3764. for (int i = 0; i < nCount; i++)
  3765. {
  3766. CXTPCalendarWMHandler* pChild = GetChildHandlerAt(i);
  3767. if (pChild)
  3768. {
  3769. pChild->OnPostAdjustLayout();
  3770. }
  3771. }
  3772. }
  3774. void CXTPCalendarWMHandler::OnFinalRelease()
  3775. {
  3776. OnBeforeDestroy();
  3777. CCmdTarget::OnFinalRelease();
  3778. }
  3780. void CXTPCalendarWMHandler::OnBeforeDestroy()
  3781. {
  3782. int nCount = GetChildHandlersCount();
  3783. for (int i = 0; i < nCount; i++)
  3784. {
  3785. CXTPCalendarWMHandler* pChild = GetChildHandlerAt(i);
  3786. if (pChild)
  3787. {
  3788. pChild->OnBeforeDestroy();
  3789. }
  3790. }
  3791. }