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

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

对话框与窗口

开发平台：

Visual C++

XTPCalendarMonthView.cpp：源码内容
  1. // XTPCalendarMonthView.cpp: implementation of the CXTPCalendarMonthView 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 "XTPCalendarMonthView.h"
  26. #include "XTPCalendarControl.h"
  27. #include "XTPCalendarTheme.h"
  28. #include "XTPCalendarNotifications.h"
  29. #include "XTPCalendarOptions.h"
  31. #ifdef _DEBUG
  32. #define new DEBUG_NEW
  33. #undef THIS_FILE
  34. static char THIS_FILE[] = __FILE__;
  35. #endif
  37. #define XTP_CAL_MIDDLE_SCROLL_POS 49
  39. //////////////////////////////////////////////////////////////////////
  40. // Construction/Destruction
  41. //////////////////////////////////////////////////////////////////////
  42. IMPLEMENT_DYNAMIC(CXTPCalendarMonthView, CXTPCalendarView)
  44. CXTPCalendarMonthView::CXTPCalendarMonthView(CXTPCalendarControl* pCalendarControl) :
  45. TBase(pCalendarControl, xtpCalendarMonthView)
  46. {
  47. m_strLongDateFormat = _T("MMMM d");
  48. m_strSmallDateFormat = _T("d");
  50. m_nEventCaptionFormat = xtpCalendarCaptionFormatSubject;
  51. m_nEventTimeWidth = 0;
  53. COleDateTime dtNow = CXTPCalendarUtils::GetCurrentTime();
  54. COleDateTime dtFirst(dtNow.GetYear(), dtNow.GetMonth(), 1, 0, 0, 0);
  56. m_pGrid = new CMonthViewGrid(this);
  57. if (m_pGrid)
  58. {
  59. m_pGrid->SetWeeksCount(5);
  60. m_pGrid->SetBeginDate(dtFirst);
  62. m_pGrid->AdjustFirstDayOfWeek();
  63. m_pGrid->SetBeginDate(dtFirst);
  64. }
  66. }
  68. void CXTPCalendarMonthView::ShowDay(const COleDateTime& date, BOOL bSelect)
  69. {
  70. if (!m_pGrid)
  71. {
  72. return;
  73. }
  75. CXTPCalendarControl::CUpdateContext updateContext(m_pControl, xtpCalendarUpdateAll);
  77. m_pGrid->SetBeginDate(date);
  78. Populate();
  80. UnselectAllEvents();
  81. if (bSelect)
  82. SelectDay(CXTPCalendarUtils::ResetTime(date));
  83. }
  85. CXTPCalendarMonthView::~CXTPCalendarMonthView()
  86. {
  87. if (m_pGrid)
  88. {
  89. delete m_pGrid;
  90. m_pGrid = NULL;
  91. }
  92. }
  94. void CXTPCalendarMonthView::Populate()
  95. {
  96. ASSERT(m_pGrid);
  97. if (m_pGrid)
  98. {
  99. m_pGrid->AdjustFirstDayOfWeek();
  100. TBase::Populate();
  101. }
  102. }
  104. void CXTPCalendarMonthView::AdjustLayout(CDC* pDC, const CRect& rcView, BOOL bCallPostAdjustLayout)
  105. {
  106. ASSERT(pDC);
  107. if (!m_pGrid || !pDC)
  108. {
  109. return;
  110. }
  112. TBase::AdjustLayout(pDC, rcView, FALSE);
  114. _CalculateDateFormats(pDC);
  115. _CalculateEventCaptionFormat(pDC);
  117. m_pGrid->AdjustLayout(pDC);
  119. //---------------------------------------------------------------------------
  120. if (bCallPostAdjustLayout)
  121. {
  122. OnPostAdjustLayout();
  123. }
  124. }
  126. void CXTPCalendarMonthView::AdjustLayout2(CDC* pDC, const CRect& rcView, BOOL bCallPostAdjustLayout)
  127. {
  128. if (!GetTheme())
  129. {
  130. ASSERT(FALSE);
  131. return;
  132. }
  133. TBase::AdjustLayout2(pDC, rcView, bCallPostAdjustLayout);
  135. GetTheme()->GetMonthViewPart()->AdjustLayout(pDC, rcView, bCallPostAdjustLayout);
  136. }
  138. void CXTPCalendarMonthView::ScrollV(int /*nPos*/, int nPos_raw)
  139. {
  140. if (!m_pGrid || m_bScrollV_Disabled)
  141. {
  142. return;
  143. }
  145. if (IsEditingSubject())
  146. {
  147. EndEditSubject(xtpCalendarEditSubjectCommit, FALSE);
  148. }
  150. COleDateTime dtFirst0 = m_pGrid->GetBeginDate();
  152. m_pGrid->ScrollV(nPos_raw);
  154. COleDateTime dtFirst1 = m_pGrid->GetBeginDate();
  156. if (GetSelection())
  157. {
  158. COleDateTimeSpan spShift = dtFirst1 - dtFirst0;
  159. m_selectedBlock.dtBegin += spShift;
  160. m_selectedBlock.dtEnd += spShift;
  162. CSelectionChangedContext selChanged(this, xtpCalendarSelectionDays);
  163. }
  164. UnselectAllEvents();
  166. Populate();
  167. }
  169. void CXTPCalendarMonthView::Draw2(CDC* pDC)
  170. {
  171. if (!GetTheme())
  172. {
  173. ASSERT(FALSE);
  174. return;
  175. }
  177. GetTheme()->GetMonthViewPart()->Draw(pDC);
  178. }
  180. void CXTPCalendarMonthView::Draw(CDC* pDC)
  181. {
  182. ASSERT(pDC);
  183. if (!pDC || !m_pGrid)
  184. {
  185. return;
  186. }
  188. pDC->SetBkMode(TRANSPARENT);
  189. pDC->FillSolidRect(GetViewRect(), GetSysColor(COLOR_3DFACE));
  191. m_pGrid->Draw(pDC);
  193. //-- Draw Days ------------------------------
  194. int nCount = GetViewDayCount();
  195. for (int i = 0; i < nCount; i++)
  196. {
  197. CXTPCalendarMonthViewDay* pViewDay = GetViewDay(i);
  198. ASSERT(pViewDay);
  199. if (pViewDay)
  200. {
  201. pViewDay->Draw(pDC);
  202. }
  203. }
  204. }
  206. void CXTPCalendarMonthView::_SplitDateFormat(const CString& strDateFormat, CStringArray& rarTokens)
  207. {
  208. CString strSeparators = _T(" dDmMyYgG");
  209. CString strToken;
  211. CString strCHprev;
  212. BOOL bIsPrevSeparator = FALSE;
  214. int nLength = strDateFormat.GetLength();
  215. for (int i = 0; i < nLength; i++)
  216. {
  217. CString strCH(strDateFormat[i]);
  219. if (strCH == _T("'"))
  220. {
  221. strToken += strCH;
  222. for (i++; i < nLength; i++)
  223. {
  224. strCH = strDateFormat[i];
  225. CString strCH2((i + 1 < nLength) ? strDateFormat[i+1] : _T(''));
  227. strToken += strCH;
  229. if (strCH == _T("'") && strCH2 == _T("'"))
  230. {
  231. strToken += strCH2;
  232. i++;
  233. continue;
  234. }
  236. if (strCH == _T("'"))
  237. {
  238. break;
  239. }
  240. }
  241. rarTokens.Add(strToken);
  242. strToken.Empty();
  243. strCHprev.Empty();
  245. continue;
  246. }
  248. BOOL bIsSeparator = (strSeparators.Find(strCH) >= 0);
  250. if (bIsPrevSeparator != bIsSeparator ||
  251. bIsPrevSeparator && bIsSeparator && strCH.CompareNoCase(strCHprev)
  252.   )
  253. {
  254. if (!strToken.IsEmpty())
  255. {
  256. rarTokens.Add(strToken);
  257. }
  258. strToken.Empty();
  259. }
  260. strToken += strCH;
  262. strCHprev = strCH;
  263. bIsPrevSeparator = bIsSeparator;
  264. }
  266. if (!strToken.IsEmpty())
  267. {
  268. rarTokens.Add(strToken);
  269. }
  270. }
  272. void CXTPCalendarMonthView::_ReadDefaultDateFormats()
  273. {
  274. const CString strSpecials(_T(" ,.-_=+|?/<>~`!@#$%^&*()"));
  276. CString strLongDateFormat;
  277. CString strSmallDateFormat;
  279. CString strLocaleFormat = CXTPCalendarUtils::GetLocaleString(LOCALE_SLONGDATE, 81);
  281. CStringArray arTokens;
  282. _SplitDateFormat(strLocaleFormat, arTokens);
  284. BOOL bDayAdded = FALSE;
  285. BOOL bMonthAdded = FALSE;
  286. BOOL bDateFormatTokenWas = FALSE;
  288. int nCount = (int)arTokens.GetSize();
  289. for (int i = 0; i < nCount; i++)
  290. {
  291. CString strToken = arTokens[i];
  293. if (!bDayAdded && (strToken == _T("d") || strToken == _T("dd")))
  294. {
  295. strLongDateFormat += _T("d");
  296. strSmallDateFormat += _T("d");
  298. bDayAdded = TRUE;
  299. if (i + 1 < nCount)
  300. {
  301. strLongDateFormat += arTokens[i + 1];
  302. strSmallDateFormat += arTokens[i + 1];
  303. }
  304. }
  306. if (!bMonthAdded && (strToken == _T("M") || strToken == _T("MM") ||
  307. strToken == _T("MMM") || strToken == _T("MMMM")))
  308. {
  309. strLongDateFormat += strToken;
  310. bMonthAdded = TRUE;
  311. if (i + 1 < nCount)
  312. {
  313. strLongDateFormat += arTokens[i + 1];
  314. }
  315. }
  317. if (!bDateFormatTokenWas)
  318. {
  319. if (strToken == _T("ddd") || strToken == _T("dddd") || strToken == _T("gg") ||
  320. strToken == _T("y") || strToken == _T("yy") || strToken == _T("yyyy"))
  321. {
  322. bDateFormatTokenWas = TRUE;
  323. if (!bDayAdded && !bMonthAdded)
  324. {
  325. strLongDateFormat.Empty();
  326. }
  327. if (!bDayAdded)
  328. {
  329. strSmallDateFormat.Empty();
  330. }
  331. }
  332. }
  334. if (!bDateFormatTokenWas && !bDayAdded && !bMonthAdded)
  335. {
  336. strLongDateFormat += strToken;
  337. strSmallDateFormat += strToken;
  338. }
  339. }
  341. TRIMRIGHT_S(strLongDateFormat, strSpecials);
  342. TRIMRIGHT_S(strSmallDateFormat, strSpecials);
  344. if (!bDayAdded && !bMonthAdded)
  345. {
  346. strLongDateFormat = _T("M-d");
  347. strSmallDateFormat = _T("d");
  348. }
  349. else if (!bDayAdded || !bMonthAdded)
  350. {
  351. int nLen = strLongDateFormat.GetLength();
  352. CString strCHlast = nLen ? strLongDateFormat.Right(1) : _T("");
  353. if (strCHlast.FindOneOf(strSpecials) < 0)
  354. {
  355. strLongDateFormat += _T("-");
  356. }
  358. if (!bDayAdded)
  359. {
  360. strLongDateFormat += _T("d");
  361. strSmallDateFormat = _T("d");
  362. }
  363. else
  364. {
  365. strLongDateFormat += _T("M");
  366. }
  367. }
  369. m_strDayHeaderFormatDefaultLong = strLongDateFormat;
  370. m_strDayHeaderFormatDefaultMiddle = m_strDayHeaderFormatDefaultLong;
  371. REPLACE_S(m_strDayHeaderFormatDefaultMiddle, _T("MMMM"), _T("MMM"));
  373. m_strDayHeaderFormatDefaultShort = m_strDayHeaderFormatDefaultMiddle;
  374. REPLACE_S(m_strDayHeaderFormatDefaultShort, _T("MMM"), _T("MM"));
  376. m_strDayHeaderFormatDefaultShortest = strSmallDateFormat;
  377. }
  379. void CXTPCalendarMonthView::_CalculateDateFormats(CDC* pDC)
  380. {
  381. if (!m_pGrid || !m_pControl || !GetPaintManager() || !pDC)
  382. {
  383. ASSERT(FALSE);
  384. return;
  385. }
  387. _ReadDefaultDateFormats();
  389. m_strLongDateFormat = _GetDayHeaderFormat(0);
  390. m_strSmallDateFormat = _GetDayHeaderFormat(3);
  392. CXTPCalendarViewPart* pPart = GetPaintManager()->GetMonthViewEventPart();
  393. if (!pPart)
  394. {
  395. return;
  396. }
  398. CXTPFontDC fnt(pDC, &pPart->GetTextFont());
  400. int nBorderX = pDC->GetTextExtent(_T("WW"), 2).cx;
  401. int arBorder[] = {nBorderX*3/2, nBorderX, nBorderX/2, 0};
  403. int nColsCount = max(1, m_pGrid->GetColsCount());
  404. int nCellWidth = GetViewRect().Width() / nColsCount;
  406. for (int i = 0; i <= 2; i++)
  407. {
  408. m_strLongDateFormat = _GetDayHeaderFormat(i);
  409. int nLen = _GetMaxWidth(pDC, m_strLongDateFormat);
  411. if (nLen < nCellWidth - arBorder[i])
  412. {
  413. return;
  414. }
  415. }
  416. }
  418. CString CXTPCalendarMonthView::_FormatDayDate(COleDateTime dtDay, BOOL bLong)
  419. {
  420. SYSTEMTIME st;
  421. ZeroMemory(&st, sizeof(st));
  423. CString strDate;
  424. int nDay = dtDay.GetDay();
  426. CString strFormat = (bLong || nDay == 1) ? m_strLongDateFormat : m_strSmallDateFormat;
  428. if (GETASSYSTEMTIME_DT(dtDay, st))
  429. {
  430. strDate = CXTPCalendarUtils::GetDateFormat(&st, strFormat);
  431. }
  432. if (strDate.IsEmpty())
  433. {
  434. ASSERT(FALSE);
  435. strDate.Format(_T("%d-%d"), dtDay.GetMonth(), dtDay.GetDay());
  436. }
  438. return strDate;
  439. }
  441. BOOL CXTPCalendarMonthView::GetScrollBarInfoV(SCROLLINFO* pSI)
  442. {
  443. ASSERT(pSI);
  444. if (!pSI || m_bScrollV_Disabled)
  445. {
  446. return FALSE;
  447. }
  449. pSI->nPos = m_pGrid->GetScrollPos();
  450. pSI->nMax = 105;
  451. pSI->nPage = m_pGrid->GetWeeksCount();
  453. return TRUE;
  454. }
  456. CXTPCalendarMonthViewDay* CXTPCalendarMonthView::GetViewDay(int nIndex)
  457. {
  458. if (!m_pGrid)
  459. {
  460. return NULL;
  461. }
  463. int nWeeksCount = m_pGrid->GetWeeksCount();
  464. int nCount = m_arDays.GetCount();
  465. ASSERT(nCount == nWeeksCount * 7);
  467. if (nIndex >= nWeeksCount * 7 || nIndex >= nCount)
  468. {
  469. ASSERT(FALSE);
  470. return NULL;
  471. }
  473. CXTPCalendarMonthViewDay* pDView = m_arDays.GetAt(nIndex);
  475. if (!pDView)
  476. {
  477. int nWeekIndex = nIndex / 7;
  478. int nWeekDayIndex = nIndex % 7;
  480. pDView = new CXTPCalendarMonthViewDay(this, nWeekIndex, nWeekDayIndex);
  481. m_arDays.SetAt(nIndex, pDView);
  482. }
  484. return pDView;
  485. }
  487. COleDateTime CXTPCalendarMonthView::GetViewDayDate(int nIndex)
  488. {
  489. int nWeekIndex = nIndex / 7;
  490. int nWeekDayIndex = nIndex % 7;
  492. return XTP_SAFE_GET1(m_pGrid, GetDayDate(nWeekIndex, nWeekDayIndex), (DATE)0);
  493. }
  495. void CXTPCalendarMonthView::_CalculateEventCaptionFormat(CDC* pDC)
  496. {
  497. if (!m_pGrid || !m_pControl || !GetPaintManager() || !pDC)
  498. {
  499. ASSERT(FALSE);
  500. return;
  501. }
  503. BOOL bShowEnd = m_pControl->MonthView_IsShowEndDate();
  504. BOOL bShowAsClocks = m_pControl->MonthView_IsShowTimeAsClocks();
  506. CXTPCalendarViewPart* pPart = GetPaintManager()->GetMonthViewEventPart();
  507. if (!pPart)
  508. {
  509. return;
  510. }
  512. CXTPFontDC fnt(pDC, &pPart->GetTextFont());
  514. //--------------------
  515. CSize szW = pDC->GetTextExtent(_T(" "), 1);
  517. int nColsCount = max(1, m_pGrid->GetColsCount());
  518. int nCellWidth = GetViewRect().Width() / nColsCount;
  519. int nTimeWithMax = (nCellWidth - szW.cx * 2)/2;
  521. //--------------------
  522. m_nEventCaptionFormat = bShowEnd ? xtpCalendarCaptionFormatStartEndSubject : xtpCalendarCaptionFormatStartSubject;
  524. m_nEventTimeWidth = (GetPaintManager()->GetClockSize().cx + szW.cx);
  526. if (!bShowAsClocks)
  527. {
  528. CString strTime = GetItemTextEventTimeMax();
  529. m_nEventTimeWidth = pDC->GetTextExtent(strTime).cx + szW.cx;
  530. m_nEventTimeWidth = min(m_nEventTimeWidth, max(0, nCellWidth - 5));
  531. }
  533. if (bShowEnd)
  534. {
  535. m_nEventTimeWidth *= 2;
  536. }
  538. if (m_nEventTimeWidth > nTimeWithMax && m_nEventCaptionFormat == xtpCalendarCaptionFormatStartEndSubject)
  539. {
  540. m_nEventCaptionFormat = xtpCalendarCaptionFormatStartSubject;
  541. m_nEventTimeWidth /= 2;
  542. }
  544. if (m_nEventTimeWidth > nTimeWithMax)
  545. {
  546. m_nEventCaptionFormat = xtpCalendarCaptionFormatSubject;
  547. m_nEventTimeWidth = 0;
  548. }
  550. DWORD dwOpt = XTP_SAFE_GET2(GetCalendarControl(), GetCalendarOptions(), dwAdditionalOptions, 0);
  552. if (dwOpt & xtpCalendarOptMonthViewShowStartTimeAlways)
  553. m_nEventCaptionFormat = xtpCalendarCaptionFormatStartSubject;
  555. if (bShowEnd && (dwOpt & xtpCalendarOptMonthViewShowEndTimeAlways))
  556. m_nEventCaptionFormat = xtpCalendarCaptionFormatStartEndSubject;
  557. }
  559. BOOL CXTPCalendarMonthView::OnLButtonDown(UINT nFlags, CPoint point)
  560. {
  561. if (GetTheme() && GetTheme()->GetMonthViewPart())
  562. if (GetTheme()->GetMonthViewPart()->OnLButtonDown(this, nFlags, point))
  563. return TRUE;
  565. return TBase::OnLButtonDown(nFlags, point);
  566. }
  568. void CXTPCalendarMonthView::OnMouseMove(UINT nFlags, CPoint point)
  569. {
  570. if (GetTheme() && GetTheme()->GetMonthViewPart())
  571. GetTheme()->GetMonthViewPart()->OnMouseMove(this, nFlags, point);
  573. TBase::OnMouseMove(nFlags, point);
  574. }
  576. void CXTPCalendarMonthView::OnKeyDown(UINT nChar, UINT nRepCnt, UINT nFlags)
  577. {
  578. CSelectionChangedContext selChanged(this);
  580. TBase::OnKeyDown(nChar, nRepCnt, nFlags);
  582. if (nChar == VK_LEFT || nChar == VK_RIGHT || nChar == VK_UP || nChar == VK_DOWN ||
  583. nChar == VK_PRIOR || nChar == VK_NEXT)
  584. {
  585. CXTPCalendarControl::CUpdateContext updateContext(m_pControl, xtpCalendarUpdateRedraw);
  587. BOOL bVKShift = !!(GetKeyState(VK_SHIFT) & 0x8000);
  588. COleDateTimeSpan spDay(1, 0, 0, 0);
  589. COleDateTimeSpan spWeek(7, 0, 0, 0);
  590. COleDateTimeSpan spPage(GetViewDayCount(), 0, 0, 0);
  592. int nDVCount = GetViewDayCount();
  593. BOOL bSelReseted = m_selectedBlock.dtEnd.GetStatus() != COleDateTime::valid;
  596. COleDateTime dtLastSelDay = GetLastSelectedDate();
  597. COleDateTime dtNewSelDay = dtLastSelDay;
  599. CXTPDrawHelpers::KeyToLayout(m_pControl, nChar);
  601. if (nChar == VK_LEFT)
  602. {
  603. dtNewSelDay -= spDay;
  604. }
  605. else
  606. if (nChar == VK_RIGHT)
  607. {
  608. dtNewSelDay += spDay;
  609. }
  610. else
  611. if (nChar == VK_UP)
  612. {
  613. dtNewSelDay -= spWeek;
  614. }
  615. else
  616. if (nChar == VK_DOWN)
  617. {
  618. dtNewSelDay += spWeek;
  619. }
  620. else
  621. if (nChar == VK_PRIOR)
  622. {
  623. dtNewSelDay -= spPage;
  624. }
  625. else
  626. if (nChar == VK_NEXT)
  627. {
  628. dtNewSelDay += spPage;
  629. }
  630. //---------------------------------------------------------------------------
  631. COleDateTime dtFirstDay = GetViewDayDate(0);
  632. COleDateTime dtLastDay = GetViewDayDate(nDVCount-1);
  634. BOOL bNeedScroll = dtNewSelDay < dtFirstDay || dtNewSelDay > dtLastDay;
  635. if (bNeedScroll && !m_bScrollV_Disabled)
  636. {
  637. CXTPCalendarControl::CUpdateContext updateContext1(m_pControl, xtpCalendarUpdateAll);
  639. if (m_pGrid)
  640. {
  641. m_pGrid->SetBeginDate(dtNewSelDay);
  642. Populate();
  643. bSelReseted = TRUE;
  644. }
  645. }
  647. //---------------------------------------------------------------------------
  648. if (!bNeedScroll || !m_bScrollV_Disabled)
  649. {
  650. if (bVKShift && !bSelReseted)
  651. {
  652. SelectDays(dtNewSelDay);
  653. }
  654. else
  655. {
  656. UnselectAllEvents();
  657. SelectDay(dtNewSelDay);
  658. }
  659. }
  660. }
  661. }
  665. /////////////////////////////////////////////////////////////////////////////
  666. //class CXTPCalendarMonthView::CMonthViewGrid
  668. CXTPCalendarMonthView::CMonthViewGrid::CMonthViewGrid(CXTPCalendarMonthView* pView)
  669. {
  670. m_pView = pView;
  672. m_dtBeginDate.SetStatus(COleDateTime::null);
  674. m_nWeeksCount = 0;
  675. SetWeeksCount(5);
  677. m_nColHeaderHeight = 18;
  679. m_nFirstDayOfWeekIndex = 2;     // 1 = Sunday, 2 = Monday ...
  681. }
  683. CXTPCalendarMonthView::CMonthViewGrid::~CMonthViewGrid()
  684. {
  685. }
  688. COleDateTime CXTPCalendarMonthView::CMonthViewGrid::GetMiddleScrollBeginDate()
  689. {
  690. COleDateTime dtNow = CXTPCalendarUtils::GetCurrentTime();
  691. COleDateTime dtFirst(dtNow.GetYear(), dtNow.GetMonth(), 1, 0, 0, 0);
  692. COleDateTime dtMiddle = ShiftDateToCell_00(dtFirst);
  694. return dtMiddle;
  695. }
  697. int CXTPCalendarMonthView::CMonthViewGrid::GetScrollPos()
  698. {
  699. COleDateTime dtMiddle = GetMiddleScrollBeginDate();
  700. COleDateTime dtBegin = GetBeginDate();
  702. COleDateTimeSpan spPos = dtBegin - dtMiddle;
  703. int nDays = (int)spPos.GetTotalDays();
  705. ASSERT(nDays % 7 == 0);
  707. int nPos = nDays/7 + XTP_CAL_MIDDLE_SCROLL_POS;
  709. return nPos;
  710. }
  712. void CXTPCalendarMonthView::CMonthViewGrid::ScrollV(int nPos)
  713. {
  714. COleDateTimeSpan    spScroll((nPos - XTP_CAL_MIDDLE_SCROLL_POS)*7, 0, 0, 0);
  715. COleDateTime dtMiddle = GetMiddleScrollBeginDate();
  716. COleDateTime dtScrolled_00 = dtMiddle + spScroll;
  718. SetBeginDate(dtScrolled_00);
  719. }
  721. COleDateTime CXTPCalendarMonthView::CMonthViewGrid::ShiftDateToCell_00(COleDateTime dtDate)
  722. {
  723. dtDate = CXTPCalendarUtils::ResetTime(dtDate);
  725. int nShift = (dtDate.GetDayOfWeek() - m_nFirstDayOfWeekIndex + 7) % 7;
  726. if (nShift)
  727. {
  728. COleDateTimeSpan spShift(nShift, 0, 0, 0);
  729. dtDate -= spShift;
  730. }
  731. return dtDate;
  732. }
  734. void CXTPCalendarMonthView::CMonthViewGrid::SetWeeksCount(int nWeeks)
  735. {
  736. ASSERT(nWeeks >= XTP_CALENDAR_MONTHVIEW_SHOW_WEEKS_MIN);
  737. ASSERT(nWeeks <= XTP_CALENDAR_MONTHVIEW_SHOW_WEEKS_MAX);
  739. ASSERT(m_pView);
  740. if (!m_pView)
  741. {
  742. return;
  743. }
  745. if (m_nWeeksCount != nWeeks)
  746. {
  747. if (m_pView->IsEditingSubject())
  748. {
  749. m_pView->EndEditSubject(xtpCalendarEditSubjectCommit, FALSE);
  750. }
  751. }
  753. m_nWeeksCount = max(nWeeks, XTP_CALENDAR_MONTHVIEW_SHOW_WEEKS_MIN);
  754. m_nWeeksCount = min(m_nWeeksCount, XTP_CALENDAR_MONTHVIEW_SHOW_WEEKS_MAX);
  756. int nDaysCount = m_nWeeksCount * 7;
  757. int nCount = (int)m_pView->m_arDays.GetCount();
  759. if (nDaysCount != nCount)
  760. {
  761. m_pView->m_arDays.SetSize(nDaysCount);
  763. CXTPCalendarControl::CViewChangedContext viewChanged(m_pView);
  764. }
  765. }
  767. COleDateTime CXTPCalendarMonthView::CMonthViewGrid::GetDayDate(int nWeekIndex, int nWeekDayIndex) const
  768. {
  769. ASSERT(nWeekIndex >= 0 && nWeekIndex < m_nWeeksCount);
  770. ASSERT(nWeekDayIndex >= 0 && nWeekDayIndex < 7);
  772. int nDayIndex = nWeekIndex * 7 + nWeekDayIndex;
  773. COleDateTimeSpan spShift(nDayIndex, 0, 0, 0);
  774. COleDateTime dtDay = m_dtBeginDate + spShift;
  776. return dtDay;
  777. }
  779. CRect CXTPCalendarMonthView::CMonthViewGrid::GetDayRect(int nWeekIndex, int nWeekDayIndex, BOOL bIncludeBorders) const
  780. {
  781. BOOL bCompressWeD = XTP_SAFE_GET2(m_pView, GetCalendarControl(), MonthView_IsCompressWeekendDays(), FALSE);
  783. COleDateTime dtDate = GetDayDate(nWeekIndex, nWeekDayIndex);
  784. int nWDay = dtDate.GetDayOfWeek();
  786. int nColIdx = nWeekDayIndex;
  787. int nCompressedColIdx = 7 - m_nFirstDayOfWeekIndex;
  788. if (bCompressWeD && nColIdx > nCompressedColIdx)
  789. {
  790. nColIdx--;
  791. }
  793. CRect rcDay(0, 0, 0, 0);
  794. rcDay.left = m_arColsLeftX[nColIdx];
  795. rcDay.right = m_arColsLeftX[nColIdx + 1];
  797. int nHalfHeight = (m_arRowsTopY[nWeekIndex + 1] - m_arRowsTopY[nWeekIndex]) / 2;
  799. if (bCompressWeD && nWDay == 7)
  800. {
  801. rcDay.top = m_arRowsTopY[nWeekIndex];
  802. rcDay.bottom = rcDay.top + nHalfHeight;
  803. }
  804. else
  805. if (bCompressWeD && nWDay == 1)
  806. {
  807. rcDay.top = m_arRowsTopY[nWeekIndex] + nHalfHeight;
  808. rcDay.bottom = m_arRowsTopY[nWeekIndex + 1];
  809. }
  810. else
  811. {
  812. rcDay.top = m_arRowsTopY[nWeekIndex];
  813. rcDay.bottom = m_arRowsTopY[nWeekIndex + 1];
  814. }
  816. if (!bIncludeBorders)
  817. {
  818. rcDay.DeflateRect(1, 1, 0, 0);
  819. }
  822. return rcDay;
  823. }
  825. CRect CXTPCalendarMonthView::CMonthViewGrid::GetCelRect(int nWeekIndex, int nColIndex, BOOL bIncludeBorders) const
  826. {
  827. CRect rcCell(0, 0, 0, 0);
  829. rcCell.left = m_arColsLeftX[nColIndex];
  830. rcCell.right = m_arColsLeftX[nColIndex + 1];
  832. rcCell.top = m_arRowsTopY[nWeekIndex];
  833. rcCell.bottom = m_arRowsTopY[nWeekIndex + 1];
  835. if (!bIncludeBorders)
  836. {
  837. rcCell.DeflateRect(1, 1, 0, 0);
  838. }
  841. return rcCell;
  842. }
  844. int CXTPCalendarMonthView::CMonthViewGrid::GetColsCount() const
  845. {
  846. BOOL bCompressWeD = XTP_SAFE_GET2(m_pView, GetCalendarControl(), MonthView_IsCompressWeekendDays(), FALSE);
  847. int nColsCount = bCompressWeD ? 6 : 7;
  848. return nColsCount;
  849. }
  851. int CXTPCalendarMonthView::CMonthViewGrid::GetWeekDayCol(int nWeekDayIndex) const
  852. {
  853. BOOL bCompressWeD = XTP_SAFE_GET2(m_pView, GetCalendarControl(), MonthView_IsCompressWeekendDays(), FALSE);
  854. int nCompressedColIdx = 7 - m_nFirstDayOfWeekIndex;
  856. int nColIdx = (nWeekDayIndex - m_nFirstDayOfWeekIndex + 7) % 7;
  858. if (bCompressWeD && nColIdx > nCompressedColIdx)
  859. {
  860. nColIdx--;
  861. }
  863. return nColIdx;
  864. }
  866. int CXTPCalendarMonthView::CMonthViewGrid::GetWeekDayForColIndex(int nColIdx) const
  867. {
  868. BOOL bCompressWeD = XTP_SAFE_GET2(m_pView, GetCalendarControl(), MonthView_IsCompressWeekendDays(), FALSE);
  869. int nCompressedColIdx = 7 - m_nFirstDayOfWeekIndex;
  871. if (bCompressWeD && nColIdx == nCompressedColIdx)
  872. {
  873. return 7;
  874. }
  876. if (bCompressWeD && nColIdx > nCompressedColIdx)
  877. {
  878. nColIdx++;
  879. }
  881. int nWeekDayIndex = (m_nFirstDayOfWeekIndex - 1 + nColIdx) % 7 + 1;
  883. return nWeekDayIndex;
  884. }
  886. int CXTPCalendarMonthView::CMonthViewGrid::GetColHeaderHeight() const
  887. {
  888. return m_nColHeaderHeight;
  889. }
  891. void CXTPCalendarMonthView::CMonthViewGrid::SetColHeaderHeight(int nHeight)
  892. {
  893. m_nColHeaderHeight = nHeight;
  894. }
  896. CXTPCalendarMonthViewDay* CXTPCalendarMonthView::CMonthViewGrid::GetViewDay(int nWeekIndex, int nWeekDayIndex)
  897. {
  898. int nIdx = nWeekIndex * 7 + nWeekDayIndex;
  899. return XTP_SAFE_GET1(m_pView, GetViewDay(nIdx), NULL);
  900. }
  902. void CXTPCalendarMonthView::CMonthViewGrid::AdjustFirstDayOfWeek()
  903. {
  904. BOOL bCompressWeD = XTP_SAFE_GET2(m_pView, GetCalendarControl(), MonthView_IsCompressWeekendDays(), FALSE);
  906. int nFDPrev = m_nFirstDayOfWeekIndex;
  907. //- Adjust First day of Week ------------------------------------------
  908. m_nFirstDayOfWeekIndex = XTP_SAFE_GET2(m_pView, GetCalendarControl(), GetFirstDayOfWeek(), 2);
  909. if (bCompressWeD && m_nFirstDayOfWeekIndex == 1)
  910. {
  911. m_nFirstDayOfWeekIndex = 2;
  912. }
  914. int nDShift = m_nFirstDayOfWeekIndex - nFDPrev;
  915. COleDateTime dtBeginDate = GetDayDate(0, 0);
  916. dtBeginDate += COleDateTimeSpan(nDShift);
  918. SetBeginDate(dtBeginDate);
  919. }
  921. void CXTPCalendarMonthView::CMonthViewGrid::SetBeginDate(COleDateTime dtBeginDate)
  922. {
  923. CXTPCalendarControl::CViewChangedContext viewChanged(m_pView);
  925. m_dtBeginDate = ShiftDateToCell_00(dtBeginDate);
  926. }
  928. void CXTPCalendarMonthView::GetWeekDayTextIfNeed(CString* pstrText, int nWeekDay)
  929. {
  930. ASSERT(nWeekDay >= 1 && nWeekDay <= 7);
  931. if (!pstrText)
  932. {
  933. ASSERT(FALSE);
  934. return;
  935. }
  937. DWORD dwFlags = XTP_SAFE_GET1(GetCalendarControl(), GetAskItemTextFlags(), 0);
  939. if (dwFlags & xtpCalendarItemText_MonthViewWeekDayHeader)
  940. {
  941. XTP_CALENDAR_GETITEMTEXT_PARAMS objRequest;
  942. ::ZeroMemory(&objRequest, sizeof(objRequest));
  944. objRequest.nItem = xtpCalendarItemText_MonthViewWeekDayHeader;
  945. objRequest.pstrText = pstrText;
  946. objRequest.nWeekDay = nWeekDay;
  948. XTP_SAFE_CALL1(GetCalendarControl(), SendNotificationAlways(XTP_NC_CALENDAR_GETITEMTEXT, (WPARAM)&objRequest, 0));
  949. }
  950. }
  952. void CXTPCalendarMonthView::CMonthViewGrid::AdjustHeader(CDC* pDC)
  953. {
  954. CXTPCalendarViewPart* pPart = XTP_SAFE_GET2(m_pView, GetPaintManager(), GetMonthViewHeaderPart(), NULL);
  955. if (!m_pView || !m_pView->GetCalendarControl() || !pPart || !pDC)
  956. {
  957. ASSERT(FALSE);
  958. return;
  959. }
  961. CXTPFontDC fnt(pDC, &pPart->GetTextFont());
  963. int nColsCount = max(1, GetColsCount());
  964. int nCellWidth = m_pView->GetViewRect().Width() / nColsCount;
  966. //-- Calc header settings -----------------------------------------
  967. LCTYPE LC_WeekDAYNAME1 = LOCALE_SDAYNAME1;
  969. int nHWithMax = 0;
  970. int i;
  971. for (i = 0; i < 7; i++)
  972. {
  973. CString sWD = CXTPCalendarUtils::GetLocaleString(LC_WeekDAYNAME1 + i, 100);
  974. nHWithMax = max(nHWithMax, pDC->GetTextExtent(sWD).cx);
  975. }
  977. int nSpace = pDC->GetTextExtent(_T("Ww"), 2).cx * 2;
  978. if (nHWithMax + nSpace > nCellWidth)
  979. {
  980. LC_WeekDAYNAME1 = LOCALE_SABBREVDAYNAME1;
  981. }
  982. //---------------------------------------------------------------------------
  983. m_arColHeaderText.RemoveAll();
  984. m_arColHeaderText.SetSize(7);
  986. CString strHearderTest = _T("/");
  988. for (i = 0; i < 7; i++)
  989. {
  990. CString sWD = CXTPCalendarUtils::GetLocaleString(LC_WeekDAYNAME1 + i, 100);
  992. int nCol = GetWeekDayCol((i + 2) % 7);
  994. CString sVal = m_arColHeaderText[nCol];
  995. if (!sVal.IsEmpty())
  996. {
  997. // compressed col - always Sat/Sun
  998. CString sSat = CXTPCalendarUtils::GetLocaleString(LOCALE_SABBREVDAYNAME6, 100);
  999. CString sSun = CXTPCalendarUtils::GetLocaleString(LOCALE_SABBREVDAYNAME7, 100);
  1001. m_arColHeaderText[nCol] = sSat + _T("/") + sSun;
  1002. strHearderTest += sWD;
  1003. }
  1004. else
  1005. {
  1006. m_arColHeaderText[nCol] += sWD;
  1007. strHearderTest += sWD;
  1008. }
  1009. }
  1011. //-------------------------------------------
  1012. CSize sizeH = pDC->GetTextExtent(strHearderTest);
  1013. m_nColHeaderHeight = max(18, sizeH.cy + 6);
  1015. m_pView->m_Layout.m_nRowHeight = m_nColHeaderHeight;
  1016. }
  1018. void CXTPCalendarMonthView::CMonthViewGrid::AdjustDays(CDC* pDC)
  1019. {
  1020. ASSERT(pDC);
  1021. if (!pDC)
  1022. {
  1023. return;
  1024. }
  1026. int nWeeksCount = m_nWeeksCount;
  1027. for (int nWeek = 0; nWeek < nWeeksCount; nWeek++)
  1028. {
  1029. for (int nDayIdx = 0; nDayIdx < 7; nDayIdx++)
  1030. {
  1031. CRect rcDay = GetDayRect(nWeek, nDayIdx, TRUE);
  1033. CXTPCalendarMonthViewDay* pViewDay = GetViewDay(nWeek, nDayIdx);
  1034. //----------------------------------------
  1035. if (pViewDay)
  1036. pViewDay->AdjustLayout(pDC, rcDay);
  1037. }
  1038. }
  1039. }
  1041. void CXTPCalendarMonthView::CMonthViewGrid::AdjustEvents(CDC* pDC)
  1042. {
  1043. ASSERT(pDC);
  1044. if (!pDC)
  1045. {
  1046. return;
  1047. }
  1049. BOOL bCompressWeD = XTP_SAFE_GET2(m_pView, GetCalendarControl(), MonthView_IsCompressWeekendDays(), FALSE);
  1050. int nSundayIdx = (7 - m_nFirstDayOfWeekIndex + 1) % 7;
  1052. CXTPCalendarMonthViewDay* pViewDay;
  1054. int nWeeksCount = m_nWeeksCount;
  1055. for (int nWeek = 0; nWeek < nWeeksCount; nWeek++)
  1056. {
  1057. int nDayIdx;
  1059. // Adjust Begin/End for multiday events
  1060. for (nDayIdx = 0; nDayIdx < 7; nDayIdx++)
  1061. {
  1062. // go through all days to look for multiday events
  1063. pViewDay = GetViewDay(nWeek, nDayIdx);
  1064. ASSERT(pViewDay);
  1065. if (!pViewDay)
  1066. {
  1067. continue;
  1068. }
  1070. ASSERT(pViewDay->GetViewGroupsCount() == 1);
  1072. int nEventsCount = 0; //pViewDay->GetViewEventsCount();
  1073. if (pViewDay->GetViewGroupsCount())
  1074. {
  1075. nEventsCount = XTP_SAFE_GET2(pViewDay, GetViewGroup_(0), GetViewEventsCount(), 0);
  1076. }
  1078. for (int nEvent = 0; nEvent < nEventsCount; nEvent++)
  1079. {
  1080. CXTPCalendarMonthViewEvent* pViewEvent = XTP_SAFE_GET2(pViewDay, GetViewGroup(0), GetViewEvent(nEvent), NULL );//pViewDay->GetViewEvent(nEvent);
  1081. ASSERT(pViewEvent);
  1082. if (!pViewEvent)
  1083. {
  1084. continue;
  1085. }
  1087. int nMDEFlags = pViewEvent->GetMultiDayEventFlags();
  1089. if ((nMDEFlags & xtpCalendarMultiDayMSmask) || !(nMDEFlags & xtpCalendarMultiDayFMLmask))
  1090. {
  1091. continue; // already marked or not multiday
  1092. }
  1093. //------------------------
  1094. BOOL bLast = (nMDEFlags & xtpCalendarMultiDayLast) != 0;
  1095. pViewEvent->SetMultiDayEvent_MasterSlave(TRUE, NULL);
  1096. int nMasterPlace = pViewEvent->GetEventPlaceNumber();
  1098. if (!bLast && (nDayIdx != nSundayIdx || !bCompressWeD))
  1099. {
  1100. // find other visible instances and mark them as Slave
  1101. for (int i = nDayIdx + 1; i < 7; i++)
  1102. {
  1103. if (i == nSundayIdx && bCompressWeD)
  1104. {
  1105. break; //continue; // skip compressed sunday
  1106. }
  1108. CXTPCalendarMonthViewDay* pViewDay2 = GetViewDay(nWeek, i);
  1109. CXTPCalendarViewEvent* pViewEvent2 = NULL;
  1111. ASSERT(XTP_SAFE_GET1(pViewDay2, GetViewGroupsCount(), 0) == 1);
  1113. if (XTP_SAFE_GET1(pViewDay2, GetViewGroupsCount(), 0))
  1114. {
  1115. pViewEvent2 = XTP_SAFE_GET2(pViewDay2, GetViewGroup_(0),
  1116. GetViewEventByEvent_(pViewEvent->GetEvent()), NULL);
  1117. }
  1118. if (!pViewEvent2)
  1119. {
  1120. break;
  1121. }
  1122. pViewEvent->AddMultiDayEvent_Slave(pViewEvent2, nMasterPlace);
  1124. if (!pViewEvent2->IsVisible())
  1125. {
  1126. break;
  1127. }
  1128. }
  1129. }
  1130. }
  1131. }
  1132. }
  1134. }
  1136. void CXTPCalendarMonthView::CMonthViewGrid::AdjustGrid(const CRect& rcRect)
  1137. {
  1138. //-------------------------------------------
  1139. int nColsCount = GetColsCount();
  1141. int nWidth = rcRect.Width(); // m_pView->GetViewRect().Width();
  1142. int nHeight = rcRect.Height(); //max(0, m_pView->GetViewRect().Height() - m_nColHeaderHeight);
  1144. m_arRowsTopY.SetSize(m_nWeeksCount + 1);
  1145. m_arColsLeftX.SetSize(nColsCount + 1);
  1147. int nCurrPos = rcRect.top; //m_nColHeaderHeight;
  1148. for (int nWeek = 0; nWeek < m_nWeeksCount; nWeek++)
  1149. {
  1150. m_arRowsTopY[nWeek] = nCurrPos;
  1152. int nHeightRow = nHeight / (m_nWeeksCount - nWeek);
  1153. nCurrPos += nHeightRow;
  1154. nHeight -= nHeightRow;
  1155. }
  1156. m_arRowsTopY[m_nWeeksCount] = nCurrPos;
  1158. nCurrPos = rcRect.left; //0;
  1159. for (int nDayColl = 0; nDayColl < nColsCount; nDayColl++)
  1160. {
  1161. m_arColsLeftX[nDayColl] = nCurrPos;
  1163. int nWidthRow = nWidth / (nColsCount - nDayColl);
  1164. nCurrPos += nWidthRow;
  1165. nWidth -= nWidthRow;
  1166. }
  1167. m_arColsLeftX[nColsCount] = nCurrPos;
  1168. }
  1170. void CXTPCalendarMonthView::CMonthViewGrid::AdjustLayout(CDC* pDC)
  1171. {
  1172. ASSERT(pDC);
  1173. ASSERT(m_pView);
  1174. if (!m_pView || !pDC)
  1175. {
  1176. return;
  1177. }
  1179. AdjustHeader(pDC);
  1181. //------------------------------------------------------------------
  1182. CRect rcGrid = m_pView->GetViewRect();
  1183. rcGrid.top = min(rcGrid.top + m_nColHeaderHeight, rcGrid.bottom);
  1185. AdjustGrid(rcGrid);
  1186. //------------------------------------------------------------------
  1189. //------------------------------------------------------
  1191. AdjustDays(pDC);
  1193. AdjustEvents(pDC);
  1194. }
  1196. void CXTPCalendarMonthView::CMonthViewGrid::Draw(CDC* pDC)
  1197. {
  1198. //-- Draw Header -------------------------------
  1199. int nColsCount = GetColsCount();
  1201. for (int nCol = 0; nCol < nColsCount; nCol++)
  1202. {
  1203. CRect rcCell = GetCelRect(0, nCol, TRUE);
  1204. rcCell.top = m_pView->m_rcView.top;
  1205. rcCell.bottom = rcCell.top + m_nColHeaderHeight;
  1207. CString strWD = m_arColHeaderText[nCol];
  1209. int nWeekDay = GetWeekDayForColIndex(nCol);
  1210. m_pView->GetWeekDayTextIfNeed(&strWD, nWeekDay);
  1212. XTP_SAFE_CALL3(m_pView, GetPaintManager(), GetMonthViewHeaderPart(),
  1213. OnDraw(pDC, m_pView, rcCell, nCol, strWD));
  1214. }
  1216. //-- Draw Grid Lines and fill background -------
  1217. XTP_SAFE_CALL3(m_pView, GetPaintManager(), GetMonthViewGridPart(),
  1218. OnDrawGrid(pDC, m_pView));
  1220. }