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

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

对话框与窗口

开发平台：

Visual C++

XTPCalendarDayView.cpp：源码内容
  1. // XTPCalendarDayView.cpp: implementation of the CXTPCalendarDayView 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 "XTPCalendarData.h"
  24. #include "XTPCalendarDayView.h"
  25. #include "XTPCalendarDayViewTimeScale.h"
  26. #include "XTPCalendarUtils.h"
  28. #include "XTPCalendarPaintManager.h"
  29. #include "XTPCalendarTheme.h"
  30. #include "XTPCalendarThemeOffice2007.h"
  32. #include "XTPCalendarControl.h"
  33. #include "XTPCalendarRecurrencePattern.h"
  34. #include "XTPCalendarNotifications.h"
  36. #include "Common/XTPDrawHelpers.h"
  37. #include "Common/XTPVC50Helpers.h"
  39. #include <math.h>
  41. #ifdef _DEBUG
  42. #undef THIS_FILE
  43. static char THIS_FILE[] = __FILE__;
  44. #define new DEBUG_NEW
  45. #endif
  47. #define XTP_SCROLL_TIMER_RESOLUTION_MS  30
  48. #define XTP_REDRAW_TIMER_RESOLUTION_MS  2000
  50. //////////////////////////////////////////////////////////////////////
  51. // Construction/Destruction
  52. //////////////////////////////////////////////////////////////////////
  53. IMPLEMENT_DYNAMIC(CXTPCalendarDayView, CXTPCalendarView)
  55. CXTPCalendarDayView::CXTPCalendarDayView(CXTPCalendarControl* pCalendarControl) :
  56. TBase(pCalendarControl, xtpCalendarDayView),
  57. m_ptLastMousePos(0, 0)
  58. {
  59. m_pTimeScaleHeader = new CXTPCalendarDayViewTimeScale(this);
  60. m_pTimeScaleHeader2 = new CXTPCalendarDayViewTimeScale(this, FALSE, FALSE);
  62. m_LayoutX.m_nRowCount = 0;
  63. m_LayoutX.m_nVisibleRowCount = 0;
  64. m_LayoutX.m_nTopRow = 0;
  66. m_LayoutX.m_rcAllDayEvents.SetRectEmpty();
  67. m_LayoutX.m_rcDayHeader.SetRectEmpty();
  69. m_LayoutX.m_nAllDayEventsCountMax = 0;
  70. m_LayoutX.m_nAllDayEventHeight = 0;
  72. m_nAllDayEventsCountMin_WhenDrag = 0;
  74. m_spDraggingStartOffset_Time = 0.;
  76. m_nScrollOffsetX = 0;
  77. m_nMinColumnWidth = -1; // 0 - means disabled; -1 use auto for multiresources; -X use for multiresources only; +X used always (in single and multi resources mode).
  79. // add today to the day view by default
  80. COleDateTime dtNow(CXTPCalendarUtils::GetCurrentTime());
  81. m_arDays.Add(new CXTPCalendarDayViewDay(this, dtNow));
  83. // go to the beginning of the work day
  84. int nHour = 0, nMin = 0, nSec = 0;
  85. XTP_SAFE_CALL1(m_pControl, GetWorkDayStartTime(nHour, nMin, nSec));
  86. int nPos = GetCellNumber(nHour, nMin, nSec, FALSE);
  87. _ScrollV(nPos, nPos);
  89. m_dwScrollingEventTimerID = 0;
  90. m_bMouseOutOfDragArea = FALSE;
  91. m_dtDraggingStartPoint = COleDateTime(0, 0, 0, 0, 0, 0);
  93. m_dwRedrawNowLineTimerID = 0;
  94. m_dtLastRedrawTime = CXTPCalendarUtils::GetCurrentTime();
  96. m_ptLBtnDownMousePos = CPoint(0,0);
  97. }
  99. CXTPCalendarDayView::~CXTPCalendarDayView()
  100. {
  101. CMDTARGET_RELEASE(m_pTimeScaleHeader);
  102. CMDTARGET_RELEASE(m_pTimeScaleHeader2);
  104. ClearDays();
  105. }
  107. XTPCalendarViewType CXTPCalendarDayView::GetViewType()
  108. {
  109. int nWWMask = m_pControl ? m_pControl->GetWorkWeekMask() : xtpCalendarDayMo_Fr;
  111. int nDaysCount = GetViewDayCount();
  113. int nWWCount = CXTPCalendarUtils::GetDayOfWeekCount(nWWMask);
  114. if (nDaysCount != nWWCount && nDaysCount != 7)
  115. {
  116. return xtpCalendarDayView;
  117. }
  119. int nFirstDayOfWeek = m_pControl ? m_pControl->GetFirstDayOfWeek() : xtpCalendarDayMonday;
  120. int nNextWWeekIdx = CXTPCalendarUtils::GetDayOfWeekIndex(nFirstDayOfWeek);
  121. BOOL bWDOrderFull = TRUE;
  122. int nViewType = xtpCalendarWorkWeekView;
  124. for (int i = 0; i < nDaysCount; i++)
  125. {
  126. COleDateTime dtDay = GetViewDayDate(i);
  127. int nDayOfWeek = dtDay.GetDayOfWeek();
  128. int nDayMask = CXTPCalendarUtils::GetDayOfWeekMask(nDayOfWeek);
  130. if ((nWWMask & nDayMask) == 0)
  131. {
  132. nViewType = xtpCalendarDayView;
  133. }
  135. if (nNextWWeekIdx != nDayOfWeek)
  136. bWDOrderFull = FALSE;
  138. nNextWWeekIdx = (nNextWWeekIdx % 7) + 1;
  139. }
  141. if (nDaysCount == 7 && bWDOrderFull)
  142. nViewType = xtpCalendarFullWeekView;
  144. return (XTPCalendarViewType)nViewType;
  145. }
  147. void CXTPCalendarDayView::ClearDays()
  148. {
  149. m_arDays.RemoveAll();
  150. }
  152. COleDateTime CXTPCalendarDayView::GetCellTime(int nCell) const
  153. {
  154. double dblTime = (long)nCell * (double)GetCellDuration();
  156. return (DATE)dblTime;
  157. }
  159. COleDateTimeSpan CXTPCalendarDayView::GetCellDuration() const
  160. {
  161. return m_pTimeScaleHeader ? m_pTimeScaleHeader->GetScaleInterval() : (double)0;
  162. }
  164. int CXTPCalendarDayView::GetCellNumber(COleDateTime dtTime, BOOL bForEndTime) const
  165. {
  166. double dblTime = (double)CXTPCalendarUtils::ResetDate(dtTime);
  168. double dblEpsilon = XTP_HALF_SECOND * (bForEndTime ? -1 : 1);
  169. double dblCellDur = (double)GetCellDuration();
  170. if (dblCellDur <= XTP_HALF_SECOND)
  171. {
  172. dblCellDur = XTP_HALF_SECOND * 2 * 60 * 30;
  173. }
  174. int nCell = int(dblTime / dblCellDur + dblEpsilon);
  175. return nCell;
  176. }
  178. int CXTPCalendarDayView::GetCellNumber(int nHour, int nMin, int nSec, BOOL bForEndTime) const
  179. {
  180. COleDateTime dtTime;
  181. dtTime.SetTime(nHour, nMin, nSec);
  182. return GetCellNumber(dtTime, bForEndTime);
  183. }
  185. void CXTPCalendarDayView::ScrollV(int nIndex, int nPos_raw)
  186. {
  187. if (m_bScrollV_Disabled)
  188. {
  189. return;
  190. }
  191. _ScrollV(nIndex, nPos_raw);
  192. }
  194. void CXTPCalendarDayView::_ScrollV(int nIndex, int /*nPos_raw*/)
  195. {
  196. if (nIndex + m_LayoutX.m_nVisibleRowCount >= m_LayoutX.m_nRowCount)
  197. {
  198. nIndex = m_LayoutX.m_nRowCount - m_LayoutX.m_nVisibleRowCount;
  199. }
  201. if (nIndex == m_LayoutX.m_nTopRow)
  202. return;
  204. m_LayoutX.m_nTopRow = nIndex;
  205. }
  207. void CXTPCalendarDayView::ScrollH(int nPos, int nPos_raw)
  208. {
  209. SCROLLINFO si;
  210. if (!GetScrollBarInfoH(&si))
  211. {
  212. m_nScrollOffsetX = 0;
  213. }
  215. int nXmax = si.nMax - si.nPage + 1;
  217. m_nScrollOffsetX = min(max(nPos, si.nMin), nXmax);
  219. if (!m_bScrollH_Disabled)
  220. {
  221. if (nPos_raw < 0)
  222. {
  223. ScrollDaysToPrev();
  224. }
  225. else if (nPos_raw > nXmax)
  226. {
  227. ScrollDaysToNext();
  228. }
  229. }
  230. }
  232. BOOL CXTPCalendarDayView::GetScrollBarInfoV(SCROLLINFO* pSI)
  233. {
  234. ASSERT(pSI);
  235. if (!pSI || m_bScrollV_Disabled)
  236. {
  237. return FALSE;
  238. }
  240. pSI->nPos = m_LayoutX.m_nTopRow;
  241. pSI->nMax = m_LayoutX.m_nRowCount - 1;
  242. pSI->nPage = m_LayoutX.m_nVisibleRowCount;
  244. return m_LayoutX.m_nVisibleRowCount != m_LayoutX.m_nRowCount;
  245. }
  247. BOOL CXTPCalendarDayView::GetScrollBarInfoH(SCROLLINFO* pSI, int* pnScrollStep)
  248. {
  249. ASSERT(pSI);
  250. if (!pSI)
  251. return FALSE;
  253. int nMinColumnWidth = RecalcMinColumnWidth();
  254. if (nMinColumnWidth <= 0)
  255. return FALSE;
  256. int nColumnsCount = GetTotalGroupsCount();
  258. CRect rcClient = _GetScrollRectClient();
  260. int nFullWidth = nColumnsCount * nMinColumnWidth;
  262. if (nFullWidth <= rcClient.Width())
  263. return FALSE;
  265. pSI->nPos = min(m_nScrollOffsetX, nFullWidth);
  266. pSI->nMin = 0;
  267. pSI->nMax = nFullWidth-1;
  268. pSI->nPage = rcClient.Width();
  270. if (pnScrollStep)
  271. *pnScrollStep = 15;
  273. return TRUE;
  274. }
  276. int CXTPCalendarDayView::GetTotalGroupsCount()
  277. {
  278. int nGroupsCount = 0;
  280. int nDays = GetViewDayCount();
  281. for (int i = 0; i < nDays; i++)
  282. {
  283. CXTPCalendarDayViewDay* pDay = GetViewDay(i);
  284. ASSERT(pDay);
  285. if (pDay)
  286. nGroupsCount += pDay->GetViewGroupsCount();
  287. }
  288. return nGroupsCount;
  289. }
  291. int CXTPCalendarDayView::RecalcMinColumnWidth()
  292. {
  293. int nMinColumnWidth = m_nMinColumnWidth;
  294. if (nMinColumnWidth < 0)
  295. {
  296. // automatically use horizontal scrolling for multi-resources mode
  297. if (GetResources() && GetResources()->GetCount() <= 1)
  298. return -1;
  300. if (nMinColumnWidth == -1)
  301. nMinColumnWidth = ::GetSystemMetrics(SM_CXFULLSCREEN) / 6;
  302. else
  303. nMinColumnWidth = abs(nMinColumnWidth);
  304. }
  305. return nMinColumnWidth;
  306. }
  308. int CXTPCalendarDayView::GetAllDayEventsMaxCount()
  309. {
  310. int nAllDayMax = 0;
  311. int nCount = GetViewDayCount();
  312. for (int i = 0; i < nCount; i++)
  313. {
  314. CXTPCalendarDayViewDay* pViewDay = GetViewDay(i);
  315. ASSERT(pViewDay);
  316. if (!pViewDay)
  317. continue;
  318. int nGroupsCount = pViewDay->GetViewGroupsCount();
  319. for (int g = 0; g < nGroupsCount; g++)
  320. {
  321. int nAllDay = 0;
  323. CXTPCalendarDayViewGroup* pViewGroup = pViewDay->GetViewGroup(g);
  324. ASSERT(pViewGroup);
  325. if (!pViewGroup)
  326. {
  327. continue;
  328. }
  329. int nECount = pViewGroup->GetViewEventsCount();
  330. for (int j = 0; j < nECount; j++)
  331. {
  332. CXTPCalendarDayViewEvent* pViewEvent = pViewGroup->GetViewEvent(j);
  333. ASSERT(pViewEvent);
  334. if (pViewEvent && pViewEvent->IsMultidayEvent())
  335. {
  336. nAllDay++;
  337. }
  338. }
  340. nAllDayMax = max(nAllDayMax, nAllDay);
  341. }
  342. }
  343. return nAllDayMax;
  344. }
  346. void CXTPCalendarDayView::AdjustAllDayEvents()
  347. {
  348. if (GetResources() && GetResources()->GetCount() > 1)
  349. {
  350. return;
  351. }
  353. int nDaysCount = GetViewDayCount();
  354. for (int nDayIdx = 0; nDayIdx < nDaysCount; nDayIdx++)
  355. {
  356. CXTPCalendarDayViewDay* pViewDay = GetViewDay(nDayIdx);
  357. if (!pViewDay)
  358. {
  359. ASSERT(FALSE);
  360. continue;
  361. }
  362. // go through all days to look for multiday events
  363. int nGroupsCount = pViewDay->GetViewGroupsCount();
  364. for (int g = 0; g < nGroupsCount; g++)
  365. {
  366. CXTPCalendarDayViewGroup* pViewGroup = pViewDay->GetViewGroup(g);
  367. ASSERT(pViewGroup);
  368. if (!pViewGroup)
  369. {
  370. continue;
  371. }
  372. int nEventsCount = pViewGroup->GetViewEventsCount();
  373. for (int nEvent = 0; nEvent < nEventsCount; nEvent++)
  374. {
  375. CXTPCalendarViewEvent* pViewEvent = pViewGroup->GetViewEvent(nEvent);
  376. if (!pViewEvent)
  377. {
  378. ASSERT(FALSE);
  379. continue;
  380. }
  382. int nMDEFlags = pViewEvent->GetMultiDayEventFlags();
  384. if ((nMDEFlags & xtpCalendarMultiDayMSmask) || !(nMDEFlags & xtpCalendarMultiDayFMLmask))
  385. {
  386. continue; // already marked or not multi day
  387. }
  388. //------------------------
  390. pViewEvent->SetMultiDayEvent_MasterSlave(TRUE, NULL);
  391. int nMasterPlace = pViewEvent->GetEventPlaceNumber();
  393. if ((nMDEFlags & xtpCalendarMultiDayLast) == 0)
  394. {
  395. // find other visible instances and mark them as Slave
  396. for (int i = nDayIdx + 1; i < nDaysCount; i++)
  397. {
  398. CXTPCalendarViewDay* pViewDay2 = GetViewDay(i);
  399. if (XTP_SAFE_GET1(pViewDay2, GetViewGroupsCount(), 0) != 1)
  400. {
  401. ASSERT(FALSE);
  402. break;
  403. }
  404. CXTPCalendarViewEvent* pViewEvent2 = XTP_SAFE_GET2(pViewDay2,
  405. GetViewGroup_(0), GetViewEventByEvent_(pViewEvent->GetEvent()), NULL);
  407. if (!pViewEvent2)
  408. {
  409. break;
  410. }
  411. pViewEvent->AddMultiDayEvent_Slave(pViewEvent2, nMasterPlace);
  412. }
  413. }
  414. }
  415. }
  417. }
  418. }
  420. int CXTPCalendarDayView::CalculateHeaderFormatAndHeight(CDC* pDC, int nCellWidth)
  421. {
  422. ASSERT(pDC);
  424. const int cnMinHeight = 19;
  426. CXTPCalendarViewPart* pPart = XTP_SAFE_GET1(GetPaintManager(), GetDayViewHeaderPart(), NULL);
  427. ASSERT(pPart);
  428. if (!pPart || !pDC)
  429. {
  430. return cnMinHeight;
  431. }
  433. CalculateHeaderFormat(pDC, nCellWidth, &pPart->GetTextFont());
  435. CString strHearderTest = _T("QW(");
  437. int nCount = GetViewDayCount();
  438. for (int i = 0; i < nCount; i++)
  439. {
  440. CXTPCalendarDayViewDay* pDay = GetViewDay(i);
  441. ASSERT(pDay);
  442. if (pDay)
  443. {
  444. strHearderTest += pDay->GetCaption();
  445. }
  446. }
  448. CXTPFontDC fnt(pDC, &pPart->GetTextFont());
  450. CSize sizeH = pDC->GetTextExtent(strHearderTest);
  451. int nHeight = max(cnMinHeight, sizeH.cy + 6);
  453. return nHeight;
  454. }
  456. CXTPCalendarData* CXTPCalendarDayView::_GetDataProviderByConnStr(LPCTSTR pcszConnStr, BOOL bCompareNoCase)
  457. {
  458. UNREFERENCED_PARAMETER(pcszConnStr);
  459. UNREFERENCED_PARAMETER(bCompareNoCase);
  461. return NULL;
  462. }
  464. BOOL CXTPCalendarDayView::IsGroupHeaderVisible()
  465. {
  466. BOOL bHideHeader = XTP_SAFE_GET1(GetResources(), GetCount(), 0) == 1 &&
  467. XTP_SAFE_GET2(GetResources(), GetAt(0), IsSchedulesSetEmpty(), FALSE);
  468. return !bHideHeader;
  469. }
  471. void CXTPCalendarDayView::AdjustLayout(CDC* pDC, const CRect& rcView, BOOL bCallPostAdjustLayout)
  472. {
  473. ASSERT(pDC);
  474. if (!pDC)
  475. {
  476. return;
  477. }
  479. XTP_SAFE_CALL1(m_pTimeScaleHeader, SetCaption(GetScaleText()) );
  480. XTP_SAFE_CALL1(m_pTimeScaleHeader2, SetCaption(GetScale2Text()) );
  481. XTP_SAFE_CALL1(m_pTimeScaleHeader2, SetVisible(IsScale2Visible()) );
  483. TBase::AdjustLayout(pDC, rcView, FALSE);
  485. COleDateTimeSpan spDay(1, 0, 0, 0);
  487. double dRows = spDay / max((double)m_pTimeScaleHeader->GetScaleInterval(), XTP_HALF_SECOND * 2);
  488. m_LayoutX.m_nRowCount = (int)(dRows + XTP_HALF_SECOND); // to prevent loosing 1 :  (int)(47.99999999999) = 47; // need 48 !
  490. //CString str; str.Format(_T("RowsCount[%d] = %.15e (%.15e)"), m_nRowCount, dRows, (dRows + XTP_HALF_SECOND));
  491. //AfxMessageBox(str);
  493. CRect rcView2 = rcView;
  494. // alternative time scale
  495. if (IsScale2Visible())
  496. {
  497. int nTimeScale2Width = XTP_SAFE_GET1(m_pTimeScaleHeader2, CalcWidth(pDC), 0);
  499. m_pTimeScaleHeader2->m_Layout.m_rcHeader.SetRect(rcView2.left, rcView2.top, rcView2.left + nTimeScale2Width, rcView2.bottom);
  500. rcView2.left += nTimeScale2Width;
  502. AdjustScale2TimeZone();
  503. }
  505. // regular time scale
  506. if (m_pTimeScaleHeader)
  507. {
  508. int nTimeScaleWidth = XTP_SAFE_GET1(m_pTimeScaleHeader, CalcWidth(pDC), 0);
  509. m_pTimeScaleHeader->m_Layout.m_rcHeader.SetRect(rcView2.left, rcView2.top, rcView2.left + nTimeScaleWidth, rcView2.bottom);
  510. rcView2.left += nTimeScaleWidth;
  511. }
  513. CXTPCalendarViewPart* pPart = XTP_SAFE_GET1(GetPaintManager(), GetDayViewHeaderPart(), NULL);
  514. int nDaysCount = GetViewDayCount();
  515. if (nDaysCount <= 0 || !pPart)
  516. {
  517. return;
  518. }
  520. int nColumnsCount = GetTotalGroupsCount();
  522. // Adjust Header
  523. int nCellWidth = rcView2.Width() / max(nDaysCount, 1);
  524. int nDayHeaderHeight = CalculateHeaderFormatAndHeight(pDC, nCellWidth);
  526. int nMinRowHeight = nDayHeaderHeight;
  527. m_LayoutX.m_nAllDayEventsCountMax = max(1, GetAllDayEventsMaxCount());
  529. if (m_eDraggingMode == xtpCalendaDragModeResizeBegin || m_eDraggingMode == xtpCalendaDragModeResizeEnd
  530. || _IsDragModeCopyMove(m_eDraggingMode))
  531. {
  532. m_LayoutX.m_nAllDayEventsCountMax = max(m_LayoutX.m_nAllDayEventsCountMax, m_nAllDayEventsCountMin_WhenDrag);
  533. m_nAllDayEventsCountMin_WhenDrag = m_LayoutX.m_nAllDayEventsCountMax;
  534. }
  536. BOOL bGroupHeaderVisible = IsGroupHeaderVisible();
  537. int nDGHeadersHeight = nDayHeaderHeight * (bGroupHeaderVisible ? 2 : 1);
  539. // day view part
  540. int nRowCount = m_LayoutX.m_nRowCount;
  541. int nTotalRows = nRowCount + m_LayoutX.m_nAllDayEventsCountMax + (bGroupHeaderVisible ? 2 : 1);
  543. m_Layout.m_nRowHeight = max(nMinRowHeight, rcView2.Height() / max(nTotalRows, 1));
  545. double dVisibleRowCountMax = (double)(rcView2.Height()) / (double)(max(m_Layout.m_nRowHeight, 1));
  546. double dVisibleRowCount = dVisibleRowCountMax - (0.2 + m_LayoutX.m_nAllDayEventsCountMax) -
  547. (bGroupHeaderVisible ? 2 : 1);
  549. m_LayoutX.m_nVisibleRowCount = max((int)dVisibleRowCount, max(0, (int)dVisibleRowCountMax/2));
  550. m_LayoutX.m_nVisibleRowCount = max(0, min(nRowCount, m_LayoutX.m_nVisibleRowCount));
  552. if (m_LayoutX.m_nTopRow + m_LayoutX.m_nVisibleRowCount >= m_LayoutX.m_nRowCount)
  553. {
  554. m_LayoutX.m_nTopRow = m_LayoutX.m_nRowCount - m_LayoutX.m_nVisibleRowCount;
  555. }
  557. int nAllDayEventsHeight = max(0, rcView2.Height() - (m_LayoutX.m_nVisibleRowCount * m_Layout.m_nRowHeight + nDGHeadersHeight));
  559. m_LayoutX.m_rcDayHeader.SetRect(rcView2.left, rcView2.top, rcView2.right, rcView2.top + nDayHeaderHeight);
  561. m_LayoutX.m_rcAllDayEvents.SetRect(rcView2.left, rcView2.top + nDGHeadersHeight,
  562.  rcView2.right, rcView2.top + nAllDayEventsHeight + nDGHeadersHeight);
  564. int nCols = 0;
  565. for (int i = 0; i < nDaysCount; i++)
  566. {
  567. CXTPCalendarDayViewDay* pDay = GetViewDay(i);
  568. if (!pDay)
  569. {
  570. ASSERT(FALSE);
  571. continue;
  572. }
  574. //int nWidth = (i == nDaysCount - 1) ? rcView2.Width() : rcView2.Width() / (nColumnsCount - nCols);
  575. int nWidth = (rcView2.Width() / (nColumnsCount - nCols)) * pDay->GetViewGroupsCount();
  576. if (i == nDaysCount - 1)
  577. nWidth = rcView2.Width();
  580. CRect rcDay(rcView2.left, rcView2.top, rcView2.left + nWidth, rcView2.bottom);
  581. pDay->AdjustLayout(pDC, rcDay);
  583. rcView2.left += nWidth;
  584. nCols += pDay->GetViewGroupsCount();
  585. }
  587. //----------------------------------------------
  588. if (nDaysCount && XTP_SAFE_GET1(GetViewDay(0), GetViewGroupsCount(), 0) &&
  589. GetViewDay(0)->GetViewGroup(0) )
  590. {
  591. CRect rcAllDayEvents = GetViewDay(0)->GetViewGroup(0)->GetAllDayEventsRect();
  592. ASSERT(rcAllDayEvents.Height() == m_LayoutX.m_rcAllDayEvents.Height());
  594. m_LayoutX.m_rcAllDayEvents.top = rcAllDayEvents.top;
  595. m_LayoutX.m_rcAllDayEvents.bottom = rcAllDayEvents.bottom;
  596. }
  598. AdjustAllDayEvents();
  600. //----------------------------------------------------------
  601. XTP_SAFE_CALL1(m_pTimeScaleHeader, AdjustLayout(pDC) );
  602. XTP_SAFE_CALL1(m_pTimeScaleHeader2, AdjustLayout(pDC) );
  604. //---------------------------------------------------------------------------
  605. int nDVCount = GetViewDayCount();
  606. if (nDVCount)
  607. {
  608. COleDateTime dtFirstDay = GetViewDayDate(0);
  609. COleDateTime dtLastDay = GetViewDayDate(nDVCount-1);
  610. BOOL bSelChanged = FALSE;
  612. if (m_selectedBlock.dtEnd.GetStatus() != COleDateTime::valid ||
  613. m_selectedBlock.dtBegin.GetStatus() != COleDateTime::valid)
  614. {
  615. int nSelRow = GetTopRow() + min(2, GetVisibleRowCount());
  617. m_selectedBlock.dtBegin = CXTPCalendarUtils::UpdateTime(dtFirstDay, GetCellTime(nSelRow));
  618. m_selectedBlock.dtEnd = m_selectedBlock.dtBegin + GetCellDuration();
  619. m_selectedBlock.bAllDayEvent = FALSE;
  620. m_selectedBlock.nGroupIndex = 0;
  622. bSelChanged = TRUE;
  623. }
  625. COleDateTime dtSelBeginDay = CXTPCalendarUtils::ResetTime(m_selectedBlock.dtBegin);
  626. COleDateTime dtSelEndDay = CXTPCalendarUtils::ResetTime(m_selectedBlock.dtEnd-COleDateTimeSpan(0, 0, 0, 1));
  628. // compare with the first day
  629. if (dtSelBeginDay < dtFirstDay)
  630. {
  631. m_selectedBlock.dtBegin = CXTPCalendarUtils::UpdateDate(m_selectedBlock.dtBegin, dtFirstDay);
  632. bSelChanged = TRUE;
  633. }
  634. if (dtSelEndDay < dtFirstDay)
  635. {
  636. m_selectedBlock.dtEnd = CXTPCalendarUtils::UpdateDate(m_selectedBlock.dtEnd, dtFirstDay);
  637. bSelChanged = TRUE;
  638. }
  639. // compare with the last day
  640. if (dtSelEndDay > dtLastDay)
  641. {
  642. m_selectedBlock.dtEnd = CXTPCalendarUtils::UpdateDate(m_selectedBlock.dtEnd, dtLastDay);
  643. bSelChanged = TRUE;
  644. }
  645. if (dtSelBeginDay > dtLastDay)
  646. {
  647. m_selectedBlock.dtBegin = CXTPCalendarUtils::UpdateDate(m_selectedBlock.dtBegin, dtLastDay);
  648. bSelChanged = TRUE;
  649. }
  651. if (bSelChanged)
  652. {
  653. CSelectionChangedContext selChanged(this, xtpCalendarSelectionDays);
  654. }
  655. }
  656. //---------------------------------------------------------------------------
  657. if (bCallPostAdjustLayout)
  658. {
  659. OnPostAdjustLayout();
  660. }
  661. }
  663. /*
  664. AdjustLayout2
  665. <Pre-Theme Adjust Layout step>
  666. Theme->AdjustLayout
  667.    <Adjust Layout for theme step>
  668. <- <call AdjustLayout2 for children>
  670. <After-Theme Adjust Layout step>
  672. OnPostAdjustLayout2
  673. <Pre-Theme Post Adjust Layout step>
  674. Theme->OnPostAdjustLayout
  676. <After-Theme Post Adjust Layout step>
  677. */
  679. void CXTPCalendarDayView::AdjustLayout2(CDC* pDC, const CRect& rcView, BOOL bCallPostAdjustLayout)
  680. {
  681. if (!pDC || !GetTheme())
  682. {
  683. ASSERT(FALSE);
  684. return;
  685. }
  686. TBase::AdjustLayout2(pDC, rcView, bCallPostAdjustLayout);
  688. //*** Pre-Theme Adjust Layout step
  689. XTP_SAFE_CALL1(m_pTimeScaleHeader, SetCaption(GetScaleText()) );
  690. XTP_SAFE_CALL1(m_pTimeScaleHeader2, SetCaption(GetScale2Text()) );
  691. XTP_SAFE_CALL1(m_pTimeScaleHeader2, SetVisible(IsScale2Visible()) );
  693. if (IsScale2Visible())
  694. {
  695. AdjustScale2TimeZone();
  696. }
  698. COleDateTimeSpan spDay(1, 0, 0, 0);
  700. double dRows = spDay / max((double)m_pTimeScaleHeader->GetScaleInterval(), XTP_HALF_SECOND * 2);
  701. m_LayoutX.m_nRowCount = (int)(dRows + XTP_HALF_SECOND); // to prevent loosing 1 :  (int)(47.99999999999) = 47; // need 48 !
  703. m_LayoutX.m_nAllDayEventsCountMax = max(1, GetAllDayEventsMaxCount());
  705. if (m_eDraggingMode == xtpCalendaDragModeResizeBegin || m_eDraggingMode == xtpCalendaDragModeResizeEnd
  706. || _IsDragModeCopyMove(m_eDraggingMode))
  707. {
  708. m_LayoutX.m_nAllDayEventsCountMax = max(m_LayoutX.m_nAllDayEventsCountMax, m_nAllDayEventsCountMin_WhenDrag);
  709. m_nAllDayEventsCountMin_WhenDrag = m_LayoutX.m_nAllDayEventsCountMax;
  710. }
  713. //***
  714. GetTheme()->GetDayViewPart()->AdjustLayout(pDC, rcView);
  716. //*** Post-Theme Adjust Layout step
  717. //---------------------------------------------------------------------------
  718. int nDVCount = GetViewDayCount();
  719. if (nDVCount)
  720. {
  721. COleDateTime dtFirstDay = GetViewDayDate(0);
  722. COleDateTime dtLastDay = GetViewDayDate(nDVCount-1);
  723. BOOL bSelChanged = FALSE;
  725. if (m_selectedBlock.dtEnd.GetStatus() != COleDateTime::valid ||
  726. m_selectedBlock.dtBegin.GetStatus() != COleDateTime::valid)
  727. {
  728. int nSelRow = GetTopRow() + min(2, GetVisibleRowCount());
  730. m_selectedBlock.dtBegin = CXTPCalendarUtils::UpdateTime(dtFirstDay, GetCellTime(nSelRow));
  731. m_selectedBlock.dtEnd = m_selectedBlock.dtBegin + GetCellDuration();
  732. m_selectedBlock.bAllDayEvent = FALSE;
  733. m_selectedBlock.nGroupIndex = 0;
  735. bSelChanged = TRUE;
  736. }
  738. COleDateTime dtSelBeginDay = CXTPCalendarUtils::ResetTime(m_selectedBlock.dtBegin);
  739. COleDateTime dtSelEndDay = CXTPCalendarUtils::ResetTime(m_selectedBlock.dtEnd-COleDateTimeSpan(0, 0, 0, 1));
  741. // compare with the first day
  742. if (dtSelBeginDay < dtFirstDay)
  743. {
  744. m_selectedBlock.dtBegin = CXTPCalendarUtils::UpdateDate(m_selectedBlock.dtBegin, dtFirstDay);
  745. bSelChanged = TRUE;
  746. }
  747. if (dtSelEndDay < dtFirstDay)
  748. {
  749. m_selectedBlock.dtEnd = CXTPCalendarUtils::UpdateDate(m_selectedBlock.dtEnd, dtFirstDay);
  750. bSelChanged = TRUE;
  751. }
  752. // compare with the last day
  753. if (dtSelEndDay > dtLastDay)
  754. {
  755. m_selectedBlock.dtEnd = CXTPCalendarUtils::UpdateDate(m_selectedBlock.dtEnd, dtLastDay);
  756. bSelChanged = TRUE;
  757. }
  758. if (dtSelBeginDay > dtLastDay)
  759. {
  760. m_selectedBlock.dtBegin = CXTPCalendarUtils::UpdateDate(m_selectedBlock.dtBegin, dtLastDay);
  761. bSelChanged = TRUE;
  762. }
  764. if (bSelChanged)
  765. {
  766. CSelectionChangedContext selChanged(this, xtpCalendarSelectionDays);
  767. }
  768. }
  769. //---------------------------------------------------------------------------
  770. if (bCallPostAdjustLayout)
  771. {
  772. OnPostAdjustLayout();
  774. GetTheme()->GetDayViewPart()->OnPostAdjustLayout();
  775. }
  776. }
  778. void CXTPCalendarDayView::Draw2(CDC* pDC)
  779. {
  780. if (!GetTheme())
  781. {
  782. ASSERT(FALSE);
  783. return;
  784. }
  786. GetTheme()->GetDayViewPart()->Draw(pDC);
  788. m_dtLastRedrawTime = CXTPCalendarUtils::GetCurrentTime();
  789. }
  791. void CXTPCalendarDayView::OnDraw(CDC* pDC)
  792. {
  793. SCROLLINFO si;
  794. if (!GetScrollBarInfoH(&si) || pDC->IsPrinting())
  795. {
  796. TBase::OnDraw(pDC);
  797. return;
  798. }
  800. //===================================
  801. CRect rcView = GetViewRect();
  803. CDC memDC;
  804. CBitmap bmpCache;
  805. memDC.CreateCompatibleDC(pDC);
  807. VERIFY( bmpCache.CreateCompatibleBitmap(pDC, rcView.Width(), rcView.Height()) );
  809. CXTPBitmapDC autoDCbmp(&memDC, &bmpCache);
  810. memDC.FillSolidRect(rcView, 0xFF);
  812. memDC.SetViewportOrg(m_nScrollOffsetX, 0);
  814. //------------------------------------------------
  815. if (m_pTimeScaleHeader)
  816. m_pTimeScaleHeader->MoveTo(m_nScrollOffsetX);
  818. if (m_pTimeScaleHeader2 && IsScale2Visible())
  819. m_pTimeScaleHeader2->MoveTo(m_nScrollOffsetX);
  821. //************************************************
  822. TBase::OnDraw(&memDC);
  823. //************************************************
  825. //int nTSWidth = _GetTimeScaleWith();
  826. CXTPClientRect rcClient(GetCalendarControl());
  828. pDC->BitBlt(rcClient.left, rcClient.top, rcClient.Width(), rcClient.Height(),
  829. &memDC, 0, 0, SRCCOPY);
  831. }
  833. void CXTPCalendarDayView::Draw(CDC* pDC)
  834. {
  835. pDC->SetBkMode(TRANSPARENT);
  837. // days
  838. int nCount = GetViewDayCount();
  839. for (int i = nCount - 1; i >= 0; i--)
  840. {
  841. XTP_SAFE_CALL1(GetViewDay(i), Draw(pDC));
  842. }
  844. // alternative time scale
  845. if (IsScale2Visible() && m_pTimeScaleHeader2)
  846. m_pTimeScaleHeader2->Draw(pDC);
  848. // regular time scale
  849. XTP_SAFE_CALL1(m_pTimeScaleHeader, Draw(pDC));
  851. m_dtLastRedrawTime = CXTPCalendarUtils::GetCurrentTime();
  852. }
  854. BOOL CXTPCalendarDayView::HitTestEx(CPoint pt, XTP_CALENDAR_HITTESTINFO_DAY_VIEW* pHitTest)
  855. {
  856. if (!pHitTest)
  857. {
  858. ASSERT(FALSE);
  859. return FALSE;
  860. }
  862. pHitTest->pt = pt;
  864. if (m_pTimeScaleHeader2 && m_pTimeScaleHeader2->HitTestDateTime(pHitTest))
  865. {
  866. return TRUE;
  867. }
  869. if (m_pTimeScaleHeader && m_pTimeScaleHeader->HitTestDateTime(pHitTest))
  870. {
  871. return TRUE;
  872. }
  874. //----------------------------------------------------
  875. CXTPCalendarThemeOffice2007* pThemeX = DYNAMIC_DOWNCAST(CXTPCalendarThemeOffice2007, GetTheme());
  877. int nHit = XTP_SAFE_GET2(pThemeX, GetPrevNextEventControllerPartX(), HitTest(&pt), 0);
  879. if (nHit)
  880. {
  881. XTP_CALENDAR_HITTESTINFO_DAY_VIEW emptyData;
  882. *pHitTest = emptyData;
  883. pHitTest->uHitCode = nHit;
  884. return TRUE;
  885. }
  886. //----------------------------------------------------
  888. return TBase::HitTestEx(pt, pHitTest);
  889. }
  891. BOOL CXTPCalendarDayView::IsUseCellAlignedDraggingInTimeArea()
  892. {
  893. if (GetTheme() && GetTheme()->GetDayViewPart())
  894. {
  895. return GetTheme()->GetDayViewPart()->IsUseCellAlignedDraggingInTimeArea();
  896. }
  897. return CXTPCalendarView::IsUseCellAlignedDraggingInTimeArea();
  898. }
  900. void CXTPCalendarDayView::OnStartDragging(CPoint point, XTP_CALENDAR_HITTESTINFO* pHitTest)
  901. {
  902. if (!pHitTest || !m_pControl)
  903. {
  904. ASSERT(FALSE);
  905. return;
  906. }
  908. m_dtDraggingStartPoint = pHitTest->dt;
  909. m_spDraggingStartOffset_Time = 0.;
  911. m_nAllDayEventsCountMin_WhenDrag = max(1, GetAllDayEventsMaxCount());
  913. CXTPCalendarControl::CUpdateContext updateContext(m_pControl, xtpCalendarUpdateRedraw);
  915. TBase::OnStartDragging(point, pHitTest);
  917. if (double(m_spDraggingStartOffset) != 0.0
  918. && IsUseCellAlignedDraggingInTimeArea())
  919. {
  920. // Align to cell begin time
  921. m_spDraggingStartOffset = pHitTest->dt - pHitTest->pViewEvent->GetEvent()->GetStartTime();
  922. int nTmpCell = GetCellNumber((DATE)(double)m_spDraggingStartOffset, FALSE);
  923. m_spDraggingStartOffset = (double)GetCellTime(nTmpCell);
  924. }
  926. m_selectedBlock.dtEnd = m_selectedBlock.dtBegin;
  927. m_selectedBlock.bAllDayEvent = FALSE;
  928. m_selectedBlock.nGroupIndex = pHitTest->nGroup;
  930. CSelectionChangedContext selChanged(this, xtpCalendarSelectionDays);
  931. }
  933. BOOL CXTPCalendarDayView::OnDragging(CPoint point, XTP_CALENDAR_HITTESTINFO* pHitTest)
  934. {
  935. if (!pHitTest)
  936. {
  937. ASSERT(FALSE);
  938. return FALSE;
  939. }
  941. if (!m_ptrDraggingEventNew || m_eDraggingMode == xtpCalendaDragModeEditSubject ||
  942. !GetCalendarControl())
  943. {
  944. return FALSE;
  945. }
  947. TRACE_DRAGGING(_T("OnDragging - [CXTPCalendarDayView] (point.x =%d, point.y =%d) n"),
  948. point.x, point.y);
  950. XTP_CALENDAR_HITTESTINFO hitInfo2 = *pHitTest;
  951. XTP_CALENDAR_HITTESTINFO* pHitTest2 = &hitInfo2;
  953. BOOL bChanged = FALSE;
  955. XTP_CALENDAR_HITTESTINFO_DAY_VIEW hitTestInfo;
  957.  // TODO:
  958. //if (IsOutOfDraggingRect(point, &hitTestInfo))
  959. //{
  960. //  return FALSE;
  961. //}
  963. if (!HitTestEx(point, &hitTestInfo))
  964. {
  965. return FALSE;
  966. }
  968. //========================================================================
  969. BOOL bScrolled = FALSE;
  970. XTPCalendarDayViewScrollDirection scrollDir = GetNeededScrollDirection(point);
  972. if (scrollDir != xtpCalendarDayViewScrollNotNeeded)
  973. {
  974. if (scrollDir == xtpCalendarDayViewScrollUp)
  975. {
  976. TRACE_DRAGGING(_T("OnDragging::ScrollV upn"));
  977. bScrolled = VertEventScroll(TRUE);//scroll up
  978. SetMouseOutOfDragArea(FALSE);
  980. if (bScrolled)
  981. {
  982. if (HitTestEx(point, &hitTestInfo))
  983. {
  984. pHitTest2->dt = hitTestInfo.dt;
  985. }
  986. }
  987. }
  988. else if (scrollDir == xtpCalendarDayViewScrollDown)
  989. {
  990. TRACE_DRAGGING(_T("OnDragging::ScrollV downn"));
  991. bScrolled = VertEventScroll(FALSE);//scroll down
  992. SetMouseOutOfDragArea(FALSE);
  994. if (bScrolled)
  995. {
  996. if (HitTestEx(point, &hitTestInfo))
  997. {
  998. pHitTest2->dt = hitTestInfo.dt;
  999. }
  1000. }
  1001. }
  1002. }
  1004. //  if (IsOutOfDraggingRect(point, &hitTestInfo))
  1005. //  {
  1006. //      TRACE_DRAGGING("OnDragging::OutOfDragArean");
  1007. //          SetMouseOutOfDragArea(TRUE);
  1008. //          StopVertEventScroll();
  1009. //          bScrolled = TRUE;
  1010. //          return TRUE;
  1011. //  }
  1013. // TODO:
  1014. if (IsOutOfClientRect(point, &hitTestInfo))
  1015. {
  1016. TRACE_DRAGGING(_T("OnDragging::OutOfDragArean"));
  1017. SetMouseOutOfDragArea(TRUE);
  1018. StopVertEventScroll();
  1019. bScrolled = TRUE;
  1020. return TRUE;
  1021. }
  1023. if (!bScrolled)
  1024. {
  1025. TRACE_DRAGGING(_T("OnDragging::In DragArean"));
  1026. SetMouseOutOfDragArea(FALSE);
  1027. StopVertEventScroll();
  1028. }
  1030. // check drag on TimeScale:
  1032. TRACE_DRAGGING(_T("OnDragging - [CXTPCalendarDayView] (hour =%d, minute =%d) n"),
  1033. pHitTest->dt.GetHour(), pHitTest->dt.GetMinute());
  1035. if (_IsDragModeCopyMove(m_eDraggingMode) && (
  1036. m_pTimeScaleHeader2 && m_pTimeScaleHeader2->HitTestDateTime(&hitTestInfo) ||
  1037. (m_pTimeScaleHeader && m_pTimeScaleHeader->HitTestDateTime(&hitTestInfo))))
  1038. {
  1039. COleDateTime dtNewTime = pHitTest->dt;
  1040. dtNewTime = COleDateTime(m_dtDraggingStartPoint.GetYear(),
  1041. m_dtDraggingStartPoint.GetMonth(), m_dtDraggingStartPoint.GetDay(),
  1042. dtNewTime.GetHour(), dtNewTime.GetMinute(), dtNewTime.GetSecond());
  1044. m_ptrDraggingEventNew->MoveEvent(dtNewTime);
  1046. return TRUE;
  1047. }
  1049. if (!m_ptrDraggingEventOrig)
  1050. {
  1051. ASSERT(FALSE);
  1052. return FALSE;
  1053. }
  1055. BOOL bAllDayEventArea = 0 != (hitTestInfo.uHitCode & xtpCalendarHitTestDayViewAllDayEvent);
  1057. BOOL bAllDayEventNew_prev = m_ptrDraggingEventNew->IsAllDayEvent();
  1058. BOOL bAllMultiDayEvent = bAllDayEventNew_prev || m_ptrDraggingEventNew->GetDurationMinutes() > 24 * 60;
  1060. BOOL bAllMultiDayEventOrig = m_ptrDraggingEventOrig->IsAllDayEvent();
  1061. bAllMultiDayEventOrig |= m_ptrDraggingEventOrig->GetDurationMinutes() > 24 * 60;
  1063. bChanged = bAllDayEventArea != bAllMultiDayEvent;
  1065. if (bChanged)
  1066. {
  1067. if (!bAllDayEventArea && bAllMultiDayEventOrig && _IsDragModeCopyMove(m_eDraggingMode))
  1068. {
  1069. m_ptrDraggingEventNew->SetDuration(GetCellDuration());
  1070. }
  1071. else if (bAllDayEventArea && !bAllMultiDayEventOrig && _IsDragModeCopyMove(m_eDraggingMode))
  1072. {
  1073. m_ptrDraggingEventNew->SetStartTime(CXTPCalendarUtils::ResetTime(m_ptrDraggingEventOrig->GetStartTime()));
  1074. m_ptrDraggingEventNew->SetEndTime(m_ptrDraggingEventNew->GetStartTime()+COleDateTimeSpan(1, 0, 0, 0));
  1075. }
  1076. else
  1077. {
  1078. m_ptrDraggingEventNew->SetStartTime(m_ptrDraggingEventOrig->GetStartTime());
  1079. m_ptrDraggingEventNew->SetEndTime(m_ptrDraggingEventOrig->GetEndTime());
  1080. }
  1082. if (_IsDragModeCopyMove(m_eDraggingMode))
  1083. {
  1084. if (bAllDayEventArea == bAllMultiDayEventOrig)
  1085. {
  1086. m_spDraggingStartOffset = m_spDraggingStartOffset_Time;
  1087. m_spDraggingStartOffset_Time = 0.;
  1088. }
  1089. else
  1090. {
  1091. m_spDraggingStartOffset_Time = m_spDraggingStartOffset;
  1092. m_spDraggingStartOffset = 0.;
  1093. }
  1095. if (bAllDayEventArea)
  1096. {
  1097. if (GetCalendarControl()->DayView_IsAutoResetBusyFlag())
  1098. {
  1099. if (!bAllDayEventNew_prev &&
  1100. xtpCalendarBusyStatusBusy == m_ptrDraggingEventNew->GetBusyStatus()
  1101. &&
  1102. !(bAllMultiDayEventOrig &&
  1103. xtpCalendarBusyStatusBusy == m_ptrDraggingEventOrig->GetBusyStatus()))
  1104. {
  1105. m_ptrDraggingEventNew->SetBusyStatus(xtpCalendarBusyStatusFree);
  1106. }
  1107. }
  1108. }
  1109. else
  1110. {
  1111. if (GetCalendarControl()->DayView_IsAutoResetBusyFlag())
  1112. {
  1113. if (bAllMultiDayEvent &&
  1114. xtpCalendarBusyStatusFree == m_ptrDraggingEventNew->GetBusyStatus()
  1115. &&
  1116. !(!bAllMultiDayEventOrig &&
  1117. xtpCalendarBusyStatusFree == m_ptrDraggingEventOrig->GetBusyStatus()))
  1118. {
  1119. m_ptrDraggingEventNew->SetBusyStatus(xtpCalendarBusyStatusBusy);
  1120. }
  1121. }
  1122. }
  1123. }
  1124. }
  1126. //========================================================================
  1127. if (m_eDraggingMode == xtpCalendaDragModeResizeEnd)
  1128. {
  1129. if (pHitTest2->bTimePartValid)
  1130. {
  1131. pHitTest2->dt += GetCellDuration();
  1132. }
  1133. }
  1135. BOOL bChangedBase = TBase::OnDragging(point, pHitTest2);
  1137. //-------------------------------------------------------------------------
  1138. // multi-resources movement
  1140. if (_IsDragModeCopyMove(m_eDraggingMode))
  1141. {
  1142. UINT uScheduleID = XTP_SAFE_GET2(pHitTest2, pViewGroup, GetScheduleID(), 0);
  1143. if (uScheduleID != m_ptrDraggingEventNew->GetScheduleID())
  1144. {
  1145. if (uScheduleID != XTP_CALENDAR_UNKNOWN_SCHEDULE_ID)
  1146. {
  1147. m_ptrDraggingEventNew->SetScheduleID(uScheduleID);
  1148. bChanged = TRUE;
  1149. }
  1150. else if (m_ptrDraggingEventNew->GetScheduleID() != m_ptrDraggingEventOrig->GetScheduleID())
  1151. {
  1152. m_ptrDraggingEventNew->SetScheduleID(m_ptrDraggingEventOrig->GetScheduleID());
  1153. bChanged = TRUE;
  1154. }
  1155. }
  1156. }
  1157. //---
  1158. CXTPCalendarData* pHitData = XTP_SAFE_GET2(pHitTest2, pViewGroup, GetDataProvider(), NULL);
  1159. if (pHitData && pHitData != m_ptrDraggingEventNew->GetDataProvider())
  1160. {
  1161. CXTPCalendarEventPtr ptrHitEventNew = pHitData->CreateNewEvent();
  1162. if (ptrHitEventNew)
  1163. {
  1164. if (m_ptrDraggingEventNew->CloneEventTo(ptrHitEventNew))
  1165. {
  1166. m_ptrDraggingEventNew = ptrHitEventNew;
  1167. bChanged = TRUE;
  1168. }
  1169. }
  1170. }
  1172. //------------------------------------------------------------------------
  1173. //COleDateTimeSpan spDurationNew = m_ptrDraggingEventNew->GetEndTime() -
  1174. //                                  m_ptrDraggingEventNew->GetStartTime();
  1176. //  TRACE(_T("bAllDayEventArea =%d, Orig->IsAllDayEvent =%d, bAllMultiDayEventOrig =%d, New->GetDurationMinutes=%d [%s - %s]n"),
  1177. //      bAllDayEventArea, m_ptrDraggingEventOrig->IsAllDayEvent(),
  1178. //bAllMultiDayEventOrig, (int)spDurationNew.GetTotalMinutes(),
  1179. //m_ptrDraggingEventNew->GetStartTime().Format(),
  1180. //m_ptrDraggingEventNew->GetEndTime().Format());
  1182. BOOL bIsResizing = m_eDraggingMode == xtpCalendaDragModeResizeBegin ||
  1183. m_eDraggingMode == xtpCalendaDragModeResizeEnd;
  1185. BOOL bIsZeroLen = CXTPCalendarUtils::IsEqual(m_ptrDraggingEventNew->GetStartTime(),
  1186. m_ptrDraggingEventNew->GetEndTime());
  1188. if (bAllDayEventArea && (bIsResizing && !bIsZeroLen || !bIsResizing) &&
  1189. (m_ptrDraggingEventOrig->IsAllDayEvent() || !bAllMultiDayEventOrig
  1190.  || m_ptrDraggingEventNew->IsAllDayEvent()))
  1191. {
  1192. m_ptrDraggingEventNew->SetAllDayEvent(TRUE);
  1193. }
  1194. else
  1195. {
  1196. m_ptrDraggingEventNew->SetAllDayEvent(FALSE);
  1197. }
  1198. //------------------------------------------------------------------------
  1200. return bChanged || bChangedBase;
  1201. }
  1203. XTPCalendarDayViewScrollDirection CXTPCalendarDayView::GetNeededScrollDirection(CPoint pnt)
  1204. {
  1205. static const int nVScrollZone = 20;
  1206. CRect rcCtrl;
  1208. if (!m_pControl)
  1209. {
  1210. return xtpCalendarDayViewScrollNotNeeded;
  1211. }
  1213. m_pControl->GetWindowRect(rcCtrl);
  1214. CRect rcAllDayEvents = GetAllDayEventsRectangle();
  1215. SCROLLINFO si;
  1216. GetScrollBarInfoV(&si);
  1218. int nCurPos = si.nPos;
  1219. int nLimit = m_pControl->GetScrollLimit(SB_VERT);
  1221. BOOL bWidtdhOK = (rcAllDayEvents.left <= pnt.x &&
  1222. rcAllDayEvents.right >= pnt.x);
  1224. if (!bWidtdhOK)
  1225. return xtpCalendarDayViewScrollNotNeeded;
  1227. if ((pnt.y >= rcAllDayEvents.bottom) &&
  1228. (pnt.y - rcAllDayEvents.bottom <= nVScrollZone) && nCurPos > 0 &&
  1229. m_ptLBtnDownMousePos.y - pnt.y > 2)
  1230. {
  1231. // Scroll up
  1232. return xtpCalendarDayViewScrollUp;
  1233. }
  1235. if ((pnt.y + 3 < rcCtrl.Height()) &&
  1236. (rcCtrl.Height() - (pnt.y + 3) <= nVScrollZone) && nCurPos < nLimit &&
  1237. pnt.y - m_ptLBtnDownMousePos.y > 2)
  1238. {
  1239. return xtpCalendarDayViewScrollDown;
  1240. }
  1242. return xtpCalendarDayViewScrollNotNeeded;
  1243. }
  1245. BOOL CXTPCalendarDayView::IsOutOfClientRect(CPoint pnt, XTP_CALENDAR_HITTESTINFO_DAY_VIEW* pHitInfo)
  1246. {
  1247. if (!m_pControl)
  1248. {
  1249. return FALSE;
  1250. }
  1252. CRect rcCtrl;
  1253. m_pControl->GetWindowRect(rcCtrl);
  1255. if (m_pTimeScaleHeader2 && m_pTimeScaleHeader2->HitTestDateTime(pHitInfo))
  1256. {
  1257. return FALSE;
  1258. }
  1260. if (m_pTimeScaleHeader && m_pTimeScaleHeader->HitTestDateTime(pHitInfo))
  1261. {
  1262. return FALSE;
  1263. }
  1266. //bottom
  1267. if (pnt.y + 3 >= rcCtrl.Height())
  1268. return TRUE;
  1269. //top
  1270. CRect rcAllDayEvents = GetAllDayEventsRectangle();
  1271. if (pnt.y <= rcAllDayEvents.top)
  1272. return TRUE;
  1274. //left
  1275. if (pnt.x < rcAllDayEvents.left)
  1276. return TRUE;
  1278. //right
  1279. if (pnt.x > rcAllDayEvents.right)
  1280. return TRUE;
  1282. if (pHitInfo->uHitCode & xtpCalendarHitTestDayViewTimeScale)
  1283. return TRUE;
  1285. return FALSE;
  1286. }
  1289. void CXTPCalendarDayView::StopVertEventScroll()
  1290. {
  1291. if (m_dwScrollingEventTimerID)
  1292. {
  1293. KillTimer(m_dwScrollingEventTimerID);
  1294. m_dwScrollingEventTimerID = 0;
  1295. }
  1296. }
  1298. void CXTPCalendarDayView::SetMouseOutOfDragArea(BOOL bOutOfArea)
  1299. {
  1301. BOOL bChanged = m_bMouseOutOfDragArea != bOutOfArea;
  1302. m_bMouseOutOfDragArea = bOutOfArea;
  1304. BOOL bNeedUpd = FALSE;
  1306. if (m_bMouseOutOfDragArea)
  1307. {
  1308. if (m_ptrDraggingEventNew)
  1309. {
  1310. m_ptrDraggingEventNew->MoveEvent(m_dtDraggingStartPoint);
  1311. }
  1312. if (m_pControl && m_pControl->m_mouseMode != xtpCalendarMouseEventDraggingOut)
  1313. {
  1314. m_pControl->m_mouseMode = xtpCalendarMouseEventDraggingOut;
  1315. TRACE_DRAGGING(_T("SetMouseOutOfDragArea OUTn"));
  1316. bNeedUpd = TRUE;
  1317. }
  1318. }
  1321. if (bChanged && !m_bMouseOutOfDragArea)
  1322. {
  1323. TRACE_DRAGGING(_T("SetMouseOutOfDragArea INn"));
  1325. XTPCalendarMouseMode mouseMode = xtpCalendarMouseNothing;
  1326. switch (m_eDraggingMode)
  1327. {
  1328. case xtpCalendaDragModeUnknown:
  1329. case xtpCalendaDragModeEditSubject:
  1330. mouseMode = xtpCalendarMouseNothing;
  1331. break;
  1332. case xtpCalendaDragModeCopy:
  1333. mouseMode = xtpCalendarMouseEventDragCopy;
  1334. break;
  1335. case xtpCalendaDragModeMove:
  1336. mouseMode = xtpCalendarMouseEventDragMove;
  1337. break;
  1338. case xtpCalendaDragModeResizeBegin:
  1339. case xtpCalendaDragModeResizeEnd:
  1340. mouseMode = xtpCalendarMouseEventResizingV;
  1341. break;
  1342. }
  1344. XTP_SAFE_SET1(m_pControl, m_mouseMode, mouseMode);
  1345. bNeedUpd = TRUE;
  1346. }
  1348. if (bNeedUpd && m_pControl)
  1349. m_pControl->UpdateMouseCursor();
  1350. }
  1352. BOOL CXTPCalendarDayView::VertEventScroll(BOOL bUp)
  1353. {
  1354. if (!m_pControl)
  1355. {
  1356. ASSERT(FALSE);
  1357. return FALSE;
  1358. }
  1360. SCROLLINFO si;
  1361. if (!GetScrollBarInfoV(&si))
  1362. {
  1363. return FALSE;
  1364. }
  1366. int nCurPos = si.nPos;
  1367. int nCurPos_raw = si.nPos;
  1368. int nLimit = m_pControl->GetScrollLimit(SB_VERT);
  1371. if (bUp && nCurPos > 0)
  1372. {
  1373. //scroll up
  1374. nCurPos = max(nCurPos - 1, 0);
  1375. nCurPos_raw--;
  1376. m_bScrollingEventUp = TRUE;
  1377. }
  1378. else if (!bUp && nCurPos < nLimit)
  1379. {
  1380. //scroll down
  1381. nCurPos = min(nCurPos + 1, nLimit);
  1382. nCurPos_raw++;
  1383. m_bScrollingEventUp = FALSE;
  1384. }
  1385. else
  1386. {
  1387. //limit is reached
  1388. StopVertEventScroll();
  1389. return FALSE;//not handled
  1390. }
  1393. ScrollV(nCurPos, nCurPos_raw);
  1394. m_pControl->SetScrollPos(SB_VERT, nCurPos, FALSE);
  1395. m_pControl->AdjustScrollBar();
  1397. if (!m_dwScrollingEventTimerID)
  1398. {
  1399. //Start timer
  1400. m_dwScrollingEventTimerID = SetTimer(XTP_SCROLL_TIMER_RESOLUTION_MS);
  1401. DBG_TRACE_TIMER(_T("SET Timer: ID =%d, m_dwScrollingEventTimerID, CXTPCalendarDayView::VertEventScroll() n"), m_dwScrollingEventTimerID);
  1402. }
  1404. return TRUE;
  1405. }
  1407. void CXTPCalendarDayView::OnActivateView(BOOL bActivate, CXTPCalendarView* pActivateView,
  1408. CXTPCalendarView* pInactiveView)
  1409. {
  1410. TBase::OnActivateView(bActivate, pActivateView, pInactiveView);
  1412. if (!bActivate)
  1413. {
  1414. if (m_dwRedrawNowLineTimerID)
  1415. {
  1416. KillTimer(m_dwRedrawNowLineTimerID);
  1417. m_dwRedrawNowLineTimerID = 0;
  1418. //TRACE(_T("DayView: Auto redraw timer was KILLED. n"));
  1419. }
  1421. if (m_dwScrollingEventTimerID)
  1422. {
  1423. KillTimer(m_dwScrollingEventTimerID);
  1424. m_dwScrollingEventTimerID = 0;
  1425. }
  1426. }
  1428. if (bActivate && m_dwRedrawNowLineTimerID == 0)
  1429. {
  1430. m_dwRedrawNowLineTimerID = SetTimer(XTP_REDRAW_TIMER_RESOLUTION_MS);
  1431. DBG_TRACE_TIMER(_T("SET Timer: ID =%d, m_dwRedrawNowLineTimerID, CXTPCalendarDayView::OnActivateView() n"), m_dwRedrawNowLineTimerID);
  1432. //TRACE(_T("DayView: Auto redraw timer was SET. n"));
  1433. }
  1435. }
  1437. BOOL CXTPCalendarDayView::OnTimer(UINT_PTR uTimerID)
  1438. {
  1439. if (uTimerID == m_dwScrollingEventTimerID)
  1440. {
  1441. OnMouseMove(MK_LBUTTON, m_ptLastMousePos);
  1442. return TRUE;
  1443. }
  1444. else if (uTimerID == m_dwRedrawNowLineTimerID)
  1445. {
  1446. COleDateTime dtNow = CXTPCalendarUtils::GetCurrentTime();
  1448. //COleDateTimeSpan spDiff = dtNow - m_dtLastRedrawTime;
  1449. //if ((spDiff.GetTotalSeconds() >= 15 || dtNow.GetSecond()%15 == 0) &&
  1450. //  dtNow.GetSecond() != m_dtLastRedrawTime.GetSecond())
  1452. if (dtNow.GetMinute() != m_dtLastRedrawTime.GetMinute())
  1453. {
  1454. CXTPCalendarControl::CUpdateContext updateContext(m_pControl, xtpCalendarUpdateRedraw);
  1455. //TRACE(_T("DayView: Auto REDRAW (%d:%d:%d). n"), (int)dtNow.GetHour(),
  1456. //  (int)dtNow.GetMinute(), (int)dtNow.GetSecond());
  1457. }
  1458. return TRUE;
  1459. }
  1461. return TBase::OnTimer(uTimerID);
  1462. }
  1465. BOOL CXTPCalendarDayView::OnEndDragging(CPoint point, XTP_CALENDAR_HITTESTINFO* pHitInfo)
  1466. {
  1467. if (!m_pControl || !pHitInfo)
  1468. {
  1469. ASSERT(FALSE);
  1470. return FALSE;
  1471. }
  1473. CRect rcCtrl;
  1474. m_pControl->GetWindowRect(rcCtrl);
  1475. BOOL bReturnBack = point.y + 3 >= rcCtrl.Height();
  1477. if (m_dwScrollingEventTimerID)
  1478. {
  1479. if (bReturnBack)
  1480. {
  1481. pHitInfo->dt = m_dtDraggingStartPoint;
  1482. OnDragging(point, pHitInfo);
  1483. }
  1484. else
  1485. {
  1486. OnDragging(point, pHitInfo);
  1487. }
  1488. }
  1490. StopVertEventScroll();
  1493. m_dtDraggingStartPoint = COleDateTime(0, 0, 0, 0, 0, 0);
  1495. if (_IsDragModeCopyMove(m_eDraggingMode) && m_ptrDraggingEventNew && m_ptrDraggingEventOrig)
  1496. {
  1497. if (!m_ptrDraggingEventNew->IsEqualStartEnd(m_ptrDraggingEventOrig))
  1498. {
  1499. COleDateTime dtS = m_ptrDraggingEventNew->GetStartTime();
  1500. COleDateTime dtE = m_ptrDraggingEventNew->GetEndTime();
  1501. COleDateTime dtS0 = CXTPCalendarUtils::ResetDate(dtS);
  1502. COleDateTime dtE0 = CXTPCalendarUtils::ResetDate(dtE);
  1504. m_selectedBlock.dtBegin = CXTPCalendarUtils::UpdateTime(dtS, GetCellTime(GetCellNumber(dtS0, FALSE)));
  1505. m_selectedBlock.dtEnd = GetCellTime(GetCellNumber(dtE0, dtS0 == dtE0 ? FALSE : TRUE)) + GetCellDuration();
  1506. m_selectedBlock.dtEnd = CXTPCalendarUtils::UpdateTime(dtE, m_selectedBlock.dtEnd);
  1508. if (m_ptrDraggingEventNew->IsAllDayEvent() ||
  1509. m_ptrDraggingEventNew->GetDurationMinutes() > 24 * 60)
  1510. {
  1511. m_selectedBlock.bAllDayEvent = TRUE;
  1512. }
  1513. m_selectedBlock.nGroupIndex = pHitInfo->nGroup;
  1514. CSelectionChangedContext selChanged(this, xtpCalendarSelectionDays);
  1515. }
  1516. }
  1518. m_nAllDayEventsCountMin_WhenDrag = 0;
  1519. {
  1520. CXTPCalendarControl::CUpdateContext updateContext(m_pControl, xtpCalendarUpdateScrollBar);
  1521. }
  1523. return TBase::OnEndDragging(point, pHitInfo);
  1524. }
  1526. BOOL CXTPCalendarDayView::OnLButtonUp(UINT nFlags, CPoint point)
  1527. {
  1528. m_ptLBtnDownMousePos = CPoint(0, 0);
  1530. return TBase::OnLButtonUp(nFlags, point);
  1531. }
  1533. BOOL CXTPCalendarDayView::OnLButtonDown(UINT nFlags, CPoint point)
  1534. {
  1535. CSelectionChangedContext selChanged(this);
  1537. TBase::OnLButtonDown(nFlags, point);
  1540. m_ptLBtnDownMousePos = point;
  1542. if (m_eDraggingMode != xtpCalendaDragModeUnknown)
  1543. {
  1544. return FALSE;
  1545. }
  1547. XTP_CALENDAR_HITTESTINFO_DAY_VIEW hitTestInfo;
  1549. if (HitTestEx(point, &hitTestInfo))
  1550. {
  1551. if (hitTestInfo.dt.GetStatus() != COleDateTime::valid)
  1552. return FALSE;
  1554. ASSERT(hitTestInfo.dt.GetStatus() == COleDateTime::valid);
  1556. BOOL bEvent = (hitTestInfo.uHitCode & xtpCalendarHitTestEvent_Mask) != 0;
  1558. if (bEvent)
  1559. {
  1560. CXTPCalendarControl::CUpdateContext updateContext(m_pControl, xtpCalendarUpdateRedraw);
  1562. m_selectedBlock.dtEnd = m_selectedBlock.dtBegin = hitTestInfo.dt;
  1563. m_dtSelectionStart = hitTestInfo.dt;
  1564. m_selectedBlock.bAllDayEvent = FALSE;
  1565. m_selectedBlock.nGroupIndex = hitTestInfo.nGroup;
  1567. CSelectionChangedContext selChanged1(this, xtpCalendarSelectionDays);
  1568. }
  1569. else
  1570. {
  1571. BOOL bFixBegin = (nFlags & MK_SHIFT);
  1572. BOOL bAllDay = 0 != (hitTestInfo.uHitCode & xtpCalendarHitTestDayViewAllDayEvent);
  1573. COleDateTime dtNewEnd = m_selectedBlock.dtEnd;
  1575. if (hitTestInfo.uHitCode & xtpCalendarHitTestDayViewTimeScale)
  1576. {
  1577. dtNewEnd = CXTPCalendarUtils::UpdateTime(dtNewEnd, hitTestInfo.dt + GetCellDuration());
  1578. hitTestInfo.nGroup = max(0, m_selectedBlock.nGroupIndex);
  1579. }
  1580. else if (hitTestInfo.uHitCode & xtpCalendarHitTestDayViewCell)
  1581. {
  1582. dtNewEnd = hitTestInfo.dt + GetCellDuration();
  1583. }
  1584. else if (bAllDay)
  1585. {
  1586. dtNewEnd = hitTestInfo.dt + COleDateTimeSpan(1, 0, 0, 0);
  1587. }
  1588. else {
  1589. return TRUE;
  1590. }
  1592. ProcessCellSelection(dtNewEnd, bFixBegin, bAllDay, hitTestInfo.nGroup);
  1593. }
  1594. return TRUE;
  1595. }
  1596. return FALSE;
  1597. }
  1599. void CXTPCalendarDayView::OnMouseMove(UINT nFlags, CPoint point)
  1600. {
  1601. CXTPCalendarControl::CUpdateContext updateContext(m_pControl, xtpCalendarUpdateRedrawIfNeed);
  1602. CSelectionChangedContext selChanged(this);
  1604. m_ptLastMousePos = point;
  1606. TBase::OnMouseMove(nFlags, point);
  1608. if (m_eDraggingMode != xtpCalendaDragModeUnknown)
  1609. {
  1610. return;
  1611. }
  1613. // process selection mode
  1614. if ((nFlags & MK_LBUTTON) == 0)
  1615. {
  1616. return;
  1617. }
  1618. else if (!m_bStartedClickInside)
  1619. {
  1620. return;
  1621. }
  1623. XTP_CALENDAR_HITTESTINFO_DAY_VIEW hitTestInfo;
  1624. if (HitTestEx(point, &hitTestInfo))
  1625. {
  1626. COleDateTime dtEnd = m_selectedBlock.dtEnd;
  1627. BOOL bAllDayEvent = m_selectedBlock.bAllDayEvent;
  1630. BOOL bScrolled = FALSE;
  1631. XTPCalendarDayViewScrollDirection direction = GetNeededScrollDirection(point);
  1632. if (direction != xtpCalendarDayViewScrollNotNeeded &&
  1633. hitTestInfo.dt.GetStatus() == COleDateTime::valid)
  1634. {
  1635. if (direction == xtpCalendarDayViewScrollUp)
  1636. {
  1637. bScrolled = VertEventScroll(TRUE);//scroll up
  1638. hitTestInfo.dt -= GetCellDuration();
  1639. }
  1640. else if (direction == xtpCalendarDayViewScrollDown)
  1641. {
  1642. bScrolled = VertEventScroll(FALSE);
  1643. hitTestInfo.dt += GetCellDuration();
  1644. }
  1646. }
  1647. if (!bScrolled)
  1648. {
  1649. StopVertEventScroll();
  1650. }
  1653. //-------------------------------------------------------------------
  1654. // selection processing
  1656. if (hitTestInfo.uHitCode & xtpCalendarHitTestDayViewTimeScale)
  1657. {
  1658. m_selectedBlock.bAllDayEvent = FALSE;
  1659. if (bAllDayEvent)
  1660. {
  1661. m_selectedBlock.dtBegin = m_dtSelectionStart;
  1662. }
  1664. m_selectedBlock.dtEnd = CXTPCalendarUtils::UpdateTime(m_selectedBlock.dtEnd, hitTestInfo.dt);
  1665. if (m_selectedBlock.dtEnd >= m_selectedBlock.dtBegin)
  1666. {
  1667. m_selectedBlock.dtEnd += GetCellDuration();
  1668. }
  1669. }
  1670. else if (hitTestInfo.uHitCode & xtpCalendarHitTestDayViewCell)
  1671. {
  1672. m_selectedBlock.bAllDayEvent = FALSE;
  1673. if (bAllDayEvent)
  1674. {
  1675. m_selectedBlock.dtBegin = m_dtSelectionStart;
  1676. }
  1678. m_selectedBlock.dtEnd = hitTestInfo.dt;
  1679. if (m_selectedBlock.dtEnd >= m_selectedBlock.dtBegin)
  1680. {
  1681. m_selectedBlock.dtEnd += GetCellDuration();
  1682. }
  1683. }
  1684. else if (hitTestInfo.uHitCode & xtpCalendarHitTestDayViewAllDayEvent)
  1685. {
  1686. if (!bAllDayEvent)
  1687. {
  1688. m_dtSelectionStart = m_selectedBlock.dtBegin;
  1689. m_selectedBlock.dtBegin = CXTPCalendarUtils::ResetTime(m_selectedBlock.dtBegin);
  1690. }
  1691. m_selectedBlock.dtEnd = hitTestInfo.dt;
  1692. if (m_selectedBlock.dtEnd >= m_selectedBlock.dtBegin)
  1693. {
  1694. m_selectedBlock.dtEnd += COleDateTimeSpan(1, 0, 0, 0);
  1695. }
  1696. m_selectedBlock.bAllDayEvent = TRUE;
  1697. }
  1699. //---------------------------------------------------------------------------
  1700. if (m_selectedBlock.dtEnd != dtEnd || m_selectedBlock.bAllDayEvent != bAllDayEvent)
  1701. {
  1702. CXTPCalendarControl::CUpdateContext updateContext1(m_pControl, xtpCalendarUpdateRedraw);
  1703. CSelectionChangedContext selChanged1(this, xtpCalendarSelectionDays);
  1704. }
  1705. }
  1706. }
  1708. BOOL CXTPCalendarDayView::GetSelection(COleDateTime* pBegin, COleDateTime* pEnd,
  1709.    BOOL* pbAllDayEvent, int* pnGroupIndex,
  1710.    COleDateTimeSpan* pspSelectionResolution)
  1711. {
  1712. if (!m_selectedBlock.IsValid())
  1713. return FALSE;
  1715. COleDateTime dtBegin = m_selectedBlock.dtBegin, dtEnd = m_selectedBlock.dtEnd;
  1717. BOOL bAllDayEvent = m_selectedBlock.bAllDayEvent;
  1719. if (pbAllDayEvent)
  1720. {
  1721. *pbAllDayEvent = bAllDayEvent;
  1722. }
  1724. if (bAllDayEvent)
  1725. {
  1726. if (dtBegin > dtEnd)
  1727. {
  1728. COleDateTime dt = dtEnd;
  1729. dtEnd = dtBegin + COleDateTimeSpan(1, 0, 0, 0);
  1731. dtBegin = dt;
  1732. }
  1734. dtBegin = CXTPCalendarUtils::ResetTime(dtBegin);
  1735. if (!CXTPCalendarUtils::IsZeroTime(dtEnd))
  1736. {
  1737. dtEnd += COleDateTimeSpan(1, 0, 0, 0);
  1738. }
  1739. dtEnd = CXTPCalendarUtils::ResetTime(dtEnd);
  1741. }
  1742. else
  1743. {
  1744. if (dtBegin >= dtEnd)
  1745. {
  1746. COleDateTime dt = dtEnd;
  1747. dtEnd = dtBegin + GetCellDuration();
  1748. dtBegin = dt;
  1749. }
  1751. bAllDayEvent = CXTPCalendarUtils::IsZeroTime(dtBegin) &&
  1752.    CXTPCalendarUtils::IsZeroTime(dtEnd);
  1753. }
  1755. if (pBegin)
  1756. *pBegin = dtBegin;
  1758. if (pEnd)
  1759. *pEnd = dtEnd;
  1761. if (pnGroupIndex)
  1762. {
  1763. *pnGroupIndex = m_selectedBlock.nGroupIndex;
  1764. }
  1766. if (pspSelectionResolution)
  1767. {
  1768. if (bAllDayEvent)
  1769. {
  1770. *pspSelectionResolution = COleDateTimeSpan(1, 0, 0, 0);
  1771. }
  1772. else
  1773. {
  1774. *pspSelectionResolution = GetCellDuration();
  1775. }
  1776. }
  1778. return TRUE;
  1779. }
  1781. void CXTPCalendarDayView::ShowDay(const COleDateTime& date, BOOL bSelect)
  1782. {
  1783. CXTPCalendarControl::CUpdateContext updateContext(m_pControl);
  1784. ClearDays();
  1785. AddDay(date);
  1787. if (bSelect)
  1788. {
  1789. CXTPCalendarDayViewDay* pDay = m_arDays.GetCount() > 0 ? m_arDays.GetAt(0) : NULL;
  1790. if (pDay)
  1791. SelectDay(pDay);
  1792. }
  1793. }
  1795. void CXTPCalendarDayView::AddDay(const COleDateTime& date)
  1796. {
  1797. CXTPCalendarControl::CViewChangedContext viewChanged(this);
  1799. _AddDay(date);
  1800. }
  1802. void CXTPCalendarDayView::_AddDay(const COleDateTime& date)
  1803. {
  1804. CXTPCalendarControl::CUpdateContext updateContext(m_pControl);
  1805. CXTPCalendarDayViewDay* pDay = new CXTPCalendarDayViewDay(this, date);
  1806. if (pDay)
  1807. {
  1808. m_arDays.Add(pDay);
  1809. pDay->Populate(date);
  1810. }
  1811. }
  1813. void CXTPCalendarDayView::ShowDays(const COleDateTime& dtBegin, const COleDateTime& dtEnd)
  1814. {
  1815. CXTPCalendarControl::CUpdateContext updateContext(m_pControl);
  1817. CXTPCalendarControl::CViewChangedContext viewChanged(this);
  1819. ClearDays();
  1821. COleDateTimeSpan spDay(1, 0, 0, 0);
  1822. COleDateTimeSpan spDaysRange = CXTPCalendarUtils::ResetTime(dtEnd) - CXTPCalendarUtils::ResetTime(dtBegin);
  1824. int nDays = GETTOTAL_DAYS_DTS(spDaysRange) + 1;
  1825. COleDateTime dtDay = CXTPCalendarUtils::ResetTime(dtBegin);
  1827. nDays = max(1, nDays); // to be sure that at leas one day will be added
  1828. for (int i = 0; i < nDays; i++)
  1829. {
  1830. _AddDay(dtDay);
  1831. dtDay += spDay;
  1832. }
  1833. }
  1835. void CXTPCalendarDayView::ShowWorkingDays(const COleDateTime& dtDay)
  1836. {
  1837. if (!m_pControl)
  1838. {
  1839. ASSERT(FALSE);
  1840. return;
  1841. }
  1843. CXTPCalendarControl::CUpdateContext updateContext(m_pControl);
  1844. CXTPCalendarControl::CViewChangedContext viewChanged(this);
  1846. COleDateTime dtWeekDay(dtDay);
  1848. int nFirstWeekDay = m_pControl->GetFirstDayOfWeek();
  1849. // adjust beginning of the week iteration period to the FirstDayOfWeek
  1850. while (dtWeekDay.GetDayOfWeek() != nFirstWeekDay)
  1851. {
  1852. dtWeekDay -= COleDateTimeSpan(1);
  1853. }
  1855. // add all working days during the week to the collection
  1856. ClearDays();
  1857. for (int nWeekDay = 0; nWeekDay < 7; nWeekDay++)
  1858. {
  1859. int nWWMask = m_pControl->GetWorkWeekMask();
  1860. int nDayOfWeek = dtWeekDay.GetDayOfWeek();
  1861. int nDayMask = CXTPCalendarUtils::GetDayOfWeekMask(nDayOfWeek);
  1862. if (nWWMask & nDayMask)
  1863. {
  1864. _AddDay(dtWeekDay);
  1865. }
  1866. dtWeekDay += COleDateTimeSpan(1);
  1867. }
  1869. if (GetViewDayCount() == 0)
  1870. {
  1871. _AddDay(CXTPCalendarUtils::ResetTime(COleDateTime::GetCurrentTime()));
  1872. }
  1873. }
  1875. COleDateTimeSpan CXTPCalendarDayView::GetScaleInterval() const
  1876. {
  1877. int nSI_min = XTP_SAFE_GET2(m_pControl, GetCalendarOptions(), nDayView_ScaleInterval, 30);
  1878. return COleDateTimeSpan(0, 0, nSI_min, 0);
  1879. }
  1881. void CXTPCalendarDayView::SetScaleInterval(const COleDateTimeSpan spScaleInterval)
  1882. {
  1883. BOOL bValidSVal = GETTOTAL_MINUTES_DTS(spScaleInterval) >= 1;
  1884. ASSERT(bValidSVal);
  1886. if (m_pTimeScaleHeader && bValidSVal)
  1887. {
  1888. int nOldScaleInterval = XTP_SAFE_GET2(m_pControl, GetCalendarOptions(), nDayView_ScaleInterval, 30);
  1889. int nScaleInterval = (int)GETTOTAL_MINUTES_DTS(spScaleInterval);
  1891. if (nScaleInterval != nOldScaleInterval)
  1892. {
  1893. XTP_SAFE_SET2(m_pControl, GetCalendarOptions(), nDayView_ScaleInterval, nScaleInterval);
  1895. CXTPCalendarControl::CUpdateContext updateContext(m_pControl, xtpCalendarUpdateAll);
  1897. SendNotification(XTP_NC_CALENDAROPTIONSWASCHANGED, xtpCalendarDayView, 0);
  1898. SendNotification(XTP_NC_CALENDARVIEWTIMESCALEWASCHANGED, 0, 0);
  1899. }
  1900. }
  1901. }
  1903. void CXTPCalendarDayView::SetScaleText(LPCTSTR strText)
  1904. {
  1905. XTP_SAFE_CALL1(m_pTimeScaleHeader, SetCaption(strText));
  1907. XTP_SAFE_SET2(m_pControl, GetCalendarOptions(), strDayView_ScaleLabel, strText);
  1909. SendNotification(XTP_NC_CALENDAROPTIONSWASCHANGED, xtpCalendarDayView, 0);
  1911. SendNotification(XTP_NC_CALENDARVIEWTIMESCALEWASCHANGED, 0, 0);
  1912. }
  1913. CString CXTPCalendarDayView::GetScaleText()
  1914. {
  1915. return XTP_SAFE_GET2(m_pControl, GetCalendarOptions(), strDayView_ScaleLabel, _T(""));
  1916. }
  1918. void CXTPCalendarDayView::SetScale2Text(LPCTSTR strText)
  1919. {
  1920. XTP_SAFE_CALL1(m_pTimeScaleHeader2, SetCaption(strText));
  1922. XTP_SAFE_SET2(m_pControl, GetCalendarOptions(), strDayView_Scale2Label, strText);
  1924. SendNotification(XTP_NC_CALENDAROPTIONSWASCHANGED, xtpCalendarDayView, 0);
  1925. SendNotification(XTP_NC_CALENDARVIEWTIMESCALEWASCHANGED, 0, 0);
  1926. }
  1927. CString CXTPCalendarDayView::GetScale2Text()
  1928. {
  1929. return XTP_SAFE_GET2(m_pControl, GetCalendarOptions(), strDayView_Scale2Label, _T(""));
  1930. }
  1932. void CXTPCalendarDayView::SetScale2TimeZone(const TIME_ZONE_INFORMATION* pTzInfo)
  1933. {
  1934. if (!pTzInfo || !m_pControl || !m_pControl->GetCalendarOptions())
  1935. {
  1936. ASSERT(FALSE);
  1937. return;
  1938. }
  1940. m_pControl->GetCalendarOptions()->tziDayView_Scale2TimeZone = *pTzInfo;
  1942. AdjustScale2TimeZone();
  1944. SendNotification(XTP_NC_CALENDAROPTIONSWASCHANGED, xtpCalendarDayView, 0);
  1945. SendNotification(XTP_NC_CALENDARVIEWTIMESCALEWASCHANGED, 0, 0);
  1946. }
  1948. void CXTPCalendarDayView::AdjustScale2TimeZone()
  1949. {
  1950. TIME_ZONE_INFORMATION tziCurrent;
  1951. ::ZeroMemory(&tziCurrent, sizeof(tziCurrent));
  1953. if (::GetTimeZoneInformation(&tziCurrent) == TIME_ZONE_ID_INVALID)
  1954. {
  1955. ASSERT(FALSE);
  1956. return;
  1957. }
  1958. TIME_ZONE_INFORMATION tziScale2 = GetScale2TimeZone();
  1960. SYSTEMTIME systm00, systmScale1, systmScale2;
  1961. ZeroMemory(&systm00, sizeof(systm00));
  1962. ZeroMemory(&systmScale1, sizeof(systmScale1));
  1963. ZeroMemory(&systmScale2, sizeof(systmScale2));
  1965. ::GetLocalTime(&systm00);
  1966. systm00.wHour = systm00.wMinute = systm00.wSecond = 0;
  1968. if (!CXTPCalendarUtils::SystemTimeToTzSpecificLocalTime(&tziCurrent,
  1969. &systm00, &systmScale1))
  1970. {
  1971. ASSERT(FALSE);
  1972. return;
  1973. }
  1974. if (!CXTPCalendarUtils::SystemTimeToTzSpecificLocalTime(&tziScale2,
  1975. &systm00, &systmScale2))
  1976. {
  1977. ASSERT(FALSE);
  1978. return;
  1979. }
  1981. COleDateTime dtScale1(systmScale1), dtScale2(systmScale2);
  1982. COleDateTimeSpan spScale2Offset = dtScale2 - dtScale1;
  1983. ASSERT((GETTOTAL_SECONDS_DTS(spScale2Offset) % 60) == 0);
  1985. int nTimeShift2_min = GETTOTAL_MINUTES_DTS(spScale2Offset);
  1987. XTP_SAFE_CALL1(m_pTimeScaleHeader2, SetTimeshift(nTimeShift2_min));
  1988. }
  1990. const TIME_ZONE_INFORMATION& CXTPCalendarDayView::GetScale2TimeZone()
  1991. {
  1992. static TIME_ZONE_INFORMATION s_tzEmty = {0};
  1994. return XTP_SAFE_GET2(m_pControl, GetCalendarOptions(), tziDayView_Scale2TimeZone, s_tzEmty);
  1995. }
  1998. void CXTPCalendarDayView::ShowScale2(BOOL bShow)
  1999. {
  2000. if (!m_pTimeScaleHeader2 || !m_pControl)
  2001. {
  2002. ASSERT(FALSE);
  2003. return;
  2004. }
  2006. m_pTimeScaleHeader2->SetVisible(bShow);
  2008. m_pControl->GetCalendarOptions()->bDayView_Scale2Visible = bShow;
  2009. m_pControl->AdjustLayout();
  2011. SendNotification(XTP_NC_CALENDAROPTIONSWASCHANGED, xtpCalendarDayView, 0);
  2012. SendNotification(XTP_NC_CALENDARVIEWTIMESCALEWASCHANGED, 0, 0);
  2013. }
  2014. BOOL CXTPCalendarDayView::IsScale2Visible()
  2015. {
  2016. return XTP_SAFE_GET2(m_pControl, GetCalendarOptions(), bDayView_Scale2Visible, FALSE);
  2017. }
  2019. COleDateTime CXTPCalendarDayView::GetViewDayDate(int nIndex)
  2020. {
  2021. CXTPCalendarDayViewDay* pViewDay = GetViewDay(nIndex);
  2022. ASSERT(pViewDay);
  2023. return pViewDay ? pViewDay->m_dtDate :
  2024. CXTPCalendarUtils::ResetTime(CXTPCalendarUtils::GetCurrentTime());
  2025. }
  2027. void CXTPCalendarDayView::_ScrollDays(int nScrollDaysCount, BOOL bPrev)
  2028. {
  2029. ASSERT(nScrollDaysCount >= 1 && nScrollDaysCount <= 14);
  2030. nScrollDaysCount = min(14, max(1, nScrollDaysCount));
  2032. int nCount = GetViewDayCount();
  2033. if (!nCount)
  2034. {
  2035. ASSERT(FALSE);
  2036. return;
  2037. }
  2039. CXTPCalendarControl::CUpdateContext updateContext(m_pControl);
  2040. CXTPCalendarControl::CViewChangedContext viewChanged(this);
  2042. COleDateTimeSpan spDay(bPrev ? -1 : 1, 0, 0, 0);
  2043. COleDateTime dtNewDay = GetViewDayDate(bPrev ? 0 : nCount-1);
  2045. for (int i = 0; i < nScrollDaysCount; i++)
  2046. {
  2047. dtNewDay += spDay;
  2049. CXTPCalendarDayViewDay* pDay = new CXTPCalendarDayViewDay(this, dtNewDay);
  2050. if (pDay)
  2051. {
  2052. m_arDays.RemoveAt(bPrev ? nCount-1 : 0);
  2053. m_arDays.InsertAt(bPrev ? 0 : nCount-1, pDay);
  2055. pDay->Populate(dtNewDay);
  2056. }
  2057. }
  2058. }
  2060. void CXTPCalendarDayView::ScrollDaysToPrev(int nScrollDaysCount)
  2061. {
  2062. _ScrollDays(nScrollDaysCount, TRUE);
  2063. }
  2065. void CXTPCalendarDayView::ScrollDaysToNext(int nScrollDaysCount)
  2066. {
  2067. _ScrollDays(nScrollDaysCount, FALSE);
  2068. }
  2070. BOOL CXTPCalendarDayView::IsExpandDown()
  2071. {
  2072. int nDays = GetViewDayCount();
  2073. for (int nDay = 0; nDay < nDays; nDay++)
  2074. {
  2075. CXTPCalendarDayViewDay* pDay = GetViewDay(nDay);
  2076. ASSERT(pDay);
  2077. if (!pDay)
  2078. continue;
  2079. int nGroupsCount = pDay->GetViewGroupsCount();
  2080. for (int i = 0; i < nGroupsCount; i++)
  2081. {
  2082. if (pDay->GetViewGroup(i) && pDay->GetViewGroup(i)->IsExpandDown())
  2083. return TRUE;
  2084. }
  2085. }
  2086. return FALSE;
  2087. }
  2089. BOOL CXTPCalendarDayView::IsExpandUp()
  2090. {
  2091. int nDays = GetViewDayCount();
  2092. for (int nDay = 0; nDay < nDays; nDay++)
  2093. {
  2094. CXTPCalendarDayViewDay* pDay = GetViewDay(nDay);
  2095. ASSERT(pDay);
  2096. if (!pDay)
  2097. continue;
  2098. int nGroupsCount = pDay->GetViewGroupsCount();
  2099. for (int i = 0; i < nGroupsCount; i++)
  2100. {
  2101. if (pDay->GetViewGroup(i) && pDay->GetViewGroup(i)->IsExpandUp())
  2102. return TRUE;
  2103. }
  2104. }
  2105. return FALSE;
  2106. }
  2108. CXTPCalendarDayViewDay* CXTPCalendarDayView::GetDay(COleDateTime dtDay)
  2109. {
  2110. dtDay = CXTPCalendarUtils::ResetTime(dtDay);
  2112. int nDays = GetViewDayCount();
  2113. for (int i = 0; i < nDays; i++)
  2114. {
  2115. COleDateTime dtDay_I = GetViewDayDate(i);
  2117. if (CXTPCalendarUtils::IsEqual(dtDay, dtDay_I))
  2118. {
  2119. return GetViewDay(i);
  2120. }
  2121. }
  2122. return NULL;
  2123. }
  2125. void CXTPCalendarDayView::OnKeyDown(UINT nChar, UINT nRepCnt, UINT nFlags)
  2126. {
  2127. CSelectionChangedContext selChanged(this);
  2129. TBase::OnKeyDown(nChar, nRepCnt, nFlags);
  2131. if (nChar == VK_LEFT || nChar == VK_RIGHT || nChar == VK_UP || nChar == VK_DOWN ||
  2132. nChar == VK_PRIOR || nChar == VK_NEXT)
  2133. {
  2134. CXTPCalendarControl::CUpdateContext updateContext(m_pControl, xtpCalendarUpdateRedraw);
  2136. UnselectAllEvents();
  2138. BOOL bVKShift = !!(GetKeyState(VK_SHIFT) & 0x8000);
  2139. COleDateTimeSpan spCell = GetCellDuration();
  2140. COleDateTimeSpan spDay(1, 0, 0, 0);
  2141. COleDateTime dtNewSelEnd = m_selectedBlock.dtEnd;
  2143. BOOL bEndIsEnd = m_selectedBlock.dtEnd > m_selectedBlock.dtBegin || !bVKShift;
  2144. int nSelCell = GetCellNumber(CXTPCalendarUtils::ResetDate(m_selectedBlock.dtEnd -
  2145. COleDateTimeSpan(0, 0, 0, bEndIsEnd ? 1 : 0)), bEndIsEnd);
  2147. CXTPDrawHelpers::KeyToLayout(m_pControl, nChar);
  2149. int nDVCount = GetViewDayCount();
  2150. COleDateTime dtFirstDay = GetViewDayDate(0);
  2151. COleDateTime dtLastDay = GetViewDayDate(nDVCount-1);
  2153. if (nChar == VK_LEFT)
  2154. {
  2155. if (!m_bScrollH_Disabled || CXTPCalendarUtils::ResetTime(dtNewSelEnd) > dtFirstDay)
  2156. {
  2157. if (!bVKShift && m_selectedBlock.nGroupIndex > 0)
  2158. {
  2159. m_selectedBlock.nGroupIndex--;
  2160. }
  2161. else
  2162. {
  2163. dtNewSelEnd -= spDay;
  2165. CXTPCalendarDayViewDay* pDay = GetDay(dtNewSelEnd);
  2166. if (!bVKShift && pDay)
  2167. {
  2168. m_selectedBlock.nGroupIndex = pDay->GetViewGroupsCount() - 1;
  2169. }
  2170. }
  2171. }
  2172. }
  2173. else
  2174. if (nChar == VK_RIGHT)
  2175. {
  2176. if (!m_bScrollH_Disabled || CXTPCalendarUtils::ResetTime(dtNewSelEnd) < dtLastDay)
  2177. {
  2178. CXTPCalendarDayViewDay* pDay = GetDay(dtNewSelEnd);
  2179. if (!bVKShift && pDay && m_selectedBlock.nGroupIndex < pDay->GetViewGroupsCount() - 1)
  2180. {
  2181. m_selectedBlock.nGroupIndex++;
  2182. }
  2183. else
  2184. {
  2185. dtNewSelEnd += spDay;
  2186. m_selectedBlock.nGroupIndex = 0;
  2187. }
  2188. }
  2189. }
  2190. else
  2191. if (nChar == VK_UP)
  2192. {
  2193. BOOL bRange = !m_bScrollV_Disabled || nSelCell > m_LayoutX.m_nTopRow;
  2195. if (nSelCell > 0 && bRange)
  2196. {
  2197. dtNewSelEnd = CXTPCalendarUtils::UpdateTime(dtNewSelEnd, GetCellTime(nSelCell));
  2198. }
  2199. if (m_selectedBlock.bAllDayEvent)
  2200. {
  2201. m_selectedBlock.bAllDayEvent = FALSE;
  2202. dtNewSelEnd -= spDay;
  2203. }
  2204. }
  2205. else
  2206. if (nChar == VK_DOWN)
  2207. {
  2208. BOOL bRange = !m_bScrollV_Disabled || nSelCell < m_LayoutX.m_nTopRow + m_LayoutX.m_nVisibleRowCount - 1;
  2209. if (nSelCell + 1 < GetRowCount() && bRange)
  2210. {
  2211. dtNewSelEnd = CXTPCalendarUtils::UpdateTime(dtNewSelEnd, GetCellTime(nSelCell+1)) + spCell;
  2212. if (nSelCell == GetRowCount()-2)
  2213. {
  2214. dtNewSelEnd -= COleDateTimeSpan(0, 0, 0, 1);
  2215. }
  2216. }
  2217. }
  2218. else
  2219. if (nChar == VK_PRIOR)
  2220. {
  2221. if (!m_bScrollV_Disabled)
  2222. {
  2223. nSelCell = max(1, nSelCell - m_LayoutX.m_nVisibleRowCount + 1);
  2224. m_LayoutX.m_nTopRow = max(0, m_LayoutX.m_nTopRow - m_LayoutX.m_nVisibleRowCount);
  2225. dtNewSelEnd = CXTPCalendarUtils::UpdateTime(dtNewSelEnd, GetCellTime(nSelCell));
  2227. CXTPCalendarControl::CUpdateContext updateContext1(m_pControl, xtpCalendarUpdateScrollBar);
  2228. }
  2229. }
  2230. else
  2231. if (nChar == VK_NEXT)
  2232. {
  2233. if (!m_bScrollV_Disabled)
  2234. {
  2235. nSelCell = min(max(0, GetRowCount()-1), nSelCell + m_LayoutX.m_nVisibleRowCount);
  2236. m_LayoutX.m_nTopRow += m_LayoutX.m_nVisibleRowCount;
  2237. dtNewSelEnd = CXTPCalendarUtils::UpdateTime(dtNewSelEnd, GetCellTime(nSelCell)) + spCell;
  2238. if (nSelCell == GetRowCount()-1)
  2239. {
  2240. dtNewSelEnd -= COleDateTimeSpan(0, 0, 0, 1);
  2241. }
  2243. CXTPCalendarControl::CUpdateContext updateContext1(m_pControl, xtpCalendarUpdateScrollBar);
  2244. }
  2245. }
  2247. ProcessCellSelection(dtNewSelEnd, bVKShift, m_selectedBlock.bAllDayEvent,
  2248.  m_selectedBlock.nGroupIndex);
  2249. }
  2250. }
  2252. void CXTPCalendarDayView::ProcessCellSelection(COleDateTime dtNewSelEnd,
  2253. BOOL bFixSelBegin, BOOL bAllDayEventSel, int nGroupIndex)
  2254. {
  2255. int nCount = GetViewDayCount();
  2256. if (!nCount)
  2257. {
  2258. ASSERT(FALSE);
  2259. return;
  2260. }
  2261. CXTPCalendarControl::CUpdateContext updateContext(m_pControl, xtpCalendarUpdateRedraw);
  2263. COleDateTimeSpan spDay(1, 0, 0, 0);
  2264. COleDateTimeSpan spCell = GetCellDuration();
  2265. COleDateTimeSpan spSelStep = bAllDayEventSel ? spDay : spCell;
  2267. COleDateTime dtFirstDay = GetViewDayDate(0);
  2269. COleDateTime dtSelBegin_prev = m_selectedBlock.dtBegin;
  2270. COleDateTime dtSelEnd_prev = m_selectedBlock.dtEnd;
  2272. if (CXTPCalendarUtils::IsEqual(m_selectedBlock.dtEnd, m_selectedBlock.dtBegin))
  2273. {
  2274. int nSelRow = GetTopRow() + min(2, GetVisibleRowCount());
  2275. m_selectedBlock.dtBegin = CXTPCalendarUtils::UpdateTime(dtFirstDay, GetCellTime(nSelRow));
  2276. m_dtSelectionStart = m_selectedBlock.dtBegin;
  2278. m_selectedBlock.dtEnd = m_selectedBlock.dtBegin + spCell;
  2279. }
  2281. m_selectedBlock.dtEnd = dtNewSelEnd;
  2283. if (!bFixSelBegin)
  2284. {
  2285. m_selectedBlock.dtBegin = m_selectedBlock.dtEnd - spSelStep;
  2286. m_dtSelectionStart = m_selectedBlock.dtBegin;
  2287. }
  2288. else
  2289. if (CXTPCalendarUtils::IsEqual(m_selectedBlock.dtEnd, m_selectedBlock.dtBegin) ||
  2290. (!bAllDayEventSel && m_selectedBlock.dtEnd < m_selectedBlock.dtBegin &&
  2291.  dtSelEnd_prev > dtSelBegin_prev)
  2292.    )
  2293. {
  2294. m_selectedBlock.dtEnd -= spSelStep;
  2295. }
  2297. m_selectedBlock.bAllDayEvent = bAllDayEventSel;
  2298. m_selectedBlock.nGroupIndex = nGroupIndex;
  2300. //===========================================================================
  2301. int nDVCount = GetViewDayCount();
  2302. COleDateTime dtLastDay = GetViewDayDate(nDVCount-1);
  2303. COleDateTime& rdtSel1 = m_selectedBlock.dtEnd < m_selectedBlock.dtBegin ?
  2304. m_selectedBlock.dtEnd : m_selectedBlock.dtBegin;
  2305. COleDateTime& rdtSel2 = m_selectedBlock.dtEnd > m_selectedBlock.dtBegin ?
  2306. m_selectedBlock.dtEnd : m_selectedBlock.dtBegin;
  2308. COleDateTime dtSelDay1 = CXTPCalendarUtils::ResetTime(rdtSel1);
  2309. COleDateTime dtSelDay2 = CXTPCalendarUtils::ResetTime(rdtSel2-COleDateTimeSpan(0, 0, 0, 1));
  2311. //---------------------------------------------------------------------------
  2312. if (!m_bScrollH_Disabled)
  2313. {
  2314. if (dtSelDay1 < dtFirstDay)
  2315. {
  2316. ScrollDaysToPrev();
  2317. }
  2318. else if (dtSelDay2 > dtLastDay)
  2319. {
  2320. ScrollDaysToNext();
  2321. }
  2322. }
  2324. //---------------------------------------------------------------------------
  2325. // update variables after scrolling
  2326. nDVCount = GetViewDayCount();
  2327. dtFirstDay = GetViewDayDate(0);
  2328. dtLastDay = GetViewDayDate(nDVCount-1);
  2330. if (dtSelDay1 < dtFirstDay || (!bFixSelBegin && dtSelDay2 >= dtLastDay))
  2331. {
  2332. if (bFixSelBegin)
  2333. {
  2334. rdtSel1 = CXTPCalendarUtils::UpdateTime(dtFirstDay, rdtSel1);
  2335. rdtSel2 = rdtSel1 + spSelStep;
  2336. }
  2337. }
  2338. //---------------------------------------------------------------------------
  2339. if (dtSelDay2 > dtLastDay || (!bFixSelBegin && dtSelDay1 <= dtFirstDay))
  2340. {
  2341. rdtSel2 = rdtSel1 + spSelStep;
  2342. }
  2344. //---------------------------------------------------------------------------
  2345. BOOL bEndIsEnd = m_selectedBlock.dtEnd > m_selectedBlock.dtBegin;
  2346. int nSelEndCell = GetCellNumber(CXTPCalendarUtils::ResetDate(m_selectedBlock.dtEnd -
  2347. COleDateTimeSpan(0, 0, 0, bEndIsEnd ? 1 : 0)), bEndIsEnd);
  2349. if (nSelEndCell < m_LayoutX.m_nTopRow && !bAllDayEventSel)
  2350. {
  2351. if (!m_bScrollV_Disabled)
  2352. {
  2353. m_LayoutX.m_nTopRow = min(max(0, nSelEndCell), max(0, GetRowCount()-1));
  2355. CXTPCalendarControl::CUpdateContext updateContext1(m_pControl, xtpCalendarUpdateScrollBar);
  2356. }
  2357. }
  2358. else if (nSelEndCell >= m_LayoutX.m_nTopRow + m_LayoutX.m_nVisibleRowCount && !bAllDayEventSel)
  2359. {
  2360. if (!m_bScrollV_Disabled)
  2361. {
  2362. m_LayoutX.m_nTopRow = nSelEndCell - m_LayoutX.m_nVisibleRowCount + 1;
  2363. m_LayoutX.m_nTopRow = min(max(0, m_LayoutX.m_nTopRow), max(0, GetRowCount() - 1));
  2365. CXTPCalendarControl::CUpdateContext updateContext1(m_pControl, xtpCalendarUpdateScrollBar);
  2366. }
  2367. }
  2369. if (_EnsureVisibleSelectionH())
  2370. {
  2371. GetCalendarControl()->AdjustLayout();
  2372. CXTPCalendarControl::CUpdateContext updateContext1(m_pControl, xtpCalendarUpdateScrollBar);
  2373. }
  2375. CSelectionChangedContext selChanged(this, xtpCalendarSelectionDays);
  2376. }
  2378. BOOL CXTPCalendarDayView::_EnsureVisibleSelectionH()
  2379. {
  2380. if (!m_selectedBlock.IsValid())
  2381. return FALSE;
  2383. CXTPCalendarViewDay* pVDay = _GetViewDay(CXTPCalendarUtils::ResetTime(m_selectedBlock.dtEnd));
  2384. ASSERT(pVDay);
  2386. if (!pVDay)
  2387. return FALSE;
  2389. CRect rcGroup = pVDay->GetDayRect();
  2390. {
  2391. CXTPCalendarViewGroup* pVGroup = pVDay->GetViewGroup_(m_selectedBlock.nGroupIndex);
  2392. ASSERT(pVGroup);
  2393. if (pVGroup)
  2394. rcGroup = pVGroup->GetRect();
  2395. }
  2397. CRect rcVisible = _GetScrollRectClient();
  2399. int nNewScrollPos = m_nScrollOffsetX;
  2401. if (rcGroup.left < rcVisible.left)
  2402. {
  2403. nNewScrollPos -= rcVisible.left - rcGroup.left;
  2404. if (nNewScrollPos <= 2) nNewScrollPos = 0;
  2405. }
  2406. else if (rcGroup.right > rcVisible.right)
  2407. {
  2408. nNewScrollPos += rcGroup.right - rcVisible.right + 1;
  2409. }
  2411. if (nNewScrollPos != m_nScrollOffsetX)
  2412. {
  2413. ScrollH(nNewScrollPos, nNewScrollPos);
  2414. return TRUE;
  2415. }
  2417. return FALSE;
  2418. }
  2420. BOOL CXTPCalendarDayView::EnsureVisibleH(CXTPCalendarViewGroup* pViewGroup)
  2421. {
  2422. ASSERT(pViewGroup);
  2423. if (!pViewGroup)
  2424. return FALSE;
  2426. SCROLLINFO si;
  2427. if (!GetScrollBarInfoH(&si))
  2428. return FALSE;
  2430. CRect rcVisible = _GetScrollRectClient();
  2431. CRect rcGroup = pViewGroup->GetRect();
  2433. int nNewScrollPos = m_nScrollOffsetX;
  2435. if (rcGroup.left < rcVisible.left)
  2436. {
  2437. nNewScrollPos -= rcVisible.left - rcGroup.left;
  2438. }
  2439. else if (rcGroup.right > rcVisible.right)
  2440. {
  2441. nNewScrollPos += rcGroup.right - rcVisible.right + 1;
  2442. }
  2444. if (nNewScrollPos != m_nScrollOffsetX)
  2445. {
  2446. ScrollH(nNewScrollPos, nNewScrollPos);
  2448. GetCalendarControl()->AdjustLayout();
  2449. CXTPCalendarControl::CUpdateContext updateContext(m_pControl, xtpCalendarUpdateScrollBar);
  2451. return TRUE;
  2452. }
  2454. return FALSE;
  2455. }
  2457. BOOL CXTPCalendarDayView::_EnsureVisibleH(CXTPCalendarViewEvent* pViewEvent)
  2458. {
  2459. ASSERT(pViewEvent);
  2461. CXTPCalendarViewGroup* pVGroup = pViewEvent ? pViewEvent->GetViewGroup_() : NULL;
  2462. ASSERT(pVGroup);
  2464. if (!pVGroup)
  2465. return FALSE;
  2467. SCROLLINFO si;
  2468. if (!GetScrollBarInfoH(&si))
  2469. return FALSE;
  2471. CRect rcVisible = _GetScrollRectClient();
  2473. CRect rcObj = pViewEvent->GetEventRect();
  2474. CRect rcGroup = pVGroup->GetRect();
  2476. if (pViewEvent->IsMultidayEvent() && (pViewEvent->GetMultiDayEventFlags() & xtpCalendarMultiDayMaster))
  2477. {
  2478. rcObj.left = max(rcObj.left, rcVisible.left);
  2479. rcObj.right = min(rcObj.right, rcVisible.right);
  2481. rcGroup.right = rcGroup.left + rcVisible.Width();
  2482. }
  2484. int nNewScrollPos = m_nScrollOffsetX;
  2486. if (rcObj.left < rcVisible.left)
  2487. {
  2488. nNewScrollPos -= rcVisible.left - rcGroup.left;
  2489. }
  2490. else if (rcObj.right > rcVisible.right)
  2491. {
  2492. nNewScrollPos += rcGroup.right - rcVisible.right + 1;
  2493. }
  2495. if (nNewScrollPos != m_nScrollOffsetX)
  2496. {
  2497. ScrollH(nNewScrollPos, nNewScrollPos);
  2498. return TRUE;
  2499. }
  2501. return FALSE;
  2502. }
  2504. BOOL CXTPCalendarDayView::_EnsureVisibleV(CXTPCalendarViewEvent* pViewEvent)
  2505. {
  2506. if (!pViewEvent || !pViewEvent->GetEvent() || !GetCalendarControl() ||
  2507. !XTP_SAFE_GET2(pViewEvent, GetViewGroup_(), GetViewDay_(), NULL) )
  2508. {
  2509. ASSERT(FALSE);
  2510. return FALSE;
  2511. }
  2513. //---------------------------------------------------------------------------
  2514. if (pViewEvent->IsMultidayEvent())
  2515. {
  2516. //return pViewEvent->IsVisible();
  2517. return FALSE;
  2518. }
  2520. //---------------------------------------------------------------------------
  2521. COleDateTime dtDay = XTP_SAFE_GET3(pViewEvent, GetViewGroup_(), GetViewDay_(), GetDayDate(), (DATE)0);
  2522. dtDay = CXTPCalendarUtils::ResetTime(dtDay);
  2524. COleDateTime dtStart = pViewEvent->GetEvent()->GetStartTime();
  2525. COleDateTime dtEnd = pViewEvent->GetEvent()->GetEndTime();
  2527. COleDateTime stSTime = CXTPCalendarUtils::ResetDate(dtStart);
  2528. COleDateTime stETime = CXTPCalendarUtils::ResetDate(dtEnd);
  2530. if (CXTPCalendarUtils::IsZeroTime(stETime))
  2531. stETime = CXTPCalendarUtils::SetTime_235959(stETime);
  2533. int nSCell = 0;
  2534. int nECell = max(0, GetRowCount() - 1);
  2536. if (CXTPCalendarUtils::ResetTime(dtStart) == dtDay)
  2537. nSCell =  GetCellNumber(stSTime, FALSE);
  2539. if (CXTPCalendarUtils::ResetTime(dtEnd) == dtDay)
  2540. nECell = GetCellNumber(stETime, TRUE);
  2542. if (nSCell < m_LayoutX.m_nTopRow)
  2543. {
  2544. m_LayoutX.m_nTopRow = min(max(0, nSCell-1), max(0, GetRowCount()-1));
  2546. return TRUE;
  2547. }
  2548. else if (nECell >= m_LayoutX.m_nTopRow + m_LayoutX.m_nVisibleRowCount)
  2549. {
  2550. int nTopRowPrev = m_LayoutX.m_nTopRow;
  2552. m_LayoutX.m_nTopRow = nECell - m_LayoutX.m_nVisibleRowCount + 1;
  2553. m_LayoutX.m_nTopRow = min(max(0, m_LayoutX.m_nTopRow), max(0, GetRowCount()-1));
  2554. m_LayoutX.m_nTopRow = min(max(0, nSCell-1), m_LayoutX.m_nTopRow);
  2556. if (nTopRowPrev != m_LayoutX.m_nTopRow)
  2557. {
  2558. return TRUE;
  2559. }
  2560. }
  2562. return FALSE;
  2563. }
  2565. BOOL CXTPCalendarDayView::EnsureVisible(CXTPCalendarViewEvent* pViewEvent)
  2566. {
  2567. ASSERT(pViewEvent);
  2568. if (!pViewEvent)
  2569. return FALSE;
  2571. BOOL bChanged1 = _EnsureVisibleH(pViewEvent);
  2572. BOOL bChanged2 = _EnsureVisibleV(pViewEvent);
  2574. if (bChanged1 || bChanged2)
  2575. {
  2576. GetCalendarControl()->AdjustLayout();
  2577. CXTPCalendarControl::CUpdateContext updateContext(m_pControl, xtpCalendarUpdateScrollBar);
  2578. }
  2580. ASSERT(pViewEvent->IsVisible());
  2582. return TRUE;
  2583. }
  2585. BOOL CXTPCalendarDayView::EnsureVisibleH(CXTPCalendarViewEvent* pViewEvent)
  2586. {
  2587. ASSERT(pViewEvent);
  2588. if (!pViewEvent)
  2589. return FALSE;
  2591. BOOL bChanged1 = _EnsureVisibleH(pViewEvent);
  2593. if (bChanged1)
  2594. {
  2595. GetCalendarControl()->AdjustLayout();
  2596. CXTPCalendarControl::CUpdateContext updateContext(m_pControl, xtpCalendarUpdateScrollBar);
  2597. }
  2599. ASSERT(pViewEvent->IsVisible());
  2601. return TRUE;
  2602. }
  2605. CXTPCalendarViewEvent* CXTPCalendarDayView::FindEventToEditByTAB(COleDateTime dtMinStart,
  2606. BOOL bReverse, CXTPCalendarEvent* pAfterEvent)
  2607. {
  2608. CXTPCalendarViewEvent* pViewEvent = TBase::FindEventToEditByTAB(dtMinStart, bReverse, pAfterEvent);
  2609. if (pViewEvent)
  2610. {
  2611. if (EnsureVisible(pViewEvent))
  2612. {
  2613. return pViewEvent;
  2614. }
  2615. }
  2616. return NULL;
  2617. }
  2619. COleDateTime CXTPCalendarDayView::GetNextTimeEditByTAB()
  2620. {
  2621. COleDateTime dtSel1 = min(m_selectedBlock.dtBegin, m_selectedBlock.dtEnd);
  2622. COleDateTime dtSel2 = max(m_selectedBlock.dtBegin, m_selectedBlock.dtEnd);
  2623. COleDateTime dtSel1Day = CXTPCalendarUtils::ResetTime(dtSel1);
  2624. COleDateTime dtSel2Day = CXTPCalendarUtils::ResetTime(dtSel2);
  2626. int nDVCount = GetViewDayCount();
  2627. COleDateTime dtFirstDay = GetViewDayDate(0);
  2628. COleDateTime dtLastDay = GetViewDayDate(nDVCount-1);
  2630. if (dtSel1Day >= dtFirstDay && dtSel1Day <= dtLastDay)
  2631. {
  2632. return dtSel1;
  2633. }
  2634. else
  2635. if (dtSel2Day >= dtFirstDay && dtSel2Day <= dtLastDay)
  2636. {
  2637. return dtSel2;
  2638. }
  2639. return TBase::GetNextTimeEditByTAB();
  2640. }
  2642. void CXTPCalendarDayView::UpdateNextTimeEditByTAB(COleDateTime dtNext, BOOL bReverse, BOOL bReset)
  2643. {
  2644. m_selectedBlock.dtBegin = m_selectedBlock.dtEnd = GetNextTimeEditByTAB();
  2645. m_dtSelectionStart = m_selectedBlock.dtBegin;
  2647. COleDateTime dtNextDay = CXTPCalendarUtils::ResetTime(dtNext);
  2648. COleDateTime dtCurrDay = CXTPCalendarUtils::ResetTime(GetNextTimeEditByTAB());
  2650. if (dtNextDay != dtCurrDay || bReset)
  2651. {
  2652. m_selectedBlock.dtBegin = m_selectedBlock.dtEnd = dtNextDay;
  2653. m_dtSelectionStart = m_selectedBlock.dtBegin;
  2655. COleDateTime dtFirstDay = GetViewDayDate(bReverse ? GetViewDayCount()-1 : 0);
  2656. if (dtNextDay == dtFirstDay || bReset)
  2657. {
  2658. if (bReverse)
  2659. {
  2660. m_selectedBlock.dtBegin = m_selectedBlock.dtEnd = dtNextDay + COleDateTimeSpan(1, 0, 0, 0);
  2661. m_selectedBlock.dtBegin = m_selectedBlock.dtEnd - GetCellDuration();
  2662. }
  2663. else
  2664. {
  2665. m_selectedBlock.dtEnd = m_selectedBlock.dtBegin + GetCellDuration();
  2666. }
  2667. ProcessCellSelection(m_selectedBlock.dtEnd, FALSE, FALSE, 0);
  2668. }
  2669. }
  2670. }
  2672. COleDateTimeSpan CXTPCalendarDayView::GetEventDurationMin() const
  2673. {
  2674. return GetCellDuration();
  2675. }
  2677. CXTPCalendarTimeZonePtr CXTPCalendarDayView::GetCurrentTimeZoneInfo()
  2678. {
  2679. TIME_ZONE_INFORMATION tziCurrent;
  2680. ::ZeroMemory(&tziCurrent, sizeof(tziCurrent));
  2682. if (::GetTimeZoneInformation(&tziCurrent) == TIME_ZONE_ID_INVALID)
  2683. {
  2684. ASSERT(FALSE);
  2685. return NULL;
  2686. }
  2688. return CXTPCalendarTimeZone::GetTimeZoneInfo(&tziCurrent);
  2689. }
  2691. CXTPCalendarTimeZonePtr CXTPCalendarDayView::GetScale2TimeZoneInfo()
  2692. {
  2693. return CXTPCalendarTimeZone::GetTimeZoneInfo(&GetScale2TimeZone());
  2694. }
  2696. void CXTPCalendarDayView::ScrollToWorkDayBegin()
  2697. {
  2698. if (!m_pControl || !m_pControl->GetCalendarOptions())
  2699. {
  2700. ASSERT(FALSE);
  2701. return;
  2702. }
  2704. COleDateTime dtStartDate = GetViewDayDate(0);
  2705. COleDateTime dtSelBegin = CXTPCalendarUtils::UpdateTime(dtStartDate, m_pControl->GetCalendarOptions()->dtWorkDayStartTime);
  2706. COleDateTime dtSelEnd = dtSelBegin + GetCellDuration();
  2708. SetSelection(dtSelBegin, dtSelEnd, FALSE);
  2710. int nWDStartCell = GetCellNumber(m_pControl->GetCalendarOptions()->dtWorkDayStartTime, FALSE);
  2711. _ScrollV(nWDStartCell, nWDStartCell);
  2712. }
  2714. int CXTPCalendarDayView::_GetTimeScaleWith()
  2715. {
  2716. int nWidth = XTP_SAFE_GET1(GetTimeScale(), GetWidth(), 0);
  2717. if (IsScale2Visible())
  2718. nWidth += XTP_SAFE_GET1(GetTimeScale(2), GetWidth(), 0);
  2720. return nWidth;
  2721. }
  2723. CRect CXTPCalendarDayView::_GetScrollRectClient()
  2724. {
  2725. CXTPClientRect rcClient(GetCalendarControl());
  2726. rcClient.left += _GetTimeScaleWith();
  2727. rcClient.left = min(rcClient.left, rcClient.right);
  2729. return rcClient;
  2730. }
  2732. /////////////////////////////////////////////////////////////////////////////