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

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

对话框与窗口

开发平台：

Visual C++

XTPCalendarThemeOffice2007.cpp：源码内容
  1. rcIconsMax.bottom = rcIconsMax.top + rcIconsMax.Height()/2 + szIcons.cy/2;
  2. }
  4. rcIconsMax.left = min(rcIconsMax.left + rcTopRow.Height(), rcIconsMax.right);
  5. rcText.right = max(rcText.right - szIcons.cx - 2, rcText.left + rcTopRow.Height() - 2);
  6. }
  8. pViewEvent->m_rcSubjectEditor.CopyRect(rcText);
  9. //pViewEvent->AdjustSubjectEditorEx(FALSE);
  10. pViewEvent->AdjustSubjectEditor();
  12. if (!bMarkupDrawn)
  13. {
  14. CString strSubj = pViewEvent->GetItemTextSubject();
  15. CString strLoc = pViewEvent->GetItemTextLocation();
  16. CString strBody = pViewEvent->GetItemTextBody();
  18. CThemeFontColorSet* pFntClr2 = bSelected ? &m_fcsetSelected.fcsetLocation : &m_fcsetNormal.fcsetLocation;
  19. CThemeFontColorSet* pFntClr3 = bSelected ? &m_fcsetSelected.fcsetBody     : &m_fcsetNormal.fcsetBody;
  21. //------------------------------------------------------------
  22. UINT uWordBreakMode = DT_WORDBREAK;
  24. DWORD dwOpt = XTP_SAFE_GET3(GetTheme(), GetCalendarControl(), GetCalendarOptions(), dwAdditionalOptions, 0);
  25. if (dwOpt & xtpCalendarOptDayViewNoWordBreak)
  26. uWordBreakMode = DT_WORD_ELLIPSIS;
  28. pThemeX->DrawText_Auto2SL3ML(pDC, strSubj, strLoc, strBody,
  29.  pFntClr1, pFntClr2, pFntClr3, rcText, _T(";"), uWordBreakMode);
  30. }
  32. Draw_Icons(pViewEvent, pDC, rcIconsMax);
  34. /*
  35. BOOL bOutOfBorders = nY_need > rcText.Height() ||
  36.  nX_need > rcText.Width() ||
  37.  bTimeOutOfBorders;
  38. pViewEvent->SetTextOutOfBorders(bOutOfBorders);
  39. */
  42. }
  44. void CXTPCalendarThemeOffice2007::CTODayViewEvent_SingleDay::DrawShadow(CDC* pDC, CXTPCalendarDayViewEvent* pViewEvent)
  45. {
  46. ASSERT(pDC && pViewEvent);
  47. if (!pDC || pDC->IsPrinting() || !pViewEvent)
  48. return;
  50. CRect rcEvent(pViewEvent->GetEventRect());
  51. CRect rcTimeframe(pViewEvent->m_rcTimeframe);
  53. if (rcEvent.IsRectEmpty())
  54. {
  55. return;
  56. }
  58. // ----- Fill event background -----
  59. int nTopRow = pViewEvent->GetViewGroup()->GetTopRow();
  60. CRect rcTopRow = pViewEvent->GetViewGroup()->GetCellRect(nTopRow);
  62. BOOL bShortEvent = rcTimeframe.Height() + 1 < rcTopRow.Height();
  63. // --- Calculate event rectangle ---
  64. CRect rcRect(rcEvent);
  65. if (bShortEvent)
  66. rcRect.left += 5;
  68. //------------------------------------------------------------------------
  69. CXTPCalendarPaintManager::CXTPShadowDrawer oShadow(pDC, dXTPMaxAlpha2007);
  71. CRect rcVShadow(rcRect);
  72. rcVShadow.left = rcVShadow.right;
  73. rcVShadow.right += 5;
  74. rcVShadow.top += 5*2 + 1;
  75. oShadow.DrawShadowRectPart(rcVShadow, oShadow.xtpShadow2007Right);
  77. CRect rcHShadow(rcRect);
  78. rcHShadow.left += 5*2;
  79. rcHShadow.top = rcHShadow.bottom;
  80. rcHShadow.bottom += 5;
  81. oShadow.DrawShadowRectPart(rcHShadow, oShadow.xtpShadow2007Bottom);
  83. CRect rcTRShadow(rcVShadow);
  84. rcTRShadow.bottom = rcTRShadow.top;
  85. rcTRShadow.top -= 6;
  86. oShadow.DrawShadowRectPart(rcTRShadow, oShadow.xtpShadow2007TopRight);
  88. CRect rcBLShadow(rcHShadow);
  89. rcBLShadow.right = rcBLShadow.left;
  90. rcBLShadow.left -= 5;
  91. oShadow.DrawShadowRectPart(rcBLShadow, oShadow.xtpShadow2007BottomLeft);
  93. CRect rcBRShadow(rcVShadow.left - 3, rcHShadow.top - 3, rcVShadow.right, rcHShadow.bottom);
  94. oShadow.DrawShadowRectPart(rcBRShadow, oShadow.xtpShadow2007BottomRight);
  96. }
  98. void CXTPCalendarThemeOffice2007::_DrawEventLTHighlight(CDC* pDC, CPoint ptLT, int nRTx, const CXTPPaintManagerColorGradient& grclrBk,
  99. int nLTCorner, int nLBy, BOOL bRCorner)
  100. {
  101. COLORREF clrTop = XTPDrawHelpers()->LightenColor(120, grclrBk.clrLight);
  103. CRect rcTop(ptLT.x + nLTCorner, ptLT.y, nRTx, ptLT.y + 1);
  104. if (bRCorner)
  105. rcTop.right -= cnCornerSize / 2 + 1;
  107. pDC->FillSolidRect(&rcTop, clrTop);
  109. if(nLBy != INT_MAX)
  110. {
  111. CRect rcLLVert(ptLT.x, ptLT.y + nLTCorner, ptLT.x + 1, nLBy - nLTCorner);
  112. rcLLVert.top += nLTCorner ? 0 : 1;
  114. COLORREF clrLight = XTPDrawHelpers()->LightenColor(76, grclrBk.clrLight);
  115. COLORREF clrDrak = XTPDrawHelpers()->LightenColor(15, grclrBk.clrDark);
  117. XTPDrawHelpers()->GradientFill(pDC, rcLLVert, clrLight, clrDrak, FALSE);
  119. CPen pen(PS_SOLID, 1, clrLight);
  120. CXTPPenDC autoPen(pDC, &pen);
  122. pDC->MoveTo(rcLLVert.TopLeft());
  123. pDC->LineTo(rcTop.TopLeft());
  124. }
  126. if (bRCorner)
  127. {
  128. COLORREF clrLight2 = XTPDrawHelpers()->LightenColor(80, grclrBk.clrLight);
  129. CPen pen(PS_SOLID, 1, clrLight2);
  130. CXTPPenDC autoPen(pDC, &pen);
  132. pDC->MoveTo(rcTop.right, rcTop.top);
  133. pDC->LineTo(rcTop.right + cnCornerSize / 2 + 1, rcTop.top + cnCornerSize / 2 + 1);
  134. }
  135. }
  137. void CXTPCalendarThemeOffice2007::CTODayViewEvent_SingleDay::InitBusyStatusDefaultColors()
  138. {
  139. TBase2::InitBusyStatusDefaultColors();
  141. SetBusyStatusBrush(xtpCalendarBusyStatusBusy, NULL, FALSE);
  143. // Tentative ---------------------------
  144. m_bmpTentativePattern.DeleteObject();
  145. m_brushTentative.DeleteObject();
  147. VERIFY(XTPResourceManager()->LoadBitmap(&m_bmpTentativePattern, XTP_IDB_CALENDAR_TENATIVE_PATTERN_2007));
  148. VERIFY(m_brushTentative.CreatePatternBrush(&m_bmpTentativePattern));
  150. CXTPCalendarViewPartBrushValue* pBVal_Tentative = _GetBusyStatusBrushValue(xtpCalendarBusyStatusTentative, TRUE);
  151. if (pBVal_Tentative)
  152. {
  153. pBVal_Tentative->SetStandardValue(&m_brushTentative, FALSE);
  154. }
  155. }
  157. void CXTPCalendarThemeOffice2007::CTODayViewEvent_SingleDay::AdjustLayout(CCmdTarget* pObject,
  158. CDC* pDC, const CRect& rcRect, int nEventPlaceNumber)
  159. {
  160. UNREFERENCED_PARAMETER(nEventPlaceNumber);
  162. CXTPCalendarDayViewEvent* pViewEvent = DYNAMIC_DOWNCAST(CXTPCalendarDayViewEvent, pObject);
  163. CXTPCalendarThemeOffice2007* pThemeX = DYNAMIC_DOWNCAST(CXTPCalendarThemeOffice2007, GetTheme());
  165. if (!pDC || !pThemeX || !pViewEvent || !pViewEvent->GetEvent() || !pViewEvent->GetViewGroup() ||
  166. !pViewEvent->GetViewGroup()->GetViewDay())
  167. {
  168. ASSERT(FALSE);
  169. return;
  170. }
  172. CXTPCalendarEvent* pEvent = pViewEvent->GetEvent();
  173. CXTPCalendarDayViewGroup* pViewGroup = pViewEvent->GetViewGroup();
  174. CXTPCalendarDayViewDay* pViewDay = pViewGroup->GetViewDay();
  176. pViewEvent->m_nMultiDayEventFlags |= xtpCalendarMultiDayNoMultiDay;
  178. // non all-day event
  179. int nPace = pViewEvent->GetEventPlacePos();
  180. int nPaceCount = max(1, pViewEvent->GetEventPlaceCount());
  182. ASSERT(pViewEvent->GetEventPlaceCount() >= 1);
  183. ASSERT(nPace >= 0 && nPace < nPaceCount);
  185. pViewEvent->m_rcEvent.CopyRect(rcRect);
  186. int nEventsAreaX = pViewEvent->m_rcEvent.Width() - 5;
  187. int nEventWidth = nEventsAreaX / nPaceCount;
  189. // skip event views if they are not fit even by 5 pixel bar width
  190. // and correct some first event views heights
  191. if (nEventWidth <= 5)
  192. {
  193. while (nPaceCount > 1 && nEventWidth <= 5)
  194. {
  195. nPaceCount--;
  196. nEventWidth = nEventsAreaX / nPaceCount;
  197. }
  198. if (nPace > nPaceCount)
  199. {
  200. pViewEvent->m_rcEvent.SetRectEmpty();
  201. return;
  202. }
  203. }
  205. // calc other rect coordinates
  206. pViewEvent->m_rcEvent.left += nEventWidth * nPace;
  207. pViewEvent->m_rcEvent.right = pViewEvent->m_rcEvent.left + nEventWidth;
  209. //-------------------------------------------------------------------
  210. COleDateTime dtStartTime(pEvent->GetStartTime());
  211. COleDateTime dtEndTime(pEvent->GetEndTime());
  213. int nTopRow = pViewGroup->GetTopRow();
  215. CRect rcTopRow = pViewGroup->GetCellRect(nTopRow);
  216. CRect rcRow0 = pViewGroup->GetCellRect(0);
  217. CRect rcRowLast = pViewGroup->GetCellRect(pViewGroup->GetRowCount()-1);
  219. COleDateTime dtTopRowTime = pViewDay->GetView()->GetCellTime(nTopRow);
  220. dtTopRowTime = (double)pViewDay->GetDayDate() + (double)dtTopRowTime;
  222. double dblCellDur = (double)pViewDay->GetView()->GetCellDuration();
  223. if (dblCellDur <= XTP_HALF_SECOND)
  224. {
  225. dblCellDur = XTP_HALF_SECOND * 2 * 60 * 30;
  226. }
  228. double dblEventOffsetTime1 = double(dtStartTime - dtTopRowTime);
  229. double dblEventOffsetTime2 = double(dtEndTime - dtTopRowTime);
  230. double dblPixelPerTime = rcTopRow.Height() / dblCellDur;
  232. int nEventY1 = int(dblPixelPerTime * dblEventOffsetTime1);
  233. nEventY1 = max(rcRow0.top,  rcTopRow.top + nEventY1);
  234. nEventY1 = min(rcRowLast.top, nEventY1);
  236. int nEventY2 = int(dblPixelPerTime * dblEventOffsetTime2);
  237. nEventY2 = rcTopRow.top + nEventY2;
  238. nEventY2 = min(rcRowLast.bottom, nEventY2);
  240. int nEvent_dy = nEventY2 - nEventY1;
  242. BOOL bShortEvent = nEvent_dy + 1 < rcTopRow.Height();
  243. nEvent_dy = max(5, nEvent_dy);
  245. if (bShortEvent)
  246. {
  247. nEventY2 = nEventY1 + rcTopRow.Height();
  248. }
  250. ///%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
  251. pViewEvent->m_rcEvent.top = nEventY1;
  252. pViewEvent->m_rcEvent.bottom = nEventY2;
  254. pViewEvent->m_rcEventMax.top = max(pViewEvent->m_rcEvent.top-5, rcRect.top);
  255. pViewEvent->m_rcEventMax.bottom = min(pViewEvent->m_rcEvent.bottom + 5, rcRect.bottom);
  257. // adjust subject area
  258. pViewEvent->m_rcText.CopyRect(pViewEvent->m_rcEvent);
  259. pViewEvent->m_rcText.left += 10; // correct to busy area
  260. pViewEvent->m_rcText.left += 4;
  262. pViewEvent->m_rcSubjectEditor.CopyRect(pViewEvent->m_rcText);
  264. // Set time frame rect
  265. pViewEvent->m_rcTimeframe.top = pViewEvent->m_rcEvent.top;
  266. pViewEvent->m_rcTimeframe.bottom = pViewEvent->m_rcTimeframe.top + nEvent_dy;
  268. pViewEvent->m_rcTimeframe.left = pViewEvent->m_rcEvent.left + 1;
  269. pViewEvent->m_rcTimeframe.right = pViewEvent->m_rcTimeframe.left + 4;
  271. // set expanded signs for day view
  272. CRect rcEvents = rcRect;
  274. if (pViewEvent->m_rcEvent.top >= rcEvents.bottom-10)
  275. pViewEvent->GetViewGroup()->SetExpandDown();
  277. if (pViewEvent->m_rcEvent.bottom <= rcEvents.top + 10)
  278. pViewEvent->GetViewGroup()->SetExpandUp();
  279. }
  281. /////////////////////////////////////////////////////////////////////////////
  282. //
  283. // ***** Month View *****
  284. //
  286. void CXTPCalendarThemeOffice2007::CTOMonthView::RefreshMetrics(BOOL bRefreshChildren)
  287. {
  288. TBase::RefreshMetrics(bRefreshChildren);
  289. }
  291. void CXTPCalendarThemeOffice2007::CTOMonthViewEvent::RefreshMetrics(BOOL bRefreshChildren)
  292. {
  293. CXTPCalendarThemeOffice2007* pThemeX = DYNAMIC_DOWNCAST(CXTPCalendarThemeOffice2007, GetTheme());
  294. ASSERT(pThemeX);
  295. if (!pThemeX)
  296. {
  297. return;
  298. }
  300. TBase::RefreshMetrics(bRefreshChildren);
  302. RefreshFromParent(pThemeX->GetEventPartX());
  304. XTP_SAFE_CALL1(GetHeightFormulaPart(), SetStandardValue(14, 10, 1));
  305. XTP_SAFE_CALL1(GetEventIconsToDrawPart(), SetStandardValue(FALSE, FALSE, FALSE, FALSE, FALSE) );
  306. }
  308. void CXTPCalendarThemeOffice2007::CTOMonthViewEvent_MultiDay::RefreshMetrics(BOOL bRefreshChildren)
  309. {
  310. UNREFERENCED_PARAMETER(bRefreshChildren);
  312. CXTPCalendarThemeOffice2007* pThemeX = DYNAMIC_DOWNCAST(CXTPCalendarThemeOffice2007, GetTheme());
  313. ASSERT(pThemeX);
  314. if (!pThemeX)
  315. {
  316. return;
  317. }
  319. RefreshFromParent(pThemeX->GetMonthViewPartX()->GetEventPartX());
  321. m_fcsetNormal.clrBorder.SetStandardValue(pThemeX->GetColor(xtpCLR_MultiDayEventBorder));
  322. m_fcsetNormal.grclrBackground.SetStandardValue(pThemeX->GetColor(xtpCLR_MultiDayEventBkGRfrom),
  323.    pThemeX->GetColor(xtpCLR_MultiDayEventBkGRto)   );
  325. m_fcsetSelected.clrBorder.SetStandardValue(pThemeX->GetColor(xtpCLR_MultiDayEventSelectedBorder));
  326. m_fcsetSelected.grclrBackground.SetStandardValue(m_fcsetNormal.grclrBackground);
  328. //---------------------------------
  329. m_fcsetNormal.fcsetStartEnd.fntFont.SetStandardValue(pThemeX->m_fntBaseFont);
  330. m_fcsetNormal.fcsetStartEnd.clrColor.SetStandardValue(pThemeX->GetColor(xtpCLR_MultiDayEventFromToDates));
  332. m_fcsetSelected.fcsetStartEnd.fntFont.SetStandardValue(pThemeX->m_fntBaseFont);
  333. m_fcsetSelected.fcsetStartEnd.clrColor.SetStandardValue(pThemeX->GetColor(xtpCLR_MultiDayEventFromToDates));
  334. }
  336. void CXTPCalendarThemeOffice2007::CTOMonthViewEvent_SingleDay::RefreshMetrics(BOOL bRefreshChildren)
  337. {
  338. UNREFERENCED_PARAMETER(bRefreshChildren);
  340. CXTPCalendarThemeOffice2007* pThemeX = DYNAMIC_DOWNCAST(CXTPCalendarThemeOffice2007, GetTheme());
  341. ASSERT(pThemeX);
  342. if (!pThemeX)
  343. {
  344. return;
  345. }
  347. RefreshFromParent(pThemeX->GetMonthViewPartX()->GetEventPartX());
  349. CFont* pFontDef = pThemeX->m_fntBaseFont;
  351. m_fcsetNormal.clrBorder.SetStandardValue(pThemeX->GetColor(xtpCLR_MonthViewSingleDayEventBorder));
  352. m_fcsetNormal.grclrBackground.SetStandardValue(pThemeX->GetColor(xtpCLR_MonthViewSingleDayEventBkGRfrom),
  353.    pThemeX->GetColor(xtpCLR_MonthViewSingleDayEventBkGRto) );
  355. m_fcsetSelected.clrBorder.SetStandardValue(pThemeX->GetColor(xtpCLR_MonthViewSingleDayEventSelectedBorder));
  356. m_fcsetSelected.grclrBackground.SetStandardValue(pThemeX->GetColor(xtpCLR_MonthViewSingleDayEventBkGRfrom),
  357.  pThemeX->GetColor(xtpCLR_MonthViewSingleDayEventBkGRto) );
  359. //----------------------------------------------
  360. pThemeX->RemoveBoldAttrFromStd(m_fcsetNormal.fcsetSubject.fntFont);
  361. pThemeX->RemoveBoldAttrFromStd(m_fcsetSelected.fcsetSubject.fntFont);
  363. //----------------------------------------------
  364. m_fcsetNormal.fcsetStartEnd.clrColor.SetStandardValue(pThemeX->GetColor(xtpCLR_MonthViewEventTime));
  365. m_fcsetNormal.fcsetStartEnd.fntFont.SetStandardValue(pFontDef);
  367. m_fcsetSelected.fcsetStartEnd.clrColor.SetStandardValue(pThemeX->GetColor(xtpCLR_MonthViewEventTime));
  368. m_fcsetSelected.fcsetStartEnd.fntFont.SetStandardValue(pFontDef);
  369. }
  371. int CXTPCalendarThemeOffice2007::CTOMonthViewWeekHeader::CalcWidth(CDC* pDC)
  372. {
  373. return CalcHeight(pDC, -1);
  374. }
  376. void CXTPCalendarThemeOffice2007::CTOMonthView::AdjustLayout(CDC* pDC, const CRect& rcRect, BOOL bCallPostAdjustLayout)
  377. {
  378. CXTPCalendarMonthView* pMonthView = DYNAMIC_DOWNCAST(CXTPCalendarMonthView,
  379. XTP_SAFE_GET2(GetTheme(), GetCalendarControl(), GetMonthView(), NULL));
  381. CXTPCalendarThemeOffice2007* pThemeX = DYNAMIC_DOWNCAST(CXTPCalendarThemeOffice2007, GetTheme());
  383. if (!pDC || !pThemeX || !pMonthView || !pMonthView->GetGrid())
  384. {
  385. ASSERT(FALSE);
  386. return;
  387. }
  389. int nWHeaderWidth = GetWeekHeaderPartX()->CalcWidth(pDC);
  391. CRect rcRectWHeader = rcRect;
  392. rcRectWHeader.right = min(rcRectWHeader.left + nWHeaderWidth, rcRect.right);
  394. GetWeekHeaderPartX()->AdjustLayout(pMonthView, pDC, rcRectWHeader);
  396. CRect rcRectGrid = rcRect;
  397. rcRectGrid.left = rcRectWHeader.right;
  399. TBase::AdjustLayout(pDC, rcRectGrid, bCallPostAdjustLayout);
  401. if (pThemeX->GetPrevNextEventControllerPartX())
  402. pThemeX->GetPrevNextEventControllerPartX()->AdjustLayout(NULL, pDC, rcRectGrid);
  403. }
  405. void CXTPCalendarThemeOffice2007::CTOMonthViewEvent::AdjustLayout(CCmdTarget* pObject,
  406.   CDC* pDC, const CRect& rcRect, int nEventPlaceNumber)
  407. {
  408. CXTPCalendarMonthViewEvent* pViewEvent = DYNAMIC_DOWNCAST(CXTPCalendarMonthViewEvent, pObject);
  410. if (!pDC || !GetTheme() || !pViewEvent || !pViewEvent->GetEvent())
  411. {
  412. ASSERT(FALSE);
  413. return;
  414. }
  416. int nEventHeight = XTP_SAFE_GET4(pViewEvent, GetViewGroup(), GetViewDay(), GetView(), GetRowHeight(), 0);
  418. pViewEvent->m_rcEventMax.top = rcRect.top + nEventPlaceNumber * nEventHeight;
  419. pViewEvent->m_rcEventMax.bottom = pViewEvent->m_rcEventMax.top + nEventHeight;
  421. pViewEvent->m_rcEvent.top = pViewEvent->m_rcEventMax.top;
  422. pViewEvent->m_rcEvent.bottom = pViewEvent->m_rcEventMax.bottom;
  423. pViewEvent->m_rcEvent.left = pViewEvent->m_rcEventMax.left + 4 + 2;
  424. pViewEvent->m_rcEvent.right = pViewEvent->m_rcEventMax.right - 5 - 2;
  426. pViewEvent->m_rcToolTip.CopyRect(pViewEvent->m_rcEventMax);
  428. // adjust subject area
  429. int nDyx = pViewEvent->IsSelected() ? 5 : 2;
  431. pViewEvent->m_rcText.CopyRect(pViewEvent->m_rcEvent);
  432. pViewEvent->m_rcText.DeflateRect(nDyx + 3, 3, nDyx + 2, 3);
  434. // set times rects
  435. pViewEvent->m_rcStartTime.SetRectEmpty();
  436. pViewEvent->m_rcEndTime.SetRectEmpty();
  438. pViewEvent->m_rcSubjectEditor.CopyRect(pViewEvent->m_rcEvent);
  439. pViewEvent->m_rcSubjectEditor.top++;
  440. pViewEvent->m_rcSubjectEditor.bottom--;
  441. }
  443. void CXTPCalendarThemeOffice2007::CTOMonthView::Draw(CDC* pDC)
  444. {
  445. CXTPCalendarThemeOffice2007* pThemeX = DYNAMIC_DOWNCAST(CXTPCalendarThemeOffice2007, GetTheme());
  446. ASSERT(pThemeX);
  448. CXTPCalendarMonthView* pMonthView = DYNAMIC_DOWNCAST(CXTPCalendarMonthView,
  449. XTP_SAFE_GET2(GetTheme(), GetCalendarControl(), GetMonthView(), NULL));
  451. if (!pDC || !pMonthView || !pThemeX)
  452. {
  453. ASSERT(FALSE);
  454. return;
  455. }
  457. pDC->SetBkMode(TRANSPARENT);
  459. GetWeekHeaderPartX()->Draw(pMonthView, pDC);
  461. //TBase::Draw(pDC);
  463. GetWeekDayHeaderPart()->Draw(pMonthView, pDC);
  465. //CXTPPropsStateContext autoStateCnt1_day(GetDayPart(), xtpCalendarBeforeDraw_MonthViewDay, TRUE);
  466. CXTPPropsStateContext autoStateCnt1_day(GetDayPart(), 0, TRUE);
  468. //-- Draw Days with events ------------------------------
  469. int nCount = pMonthView->GetViewDayCount();
  470. int i;
  472. for (i = nCount - 1; i >= 0; i--)
  473. {
  474. CXTPCalendarMonthViewDay* pViewDay = pMonthView->GetViewDay(i);
  475. ASSERT(pViewDay);
  476. if (pViewDay)
  477. {
  478. GetDayPartX()->SetDynColors(pViewDay);
  480. autoStateCnt1_day.SendBeforeDrawThemeObject((LPARAM)pViewDay, xtpCalendarBeforeDraw_MonthViewDay);
  482. GetDayPart()->Draw(pViewDay, pDC);
  484. autoStateCnt1_day.RestoreState();
  485. }
  486. }
  487. autoStateCnt1_day.Clear();
  489. if (pThemeX->GetPrevNextEventControllerPartX())
  490. pThemeX->GetPrevNextEventControllerPartX()->Draw(NULL, pDC);
  492. // All saved data must be freed after draw!
  493. ASSERT(CXTPPropsState::s_dbg_nActiveStates == 0);
  494. }
  496. void CXTPCalendarThemeOffice2007::CTOMonthViewWeekDayHeader::RefreshMetrics(BOOL bRefreshChildren)
  497. {
  498. UNREFERENCED_PARAMETER(bRefreshChildren);
  500. CXTPCalendarThemeOffice2007* pThemeX = DYNAMIC_DOWNCAST(CXTPCalendarThemeOffice2007, GetTheme());
  501. ASSERT(pThemeX);
  502. if (!pThemeX)
  503. {
  504. return;
  505. }
  507. RefreshFromParent(pThemeX->GetHeaderPartX());
  509. m_clrBaseColor.SetStandardValue(pThemeX->GetColor2(_T("MonthViewWeekDayHeaderBk"), RGB(227, 239, 255)));
  511. m_bkNormal.nBitmapID.       SetStandardValue(0); //xtpIMG_MonthViewWeekDayHeader);
  512. m_bkSelected.nBitmapID.     SetStandardValue(0); //xtpIMG_MonthViewWeekDayHeader);
  513. m_bkToday.nBitmapID.        SetStandardValue(0); //xtpIMG_MonthViewWeekDayHeader);
  514. m_bkTodaySelected.nBitmapID.SetStandardValue(0); //xtpIMG_MonthViewWeekDayHeader);
  516. m_TextCenter.fcsetNormal.clrColor.SetStandardValue(pThemeX->GetColor2(_T("MonthViewWeekDayHeaderText"), RGB(101, 147, 201)));
  518. // 0 - Sunday, 1 - Monday, ...; 7 - Sat/Sun
  519. m_arWeekDayNamesLong.RemoveAll();
  520. m_arWeekDayNamesShort.RemoveAll();
  522. m_arWeekDayNamesLong.SetSize(8);
  523. m_arWeekDayNamesShort.SetSize(8);
  525. for (int i = 0; i < 7; i++)
  526. {
  527. CString sWDlong = CXTPCalendarUtils::GetLocaleString(LOCALE_SDAYNAME1 + i, 100);
  528. CString sWDshort = CXTPCalendarUtils::GetLocaleString(LOCALE_SABBREVDAYNAME1 + i, 100);
  530. m_arWeekDayNamesLong [(i + 1) % 7] = sWDlong;
  531. m_arWeekDayNamesShort[(i + 1) % 7] = sWDshort;
  532. }
  534. m_arWeekDayNamesLong [7] = m_arWeekDayNamesLong[6] + _T("/") + m_arWeekDayNamesLong[0];
  535. m_arWeekDayNamesShort[7] = m_arWeekDayNamesShort[6] + _T("/") + m_arWeekDayNamesShort[0];
  537. }
  539. void CXTPCalendarThemeOffice2007::CTOMonthViewWeekHeader::RefreshMetrics(BOOL bRefreshChildren)
  540. {
  541. UNREFERENCED_PARAMETER(bRefreshChildren);
  543. CXTPCalendarThemeOffice2007* pThemeX = DYNAMIC_DOWNCAST(CXTPCalendarThemeOffice2007, GetTheme());
  544. ASSERT(pThemeX);
  545. if (!pThemeX)
  546. {
  547. return;
  548. }
  550. RefreshFromParent(pThemeX->GetHeaderPartX());
  552. m_clrFreeSpaceBk.SetStandardValue(pThemeX->GetColor2(_T("MonthViewWeekHeaderFreeSpaceBk"), RGB(227, 239, 255)));
  554. m_bkNormal.nBitmapID.SetStandardValue(xtpIMG_MonthViewWeekHeader);
  555. m_bkSelected.nBitmapID.SetStandardValue(xtpIMG_MonthViewWeekHeader);
  556. m_bkToday.nBitmapID.SetStandardValue(xtpIMG_MonthViewWeekHeader);
  557. m_bkTodaySelected.nBitmapID.SetStandardValue(xtpIMG_MonthViewWeekHeader);
  559. LOGFONT lfVert;
  560. VERIFY( m_TextCenter.fcsetNormal.fntFont->GetLogFont(&lfVert) );
  561. lfVert.lfOrientation = 900;
  562. lfVert.lfEscapement = 900;
  563. if (XTPDrawHelpers()->FontExists(XTP_CALENDAR_OFFICE2007_FONT_NAME))
  564. {
  565. STRCPY_S(lfVert.lfFaceName, LF_FACESIZE, XTP_CALENDAR_OFFICE2007_FONT_NAME);
  566. }
  567. else
  568. {
  569. STRCPY_S(lfVert.lfFaceName, LF_FACESIZE, XTPDrawHelpers()->GetVerticalFontName(TRUE));
  570. }
  572. m_TextCenter.fcsetNormal.fntFont.SetStandardValue(&lfVert);
  573. m_TextCenter.fcsetNormal.clrColor.SetStandardValue(RGB(0, 0, 0)); //pThemeX->GetColor(xtpCLR_HeaderBorder));
  575. XTP_SAFE_CALL1(GetHeightFormulaPart(), SetStandardValue(13, 10, 1));
  576. }
  578. void CXTPCalendarThemeOffice2007::CTOMonthViewWeekDayHeader::AdjustLayout(
  579. CCmdTarget* pObject, CDC* pDC, const CRect& rcRect)
  580. {
  581. CXTPCalendarThemeOffice2007* pThemeX = DYNAMIC_DOWNCAST(CXTPCalendarThemeOffice2007, GetTheme());
  582. CXTPCalendarMonthView* pMonthView = DYNAMIC_DOWNCAST(CXTPCalendarMonthView, pObject);
  584. if (!pDC || !pThemeX || !pMonthView || !pMonthView->GetGrid())
  585. {
  586. ASSERT(FALSE);
  587. return;
  588. }
  589. CXTPCalendarMonthView::CMonthViewGrid* pGrid = pMonthView->GetGrid();
  590. int nColsCount = pGrid->GetColsCount();
  591. int nCellWidth = rcRect.Width() / max(1, nColsCount);
  593. int nHeaderHeight = CalcHeight(pDC, nCellWidth);
  594. pGrid->SetColHeaderHeight(nHeaderHeight);
  596. if (!nColsCount || m_arWeekDayNamesLong.GetSize() < 8 ||
  597. m_arWeekDayNamesShort.GetSize() < 8)
  598. {
  599. ASSERT(FALSE);
  600. return;
  601. }
  603. CString strDWMaxLong;
  604. for (int i = 0; i < 7; i++)
  605. {
  606. if (strDWMaxLong.GetLength() < m_arWeekDayNamesLong[i].GetLength())
  607. {
  608. strDWMaxLong = m_arWeekDayNamesLong[i];
  609. }
  610. }
  612. CXTPFontDC autoFont(pDC, m_TextCenter.fcsetNormal.Font());
  614. CSize szWDlong = pDC->GetTextExtent(strDWMaxLong);
  615. CSize szSaSuLong = pDC->GetTextExtent(m_arWeekDayNamesLong[7]);
  617. int nRectSize = nCellWidth;
  619. m_bWeekDayNamesLong = szWDlong.cx + szWDlong.cx/4 + nRectSize/5 < nRectSize;
  620. m_bWeekDayNameSaSuLong = szSaSuLong.cx + szSaSuLong.cx/4 + nRectSize/5 < nRectSize;
  621. }
  623. void CXTPCalendarThemeOffice2007::CTOMonthViewWeekDayHeader::Draw(CCmdTarget* pObject, CDC* pDC)
  624. {
  625. CXTPCalendarThemeOffice2007* pThemeX = DYNAMIC_DOWNCAST(CXTPCalendarThemeOffice2007, GetTheme());
  626. CXTPCalendarMonthView* pMonthView = DYNAMIC_DOWNCAST(CXTPCalendarMonthView, pObject);
  627. if (!pDC || !pThemeX || !pMonthView || !pMonthView->GetGrid())
  628. {
  629. ASSERT(FALSE);
  630. return;
  631. }
  632. CXTPCalendarMonthView::CMonthViewGrid* pGrid = pMonthView->GetGrid();
  634. CRect rcWDHeader = pMonthView->GetViewRect();
  635. rcWDHeader.bottom = rcWDHeader.top + pGrid->GetColHeaderHeight();
  637. CXTPPropsStateContext autoStateCnt1(this, xtpCalendarBeforeDraw_MonthViewWeekDayHeader, TRUE);
  638. autoStateCnt1.SendBeforeDrawThemeObject((LPARAM)-1);
  640. //===========================================
  641. CStringArray arColHeaderText;
  642. CUIntArray arWeekDays;
  643. arColHeaderText.SetSize(7);
  644. arWeekDays.SetSize(7);
  646. for (int i = 0; i < 7; i++)
  647. {
  648. int nCol = pGrid->GetWeekDayCol(i + 1);
  650. CString sVal = arColHeaderText[nCol];
  651. if (!sVal.IsEmpty())
  652. {
  653. // compressed col - always Sat/Sun
  654. arColHeaderText[nCol] = m_bWeekDayNameSaSuLong ? m_arWeekDayNamesLong[7] : m_arWeekDayNamesShort[7];
  655. arWeekDays[nCol] = 7;
  656. }
  657. else
  658. {
  659. CString sWD = m_bWeekDayNamesLong ? m_arWeekDayNamesLong[i] : m_arWeekDayNamesShort[i];
  660. arColHeaderText[nCol] = sWD;
  661. arWeekDays[nCol] = i + 1;
  662. }
  663. }
  665. CXTPPropsStateContext autoStateCnt2_wd(this, xtpCalendarBeforeDraw_MonthViewWeekDayHeader);
  666. //===========================================
  667. int nColsCount = pGrid->GetColsCount();
  668. for (int nCol = 0; nCol < nColsCount; nCol++)
  669. {
  670. CRect rcCell = pGrid->GetCelRect(0, nCol, TRUE);
  671. rcCell.top = rcWDHeader.top;
  672. rcCell.bottom = rcWDHeader.bottom;
  674. CString strWD = arColHeaderText[nCol];
  675. int nWeekDay = arWeekDays[nCol];
  677. autoStateCnt2_wd.SendBeforeDrawThemeObject((LPARAM)nWeekDay);
  679. //--------------------------------------------------------
  680. pMonthView->GetWeekDayTextIfNeed(&strWD, nWeekDay);
  682. Draw_Header(pDC, rcCell, 0, _T(""), strWD);
  684. if (nCol +1 < nColsCount)
  685. {
  686. CRect rcLine = rcCell;
  687. rcLine.left = rcLine.right - 1;
  688. rcLine.top += 2;
  689. pDC->FillSolidRect(rcLine, (COLORREF)m_TextCenter.fcsetNormal.clrColor);
  690. }
  692. //--------------------------------------------------------
  693. autoStateCnt2_wd.RestoreState();
  694. }
  695. autoStateCnt2_wd.Clear();
  696. }
  698. void CXTPCalendarThemeOffice2007::CTOMonthViewWeekHeader::AdjustLayout(CCmdTarget* pObject, CDC* pDC, const CRect& rcRect)
  699. {
  700. CXTPCalendarThemeOffice2007* pThemeX = DYNAMIC_DOWNCAST(CXTPCalendarThemeOffice2007, GetTheme());
  701. CXTPCalendarMonthView* pMonthView = DYNAMIC_DOWNCAST(CXTPCalendarMonthView, pObject);
  702. if (!pDC || !pThemeX || !pMonthView || !pMonthView->GetGrid())
  703. {
  704. ASSERT(FALSE);
  705. return;
  706. }
  708. //***
  709. m_rcHeader = rcRect;
  711. //***
  712. int nWeeksCount = pMonthView->GetGrid()->GetWeeksCount();
  713. if (!nWeeksCount)
  714. {
  715. return;
  716. }
  718. CXTPCalendarMonthViewDay* pViewDay = pMonthView->GetGrid()->GetViewDay(0, 0);
  719. ASSERT(pViewDay);
  720. if (!pViewDay)
  721. {
  722. return;
  723. }
  724. const CXTPCalendarViewDay::XTP_VIEW_DAY_LAYOUT& dayLayout = pThemeX->GetViewDayLayout(pViewDay);
  726. COleDateTime dtWDay1 = pViewDay->GetDayDate();
  728. CRect rcWHeaderTextVert = m_rcHeader;
  729. rcWHeaderTextVert.top = dayLayout.m_rcDayHeader.bottom;
  730. rcWHeaderTextVert.bottom = dayLayout.m_rcDay.bottom;
  732. //---
  733. CString strTmp, strCaptionLong;
  734. FormatWeekCaption(dtWDay1, strTmp, strCaptionLong, 2);
  736. CXTPFontDC autoFont(pDC, m_TextCenter.fcsetNormal.fntFont, m_TextCenter.fcsetNormal.clrColor);
  737. CSize szText1 = pDC->GetTextExtent(strCaptionLong);
  739. int nRectSize = abs(rcWHeaderTextVert.Height());
  741. m_bDateFormatShort = TRUE;
  742. if (szText1.cx + szText1.cx/3 + nRectSize/10 < nRectSize)
  743. {
  744. m_bDateFormatShort = FALSE;
  745. }
  746. }
  748. void CXTPCalendarThemeOffice2007::CTOMonthViewWeekDayHeader::Draw_Borders2(
  749. CDC* /*pDC*/, const CRect& /*rcRect*/, BOOL /*bDrawRightBorder*/)
  750. {
  752. }
  754. void CXTPCalendarThemeOffice2007::CTOMonthViewWeekHeader::DoPropExchange(CXTPPropExchange* pPX)
  755. {
  756. ASSERT(pPX);
  757. if (!pPX)
  758. return;
  760. CXTPPropExchangeSection secData(pPX->GetSection(_T("MonthViewWeekHeader")));
  761. if (pPX->IsStoring())
  762. secData->EmptySection();
  764. PX_Color(&secData, _T("FreeSpaceBkColor"), m_clrFreeSpaceBk);
  766. TBase::DoPropExchange(pPX);
  767. }
  769. void CXTPCalendarThemeOffice2007::CTOMonthViewWeekHeader::Serialize(CArchive& ar)
  770. {
  771. m_clrFreeSpaceBk.Serialize(ar);
  773. TBase::Serialize(ar);
  774. }
  776. void CXTPCalendarThemeOffice2007::CTOMonthViewWeekHeader::Draw(CCmdTarget* pObject, CDC* pDC)
  777. {
  778. CXTPCalendarThemeOffice2007* pThemeX = DYNAMIC_DOWNCAST(CXTPCalendarThemeOffice2007, GetTheme());
  779. CXTPCalendarMonthView* pMonthView = DYNAMIC_DOWNCAST(CXTPCalendarMonthView, pObject);
  780. if (!pDC || !pThemeX || !pMonthView || !pMonthView->GetGrid())
  781. {
  782. ASSERT(FALSE);
  783. return;
  784. }
  786. CXTPPropsStateContext autoStateCnt1(this, xtpCalendarBeforeDraw_MonthViewWeekHeader, TRUE);
  787. autoStateCnt1.SendBeforeDrawThemeObject((LPARAM)-1);
  789. pDC->FillSolidRect(&m_rcHeader, m_clrFreeSpaceBk);
  791. CXTPFontDC autoFont(pDC, m_TextCenter.fcsetNormal.fntFont, m_TextCenter.fcsetNormal.clrColor);
  793. CXTPPropsStateContext autoStateCnt2_week(this, xtpCalendarBeforeDraw_MonthViewWeekHeader);
  795. int nWeeksCount = pMonthView->GetGrid()->GetWeeksCount();
  796. for (int i = 0; i < nWeeksCount; i++)
  797. {
  798. CXTPCalendarMonthViewDay* pViewDay = pMonthView->GetGrid()->GetViewDay(i, 0);
  799. ASSERT(pViewDay);
  800. if (!pViewDay)
  801. {
  802. continue;
  803. }
  804. const CXTPCalendarViewDay::XTP_VIEW_DAY_LAYOUT& dayLayout = pThemeX->GetViewDayLayout(pViewDay);
  806. COleDateTime dtWDay1 = pViewDay->GetDayDate();
  808. CRect rcWHeader = m_rcHeader;
  809. rcWHeader.left+= 3;
  810. rcWHeader.top = dayLayout.m_rcDayHeader.bottom - 1;
  811. rcWHeader.bottom = dayLayout.m_rcDay.bottom;
  813. autoStateCnt2_week.SendBeforeDrawThemeObject((LPARAM)i);
  814. //--------------------------------------------------
  815. CString strWeekCaption;
  816. FormatWeekCaption(dtWDay1, strWeekCaption, strWeekCaption, m_bDateFormatShort ? 1 : 2);
  818. //--------------------------------------------------
  819. Draw_Background(pDC, rcWHeader, 0);
  821. Draw_TextCenter(pDC, rcWHeader, 0, strWeekCaption);
  824. if (i +1 < nWeeksCount)
  825. autoStateCnt2_week.RestoreState();
  826. }
  827. autoStateCnt2_week.Clear();
  828. }
  830. void CXTPCalendarThemeOffice2007::CTOMonthViewWeekHeader::Draw_TextCenter(CDC* pDC, const CRect& rcRect, int nState,
  831.  LPCTSTR pcszCenterText, int* pnWidth)
  832. {
  833. UNREFERENCED_PARAMETER(nState);
  834. UNREFERENCED_PARAMETER(pnWidth);
  836. // Warning: not supported.
  837. ASSERT(pnWidth == NULL);
  839. CRect rcWHeaderTextVert = rcRect;
  840. rcWHeaderTextVert.DeflateRect(1, 3, 1, 3);
  842. int nTmp = rcWHeaderTextVert.top;
  843. rcWHeaderTextVert.top = rcWHeaderTextVert.bottom;
  844. rcWHeaderTextVert.bottom = nTmp;
  846. int nRectSize = abs(rcWHeaderTextVert.Height());
  848. //---
  849. CSize szText = pDC->GetTextExtent(pcszCenterText);
  851. // Center text vertically
  852. if (szText.cx + 7 < nRectSize)
  853. {
  854. rcWHeaderTextVert.top = max(rcWHeaderTextVert.top - (nRectSize - szText.cx)/2, rcWHeaderTextVert.bottom);
  855. }
  857. pDC->DrawText(CString(pcszCenterText), &rcWHeaderTextVert, DT_NOPREFIX | DT_SINGLELINE); //| DT_NOCLIP
  858. }
  860. void CXTPCalendarThemeOffice2007::CTOMonthViewWeekHeader::FormatWeekCaption(COleDateTime dtWDay1,
  861. CString& rstrShort, CString& rstrLong, int nShort1Long2 )
  862. {
  863. //LOCALE_IDATE  -  short date format ordering
  864. // 0 Month-Day-Year
  865. // 1 Day-Month-Year
  866. // 2 Year-Month-Day
  868. int nDateOrdering = CXTPCalendarUtils::GetLocaleLong(LOCALE_IDATE);
  869. CString strDSeparator = CXTPCalendarUtils::GetLocaleString(LOCALE_SDATE, 100);
  871. // SHORT
  872. COleDateTime dtWDay6 = dtWDay1 + COleDateTimeSpan(6, 0, 0, 0);
  874. const int cnBuffSize = 128;
  876. TCHAR szWDay1[cnBuffSize], szMonth1[cnBuffSize];
  877. TCHAR szWDay6[cnBuffSize], szMonth6[cnBuffSize];
  879. ITOT_S(dtWDay1.GetDay(), szWDay1, cnBuffSize);
  880. ITOT_S(dtWDay6.GetDay(), szWDay6, cnBuffSize);
  882. if (nShort1Long2 == 0 || nShort1Long2 == 1)
  883. {
  884. ITOT_S(dtWDay1.GetMonth(), szMonth1, cnBuffSize);
  885. ITOT_S(dtWDay6.GetMonth(), szMonth6, cnBuffSize);
  887. rstrShort = _FormatWCaption(szWDay1, szMonth1, szWDay6, szMonth6, strDSeparator, nDateOrdering);
  888. }
  890. if (nShort1Long2 == 0 || nShort1Long2 == 2)
  891. {
  892. CString strMonth1 = CXTPCalendarUtils::GetLocaleString(LOCALE_SABBREVMONTHNAME1 + dtWDay1.GetMonth() - 1, 100);
  893. CString strMonth6 = CXTPCalendarUtils::GetLocaleString(LOCALE_SABBREVMONTHNAME1 + dtWDay6.GetMonth() - 1, 100);
  895. rstrLong = _FormatWCaption(szWDay1, strMonth1, szWDay6, strMonth6, _T(" "), nDateOrdering);
  896. }
  897. }
  899. CString CXTPCalendarThemeOffice2007::CTOMonthViewWeekHeader::_FormatWCaption(LPCTSTR pcszDay1, LPCTSTR pcszMonth1,
  900. LPCTSTR pcszDay6, LPCTSTR pcszMonth6,
  901. LPCTSTR pcszDayMonthSeparator, int nDateOrdering)
  902. {
  903. //LOCALE_IDATE  -  short date format ordering
  904. // 0 Month-Day-Year
  905. // 1 Day-Month-Year
  906. // 2 Year-Month-Day
  908. CString strCaption;
  909. if (_tcsicmp(pcszMonth1, pcszMonth6) == 0)
  910. {
  911. if (nDateOrdering == 1)
  912. {
  913. strCaption.Format(_T("%s - %s%s%s"), pcszDay1, pcszDay6,
  914.   pcszDayMonthSeparator, pcszMonth6);
  915. }
  916. else
  917. {
  918. strCaption.Format(_T("%s%s%s - %s"), pcszMonth1, pcszDayMonthSeparator,
  919.   pcszDay1, pcszDay6);
  920. }
  921. }
  922. else
  923. {
  924. if (nDateOrdering == 1)
  925. {
  926. strCaption.Format(_T("%s%s%s - %s%s%s"), pcszDay1, pcszDayMonthSeparator,
  927.   pcszMonth1, pcszDay6, pcszDayMonthSeparator, pcszMonth6);
  928. }
  929. else
  930. {
  931. strCaption.Format(_T("%s%s%s - %s%s%s"), pcszMonth1, pcszDayMonthSeparator,
  932.   pcszDay1, pcszMonth6, pcszDayMonthSeparator, pcszDay6);
  933. }
  934. }
  935. return strCaption;
  936. }
  938. void CXTPCalendarThemeOffice2007::CTOMonthViewDay::RefreshMetrics(BOOL bRefreshChildren)
  939. {
  940. CXTPCalendarThemeOffice2007* pThemeX = DYNAMIC_DOWNCAST(CXTPCalendarThemeOffice2007, GetTheme());
  941. ASSERT(pThemeX);
  942. if (!pThemeX)
  943. {
  944. return;
  945. }
  947. m_clrBorder.SetStandardValue(pThemeX->GetColor(xtpCLR_DayBorder));
  948. //m_clrTodayBorder.SetStandardValue(XTP_CALENDAR_OFFICE2007_TODAYBORDER);
  950. m_clrBackgroundLight.SetStandardValue(pThemeX->GetColor(xtpCLR_MonthViewDayBkLight));
  951. m_clrBackgroundDark.SetStandardValue(pThemeX->GetColor(xtpCLR_MonthViewDayBkDark));
  952. m_clrBackgroundSelected.SetStandardValue(pThemeX->GetColor(xtpCLR_MonthViewDayBkSelected));
  954. TBase::RefreshMetrics(bRefreshChildren);
  956. m_clrTodayBorder.SetStandardValue(GetHeaderPartX()->m_clrTodayBaseColor);
  957. }
  959. void CXTPCalendarThemeOffice2007::CTOMonthViewDay::SetDynColors(CXTPCalendarMonthViewDay* pMViewDay)
  960. {
  961. CXTPCalendarThemeOffice2007* pThemeX = DYNAMIC_DOWNCAST(CXTPCalendarThemeOffice2007, GetTheme());
  962. CXTPCalendarThemeOffice2007::CTOCellDynBackground* pCellDynBkPart =
  963. XTP_SAFE_GET1(pThemeX, GetCellDynBackgroundPart(), NULL);
  965. if (!pMViewDay || !pCellDynBkPart || !GetTheme() || !GetTheme()->GetColorsSetPart())
  966. {
  967. ASSERT(FALSE);
  968. return;
  969. }
  971. CXTPCalendarViewGroup* pViewGroup = pMViewDay->GetViewGroupsCount() ? pMViewDay->GetViewGroup_(0) : NULL;
  973. //--------------------------------------------------------------------
  974. CXTPCalendarTheme::XTP_BUSY_STATUS_CONTEXT bsColors;
  975. m_nDynBusyStatus = pCellDynBkPart->GetCellDynBackground(pViewGroup, pMViewDay->GetDayDate(), -1, bsColors);
  977. //--------------------------------------------------------------------
  978. m_clrDynHatch = 0;
  980. if (m_nDynBusyStatus == xtpCalendarBusyStatusBusy ||
  981.  m_nDynBusyStatus == xtpCalendarBusyStatusOutOfOffice ||
  982.  m_nDynBusyStatus == xtpCalendarBusyStatusTentative)
  983. {
  984. if (bsColors.clrBkAllDayEvents != 0 && bsColors.clrCellBorder != 0) // is Category or OutOfOffice
  985. {
  986. m_clrDynHatch = bsColors.clrBkAllDayEvents;
  988. if (m_nDynBusyStatus != xtpCalendarBusyStatusTentative)
  989. {
  990. m_clrBackgroundLight = bsColors.clrBkAllDayEvents;
  991. m_clrBackgroundDark = bsColors.clrBkAllDayEvents;
  992. m_clrBackgroundSelected = CXTPCalendarThemeOffice2007::PowerColor(bsColors.clrBkAllDayEvents, -7.5, 0.25);
  993. }
  994. }
  995. else
  996. {
  997. if (m_nDynBusyStatus == xtpCalendarBusyStatusBusy)
  998. {
  999. m_clrBackgroundLight = GetTheme()->GetColorsSetPart()->GetColor(xtpCLR_HeaderBorder); // 141, 174, 217
  1000. m_clrBackgroundDark = (COLORREF)m_clrBackgroundLight;
  1001. }
  1002. m_clrDynHatch = GetTheme()->GetColorsSetPart()->GetColor(xtpCLR_HeaderBorder); // 141, 174, 217;
  1003. }
  1004. }
  1005. }
  1007. void CXTPCalendarThemeOffice2007::CTOMonthViewDay::Draw(CCmdTarget* pObject, CDC* pDC)
  1008. {
  1009. CXTPCalendarThemeOffice2007* pThemeX = DYNAMIC_DOWNCAST(CXTPCalendarThemeOffice2007, GetTheme());
  1010. CXTPCalendarMonthViewDay* pMViewDay = DYNAMIC_DOWNCAST(CXTPCalendarMonthViewDay, pObject);
  1011. CXTPCalendarThemeOffice2007::CTOCellDynBackground* pCellDynBkPart =
  1012. XTP_SAFE_GET1(pThemeX, GetCellDynBackgroundPart(), NULL);
  1014. if (!pDC || !pThemeX || !pCellDynBkPart || !pMViewDay || !pMViewDay->GetView() ||
  1015. !pMViewDay->GetView()->GetGrid() || pMViewDay->GetViewGroupsCount() == 0 ||
  1016. !pMViewDay->GetViewGroup(0) || !pThemeX->GetCalendarControl())
  1017. {
  1018. ASSERT(FALSE);
  1019. return;
  1020. }
  1022. CXTPCalendarMonthView::CMonthViewGrid* pGrid = pMViewDay->GetView()->GetGrid();
  1023. CXTPCalendarMonthViewGroup* pMViewGroup = pMViewDay->GetViewGroup(0);
  1024. CXTPCalendarViewDay::XTP_VIEW_DAY_LAYOUT& dayLayout = CXTPCalendarTheme::GetViewDayLayout(pMViewDay);
  1026. CRect rcDay = dayLayout.m_rcDay;
  1027. CRect rcBorders = rcDay;
  1028. rcBorders.top = dayLayout.m_rcDayHeader.bottom;
  1030. COleDateTime dtDay = pMViewDay->GetDayDate();
  1031. COleDateTime dtNow = CXTPCalendarUtils::GetCurrentTime();
  1033. BOOL bIsToday = GetHeaderPart()->IsToday(pMViewDay);
  1034. BOOL bIsSelected = GetHeaderPart()->IsSelected(pMViewDay);
  1035. //-----------------
  1036. int nCurrentMonth = dtNow.GetMonth();
  1037. int nLiteBkColorIdx = nCurrentMonth % 2;
  1039. int nMonth = dtDay.GetMonth();
  1040. COLORREF clrBackground = nMonth % 2 == nLiteBkColorIdx ? m_clrBackgroundLight : m_clrBackgroundDark;
  1041. if (bIsSelected)
  1042. {
  1043. clrBackground = m_clrBackgroundSelected;
  1044. }
  1046. pDC->FillSolidRect(rcDay, clrBackground);
  1048. //--------------------------------------------------------------------
  1049. if (m_nDynBusyStatus == xtpCalendarBusyStatusTentative)
  1050. {
  1051. CXTPTextDC autoTxt(pDC, COLORREF_NULL, clrBackground);
  1052. CBrush br(HS_BDIAGONAL, m_clrDynHatch);
  1054. pDC->FillRect(&rcDay, &br);
  1055. }
  1056. //--------------------------------------------------------------------
  1058. if (bIsToday)
  1059. {
  1060. CXTPCalendarTheme::DrawRectPartly(pDC, rcBorders, m_clrTodayBorder, 2, CRect(1, 0, 1, 1));
  1061. CXTPCalendarTheme::DrawRectPartly(pDC, rcBorders, m_clrBorder, 1, CRect(0, 0, 1, 0));
  1062. }
  1063. else
  1064. {
  1065. int nColIdx = pGrid->GetWeekDayCol(dtDay.GetDayOfWeek());
  1066. int nIsLBorder = nColIdx == 0 ? 1 : 0;
  1068. CXTPCalendarTheme::DrawRectPartly(pDC, rcBorders, m_clrBorder, 1, CRect(nIsLBorder, 0, 1, 0));
  1069. CXTPCalendarTheme::DrawRectPartly(pDC, rcBorders, m_clrBorder, 2, CRect(0, 0, 0, 1));
  1070. }
  1071. //------------------
  1072. GetHeaderPart()->Draw(pMViewDay, pDC);
  1074. //=====================
  1075. BOOL bCnt_EvS = FALSE;
  1076. BOOL bCnt_EvMul = FALSE;
  1078. CXTPPropsStateContext autoStateCnt_EvS;
  1079. CXTPPropsStateContext autoStateCnt_EvMul;
  1081. int nCount = pMViewGroup->GetViewEventsCount();
  1082. for (int i = 0; i < nCount; i++)
  1083. {
  1084. CXTPCalendarViewEvent* pViewEvent = pMViewGroup->GetViewEvent_(i);
  1085. ASSERT(pViewEvent);
  1086. if (pViewEvent && pViewEvent->IsVisible())
  1087. {
  1088. if (pViewEvent->IsMultidayEvent())
  1089. {
  1090. if (!bCnt_EvMul)
  1091. autoStateCnt_EvMul.SetData(GetMultiDayEventPartX(), xtpCalendarBeforeDraw_MonthViewEvent, TRUE);
  1092. bCnt_EvMul = TRUE;
  1094. autoStateCnt_EvMul.SendBeforeDrawThemeObject((LPARAM)pViewEvent);
  1096. GetMultiDayEventPartX()->Draw(pViewEvent, pDC);
  1098. autoStateCnt_EvMul.RestoreState();
  1099. }
  1100. else
  1101. {
  1102. if (!bCnt_EvS)
  1103. autoStateCnt_EvS.SetData(GetSingleDayEventPartX(), xtpCalendarBeforeDraw_MonthViewEvent, TRUE);
  1104. bCnt_EvS = TRUE;
  1106. autoStateCnt_EvS.SendBeforeDrawThemeObject((LPARAM)pViewEvent);
  1108. GetSingleDayEventPartX()->Draw(pViewEvent, pDC);
  1110. autoStateCnt_EvS.RestoreState();
  1111. }
  1112. }
  1113. }
  1115. if (!pDC->IsPrinting() && pMViewDay->NoAllEventsAreVisible())
  1116. {
  1117. CRect rc = dayLayout.m_rcDay;
  1118. rc.right -= 5;
  1119. rc.bottom -= 5;
  1121. BOOL bHot = HitTestExpandDayButton(pMViewDay) != 0;
  1123. dayLayout.m_rcExpandSign = pThemeX->DrawExpandDayButton(pDC, rc, FALSE, bHot);
  1125. if (bHot)
  1126. dayLayout.m_nHotState |= CXTPCalendarViewDay::XTP_VIEW_DAY_LAYOUT::xtpHotExpandButton;
  1127. else
  1128. dayLayout.m_nHotState &= ~CXTPCalendarViewDay::XTP_VIEW_DAY_LAYOUT::xtpHotExpandButton;
  1129. }
  1131. autoStateCnt_EvS.Clear();
  1132. autoStateCnt_EvMul.Clear();
  1133. }
  1135. void CXTPCalendarThemeOffice2007::CTOMonthViewDay::OnMouseMove(CCmdTarget* pObject, UINT nFlags, CPoint point)
  1136. {
  1137. UNREFERENCED_PARAMETER(nFlags);
  1139. CXTPCalendarThemeOffice2007* pThemeX = DYNAMIC_DOWNCAST(CXTPCalendarThemeOffice2007, GetTheme());
  1140. CXTPCalendarMonthViewDay* pMViewDay = DYNAMIC_DOWNCAST(CXTPCalendarMonthViewDay, pObject);
  1141. if (!pThemeX || !pMViewDay || !pThemeX->GetCalendarControl())
  1142. {
  1143. ASSERT(FALSE);
  1144. return;
  1145. }
  1147. CXTPCalendarViewDay::XTP_VIEW_DAY_LAYOUT& dayLayout = CXTPCalendarTheme::GetViewDayLayout(pMViewDay);
  1149. if (pMViewDay->NoAllEventsAreVisible())
  1150. {
  1151. BOOL bHot = pThemeX->ExpandDayButton_HitTest(point, dayLayout.m_rcExpandSign, FALSE);
  1152. BOOL bHotPrev = !!(dayLayout.m_nHotState & CXTPCalendarViewDay::XTP_VIEW_DAY_LAYOUT::xtpHotExpandButton);
  1154. if (bHot != bHotPrev)
  1155. {
  1156. CXTPCalendarControl::CUpdateContext updateContext(pThemeX->GetCalendarControl(), xtpCalendarUpdateRedraw);
  1157. }
  1158. }
  1160. BOOL bHotPrev = !!(dayLayout.m_nHotState & CXTPCalendarViewDay::XTP_VIEW_DAY_LAYOUT::xtpHotDayHeader);
  1161. if (dayLayout.m_rcDayHeader.PtInRect(point) != bHotPrev)
  1162. {
  1163. CXTPCalendarControl::CUpdateContext updateContext(pThemeX->GetCalendarControl(), xtpCalendarUpdateRedraw);
  1164. }
  1165. }
  1167. BOOL CXTPCalendarThemeOffice2007::CTOMonthViewDay::OnLButtonDown(CCmdTarget* pObject, UINT nFlags, CPoint point)
  1168. {
  1169. UNREFERENCED_PARAMETER(nFlags);
  1171. CXTPCalendarThemeOffice2007* pThemeX = DYNAMIC_DOWNCAST(CXTPCalendarThemeOffice2007, GetTheme());
  1172. CXTPCalendarMonthViewDay* pMViewDay = DYNAMIC_DOWNCAST(CXTPCalendarMonthViewDay, pObject);
  1173. if (!pThemeX || !pMViewDay || !pThemeX->GetCalendarControl())
  1174. {
  1175. ASSERT(FALSE);
  1176. return FALSE;
  1177. }
  1178. CXTPCalendarViewDay::XTP_VIEW_DAY_LAYOUT& dayLayout = CXTPCalendarTheme::GetViewDayLayout(pMViewDay);
  1180. if (pThemeX->ExpandDayButton_HitTest(point, dayLayout.m_rcExpandSign, FALSE))
  1181. {
  1182. pThemeX->GetCalendarControl()->PostMessage(xtp_wm_UserAction,
  1183. (WPARAM)(xtpCalendarUserAction_OnExpandDay | xtpCalendarExpandDayButton_MonthView),
  1184. (LPARAM)(LONG)(DATE)pMViewDay->GetDayDate());
  1186. return TRUE;
  1187. }
  1189. return FALSE;
  1190. }
  1192. void CXTPCalendarThemeOffice2007::CTOMonthViewDay::DoPropExchange(CXTPPropExchange* pPX)
  1193. {
  1194. ASSERT(pPX);
  1195. if (!pPX)
  1196. return;
  1198. CXTPPropExchangeSection secData(pPX->GetSection(_T("MonthViewDay")));
  1199. if (pPX->IsStoring())
  1200. secData->EmptySection();
  1202. PX_Color(&secData, _T("BorderColor"),       m_clrBorder);
  1203. PX_Color(&secData, _T("TodayBorderColor"),  m_clrTodayBorder);
  1205. PX_Color(&secData, _T("BackgroundLightColor"),   m_clrBackgroundLight);
  1206. PX_Color(&secData, _T("BackgroundDarkColor"),    m_clrBackgroundDark);
  1207. PX_Color(&secData, _T("BackgroundSelectedColor"), m_clrBackgroundSelected);
  1209. TBase::DoPropExchange(&secData);
  1210. }
  1212. void CXTPCalendarThemeOffice2007::CTOMonthViewDay::Serialize(CArchive& ar)
  1213. {
  1214. m_clrBorder.Serialize(ar);
  1215. m_clrTodayBorder.Serialize(ar);
  1217. m_clrBackgroundLight.Serialize(ar);
  1218. m_clrBackgroundDark.Serialize(ar);
  1219. m_clrBackgroundSelected.Serialize(ar);
  1221. TBase::Serialize(ar);
  1222. }
  1224. void CXTPCalendarThemeOffice2007::CTOMonthViewDayHeader::RefreshMetrics(BOOL bRefreshChildren)
  1225. {
  1226. UNREFERENCED_PARAMETER(bRefreshChildren);
  1228. CXTPCalendarThemeOffice2007* pThemeX = DYNAMIC_DOWNCAST(CXTPCalendarThemeOffice2007, GetTheme());
  1229. ASSERT(pThemeX);
  1230. if (!pThemeX)
  1231. {
  1232. return;
  1233. }
  1235. RefreshFromParent(pThemeX->GetMonthViewPartX()->GetHeaderPartX());
  1237. //  m_clrTodayBaseColor.SetStandardValue(pThemeX->GetHeaderPartX()->m_clrTodayBaseColor);
  1238. m_bkNormal.nBitmapID.SetStandardValue(xtpIMG_MonthViewDayHeader);
  1239. m_bkSelected.nBitmapID.SetStandardValue(xtpIMG_MonthViewDayHeader);
  1240. m_bkToday.nBitmapID.SetStandardValue(xtpIMG_MonthViewDayHeaderToday);
  1241. m_bkTodaySelected.nBitmapID.SetStandardValue(xtpIMG_MonthViewDayHeaderToday);
  1243. m_bkToday.rcBitmapBorder.        SetStandardValue(CRect(1, 1, 2, 1));
  1244. m_bkTodaySelected.rcBitmapBorder.SetStandardValue(CRect(1, 1, 2, 1));
  1245. }
  1247. void CXTPCalendarThemeOffice2007::CTOMonthViewDayHeader::Draw(CCmdTarget* pObject, CDC* pDC)
  1248. {
  1249. CXTPCalendarThemeOffice2007* pThemeX = DYNAMIC_DOWNCAST(CXTPCalendarThemeOffice2007, GetTheme());
  1250. CXTPCalendarMonthViewDay* pMViewDay = DYNAMIC_DOWNCAST(CXTPCalendarMonthViewDay, pObject);
  1251. if (!pDC || !pThemeX || !pMViewDay || !pThemeX->GetCalendarControl() ||
  1252. !pMViewDay->GetView() || !pMViewDay->GetView()->GetGrid())
  1253. {
  1254. ASSERT(FALSE);
  1255. return;
  1256. }
  1257. CXTPCalendarViewDay::XTP_VIEW_DAY_LAYOUT& dayLayout = CXTPCalendarTheme::GetViewDayLayout(pMViewDay);
  1258. COleDateTime dtDay = pMViewDay->GetDayDate();
  1259. BOOL bCompressWeD = XTP_SAFE_GET3(pMViewDay, GetView(), GetCalendarControl(), MonthView_IsCompressWeekendDays(), FALSE);
  1261. BOOL bIsToday    = IsToday(pMViewDay);
  1262. BOOL bIsSelected = IsSelected(pMViewDay);
  1264. int nDImod7 = pMViewDay->GetDayIndex() % 7;
  1265. BOOL bFirstDay = nDImod7 == 0 || (nDImod7 == 6 && bCompressWeD);
  1266. BOOL bLastDay = nDImod7 >= (bCompressWeD ? 5 : 6);
  1268. CPoint pt(0, 0);
  1269. if (pThemeX->GetCalendarControl()->GetSafeHwnd() && GetCursorPos(&pt))
  1270. pThemeX->GetCalendarControl()->ScreenToClient(&pt);
  1272. int nFlags = bIsToday ? CTOHeader::xtpCalendarItemState_Today : CTOHeader::xtpCalendarItemState_Normal;
  1273. nFlags |= bIsSelected ? CTOHeader::xtpCalendarItemState_Selected : 0;
  1274. if (dayLayout.m_rcDayHeader.PtInRect(pt))
  1275. {
  1276. nFlags |=  CTOHeader::xtpCalendarItemState_Hot;
  1277. dayLayout.m_nHotState |= CXTPCalendarViewDay::XTP_VIEW_DAY_LAYOUT::xtpHotDayHeader;
  1278. }
  1279. else
  1280. {
  1281. dayLayout.m_nHotState &= ~CXTPCalendarViewDay::XTP_VIEW_DAY_LAYOUT::xtpHotDayHeader;
  1282. }
  1284. nFlags |= bFirstDay ? CTOHeader::xtpCalendarItemFirst : 0;
  1285. nFlags |= bLastDay ? CTOHeader::xtpCalendarItemLast : 0;
  1287. CRect rcRect = dayLayout.m_rcDay;
  1289. //***
  1290. rcRect.bottom = dayLayout.m_rcDayHeader.bottom;
  1292. CString strTextLeft;
  1293. CString strTextCenter;
  1294. CString strTextRight;
  1296. int nMonth = dtDay.GetMonth();
  1297. int nDay = dtDay.GetDay();
  1299. if (nDay == 1 || pMViewDay->GetDayIndex() == 0)
  1300. {
  1301. CString strMonth = CXTPCalendarUtils::GetLocaleString(LOCALE_SABBREVMONTHNAME1 + nMonth - 1, 100);
  1303. //LOCALE_IDATE  -  short date format ordering
  1304. // 0 Month-Day-Year
  1305. // 1 Day-Month-Year
  1306. // 2 Year-Month-Day
  1307. int nDateOrdering = CXTPCalendarUtils::GetLocaleLong(LOCALE_IDATE);
  1309. if (nDateOrdering == 1)
  1310. {
  1311. strTextLeft.Format(_T("%d %s"), nDay, (LPCTSTR)strMonth);
  1312. }
  1313. else
  1314. {
  1315. strTextLeft.Format(_T("%s %d"), (LPCTSTR)strMonth, nDay);
  1316. }
  1317. }
  1318. else
  1319. {
  1320. strTextLeft.Format(_T("%d"), nDay);
  1321. }
  1323. //------------------------------------------------------
  1324. pThemeX->GetItemTextIfNeed(xtpCalendarItemText_MonthViewDayHeaderLeft, &strTextLeft, pMViewDay);
  1325. pThemeX->GetItemTextIfNeed(xtpCalendarItemText_MonthViewDayHeaderCenter, &strTextCenter, pMViewDay);
  1326. pThemeX->GetItemTextIfNeed(xtpCalendarItemText_MonthViewDayHeaderRight, &strTextRight, pMViewDay);
  1327. //------------------------------------------------------
  1329. Draw_Header(pDC, rcRect, nFlags, strTextLeft, strTextCenter, strTextRight);
  1330. }
  1332. void CXTPCalendarThemeOffice2007::CTOMonthViewEvent_MultiDay::Draw_Time(CDC* pDC, const CRect& rcEventRect,
  1333. CXTPCalendarMonthViewEvent* pViewEvent)
  1334. {
  1335. if (!pDC || !pViewEvent || !pViewEvent->GetEvent())
  1336. {
  1337. ASSERT(FALSE);
  1338. return;
  1339. }
  1341. BOOL bSelected = pViewEvent->IsSelected();
  1343. CFont* pFont = bSelected ? m_fcsetSelected.fcsetStartEnd.Font() : m_fcsetNormal.fcsetStartEnd.Font();
  1344. COLORREF clrColor = bSelected ? m_fcsetSelected.fcsetStartEnd.Color() : m_fcsetNormal.fcsetStartEnd.Color();
  1346. CXTPFontDC autoFont(pDC, pFont, clrColor);
  1348. //--------------------------
  1349. COleDateTime dtStart(pViewEvent->GetEvent()->GetStartTime());
  1350. COleDateTime dtEnd(pViewEvent->GetEvent()->GetEndTime());
  1352. //*****************
  1353. // not implemented for office 2007 theme.
  1354. //if (pViewEvent->IsTimeAsClock()) {}
  1355. //*****************
  1357. CString strStartTime = pViewEvent->GetItemTextStartTime();
  1358. CString strEndTime = pViewEvent->GetItemTextEndTime();
  1360. CSize szStart = pDC->GetTextExtent(strStartTime);
  1361. CSize szEnd = pDC->GetTextExtent(strEndTime);
  1363. CRect rcStart(rcEventRect);
  1364. CRect rcEnd(rcEventRect);
  1366. BOOL bDrawStartEndTimes = szStart.cx + szEnd.cx + 6 * 2 < rcEventRect.Width()/2;
  1368. if (!bDrawStartEndTimes)
  1369. {
  1370. return;
  1371. }
  1373. rcStart.left = min(rcStart.left + 6, rcStart.right);
  1374. rcStart.right = min(rcStart.left + szStart.cx + 2, rcStart.right);
  1376. rcEnd.right = max(rcEnd.right - 6, rcEventRect.left);
  1377. rcEnd.left = max(rcEnd.right - szEnd.cx - 2, rcEventRect.left);
  1379. //-------------------------------------------------
  1380. UINT uAlign = DT_VCENTER | DT_SINGLELINE ;
  1381. pDC->DrawText(strStartTime, &rcStart, uAlign | DT_LEFT);
  1382. pDC->DrawText(strEndTime, &rcEnd, uAlign | DT_RIGHT);
  1384. //-------------------------------------------------
  1385. pViewEvent->m_rcStartTime.CopyRect(&rcStart);
  1386. pViewEvent->m_rcEndTime.CopyRect(&rcEnd);
  1388. pViewEvent->m_rcText.left = rcStart.right;
  1389. pViewEvent->m_rcText.right = rcEnd.left;
  1390. }
  1392. void CXTPCalendarThemeOffice2007::CTOMonthViewEvent_MultiDay::Draw(CCmdTarget* pObject, CDC* pDC)
  1393. {
  1394. CXTPCalendarThemeOffice2007* pThemeX = DYNAMIC_DOWNCAST(CXTPCalendarThemeOffice2007, GetTheme());
  1395. CXTPCalendarMonthViewEvent* pViewEvent = DYNAMIC_DOWNCAST(CXTPCalendarMonthViewEvent, pObject);
  1397. CXTPCalendarMonthViewDay* pMVDay = XTP_SAFE_GET2(pViewEvent, GetViewGroup(), GetViewDay(), NULL);
  1398. CXTPCalendarMonthView* pMView = XTP_SAFE_GET1(pMVDay, GetView(), NULL);
  1400. if (!pDC || !pThemeX || !pViewEvent || !pViewEvent->GetEvent() ||
  1401. !pMView || !pMVDay)
  1402. {
  1403. ASSERT(FALSE);
  1404. return;
  1405. }
  1407. BOOL bNoVisibleMDEvent = pViewEvent->IsMultidayEvent() && !pViewEvent->IsVisible();
  1409. int nMDEFlags = pViewEvent->GetMultiDayEventFlags();
  1410. if ((nMDEFlags & xtpCalendarMultiDaySlave) || bNoVisibleMDEvent)
  1411. {
  1412. return;// was drawn in the Master (or out of events rect)
  1413. }
  1415. CRect rcEventMax(pViewEvent->GetViewEventRectMax());
  1416. CRect rcEvent(pViewEvent->GetEventRect());
  1417. if (rcEvent.IsRectEmpty())
  1418. {
  1419. return;
  1420. }
  1422. // fill event background
  1423. BOOL bSelected = pViewEvent->IsSelected();
  1424. COLORREF clrBorderNotSel;
  1425. COLORREF clrBorder;
  1426. CXTPPaintManagerColorGradient grclrBk;
  1428. GetEventColors(pDC, pViewEvent, clrBorder, clrBorderNotSel, grclrBk);
  1430. //----------------
  1431. pThemeX->DrawRoundRect(pDC, rcEvent, clrBorder, bSelected, grclrBk);
  1433. int nSelOffset = bSelected ? 2 : 1;
  1435. if (nMDEFlags & xtpCalendarMultiDayFirst)
  1436. pThemeX->_DrawEventLTHighlight(pDC, CPoint(rcEvent.left + nSelOffset, rcEvent.top + nSelOffset),
  1437.   rcEvent.right - nSelOffset, grclrBk, cnCornerSize / 2, rcEvent.bottom);
  1439. //------------------
  1440. int nViewDayIndex = pMVDay->GetDayIndex();
  1442. BOOL bCompressWD = XTP_SAFE_GET2(pViewEvent, GetCalendarControl(), MonthView_IsCompressWeekendDays(), FALSE);
  1443. int nLastDayDx = bCompressWD ? 1 : 7;
  1445. BOOL bFirstOnScreen = nViewDayIndex == 0;
  1446. BOOL bLastOnScreen = nViewDayIndex == (pMView->GetViewDayCount() - nLastDayDx);
  1448. CRect rcText(pViewEvent->GetTextRect());
  1450. if ((nMDEFlags & xtpCalendarMultiDayFirst) == 0)
  1451. {
  1452. CRect rcSQ = rcEventMax;
  1453. rcSQ.right = min(rcEvent.left + cnCornerSize, rcEventMax.right);
  1454. CXTPCalendarTheme::DrawRectPartly(pDC, rcSQ, clrBorder, bSelected, grclrBk, CRect(1,1,0,1));
  1456. pThemeX->_DrawEventLTHighlight(pDC, CPoint(rcEvent.left + nSelOffset, rcEvent.top + nSelOffset),
  1457.   rcEvent.right - nSelOffset, grclrBk, 0, rcEvent.bottom - nSelOffset);
  1458. //-------------------------------------------------------------------
  1459. if (bFirstOnScreen)
  1460. {
  1461. CRect rcArrow;
  1462. BOOL bArrow = Draw_ArrowL(pViewEvent, pDC, rcArrow);
  1463. if (bArrow)
  1464. rcText.left = rcArrow.right;
  1465. }
  1466. }
  1467. else if (bSelected)
  1468. {
  1469. // draw left Gripper
  1470. CRect rcGripper;
  1471. rcGripper.top = rcEvent.top + rcEvent.Height() / 2 - cnGripperSize / 2;
  1472. rcGripper.bottom = rcGripper.top + cnGripperSize;
  1473. rcGripper.left = rcEvent.left - 1;
  1474. rcGripper.right = rcGripper.left + cnGripperSize;
  1476. pDC->FillSolidRect(&rcGripper, m_clrGripperBackground);
  1477. CBrush brBorder(m_clrGripperBorder);
  1478. pDC->FrameRect(&rcGripper, &brBorder);
  1479. }
  1482. if ((nMDEFlags & xtpCalendarMultiDayLast) == 0)
  1483. {
  1484. CRect rcSQ = rcEventMax;
  1485. rcSQ.left = max(rcEvent.right - cnCornerSize, rcEventMax.left);
  1486. CXTPCalendarTheme::DrawRectPartly(pDC, rcSQ, clrBorder, bSelected, grclrBk, CRect(0,1,1,1));
  1488. pThemeX->_DrawEventLTHighlight(pDC, CPoint(rcSQ.left, rcEvent.top + nSelOffset),
  1489.   rcEventMax.right - nSelOffset, grclrBk, 0, INT_MAX, FALSE);
  1490. //-------------------------------------------------------------------
  1491. if (bLastOnScreen)
  1492. {
  1493. CRect rcArrow;
  1494. BOOL bArrow = Draw_ArrowR(pViewEvent, pDC, rcArrow);
  1495. if (bArrow)
  1496. rcText.right = rcArrow.left;
  1497. }
  1498. }
  1499. else if (bSelected)
  1500. {
  1501. // draw right gripper
  1502. CRect rcGripper;
  1503. rcGripper.top = rcEvent.top + rcEvent.Height() / 2 - cnGripperSize / 2;
  1504. rcGripper.bottom = rcGripper.top + cnGripperSize;
  1505. rcGripper.right = rcEvent.right + 1;
  1506. rcGripper.left = rcGripper.right - cnGripperSize;
  1508. pDC->FillSolidRect(&rcGripper, m_clrGripperBackground);
  1509. CBrush brBorder(m_clrGripperBorder);
  1510. pDC->FrameRect(&rcGripper, &brBorder);
  1511. }
  1513. int nMDFirstLastMask = (xtpCalendarMultiDayFirst|xtpCalendarMultiDayLast);
  1514. if ((nMDEFlags & nMDFirstLastMask) == nMDFirstLastMask)
  1515. {
  1516. COleDateTime dtStart = pViewEvent->GetEvent()->GetStartTime();
  1517. COleDateTime dtEnd = pViewEvent->GetEvent()->GetEndTime();
  1519. if (!CXTPCalendarUtils::IsZeroTime(dtStart) && !CXTPCalendarUtils::IsZeroTime(dtEnd))
  1520. {
  1521. Draw_Time(pDC, rcEvent, pViewEvent);
  1522. rcText = pViewEvent->GetTextRect();
  1523. }
  1524. }
  1526. //****
  1527. pViewEvent->m_rcText.CopyRect(rcText);
  1529. //=====================================
  1530. CThemeFontColorSet* pFntClr1 = bSelected ? &m_fcsetSelected.fcsetSubject : &m_fcsetNormal.fcsetSubject;
  1531. CThemeFontColorSet* pFntClr2 = bSelected ? &m_fcsetSelected.fcsetLocation : &m_fcsetNormal.fcsetLocation;
  1533. rcText.DeflateRect(3, 0, 3, 0);
  1535. pViewEvent->m_rcSubjectEditor.CopyRect(rcText);
  1536. pViewEvent->m_rcSubjectEditor.top = rcEvent.top + 2;
  1537. pViewEvent->m_rcSubjectEditor.bottom = rcEvent.bottom - 2;
  1538. pViewEvent->AdjustSubjectEditor();
  1540. CRect rcIconsMax = rcText;
  1541. rcIconsMax.left = min(rcIconsMax.left + rcText.Height(), rcIconsMax.right);
  1543. //
  1544. BOOL bMarkupDrawn = FALSE;
  1545. if (pThemeX->GetCalendarControl()->IsMarkupEnabled())
  1546. {
  1547. CXTPMarkupContext* pMarkupContext = pThemeX->GetCalendarControl()->GetMarkupContext();
  1548. ASSERT(pMarkupContext);
  1550. CXTPMarkupUIElement* pUIElement = pViewEvent->GetMarkupUIElement();
  1552. if (pUIElement && pMarkupContext)
  1553. {
  1554. CSize szIcons = Draw_Icons(pViewEvent, pDC, rcIconsMax, TRUE);
  1556. if (rcIconsMax.Height() > szIcons.cy)
  1557. {
  1558. rcIconsMax.bottom -= (rcIconsMax.Height() - szIcons.cy) / 2 + 1;
  1559. }
  1561. rcText.right = max(rcText.left,  rcText.right - szIcons.cx - 2);
  1563. //---------------------------------------------------------------
  1565. XTPMarkupSetDefaultFont(pMarkupContext, (HFONT)pFntClr1->Font()->GetSafeHandle(), pFntClr1->Color());
  1567. XTPMarkupRenderElement(pUIElement, pDC->GetSafeHdc(), rcText);
  1569. bMarkupDrawn = TRUE;
  1570. }
  1571. }
  1572. //
  1574. //----------------------------------------------------
  1575. if (!bMarkupDrawn)
  1576. {
  1577. CString strSubj = pViewEvent->GetItemTextSubject();
  1578. CString strLoc = pViewEvent->GetItemTextLocation();
  1580. if (!strLoc.IsEmpty())
  1581. {
  1582. strSubj += _T(";");
  1583. }
  1585. //----------------------------------------------------
  1586. UINT uTextShortAlign = DT_VCENTER | DT_LEFT;
  1587. CSize szText = pThemeX->DrawLine2_CenterLR(pDC, strSubj, strLoc, pFntClr1, pFntClr2,
  1588. rcText, uTextShortAlign | DT_CALCRECT);
  1590. //--- calculate rects and fix to be centered if enough space ---
  1591. CSize szIcons = Draw_Icons(pViewEvent, pDC, rcIconsMax, TRUE);
  1593. if (rcIconsMax.Height() > szIcons.cy)
  1594. {
  1595. rcIconsMax.bottom -= (rcIconsMax.Height() - szIcons.cy) / 2;
  1596. }
  1598. int nTIcx = szText.cx + szIcons.cx;
  1599. if (nTIcx + 5 < rcText.Width())
  1600. {
  1601. int ncx_2 = (rcText.Width() - nTIcx) / 2 - 2;
  1602. rcText.left += ncx_2;
  1603. rcText.right = rcText.left + szText.cx + 2;
  1605. rcIconsMax.right -= ncx_2;
  1606. }
  1607. else
  1608. {
  1609. rcText.right -= szIcons.cx + 2;
  1610. }
  1612. pThemeX->DrawLine2_CenterLR(pDC, strSubj, strLoc, pFntClr1, pFntClr2,
  1613. rcText, uTextShortAlign);
  1614. }
  1616. Draw_Icons(pViewEvent, pDC, rcIconsMax);
  1617. }
  1619. void CXTPCalendarThemeOffice2007::CTOMonthViewEvent_SingleDay::Draw(CCmdTarget* pObject, CDC* pDC)
  1620. {
  1621. CXTPCalendarThemeOffice2007* pThemeX = DYNAMIC_DOWNCAST(CXTPCalendarThemeOffice2007, GetTheme());
  1622. CXTPCalendarMonthViewEvent* pViewEvent = DYNAMIC_DOWNCAST(CXTPCalendarMonthViewEvent, pObject);
  1623. if (!pDC || !pThemeX || !pViewEvent)
  1624. {
  1625. ASSERT(FALSE);
  1626. return;
  1627. }
  1629. if (!pViewEvent->IsVisible())
  1630. {
  1631. return;
  1632. }
  1634. CRect rcEvent(pViewEvent->GetEventRect());
  1635. if (rcEvent.IsRectEmpty())
  1636. {
  1637. return;
  1638. }
  1640. // fill event background
  1641. Draw_Background(pDC, rcEvent, pViewEvent);
  1643. //
  1644. BOOL bMarkupDrawn = FALSE;
  1645. if (pThemeX->GetCalendarControl()->IsMarkupEnabled())
  1646. {
  1647. CXTPMarkupContext* pMarkupContext = pThemeX->GetCalendarControl()->GetMarkupContext();
  1648. ASSERT(pMarkupContext);
  1650. CXTPMarkupUIElement* pUIElement = pViewEvent->GetMarkupUIElement();
  1652. if (pUIElement && pMarkupContext)
  1653. {
  1654. BOOL bSelected = pViewEvent->IsSelected();
  1655. CThemeFontColorSet* pFntClr1 = bSelected ? &m_fcsetSelected.fcsetSubject : &m_fcsetNormal.fcsetSubject;
  1657. CRect rcText = rcEvent;
  1658. rcText.DeflateRect(3, 2, 3, 2);
  1659. CRect rcIconsMax = rcText;
  1661. CSize szIcons = Draw_Icons(pViewEvent, pDC, rcIconsMax, TRUE);
  1663. if (rcIconsMax.Height() > szIcons.cy)
  1664. {
  1665. rcIconsMax.bottom -= (rcIconsMax.Height() - szIcons.cy) / 2 + 1;
  1666. }
  1668. rcText.right = max(rcText.left,  rcText.right - szIcons.cx - 2);
  1670. //---------------------------------------------------------------
  1671. XTPMarkupSetDefaultFont(pMarkupContext, (HFONT)pFntClr1->Font()->GetSafeHandle(), pFntClr1->Color());
  1673. XTPMarkupRenderElement(pUIElement, pDC->GetSafeHdc(), rcText);
  1675. bMarkupDrawn = TRUE;
  1677. Draw_Icons(pViewEvent, pDC, rcIconsMax);
  1678. }
  1679. }
  1680. //
  1682. if (!bMarkupDrawn)
  1683. {
  1684. Draw_Time(pDC, rcEvent, pViewEvent);
  1686. CRect rcText(pViewEvent->GetTextRect());
  1687. Draw_Caption(pDC, rcText, pViewEvent);
  1688. }
  1689. }
  1691. void CXTPCalendarThemeOffice2007::CTOMonthViewEvent_SingleDay::
  1692. Draw_Background(CDC* pDC, const CRect& rcEventRect, CXTPCalendarMonthViewEvent* pViewEvent)
  1693. {
  1694. CXTPCalendarThemeOffice2007* pThemeX = DYNAMIC_DOWNCAST(CXTPCalendarThemeOffice2007, GetTheme());
  1696. if (!pDC || !pThemeX || !pViewEvent || !pViewEvent->GetEvent())
  1697. {
  1698. ASSERT(FALSE);
  1699. return;
  1700. }
  1701. BOOL bSelected = pViewEvent->IsSelected();
  1703. COLORREF clrBorderNotSel, clrBorder;
  1704. CXTPPaintManagerColorGradient grclrBk;
  1705. int nColorsSrc_1Cat2Lbl = 0;
  1706. GetEventColors(pDC, pViewEvent, clrBorder, clrBorderNotSel, grclrBk, bSelected, &nColorsSrc_1Cat2Lbl);
  1708. if (!bSelected && nColorsSrc_1Cat2Lbl > 0)
  1709. {
  1710. clrBorder = grclrBk.clrLight;
  1711. }
  1713. pThemeX->DrawRoundRect(pDC, rcEventRect, clrBorder, bSelected, grclrBk);
  1714. }
  1716. CSize CXTPCalendarThemeOffice2007::CTOMonthViewEvent_SingleDay::Draw_Time(
  1717. CDC* pDC, const CRect& rcEventRect, CXTPCalendarMonthViewEvent* pViewEvent)
  1718. {
  1719. CSize szResult(0, 0);
  1721. if (!pDC || !pViewEvent || !pViewEvent->GetEvent())
  1722. {
  1723. ASSERT(FALSE);
  1724. return szResult;
  1725. }
  1727. BOOL bSelected = pViewEvent->IsSelected();
  1729. CFont* pFont = bSelected ? m_fcsetSelected.fcsetStartEnd.Font() : m_fcsetNormal.fcsetStartEnd.Font();
  1730. COLORREF clrColor = bSelected ? m_fcsetSelected.fcsetStartEnd.Color() : m_fcsetNormal.fcsetStartEnd.Color();
  1732. CXTPFontDC autoFont(pDC, pFont, clrColor);
  1734. //--------------------------
  1736. //*****************
  1737. // not implemented for office 2007 theme.
  1738. //if (pViewEvent->IsTimeAsClock()) {}
  1739. //*****************
  1741. CString strStartTime = pViewEvent->GetItemTextStartTime();
  1742. CString strEndTime = pViewEvent->GetItemTextEndTime();
  1744. CSize szStart = pDC->GetTextExtent(strStartTime);
  1745. CSize szEnd = pDC->GetTextExtent(strEndTime);
  1747. CRect rcStart(rcEventRect);
  1748. CRect rcEnd(rcEventRect);
  1750. DWORD dwOpt = XTP_SAFE_GET3(GetTheme(), GetCalendarControl(), GetCalendarOptions(), dwAdditionalOptions, 0);
  1752. BOOL bShowEndTime = XTP_SAFE_GET2(pViewEvent, GetCalendarControl(), MonthView_IsShowEndDate(), TRUE);
  1753. BOOL bDrawStartTime = szStart.cx + 6 < rcEventRect.Width()/2 ||
  1754.   (dwOpt & xtpCalendarOptMonthViewShowStartTimeAlways);
  1755. BOOL bDrawEndTime = bShowEndTime && szStart.cx + szEnd.cx + 6 * 2 < rcEventRect.Width()/2 ||
  1756. (dwOpt & xtpCalendarOptMonthViewShowEndTimeAlways);
  1758. if (!bDrawStartTime && !bDrawEndTime)
  1759. {
  1760. return szResult;
  1761. }
  1763. rcStart.left = min(rcStart.left + 4, rcStart.right);
  1764. rcStart.right = min(rcStart.left + szStart.cx + 6, rcStart.right);
  1766. rcEnd.left = rcStart.right;
  1767. rcEnd.right = min(rcEnd.left + szEnd.cx + 6, rcEnd.right);
  1768. if (!bDrawEndTime)
  1769. {
  1770. rcEnd.right = rcEnd.left;
  1771. }
  1773. //-------------------------------------------------
  1774. UINT uAlign = DT_VCENTER | DT_SINGLELINE | DT_LEFT;
  1775. pDC->DrawText(strStartTime, &rcStart, uAlign);
  1777. if (bDrawEndTime)
  1778. {
  1779. pDC->DrawText(strEndTime, &rcEnd, uAlign);
  1780. }
  1782. //-------------------------------------------------
  1783. pViewEvent->m_rcStartTime.CopyRect(&rcStart);
  1784. pViewEvent->m_rcEndTime.CopyRect(&rcEnd);
  1786. pViewEvent->m_rcText.left = rcEnd.right;
  1788. //-------------------------------------------------
  1789. szResult.cx = max(0, rcEnd.right - rcStart.left);
  1790. szResult.cy = szStart.cy;
  1792. return szResult;
  1793. }
  1795. void CXTPCalendarThemeOffice2007::CTOMonthViewEvent_SingleDay::Draw_Caption(
  1796. CDC* pDC, const CRect& rcTextRect, CXTPCalendarMonthViewEvent* pViewEvent)
  1797. {
  1798. CXTPCalendarThemeOffice2007* pThemeX = DYNAMIC_DOWNCAST(CXTPCalendarThemeOffice2007, GetTheme());
  1799. if (!pDC || !pViewEvent || !pThemeX )
  1800. {
  1801. ASSERT(FALSE);
  1802. return;
  1803. }
  1805. CString strSubj = pViewEvent->GetItemTextSubject();
  1806. CString strLoc = pViewEvent->GetItemTextLocation();
  1808. if (!strLoc.IsEmpty())
  1809. {
  1810. strSubj += _T(";");
  1811. }
  1813. BOOL bSelected = pViewEvent->IsSelected();
  1814. CThemeFontColorSet* pFntClr1 = bSelected ? &m_fcsetSelected.fcsetSubject : &m_fcsetNormal.fcsetSubject;
  1815. CThemeFontColorSet* pFntClr2 = bSelected ? &m_fcsetSelected.fcsetLocation : &m_fcsetNormal.fcsetLocation;
  1817. CRect rcText = rcTextRect;
  1818. //rcText.DeflateRect(1, 2, 3, 2);
  1820. pViewEvent->m_rcSubjectEditor.CopyRect(rcText);
  1821. pViewEvent->AdjustSubjectEditor();
  1823. UINT nAlign = DT_VCENTER | DT_LEFT | DT_SINGLELINE;
  1824. CSize szText = pThemeX->DrawLine2_CenterLR(pDC, strSubj, strLoc, pFntClr1, pFntClr2,
  1825. rcText, nAlign  | DT_CALCRECT, nAlign);
  1827. //----------------------------------------------------
  1828. CRect rcIconsMax = rcText;
  1829. rcIconsMax.left = min(rcIconsMax.left + rcTextRect.Height(), rcIconsMax.right);
  1831. //--- calculate rects and fix to be centered if enough space ---
  1832. CSize szIcons = Draw_Icons(pViewEvent, pDC, rcIconsMax, TRUE);
  1834. if (rcIconsMax.Height() > szIcons.cy)
  1835. {
  1836. rcIconsMax.bottom -= (rcIconsMax.Height() - szIcons.cy) / 2;
  1837. }
  1839. int nTIcx = szText.cx + szIcons.cx;
  1840. if (nTIcx > rcText.Width())
  1841. {
  1842. rcText.right = max(rcIconsMax.left, rcIconsMax.right - szIcons.cx) - 2;
  1843. }
  1845. pThemeX->DrawLine2_CenterLR(pDC, strSubj, strLoc, pFntClr1, pFntClr2,
  1846. rcText, nAlign, nAlign);
  1848. Draw_Icons(pViewEvent, pDC, rcIconsMax);
  1849. }
  1851. /////////////////////////////////////////////////////////////////////////////
  1852. //
  1853. // ***** Week View *****
  1854. //
  1856. void CXTPCalendarThemeOffice2007::CTOWeekView::RefreshMetrics(BOOL bRefreshChildren)
  1857. {
  1858. TBase::RefreshMetrics(bRefreshChildren);
  1859. }
  1861. void CXTPCalendarThemeOffice2007::CTOWeekView::AdjustLayout(CDC* pDC, const CRect& rcRect, BOOL bCallPostAdjustLayout)
  1862. {
  1863. CXTPCalendarThemeOffice2007* pThemeX = DYNAMIC_DOWNCAST(CXTPCalendarThemeOffice2007, GetTheme());
  1864. ASSERT(pThemeX);
  1865. if (!pThemeX)
  1866. {
  1867. return;
  1868. }
  1870. TBase::AdjustLayout(pDC, rcRect, bCallPostAdjustLayout);
  1872. if (pThemeX->GetPrevNextEventControllerPartX())
  1873. pThemeX->GetPrevNextEventControllerPartX()->AdjustLayout(NULL, pDC, rcRect);
  1874. }
  1876. void CXTPCalendarThemeOffice2007::CTOWeekView::Draw(CCmdTarget* /*pObject*/, CDC* pDC)
  1877. {
  1878. CXTPCalendarThemeOffice2007* pThemeX = DYNAMIC_DOWNCAST(CXTPCalendarThemeOffice2007, GetTheme());
  1879. ASSERT(pThemeX);
  1880. if (!pThemeX)
  1881. {
  1882. return;
  1883. }
  1885. TBase::Draw(pDC);
  1887. if (pThemeX->GetPrevNextEventControllerPartX())
  1888. pThemeX->GetPrevNextEventControllerPartX()->Draw(NULL, pDC);
  1889. }
  1891. void CXTPCalendarThemeOffice2007::CTOWeekViewEvent::RefreshMetrics(BOOL bRefreshChildren)
  1892. {
  1893. CXTPCalendarThemeOffice2007* pThemeX = DYNAMIC_DOWNCAST(CXTPCalendarThemeOffice2007, GetTheme());
  1894. ASSERT(pThemeX);
  1895. if (!pThemeX)
  1896. {
  1897. return;
  1898. }
  1900. TBase::RefreshMetrics(bRefreshChildren);
  1902. RefreshFromParent(pThemeX->GetEventPartX());
  1904. XTP_SAFE_CALL1(GetHeightFormulaPart(), SetStandardValue(14, 10, 1));
  1905. XTP_SAFE_CALL1(GetEventIconsToDrawPart(), SetStandardValue(FALSE, FALSE, FALSE, FALSE, FALSE) );
  1906. }
  1908. void CXTPCalendarThemeOffice2007::CTOWeekViewEvent_MultiDay::RefreshMetrics(BOOL bRefreshChildren)
  1909. {
  1910. UNREFERENCED_PARAMETER(bRefreshChildren);
  1912. CXTPCalendarThemeOffice2007* pThemeX = DYNAMIC_DOWNCAST(CXTPCalendarThemeOffice2007, GetTheme());
  1913. ASSERT(pThemeX);
  1914. if (!pThemeX)
  1915. {
  1916. return;
  1917. }
  1919. RefreshFromParent(pThemeX->GetWeekViewPartX()->GetEventPartX());
  1921. m_fcsetNormal.clrBorder.SetStandardValue(pThemeX->GetColor(xtpCLR_MultiDayEventBorder));
  1922. m_fcsetNormal.grclrBackground.SetStandardValue(pThemeX->GetColor(xtpCLR_MultiDayEventBkGRfrom),
  1923.    pThemeX->GetColor(xtpCLR_MultiDayEventBkGRto));
  1925. m_fcsetSelected.clrBorder.SetStandardValue(pThemeX->GetColor(xtpCLR_MultiDayEventSelectedBorder));
  1926. m_fcsetSelected.grclrBackground.SetStandardValue(m_fcsetNormal.grclrBackground);
  1927. }
  1929. void CXTPCalendarThemeOffice2007::CTOWeekViewEvent_SingleDay::RefreshMetrics(BOOL bRefreshChildren)
  1930. {
  1931. UNREFERENCED_PARAMETER(bRefreshChildren);
  1933. CXTPCalendarThemeOffice2007* pThemeX = DYNAMIC_DOWNCAST(CXTPCalendarThemeOffice2007, GetTheme());
  1934. ASSERT(pThemeX);
  1935. if (!pThemeX)
  1936. {
  1937. return;
  1938. }
  1940. RefreshFromParent(pThemeX->GetWeekViewPartX()->GetEventPartX());
  1941. CFont* pFontDef = pThemeX->m_fntBaseFont;
  1943. m_fcsetNormal.clrBorder.SetStandardValue(pThemeX->GetColor(xtpCLR_WeekViewSingleDayEventBorder));
  1944. m_fcsetNormal.grclrBackground.SetStandardValue(pThemeX->GetColor(xtpCLR_WeekViewSingleDayEventBkGRfrom),
  1945.    pThemeX->GetColor(xtpCLR_WeekViewSingleDayEventBkGRto) );
  1947. m_fcsetSelected.clrBorder.SetStandardValue(pThemeX->GetColor(xtpCLR_WeekViewSingleDayEventSelectedBorder));
  1948. m_fcsetSelected.grclrBackground.SetStandardValue(pThemeX->GetColor(xtpCLR_WeekViewSingleDayEventBkGRfrom),
  1949.  pThemeX->GetColor(xtpCLR_WeekViewSingleDayEventBkGRto) );
  1951. //----------------------------------------------
  1952. pThemeX->RemoveBoldAttrFromStd(m_fcsetNormal.fcsetSubject.fntFont);
  1953. pThemeX->RemoveBoldAttrFromStd(m_fcsetSelected.fcsetSubject.fntFont);
  1955. //----------------------------------------------
  1956. m_fcsetNormal.fcsetStartEnd.clrColor.SetStandardValue(pThemeX->GetColor(xtpCLR_WeekViewEventTime));
  1957. m_fcsetNormal.fcsetStartEnd.fntFont.SetStandardValue(pFontDef);
  1959. m_fcsetSelected.fcsetStartEnd.clrColor.SetStandardValue(pThemeX->GetColor(xtpCLR_WeekViewEventTime));
  1960. m_fcsetSelected.fcsetStartEnd.fntFont.SetStandardValue(pFontDef);
  1961. }
  1963. void CXTPCalendarThemeOffice2007::CTOWeekViewDay::RefreshMetrics(BOOL bRefreshChildren)
  1964. {
  1965. CXTPCalendarThemeOffice2007* pThemeX = DYNAMIC_DOWNCAST(CXTPCalendarThemeOffice2007, GetTheme());
  1966. ASSERT(pThemeX);
  1967. if (!pThemeX)
  1968. {
  1969. return;
  1970. }
  1972. m_clrBorder.SetStandardValue(pThemeX->GetColor(xtpCLR_DayBorder));
  1973. //m_clrTodayBorder.SetStandardValue(XTP_CALENDAR_OFFICE2007_TODAYBORDER);
  1975. m_clrBackgroundLight.SetStandardValue(pThemeX->GetColor(xtpCLR_WeekViewDayBkLight));
  1976. m_clrBackgroundDark.SetStandardValue(pThemeX->GetColor(xtpCLR_WeekViewDayBkDark));
  1977. m_clrBackgroundSelected.SetStandardValue(pThemeX->GetColor(xtpCLR_WeekViewDayBkSelected));
  1979. TBase::RefreshMetrics(bRefreshChildren);
  1981. m_clrTodayBorder.SetStandardValue(GetHeaderPartX()->m_clrTodayBaseColor);
  1982. }
  1984. void CXTPCalendarThemeOffice2007::CTOWeekViewDayHeader::RefreshMetrics(BOOL bRefreshChildren)
  1985. {
  1986. UNREFERENCED_PARAMETER(bRefreshChildren);
  1988. CXTPCalendarThemeOffice2007* pThemeX = DYNAMIC_DOWNCAST(CXTPCalendarThemeOffice2007, GetTheme());
  1989. ASSERT(pThemeX);
  1990. if (!pThemeX)
  1991. {
  1992. return;
  1993. }
  1995. //LOCALE_IDATE  -  short date format ordering
  1996. // 0 Month-Day-Year
  1997. // 1 Day-Month-Year
  1998. // 2 Year-Month-Day
  1999. int nDateOrdering = CXTPCalendarUtils::GetLocaleLong(LOCALE_IDATE);
  2001. if (nDateOrdering == 1)
  2002. {
  2003. m_strHeaderFormat.SetStandardValue(_T("dddd, dd MMMM"));
  2004. }
  2005. else
  2006. {
  2007. m_strHeaderFormat.SetStandardValue(_T("dddd, MMMM dd"));
  2008. }
  2010. RefreshFromParent(pThemeX->GetHeaderPartX());
  2012. //  m_clrTodayBaseColor.SetStandardValue(pThemeX->GetHeaderPartX()->m_clrTodayBaseColor);
  2013. m_bkNormal.nBitmapID.SetStandardValue(xtpIMG_WeekViewDayHeader);
  2014. m_bkSelected.nBitmapID.SetStandardValue(xtpIMG_WeekViewDayHeader);
  2016. m_UseOffice2003HeaderFormat.SetStandardValue(FALSE);
  2017. }
  2019. void CXTPCalendarThemeOffice2007::CTOWeekViewDayHeader::AdjustLayout(CCmdTarget* pObject,
  2020. CDC* pDC, const CRect& rcRect)
  2021. {
  2022. //TBase::AdjustLayout(pObject, pDC, rcRect);
  2024. CXTPCalendarThemeOffice2007* pThemeX = DYNAMIC_DOWNCAST(CXTPCalendarThemeOffice2007, GetTheme());
  2025. CXTPCalendarWeekViewDay* pWViewDay = DYNAMIC_DOWNCAST(CXTPCalendarWeekViewDay, pObject);
  2026. if (!pDC || !pThemeX || !pWViewDay || !pWViewDay->GetView())
  2027. {
  2028. ASSERT(FALSE);
  2029. return;
  2030. }
  2032. if (pWViewDay->GetDayIndex() != 0)
  2033. {
  2034. return;
  2035. }
  2038. CXTPCalendarWeekView* pWView = pWViewDay->GetView();
  2039. if (m_UseOffice2003HeaderFormat)
  2040. {
  2041. int nDayWidth = rcRect.Width() - 4;
  2042. pWView->CalculateHeaderFormat(pDC, nDayWidth, m_TextLeftRight.fcsetNormal.Font());
  2043. }
  2044. }
  2046. void CXTPCalendarThemeOffice2007::CTOWeekViewEvent::AdjustLayout(CCmdTarget* pObject,
  2047.   CDC* pDC, const CRect& rcRect, int nEventPlaceNumber)
  2048. {
  2049. CXTPCalendarWeekViewEvent* pViewEvent = DYNAMIC_DOWNCAST(CXTPCalendarWeekViewEvent, pObject);
  2051. if (!pDC || !GetTheme() || !pViewEvent || !pViewEvent->GetEvent())
  2052. {
  2053. ASSERT(FALSE);
  2054. return;
  2055. }
  2057. int nEventHeight = XTP_SAFE_GET4(pViewEvent, GetViewGroup(), GetViewDay(), GetView(), GetRowHeight(), 0);
  2059. pViewEvent->m_rcEventMax.top = rcRect.top + nEventPlaceNumber * nEventHeight;
  2060. pViewEvent->m_rcEventMax.bottom = pViewEvent->m_rcEventMax.top + nEventHeight;
  2062. pViewEvent->m_rcEvent.top = pViewEvent->m_rcEventMax.top;
  2063. pViewEvent->m_rcEvent.bottom = pViewEvent->m_rcEventMax.bottom;
  2064. pViewEvent->m_rcEvent.left = pViewEvent->m_rcEventMax.left + 4 + 2;
  2065. pViewEvent->m_rcEvent.right = pViewEvent->m_rcEventMax.right - 5 - 2;
  2067. pViewEvent->m_rcToolTip.CopyRect(pViewEvent->m_rcEventMax);
  2069. // adjust subject area
  2070. int nDyx = pViewEvent->IsSelected() ? 5 : 2;
  2072. pViewEvent->m_rcText.CopyRect(pViewEvent->m_rcEvent);
  2073. pViewEvent->m_rcText.DeflateRect(nDyx + 3, 3, nDyx + 2, 3);
  2075. // set times rects
  2076. pViewEvent->m_rcStartTime.SetRectEmpty();
  2077. pViewEvent->m_rcEndTime.SetRectEmpty();
  2079. pViewEvent->m_rcSubjectEditor.CopyRect(pViewEvent->m_rcEvent);
  2080. pViewEvent->m_rcSubjectEditor.top++;
  2081. pViewEvent->m_rcSubjectEditor.bottom--;
  2082. }
  2084. void CXTPCalendarThemeOffice2007::CTOWeekViewDay::SetDynColors(CXTPCalendarWeekViewDay* pWViewDay)
  2085. {
  2086. CXTPCalendarThemeOffice2007* pThemeX = DYNAMIC_DOWNCAST(CXTPCalendarThemeOffice2007, GetTheme());
  2087. CXTPCalendarThemeOffice2007::CTOCellDynBackground* pCellDynBkPart =
  2088. XTP_SAFE_GET1(pThemeX, GetCellDynBackgroundPart(), NULL);
  2090. if (!pWViewDay || !pCellDynBkPart || !GetTheme() || !GetTheme()->GetColorsSetPart())
  2091. {
  2092. ASSERT(FALSE);
  2093. return;
  2094. }
  2096. CXTPCalendarViewGroup* pViewGroup = pWViewDay->GetViewGroupsCount() ? pWViewDay->GetViewGroup_(0) : NULL;
  2098. //--------------------------------------------------------------------
  2099. CXTPCalendarTheme::XTP_BUSY_STATUS_CONTEXT bsColors;
  2100. m_nDynBusyStatus = pCellDynBkPart->GetCellDynBackground(pViewGroup, pWViewDay->GetDayDate(), -1, bsColors);
  2102. //--------------------------------------------------------------------
  2103. m_clrDynHatch = 0;
  2105. if (m_nDynBusyStatus == xtpCalendarBusyStatusBusy ||
  2106.  m_nDynBusyStatus == xtpCalendarBusyStatusOutOfOffice ||
  2107.  m_nDynBusyStatus == xtpCalendarBusyStatusTentative)
  2108. {
  2109. if (bsColors.clrBkAllDayEvents != 0 && bsColors.clrCellBorder != 0) // is Category or OutOfOffice
  2110. {
  2111. m_clrDynHatch = bsColors.clrBkAllDayEvents;
  2113. if (m_nDynBusyStatus != xtpCalendarBusyStatusTentative)
  2114. {
  2115. m_clrBackgroundLight = bsColors.clrBkAllDayEvents;
  2116. m_clrBackgroundDark = bsColors.clrBkAllDayEvents;
  2117. m_clrBackgroundSelected = CXTPCalendarThemeOffice2007::PowerColor(bsColors.clrBkAllDayEvents, -7.5, 0.25);
  2118. }
  2119. }
  2120. else
  2121. {
  2122. if (m_nDynBusyStatus == xtpCalendarBusyStatusBusy)
  2123. {
  2124. m_clrBackgroundLight = GetTheme()->GetColorsSetPart()->GetColor(xtpCLR_HeaderBorder); // 141, 174, 217
  2125. m_clrBackgroundDark = (COLORREF)m_clrBackgroundLight;
  2126. }
  2127. m_clrDynHatch = GetTheme()->GetColorsSetPart()->GetColor(xtpCLR_HeaderBorder); // 141, 174, 217;
  2128. }
  2129. }
  2130. }
  2132. void CXTPCalendarThemeOffice2007::CTOWeekViewDay::Draw(CCmdTarget* pObject, CDC* pDC)
  2133. {
  2134. CXTPCalendarThemeOffice2007* pThemeX = DYNAMIC_DOWNCAST(CXTPCalendarThemeOffice2007, GetTheme());
  2135. CXTPCalendarWeekViewDay* pWViewDay = DYNAMIC_DOWNCAST(CXTPCalendarWeekViewDay, pObject);
  2136. if (!pDC || !pThemeX || !pWViewDay || !pWViewDay->GetView() ||
  2137. pWViewDay->GetViewGroupsCount() == 0 ||
  2138. !pWViewDay->GetViewGroup(0))
  2139. {
  2140. ASSERT(FALSE);
  2141. return;
  2142. }
  2143. CXTPCalendarWeekViewGroup* pWViewGroup = pWViewDay->GetViewGroup(0);
  2144. CXTPCalendarViewDay::XTP_VIEW_DAY_LAYOUT& dayLayout = CXTPCalendarTheme::GetViewDayLayout(pWViewDay);
  2146. CRect rcDay = dayLayout.m_rcDay;
  2147. CRect rcBorders = rcDay;
  2148. rcBorders.top = dayLayout.m_rcDayHeader.bottom;
  2150. COleDateTime dtDay = pWViewDay->GetDayDate();
  2151. int nDayCol = GetDayCol(pWViewDay);
  2153. BOOL bIsToday = GetHeaderPart()->IsToday(pWViewDay);
  2154. BOOL bIsSelected = GetHeaderPart()->IsSelected(pWViewDay);
  2156. // Draw background
  2157. int nLiteBkColorIdx = 0;
  2158. // for non-work days choose dark background
  2159. if (pWViewDay->GetCalendarControl() &&
  2160. pWViewDay->GetCalendarControl()->GetCalendarOptions())
  2161. {
  2162. int nMask = pWViewDay->GetCalendarControl()->GetCalendarOptions()->nWorkWeekMask;
  2163. int nWeekDay = dtDay.GetDayOfWeek();
  2164. if ((CXTPCalendarUtils::GetDayOfWeekMask(nWeekDay) & nMask) != 0)
  2165. {
  2166. nLiteBkColorIdx = 1;
  2167. }
  2168. }
  2169. // for selected days choose another background
  2170. COLORREF clrBackground = nLiteBkColorIdx ? m_clrBackgroundLight : m_clrBackgroundDark;
  2171. if (bIsSelected)
  2172. {
  2173. clrBackground = m_clrBackgroundSelected;
  2174. }
  2176. // draw background
  2177. pDC->FillSolidRect(rcDay, clrBackground);
  2179. //--------------------------------------------------------------------
  2180. if (m_nDynBusyStatus == xtpCalendarBusyStatusTentative)
  2181. {
  2182. CXTPTextDC autoTxt(pDC, COLORREF_NULL, clrBackground);
  2183. CBrush br(HS_BDIAGONAL, m_clrDynHatch);
  2185. pDC->FillRect(&rcDay, &br);
  2186. }
  2187. //--------------------------------------------------------------------
  2189. if (bIsToday)
  2190. {
  2191. CXTPCalendarTheme::DrawRectPartly(pDC, rcBorders, m_clrTodayBorder, 2, CRect(1, 0, 0, 1));
  2192. CXTPCalendarTheme::DrawRectPartly(pDC, rcBorders, m_clrTodayBorder, 1, CRect(0, 0, 1, 0));
  2193. //CXTPCalendarTheme::DrawRectPartly(pDC, rcBorders, m_clrBorder, 1, CRect(0, 0, 1, 0));
  2194. }
  2195. else
  2196. {
  2197. int nIsRBorder = nDayCol;
  2198. int nIsLBorder = nDayCol;
  2200. CXTPCalendarTheme::DrawRectPartly(pDC, rcBorders, m_clrBorder, 1, CRect(nIsLBorder, 0, nIsRBorder, 0));
  2201. CXTPCalendarTheme::DrawRectPartly(pDC, rcBorders, m_clrBorder, 2, CRect(0, 0, 0, 1));
  2202. }
  2203. //------------------
  2204. GetHeaderPart()->Draw(pWViewDay, pDC);
  2206. BOOL bCnt_EvS = FALSE;
  2207. BOOL bCnt_EvMul = FALSE;
  2209. CXTPPropsStateContext autoStateCnt_EvS;
  2210. CXTPPropsStateContext autoStateCnt_EvMul;
  2212. //=====================
  2213. int nCount = pWViewGroup->GetViewEventsCount();
  2214. for (int i = 0; i < nCount; i++)
  2215. {
  2216. CXTPCalendarViewEvent* pViewEvent = pWViewGroup->GetViewEvent_(i);
  2217. ASSERT(pViewEvent);
  2218. if (pViewEvent && pViewEvent->IsVisible())
  2219. {
  2220. if (pViewEvent->IsMultidayEvent())
  2221. {
  2222. if (!bCnt_EvMul)
  2223. autoStateCnt_EvMul.SetData(GetMultiDayEventPartX(), xtpCalendarBeforeDraw_WeekViewEvent, TRUE);
  2224. bCnt_EvMul = TRUE;
  2226. autoStateCnt_EvMul.SendBeforeDrawThemeObject((LPARAM)pViewEvent);
  2228. GetMultiDayEventPartX()->Draw(pViewEvent, pDC);
  2230. autoStateCnt_EvMul.RestoreState();
  2231. }
  2232. else
  2233. {
  2234. if (!bCnt_EvS)
  2235. autoStateCnt_EvS.SetData(GetSingleDayEventPartX(), xtpCalendarBeforeDraw_WeekViewEvent, TRUE);
  2236. bCnt_EvS = TRUE;
  2238. autoStateCnt_EvS.SendBeforeDrawThemeObject((LPARAM)pViewEvent);
  2240. GetSingleDayEventPartX()->Draw(pViewEvent, pDC);
  2242. autoStateCnt_EvS.RestoreState();
  2243. }
  2244. }
  2245. }
  2247. if (!pDC->IsPrinting() && pWViewDay->NoAllEventsAreVisible())
  2248. {
  2249. CRect rc = dayLayout.m_rcDay;
  2250. rc.right -= 5;
  2251. rc.bottom -= 5;
  2253. BOOL bHot = _HitTestExpandDayButton(pWViewDay, rc) != 0;
  2255. dayLayout.m_rcExpandSign = pThemeX->DrawExpandDayButton(pDC, rc, FALSE, bHot);
  2256. if (bHot)
  2257. dayLayout.m_nHotState |= CXTPCalendarViewDay::XTP_VIEW_DAY_LAYOUT::xtpHotExpandButton;
  2258. else
  2259. dayLayout.m_nHotState &= ~CXTPCalendarViewDay::XTP_VIEW_DAY_LAYOUT::xtpHotExpandButton;
  2260. }
  2262. autoStateCnt_EvS.Clear();
  2263. autoStateCnt_EvMul.Clear();
  2264. }
  2266. void CXTPCalendarThemeOffice2007::CTOWeekViewDay::OnMouseMove(CCmdTarget* pObject, UINT nFlags, CPoint point)
  2267. {
  2268. UNREFERENCED_PARAMETER(nFlags);
  2270. CXTPCalendarThemeOffice2007* pThemeX = DYNAMIC_DOWNCAST(CXTPCalendarThemeOffice2007, GetTheme());
  2271. CXTPCalendarWeekViewDay* pWViewDay = DYNAMIC_DOWNCAST(CXTPCalendarWeekViewDay, pObject);
  2272. if (!pThemeX || !pWViewDay || !pThemeX->GetCalendarControl())
  2273. {
  2274. ASSERT(FALSE);
  2275. return;
  2276. }
  2278. CXTPCalendarViewDay::XTP_VIEW_DAY_LAYOUT& dayLayout = CXTPCalendarTheme::GetViewDayLayout(pWViewDay);
  2280. if (pWViewDay->NoAllEventsAreVisible())
  2281. {
  2282. BOOL bHot = pThemeX->ExpandDayButton_HitTest(point, dayLayout.m_rcExpandSign, FALSE);
  2283. BOOL bHotPrev = !!(dayLayout.m_nHotState & CXTPCalendarViewDay::XTP_VIEW_DAY_LAYOUT::xtpHotExpandButton);
  2285. if (bHot != bHotPrev)
  2286. {
  2287. CXTPCalendarControl::CUpdateContext updateContext(pThemeX->GetCalendarControl(), xtpCalendarUpdateRedraw);
  2288. }
  2289. }
  2291. BOOL bHotPrev = !!(dayLayout.m_nHotState & CXTPCalendarViewDay::XTP_VIEW_DAY_LAYOUT::xtpHotDayHeader);
  2292. if (dayLayout.m_rcDayHeader.PtInRect(point) != bHotPrev)
  2293. {
  2294. CXTPCalendarControl::CUpdateContext updateContext(pThemeX->GetCalendarControl(), xtpCalendarUpdateRedraw);
  2295. }
  2296. }
  2298. BOOL CXTPCalendarThemeOffice2007::CTOWeekViewDay::OnLButtonDown(CCmdTarget* pObject, UINT nFlags, CPoint point)
  2299. {
  2300. UNREFERENCED_PARAMETER(nFlags);
  2302. CXTPCalendarThemeOffice2007* pThemeX = DYNAMIC_DOWNCAST(CXTPCalendarThemeOffice2007, GetTheme());
  2303. CXTPCalendarViewDay* pViewDay = DYNAMIC_DOWNCAST(CXTPCalendarViewDay, pObject);
  2304. if (!pThemeX || !pViewDay || !pThemeX->GetCalendarControl())
  2305. {
  2306. ASSERT(FALSE);
  2307. return FALSE;
  2308. }
  2309. CXTPCalendarViewDay::XTP_VIEW_DAY_LAYOUT& dayLayout = CXTPCalendarTheme::GetViewDayLayout(pViewDay);
  2311. if (pThemeX->ExpandDayButton_HitTest(point, dayLayout.m_rcExpandSign, FALSE))
  2312. {
  2313. pThemeX->GetCalendarControl()->PostMessage(xtp_wm_UserAction,
  2314. (WPARAM)(xtpCalendarUserAction_OnExpandDay | xtpCalendarExpandDayButton_WeekView),
  2315. (LPARAM)(LONG)(DATE)pViewDay->GetDayDate());
  2317. return TRUE;
  2318. }
  2320. return FALSE;
  2321. }
  2323. void CXTPCalendarThemeOffice2007::CTOWeekViewDay::DoPropExchange(CXTPPropExchange* pPX)
  2324. {
  2325. ASSERT(pPX);
  2326. if (!pPX)
  2327. return;
  2329. CXTPPropExchangeSection secData(pPX->GetSection(_T("WeekViewDay")));
  2330. if (pPX->IsStoring())
  2331. secData->EmptySection();
  2333. PX_Color(&secData, _T("BorderColor"),       m_clrBorder);
  2334. PX_Color(&secData, _T("TodayBorderColor"),  m_clrTodayBorder);
  2336. PX_Color(&secData, _T("BackgroundLightColor"),   m_clrBackgroundLight);
  2337. PX_Color(&secData, _T("BackgroundDarkColor"),    m_clrBackgroundDark);
  2338. PX_Color(&secData, _T("BackgroundSelectedColor"), m_clrBackgroundSelected);
  2340. TBase::DoPropExchange(&secData);
  2341. }
  2343. void CXTPCalendarThemeOffice2007::CTOWeekViewDay::Serialize(CArchive& ar)
  2344. {
  2345. m_clrBorder.Serialize(ar);
  2346. m_clrTodayBorder.Serialize(ar);
  2348. m_clrBackgroundLight.Serialize(ar);
  2349. m_clrBackgroundDark.Serialize(ar);
  2350. m_clrBackgroundSelected.Serialize(ar);
  2352. TBase::Serialize(ar);
  2353. }
  2356. void CXTPCalendarThemeOffice2007::CTOWeekViewDayHeader::Draw(CCmdTarget* pObject, CDC* pDC)
  2357. {
  2358. CXTPCalendarThemeOffice2007* pThemeX = DYNAMIC_DOWNCAST(CXTPCalendarThemeOffice2007, GetTheme());
  2359. CXTPCalendarWeekViewDay* pWViewDay = DYNAMIC_DOWNCAST(CXTPCalendarWeekViewDay, pObject);
  2360. if (!pDC || !pThemeX || !pWViewDay || !pWViewDay->GetView())
  2361. {
  2362. ASSERT(FALSE);
  2363. return;
  2364. }
  2366. CXTPCalendarViewDay::XTP_VIEW_DAY_LAYOUT& dayLayout = CXTPCalendarTheme::GetViewDayLayout(pWViewDay);
  2367. COleDateTime dtDay = pWViewDay->GetDayDate();
  2368. int nDayCol = pThemeX->GetWeekViewPart()->GetDayPart()->GetDayCol(pWViewDay);
  2370. CPoint pt(0, 0);
  2371. if (pThemeX->GetCalendarControl()->GetSafeHwnd() && GetCursorPos(&pt))
  2372. pThemeX->GetCalendarControl()->ScreenToClient(&pt);
  2374. BOOL bIsToday    = IsToday(pWViewDay);
  2375. BOOL bIsSelected = IsSelected(pWViewDay);
  2376. BOOL bFirstDay = nDayCol == 0;
  2377. BOOL bLastDay = nDayCol == 1;
  2379. int nFlags = bIsToday ? CTOHeader::xtpCalendarItemState_Today : CTOHeader::xtpCalendarItemState_Normal;
  2380. nFlags |= bIsSelected ? CTOHeader::xtpCalendarItemState_Selected : 0;
  2381. if (dayLayout.m_rcDayHeader.PtInRect(pt))
  2382. {
  2383. nFlags |=  CTOHeader::xtpCalendarItemState_Hot;
  2384. dayLayout.m_nHotState |= CXTPCalendarViewDay::XTP_VIEW_DAY_LAYOUT::xtpHotDayHeader;
  2385. }
  2386. else
  2387. {
  2388. dayLayout.m_nHotState &= ~CXTPCalendarViewDay::XTP_VIEW_DAY_LAYOUT::xtpHotDayHeader;
  2389. }
  2391. nFlags |= bFirstDay ? CTOHeader::xtpCalendarItemFirst : 0;
  2392. nFlags |= bLastDay ? CTOHeader::xtpCalendarItemLast : 0;
  2394. CRect rcRect(dayLayout.m_rcDay);
  2395. rcRect.bottom = dayLayout.m_rcDayHeader.bottom;
  2397. CString strTextLeft;
  2398. CString strTextCenter;
  2399. CString strTextRight;
  2401. if (m_UseOffice2003HeaderFormat)
  2402. {
  2403. strTextRight = pWViewDay->GetCaption();
  2404. }
  2405. else
  2406. {
  2407. strTextRight = CXTPCalendarUtils::GetDateFormat(dtDay, m_strHeaderFormat);
  2409. //------------------------------------------------------
  2410. pThemeX->GetItemTextIfNeed(xtpCalendarItemText_WeekViewDayHeaderLeft, &strTextLeft, pWViewDay);
  2411. pThemeX->GetItemTextIfNeed(xtpCalendarItemText_WeekViewDayHeaderCenter, &strTextCenter, pWViewDay);
  2412. pThemeX->GetItemTextIfNeed(xtpCalendarItemText_WeekViewDayHeaderRight, &strTextRight, pWViewDay);
  2413. //------------------------------------------------------
  2414. }
  2416. Draw_Header(pDC, rcRect, nFlags, strTextLeft, strTextCenter, strTextRight);
  2417. }
  2419. void CXTPCalendarThemeOffice2007::CTOWeekViewDayHeader::DoPropExchange(CXTPPropExchange* pPX)
  2420. {
  2421. ASSERT(pPX);
  2422. if (!pPX)
  2423. return;
  2425. CXTPPropExchangeSection secData(pPX->GetSection(_T("WeekViewDayHeader")));
  2426. if (pPX->IsStoring())
  2427. secData->EmptySection();
  2429. m_strHeaderFormat.DoPropExchange(&secData, _T("HeaderFormat"));
  2431. if (pPX->GetSchema() >= _XTP_SCHEMA_112)
  2432. m_UseOffice2003HeaderFormat.DoPropExchange(&secData, _T("UseOffice2003HeaderFormat"));
  2434. TBase::DoPropExchange(&secData);
  2435. }
  2437. void CXTPCalendarThemeOffice2007::CTOWeekViewDayHeader::Serialize(CArchive& ar)
  2438. {
  2439. m_strHeaderFormat.Serialize(ar);
  2440. m_UseOffice2003HeaderFormat.Serialize(ar);
  2442. TBase::Serialize(ar);
  2443. }
  2445. void CXTPCalendarThemeOffice2007::CTOWeekViewEvent_MultiDay::Draw(CCmdTarget* pObject, CDC* pDC)
  2446. {
  2447. CXTPCalendarThemeOffice2007* pThemeX = DYNAMIC_DOWNCAST(CXTPCalendarThemeOffice2007, GetTheme());
  2448. CXTPCalendarWeekViewEvent* pViewEvent = DYNAMIC_DOWNCAST(CXTPCalendarWeekViewEvent, pObject);
  2450. CXTPCalendarWeekViewDay* pMVDay = XTP_SAFE_GET2(pViewEvent, GetViewGroup(), GetViewDay(), NULL);
  2451. CXTPCalendarWeekView* pMView = XTP_SAFE_GET1(pMVDay, GetView(), NULL);
  2453. if (!pDC || !pThemeX || !pViewEvent || !pViewEvent->GetEvent() ||
  2454. !pMView || !pMVDay)
  2455. {
  2456. ASSERT(FALSE);
  2457. return;
  2458. }
  2460. BOOL bNoVisibleMDEvent = pViewEvent->IsMultidayEvent() && !pViewEvent->IsVisible();
  2462. int nMDEFlags = pViewEvent->GetMultiDayEventFlags();
  2463. ASSERT(0 == (nMDEFlags & xtpCalendarMultiDaySlave)); // error for week view.
  2465. if (bNoVisibleMDEvent)
  2466. {
  2467. return;
  2468. }
  2470. CRect rcEventMax(pViewEvent->GetViewEventRectMax());
  2471. CRect rcEvent(pViewEvent->GetEventRect());
  2472. if (rcEvent.IsRectEmpty())
  2473. {
  2474. return;
  2475. }
  2477. // fill event background
  2478. BOOL bSelected = pViewEvent->IsSelected();
  2479. COLORREF clrBorderNotSel;
  2480. COLORREF clrBorder;
  2481. CXTPPaintManagerColorGradient grclrBk;
  2483. GetEventColors(pDC, pViewEvent, clrBorder, clrBorderNotSel, grclrBk);
  2485. //----------------
  2486. pThemeX->DrawRoundRect(pDC, rcEvent, clrBorder, bSelected, grclrBk);
  2488. //------------------
  2489. int nViewDayIndex = pMVDay->GetDayIndex();
  2491. BOOL bFirstOnScreen = nViewDayIndex == 0;
  2492. BOOL bLastOnScreen = nViewDayIndex == 6;
  2494. CRect rcText(pViewEvent->GetTextRect());
  2496. if ((nMDEFlags & xtpCalendarMultiDayFirst) == 0)
  2497. {
  2498. //CRect rcSQ = rcEvent;
  2499. ////rcSQ.left += min(1, rcSQ.Width());
  2500. CRect rcSQ = rcEventMax;
  2501. rcSQ.left += min(1, rcSQ.Width());
  2503. rcSQ.right = min(rcEvent.left + cnCornerSize, rcEventMax.right);
  2504. CXTPCalendarTheme::DrawRectPartly(pDC, rcSQ, clrBorder, bSelected, grclrBk, CRect(0,1,0,1));
  2506. //-------------------------------------------------------------------
  2507. if (bFirstOnScreen)
  2508. {
  2509. CRect rcArrow;
  2510. BOOL bArrow = Draw_ArrowL(pViewEvent, pDC, rcArrow);
  2511. if (bArrow)
  2512. rcText.left = rcArrow.right;
  2513. }
  2514. }
  2515. else if (bSelected)
  2516. {
  2517. // draw left Gripper
  2518. CRect rcGripper;
  2519. rcGripper.top = rcEvent.top + rcEvent.Height() / 2 - cnGripperSize / 2;
  2520. rcGripper.bottom = rcGripper.top + cnGripperSize;
  2521. rcGripper.left = rcEvent.left - 1;
  2522. rcGripper.right = rcGripper.left + cnGripperSize;
  2524. pDC->FillSolidRect(&rcGripper, m_clrGripperBackground);
  2525. CBrush brBorder(m_clrGripperBorder);
  2526. pDC->FrameRect(&rcGripper, &brBorder);
  2527. }
  2530. if ((nMDEFlags & xtpCalendarMultiDayLast) == 0)
  2531. {
  2532. //      CRect rcSQ = rcEvent;
  2533. //      rcSQ.left = max(rcEvent.right - cnCornerSize, rcEventMax.left);
  2534. //      //rcSQ.right -= min(2, rcSQ.Width());
  2535. CRect rcSQ = rcEventMax;
  2536. rcSQ.left = max(rcEvent.right - cnCornerSize, rcEventMax.left);
  2537. rcSQ.right -= min(2, rcSQ.Width());
  2538. CXTPCalendarTheme::DrawRectPartly(pDC, rcSQ, clrBorder, bSelected, grclrBk, CRect(0,1,0, 1));
  2540. //-------------------------------------------------------------------
  2541. if (bLastOnScreen)
  2542. {
  2543. CRect rcArrow;
  2544. BOOL bArrow = Draw_ArrowR(pViewEvent, pDC, rcArrow);
  2545. if (bArrow)
  2546. rcText.right = rcArrow.left;
  2547. }
  2548. }
  2549. else if (bSelected)
  2550. {
  2551. // draw right gripper
  2552. CRect rcGripper;
  2553. rcGripper.top = rcEvent.top + rcEvent.Height() / 2 - cnGripperSize / 2;
  2554. rcGripper.bottom = rcGripper.top + cnGripperSize;
  2555. rcGripper.right = rcEvent.right + 1;
  2556. rcGripper.left = rcGripper.right - cnGripperSize;
  2558. pDC->FillSolidRect(&rcGripper, m_clrGripperBackground);
  2559. CBrush brBorder(m_clrGripperBorder);
  2560. pDC->FrameRect(&rcGripper, &brBorder);
  2561. }
  2563. //****
  2564. pViewEvent->m_rcText.CopyRect(rcText);
  2566. //=====================================
  2567. CString strSubj = pViewEvent->GetItemTextSubject();
  2568. CString strLoc = pViewEvent->GetItemTextLocation();
  2570. if (!strLoc.IsEmpty())
  2571. {
  2572. strSubj += _T(";");
  2573. }
  2575. CThemeFontColorSet* pFntClr1 = bSelected ? &m_fcsetSelected.fcsetSubject : &m_fcsetNormal.fcsetSubject;
  2576. CThemeFontColorSet* pFntClr2 = bSelected ? &m_fcsetSelected.fcsetLocation : &m_fcsetNormal.fcsetLocation;
  2577. rcText.DeflateRect(3, 0, 3, 0);
  2579. pViewEvent->m_rcSubjectEditor.CopyRect(rcText);
  2580. pViewEvent->m_rcSubjectEditor.top = rcEvent.top + 2;
  2581. pViewEvent->m_rcSubjectEditor.bottom = rcEvent.bottom - 2;
  2582. pViewEvent->AdjustSubjectEditor();
  2584. CRect rcIconsMax = rcText;
  2585. rcIconsMax.left = min(rcIconsMax.left + rcText.Height(), rcIconsMax.right);
  2587. //
  2588. BOOL bMarkupDrawn = FALSE;
  2589. if (pThemeX->GetCalendarControl()->IsMarkupEnabled())
  2590. {
  2591. CXTPMarkupContext* pMarkupContext = pThemeX->GetCalendarControl()->GetMarkupContext();
  2592. ASSERT(pMarkupContext);
  2594. CXTPMarkupUIElement* pUIElement = pViewEvent->GetMarkupUIElement();
  2596. if (pUIElement && pMarkupContext)
  2597. {
  2598. CSize szIcons = Draw_Icons(pViewEvent, pDC, rcIconsMax, TRUE);
  2600. if (rcIconsMax.Height() > szIcons.cy)
  2601. {
  2602. rcIconsMax.bottom -= (rcIconsMax.Height() - szIcons.cy) / 2 + 1;
  2603. }
  2605. rcText.right = max(rcText.left,  rcText.right - szIcons.cx - 2);
  2607. //---------------------------------------------------------------
  2608. XTPMarkupSetDefaultFont(pMarkupContext, (HFONT)pFntClr1->Font()->GetSafeHandle(), pFntClr1->Color());
  2610. XTPMarkupRenderElement(pUIElement, pDC->GetSafeHdc(), rcText);
  2612. bMarkupDrawn = TRUE;
  2613. }
  2614. }
  2615. //
  2617. //----------------------------------------------------
  2618. if (!bMarkupDrawn)
  2619. {
  2620. UINT uTextShortAlign = DT_VCENTER | DT_LEFT;
  2621. CSize szText = pThemeX->DrawLine2_CenterLR(pDC, strSubj, strLoc, pFntClr1, pFntClr2,
  2622. rcText, uTextShortAlign | DT_CALCRECT);
  2624. //--- calculate rects and fix to be centered if enough space ---
  2625. CSize szIcons = Draw_Icons(pViewEvent, pDC, rcIconsMax, TRUE);
  2627. if (rcIconsMax.Height() > szIcons.cy)
  2628. {
  2629. rcIconsMax.bottom -= (rcIconsMax.Height() - szIcons.cy) / 2;
  2630. }
  2632. int nTIcx = szText.cx + szIcons.cx;
  2633. if (nTIcx + 5 < rcText.Width())
  2634. {
  2635. int ncx_2 = (rcText.Width() - nTIcx) / 2 - 2;
  2636. rcText.left += ncx_2;
  2637. rcText.right = rcText.left + szText.cx + 2;
  2639. rcIconsMax.right -= ncx_2;
  2640. }
  2641. else
  2642. {
  2643. rcText.right -= szIcons.cx + 2;
  2644. }
  2646. pThemeX->DrawLine2_CenterLR(pDC, strSubj, strLoc, pFntClr1, pFntClr2,
  2647. rcText, uTextShortAlign);
  2648. }
  2650. Draw_Icons(pViewEvent, pDC, rcIconsMax);
  2651. }
  2653. void CXTPCalendarThemeOffice2007::CTOWeekViewEvent_SingleDay::Draw(CCmdTarget* pObject, CDC* pDC)
  2654. {
  2655. CXTPCalendarThemeOffice2007* pThemeX = DYNAMIC_DOWNCAST(CXTPCalendarThemeOffice2007, GetTheme());
  2656. CXTPCalendarWeekViewEvent* pViewEvent = DYNAMIC_DOWNCAST(CXTPCalendarWeekViewEvent, pObject);
  2657. if (!pDC || !pThemeX || !pViewEvent)
  2658. {
  2659. ASSERT(FALSE);
  2660. return;
  2661. }
  2663. if (!pViewEvent->IsVisible())
  2664. {
  2665. return;
  2666. }
  2668. CRect rcEvent(pViewEvent->GetEventRect());
  2669. if (rcEvent.IsRectEmpty())
  2670. {
  2671. return;
  2672. }
  2674. // fill event background
  2675. Draw_Background(pDC, rcEvent, pViewEvent);
  2677. //
  2678. BOOL bMarkupDrawn = FALSE;
  2679. if (pThemeX->GetCalendarControl()->IsMarkupEnabled())
  2680. {
  2681. CXTPMarkupContext* pMarkupContext = pThemeX->GetCalendarControl()->GetMarkupContext();
  2682. ASSERT(pMarkupContext);
  2684. CXTPMarkupUIElement* pUIElement = pViewEvent->GetMarkupUIElement();
  2686. if (pUIElement && pMarkupContext)
  2687. {
  2688. BOOL bSelected = pViewEvent->IsSelected();
  2689. CThemeFontColorSet* pFntClr1 = bSelected ? &m_fcsetSelected.fcsetSubject : &m_fcsetNormal.fcsetSubject;
  2691. CRect rcText = rcEvent;
  2692. rcText.DeflateRect(3, 2, 3, 2);
  2693. CRect rcIconsMax = rcText;
  2695. CSize szIcons = Draw_Icons(pViewEvent, pDC, rcIconsMax, TRUE);
  2697. if (rcIconsMax.Height() > szIcons.cy)
  2698. {
  2699. rcIconsMax.bottom -= (rcIconsMax.Height() - szIcons.cy) / 2 + 1;
  2700. }
  2702. rcText.right = max(rcText.left,  rcText.right - szIcons.cx - 2);
  2704. //---------------------------------------------------------------
  2705. XTPMarkupSetDefaultFont(pMarkupContext, (HFONT)pFntClr1->Font()->GetSafeHandle(), pFntClr1->Color());
  2707. XTPMarkupRenderElement(pUIElement, pDC->GetSafeHdc(), rcText);
  2709. bMarkupDrawn = TRUE;
  2711. Draw_Icons(pViewEvent, pDC, rcIconsMax);
  2712. }
  2713. }
  2714. //
  2716. if (!bMarkupDrawn)
  2717. {
  2718. Draw_Time(pDC, rcEvent, pViewEvent);
  2720. CRect rcText(pViewEvent->GetTextRect());
  2721. Draw_Caption(pDC, rcText, pViewEvent);
  2722. }
  2723. }
  2725. void CXTPCalendarThemeOffice2007::CTOWeekViewEvent_SingleDay::
  2726. Draw_Background(CDC* pDC, const CRect& rcEventRect, CXTPCalendarWeekViewEvent* pViewEvent)
  2727. {
  2728. CXTPCalendarThemeOffice2007* pThemeX = DYNAMIC_DOWNCAST(CXTPCalendarThemeOffice2007, GetTheme());
  2730. if (!pDC || !pThemeX || !pViewEvent || !pViewEvent->GetEvent())
  2731. {
  2732. ASSERT(FALSE);
  2733. return;
  2734. }
  2735. BOOL bSelected = pViewEvent->IsSelected();
  2737. COLORREF clrBorderNotSel, clrBorder;
  2738. CXTPPaintManagerColorGradient grclrBk;
  2739. int nColorsSrc_1Cat2Lbl = 0;
  2740. GetEventColors(pDC, pViewEvent, clrBorder, clrBorderNotSel, grclrBk, bSelected, &nColorsSrc_1Cat2Lbl);
  2742. if (!bSelected && nColorsSrc_1Cat2Lbl > 0)
  2743. {
  2744. clrBorder = grclrBk.clrLight;
  2745. }
  2747. pThemeX->DrawRoundRect(pDC, rcEventRect, clrBorder, bSelected, grclrBk);
  2748. }
  2750. CSize CXTPCalendarThemeOffice2007::CTOWeekViewEvent_SingleDay::Draw_Time(
  2751. CDC* pDC, const CRect& rcEventRect, CXTPCalendarWeekViewEvent* pViewEvent)
  2752. {
  2753. CSize szResult(0, 0);
  2755. if (!pDC || !pViewEvent || !pViewEvent->GetEvent())
  2756. {
  2757. ASSERT(FALSE);
  2758. return szResult;
  2759. }
  2761. BOOL bSelected = pViewEvent->IsSelected();
  2763. CFont* pFont = bSelected ? m_fcsetSelected.fcsetStartEnd.Font() : m_fcsetNormal.fcsetStartEnd.Font();
  2764. COLORREF clrColor = bSelected ? m_fcsetSelected.fcsetStartEnd.Color() : m_fcsetNormal.fcsetStartEnd.Color();
  2766. CXTPFontDC autoFont(pDC, pFont, clrColor);
  2768. //--------------------------
  2769. //*****************
  2770. // not implemented for office 2007 theme.
  2771. //if (pViewEvent->IsTimeAsClock()) {}
  2772. //*****************
  2774. CString strStartTime = pViewEvent->GetItemTextStartTime();
  2775. CString strEndTime = pViewEvent->GetItemTextEndTime();
  2777. CSize szStart = pDC->GetTextExtent(strStartTime);
  2778. CSize szEnd = pDC->GetTextExtent(strEndTime);
  2780. CRect rcStart(rcEventRect);
  2781. CRect rcEnd(rcEventRect);
  2783. DWORD dwOpt = XTP_SAFE_GET3(GetTheme(), GetCalendarControl(), GetCalendarOptions(), dwAdditionalOptions, 0);
  2785. BOOL bShowEndTime = XTP_SAFE_GET2(pViewEvent, GetCalendarControl(), WeekView_IsShowEndDate(), TRUE);
  2786. BOOL bDrawStartTime = szStart.cx + 6 < rcEventRect.Width()/2 ||
  2787.   (dwOpt & xtpCalendarOptMonthViewShowStartTimeAlways);
  2788. BOOL bDrawEndTime = bShowEndTime && szStart.cx + szEnd.cx + 6 * 2 < rcEventRect.Width()/2 ||
  2789. (dwOpt & xtpCalendarOptMonthViewShowEndTimeAlways);
  2791. if (!bDrawStartTime && !bDrawEndTime)
  2792. {
  2793. return szResult;
  2794. }
  2796. rcStart.left = min(rcStart.left + 4, rcStart.right);
  2797. rcStart.right = min(rcStart.left + szStart.cx + 6, rcStart.right);
  2799. rcEnd.left = rcStart.right;
  2800. rcEnd.right = min(rcEnd.left + szEnd.cx + 6, rcEnd.right);
  2801. if (!bDrawEndTime)
  2802. {
  2803. rcEnd.right = rcEnd.left;
  2804. }
  2806. //-------------------------------------------------
  2807. UINT uAlign = DT_VCENTER | DT_SINGLELINE | DT_LEFT;
  2808. pDC->DrawText(strStartTime, &rcStart, uAlign);
  2810. if (bDrawEndTime)
  2811. {
  2812. pDC->DrawText(strEndTime, &rcEnd, uAlign);
  2813. }
  2815. //-------------------------------------------------
  2816. pViewEvent->m_rcStartTime.CopyRect(&rcStart);
  2817. pViewEvent->m_rcEndTime.CopyRect(&rcEnd);
  2819. pViewEvent->m_rcText.left = rcEnd.right;
  2821. //-------------------------------------------------
  2822. szResult.cx = max(0, rcEnd.right - rcStart.left);
  2823. szResult.cy = szStart.cy;
  2825. return szResult;
  2826. }
  2828. void CXTPCalendarThemeOffice2007::CTOWeekViewEvent_SingleDay::Draw_Caption(
  2829. CDC* pDC, const CRect& rcTextRect, CXTPCalendarWeekViewEvent* pViewEvent)
  2830. {
  2831. CXTPCalendarThemeOffice2007* pThemeX = DYNAMIC_DOWNCAST(CXTPCalendarThemeOffice2007, GetTheme());
  2832. if (!pDC || !pViewEvent || !pThemeX )
  2833. {
  2834. ASSERT(FALSE);
  2835. return;
  2836. }
  2838. CString strSubj = pViewEvent->GetItemTextSubject();
  2839. CString strLoc = pViewEvent->GetItemTextLocation();
  2841. if (!strLoc.IsEmpty())
  2842. {
  2843. strSubj += _T(";");
  2844. }
  2846. BOOL bSelected = pViewEvent->IsSelected();
  2847. CThemeFontColorSet* pFntClr1 = bSelected ? &m_fcsetSelected.fcsetSubject : &m_fcsetNormal.fcsetSubject;
  2848. CThemeFontColorSet* pFntClr2 = bSelected ? &m_fcsetSelected.fcsetLocation : &m_fcsetNormal.fcsetLocation;
  2850. CRect rcText = rcTextRect;
  2851. //rcText.DeflateRect(1, 2, 3, 2);
  2853. pViewEvent->m_rcSubjectEditor.CopyRect(rcText);
  2854. pViewEvent->AdjustSubjectEditor();
  2856. UINT nAlign = DT_VCENTER | DT_LEFT | DT_SINGLELINE;
  2857. CSize szText = pThemeX->DrawLine2_CenterLR(pDC, strSubj, strLoc, pFntClr1, pFntClr2,
  2858. rcText, nAlign  | DT_CALCRECT, nAlign);
  2860. //----------------------------------------------------
  2861. CRect rcIconsMax = rcText;
  2862. rcIconsMax.left = min(rcIconsMax.left + rcTextRect.Height(), rcIconsMax.right);
  2864. //--- calculate rects and fix to be centered if enough space ---
  2865. CSize szIcons = Draw_Icons(pViewEvent, pDC, rcIconsMax, TRUE);
  2867. if (rcIconsMax.Height() > szIcons.cy)
  2868. {
  2869. rcIconsMax.bottom -= (rcIconsMax.Height() - szIcons.cy) / 2;
  2870. }
  2872. int nTIcx = szText.cx + szIcons.cx;
  2873. if (nTIcx > rcText.Width())
  2874. {
  2875. rcText.right = max(rcIconsMax.left, rcIconsMax.right - szIcons.cx) - 2;
  2876. }
  2878. pThemeX->DrawLine2_CenterLR(pDC, strSubj, strLoc, pFntClr1, pFntClr2,
  2879. rcText, nAlign, nAlign);
  2881. Draw_Icons(pViewEvent, pDC, rcIconsMax);
  2882. }
  2884. void CXTPCalendarThemeOffice2007::CTOPrevNextEventButton::RefreshMetrics(BOOL /*bRefreshChildren*/)
  2885. {
  2886. m_bPrev = 0 == _tcsnicmp(GetInstanceName(), _T("Prev"), 4);
  2888. m_nBitmapID.SetStandardValue(xtpIMG_PrevNextEventButtons) ;
  2889. m_rcBitmapBorder.SetStandardValue(CRect(1, 8, 1, 8));
  2891. if (!GetTheme())
  2892. return;
  2894. LOGFONT lfVert;
  2895. VERIFY( GetTheme()->m_fntBaseFont->GetLogFont(&lfVert) );
  2896. lfVert.lfOrientation = 900;
  2897. lfVert.lfEscapement = 900;
  2898. if (XTPDrawHelpers()->FontExists(XTP_CALENDAR_OFFICE2007_FONT_NAME))
  2899. {
  2900. STRCPY_S(lfVert.lfFaceName, LF_FACESIZE, XTP_CALENDAR_OFFICE2007_FONT_NAME);
  2901. }
  2902. else
  2903. {
  2904. STRCPY_S(lfVert.lfFaceName, LF_FACESIZE, XTPDrawHelpers()->GetVerticalFontName(TRUE));
  2905. }
  2907. m_fcsetText.fntFont.SetStandardValue(&lfVert);
  2908. m_fcsetText.clrColor.SetStandardValue(RGB(0, 0, 0));
  2909. m_clrDisabledText.SetStandardValue(RGB(136, 128, 128));
  2911. m_strText.SetStandardValue(XTPResourceManager()->LoadString(m_bPrev ? XTP_IDS_CALENDAR_PREVAPPOINTMENT : XTP_IDS_CALENDAR_NEXTAPPOINTMENT));
  2912. }
  2914. CSize CXTPCalendarThemeOffice2007::CTOPrevNextEventButton::GetSize(const CRect* prcRect)
  2915. {
  2916. CSize szSize(23, 172);
  2918. if (prcRect)
  2919. {
  2920. if (prcRect->Height() < 35 ||
  2921. prcRect->Width() < szSize.cx * 2 + 1)
  2922. {
  2923. szSize.cx = szSize.cy = 0;
  2924. }
  2925. else if (szSize.cy + 70 > prcRect->Height())
  2926. {
  2927. szSize.cy = 34;
  2928. }
  2929. }
  2931. return szSize;
  2932. }
  2934. CRect CXTPCalendarThemeOffice2007::CTOPrevNextEventButton::GetRect()
  2935. {
  2936. if (m_bVisible)
  2937. return m_rcRect;
  2938. else
  2939. return CRect(0, 0, 0, 0);
  2940. }
  2942. void CXTPCalendarThemeOffice2007::CTOPrevNextEventButton::AdjustLayout(CXTPCalendarView* /*pObject*/, CDC* /*pDC*/, const CRect& rcRect)
  2943. {
  2944. CSize szSize = GetSize(&rcRect);
  2945. m_rcRect = rcRect;
  2947. m_rcRect.top += (rcRect.Height() - szSize.cy) / 2;
  2948. m_rcRect.bottom = m_rcRect.top + szSize.cy;
  2950. if (m_bPrev)
  2951. {
  2952. m_rcRect.left++;
  2953. m_rcRect.right = m_rcRect.left + szSize.cx;
  2954. }
  2955. else
  2956. {
  2957. m_rcRect.right--;
  2958. m_rcRect.left = m_rcRect.right - szSize.cx;
  2959. }
  2960. }
  2962. void CXTPCalendarThemeOffice2007::CTOPrevNextEventButton::Draw(CXTPCalendarView* /*pObject*/, CDC* pDC)
  2963. {
  2964. if (m_rcRect.IsRectEmpty() || !m_bVisible || !GetTheme() || !GetTheme()->GetImageList())
  2965. return;
  2967. UINT nButmapID = (UINT)(int)m_nBitmapID;
  2968. // Lookup for bitmap
  2969. CXTPOffice2007Image* pImage = GetTheme()->GetImageList()->GetBitmap(nButmapID);
  2970. ASSERT(pImage);
  2972. CXTPOffice2007Image* pArrow = GetTheme()->GetBitmap(_T("CalendarPrevNextEventButtonArr"));
  2973. ASSERT(pArrow);
  2975. if (!pImage || !pArrow)
  2976. {
  2977. #ifdef _DEBUG
  2978. pDC->FillSolidRect(m_rcRect, RGB(200, 0, 0));
  2979. #else
  2980. m_bVisible = FALSE;
  2981. #endif
  2982. return;
  2983. }
  2985. //------------------------------------------
  2986. m_bHot = HitTest();
  2988. int nBkIdx = (m_bPrev ? 0 : 2) + (m_bHot && !m_bDisabled ? 1 : 0);
  2989. int nArrIdx = (m_bPrev ? 0 : 2) + (m_bDisabled ? 1 : 0);
  2991. CRect rcBkSrc = pImage->GetSource(nBkIdx, 4);
  2992. CRect rcArrSrc = pArrow->GetSource(nArrIdx, 4);
  2994. CRect rcArrDest = m_rcRect;
  2995. rcArrDest.OffsetRect(9, 12);
  2996. rcArrDest.right = rcArrDest.left + rcArrSrc.Width();
  2997. rcArrDest.bottom = rcArrDest.top + rcArrSrc.Height();
  2999. pImage->DrawImage(pDC, m_rcRect, rcBkSrc, m_rcBitmapBorder, RGB(255, 0, 255));
  3000. pArrow->DrawImage(pDC, rcArrDest, rcArrSrc, CRect(0,0,0,0), RGB(255, 0, 255));
  3002. //-------------------------------------------
  3003. CRect rcText = m_rcRect;
  3004. rcText.top = rcArrDest.bottom;
  3005. if (rcText.Height() > 100)
  3006. {
  3007. rcText.DeflateRect(1, 3, 1, 3);
  3009. int nTmp = rcText.top;
  3010. rcText.top = rcText.bottom;
  3011. rcText.bottom = nTmp;
  3013. int nRectSize = abs(rcText.Height());
  3015. //---
  3016. COLORREF clrText = m_bDisabled ? (COLORREF)m_clrDisabledText : (COLORREF)m_fcsetText.clrColor;
  3017. CXTPFontDC autoFont(pDC, m_fcsetText.fntFont, clrText);
  3018. CSize szText = pDC->GetTextExtent(m_strText);
  3020. // Center text vertically
  3021. if (szText.cx + 7 < nRectSize)
  3022. {
  3023. rcText.top = max(rcText.top - (nRectSize - szText.cx)/2, rcText.bottom);
  3024. }
  3026. if (szText.cy < rcText.Width())
  3027. {
  3028. rcText.left += (rcText.Width() - szText.cy) / 2;
  3029. }
  3031. pDC->DrawText((const CString&)m_strText, &rcText, DT_NOPREFIX | DT_SINGLELINE); //| DT_NOCLIP
  3032. }
  3033. }
  3035. int CXTPCalendarThemeOffice2007::CTOPrevNextEventButton::HitTest(const CPoint* pPoint/* = NULL*/)
  3036. {
  3037. if (!m_bVisible || !GetTheme())
  3038. return 0;
  3040. CPoint pt(0, 0);
  3041. if (pPoint)
  3042. {
  3043. pt = *pPoint;
  3044. }
  3045. else if (GetTheme()->GetCalendarControl()->GetSafeHwnd() && GetCursorPos(&pt))
  3046. {
  3047. GetTheme()->GetCalendarControl()->ScreenToClient(&pt);
  3048. }
  3050. if (m_rcRect.PtInRect(pt))
  3051. {
  3052. return m_bPrev ? xtpCalendarHitTestPrevEventButton : xtpCalendarHitTestNextEventButton;
  3053. }
  3055. return 0;
  3056. }
  3058. void CXTPCalendarThemeOffice2007::CTOPrevNextEventButton::OnMouseMove(CCmdTarget* /*pObject*/, UINT /*nFlags*/, CPoint point)
  3059. {
  3060. CXTPCalendarThemeOffice2007* pThemeX = DYNAMIC_DOWNCAST(CXTPCalendarThemeOffice2007, GetTheme());
  3061. if (!pThemeX )
  3062. {
  3063. ASSERT(FALSE);
  3064. return;
  3065. }
  3067. BOOL bHotNew = !!HitTest(&point);
  3068. if (m_bHot != bHotNew)
  3069. {
  3070. CXTPCalendarControl::CUpdateContext updateContext(pThemeX->GetCalendarControl(), xtpCalendarUpdateRedraw);
  3071. }
  3072. }
  3074. BOOL CXTPCalendarThemeOffice2007::CTOPrevNextEventButton::OnLButtonDown(CCmdTarget* /*pObject*/, UINT /*nFlags*/, CPoint point)
  3075. {
  3076. CXTPCalendarThemeOffice2007* pThemeX = DYNAMIC_DOWNCAST(CXTPCalendarThemeOffice2007, GetTheme());
  3077. if (!pThemeX || !pThemeX->GetPrevNextEventControllerPartX())
  3078. {
  3079. ASSERT(FALSE);
  3080. return FALSE;
  3081. }
  3082. BOOL bHitTest = HitTest(&point);
  3083. if (bHitTest)
  3084. {
  3085. COleDateTime dtDay;
  3086. BOOL bDayValid = FALSE;
  3088. if (m_bPrev)
  3089. bDayValid = pThemeX->GetPrevNextEventControllerPartX()->GetPrevEventDay(&dtDay);
  3090. else
  3091. bDayValid = pThemeX->GetPrevNextEventControllerPartX()->GetNextEventDay(&dtDay);
  3093. CXTPCalendarView* pView = XTP_SAFE_GET2(GetTheme(), GetCalendarControl(), GetActiveView(), NULL);
  3094. ASSERT(pView);
  3095. if (pView && bDayValid)
  3096. {
  3097. XTPCalendarViewType nViewType = pView->GetViewType();
  3098. pView->ShowDay(dtDay);
  3100. pView = GetTheme()->GetCalendarControl()->GetActiveView();
  3102. if (pView && pView->GetViewType() != nViewType)
  3103. GetTheme()->GetCalendarControl()->SwitchActiveView(nViewType);
  3104. }
  3105. }
  3107. return bHitTest;
  3108. }
  3110. void CXTPCalendarThemeOffice2007::CTOPrevNextEventController::AdjustLayout(CXTPCalendarView* /*pObject*/, CDC* pDC, const CRect& rcRect)
  3111. {
  3112. CXTPCalendarThemeOffice2007* pThemeX = DYNAMIC_DOWNCAST(CXTPCalendarThemeOffice2007, GetTheme());
  3113. if (!pThemeX || !GetPrevEventButtonPartX() || !GetNextEventButtonPartX())
  3114. {
  3115. ASSERT(FALSE);
  3116. return;
  3117. }
  3119. m_rcRect = rcRect;
  3121. BOOL bIsPrevNextButtonsVisible = IsPrevNextButtonsVisible();
  3122. if (pDC && pDC->IsPrinting())
  3123. bIsPrevNextButtonsVisible = FALSE;
  3125. GetPrevEventButtonPartX()->m_bVisible = bIsPrevNextButtonsVisible;
  3126. GetNextEventButtonPartX()->m_bVisible = bIsPrevNextButtonsVisible;
  3128. if (!bIsPrevNextButtonsVisible)
  3129. {
  3130. _StopRequests();
  3131. }
  3132. else
  3133. {
  3134. GetPrevEventButtonPartX()->m_bDisabled = !GetPrevEventDay();
  3135. GetNextEventButtonPartX()->m_bDisabled = !GetNextEventDay();
  3137. }
  3139. //--------------------------------------------
  3140. if (GetPrevEventButtonPartX())
  3141. GetPrevEventButtonPartX()->AdjustLayout(NULL, pDC, rcRect);
  3143. if (GetNextEventButtonPartX())
  3144. GetNextEventButtonPartX()->AdjustLayout(NULL, pDC, rcRect);
  3145. }
  3147. void CXTPCalendarThemeOffice2007::CTOPrevNextEventController::Draw(CXTPCalendarView* /*pObject*/, CDC* pDC)
  3148. {
  3149. if (GetPrevEventButtonPartX())
  3150. GetPrevEventButtonPartX()->Draw(NULL, pDC);
  3152. if (GetNextEventButtonPartX())
  3153. GetNextEventButtonPartX()->Draw(NULL, pDC);
  3154. }
  3156. int CXTPCalendarThemeOffice2007::CTOPrevNextEventController::HitTest(const CPoint* pPoint)
  3157. {
  3158. int nHit = 0;
  3159. if (GetPrevEventButtonPartX())
  3160. nHit = GetPrevEventButtonPartX()->HitTest(pPoint);
  3162. if (!nHit && GetNextEventButtonPartX())
  3163. nHit = GetNextEventButtonPartX()->HitTest(pPoint);
  3165. return nHit;
  3166. }
  3168. void CXTPCalendarThemeOffice2007::CTOPrevNextEventController::OnMouseMove(CCmdTarget* pObject, UINT nFlags, CPoint point)
  3169. {
  3170. if (GetPrevEventButtonPartX())
  3171. GetPrevEventButtonPartX()->OnMouseMove(pObject, nFlags, point);
  3173. if (GetNextEventButtonPartX())
  3174. GetNextEventButtonPartX()->OnMouseMove(pObject, nFlags, point);
  3175. }
  3177. BOOL CXTPCalendarThemeOffice2007::CTOPrevNextEventController::OnLButtonDown(CCmdTarget* pObject, UINT nFlags, CPoint point)
  3178. {
  3179. BOOL b1 = FALSE, b2 = FALSE;
  3181. if (GetPrevEventButtonPartX())
  3182. b1 = GetPrevEventButtonPartX()->OnLButtonDown(pObject, nFlags, point);
  3184. if (GetNextEventButtonPartX())
  3185. b2 = GetNextEventButtonPartX()->OnLButtonDown(pObject, nFlags, point);
  3187. return b1 || b2;
  3188. }
  3190. void CXTPCalendarThemeOffice2007::CTOPrevNextEventController::OnStatusChanged()
  3191. {
  3192. CXTPCalendarThemeOffice2007* pThemeX = DYNAMIC_DOWNCAST(CXTPCalendarThemeOffice2007, GetTheme());
  3193. if (!pThemeX )
  3194. {
  3195. ASSERT(FALSE);
  3196. return;
  3197. }
  3199. CXTPCalendarControl::CUpdateContext updateContext(pThemeX->GetCalendarControl(), xtpCalendarUpdateRedraw);
  3201. AdjustLayout(NULL, NULL, m_rcRect);
  3203. DBG_TRACE_PREVNEXTBTN(_T("PrevNextEventController::OnStatusChanged() n"));
  3204. }
  3207. BOOL CXTPCalendarThemeOffice2007::CTOPrevNextEventController::IsPrevNextButtonsVisible()
  3208. {
  3209. HWND hWnd = XTP_SAFE_GET2(GetTheme(), GetCalendarControl(), GetSafeHwnd(), NULL);
  3210. if (!hWnd)
  3211. return FALSE;
  3213. return !_IsSomeEventVisible();
  3214. }
  3216. BOOL CXTPCalendarThemeOffice2007::CTOPrevNextEventController::_IsSomeEventVisible()
  3217. {
  3218. CXTPCalendarView* pView = XTP_SAFE_GET2(GetTheme(), GetCalendarControl(), GetActiveView(), NULL);
  3219. ASSERT(pView);
  3220. if (!pView)
  3221. return FALSE;
  3223. int nDays = pView->GetViewDayCount();
  3224. for (int nDay = 0; nDay < nDays; nDay++)
  3225. {
  3226. CXTPCalendarViewDay* pDay = pView->GetViewDay_(nDay);
  3227. ASSERT(pDay);
  3228. if (!pDay)
  3229. continue;
  3230. int nGroupsCount = pDay->GetViewGroupsCount();
  3231. for (int i = 0; i < nGroupsCount; i++)
  3232. {
  3233. if (pDay->GetViewGroup_(i) && pDay->GetViewGroup_(i)->GetViewEventsCount())
  3234. return TRUE;
  3235. }
  3236. }
  3238. return FALSE;
  3239. }
  3241. COleDateTime CXTPCalendarThemeOffice2007::CTOPrevNextEventController::GetVisibleDay(BOOL bFirst)
  3242. {
  3243. CXTPCalendarView* pView = XTP_SAFE_GET2(GetTheme(), GetCalendarControl(), GetActiveView(), NULL);
  3244. ASSERT(pView);
  3245. if (!pView)
  3246. return (DATE)0;
  3248. if (bFirst)
  3249. {
  3250. return pView->GetViewDayDate(0);
  3251. }
  3253. int nDays = pView->GetViewDayCount();
  3254. return pView->GetViewDayDate(max(0, nDays - 1));
  3255. }
  3257. BOOL CXTPCalendarThemeOffice2007::CTOPrevNextEventController::GetPrevEventDay(COleDateTime* pdtDay)
  3258. {
  3259. if (pdtDay)
  3260. *pdtDay = COleDateTime((DATE)0);
  3262. long nFirstDay = (long)GetVisibleDay(TRUE);
  3263. long nPrevDay = 0;
  3265. int nCount = m_arNotEmptyDays.GetSize();
  3266. for (int i = 0; i < nCount; i++)
  3267. {
  3268. if (nFirstDay > m_arNotEmptyDays[i])
  3269. nPrevDay = m_arNotEmptyDays[i];
  3270. else
  3271. break;
  3272. }
  3274. if (nPrevDay > 0)
  3275. {
  3276. if (pdtDay)
  3277. *pdtDay = COleDateTime((DATE)nPrevDay);
  3278. return TRUE;
  3279. }
  3281. m_ndtRefreshDatePrev = nFirstDay - 1;
  3282. m_bScanPrev = TRUE;
  3283. _RequestToFindEvents();
  3286. return FALSE;
  3288. }
  3290. BOOL CXTPCalendarThemeOffice2007::CTOPrevNextEventController::GetNextEventDay(COleDateTime* pdtDay)
  3291. {
  3292. if (pdtDay)
  3293. *pdtDay = COleDateTime((DATE)0);
  3295. long nDay = (long)GetVisibleDay(FALSE);
  3296. long nNextDay = 0;
  3298. int nCount = m_arNotEmptyDays.GetSize();
  3299. for (int i = 0; i < nCount; i++)
  3300. {
  3301. if (nDay < m_arNotEmptyDays[i])
  3302. {
  3303. nNextDay = m_arNotEmptyDays[i];
  3304. break;
  3305. }
  3306. }
  3308. if (nNextDay > 0)
  3309. {
  3310. if (pdtDay)
  3311. *pdtDay = COleDateTime((DATE)nNextDay);
  3312. return TRUE;
  3313. }
  3315. m_ndtRefreshDateNext = nDay + 1;
  3316. m_bScanNext = TRUE;
  3317. _RequestToFindEvents();
  3319. return FALSE;
  3320. }
  3322. BOOL CXTPCalendarThemeOffice2007::CTOPrevNextEventController::OnTimer(UINT_PTR uTimerID)
  3323. {
  3324. if (m_nRefreshTimerID != (UINT)uTimerID)
  3325. return FALSE;
  3327. BOOL bIsEventsPrev = FALSE;
  3328. BOOL bIsEventsNext = FALSE;
  3330. if (m_bScanPrev && m_ndtRefreshDatePrev > m_ndtMinScanDay)
  3331. {
  3332. for (int i = 0; i < m_nRefreshDaysPerIdleStep; i++)
  3333. {
  3334. DBG_TRACE_PREVNEXTBTN(_T("%d - PrevNextEventController::_RefreshDay(-- %d) n"), m_nRefreshTimerID, m_ndtRefreshDatePrev);
  3336. bIsEventsPrev = _RefreshDay(m_ndtRefreshDatePrev);
  3337. m_ndtRefreshDatePrev--;
  3339. if (bIsEventsPrev)
  3340. {
  3341. m_bScanPrev = FALSE;
  3342. break;
  3343. }
  3344. }
  3345. }
  3346. else
  3347. {
  3348. m_bScanPrev = FALSE;
  3349. }
  3351. if (m_bScanNext && m_ndtRefreshDateNext < m_ndtMaxScanDay)
  3352. {
  3353. for (int i = 0; i < m_nRefreshDaysPerIdleStep; i++)
  3354. {
  3355. DBG_TRACE_PREVNEXTBTN(_T("%d - PrevNextEventController::_RefreshDay(%d ++) n"), m_nRefreshTimerID, m_ndtRefreshDateNext);
  3356. bIsEventsNext = _RefreshDay(m_ndtRefreshDateNext);
  3357. m_ndtRefreshDateNext++;
  3359. if (bIsEventsNext)
  3360. {
  3361. m_bScanNext = FALSE;
  3362. break;
  3363. }
  3364. }
  3365. }
  3366. else
  3367. {
  3368. m_bScanNext = FALSE;
  3369. }
  3372. BOOL bStatusChanged = bIsEventsPrev || bIsEventsNext;
  3374. if (!m_bScanPrev && !m_bScanNext)
  3375. {
  3376. DBG_TRACE_PREVNEXTBTN(_T("%d - PrevNextEventController::_StopRequests(Prev=%d, Next=%d) n"),
  3377.  m_nRefreshTimerID, m_bScanPrev, m_bScanNext);
  3379. _StopRequests();
  3380. bStatusChanged = TRUE;
  3381. }
  3383. if (bStatusChanged)
  3384. {
  3385. OnStatusChanged();
  3386. }
  3388. return TRUE;
  3389. }
  3391. BOOL CXTPCalendarThemeOffice2007::CTOPrevNextEventController::_RefreshDay(long ndtDay)
  3392. {
  3393. // TODO: Change to use multi-Data Providers from Resources
  3394. // also PrePopulate events have to be used too ???
  3395. //
  3396. CXTPCalendarData* pData = XTP_SAFE_GET2(GetTheme(), GetCalendarControl(), GetDataProvider(), NULL);
  3397. ASSERT(pData);
  3398. if (!pData)
  3399. return FALSE;
  3401. CXTPCalendarEventsPtr ptrEvents = pData->RetrieveDayEvents((DATE)ndtDay);
  3402. BOOL bIsEvents = ptrEvents && ptrEvents->GetCount() > 0;
  3403. if (bIsEvents)
  3404. m_arNotEmptyDays.AddDay(ndtDay);
  3405. else
  3406. m_arNotEmptyDays.RemoveElement(ndtDay);
  3408. return bIsEvents;
  3409. }
  3412. void CXTPCalendarThemeOffice2007::CTOPrevNextEventController::_RequestToFindEvents()
  3413. {
  3414. if (m_nRefreshTimerID)
  3415. return;
  3417. m_nRefreshTimerID = SetTimer((UINT)m_nIdleStepTime_ms);
  3418. ASSERT(m_nRefreshTimerID);
  3420. DBG_TRACE_PREVNEXTBTN(_T("n%d *** PrevNextEventController::_RequestToFindEvents() n"), m_nRefreshTimerID);
  3421. }
  3423. void CXTPCalendarThemeOffice2007::CTOPrevNextEventController::_StopRequests()
  3424. {
  3425. if (m_nRefreshTimerID)
  3426. KillTimer(m_nRefreshTimerID);
  3428. m_nRefreshTimerID = 0;
  3429. }
  3431. void CXTPCalendarThemeOffice2007::CTOPrevNextEventController::OnDetachCalendar()
  3432. {
  3433. _StopRequests();
  3434. }
  3436. /////////////////////////////////////////////////////////////////////////////