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

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

对话框与窗口

开发平台：

Visual C++

XTPCalendarViewEvent.cpp：源码内容
  1. // XTPCalendarViewEvent.cpp: implementation of the CXTPCalendarViewEvent class.
  2. //
  3. // This file is a part of the XTREME CALENDAR MFC class library.
  4. // (c)1998-2008 Codejock Software, All Rights Reserved.
  5. //
  6. // THIS SOURCE FILE IS THE PROPERTY OF CODEJOCK SOFTWARE AND IS NOT TO BE
  7. // RE-DISTRIBUTED BY ANY MEANS WHATSOEVER WITHOUT THE EXPRESSED WRITTEN
  8. // CONSENT OF CODEJOCK SOFTWARE.
  9. //
  10. // THIS SOURCE CODE CAN ONLY BE USED UNDER THE TERMS AND CONDITIONS OUTLINED
  11. // IN THE XTREME TOOLKIT PRO LICENSE AGREEMENT. CODEJOCK SOFTWARE GRANTS TO
  12. // YOU (ONE SOFTWARE DEVELOPER) THE LIMITED RIGHT TO USE THIS SOFTWARE ON A
  13. // SINGLE COMPUTER.
  14. //
  15. // CONTACT INFORMATION:
  16. // support@codejock.com
  17. // http://www.codejock.com
  18. //
  19. /////////////////////////////////////////////////////////////////////////////
  21. #include "stdafx.h"
  23. #include "Common/XTPVC50Helpers.h"
  25. #include "Common/XTPMarkupRender.h"
  27. #include "XTPCalendarViewEvent.h"
  28. #include "XTPCalendarView.h"
  29. #include "XTPCalendarControl.h"
  30. #include "XTPCalendarViewDay.h"
  31. #include "XTPCalendarTheme.h"
  32. #include "XTPCalendarCustomProperties.h"
  34. #ifdef _DEBUG
  35. #undef THIS_FILE
  36. static char THIS_FILE[] = __FILE__;
  37. #define new DEBUG_NEW
  38. #endif
  40. //////////////////////////////////////////////////////////////////////
  41. //class CXTPCalendarViewEventSubjectEditor : public CEdit
  43. IMPLEMENT_DYNAMIC(CXTPCalendarViewEvent, CXTPCalendarWMHandler)
  45. BEGIN_MESSAGE_MAP(CXTPCalendarViewEventSubjectEditor, CEdit)
  46. ON_WM_GETDLGCODE()
  47. END_MESSAGE_MAP()
  49. CXTPCalendarViewEventSubjectEditor::CXTPCalendarViewEventSubjectEditor(CXTPCalendarControl* pOwner)
  50. {
  51. ASSERT(pOwner);
  52. m_pOwner = pOwner;
  53. }
  55. CXTPCalendarViewEventSubjectEditor::~CXTPCalendarViewEventSubjectEditor()
  56. {
  57. }
  59. BOOL CXTPCalendarViewEventSubjectEditor::OnWndMsg(UINT message, WPARAM wParam,
  60.   LPARAM lParam, LRESULT* pResult)
  61. {
  62. ASSERT(m_pOwner);
  64. if (m_pOwner)
  65. {
  66. if(message == WM_MOUSEMOVE)
  67. {
  68. CPoint pt(lParam);
  69. MapWindowPoints(m_pOwner, &pt, 1);
  70. lParam = MAKELPARAM(pt.x, pt.y);
  71. }
  73. BOOL bHandled = m_pOwner->OnWndMsg_Children(message, wParam, lParam, pResult);
  74. if (bHandled)
  75. {
  76. return TRUE;
  77. }
  78. }
  79. return CEdit::OnWndMsg(message, wParam, lParam, pResult);
  80. }
  82. UINT CXTPCalendarViewEventSubjectEditor::OnGetDlgCode()
  83. {
  84. return DLGC_WANTARROWS | DLGC_WANTTAB | DLGC_WANTALLKEYS;
  85. }
  87. //////////////////////////////////////////////////////////////////////
  88. CXTPCalendarViewEvent::CXTPCalendarViewEvent(CXTPCalendarEvent* pEvent, CXTPCalendarViewGroup* pViewGroup)
  89. {
  90. UNUSED_ALWAYS(pViewGroup);
  92. m_bShowingToolTip = FALSE;
  94. ASSERT(pEvent);
  95. m_ptrEvent = pEvent;
  96. CMDTARGET_ADDREF(m_ptrEvent);
  98. m_pMasterView = NULL;
  99. m_pUIElement = NULL;
  101. m_bSelected = FALSE;
  103. m_nMultiDayEventFlags = xtpCalendarMultiDayUnknown;
  105. m_nEventPlaceNumber = 0;
  107. m_nTimerID_ShowToolTip = 0;
  109. m_pSubjectEditor = NULL;
  111. //m_rcFirstClock.SetRect(0, 0, 0, 0);
  112. //m_rcLastClock.SetRect(0, 0, 0, 0);
  113. //m_rcStartTime.SetRect(0, 0, 0, 0);
  114. //m_rcEndTime.SetRect(0, 0, 0, 0);
  115. //  m_rcGlyphs.SetRect(0, 0, 0, 0);
  116. m_rcText.SetRect(0, 0, 0, 0);
  117. m_szText.cx = 0;
  118. m_szText.cy = 0;
  119. m_bMultyDayTextAlign = FALSE;
  121. m_bTextOutOfBorders = TRUE;
  123. }
  125. CXTPCalendarViewEvent::~CXTPCalendarViewEvent()
  126. {
  127. //---------------------------------------------------------------------------
  128. if (m_pSubjectEditor)
  129. {
  130. ASSERT(FALSE);
  131. delete m_pSubjectEditor;
  132. m_pSubjectEditor = NULL;
  133. }
  135. CMDTARGET_RELEASE(m_ptrEvent);
  136. CMDTARGET_RELEASE(m_pMasterView);
  138. XTPMarkupReleaseElement(m_pUIElement);
  140. ASSERT(m_nTimerID_ShowToolTip == 0);
  141. }
  143. void CXTPCalendarViewEvent::OnBeforeDestroy()
  144. {
  145. //---------------------------------------------------------------------------
  147. if (IsEditingSubject())
  148. {
  149. XTP_SAFE_CALL3(GetViewGroup_(), GetViewDay_(), GetView_(), EndEditSubject(xtpCalendarEditSubjectCommit, FALSE) );
  150. }
  151. //---------------------------------------------------------------------------
  152. if (m_nTimerID_ShowToolTip)
  153. {
  154. KillTimer(m_nTimerID_ShowToolTip);
  155. m_nTimerID_ShowToolTip = 0;
  156. }
  158. if (IsShowingToolTip())
  159. {
  160. HideToolTip();
  161. }
  162. }
  164. CXTPCalendarControl* CXTPCalendarViewEvent::GetCalendarControl()
  165. {
  166. return XTP_SAFE_GET2(GetViewGroup_(), GetViewDay_(), GetCalendarControl(), NULL);
  167. }
  169. void CXTPCalendarViewEvent::AdjustLayout(CDC* pDC, const CRect& rcEventMax, int nEventPlaceNumber)
  170. {
  171. UNREFERENCED_PARAMETER(pDC);
  173. m_rcEvent.CopyRect(&rcEventMax);
  174. m_rcEventMax.CopyRect(&rcEventMax);
  176. m_rcSubjectEditor.CopyRect(&rcEventMax);
  177. m_rcToolTip.CopyRect(&rcEventMax);
  178. m_rcText.CopyRect(&rcEventMax);
  179. m_rcStartTime.CopyRect(m_rcEvent);
  180. m_rcStartTime.DeflateRect(0, 0, m_rcStartTime.Width(), m_rcStartTime.Height());
  181. m_rcEndTime.CopyRect(m_rcStartTime);
  183. m_nEventPlaceNumber = nEventPlaceNumber;
  184. }
  186. void CXTPCalendarViewEvent::OnMouseMove(UINT nFlags, CPoint point)
  187. {
  188. UNREFERENCED_PARAMETER(nFlags);
  190. CXTPCalendarView* pView =  XTP_SAFE_GET2(GetViewGroup_(), GetViewDay_(), GetView_(), NULL);
  192. if (!pView || !GetCalendarControl())
  193. {
  194. ASSERT(FALSE);
  195. return;
  196. }
  198. XTP_CALENDAR_HITTESTINFO hitInfo;
  199. BOOL bIsNoDragging = pView->GetDraggingMode() == xtpCalendaDragModeUnknown;
  200. BOOL bHideTooltip = TRUE;
  202. BOOL bHit = HitTest(point, &hitInfo);
  204. // to check that mouse is not over some topmost element (like Expand/Scroll button)
  205. if (bHit)
  206. {
  207. bHit = XTP_SAFE_GET3(GetViewGroup_(), GetViewDay_(), GetView_(), HitTest(point, &hitInfo), FALSE) &&
  208. ((hitInfo.uHitCode & xtpCalendarHitTestEvent_Mask) && hitInfo.pViewEvent == this);
  209. }
  211. if (bHit)
  212. {
  213. int eDragMode = pView->_GetDraggingMode(&hitInfo);
  214. BOOL bDragEnabled = !pView->IsEditOperationDisabledNotify(pView->_DragMod2Operation(eDragMode), this);
  216. if (bDragEnabled && hitInfo.uHitCode & xtpCalendarHitTestEventResizeHArea)
  217. {
  218. GetCalendarControl()->m_mouseMode = xtpCalendarMouseEventPreResizeH;
  219. }
  220. else if (bDragEnabled && hitInfo.uHitCode & xtpCalendarHitTestEventResizeVArea)
  221. {
  222. GetCalendarControl()->m_mouseMode = xtpCalendarMouseEventPreResizeV;
  223. }
  224. else if (bDragEnabled && hitInfo.uHitCode & xtpCalendarHitTestEventDragArea)
  225. {
  226. GetCalendarControl()->m_mouseMode = xtpCalendarMouseEventPreDrag;
  227. }
  228. else if (hitInfo.uHitCode & xtpCalendarHitTestEventTextArea)
  229. {
  230. bHideTooltip = !!(nFlags & MK_LBUTTON);
  231. BOOL bShow = !IsMultidayEvent() || XTP_SAFE_GET2(pView, GetResources(), GetCount(), 0) > 1;
  233. if (bShow && bIsNoDragging && !IsEditingSubject() && !pView->IsEditingSubject() &&
  234. !IsShowingToolTip() && !(nFlags&MK_LBUTTON) && m_bTextOutOfBorders)
  235. {
  236. if (m_nTimerID_ShowToolTip == 0)
  237. {
  238. UINT uTimeOut_ms = GetShowToolTipTimeOut();
  239. m_nTimerID_ShowToolTip = SetTimer(uTimeOut_ms);
  240. ASSERT(m_nTimerID_ShowToolTip);
  242. DBG_TRACE_TIMER(_T("SET Timer: ID =%d, m_nTimerID_ShowToolTip, CXTPCalendarViewEvent::OnMouseMove(xtpCalendarHitTestEvent_Mask) n"), m_nTimerID_ShowToolTip);
  243. }
  244. }
  245. }
  246. }
  247. else // we are not under Event view area
  248. {
  249. // kill waiting for mouse under event view area
  250. if (m_nTimerID_ShowToolTip)
  251. {
  252. KillTimer(m_nTimerID_ShowToolTip);
  253. m_nTimerID_ShowToolTip = 0;
  254. }
  255. }
  257. if (bHideTooltip && IsShowingToolTip())
  258. {
  259. HideToolTip();
  260. }
  261. }
  263. //void CXTPCalendarViewEvent::OnChar(UINT nChar, UINT nRepCnt, UINT nFlags)
  264. //{
  265. //  UNREFERENCED_PARAMETER(nChar);
  266. //  UNREFERENCED_PARAMETER(nRepCnt);
  267. //  UNREFERENCED_PARAMETER(nFlags);
  268. //}
  269. //
  270. //void CXTPCalendarViewEvent::OnKeyDown(UINT nChar, UINT nRepCnt, UINT nFlags)
  271. //{
  272. //  UNREFERENCED_PARAMETER(nChar);
  273. //  UNREFERENCED_PARAMETER(nRepCnt);
  274. //  UNREFERENCED_PARAMETER(nFlags);
  275. //}
  276. //
  277. //BOOL CXTPCalendarViewEvent::OnSysKeyDown(UINT nChar, UINT nRepCnt, UINT nFlags)
  278. //{
  279. //  UNREFERENCED_PARAMETER(nChar);
  280. //  UNREFERENCED_PARAMETER(nRepCnt);
  281. //  UNREFERENCED_PARAMETER(nFlags);
  282. //  return FALSE;
  283. //}
  286. void CXTPCalendarViewEvent::AddMultiDayEvent_Slave(CXTPCalendarViewEvent* pSlaveView, int nMasterEventPlace)
  287. {
  288. if (!pSlaveView || !pSlaveView->GetViewGroup_() || !GetEvent())
  289. {
  290. ASSERT(FALSE);
  291. return;
  292. }
  294. pSlaveView->GetViewGroup_()->ExchangeEventPlace(pSlaveView, nMasterEventPlace);
  295. pSlaveView->SetMultiDayEvent_MasterSlave(FALSE, this);
  297. if (!pSlaveView->IsVisible())
  298. {
  299. return;
  300. }
  302. //  ASSERT(m_rcEvent.top == pSlaveView->m_rcEvent.top);
  303. //  ASSERT(m_rcEventMax.bottom == pSlaveView->m_rcEventMax.bottom);
  305. m_rcEvent.right = pSlaveView->m_rcEvent.right;
  306. m_rcEventMax.right = pSlaveView->m_rcEventMax.right;
  308. // correct right margins
  309. m_rcText.right = m_rcEvent.right;
  310. m_rcLastClock.CopyRect(m_rcText);
  311. m_rcLastClock.left = m_rcLastClock.right;
  312. m_rcLastClock.bottom = m_rcLastClock.top;
  314. //pSlaveView->SetMultiDayEvent_MasterSlave(FALSE, this);
  316. int nMDEFlags = pSlaveView->GetMultiDayEventFlags();
  318. if (nMDEFlags & xtpCalendarMultiDayLast)
  319. {
  320. m_nMultiDayEventFlags |= xtpCalendarMultiDayLast;
  321. COleDateTime dtEE(GetEvent()->GetEndTime());
  322. if (dtEE == CXTPCalendarUtils::ResetTime(dtEE) || GetEvent()->IsAllDayEvent())
  323. {
  324. m_rcLastClock.left = m_rcLastClock.right;
  325. }
  326. else
  327. {
  328. // correct last clock rect
  329. CSize szClock = XTP_SAFE_GET4(GetViewGroup_(), GetViewDay_(), GetView_(), GetPaintManager(), GetClockSize(), CSize(0) );
  330. m_rcLastClock.left = m_rcLastClock.right - szClock.cx -1;
  331. m_rcLastClock.bottom = m_rcLastClock.top + szClock.cy;
  332. m_rcText.right -= szClock.cx;
  333. }
  334. }
  335. }
  337. BOOL CXTPCalendarViewEvent::IsMultidayEvent()
  338. {
  339. if (!m_ptrEvent)
  340. {
  341. ASSERT(FALSE);
  342. return FALSE;
  343. }
  345. if (m_ptrEvent->IsAllDayEvent())
  346. {
  347. return TRUE;
  348. }
  350. int nDays = m_ptrEvent->GetEventPeriodDays();
  351. return nDays > 1;
  352. }
  354. void CXTPCalendarViewEvent::OnPostAdjustLayout()
  355. {
  356. if (IsMultidayEvent())
  357. {
  358. m_rcSubjectEditor.CopyRect(&m_rcEvent);
  359. m_rcSubjectEditor.left += 1;
  361. m_rcText.CopyRect(m_rcEvent);
  362. m_rcText.left += min(m_rcText.Width()-1, m_rcFirstClock.Width() + 4);
  363. m_rcText.right -= min(m_rcText.Width()-1, m_rcLastClock.Width() + 4);
  365. int nGlyphs = CalcIconsRect(m_rcEvent);
  366. CRect rcGlyphs(max(m_rcText.CenterPoint().x - (m_szText.cx/2 + nGlyphs + 3), m_rcText.left),
  367.    m_rcText.top,
  368.    m_rcText.right,
  369.    m_rcText.bottom
  370.  );
  371. if (m_rcText.CenterPoint().x <= m_rcText.left + nGlyphs + m_szText.cx/2) //
  372. {
  373. m_rcText.left = min(m_rcText.left + CalcIconsRect(rcGlyphs), m_rcText.right);
  375. m_bMultyDayTextAlign = TRUE;
  376. }
  377. else
  378. {
  379. m_bMultyDayTextAlign = FALSE;
  380. CalcIconsRect(rcGlyphs);
  381. }
  382. }
  384. m_rcToolTip = m_rcEvent;
  386. AdjustSubjectEditor();
  387. }
  389. void CXTPCalendarViewEvent::AdjustMultidayEvent(CRect rcEventMax, int nEventPlaceNumber)
  390. {
  391. if (!XTP_SAFE_GET3(GetViewGroup_(), GetViewDay_(), GetView_(), GetPaintManager(), NULL)
  392. || !m_ptrEvent)
  393. {
  394. ASSERT(FALSE);
  395. return;
  396. }
  398. int nRowHeight = GetViewGroup_()->GetViewDay_()->GetView_()->GetRowHeight();
  400. m_nMultiDayEventFlags = 0;
  402. m_rcEventMax.top = rcEventMax.top + nRowHeight * nEventPlaceNumber + 1;
  403. m_rcEventMax.bottom = m_rcEventMax.top + nRowHeight - 2;
  405. m_rcEvent.CopyRect(&m_rcEventMax);
  406. m_rcEvent.left += 4;
  407. m_rcEvent.right -= 4;
  409. if (!IsMultidayEvent())
  410. {
  411. m_nMultiDayEventFlags = xtpCalendarMultiDayNoMultiDay;
  412. return;
  413. }
  415. COleDateTime dtDay = GetViewGroup_()->GetViewDay_()->GetDayDate();
  417. COleDateTime dtStartDay = CXTPCalendarUtils::ResetTime(m_ptrEvent->GetStartTime());
  418. COleDateTime dtEndDay = CXTPCalendarUtils::RetriveEventEndDate(m_ptrEvent);
  420. //TRACE(dtStartDay.Format(_T("%A, %B %d, %Y %H %M %sn")));
  421. //TRACE(dtEndDay.Format(_T("%A, %B %d, %Y %H %M %sn")));
  422. ASSERT(dtDay == dtStartDay || dtDay == dtEndDay || dtDay > dtStartDay && dtDay < dtEndDay);
  424. m_rcText.CopyRect(m_rcEvent);
  425. m_rcFirstClock.CopyRect(m_rcEvent);
  426. m_rcFirstClock.right = m_rcFirstClock.left;
  427. m_rcFirstClock.bottom = m_rcFirstClock.top;
  428. CSize szClock(GetViewGroup_()->GetViewDay_()->GetView_()->GetPaintManager()->GetClockSize());
  430. if (dtDay == dtStartDay)
  431. {
  432. m_nMultiDayEventFlags |= xtpCalendarMultiDayFirst;
  433. if (!m_ptrEvent->IsAllDayEvent() && dtDay != m_ptrEvent->GetStartTime())
  434. {
  435. m_rcFirstClock.right = m_rcFirstClock.left + szClock.cx;
  436. m_rcFirstClock.bottom = m_rcFirstClock.top + szClock.cy;
  437. m_rcText.left += m_rcFirstClock.right + 4;
  438. }
  439. }
  441. if (dtDay == dtEndDay)
  442. {
  443. m_nMultiDayEventFlags |= xtpCalendarMultiDayLast;
  444. }
  446. COleDateTimeSpan spDay(1, 0, 0, 0);
  447. if (dtDay == m_ptrEvent->GetEndTime() - spDay)
  448. {
  449. m_nMultiDayEventFlags |= xtpCalendarMultiDayLast;
  450. }
  451. else if (dtDay > dtStartDay && dtDay < dtEndDay)
  452. {
  453. m_nMultiDayEventFlags |= xtpCalendarMultiDayMiddle;
  454. }
  456. //m_rcGlyphs.CopyRect(rcEventMax);
  457. m_rcStartTime.CopyRect(m_rcEventMax);
  458. m_rcStartTime.right = m_rcStartTime.left;
  459. m_rcEndTime.CopyRect(m_rcEventMax);
  460. m_rcStartTime.left = m_rcStartTime.right;
  461. }
  463. void CXTPCalendarViewEvent::_MoveRectY(int nYbasePrev, int nYbaseNew, CRect& rRC)
  464. {
  465. int nOffset = rRC.top - nYbasePrev;
  466. rRC.bottom = rRC.Height() + nYbaseNew + nOffset;
  467. rRC.top = nYbaseNew + nOffset;
  468. }
  470. void CXTPCalendarViewEvent::ChangeEventPlace(int nNewPlace)
  471. {
  472. int nEventHeight = XTP_SAFE_GET3(GetViewGroup_(), GetViewDay_(), GetView_(), GetRowHeight(), 1);
  474. int nY0 = m_rcEvent.top;
  475. int nEventsTop = m_rcEvent.top - m_nEventPlaceNumber * nEventHeight - 1;
  476. int nY1 = nEventsTop + nNewPlace * nEventHeight + 1;
  478. _ChangeEventPlace(nNewPlace, nY0, nY1);
  479. }
  481. void CXTPCalendarViewEvent::_ChangeEventPlace(int nNewPlace, int nYbasePrev, int nYbaseNew)
  482. {
  483. _MoveRectY(nYbasePrev, nYbaseNew, m_rcFirstClock);
  484. _MoveRectY(nYbasePrev, nYbaseNew, m_rcLastClock);
  486. _MoveRectY(nYbasePrev, nYbaseNew, m_rcStartTime);
  487. _MoveRectY(nYbasePrev, nYbaseNew, m_rcEndTime);
  489. _MoveRectY(nYbasePrev, nYbaseNew, m_rcReminderGlyph);
  490. _MoveRectY(nYbasePrev, nYbaseNew, m_rcRecurrenceGlyph);
  492. _MoveRectY(nYbasePrev, nYbaseNew, m_rcMeetingGlyph);
  493. _MoveRectY(nYbasePrev, nYbaseNew, m_rcPrivateGlyph);
  495. _MoveRectY(nYbasePrev, nYbaseNew, m_rcEvent);
  496. _MoveRectY(nYbasePrev, nYbaseNew, m_rcEventMax);
  497. _MoveRectY(nYbasePrev, nYbaseNew, m_rcSubjectEditor);
  498. _MoveRectY(nYbasePrev, nYbaseNew, m_rcToolTip);
  499. _MoveRectY(nYbasePrev, nYbaseNew, m_rcText);
  501. m_nEventPlaceNumber = nNewPlace;
  502. }
  504. void CXTPCalendarViewEvent::SetMultiDayEvent_MasterSlave(BOOL bMaster, CXTPCalendarViewEvent* pMasterView)
  505. {
  506. m_nMultiDayEventFlags |= bMaster ? xtpCalendarMultiDayMaster : xtpCalendarMultiDaySlave;
  508. ASSERT(bMaster && !pMasterView || !bMaster && pMasterView);
  510. CMDTARGET_RELEASE(m_pMasterView);
  511. m_pMasterView = pMasterView;
  512. CMDTARGET_ADDREF(m_pMasterView);
  513. }
  515. UINT CXTPCalendarViewEvent::SetTimer(UINT uTimeOut_ms)
  516. {
  517. return XTP_SAFE_GET1(GetViewGroup_(), SetTimer(uTimeOut_ms), 0);
  518. }
  520. void CXTPCalendarViewEvent::KillTimer(UINT uTimerID)
  521. {
  522. XTP_SAFE_CALL1(GetViewGroup_(), KillTimer(uTimerID) );
  523. }
  525. BOOL CXTPCalendarViewEvent::OnTimer(UINT_PTR uTimerID)
  526. {
  527. if (!uTimerID)
  528. {
  529. ASSERT(FALSE);
  530. return FALSE;
  531. }
  533. if (uTimerID == m_nTimerID_ShowToolTip)
  534. {
  535. ShowToolTip();
  536. return TRUE;
  537. }
  538. return FALSE;
  539. }
  541. CXTPCalendarViewEvent* CXTPCalendarViewEvent::StartEditSubject()
  542. {
  543. //- Forward editing process to master event ---------------------------------
  544. if (m_pMasterView)
  545. {
  546. if (!m_pMasterView->IsEditingSubject())
  547. {
  548. m_pMasterView->StartEditSubject();
  549. }
  550. return m_pMasterView;
  551. }
  553. // ensure that previous one is destroyed.
  554. if (m_pSubjectEditor)
  555. {
  556. ASSERT(FALSE);
  557. delete m_pSubjectEditor;
  558. m_pSubjectEditor = NULL;
  559. }
  561. CXTPCalendarControl* pControl = GetCalendarControl();
  562. if (!pControl)
  563. {
  564. ASSERT(FALSE);
  565. return NULL;
  566. }
  568. if (IsShowingToolTip())
  569. {
  570. HideToolTip();
  571. }
  573. // let theme to customize subject editor
  574. if (pControl->GetTheme())
  575. {
  576. m_pSubjectEditor = pControl->GetTheme()->StartEditSubject(this);
  577. if (m_pSubjectEditor)
  578. {
  579. return this;
  580. }
  581. }
  583. //- create and show text editor ---------------------------------------------
  584. m_pSubjectEditor = new CXTPCalendarViewEventSubjectEditor(pControl);
  585. if (!m_pSubjectEditor)
  586. {
  587. return NULL;
  588. }
  590. DWORD dwEditStyles = WS_CHILD | WS_VISIBLE | GetSubjectEditorStyles()
  591.  | ES_MULTILINE | ES_AUTOHSCROLL;
  593. m_pSubjectEditor->Create(dwEditStyles, m_rcSubjectEditor, pControl, 0);
  595. //m_pSubjectEditor->CreateEx(WS_EX_TRANSPARENT, _T("EDIT"), NULL,
  596. //                         dwEditStyles, m_rcSubjectEditor, pControl, 0);
  598. m_pSubjectEditor->SetFocus();
  599. CFont* pEditorFont = GetSubjectEditorFont();
  600. if (pEditorFont)
  601. {
  602. m_pSubjectEditor->SetFont(pEditorFont);
  603. }
  605. m_pSubjectEditor->SetWindowText(XTP_SAFE_GET1(m_ptrEvent, GetSubject(), _T("")));
  606. m_pSubjectEditor->SetSel(0, 0);
  608. //---------------------------------------------------------------------------
  609. return this;
  610. }
  612. CString CXTPCalendarViewEvent::GetEditingSubjectFromEditor()
  613. {
  614. if (!m_pSubjectEditor)
  615. {
  616. ASSERT(FALSE);
  617. return _T("");
  618. }
  620. CString strSubject;
  621. m_pSubjectEditor->GetWindowText(strSubject);
  623. REPLACE_S(strSubject, _T(" rrn "), _T(" "));
  624. REPLACE_S(strSubject, _T(" rrn"), _T(" "));
  625. REPLACE_S(strSubject, _T("rrn "), _T(" "));
  627. REPLACE_S(strSubject, _T("rn"), _T(" "));
  628. REPLACE_S(strSubject, _T("n"), _T(" "));
  629. REPLACE_S(strSubject, _T("r"), _T(" "));
  631. return strSubject;
  632. }
  634. CString CXTPCalendarViewEvent::EndEditSubject()
  635. {
  636. if (!m_pSubjectEditor)
  637. {
  638. ASSERT(FALSE);
  639. return _T("");
  640. }
  642. CString strSubject = GetEditingSubjectFromEditor();
  644. //---------------------------------------------------------------------------
  645. delete m_pSubjectEditor;
  646. m_pSubjectEditor = NULL;
  647. //---------------------------------------------------------------------------
  648. return strSubject;
  649. }
  651. BOOL CXTPCalendarViewEvent::IsShowingToolTip()
  652. {
  653. return m_bShowingToolTip;
  654. }
  656. void CXTPCalendarViewEvent::ShowToolTip()
  657. {
  658. if (m_nTimerID_ShowToolTip)
  659. {
  660. KillTimer(m_nTimerID_ShowToolTip);
  661. m_nTimerID_ShowToolTip = 0;
  662. }
  663. BOOL bFocused = CWnd::GetFocus() == (CWnd*)GetCalendarControl();
  665. if (!bFocused)
  666. {
  667. return;
  668. }
  670. // create tooltip text
  671. CString strTip = GetToolText();
  673. // show tooltip window
  674. if (GetCalendarControl())
  675. {
  676. GetCalendarControl()->ShowToolTip(strTip, m_rcToolTip, GetSubjectEditorFont());
  677. m_bShowingToolTip = TRUE;
  678. }
  679. }
  681. void CXTPCalendarViewEvent::HideToolTip()
  682. {
  683. if (GetCalendarControl())
  684. {
  685. GetCalendarControl()->HideToolTip();
  686. }
  687. m_bShowingToolTip = FALSE;
  688. }
  690. CString CXTPCalendarViewEvent::FormatEventTime(COleDateTime dtTime)
  691. {
  692. return XTP_SAFE_GET3(GetViewGroup_(), GetViewDay_(), GetView_(), FormatEventTime(dtTime), _T("") );
  693. }
  695. CString CXTPCalendarViewEvent::GetToolText()
  696. {
  697. if (!m_ptrEvent)
  698. {
  699. ASSERT(FALSE);
  700. return _T("");
  701. }
  703. CString strTime;
  705. if (!IsMultidayEvent())
  706. {
  707. COleDateTime dtStart = m_ptrEvent->GetStartTime();
  708. COleDateTime dtEnd = m_ptrEvent->GetEndTime();
  710. DWORD dwTimeFlags = xtpCalendarItemText_EventStartTimeText;
  711. if (!CXTPCalendarUtils::IsEqual(dtStart, dtEnd))
  712. dwTimeFlags = dwTimeFlags | xtpCalendarItemText_EventEndTimeText;
  714. strTime = GetItemText(dwTimeFlags);
  715. }
  717. if (!strTime.IsEmpty())
  718. {
  719. strTime += _T(" ");
  720. }
  722. CString strTip = strTime + m_ptrEvent->GetSubject();
  724. // add Location for Office2007 theme
  725. CXTPCalendarControl* pControl = GetCalendarControl();
  726. if (pControl)
  727. {
  728. if (pControl->GetPaintTheme() == xtpCalendarThemeOffice2007)
  729. {
  730. CString strLocation(m_ptrEvent->GetLocation());
  731. if (strLocation.GetLength() > 0)
  732. {
  733. strTip += _T("n(") + strLocation + _T(")");
  734. }
  735. }
  736. }
  737. //---------------------------------------------------------
  738. DWORD dwFlags = XTP_SAFE_GET1(GetCalendarControl(), GetAskItemTextFlags(), 0);
  740. if (dwFlags & xtpCalendarItemText_EventToolTipText)
  741. {
  742. XTP_CALENDAR_GETITEMTEXT_PARAMS objRequest;
  743. ::ZeroMemory(&objRequest, sizeof(objRequest));
  745. objRequest.nItem = (int)xtpCalendarItemText_EventToolTipText;
  746. objRequest.pstrText = &strTip;
  747. objRequest.pViewEvent = this;
  749. XTP_SAFE_CALL1(GetCalendarControl(), SendNotificationAlways(XTP_NC_CALENDAR_GETITEMTEXT, (WPARAM)&objRequest, 0));
  750. }
  752. return strTip;
  753. }
  756. int CXTPCalendarViewEvent::CalcIconsRect(CRect rc)
  757. {
  758. rc.top += 2;
  759. rc.bottom += 2;
  761. m_rcReminderGlyph.CopyRect(rc);
  762. m_rcPrivateGlyph.CopyRect(rc);
  763. m_rcRecurrenceGlyph.CopyRect(rc);
  764. m_rcMeetingGlyph.CopyRect(rc);
  765. m_rcReminderGlyph.right = m_rcReminderGlyph.left;
  766. m_rcPrivateGlyph.right = m_rcPrivateGlyph.left;
  767. m_rcRecurrenceGlyph.right = m_rcRecurrenceGlyph.left;
  768. m_rcMeetingGlyph.right = m_rcMeetingGlyph.left;
  770. m_rcReminderGlyph.bottom = m_rcReminderGlyph.top + 11;
  771. m_rcPrivateGlyph.bottom = m_rcPrivateGlyph.top + 11;
  772. m_rcRecurrenceGlyph.bottom = m_rcRecurrenceGlyph.top + 11;
  773. m_rcMeetingGlyph.bottom = m_rcMeetingGlyph.top + 11;
  775. CPoint ptX(rc.left, rc.top);
  776. CPoint ptY(rc.left, rc.top);
  777. int nMinsize = 0;
  779. if (GetEvent() && GetEvent()->IsReminder())
  780. {
  781. m_rcReminderGlyph.right = min(m_rcReminderGlyph.right + 15, rc.right);
  782. ptX.Offset(15, 0);
  783. ptY.Offset(0, 11);
  784. }
  786. if (GetEvent() && GetEvent()->IsPrivate())
  787. {
  788. if (rc.bottom - (ptY.y + 11) > 11)
  789. {
  790. m_rcPrivateGlyph.left = min(ptY.x, rc.right);
  791. m_rcPrivateGlyph.top = min(ptY.y, rc.bottom);
  792. ptY.Offset(0, 11);
  793. }
  794. else
  795. {
  796. m_rcPrivateGlyph.left = min(ptX.x, rc.right);
  797. m_rcPrivateGlyph.top = min(ptX.y, rc.bottom);
  798. ptX.Offset(11, 0);
  800. }
  801. m_rcPrivateGlyph.right = min(m_rcPrivateGlyph.left + 11, rc.right);
  802. m_rcPrivateGlyph.bottom = min(m_rcPrivateGlyph.top + 11, rc.bottom);
  803. nMinsize = 15;
  804. }
  806. int nRecurrenceState = XTP_SAFE_GET1(GetEvent(), GetRecurrenceState(), xtpCalendarRecurrenceNotRecurring);
  807. if ((nRecurrenceState & xtpCalendarRecurrenceMaster) ||
  808. (nRecurrenceState == xtpCalendarRecurrenceOccurrence) ||
  809. (nRecurrenceState == xtpCalendarRecurrenceException)
  810.  )
  812. {
  813. if (rc.bottom - (ptY.y + 11) > 11)
  814. {
  815. m_rcRecurrenceGlyph.left = min(ptY.x, rc.right);
  816. m_rcRecurrenceGlyph.top = min(ptY.y, rc.bottom);
  817. ptY.Offset(0, 11);
  818. }
  819. else
  820. {
  821. m_rcRecurrenceGlyph.left = min(ptX.x, rc.right);
  822. m_rcRecurrenceGlyph.top = min(ptX.y, rc.bottom);
  823. ptX.Offset(15, 0);
  825. }
  826. m_rcRecurrenceGlyph.right = min(m_rcRecurrenceGlyph.left + 15, rc.right);
  827. m_rcRecurrenceGlyph.bottom = min(m_rcRecurrenceGlyph.top + 11, rc.bottom);
  828. nMinsize = 15;
  829. }
  831. if (GetEvent() && GetEvent()->IsMeeting())
  832. {
  833. if (rc.bottom - (ptY.y + 11) > 11)
  834. {
  835. m_rcMeetingGlyph.left = min(ptY.x, rc.right);
  836. m_rcMeetingGlyph.top = min(ptY.y, rc.bottom);
  837. ptY.Offset(0, 11);
  838. }
  839. else
  840. {
  841. m_rcMeetingGlyph.left = min(ptX.x, rc.right);
  842. m_rcMeetingGlyph.top = min(ptX.y, rc.bottom);
  843. ptX.Offset(15, 0);
  845. }
  846. m_rcMeetingGlyph.right = min(m_rcMeetingGlyph.left + 15, rc.right);
  847. m_rcMeetingGlyph.bottom = min(m_rcMeetingGlyph.top + 11, rc.bottom);
  848. nMinsize = 15;
  849. }
  851. return max((ptX.x)- rc.left, nMinsize);
  852. }
  854. void CXTPCalendarViewEvent::AdjustSubjectEditor()
  855. {
  856. if (IsEditingSubject() && m_pSubjectEditor)
  857. {
  858. m_pSubjectEditor->MoveWindow(&m_rcSubjectEditor, FALSE);
  859. }
  860. }
  862. BOOL CXTPCalendarViewEvent::IsSelected() const
  863. {
  864. CXTPCalendarViewEvents* pSelEvents = XTP_SAFE_GET3(GetViewGroup_(), GetViewDay_(), GetView_(), GetSelectedViewEvents(), NULL);
  865. if (!pSelEvents)
  866. {
  867. return FALSE;
  868. }
  870. int nFIndex = pSelEvents->Find(m_ptrEvent);
  871. return nFIndex >= 0;
  872. }
  874. void CXTPCalendarViewEvent::SetSelected(BOOL bSet)
  875. {
  876. XTP_SAFE_CALL3(GetViewGroup_(), GetViewDay_(), GetView_(), SelectViewEvent(this, bSet) );
  877. }
  879. CString CXTPCalendarViewEvent::GetItemText(DWORD dwItemFlag, LPCTSTR pcszDefaultText)
  880. {
  881. if (!GetCalendarControl() || !m_ptrEvent)
  882. {
  883. ASSERT(FALSE);
  884. return _T("");
  885. }
  887. DWORD dwFlags = GetCalendarControl()->GetAskItemTextFlags();
  889. CString strText;
  891. if (pcszDefaultText)
  892. {
  893. strText = pcszDefaultText;
  894. }
  895. else
  896. {
  897. if (dwItemFlag & xtpCalendarItemText_EventSubject)
  898. {
  899. strText = m_ptrEvent->GetSubject();
  900. }
  901. else if (dwItemFlag & xtpCalendarItemText_EventLocation)
  902. {
  903. strText = m_ptrEvent->GetLocation();
  904. }
  905. else if (dwItemFlag & xtpCalendarItemText_EventBody)
  906. {
  907. strText = m_ptrEvent->GetBody();
  908. }
  909. else if (dwItemFlag & (xtpCalendarItemText_EventStartTimeText | xtpCalendarItemText_EventEndTimeText))
  910. {
  911. if (dwItemFlag & xtpCalendarItemText_EventStartTimeText)
  912. strText = FormatEventTime(m_ptrEvent->GetStartTime());
  914. if (dwItemFlag & xtpCalendarItemText_EventEndTimeText)
  915. {
  916. if (!strText.IsEmpty())
  917. strText += _T("-");
  918. strText += FormatEventTime(m_ptrEvent->GetEndTime());
  919. }
  920. }
  921. else if (dwItemFlag & xtpCalendarItemText_EventMarkupTemplate)
  922. {
  923. COleVariant oleMTempl;
  924. BOOL bProp = m_ptrEvent->GetCustomProperties()->GetProperty(cszEventCustProp_MarkupTemplate, oleMTempl);
  925. if (bProp &&oleMTempl.vt == VT_BSTR)
  926. {
  927. strText = oleMTempl.bstrVal;
  928. }
  929. }
  930. else
  931. {
  932. ASSERT(FALSE);
  933. return _T("");
  934. }
  935. }
  937. if ((dwItemFlag & xtpCalendarItemText_EventMarkupTemplate) == 0)
  938. strText.Left(XTP_CALENDAR_DRAW_EVENTITEMTEXT_MAX);
  940. if (dwFlags & dwItemFlag)
  941. {
  942. XTP_CALENDAR_GETITEMTEXT_PARAMS objRequest;
  943. ::ZeroMemory(&objRequest, sizeof(objRequest));
  945. objRequest.nItem = (int)dwItemFlag;
  946. objRequest.pstrText = &strText;
  947. objRequest.pViewEvent = this;
  949. GetCalendarControl()->SendNotificationAlways(XTP_NC_CALENDAR_GETITEMTEXT, (WPARAM)&objRequest, 0);
  950. }
  952. return strText;
  953. }
  955. CString CXTPCalendarViewEvent::GetMarkupText()
  956. {
  957. //  /Calendar/Events/Event/Subject
  958. //  /Calendar/Events/Event/Location
  959. //  /Calendar/Events/Event/Body
  960. //  /Calendar/Events/Event/StartTime
  961. //  /Calendar/Events/Event/EndTime
  963. //TODO: Add NoCase parameters replacement.
  965. CString strMarkupTemplate = GetItemText(xtpCalendarItemText_EventMarkupTemplate);
  966. //strMarkupTemplate = _T("<StackPanel><TextBlock Background='#00ebff' Padding='12, 0, 2, 0'><Bold>%S</Bold></TextBlock><Border Height='1'/><TextBlock Foreground='Green'>[%L]</TextBlock><Border Height='1'/><TextBlock>%B</TextBlock></StackPanel>");
  967. //strMarkupTemplate = _T("<StackPanel><TextBlock Padding='12, 0, 2, 0'><Bold>%S</Bold></TextBlock><Border Height='1'/><TextBlock Foreground='Green'>[%L]</TextBlock><Border Height='1'/><TextBlock>%B</TextBlock></StackPanel>");
  969. TRIMLEFT_S(strMarkupTemplate, _T(" tnr"));
  970. TRIMRIGHT_S(strMarkupTemplate, _T(" tnr"));
  972. if (strMarkupTemplate.Find(cszCalendarMarkupPrm_Subject) >= 0)
  973. REPLACE_S(strMarkupTemplate, cszCalendarMarkupPrm_Subject, GetItemTextSubject());
  975. if (strMarkupTemplate.Find(cszCalendarMarkupPrm_Location) >= 0)
  976. REPLACE_S(strMarkupTemplate, cszCalendarMarkupPrm_Location, GetItemTextLocation());
  978. if (strMarkupTemplate.Find(cszCalendarMarkupPrm_Body) >= 0)
  979. REPLACE_S(strMarkupTemplate, cszCalendarMarkupPrm_Body, GetItemTextBody());
  981. if (strMarkupTemplate.Find(cszCalendarMarkupPrm_StartTime) >= 0)
  982. REPLACE_S(strMarkupTemplate, cszCalendarMarkupPrm_StartTime, GetItemTextStartTime());
  984. if (strMarkupTemplate.Find(cszCalendarMarkupPrm_EndTime) >= 0)
  985. REPLACE_S(strMarkupTemplate, cszCalendarMarkupPrm_EndTime, GetItemTextEndTime());
  987. return strMarkupTemplate;
  988. }
  990. CXTPMarkupUIElement* CXTPCalendarViewEvent::GetMarkupUIElement()
  991. {
  992. if (!GetCalendarControl() || !GetCalendarControl()->IsMarkupEnabled())
  993. return NULL;
  995. CXTPMarkupContext* pMarkupContext = GetCalendarControl()->GetMarkupContext();
  996. ASSERT(pMarkupContext);
  998. CString strMKText = GetMarkupText();
  1000. if (!pMarkupContext || strMKText.IsEmpty())
  1001. return NULL;
  1004. if (!m_pUIElement || strMKText != m_strUIElementText)
  1005. {
  1006. XTPMarkupReleaseElement(m_pUIElement);
  1008. m_pUIElement = XTPMarkupParseText(pMarkupContext, strMKText);
  1010. m_strUIElementText = strMKText;
  1011. }
  1013. return m_pUIElement;
  1014. }
  1016. //////////////////////////////////////////////////////////////////////////
  1017. //  CXTPCalendarViewEvents
  1018. //
  1020. CXTPCalendarViewEvents::CXTPCalendarViewEvents()
  1021. {
  1022. }
  1024. CXTPCalendarViewEvents::~CXTPCalendarViewEvents()
  1025. {
  1026. }
  1028. int CXTPCalendarViewEvents::Find(CXTPCalendarEvent* pEvent)
  1029. {
  1030. if (!pEvent)
  1031. {
  1032. ASSERT(FALSE);
  1033. return -1;
  1034. }
  1036. int nCount = GetCount();
  1037. for (int i = 0; i < nCount; i++)
  1038. {
  1039. CXTPCalendarViewEvent* pViewEvent = GetAt(i);
  1040. CXTPCalendarEvent* pEv = pViewEvent ? pViewEvent->GetEvent() : NULL;
  1041. if (pEv && pEvent->IsEqualIDs(pEv) && pEvent->IsEqualStartEnd(pEv))
  1042. {
  1043. return i;
  1044. }
  1045. }
  1047. return -1;
  1048. }
  1050. void CXTPCalendarViewEvents::Remove(CXTPCalendarEvent* pEvent)
  1051. {
  1052. if (!pEvent)
  1053. {
  1054. ASSERT(FALSE);
  1055. return;
  1056. }
  1058. int nCount = GetCount();
  1059. for (int i = nCount -1 ; i >= 0; i--)
  1060. {
  1061. CXTPCalendarViewEvent* pViewEvent = GetAt(i);
  1062. CXTPCalendarEvent* pEv = XTP_SAFE_GET1(pViewEvent, GetEvent(), NULL);
  1063. if (pEv && pEvent->IsEqualIDs(pEv) && pEvent->IsEqualStartEnd(pEv))
  1064. {
  1065. RemoveAt(i);
  1066. }
  1067. }
  1068. }