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

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

对话框与窗口

开发平台：

Visual C++

XTPCalendarPaintManager.cpp：源码内容
  1. // XTPCalendarPaintManager.cpp : implementation file
  2. //
  3. // This file is a part of the XTREME CALENDAR MFC class library.
  4. // (c)1998-2008 Codejock Software, All Rights Reserved.
  5. //
  6. // THIS SOURCE FILE IS THE PROPERTY OF CODEJOCK SOFTWARE AND IS NOT TO BE
  7. // RE-DISTRIBUTED BY ANY MEANS WHATSOEVER WITHOUT THE EXPRESSED WRITTEN
  8. // CONSENT OF CODEJOCK SOFTWARE.
  9. //
  10. // THIS SOURCE CODE CAN ONLY BE USED UNDER THE TERMS AND CONDITIONS OUTLINED
  11. // IN THE XTREME TOOLKIT PRO LICENSE AGREEMENT. CODEJOCK SOFTWARE GRANTS TO
  12. // YOU (ONE SOFTWARE DEVELOPER) THE LIMITED RIGHT TO USE THIS SOFTWARE ON A
  13. // SINGLE COMPUTER.
  14. //
  15. // CONTACT INFORMATION:
  16. // support@codejock.com
  17. // http://www.codejock.com
  18. //
  19. /////////////////////////////////////////////////////////////////////////////
  21. #include "stdafx.h"
  22. #include <math.h>
  23. #include "Resource.h"
  25. #include "Common/XTPVC50Helpers.h"
  26. #include "Common/XTPVC80Helpers.h"
  27. #include "Common/XTPResourceManager.h"
  29. #include "XTPCalendarControl.h"
  30. #include "XTPCalendarPaintManager.h"
  31. #include "XTPCalendarDayViewEvent.h"
  32. #include "XTPCalendarEvent.h"
  33. #include "XTPCalendarEventLabel.h"
  34. #include "XTPCalendarDayView.h"
  35. #include "XTPCalendarWeekView.h"
  36. #include "XTPCalendarMonthView.h"
  37. #include "XTPCalendarData.h"
  38. #include "XTPCalendarDayViewTimeScale.h"
  40. static const double dXTPMaxAlpha2003 = 75.;
  42. static const LPCTSTR cszGlyphsFontName = _T("MS Outlook");
  44. #ifdef _DEBUG
  45. #define new DEBUG_NEW
  46. #undef THIS_FILE
  47. static char THIS_FILE[] = __FILE__;
  48. #endif
  51. void CXTPCalendarPaintManager::CDayViewEventPart::OnDraw(CDC* pDC, CXTPCalendarDayViewEvent* pViewEvent)
  52. {
  53. if (!pDC || !pViewEvent || !pViewEvent->GetEvent() || !m_pPaintManager)
  54. {
  55. ASSERT(FALSE);
  56. return;
  57. }
  59. CRect rcEvent(pViewEvent->GetEventRect());
  60. if (rcEvent.IsRectEmpty())
  61. {
  62. return;
  63. }
  65. // fill event background
  66. CXTPCalendarEventLabel* ptrLabel = pViewEvent->GetEvent()->GetLabel();
  67. COLORREF crBackground = ptrLabel ? ptrLabel->m_clrColor : GetBackgroundColor();
  69. BOOL bSelected = pViewEvent->IsSelected();
  70. int nMDEFlags = pViewEvent->GetMultiDayEventFlags();
  72. BOOL bMultiDay = (nMDEFlags & xtpCalendarMultiDayFMLmask) != 0;
  74. DWORD dwAdditionalOpt = XTP_SAFE_GET3(pViewEvent, GetCalendarControl(), GetCalendarOptions(), dwAdditionalOptions, 0);
  76. CString strLoc = pViewEvent->GetItemTextLocation();
  77. CString strText = pViewEvent->GetItemTextSubject();
  78. if (strLoc.GetLength() > 0)
  79. {
  80. if (dwAdditionalOpt & xtpCalendarOptDayViewNoWordBreak)
  81. {
  82. strText += _T("n(") + strLoc + _T(")");
  83. }
  84. else
  85. {
  86. strText += _T(" (") + strLoc + _T(")");
  87. }
  88. }
  89. CString strTime;
  91. if (!bMultiDay)
  92. {
  93. COleDateTime dtStart = pViewEvent->GetEvent()->GetStartTime();
  94. COleDateTime dtEnd = pViewEvent->GetEvent()->GetEndTime();
  96. DWORD dwTimeFlags = xtpCalendarItemText_EventStartTimeText;
  97. if (!CXTPCalendarUtils::IsEqual(dtStart, dtEnd))
  98. dwTimeFlags = dwTimeFlags | xtpCalendarItemText_EventEndTimeText;
  100. strTime = pViewEvent->GetItemText(dwTimeFlags, pViewEvent->HideEventTime() ? _T("") : NULL);
  101. }
  103. CRect rcBorder(rcEvent);
  104. rcBorder.left += 1;
  106. pDC->FillSolidRect(rcBorder, crBackground);
  107. pDC->FillSolidRect(rcBorder.left, rcBorder.top, rcBorder.Width(), 1, m_pPaintManager->m_clrWindowText);
  108. pDC->FillSolidRect(rcBorder.left - 1, rcBorder.bottom - (bMultiDay ? 1 : 0),
  109. rcBorder.Width() + 1, 1, m_pPaintManager->m_clrWindowText);
  111. if (!bMultiDay)
  112. {
  113. pDC->FillSolidRect(rcBorder.right, rcBorder.top, 1, rcBorder.Height()+1, m_pPaintManager->m_clrWindowText);
  114. }
  116. if (bSelected && bMultiDay)
  117. {
  118. pDC->FillSolidRect(rcEvent.left, rcEvent.top + 1, rcEvent.Width(), rcEvent.Height() - 2, m_pPaintManager->m_clrButtonFace);
  119. pDC->FillSolidRect(rcEvent.left, rcEvent.top - 1, rcEvent.Width()+1, 1, m_pPaintManager->m_clrWindowText);
  120. pDC->FillSolidRect(rcEvent.left, rcEvent.bottom, rcEvent.Width()+1, 1, m_pPaintManager->m_clrWindowText);
  121. }
  123. if (nMDEFlags & xtpCalendarMultiDayFirst)
  124. {
  125. pDC->FillSolidRect(rcEvent.left, rcEvent.top, 1, rcEvent.Height(), m_pPaintManager->m_clrWindowText);
  126. rcEvent.left++;
  127. if (pViewEvent->GetFirstClockRect().Width() > 0)
  128. {
  129. m_pPaintManager->DrawClock(
  130. pDC,
  131. pViewEvent->GetEvent()->GetStartTime(),
  132. pViewEvent->GetFirstClockRect(),
  133. crBackground,
  134. xtpCalendarClockAlignLeft);
  135. }
  136. }
  137. if (nMDEFlags & xtpCalendarMultiDayLast)
  138. {
  139. pDC->FillSolidRect(rcEvent.right, rcEvent.top, 1, rcEvent.Height(), m_pPaintManager->m_clrWindowText);
  140. rcEvent.right -= 2;
  141. if (pViewEvent->GetLastClockRect().Width() > 0)
  142. {
  143. m_pPaintManager->DrawClock(
  144. pDC,
  145. pViewEvent->GetEvent()->GetEndTime(),
  146. pViewEvent->GetLastClockRect(),
  147. crBackground,
  148. xtpCalendarClockAlignLeft);
  149. }
  151. }
  153. UINT uAlign = 0;
  154. UINT uAlignWordBreak = 0;
  156. CRect rcText(pViewEvent->GetTextRect());
  157. CRect rcTime(rcText);
  158. BOOL bTimeOutOfBorders = FALSE;
  160. //  draw busy border
  161. if (!bMultiDay)
  162. {
  163. rcText.top += min(2, rcText.Height());
  164. rcTime.top = rcText.top;
  166. int nBusyStatus = pViewEvent->GetEvent()->GetBusyStatus();
  168. // fill busy area
  169. CRect rcBusyArea(rcEvent);
  170. //  draw border
  171. rcBusyArea.right = rcBusyArea.left + 7;
  172. //rcText.left = rcBusyArea.right + 3;
  173. pDC->FillSolidRect(rcBusyArea, m_pPaintManager->m_clrWindowText);
  174. //  draw background
  175. rcBusyArea.DeflateRect(1, 1, 1, 0);
  176. pDC->FillSolidRect(rcBusyArea, m_pPaintManager->m_clrWindow);
  178. if (pViewEvent->GetTimeframeRect().top == LONG_MAX ||
  179. pViewEvent->GetTimeframeRect().bottom == LONG_MAX)
  180. {
  181. POINT arBusyPoints[] =
  182. {
  183. {rcEvent.left, rcEvent.top},
  184. {rcEvent.left + 7, rcEvent.top},
  185. {rcEvent.left + 7, rcEvent.top + 7},
  186. {rcEvent.left, rcEvent.top}
  187. };
  188. const int cBPCount = sizeof(arBusyPoints) / sizeof(arBusyPoints[0]);
  189. CRgn rgnBusy;
  190. BOOL bRgn = rgnBusy.CreatePolygonRgn(arBusyPoints, cBPCount, ALTERNATE);
  191. ASSERT(bRgn);
  193. if (bRgn)
  194. {
  195. m_pPaintManager->DrawBusyStatus(pDC, rgnBusy, nBusyStatus);
  196. }
  197. }
  198. else
  199. {
  200. //  draw busy border
  201. rcBusyArea.top = pViewEvent->GetTimeframeRect().top;
  202. rcBusyArea.bottom = pViewEvent->GetTimeframeRect().bottom;
  203. pDC->FillSolidRect(rcBusyArea, m_pPaintManager->m_clrWindowText);
  204. //  draw busy color
  205. rcBusyArea.DeflateRect(0, 1, 0, 1);
  207. m_pPaintManager->DrawBusyStatus(pDC, rcBusyArea, nBusyStatus);
  208. }
  210. // draw shadow
  211. if (!bSelected)
  212. m_pPaintManager->DrawShadow(pDC, pViewEvent->GetEventRect());
  214. // draw border
  215. if (bSelected)
  216. {
  217. CBrush brushBorder(m_pPaintManager->m_clrWindowText);
  219. CRect rcBorder2(pViewEvent->GetEventRect());
  220. rcBorder2.right += 1;
  222. CRect rcBorderTop(rcBorder2);
  223. rcBorderTop.bottom = rcBorderTop.top + 1;
  224. rcBorderTop.top -= 5;
  226. m_pPaintManager->DrawBusyStatus(pDC, rcBorderTop, nBusyStatus);
  227. pDC->FrameRect(&rcBorderTop, &brushBorder);
  229. CRect rcBorderBottom(rcBorder2);
  230. rcBorderBottom.top = rcBorderBottom.bottom;
  231. rcBorderBottom.bottom += 6;
  233. m_pPaintManager->DrawBusyStatus(pDC, rcBorderBottom, nBusyStatus);
  234. pDC->FrameRect(&rcBorderBottom, &brushBorder);
  235. }
  236. rcText.right -= 4;
  238. uAlignWordBreak = (dwAdditionalOpt & xtpCalendarOptDayViewNoWordBreak) ? DT_WORD_ELLIPSIS : DT_WORDBREAK;
  239. uAlign |= DT_LEFT | uAlignWordBreak | DT_EDITCONTROL;
  241. //---------------------------------------------------------------------------
  242. if (!strTime.IsEmpty())
  243. {
  244. CString strTest = strTime;
  245. if (dwAdditionalOpt & xtpCalendarOptDayViewNoWordBreak)
  246. strTest += _T(" W...");
  248. CSize szTime = GetTextExtent(pDC, strTest);
  249. if (szTime.cx <= rcText.Width())
  250. {
  251. strText = strTime + _T(" ") + strText;
  252. strTime.Empty();
  253. }
  254. else
  255. {
  256. bTimeOutOfBorders = TRUE;
  257. rcTime.bottom = rcTime.top + szTime.cy;
  258. rcText.top = rcTime.bottom;
  259. }
  260. }
  261. }
  262. else
  263. {
  264. rcText.left += 3;
  265. CSize szText = GetTextExtent(pDC, strText);
  266. if (pViewEvent->IsMultyDayTextAlign() || szText.cx + 2 > rcText.Width())
  267. {
  268. uAlign |= DT_LEFT;
  269. }
  270. else
  271. {
  272. uAlign |= DT_CENTER;
  273. }
  274. uAlign |= DT_SINGLELINE;
  275. }
  277. m_pPaintManager->DrawIcons(pDC, pViewEvent);
  279. // draw event time, if need
  280. if (!strTime.IsEmpty())
  281. {
  282. DrawText(pDC, strTime, rcTime, DT_LEFT | DT_SINGLELINE | DT_VCENTER);
  283. }
  285. // draw event text
  286. DrawText(pDC, strText, rcText, uAlign | DT_VCENTER);
  288. // update OutOfBorders flag
  290. int nX_need = 0, nY_need = 0;
  291. if (uAlign & DT_SINGLELINE)
  292. {
  293. CSize szText = GetTextExtent(pDC, strText);
  294. nX_need = szText.cx;
  295. }
  296. else
  297. {
  298. CRect rcNeeded(0, 0, rcText.Width(), 0);
  299. DrawText(pDC, strText, rcNeeded, DT_CALCRECT | uAlignWordBreak);
  300. nY_need = rcNeeded.Height();
  301. }
  303. BOOL bOutOfBorders = nY_need > rcText.Height() ||
  304.  nX_need > rcText.Width() ||
  305.  bTimeOutOfBorders;
  306. pViewEvent->SetTextOutOfBorders(bOutOfBorders);
  307. }
  309. //////////////////////////////////////////////////////////////////////////
  310. CXTPCalendarPaintManager::CXTPShadowDrawer::CXTPShadowDrawer(CDC* pDC, double dMaxAlpha)
  311. : m_pDC(pDC), m_dMaxAlpha(dMaxAlpha)
  312. {
  313. ASSERT(m_pDC);
  314. }
  316. CXTPCalendarPaintManager::CXTPShadowDrawer::~CXTPShadowDrawer()
  317. {
  318. }
  320. int CXTPCalendarPaintManager::CXTPShadowDrawer::CheckValue(int iValue)
  321. {
  322. return ((iValue > 255) ? 255 : ((iValue < 0) ? 0 : iValue));
  323. }
  325. COLORREF CXTPCalendarPaintManager::CXTPShadowDrawer::AlphaPixel(const COLORREF crPixel, const UINT i)
  326. {
  327. return RGB(
  328.    CheckValue(GetRValue(crPixel)-i),
  329.    CheckValue(GetGValue(crPixel)-i),
  330.    CheckValue(GetBValue(crPixel)-i));
  331. }
  333. void CXTPCalendarPaintManager::DrawShadow(CDC* pDC, const CRect& rcRect)
  334. {
  335. ASSERT(pDC);
  336. if (!pDC || pDC->IsPrinting())
  337. {
  338. return;
  339. }
  341. CXTPShadowDrawer oShadow(pDC, dXTPMaxAlpha2003);
  343. CRect rcVShadow(rcRect);
  344. rcVShadow.left = rcVShadow.right;
  345. rcVShadow.right += 5;
  346. rcVShadow.top += 5;
  347. oShadow.DrawShadowRectPart(rcVShadow, CXTPShadowDrawer::xtpShadowLR);
  349. CRect rcHShadow(rcRect);
  350. rcHShadow.left += 7;
  351. rcHShadow.top = rcHShadow.bottom + 1;
  352. rcHShadow.bottom += 6;
  353. oShadow.DrawShadowRectPart(rcHShadow, CXTPShadowDrawer::xtpShadowTB);
  355. CRect rcTRShadow(rcVShadow);
  356. rcTRShadow.bottom = rcTRShadow.top;
  357. rcTRShadow.top -= 5;
  358. oShadow.DrawShadowRectPart(rcTRShadow, CXTPShadowDrawer::xtpShadowBR);
  360. CRect rcBRShadow(rcVShadow);
  361. rcBRShadow.top = rcBRShadow.bottom;
  362. rcBRShadow.bottom += 5;
  363. oShadow.DrawShadowRectPart(rcBRShadow, CXTPShadowDrawer::xtpShadowTR);
  365. CRect rcBLShadow(rcRect);
  366. rcBLShadow.right = rcBLShadow.left + 7;
  367. rcBLShadow.top = rcBLShadow.bottom + 1;
  368. rcBLShadow.bottom += 6;
  369. oShadow.DrawShadowRectPart(rcBLShadow, CXTPShadowDrawer::xtpShadowBL);
  370. }
  372. void CXTPCalendarPaintManager::CXTPShadowDrawer::DrawShadowRectPart(const CRect& rcShadow, const XTPShadowPart part)
  373. {
  374. ASSERT(m_pDC);
  375. if (!m_pDC || !m_pDC->GetSafeHdc())
  376. {
  377. return;
  378. }
  380. // start processing
  381. HDC hdc;               // handle of the DC we will create
  382. HBITMAP hbitmap;       // bitmap handle
  383. BITMAPINFO bmi;        // bitmap header
  384. ULONG   ulBitmapWidth, ulBitmapHeight;      // bitmap width/height
  385. VOID *pvBits;          // pointer to DIB section
  387. // create a DC for our bitmap -- the source DC for AlphaBlend
  388. hdc = ::CreateCompatibleDC(m_pDC->GetSafeHdc());
  389. if (!hdc)
  390. return;
  392. // setup bitmap info
  393. // zero the memory for the bitmap info
  394. ZeroMemory(&bmi, sizeof(BITMAPINFO));
  395. // set the bitmap width and height. Later on, the blending will occur in the center of each of the three areas.
  396. bmi.bmiHeader.biSize = sizeof(BITMAPINFOHEADER);
  397. bmi.bmiHeader.biWidth = ulBitmapWidth = max(rcShadow.Width(), 0);
  398. bmi.bmiHeader.biHeight = ulBitmapHeight = max(rcShadow.Height(), 0);
  399. bmi.bmiHeader.biPlanes = 1;
  400. bmi.bmiHeader.biBitCount = 32;         // four 8-bit components
  401. bmi.bmiHeader.biCompression = BI_RGB;
  402. bmi.bmiHeader.biSizeImage = ulBitmapWidth * ulBitmapHeight * 4;
  403. // create our DIB section and select the bitmap into the dc
  404. if ((ulBitmapWidth > 0) && (ulBitmapHeight > 0))
  405. {
  406. hbitmap = CreateDIBSection(hdc, &bmi, DIB_RGB_COLORS, &pvBits, NULL, 0x0);
  407. if (hbitmap)
  408. {
  409. HGDIOBJ hOld = SelectObject(hdc, hbitmap);
  410. // Copy old picture values to the created bitmap
  411. if (::BitBlt(hdc, 0, 0, ulBitmapWidth, ulBitmapHeight,
  412. m_pDC->GetSafeHdc(), rcShadow.left, rcShadow.top, SRCCOPY))
  413. {
  415. // Adjust all pixels of the picture
  416. switch (part)
  417. {
  418. case xtpShadowLR:
  419. ApplyShadowLR((UINT*)pvBits, ulBitmapWidth, ulBitmapHeight);
  420. break;
  421. case xtpShadowTB:
  422. ApplyShadowTB((UINT*)pvBits, ulBitmapWidth, ulBitmapHeight);
  423. break;
  424. case xtpShadowTR:
  425. ApplyShadowTR((UINT*)pvBits, ulBitmapWidth, ulBitmapHeight);
  426. break;
  427. case xtpShadowBR:
  428. ApplyShadowBR((UINT*)pvBits, ulBitmapWidth, ulBitmapHeight);
  429. break;
  430. case xtpShadowBL:
  431. ApplyShadowBL((UINT*)pvBits, ulBitmapWidth, ulBitmapHeight);
  432. break;
  433. case xtpShadow2007Right:
  434. ApplyShadow2007Right((UINT*)pvBits, ulBitmapWidth, ulBitmapHeight);
  435. break;
  436. case xtpShadow2007Bottom:
  437. ApplyShadow2007Bottom((UINT*)pvBits, ulBitmapWidth, ulBitmapHeight);
  438. break;
  439. case xtpShadow2007TopRight:
  440. ApplyShadow2007TR((UINT*)pvBits, ulBitmapWidth, ulBitmapHeight);
  441. break;
  442. case xtpShadow2007BottomLeft:
  443. ApplyShadow2007BL((UINT*)pvBits, ulBitmapWidth, ulBitmapHeight);
  444. break;
  445. case xtpShadow2007BottomRight:
  446. ApplyShadow2007BR((UINT*)pvBits, ulBitmapWidth, ulBitmapHeight);
  447. break;
  448. default:
  449. break;
  450. }
  452. // Copy modified picture to the old DC
  453. if (pvBits)
  454. {
  455. m_pDC->BitBlt(rcShadow.left, rcShadow.top, ulBitmapWidth, ulBitmapHeight, CDC::FromHandle(hdc), 0, 0, SRCCOPY);
  456. }
  457. }
  458. // do cleanup
  459. SelectObject(hdc, hOld);
  460. DeleteObject(hbitmap);
  461. }
  462. }
  463. // do cleanup
  464. DeleteDC(hdc);
  465. }
  467. void CXTPCalendarPaintManager::CXTPShadowDrawer::ApplyShadowLR(UINT* pBitmap, const ULONG ulBitmapWidth, const ULONG ulBitmapHeight)
  468. {
  469. if (!pBitmap)
  470. return;
  472. UINT nAlpha = 0;
  473. const double dPercentsPerPixel = m_dMaxAlpha / (double)ulBitmapWidth;
  474. double dAlpha = m_dMaxAlpha;
  476. for (ULONG x = 0; x < ulBitmapWidth; x++)
  477. {
  478. nAlpha = (UINT)dAlpha;
  479. if (nAlpha != 0)
  480. {
  481. for (ULONG y = 0; y < ulBitmapHeight; y++)
  482. {
  483. UINT uiPixel = pBitmap[x + y * ulBitmapWidth];
  484. pBitmap[x + y * ulBitmapWidth] = AlphaPixel(uiPixel, nAlpha);
  485. }
  486. }
  487. dAlpha -= dPercentsPerPixel;
  488. }
  489. }
  491. void CXTPCalendarPaintManager::CXTPShadowDrawer::ApplyShadowTB(UINT* pBitmap, const ULONG ulBitmapWidth, const ULONG ulBitmapHeight)
  492. {
  493. if (!pBitmap)
  494. return;
  496. UINT nAlpha = 0;
  497. const double dPercentsPerPixel = m_dMaxAlpha / (double)ulBitmapHeight;
  498. double dAlpha = 0;
  500. for (ULONG y = 0; y < ulBitmapHeight; y++)
  501. {
  502. nAlpha = (UINT)(dAlpha);
  503. if (nAlpha != 0)
  504. {
  505. for (ULONG x = 0; x < ulBitmapWidth; x++)
  506. {
  507. UINT uiPixel = pBitmap[x + y * ulBitmapWidth];
  508. pBitmap[x + y * ulBitmapWidth] = AlphaPixel(uiPixel, nAlpha);
  509. }
  510. }
  511. dAlpha += dPercentsPerPixel;
  512. }
  513. }
  515. void CXTPCalendarPaintManager::CXTPShadowDrawer::ApplyShadowTR(UINT* pBitmap, const ULONG ulBitmapWidth, const ULONG ulBitmapHeight)
  516. {
  517. if (!pBitmap)
  518. return;
  520. UINT nAlpha = 0;
  521. const double dPercentsPerPixel = m_dMaxAlpha / (double)min(ulBitmapWidth, ulBitmapHeight);
  523. for (ULONG y = 0; y < ulBitmapHeight; y++)
  524. {
  525. for (ULONG x = 0; x < ulBitmapWidth; x++)
  526. {
  527. nAlpha = (UINT)(m_dMaxAlpha - sqrt((double)(ulBitmapHeight - y)*(x)) * dPercentsPerPixel);
  528. nAlpha = min(nAlpha, (UINT)((ulBitmapWidth - x) * dPercentsPerPixel));
  529. nAlpha = min(nAlpha, (UINT)((y + 1) * dPercentsPerPixel));
  530. if (nAlpha != 0)
  531. {
  532. UINT uiPixel = pBitmap[x + y * ulBitmapWidth];
  533. pBitmap[x + y * ulBitmapWidth] = AlphaPixel(uiPixel, nAlpha);
  534. }
  535. }
  536. }
  537. }
  539. void CXTPCalendarPaintManager::CXTPShadowDrawer::ApplyShadow2007Right(UINT* pBitmap, const ULONG ulBitmapWidth, const ULONG ulBitmapHeight)
  540. {
  541. if (!pBitmap)
  542. return;
  544. ASSERT(5 == ulBitmapWidth); // ToDo: make shadow rect more than 5x? pixels
  546. static const UINT uiShadow[5] = {38, 34, 30, 27, 25};
  547. UINT nAlpha = 0;
  549. for (ULONG y = 0; y < ulBitmapHeight; y++)
  550. {
  551. for (ULONG x = 0; x < ulBitmapWidth; x++)
  552. {
  553. nAlpha = uiShadow[x];
  554. if (nAlpha != 0)
  555. {
  556. UINT uiPixel = pBitmap[x + y * ulBitmapWidth];
  557. pBitmap[x + y * ulBitmapWidth] = AlphaPixel(uiPixel, nAlpha);
  558. }
  559. }
  560. }
  561. }
  563. void CXTPCalendarPaintManager::CXTPShadowDrawer::ApplyShadow2007Bottom(UINT* pBitmap, const ULONG ulBitmapWidth, const ULONG ulBitmapHeight)
  564. {
  565. if (!pBitmap)
  566. return;
  568. static const UINT uiShadow[3] = {50, 40, 25};
  569. UINT nAlpha = 0;
  571. for (ULONG y = 0; y < ulBitmapHeight; y++)
  572. {
  573. if (0 == y)
  574. nAlpha = uiShadow[2];
  575. else if (1 == y)
  576. nAlpha = uiShadow[1];
  577. else
  578. nAlpha = uiShadow[0];
  580. for (ULONG x = 0; x < ulBitmapWidth; x++)
  581. {
  582. if (nAlpha != 0)
  583. {
  584. UINT uiPixel = pBitmap[x + y * ulBitmapWidth];
  585. pBitmap[x + y * ulBitmapWidth] = AlphaPixel(uiPixel, nAlpha);
  586. }
  587. }
  588. }
  589. }
  591. void CXTPCalendarPaintManager::CXTPShadowDrawer::ApplyShadow2007TR(UINT* pBitmap, const ULONG ulBitmapWidth, const ULONG ulBitmapHeight)
  592. {
  593. if (!pBitmap)
  594. return;
  597. ASSERT(5 == ulBitmapWidth); // ToDo: make shadow rect more than 5x6 pixels
  598. ASSERT(6 == ulBitmapHeight);
  600. static const UINT nShadowTR[6][5] =
  601. {
  602. {22, 17,  7,  0,  0},
  603. {31, 33, 35, 15,  0},
  604. {32, 30, 28, 34, 10},
  605. {35, 32, 29, 30, 21},
  606. {37, 33, 30, 27, 25},
  607. {38, 34, 30, 27, 25}
  608. };
  611. UINT nAlpha = 0;
  613. for (ULONG y = 0; y < ulBitmapHeight; y++)
  614. {
  615. for (ULONG x = 0; x < ulBitmapWidth; x++)
  616. {
  617. nAlpha = nShadowTR[5-y][x];
  618. if (nAlpha != 0)
  619. {
  620. UINT uiPixel = pBitmap[x + y * ulBitmapWidth];
  621. pBitmap[x + y * ulBitmapWidth] = AlphaPixel(uiPixel, nAlpha);
  622. }
  623. }
  624. }
  625. }
  627. void CXTPCalendarPaintManager::CXTPShadowDrawer::ApplyShadow2007BL(UINT* pBitmap, const ULONG ulBitmapWidth, const ULONG ulBitmapHeight)
  628. {
  629. if (!pBitmap)
  630. return;
  632. ASSERT(5 == ulBitmapHeight); // ToDo: make shadow rect more than 5x6 pixels
  633. ASSERT(5 == ulBitmapWidth);
  635. static const UINT uiShadowBL[5][5] =
  636. {
  637. {33, 30, 34, 44, 50},
  638. {19, 33, 33, 40, 50},
  639. {10, 35, 30, 35, 43},
  640. { 0, 18, 35, 30, 33},
  641. { 0,  0, 11, 24, 25}
  642. };
  644. UINT nAlpha = 0;
  646. for (ULONG y = 0; y < ulBitmapHeight; y++)
  647. {
  648. for (ULONG x = 0; x < ulBitmapWidth; x++)
  649. {
  650. nAlpha = uiShadowBL[4-y][x];
  651. if (nAlpha != 0)
  652. {
  653. UINT uiPixel = pBitmap[x + y * ulBitmapWidth];
  654. pBitmap[x + y * ulBitmapWidth] = AlphaPixel(uiPixel, nAlpha);
  655. }
  656. }
  657. }
  658. }
  660. void CXTPCalendarPaintManager::CXTPShadowDrawer::ApplyShadow2007BR(UINT* pBitmap, const ULONG ulBitmapWidth, const ULONG ulBitmapHeight)
  661. {
  662. if (!pBitmap)
  663. return;
  665. ASSERT(3+5 == ulBitmapHeight); // ToDo: make shadow rect more than 5x6 pixels
  666. ASSERT(3+5 == ulBitmapWidth);
  668. static const UINT uiShadowBL[8][8] =
  669. {
  670. {255,255,200,255,255,255,255,255},
  671. {255,255,200,255,255,255,255,255},
  672. {200,200,205,255,255,255,255,255},
  673. {255,255,255,213,215,219,224,230},
  674. {255,255,255,217,219,223,224,233},
  675. {255,255,255,219,221,225,221,241},
  676. {255,255,255,226,226,221,236,254},
  677. {255,255,255,230,231,241,254,255}
  678. };
  680. UINT nAlpha = 0;
  682. for (ULONG y = 0; y < ulBitmapHeight; y++)
  683. {
  684. for (ULONG x = 0; x < ulBitmapWidth; x++)
  685. {
  686. nAlpha = 255 - uiShadowBL[7-y][x];
  687. if (nAlpha != 0)
  688. {
  689. UINT uiPixel = pBitmap[x + y * ulBitmapWidth];
  690. pBitmap[x + y * ulBitmapWidth] = AlphaPixel(uiPixel, nAlpha);
  691. }
  692. }
  693. }
  694. }
  696. void CXTPCalendarPaintManager::CXTPShadowDrawer::ApplyShadowBR(UINT* pBitmap, const ULONG ulBitmapWidth, const ULONG ulBitmapHeight)
  697. {
  698. if (!pBitmap)
  699. return;
  701. UINT nAlpha = 0;
  702. const double dPercentsPerPixel = m_dMaxAlpha / (double)min(ulBitmapHeight, ulBitmapWidth);
  704. for (ULONG y = 0; y < ulBitmapHeight; y++)
  705. {
  706. for (ULONG x = 0; x < ulBitmapWidth; x++)
  707. {
  708. nAlpha = (UINT)(m_dMaxAlpha - sqrt((double)y * x) * dPercentsPerPixel);
  709. nAlpha = min(nAlpha, (UINT)((ulBitmapWidth - x) * dPercentsPerPixel));
  710. nAlpha = min(nAlpha, (UINT)((ulBitmapHeight - y) * dPercentsPerPixel));
  711. if (nAlpha != 0)
  712. {
  713. UINT uiPixel = pBitmap[x + y * ulBitmapWidth];
  714. pBitmap[x + y * ulBitmapWidth] = AlphaPixel(uiPixel, nAlpha);
  715. }
  716. }
  717. }
  718. }
  720. void CXTPCalendarPaintManager::CXTPShadowDrawer::ApplyShadowBL(UINT* pBitmap, const ULONG ulBitmapWidth, const ULONG ulBitmapHeight)
  721. {
  722. if (!pBitmap)
  723. return;
  725. UINT nAlpha = 0;
  726. const double dPercentsPerPixel = m_dMaxAlpha / (double)min(ulBitmapHeight, ulBitmapWidth);
  728. for (ULONG y = 0; y < ulBitmapHeight; y++)
  729. {
  730. for (ULONG x = 0; x < ulBitmapWidth; x++)
  731. {
  732. nAlpha = (UINT)(m_dMaxAlpha - sqrt((double)(ulBitmapHeight - y)*(ulBitmapWidth - x)) * dPercentsPerPixel);
  733. nAlpha = min(nAlpha, (UINT)(x * dPercentsPerPixel));
  734. nAlpha = min(nAlpha, (UINT)((y) * dPercentsPerPixel));
  735. if (nAlpha != 0)
  736. {
  737. UINT uiPixel = pBitmap[x + y * ulBitmapWidth];
  738. pBitmap[x + y * ulBitmapWidth] = AlphaPixel(uiPixel, nAlpha);
  739. }
  740. }
  741. }
  742. }
  744. void CXTPCalendarPaintManager::CDayViewTimeScaleCellPart::RefreshMetrics()
  745. {
  746. m_nHourWidth = m_nMinWidth = 0;
  747. LOGFONT lfIcon;
  748. VERIFY(::SystemParametersInfo(SPI_GETICONTITLELOGFONT, sizeof(lfIcon), &lfIcon, 0));
  749. STRCPY_S(lfIcon.lfFaceName, LF_FACESIZE, _T("Tahoma"));
  750. m_fntTimeText.SetStandardValue(&lfIcon);
  751. }
  753. void CXTPCalendarPaintManager::CDayViewTimeScaleCellPart::CalcWidth(CDC* pDC,
  754. const CString& strHour, const CString& strMin,
  755. int nHourHeight, int& nWidth)
  756. {
  757. ASSERT(pDC);
  758. if (!pDC || !m_pPaintManager)
  759. return;
  761. CSize szMin(0, 0), szHour(0, 0);
  763. {
  764. CXTPFontDC fnt(pDC, &GetTextFont());
  765. szMin = pDC->GetTextExtent(strMin);
  766. }
  768. {
  769. CRect rcDefaultCell(0, 0, 100, nHourHeight);
  770. AdjustTimeFont(pDC, rcDefaultCell);
  772. CXTPFontDC fnt(pDC, m_fntTimeText);
  773. szHour = pDC->GetTextExtent(strHour);
  774. // check also widest hours number
  775. CSize szHour2 = pDC->GetTextExtent(_T("88"), 2);
  776. if (szHour2.cx > szHour.cx)
  777. {
  778. szHour = szHour2;
  779. }
  780. }
  782. m_nHourWidth = szHour.cx;
  783. m_nMinWidth = szMin.cx;
  784. nWidth = max(42, szHour.cx + szMin.cx + 17);
  785. }
  787. void CXTPCalendarPaintManager::CDayViewTimeScaleCellPart::AdjustTimeFont(CDC* pDC, CRect rcCell)
  788. {
  789. ASSERT(pDC);
  790. if (!pDC)
  791. {
  792. return;
  793. }
  794. rcCell.DeflateRect(5, 6, 1, 7);
  796. LOGFONT lfIcon;
  797. ((CFont*)m_fntTimeText)->GetLogFont(&lfIcon);
  798. CSize szText;
  799. {
  800. CXTPFontDC fontBig(pDC, m_fntTimeText);
  801. szText = pDC->GetTextExtent(_T("88"), 2);
  802. }
  804. int nParam1 = rcCell.Width() * szText.cy;
  805. int nParam2 = rcCell.Height() * szText.cx;
  806. if (nParam1 > nParam2)
  807. {
  808. lfIcon.lfHeight = ::MulDiv(lfIcon.lfHeight, rcCell.Height(), szText.cy);
  809. }
  810. else
  811. {
  812. lfIcon.lfHeight = ::MulDiv(lfIcon.lfHeight, rcCell.Width(), szText.cx);
  813. }
  815. m_fntTimeText.SetStandardValue(&lfIcon);
  816. }
  818. void CXTPCalendarPaintManager::CDayViewTimeScaleCellPart::DrawHourCell(CDC* pDC, CRect rc, CString strText, BOOL bFillBackground)
  819. {
  820. if (!pDC || !m_pPaintManager)
  821. {
  822. ASSERT(FALSE);
  823. return;
  824. }
  826. if (bFillBackground)
  827. pDC->FillSolidRect(rc, GetBackgroundColor());
  828. pDC->FillSolidRect(rc.right - 1, rc.top, 1, rc.Height(), m_pPaintManager->m_clr3DShadow);
  830. rc.DeflateRect(0, 0, 4, 0);
  832. DrawText(pDC, strText, rc, DT_VCENTER | DT_RIGHT | DT_SINGLELINE);
  834. rc.DeflateRect(5, 0, 0, 0);
  835. pDC->FillSolidRect(rc.left, rc.bottom - 1, rc.Width(), 1, m_pPaintManager->m_clr3DShadow);
  836. }
  838. void CXTPCalendarPaintManager::CDayViewTimeScaleCellPart::DrawBigHourCell(CDC* pDC, CRect rc, CString strHour, CString strMin, int nRowPerHour, BOOL bFillBackground)
  839. {
  840. if (!pDC || !m_pPaintManager)
  841. {
  842. ASSERT(FALSE);
  843. return;
  844. }
  846. // Fill background
  847. if (bFillBackground)
  848. pDC->FillSolidRect(rc, GetBackgroundColor());
  849. pDC->FillSolidRect(rc.right - 1, rc.top, 1, rc.Height(), m_pPaintManager->m_clr3DShadow);
  851. // Calculate coordinates
  852. CRect rcMinutesText(rc);
  853. rcMinutesText.bottom = rcMinutesText.top + rc.Height() / nRowPerHour;
  854. rcMinutesText.left += m_nHourWidth + 10;
  856. CRect rcHoursText(rc);
  857. rcHoursText.right = rcMinutesText.left;
  858. rcHoursText.DeflateRect(0, 4, 4, 7);
  860. // Draw hours text
  861. CXTPFontDC fontBig(pDC, m_fntTimeText, GetTextColor());
  862. pDC->DrawText(strHour, rcHoursText, DT_TOP | DT_RIGHT | DT_SINGLELINE | DT_NOCLIP);
  864. // draw minutes text
  865. DrawText(pDC, strMin, rcMinutesText, DT_VCENTER | DT_LEFT | DT_SINGLELINE | DT_NOCLIP);
  867. // draw small lines
  868. if (nRowPerHour > 2)
  869. {
  870. BOOL bShowMinutes = XTP_SAFE_GET3(m_pPaintManager, m_pControl, GetCalendarOptions(), bDayView_TimeScaleShowMinutes, FALSE);
  871. CString strMinEx;
  873. for (int i = 1; i < nRowPerHour; i++)
  874. {
  875. int y = rc.top + i * rc.Height() / nRowPerHour;
  876. pDC->FillSolidRect(rcMinutesText.left, y - 1, rcMinutesText.Width(), 1, m_pPaintManager->m_clr3DShadow);
  878. //------------------------------------------
  879. if (bShowMinutes)
  880. {
  881. int nMinEx = 60 / nRowPerHour * i;
  882. strMinEx.Format(_T("%02d"), nMinEx);
  884. CRect rcMinEx = rcMinutesText;
  885. rcMinEx.top = y;
  886. rcMinEx.bottom = y + rc.Height();
  888. DrawText(pDC, strMinEx, rcMinEx, DT_TOP | DT_LEFT | DT_SINGLELINE | DT_NOCLIP);
  889. }
  890. }
  891. }
  893. // draw line below
  894. rc.DeflateRect(5, 0, 4, 0);
  895. pDC->FillSolidRect(rc.left, rc.bottom - 1, rc.Width(), 1, m_pPaintManager->m_clr3DShadow);
  896. }
  898. void CXTPCalendarPaintManager::CDayViewTimeScaleHeaderPart::OnDraw(CDC* pDC, CXTPCalendarDayView* /*pView*/, CRect rc, CString strText)
  899. {
  900. if (!pDC || !m_pPaintManager)
  901. {
  902. ASSERT(FALSE);
  903. return;
  904. }
  906. pDC->FillSolidRect(rc, GetBackgroundColor());
  907. pDC->FillSolidRect(rc.right - 1, rc.top, 1, rc.Height(), m_pPaintManager->m_clr3DShadow);
  909. rc.DeflateRect(1, 0, 4, 0);
  910. pDC->FillSolidRect(rc.left, rc.bottom - 1, rc.Width(), 1, m_pPaintManager->m_clr3DShadow);
  912. rc.DeflateRect(1, 2);
  913. DrawText(pDC, strText, rc, DT_BOTTOM | DT_LEFT | DT_SINGLELINE);
  914. }
  916. void CXTPCalendarPaintManager::CDayViewTimeScaleHeaderPart::DrawNowLine(CDC* pDC,
  917. CXTPCalendarDayView* pView, CRect rc, int y, BOOL bDrawBk)
  918. {
  919. if (!pDC || !pView || !m_pPaintManager)
  920. {
  921. ASSERT(FALSE);
  922. return;
  923. }
  925. int nHeight = GETTOTAL_MINUTES_DTS(pView->GetScaleInterval()) >= 60 ? 5 : 10;
  927. CRect rcNowLine = rc;
  928. rcNowLine.top = y - nHeight;
  929. rcNowLine.bottom = y + 1;
  930. rcNowLine.left += 5;
  931. rcNowLine.right -= 1;
  933. BOOL bXPTheme = m_pPaintManager->GetCurrentSystemTheme() != xtpSystemThemeUnknown;
  935. if (bDrawBk)
  936. {
  937. if (bXPTheme)
  938. {
  939. XTPDrawHelpers()->GradientFill(pDC, &rcNowLine, m_pPaintManager->m_grclrToday, FALSE);
  940. }
  941. }
  942. else
  943. {
  944. rcNowLine.top = rcNowLine.bottom - 1;
  945. pDC->FillSolidRect(&rcNowLine, m_pPaintManager->m_clrUnderLineHdr);
  946. }
  947. }
  949. void CXTPCalendarPaintManager::CDayViewTimeScaleHeaderPart::DrawExpandSigns(CDC* pDC,
  950. CXTPCalendarDayView* pView, const CRect& rcTSHours)
  951. {
  952. if (!pDC || !pView || !m_pPaintManager)
  953. {
  954. ASSERT(FALSE);
  955. return;
  956. }
  958. // draw expand signs
  959. CRect rcSignUp(rcTSHours);
  960. CRect rcSignDown(rcTSHours);
  961. CSize szSign(m_pPaintManager->GetExpandSignSize());
  963. rcSignUp.left = rcTSHours.right - szSign.cx;
  965. rcSignDown.left = rcTSHours.right - szSign.cx;
  966. rcSignDown.top = rcSignDown.bottom - szSign.cy;
  968. CImageList* pilExpSgn = &m_pPaintManager->m_ilExpandSigns;
  969. if (pView->IsExpandUp())
  970. {
  971. m_pPaintManager->DrawBitmap(pilExpSgn, pDC, rcSignUp,
  972. CXTPCalendarPaintManager::idxExpandSignUp);
  973. }
  974. if (pView->IsExpandDown())
  975. {
  976. m_pPaintManager->DrawBitmap(pilExpSgn, pDC, rcSignDown,
  977. CXTPCalendarPaintManager::idxExpandSignDown);
  978. }
  980. }
  982. void CXTPCalendarPaintManager::CDayViewCellPart::GetParams(CXTPCalendarDayViewGroup* pViewGroup,
  983.    XTP_CALENDAR_DAYVIEWCELL_PARAMS& rCellParams)
  984. {
  985. if (!pViewGroup || !m_pPaintManager)
  986. {
  987. ASSERT(FALSE);
  988. return;
  989. }
  991. rCellParams.clrBackgroundColor =  rCellParams.bSelected ? m_pPaintManager->m_clrHighlight : GetBackgroundColor();
  992. }
  994. void CXTPCalendarPaintManager::CDayViewCellPart::OnDraw(CDC* pDC,
  995. CXTPCalendarDayViewGroup* pViewGroup, CRect rc,
  996. const XTP_CALENDAR_DAYVIEWCELL_PARAMS& cellParams)
  997. {
  998. if (!pDC || !pViewGroup || !m_pPaintManager)
  999. {
  1000. ASSERT(FALSE);
  1001. return;
  1002. }
  1003. COleDateTime dtTime = cellParams.dtBeginTime;
  1005. CRect rcBusyStatus(rc);
  1006. rcBusyStatus.right = rcBusyStatus.left + 6;
  1008. pDC->FillSolidRect(&rcBusyStatus, m_pPaintManager->m_clrWindow);
  1009. int nDayBusyStatus = pViewGroup->GetBusyStatus(dtTime);
  1010. if (nDayBusyStatus != xtpCalendarBusyStatusUnknown)
  1011. {
  1012. m_pPaintManager->DrawBusyStatus(pDC, rcBusyStatus, nDayBusyStatus);
  1013. }
  1015. if (XTP_SAFE_GET2(pViewGroup, GetViewDay(), GetDayIndex(), 0) != 0 ||
  1016. pViewGroup->GetGroupIndex() != 0)
  1017. {
  1018. pDC->FillSolidRect(rc.left, rc.top, 1, rc.Height(), m_pPaintManager->m_clrWindowText);
  1019. }
  1020. int nDayDeviderX = 0;//pViewGroup->GetGroupIndex() ? -2 : 0;
  1021. pDC->FillSolidRect(rc.left + 6 + nDayDeviderX, rc.top, 1, rc.Height(), m_pPaintManager->m_clrWindowText);
  1023. rc.left += 7 + nDayDeviderX;
  1025. if (m_pPaintManager->GetPaintTheme() >= xtpCalendarThemeOffice2003 ||
  1026. cellParams.bSelected)
  1027. {
  1028. pDC->FillSolidRect(rc, cellParams.clrBackgroundColor);
  1029. }
  1030. else
  1031. {
  1032. WORD arBits[2] = {0xAA, 0x55};
  1034. // Use the bit pattern to create a bitmap.
  1035. CBitmap bm;
  1036. bm.CreateBitmap(8,2,1,1, arBits);
  1038. CBrush brush;
  1039. brush.CreatePatternBrush(&bm);
  1041. COLORREF clrTxt0 = pDC->SetTextColor(cellParams.clrBackgroundColor);
  1042. COLORREF clrBk0 = pDC->SetBkColor(m_clrBackgroundSlave);
  1044. pDC->FillRect(rc, &brush);
  1046. pDC->SetTextColor(clrTxt0);
  1047. pDC->SetBkColor(clrBk0);
  1048. }
  1050. if (dtTime.GetMinute() == 0 && dtTime.GetHour() != 0)
  1051. {
  1052. pDC->FillSolidRect(rc.left, rc.top - 1, rc.Width(), 1, m_clrHour);
  1053. }
  1055. pDC->FillSolidRect(rc.left, rc.bottom - 1, rc.Width(), 1, m_clrShadow);
  1056. }
  1058. void CXTPCalendarPaintManager::CDayViewAllDayEventsPart::OnDraw(CDC* pDC,
  1059. CXTPCalendarDayViewGroup* pViewGroup, CRect rc, BOOL bSelected)
  1060. {
  1061. if (!pDC || !pViewGroup || !pViewGroup->GetViewDay() || !m_pPaintManager)
  1062. {
  1063. ASSERT(FALSE);
  1064. return;
  1065. }
  1067. if (bSelected)
  1068. {
  1069. pDC->FillSolidRect(rc, m_pPaintManager->m_clrWindow);
  1070. pDC->FillSolidRect(rc.left, rc.top, rc.Width(), 1, m_pPaintManager->m_clr3DShadow);
  1071. pDC->FillSolidRect(rc.left, rc.bottom - 1, rc.Width(), 1, m_pPaintManager->m_clr3DShadow);
  1072. }
  1073. else
  1074. {
  1075. pDC->FillSolidRect(rc, GetBackgroundColor());
  1076. }
  1078. if (pViewGroup->GetViewDay()->GetDayIndex() || pViewGroup->GetGroupIndex())
  1079. {
  1080. pDC->FillSolidRect(rc.left, rc.top + 1, 1, rc.Height() - 2, 0);
  1081. }
  1082. }
  1084. void CXTPCalendarPaintManager::CDayViewHeaderPart::OnDraw(CDC* pDC,
  1085. CXTPCalendarDayViewDay* pViewDay, CRect rc, CString strText)
  1086. {
  1087. if (!pDC || !pViewDay || !pViewDay->GetView() || !m_pPaintManager)
  1088. {
  1089. ASSERT(FALSE);
  1090. return;
  1091. }
  1093. BOOL bIsCurrent = FALSE;
  1094. COleDateTime dtCurrent =  CXTPCalendarUtils::GetCurrentTime();
  1095. dtCurrent = CXTPCalendarUtils::ResetTime(dtCurrent);
  1097. COleDateTime dtDay;
  1099. bIsCurrent = pViewDay->GetDayDate() == dtCurrent;
  1101. pDC->FillSolidRect(rc, GetBackgroundColor());
  1103. CRect rcHeader(rc);
  1105. m_pPaintManager->DrawHeader(pDC, rcHeader, FALSE, bIsCurrent);
  1107. BOOL bFirstDay = pViewDay->GetDayIndex() == 0;
  1108. BOOL bLastDay = pViewDay->GetDayIndex() == pViewDay->GetView()->GetViewDayCount() - 1;
  1110. pDC->FillSolidRect(rc.left, rc.top, rc.Width(), 1, m_clrTopLeftBorder);
  1112. pDC->FillSolidRect(rc.left, rc.top + (bFirstDay ? 0: 2), 1, rc.Height() -  (bFirstDay ? 0 : 3), m_clrTopLeftBorder);
  1113. pDC->FillSolidRect(rc.right - 1, rc.top + (bLastDay ? 0: 2), 1, rc.Height() - (bLastDay ? 0 : 3), m_pPaintManager->m_clr3DShadow);
  1115. rc.DeflateRect(2, 0, 2, 0);
  1116. DrawLine_CenterLR(pDC, strText, rc, DT_VCENTER);
  1117. }
  1119. void CXTPCalendarPaintManager::CDayViewGroupHeaderPart::OnDraw(CDC* pDC,
  1120. CXTPCalendarDayViewGroup* pViewGroup, CRect rc, CString strText)
  1121. {
  1122. if (!pDC || !pViewGroup || !pViewGroup->GetViewDay() || !m_pPaintManager)
  1123. {
  1124. ASSERT(FALSE);
  1125. return;
  1126. }
  1128. pDC->FillSolidRect(rc, GetBackgroundColor());
  1130. CRect rcHeader(rc);
  1132. m_pPaintManager->DrawHeader(pDC, rcHeader, FALSE, FALSE);
  1134. CXTPCalendarDayViewDay* pViewDay = pViewGroup->GetViewDay();
  1136. BOOL bFirstGroup = pViewDay->GetDayIndex() == 0 &&
  1137.    pViewGroup->GetGroupIndex() == 0;
  1138. BOOL bLastGroup = pViewDay->GetDayIndex() == pViewDay->GetView()->GetViewDayCount() - 1 &&
  1139. pViewGroup->GetGroupIndex() == pViewDay->GetViewGroupsCount() - 1;          ;
  1141. pDC->FillSolidRect(rc.left, rc.top, rc.Width(), 1, m_clrTopLeftBorder);
  1143. pDC->FillSolidRect(rc.left, rc.top + (bFirstGroup ? 0: 2), 1, rc.Height() -  (bFirstGroup ? 0 : 3), m_clrTopLeftBorder);
  1144. pDC->FillSolidRect(rc.right - 1, rc.top + (bLastGroup ? 0: 2), 1, rc.Height() - (bLastGroup ? 0 : 3), m_pPaintManager->m_clr3DShadow);
  1146. rc.DeflateRect(2, 0, 2, 0);
  1148. DrawLine_CenterLR(pDC, strText, rc, DT_VCENTER);
  1149. }
  1151. void CXTPCalendarPaintManager::DrawHeader(CDC* pDC, CRect& rcHeader,
  1152. BOOL bIsSelected, BOOL bIsCurrent)
  1153. {
  1154. DrawHeader(pDC, rcHeader, bIsSelected, bIsCurrent, m_grclrToday,
  1155.   m_clrUnderLineHdr);
  1156. }
  1158. void CXTPCalendarPaintManager::DrawHeader(CDC* pDC, CRect& rcHeader,
  1159. BOOL bIsSelected, BOOL bIsCurrent, const CXTPPaintManagerColorGradient& grclr, COLORREF clrUnderLineHdr)
  1160. {
  1161. ASSERT(pDC);
  1162. if (!pDC)
  1163. {
  1164. return;
  1165. }
  1167. if (!bIsSelected)
  1168. pDC->FillSolidRect(rcHeader, m_clrButtonFace);
  1170. if (bIsCurrent)
  1171. {
  1172. if (grclr.clrDark != grclr.clrLight)
  1173. {
  1174. XTPDrawHelpers()->GradientFill(pDC, &rcHeader, grclr, FALSE);
  1175. }
  1176. else
  1177. {
  1178. pDC->FillSolidRect(rcHeader, grclr.clrDark);
  1179. }
  1180. pDC->FillSolidRect(rcHeader.left, rcHeader.bottom -1 ,
  1181. rcHeader.Width(), 1, clrUnderLineHdr);
  1182. }
  1184. if (bIsSelected)
  1185. {
  1186. pDC->FillSolidRect(rcHeader, m_clrHighlight);
  1187. }
  1188. }
  1191. void CXTPCalendarPaintManager::CWeekViewPart::DrawDayHeader(CDC* pDC,
  1192. CRect rcDay, int nHeaderHeight,
  1193. CString strHeader, BOOL bIsCurrent, BOOL bIsSelected)
  1194. {
  1195. if (!pDC || !m_pPaintManager)
  1196. {
  1197. ASSERT(FALSE);
  1198. return;
  1199. }
  1201. if (m_pPaintManager->GetPaintTheme() != xtpCalendarThemeOffice2003)
  1202. {
  1203. bIsCurrent = FALSE;
  1204. }
  1206. CRect rcHeader(rcDay);
  1208. // draw header top line
  1209. m_pPaintManager->DrawHorizontalLine(pDC, rcDay.left + 1, rcDay.top,
  1210.  rcDay.Width()+1);
  1212. rcHeader.DeflateRect(2, 2, 1, rcHeader.Height() - nHeaderHeight - 1);
  1213. CRect rcText(rcHeader);
  1214. rcText.DeflateRect(1, 0, 3, 1);
  1216. // draw header contents
  1217. CRect rcHeader2(rcHeader);
  1218. rcHeader2.bottom -= 1;
  1219. if (bIsCurrent && bIsSelected)
  1220. {
  1221. m_pPaintManager->DrawHeader(pDC, rcHeader2, FALSE, bIsCurrent);
  1222. CRect rcSel = CRect(rcHeader2);
  1223. CSize  szText = GetTextExtent(pDC, strHeader);
  1224. rcSel.left = rcSel.right - (szText.cx + 7);
  1225. rcSel.bottom--;
  1226. m_pPaintManager->DrawHeader(pDC, rcSel, bIsSelected, FALSE);
  1227. }
  1228. else
  1229. {
  1230. m_pPaintManager->DrawHeader(pDC, rcHeader2, bIsSelected, bIsCurrent);
  1231. }
  1233. // draw header bottom line
  1234. if (!bIsCurrent)
  1235. {
  1236. CRect rcBottomLine(rcHeader);
  1237. rcBottomLine.top = --rcBottomLine.bottom - 1;
  1238. if (!bIsSelected)
  1239. rcBottomLine.DeflateRect(2, 0, 2, 0);
  1240. pDC->FillSolidRect(rcBottomLine, m_clrHeaderBottomLine);
  1241. }
  1243. // draw header text
  1244. pDC->SetBkMode(TRANSPARENT);
  1245. SetTextColor(bIsSelected ? m_clrTextHighLightColor : m_clrTextNormalColor);
  1246. DrawText(pDC, strHeader, rcText, DT_VCENTER | DT_RIGHT | DT_SINGLELINE);
  1248. }
  1250. void CXTPCalendarPaintManager::CWeekViewPart::OnDraw(CDC* pDC, CXTPCalendarWeekView* pWeekView)
  1251. {
  1252. if (!pDC || !pWeekView || !m_pPaintManager)
  1253. {
  1254. ASSERT(FALSE);
  1255. return;
  1256. }
  1258. CRect rcView(pWeekView->GetViewRect());
  1260. pDC->FillSolidRect(rcView, m_clrBackground);
  1262. //draw grid
  1263. int nDayWidth = pWeekView->GetDayWidth();
  1265. m_pPaintManager->DrawVerticalLine(pDC, rcView.left + nDayWidth - 1, rcView.top, rcView.bottom);
  1267. // draw headers
  1268. BOOL bIsSelected = FALSE;
  1269. BOOL bIsCurrent = FALSE;
  1270. COleDateTime dtCurrent = CXTPCalendarUtils::ResetTime(COleDateTime::GetCurrentTime());
  1272. COleDateTime dtDay;
  1274. int nDayHeaderHeight = pWeekView->GetDayHeaderHeight();
  1275. for (int nDay = 0; nDay < 7; nDay++)
  1276. {
  1277. CXTPCalendarWeekViewDay* pWDay = pWeekView->GetViewDay(nDay);
  1278. ASSERT(pWDay);
  1279. if (!pWDay)
  1280. {
  1281. continue;
  1282. }
  1283. CString strDate = pWDay->GetCaption();
  1285. dtDay = pWDay->GetDayDate();
  1286. bIsSelected = pWDay->IsSelected();
  1287. bIsCurrent = CXTPCalendarUtils::IsEqual(dtDay, dtCurrent);
  1290. //-------------------------------------------------------------
  1292. DrawDayHeader(pDC, pWDay->GetDayRect(), nDayHeaderHeight,
  1293.   strDate, bIsCurrent, bIsSelected);
  1294. }
  1295. }
  1296. void CXTPCalendarPaintManager::CWeekViewEventPart::DrawBorder(CDC* pDC,
  1297. CRect rcView, CXTPCalendarWeekViewEvent* pWeekViewEvent)
  1298. {
  1299. if (!pDC || !pWeekViewEvent || !pWeekViewEvent->GetEvent() || !m_pPaintManager)
  1300. {
  1301. ASSERT(FALSE);
  1302. return;
  1303. }
  1305. int nBorderWidth = pWeekViewEvent->IsSelected() ? 2 : 1;
  1307. int nMDEFlags = pWeekViewEvent->GetMultiDayEventFlags();
  1308. BOOL bAllDay = pWeekViewEvent->GetEvent()->IsAllDayEvent();
  1310. if (pWeekViewEvent->IsSelected() &&
  1311. (nMDEFlags & xtpCalendarMultiDayFirst ||
  1312.  nMDEFlags & xtpCalendarMultiDayLast ||
  1313.  nMDEFlags & xtpCalendarMultiDayMiddle)
  1314.  )
  1315. {
  1316. rcView.top--;
  1317. rcView.bottom++;
  1318. }
  1320. if (bAllDay ||
  1321. nMDEFlags & xtpCalendarMultiDayFirst ||
  1322. nMDEFlags & xtpCalendarMultiDayLast ||
  1323. nMDEFlags & xtpCalendarMultiDayMiddle)
  1324. {
  1325. pDC->FillSolidRect(rcView.left, rcView.top , rcView.Width(), nBorderWidth, m_clrTextNormalColor);
  1326. pDC->FillSolidRect(rcView.left, rcView.bottom - nBorderWidth, rcView.Width(), nBorderWidth, m_clrTextNormalColor);
  1327. }
  1328. if (nMDEFlags & xtpCalendarMultiDayFirst)
  1329. {
  1330. pDC->FillSolidRect(rcView.left, rcView.top, 1, rcView.Height(), m_clrTextNormalColor);
  1331. }
  1332. if (nMDEFlags & xtpCalendarMultiDayLast)
  1333. {
  1334. pDC->FillSolidRect(rcView.right, rcView.top, 1, rcView.Height(), m_clrTextNormalColor);
  1335. }
  1336. }
  1338. int CXTPCalendarPaintManager::CWeekViewEventPart::DrawTimes(CDC* pDC, CXTPCalendarWeekViewEvent* pWeekViewEvent)
  1339. {
  1340. if (!pDC || !pWeekViewEvent || !pWeekViewEvent->GetEvent() || !m_pPaintManager)
  1341. {
  1342. ASSERT(FALSE);
  1343. return 0;
  1344. }
  1346. COLORREF clrBackground = pWeekViewEvent->IsSelected() ? m_pPaintManager->m_clrHighlight : m_clrBackground;
  1348. CXTPCalendarEventLabel* ptrLabel = pWeekViewEvent->GetEvent()->GetLabel();
  1349. COLORREF clrLabel = ptrLabel ? ptrLabel->m_clrColor : clrBackground;
  1350. clrBackground = clrLabel;
  1352. CRect rcStart(pWeekViewEvent->GetStartTimeRect());
  1353. CRect rcEnd(pWeekViewEvent->GetEndTimeRect());
  1354. COleDateTime dtStart(pWeekViewEvent->GetEvent()->GetStartTime());
  1356. if (pWeekViewEvent->IsTimeAsClock())
  1357. {
  1358. m_pPaintManager->DrawClock(pDC, dtStart, rcStart, clrBackground, xtpCalendarClockAlignCenter);
  1359. }
  1360. else
  1361. {
  1362. CString strStartTime = pWeekViewEvent->GetItemTextStartTime();
  1363. DrawLineEx(pDC, strStartTime, &rcStart, DT_RIGHT | DT_VCENTER, DT_LEFT | DT_VCENTER);
  1364. }
  1366. if (pWeekViewEvent->IsShowEndTime())
  1367. {
  1368. COleDateTime dtEnd(pWeekViewEvent->GetEvent()->GetEndTime());
  1369. if (pWeekViewEvent->IsTimeAsClock())
  1370. {
  1371. m_pPaintManager->DrawClock(pDC, dtEnd, rcEnd, clrBackground, xtpCalendarClockAlignCenter);
  1372. }
  1373. else
  1374. {
  1375. CString strEndTime = pWeekViewEvent->GetItemTextEndTime();
  1376. DrawLineEx(pDC, strEndTime, &rcEnd, DT_RIGHT | DT_VCENTER, DT_LEFT | DT_VCENTER);
  1377. }
  1378. }
  1379. return 0;
  1380. }
  1382. void CXTPCalendarPaintManager::CWeekViewEventPart::DrawSubj(CDC* pDC,
  1383. CXTPCalendarWeekViewEvent* pWeekViewEvent)
  1384. {
  1385. if (!pDC || !pWeekViewEvent || !pWeekViewEvent->GetEvent() || !m_pPaintManager)
  1386. {
  1387. ASSERT(FALSE);
  1388. return;
  1389. }
  1391. CRect rcText(pWeekViewEvent->GetTextRect());
  1392. CString strLoc = pWeekViewEvent->GetItemTextLocation();
  1393. CString strEventText = pWeekViewEvent->GetItemTextSubject();
  1394. if (strLoc.GetLength() > 0)
  1395. {
  1396. strEventText += _T(" (") + strLoc + _T(")");
  1397. }
  1399. int nDayEventFlags = pWeekViewEvent->GetMultiDayEventFlags();
  1400. int nAlign = DT_CENTER;
  1401. if (pWeekViewEvent->IsMultyDayTextAlign() || GetTextExtent(pDC, strEventText).cx >= rcText.Width())
  1402. nAlign = DT_LEFT;
  1404. //nAlign
  1405. if (pWeekViewEvent->GetEvent()->IsAllDayEvent() ||
  1406. nDayEventFlags & xtpCalendarMultiDayFirst ||
  1407. nDayEventFlags & xtpCalendarMultiDayMiddle ||
  1408. nDayEventFlags & xtpCalendarMultiDayLast
  1409.   )
  1410. DrawText(pDC, strEventText, &rcText, nAlign | DT_VCENTER | DT_SINGLELINE);
  1411. else
  1412. DrawText(pDC, strEventText, &rcText, DT_LEFT | DT_VCENTER | DT_SINGLELINE);
  1413. }
  1415. void CXTPCalendarPaintManager::CWeekViewEventPart::OnDraw(CDC* pDC,
  1416. CXTPCalendarWeekViewEvent* pWeekViewEvent)
  1417. {
  1418. if (!pDC || !pWeekViewEvent || !pWeekViewEvent->GetEvent() || !m_pPaintManager)
  1419. {
  1420. ASSERT(FALSE);
  1421. return;
  1422. }
  1424. CRect rcView(pWeekViewEvent->GetViewEventRect());
  1425. CRect rcViewMax(rcView);
  1426. CString strEventText;
  1428. BOOL bSelected = pWeekViewEvent->IsSelected();
  1429. int nDayEventFlags = pWeekViewEvent->GetMultiDayEventFlags();
  1430. BOOL bMday = (nDayEventFlags & xtpCalendarMultiDayFMLmask) != 0;
  1431. BOOL bAllDay = pWeekViewEvent->GetEvent()->IsAllDayEvent();
  1433. CXTPCalendarEventLabel* ptrLabel = pWeekViewEvent->GetEvent()->GetLabel();
  1434. BOOL bLabel = (ptrLabel && ptrLabel->m_nLabelID != XTP_CALENDAR_NONE_LABEL_ID);
  1436. COLORREF clrBackground = m_clrBackground;
  1437. SetTextColor(m_clrTextNormalColor);
  1438. if (bMday || bAllDay)
  1439. clrBackground = RGB(255, 255, 255);
  1440. if (bLabel && ptrLabel)
  1441. clrBackground = ptrLabel->m_clrColor;
  1442. if (bSelected)
  1443. {
  1444. rcViewMax.CopyRect(pWeekViewEvent->GetViewEventRectMax());
  1445. clrBackground = m_pPaintManager->m_clrHighlight;
  1446. SetTextColor(m_clrTextHighLightColor);
  1447. }
  1449. if (bMday || bAllDay)
  1450. pDC->FillSolidRect(rcView, clrBackground);
  1451. else
  1452. pDC->FillSolidRect(rcViewMax, clrBackground);
  1454. // Draw border for long event
  1455. DrawBorder(pDC, rcView, pWeekViewEvent);
  1457. // Draw Clock for Long Events
  1458. if (nDayEventFlags & xtpCalendarMultiDayFirst)
  1459. {
  1460. m_pPaintManager->DrawClock(pDC,
  1461.    pWeekViewEvent->GetEvent()->GetStartTime(),
  1462.    pWeekViewEvent->GetFirstClockRect(),
  1463.    clrBackground,
  1464.    xtpCalendarClockAlignLeft);
  1465. }
  1466. else if (nDayEventFlags & xtpCalendarMultiDayLast)
  1467. {
  1468. m_pPaintManager->DrawClock(pDC,
  1469.    pWeekViewEvent->GetEvent()->GetEndTime(),
  1470.    pWeekViewEvent->GetLastClockRect(),
  1471.    clrBackground,
  1472.    xtpCalendarClockAlignRight);
  1473. }
  1475. // 3 Draw time start/end and  icons
  1476. clrBackground = bSelected ? m_pPaintManager->m_clrHighlight : m_clrBackground;
  1477. if (!bMday && !bAllDay)
  1478. {
  1479. DrawTimes(pDC, pWeekViewEvent);
  1480. }
  1481. m_pPaintManager->DrawIcons(pDC, pWeekViewEvent);
  1483. // 5 Draw Text
  1484. DrawSubj(pDC, pWeekViewEvent);
  1485. }
  1487. void CXTPCalendarPaintManager::CMonthViewGridPart::OnDrawGrid(CDC* pDC,
  1488. CXTPCalendarMonthView* pMonthView)
  1489. {
  1490. if (!pDC || !pMonthView || !pMonthView->GetGrid() ||
  1491. !pMonthView->GetCalendarControl() || !m_pPaintManager)
  1492. {
  1493. ASSERT(FALSE);
  1494. return;
  1495. }
  1497. COLORREF clrGridLine = RGB(0, 0, 0);
  1498. BOOL bCompressWeD = pMonthView->GetCalendarControl()->MonthView_IsCompressWeekendDays();
  1499. int nWeeksCount = pMonthView->GetGrid()->GetWeeksCount();
  1501. COleDateTime dtNow = CXTPCalendarUtils::GetCurrentTime();
  1502. int nCurrentMonth = dtNow.GetMonth();
  1503. int nWhiteMonthColorIdx = nCurrentMonth % 2;
  1505. for (int nWeek = 0; nWeek < nWeeksCount; nWeek++)
  1506. {
  1507. for (int nDayIdx = 0; nDayIdx < 7; nDayIdx++)
  1508. {
  1509. COleDateTime dtDay = pMonthView->GetGrid()->GetDayDate(nWeek, nDayIdx);
  1510. CRect rcB = pMonthView->GetGrid()->GetDayRect(nWeek, nDayIdx, TRUE);
  1512. //Draw Grid lines
  1513. if (nWeek > 0)
  1514. {
  1515. pDC->FillSolidRect(rcB.left, rcB.top, rcB.Width(), 1, clrGridLine);
  1516. }
  1517. if (nWeek < nWeeksCount-1)
  1518. {
  1519. pDC->FillSolidRect(rcB.left, rcB.bottom, rcB.Width(), 1, clrGridLine);
  1520. }
  1521. int nWDay = dtDay.GetDayOfWeek();
  1522. BOOL bCompressedCol_Su = bCompressWeD && nDayIdx == 1 && nWDay == 1;
  1523. if (nDayIdx > 0 && !bCompressedCol_Su)
  1524. {
  1525. pDC->FillSolidRect(rcB.left, rcB.top, 1, rcB.Height(), clrGridLine);
  1526. }
  1528. //Fill Grid cells background
  1529. CRect rcDay = pMonthView->GetGrid()->GetDayRect(nWeek, nDayIdx, FALSE);
  1531. int nMonth = dtDay.GetMonth();
  1532. COLORREF clrBackground = nMonth % 2 == nWhiteMonthColorIdx ? m_clrBackground : m_clrBackground2;
  1533. if (nDayIdx == 0)
  1534. {
  1535. rcDay.left--;
  1536. }
  1537. pDC->FillSolidRect(&rcDay, clrBackground);
  1538. }
  1539. }
  1540. }
  1542. void CXTPCalendarPaintManager::CMonthViewHeaderPart::OnDraw(CDC* pDC,
  1543. CXTPCalendarMonthView* pMonthView, CRect rc,
  1544. int nCollIndex, CString strText)
  1545. {
  1546. if (!pDC || !pMonthView || !pMonthView->GetGrid() || !m_pPaintManager)
  1547. {
  1548. ASSERT(FALSE);
  1549. return;
  1550. }
  1552. pDC->FillSolidRect(rc, GetBackgroundColor());
  1554. BOOL bFirstDay = nCollIndex == 0;
  1555. BOOL bLastDay = nCollIndex == pMonthView->GetGrid()->GetColsCount() - 1;
  1557. pDC->FillSolidRect(rc.left, rc.top, rc.Width(), 1, m_clrTopLeftBorder);
  1559. pDC->FillSolidRect(rc.left, rc.top + (bFirstDay ? 0: 2), 1, rc.Height() -  (bFirstDay ? 1 : 3), m_clrTopLeftBorder);
  1560. pDC->FillSolidRect(rc.right - 1, rc.top + (bLastDay ? 0: 2), 1, rc.Height() - (bLastDay ? 1 : 3), m_pPaintManager->m_clr3DShadow);
  1562. pDC->FillSolidRect(rc.left, rc.bottom, rc.Width(), 1, m_pPaintManager->m_clr3DShadow);
  1564. rc.DeflateRect(2, 0, 2, 0);
  1566. DrawLine_CenterLR(pDC, strText, rc, DT_VCENTER);
  1567. }
  1569. void CXTPCalendarPaintManager::CMonthViewEventPart::OnDrawDayDate(CDC* pDC,
  1570. CRect rc, BOOL bToday,
  1571. BOOL bSelected, CString strText)
  1572. {
  1573. if (!pDC || !m_pPaintManager)
  1574. {
  1575. ASSERT(FALSE);
  1576. return;
  1577. }
  1579. rc.DeflateRect(1, 1, 1, 1);
  1582. BOOL bXPTheme = m_pPaintManager->GetCurrentSystemTheme() != xtpSystemThemeUnknown;
  1584. if (m_pPaintManager->GetPaintTheme() != xtpCalendarThemeOffice2003)
  1585. {
  1586. bXPTheme = bToday = FALSE;
  1587. }
  1589. if (bSelected && bToday)
  1590. {
  1591. CRect rcSel = CRect(rc);
  1592. CRect rcUnSel = CRect(rc);
  1593. CSize  szText = GetTextExtent(pDC, strText);
  1594. rcSel.left = rcSel.right - (szText.cx + 7);
  1595. rcUnSel.right = rcUnSel.left + rcUnSel.Width() - (szText.cx + 7);
  1596. if (bXPTheme)
  1597. m_pPaintManager->DrawHeader(pDC, rcUnSel, FALSE, bToday);
  1598. else
  1599. m_pPaintManager->DrawHeader(pDC, rcUnSel, FALSE, bToday,
  1600. m_grclrClassicSelDay, m_clrClassicUnderline);
  1602. m_pPaintManager->DrawHeader(pDC, rcSel, bSelected, FALSE);
  1603. }
  1604. else
  1605. if (bSelected || bToday)
  1606. {
  1607. if (bXPTheme)
  1608. m_pPaintManager->DrawHeader(pDC, rc, bSelected, bToday);
  1609. else
  1610. m_pPaintManager->DrawHeader(pDC, rc, bSelected, bToday,
  1611. m_grclrClassicSelDay, m_clrClassicUnderline);
  1613. }
  1615. if (bSelected)
  1616. {
  1617. SetTextColor(m_clrTextHighLightColor);
  1618. }
  1620. rc.DeflateRect(0, 0, 5, 0);
  1621. DrawText(pDC, strText, rc, DT_VCENTER | DT_RIGHT | DT_SINGLELINE);
  1623. m_clrTextColor.SetDefaultValue();
  1624. }
  1626. void CXTPCalendarPaintManager::CMonthViewEventPart::OnDrawEvent(CDC* pDC,
  1627. CXTPCalendarMonthViewEvent* pViewEvent)
  1628. {
  1629. if (!pDC || !pViewEvent || !pViewEvent->GetEvent() || !m_pPaintManager)
  1630. {
  1631. ASSERT(FALSE);
  1632. return;
  1633. }
  1635. CRect rcEvent = pViewEvent->GetEventRect();
  1636. CRect rcText = pViewEvent->GetTextRect();
  1637. CXTPCalendarEvent* prtEvent = pViewEvent->GetEvent();
  1639. BOOL bSelected = pViewEvent->IsSelected();
  1640. int nMDEFlags = pViewEvent->GetMultiDayEventFlags();
  1642. CRect rcClockFirst(0, 0, 0, 0);
  1643. CRect rcClockLast(0, 0, 0, 0);
  1644. COleDateTime dtClockFirst;
  1645. COleDateTime dtClockLast;
  1646. COLORREF clrBackground;
  1647. if (nMDEFlags & xtpCalendarMultiDayFirst)
  1648. {
  1649. rcClockFirst.CopyRect(pViewEvent->GetFirstClockRect());
  1650. dtClockFirst = pViewEvent->GetEvent()->GetStartTime();
  1651. }
  1652. if (nMDEFlags & xtpCalendarMultiDayLast)
  1653. {
  1654. rcClockLast.CopyRect(pViewEvent->GetLastClockRect());
  1655. dtClockLast = pViewEvent->GetEvent()->GetEndTime();
  1656. }
  1658. if (bSelected)
  1659. {
  1660. if (nMDEFlags & xtpCalendarMultiDayFMLmask)
  1661. {
  1662. rcEvent.top--;
  1663. rcEvent.bottom++;
  1664. }
  1665. else
  1666. {
  1667. rcEvent.left = pViewEvent->m_rcEventMax.left + 2;
  1668. rcEvent.right = pViewEvent->m_rcEventMax.right - 2;
  1669. }
  1670. SetTextColor(m_clrTextHighLightColor);
  1671. clrBackground = m_pPaintManager->m_clrHighlight;
  1672. pDC->FillSolidRect(&rcEvent, m_pPaintManager->m_clrHighlight);
  1673. clrBackground = m_pPaintManager->m_clrHighlight;
  1674. }
  1675. else
  1676. {
  1677. CXTPCalendarEventLabel* ptrLabel = pViewEvent->GetEvent()->GetLabel();
  1678. COLORREF clrLabel = ptrLabel ? ptrLabel->m_clrColor : RGB(255, 255, 255);
  1679. BOOL bNoneLabel = ptrLabel ? (ptrLabel->m_nLabelID == XTP_CALENDAR_NONE_LABEL_ID) : TRUE;
  1680. clrBackground = clrLabel;
  1682. if (nMDEFlags & xtpCalendarMultiDayFMLmask || !bNoneLabel)
  1683. {
  1684. pDC->FillSolidRect(&rcEvent, clrLabel);
  1685. }
  1686. }
  1688. UINT uAlign = DT_LEFT;
  1690. CString strLoc = pViewEvent->GetItemTextLocation();
  1691. CString strText = pViewEvent->GetItemTextSubject();
  1692. if (strLoc.GetLength() > 0)
  1693. {
  1694. strText += _T(" (") + strLoc + _T(")");
  1695. }
  1697. if (nMDEFlags & xtpCalendarMultiDayFMLmask)
  1698. {
  1699. int nBY = bSelected ? 2 : 1;
  1700. pDC->FillSolidRect(rcEvent.left, rcEvent.top, rcEvent.Width(), nBY, m_clrMultiDayEventFrameColor);
  1701. pDC->FillSolidRect(rcEvent.left, rcEvent.bottom - nBY, rcEvent.Width(), nBY, m_clrMultiDayEventFrameColor);
  1703. if (nMDEFlags & xtpCalendarMultiDayFirst)
  1704. {
  1705. pDC->FillSolidRect(rcEvent.left, rcEvent.top, 1, rcEvent.Height(), m_clrMultiDayEventFrameColor);
  1706. }
  1707. if (nMDEFlags & xtpCalendarMultiDayLast)
  1708. {
  1709. pDC->FillSolidRect(rcEvent.right, rcEvent.top, 1, rcEvent.Height(), m_clrMultiDayEventFrameColor);
  1710. }
  1712. //CSize szSpace = GetTextExtent(pDC, _T(" "));
  1714. rcText.left += 1;//min(1, szSpace.cx/2);
  1715. rcText.right -= 1;
  1716. CSize szText = GetTextExtent(pDC, strText);
  1718. if (pViewEvent->IsMultyDayTextAlign() || szText.cx > rcText.Width())
  1719. uAlign = DT_LEFT;
  1720. else
  1721. uAlign = DT_CENTER;
  1723. }
  1725. // draw clocks for multyday events
  1726. if ((nMDEFlags & xtpCalendarMultiDayFirst) || (nMDEFlags & xtpCalendarMultiDayLast))
  1727. {
  1728. if (rcClockFirst.Width() > 0)
  1729. m_pPaintManager->DrawClock(
  1730. pDC,
  1731. dtClockFirst,
  1732. rcClockFirst,
  1733. clrBackground,
  1734. xtpCalendarClockAlignLeft);
  1736. if (rcClockLast.Width() > 0)
  1737. m_pPaintManager->DrawClock(
  1738. pDC,
  1739. dtClockLast,
  1740. rcClockLast,
  1741. clrBackground,
  1742. xtpCalendarClockAlignLeft);
  1743. }
  1745. //CRect rcText = pViewEvent->GetTextRect();
  1746. if (nMDEFlags & xtpCalendarMultiDayNoMultiDay)
  1747. {
  1748. //IsTimeAsClock()
  1749. COleDateTime dtStart(prtEvent->GetStartTime());
  1750. COleDateTime dtEnd(prtEvent->GetEndTime());
  1752. CString strStartTime = pViewEvent->GetItemTextStartTime();
  1753. CString strEndTime = pViewEvent->GetItemTextEndTime();
  1755. CRect rcStart(pViewEvent->GetStartTimeRect());
  1756. CRect rcEnd(pViewEvent->GetEndTimeRect());
  1758. if (pViewEvent->IsTimeAsClock())
  1759. {
  1760. m_pPaintManager->DrawClock(pDC, dtStart, rcStart, clrBackground, xtpCalendarClockAlignCenter);
  1761. m_pPaintManager->DrawClock(pDC, dtEnd, rcEnd, clrBackground, xtpCalendarClockAlignCenter);
  1762. }
  1763. else
  1764. {
  1765. DrawLineEx(pDC, strStartTime, rcStart, DT_RIGHT | DT_VCENTER, DT_LEFT | DT_VCENTER );
  1766. DrawLineEx(pDC, strEndTime, rcEnd, DT_RIGHT | DT_VCENTER, DT_LEFT | DT_VCENTER );
  1767. }
  1768. }
  1770. DrawText(pDC, strText, rcText, uAlign | DT_VCENTER | DT_SINGLELINE);
  1771. m_pPaintManager->DrawIcons(pDC, pViewEvent);
  1773. m_clrTextColor.SetDefaultValue();
  1774. }
  1777. /////////////////////////////////////////////////////////////////////////////
  1778. // CXTPCalendarPaintManager
  1780. #define ADDVIEWPART(theClass, parent)
  1781. m_p##theClass = (C##theClass*)AddViewPart(new C##theClass(m_p##parent));
  1785. CXTPCalendarPaintManager::CXTPCalendarPaintManager()
  1786. {
  1787. m_pGlyphsFont = NULL;
  1789. m_szClockRect.cx = 15;
  1790. m_szClockRect.cy = 15;
  1792. m_szExpandSign.cx = m_szExpandSign.cy = 0;
  1794. m_pControl = NULL;
  1796. m_bEnableTheme = TRUE;
  1798. m_dwAskItemTextFlags = 0;
  1800. m_pControlPart = (CControlPart*)AddViewPart(new CControlPart());
  1802. ADDVIEWPART(DayViewTimeScaleHeaderPart, ControlPart);
  1803. ADDVIEWPART(DayViewTimeScaleCellPart, DayViewTimeScaleHeaderPart);
  1804. ADDVIEWPART(DayViewCellPart, ControlPart);
  1805. ADDVIEWPART(DayViewWorkCellPart, DayViewCellPart);
  1806. ADDVIEWPART(DayViewNonworkCellPart, DayViewCellPart);
  1807. ADDVIEWPART(DayViewHeaderPart, ControlPart);
  1808. ADDVIEWPART(DayViewGroupHeaderPart, ControlPart);
  1809. ADDVIEWPART(DayViewAllDayEventsPart, ControlPart);
  1810. ADDVIEWPART(DayViewEventPart, ControlPart);
  1811. ADDVIEWPART(WeekViewPart, ControlPart);
  1812. ADDVIEWPART(WeekViewEventPart, ControlPart);
  1813. ADDVIEWPART(MonthViewGridPart, ControlPart);
  1814. ADDVIEWPART(MonthViewHeaderPart, ControlPart);
  1815. ADDVIEWPART(MonthViewEventPart, ControlPart);
  1817. //-----------------------------------------------------------------------
  1818. CBitmap bmpSignUp, bmpSignDown;
  1820. VERIFY(XTPResourceManager()->LoadBitmap(&bmpSignUp, XTP_IDB_CALENDAR_EXPANDSIGNUP) );
  1821. VERIFY(XTPResourceManager()->LoadBitmap(&bmpSignDown, XTP_IDB_CALENDAR_EXPANDSIGNDOWN) );
  1823. CSize szSexpandSign = GetExpandSignSize();
  1825. VERIFY(m_ilExpandSigns.Create(szSexpandSign.cx, szSexpandSign.cy, ILC_COLOR24 | ILC_MASK, 0, 1));
  1827. COLORREF clrMask = RGB(255, 0, 255);
  1828. m_ilExpandSigns.Add(&bmpSignUp, clrMask);
  1829. m_ilExpandSigns.Add(&bmpSignDown, clrMask);
  1831. //-----------------------------------------------------------------------
  1832. VERIFY(m_ilGlyphs.Create(16, 11, ILC_COLOR24 | ILC_MASK, 0, 1));
  1833. CBitmap bmp;
  1834. VERIFY(XTPResourceManager()->LoadBitmap(&bmp, XTP_IDB_CALENDAR_EVENT_GLYPHS));
  1835. m_ilGlyphs.Add(&bmp, RGB(255, 0, 255));
  1837. m_CurrSystemTheme = xtpSystemThemeUnknown;
  1838. m_nPaintTheme = xtpCalendarThemeOffice2003;
  1840. RefreshMetrics();
  1841. }
  1843. CXTPCalendarPaintManager::~CXTPCalendarPaintManager()
  1844. {
  1845. while (!m_lstViewParts.IsEmpty())
  1846. {
  1847. delete m_lstViewParts.RemoveHead();
  1848. }
  1850. SAFE_DELETE(m_pGlyphsFont);
  1851. }
  1853. void CXTPCalendarPaintManager::RefreshMetrics()
  1854. {
  1855. RefreshXtremeColors();
  1857. m_clrButtonFace.SetStandardValue(GetSysColor(COLOR_BTNFACE));
  1858. m_clrButtonFaceText.SetStandardValue(GetSysColor(COLOR_BTNTEXT));
  1859. m_clrWindow.SetStandardValue(GetSysColor(COLOR_WINDOW));
  1860. m_clrWindowText.SetStandardValue(GetSysColor(COLOR_WINDOWTEXT));
  1861. m_clr3DShadow.SetStandardValue(GetSysColor(COLOR_3DSHADOW));
  1862. m_clrHighlight.SetStandardValue(GetSysColor(COLOR_HIGHLIGHT));
  1864. InitBusyStatusDefaultColors();
  1866. POSITION pos = m_lstViewParts.GetHeadPosition();
  1867. while (pos)
  1868. {
  1869. CXTPCalendarViewPart* pPart = m_lstViewParts.GetNext(pos);
  1870. ASSERT(pPart);
  1871. if (pPart)
  1872. {
  1873. pPart->RefreshMetrics();
  1874. }
  1875. }
  1877. m_grclrToday.SetStandardValue(m_clrButtonFace, m_clrButtonFace);
  1879. m_clrUnderLineHdr = m_clrHighlight;
  1881. if (m_nPaintTheme >= xtpCalendarThemeOffice2003)
  1882. {
  1883. m_CurrSystemTheme = xtpSystemThemeUnknown;
  1885. if (m_bEnableTheme && !XTPColorManager()->IsLunaColorsDisabled())
  1886. {
  1887. m_CurrSystemTheme = XTPColorManager()->GetCurrentSystemTheme();
  1889. if (m_CurrSystemTheme != xtpSystemThemeUnknown)
  1890. {
  1891. m_grclrToday.SetStandardValue(m_clrButtonFace, RGB(250, 203, 91));
  1892. m_clrUnderLineHdr = RGB(187, 85, 3);
  1893. }
  1894. }
  1895. }
  1897. //-----------------------------------------------------------------------
  1898. SAFE_DELETE(m_pGlyphsFont);
  1900. BOOL bFontExists = XTPDrawHelpers()->FontExists(cszGlyphsFontName);
  1901. if (bFontExists)
  1902. {
  1903. m_pGlyphsFont = new CFont();
  1904. if (m_pGlyphsFont)
  1905. {
  1906. LOGFONT lfGlupth;
  1907. ::ZeroMemory(&lfGlupth, sizeof(lfGlupth));
  1909. STRCPY_S(lfGlupth.lfFaceName, LF_FACESIZE, cszGlyphsFontName);
  1910. lfGlupth.lfCharSet = SYMBOL_CHARSET;
  1911. lfGlupth.lfHeight = -11;
  1912. lfGlupth.lfWeight = FW_NORMAL;
  1914. if (!m_pGlyphsFont->CreateFontIndirect(&lfGlupth))
  1915. {
  1916. SAFE_DELETE(m_pGlyphsFont);
  1917. }
  1918. }
  1919. }
  1921. if (!m_pGlyphsFont)
  1922. {
  1923. TRACE(_T("WARNING! Calendar PaintManeger: cannot create 'MS Outlook' font. Standard bitmaps are used. n"));
  1924. }
  1925. }
  1927. void CXTPCalendarPaintManager::CDayViewWorkCellPart::RefreshMetrics()
  1928. {
  1929. if (m_pPaintManager->GetPaintTheme() <= xtpCalendarThemeOffice2000 ||
  1930. m_pPaintManager->GetPaintTheme() == xtpCalendarThemeOfficeXP)
  1931. {
  1932. if (m_pPaintManager->GetPaintTheme() <= xtpCalendarThemeOffice2000)
  1933. m_clrBackground.SetStandardValue(RGB(255, 255, 255));
  1934. else
  1935. m_clrBackground.SetStandardValue(RGB(255, 255, 0));
  1937. m_clrBackgroundSlave.SetStandardValue(RGB(255, 255, 255));
  1938. m_clrShadow.SetStandardValue(RGB(128, 128, 128));
  1939. m_clrHour.SetStandardValue(RGB(128, 128, 128));
  1940. }
  1941. else if (m_pPaintManager->GetPaintTheme() >= xtpCalendarThemeOffice2003)
  1942. {
  1943. m_clrBackground.SetStandardValue(RGB(255, 255, 213));
  1944. m_clrShadow.SetStandardValue(RGB(243, 228, 177));
  1945. m_clrHour.SetStandardValue(RGB(234, 208, 152));
  1946. }
  1947. else {
  1948. ASSERT(FALSE);
  1949. }
  1950. }
  1952. void CXTPCalendarPaintManager::CDayViewNonworkCellPart::RefreshMetrics()
  1953. {
  1954. if (m_pPaintManager->GetPaintTheme() <= xtpCalendarThemeOffice2000 ||
  1955. m_pPaintManager->GetPaintTheme() == xtpCalendarThemeOfficeXP)
  1956. {
  1957. m_clrBackground.SetStandardValue(RGB(255, 255, 0));
  1958. m_clrBackgroundSlave.SetStandardValue(RGB(128, 128, 128));
  1960. if (m_pPaintManager->GetPaintTheme() <= xtpCalendarThemeOffice2000)
  1961. {
  1962. m_clrBackground.SetStandardValue(RGB(212, 208, 200));
  1963. m_clrBackgroundSlave.SetStandardValue(RGB(212, 208, 200));
  1964. }
  1966. m_clrShadow.SetStandardValue(RGB(128, 128, 128));
  1967. m_clrHour.SetStandardValue(RGB(128, 128, 128));
  1968. }
  1969. else if (m_pPaintManager->GetPaintTheme() >= xtpCalendarThemeOffice2003)
  1970. {
  1971. m_clrBackground.SetStandardValue(RGB(255, 244, 188));
  1972. m_clrBackgroundSlave.SetStandardValue(RGB(255, 244, 188));
  1973. m_clrShadow.SetStandardValue(RGB(243, 228, 177));
  1974. m_clrHour.SetStandardValue(RGB(234, 208, 152));
  1975. }
  1976. else {
  1977. ASSERT(FALSE);
  1978. }
  1979. }
  1981. void CXTPCalendarPaintManager::CMonthViewGridPart::RefreshMetrics()
  1982. {
  1983. if (m_pPaintManager->GetPaintTheme() <= xtpCalendarThemeOffice2000 ||
  1984. m_pPaintManager->GetPaintTheme() == xtpCalendarThemeOfficeXP)
  1985. {
  1986. m_clrBackground.SetStandardValue(RGB(255, 255, 255));
  1987. m_clrBackground2.SetStandardValue(RGB(215, 211, 203));
  1988. }
  1989. else if (m_pPaintManager->GetPaintTheme() >= xtpCalendarThemeOffice2003)
  1990. {
  1991. m_clrBackground.SetStandardValue(RGB(255, 255, 213));
  1992. m_clrBackground2.SetStandardValue(RGB(255, 244, 188));
  1993. }
  1994. else {
  1995. ASSERT(FALSE);
  1996. }
  1997. }
  1999. void CXTPCalendarPaintManager::CWeekViewPart::RefreshMetrics()
  2000. {
  2001. m_clrTextColor.SetStandardValue(m_pPaintManager->m_clrButtonFaceText);
  2002. m_clrTextHighLightColor = RGB(255, 255, 255);
  2003. m_clrTextNormalColor = m_pPaintManager->m_clrButtonFaceText;
  2004. m_clrHeaderBottomLine = m_pPaintManager->m_clr3DShadow;
  2005. LOGFONT lfIcon;
  2006. VERIFY(::SystemParametersInfo(SPI_GETICONTITLELOGFONT, sizeof(lfIcon), &lfIcon, 0));
  2007. m_fntText.SetStandardValue(&lfIcon);
  2009. if (m_pPaintManager->GetPaintTheme() <= xtpCalendarThemeOffice2000 ||
  2010. m_pPaintManager->GetPaintTheme() == xtpCalendarThemeOfficeXP)
  2011. {
  2012. m_clrBackground.SetStandardValue(RGB(255, 255, 255));
  2013. }
  2014. else if (m_pPaintManager->GetPaintTheme() >= xtpCalendarThemeOffice2003)
  2015. {
  2017. m_clrBackground.SetStandardValue(RGB(255, 255, 213));
  2018. }
  2019. else {
  2020. ASSERT(FALSE);
  2021. }
  2022. }
  2024. CXTPCalendarViewPart* CXTPCalendarPaintManager::AddViewPart(CXTPCalendarViewPart* pPart)
  2025. {
  2026. ASSERT(pPart);
  2027. if (pPart)
  2028. {
  2029. m_lstViewParts.AddTail(pPart);
  2030. pPart->m_pPaintManager = this;
  2031. }
  2033. return pPart;
  2034. }
  2036. void CXTPCalendarPaintManager::DrawLine(CDC* pDC, int x, int y, int cx, int cy)
  2037. {
  2038. ASSERT(pDC);
  2039. if (!pDC)
  2040. {
  2041. return;
  2042. }
  2044. pDC->MoveTo(x, y);
  2045. pDC->LineTo(x + cx, y + cy);
  2046. }
  2048. void CXTPCalendarPaintManager::DrawHorizontalLine(CDC* pDC, int x, int y, int cx)
  2049. {
  2050. DrawLine(pDC, x, y, cx, 0);
  2051. }
  2052. void CXTPCalendarPaintManager::DrawVerticalLine(CDC* pDC, int x, int y, int cy)
  2053. {
  2054. DrawLine(pDC, x, y, 0, cy);
  2055. }
  2057. int CXTPCalendarPaintManager::DrawBitmap(CImageList* pImageList, CDC* pDC,
  2058.  CRect rcView, int iIcon, UINT uFlags)
  2059. {
  2060. ASSERT(pImageList && pDC);
  2061. if (!pImageList || !pDC)
  2062. {
  2063. return 0;
  2064. }
  2066. int nImageBound = rcView.left;
  2068. if (rcView.left >= rcView.right - 2)
  2069. return nImageBound;
  2071. POINT ptIcon;
  2072. IMAGEINFO imgInf;
  2074. if (!pImageList->GetImageInfo(iIcon, &imgInf))
  2075. return nImageBound;
  2077. CSize szImage(imgInf.rcImage.right - imgInf.rcImage.left, imgInf.rcImage.bottom - imgInf.rcImage.top);
  2078. CSize szView(rcView.Size());
  2079. ptIcon.x = rcView.left;
  2080. ptIcon.y = rcView.top;
  2082. szImage.cx = min(szImage.cx, szView.cx);
  2084. if (uFlags & DT_VCENTER)
  2085. {
  2086. ptIcon.y = rcView.top + (szView.cy - szImage.cy) /2 + 1;
  2087. }
  2089. IMAGELISTDRAWINDIRECT_S(pImageList, pDC, iIcon, ptIcon, szImage);
  2091. return szImage.cx;
  2092. }
  2094. int CXTPCalendarPaintManager::DrawBitmap(UINT nIDResource, CDC* pDC, CRect rcBitmap)
  2095. {
  2096. ASSERT(pDC);
  2097. if (!pDC)
  2098. {
  2099. return 0;
  2100. }
  2102. CBitmap bmpIcon;
  2104. if (!XTPResourceManager()->LoadBitmap(&bmpIcon, nIDResource))
  2105. return 0;
  2107. BITMAP bmpInfo;
  2108. bmpIcon.GetBitmap(&bmpInfo);
  2110. CImageList ilBitmap;
  2111. VERIFY(ilBitmap.Create(bmpInfo.bmWidth, bmpInfo.bmHeight, ILC_COLOR24 | ILC_MASK, 0, 1));
  2112. ilBitmap.Add(&bmpIcon, RGB(255, 0 , 255));
  2114. CRect rcBitmap2 = rcBitmap;
  2115. rcBitmap2.bottom = rcBitmap2.top + bmpInfo.bmHeight;
  2117. DrawBitmap(&ilBitmap, pDC, rcBitmap2, 0);
  2119. // Don't work correctly for the printer
  2120. //
  2121. //  CXTPCompatibleDC dcMem(pDC, &bmpIcon);
  2122. //
  2123. // Get the size of the bitmap
  2124. //  BITMAP bmpInfo;
  2125. //  bmpIcon.GetBitmap(&bmpInfo);
  2127. //  pDC->BitBlt(rcBitmap.left, rcBitmap.top,
  2128. //              bmpInfo.bmWidth, bmpInfo.bmHeight, &dcMem,
  2129. //              0, 0, SRCCOPY);
  2131. return bmpInfo.bmWidth;
  2132. }
  2134. CSize CXTPCalendarPaintManager::GetBitmapSize(UINT nIDResource)
  2135. {
  2136. CBitmap bmpIcon;
  2137. VERIFY(XTPResourceManager()->LoadBitmap(&bmpIcon, nIDResource));
  2139. BITMAP bmpInfo;
  2140. bmpIcon.GetBitmap(&bmpInfo);
  2141. CSize szIcon(bmpInfo.bmWidth, bmpInfo.bmHeight);
  2142. return szIcon;
  2143. }
  2145. const CSize CXTPCalendarPaintManager::GetExpandSignSize()
  2146. {
  2147. // if sign size is not initialized, initialize it
  2148. if (!(m_szExpandSign.cx | m_szExpandSign.cy))
  2149. {
  2150. m_szExpandSign = GetBitmapSize(XTP_IDB_CALENDAR_EXPANDSIGNDOWN);
  2151. }
  2152. return m_szExpandSign;
  2153. }
  2155. int CXTPCalendarPaintManager::DrawClock(CDC* pDC, COleDateTime dtClockTime,
  2156. CRect rcView, COLORREF clrBackground, XTPCalendarClockAlignFlags cafAlign)
  2157. {
  2158. ASSERT(pDC);
  2159. if (!pDC)
  2160. {
  2161. return 0;
  2162. }
  2164. static const CPoint arrHours[] =
  2165. {
  2166. CPoint(0, -6),
  2167. CPoint(3, -5),
  2168. CPoint(5, -3),
  2169. CPoint(6, 0),
  2170. CPoint(5, 3),
  2171. CPoint(3, 5),
  2172. CPoint(0, 6),
  2173. CPoint(-3, 5),
  2174. CPoint(-5, 3),
  2175. CPoint(-6, 0),
  2176. CPoint(-5, -3),
  2177. CPoint(-3, -5),
  2178. CPoint(0, -6)
  2179. };
  2181. static const CPoint arrHalfHours[] =
  2182. {
  2183. CPoint(1, -5),
  2184. CPoint(3, -3),
  2185. CPoint(4, -1),
  2186. CPoint(5, 1),
  2187. CPoint(3, 3),
  2188. CPoint(1, 5),
  2189. CPoint(-1, 5),
  2190. CPoint(-3, 3),
  2191. CPoint(-5, 1),
  2192. CPoint(-5, -1),
  2193. CPoint(-3, -3),
  2194. CPoint(-1, -5),
  2195. CPoint(1, -5)
  2196. };
  2198. if (rcView.Width() < m_szClockRect.cx || rcView.Height() < m_szClockRect.cy)
  2199. return 0;
  2201. CPoint ptClock(rcView.left, rcView.top);
  2203. if (cafAlign == xtpCalendarClockAlignLeft)
  2204. ptClock.Offset(1, (rcView.Height() - m_szClockRect.cy)/2 + 1);
  2205. else if (cafAlign == xtpCalendarClockAlignRight)
  2206. ptClock.Offset(rcView.Width() - m_szClockRect.cx - 1,
  2207.    (rcView.Height() - m_szClockRect.cy)/2 + 1);
  2208. else if (cafAlign == xtpCalendarClockAlignCenter)
  2209. ptClock.Offset((rcView.Width() - m_szClockRect.cx)/2,
  2210.    (rcView.Height() - m_szClockRect.cy)/2 + 1);
  2212. CRect rcClock(0, 0, 0, 0);
  2213. rcClock.SetRect(ptClock.x, ptClock.y,
  2214. ptClock.x + m_szClockRect.cx,
  2215. ptClock.y + m_szClockRect.cy);
  2217. int nHour = dtClockTime.GetHour();
  2218. int nMin = dtClockTime.GetMinute() /5;
  2220. COLORREF clrFill;
  2221. COLORREF clrItems;
  2222. if (nHour >= 12)
  2223. {
  2224. clrFill = RGB(0, 0, 0);
  2225. clrItems = clrBackground;
  2226. }
  2227. else
  2228. {
  2229. clrFill = clrBackground;
  2230. clrItems = RGB(0, 0, 0);
  2231. }
  2234. nHour = nHour > 12 ? nHour - 12 : nHour;
  2236. CXTPBrushDC brushClock(pDC->m_hDC, clrFill);
  2237. CPoint ptCenter(rcClock.CenterPoint());
  2238. pDC->Ellipse(rcClock);
  2239. CXTPPenDC penItems(pDC->m_hDC, clrItems);
  2240. int x = 0;
  2241. int y = 0;
  2243. for (int i = 0; i <= 12; i++)
  2244. {
  2245. pDC->SetPixel(ptCenter.x + arrHours[i].x,
  2246.   ptCenter.y + arrHours[i].y, clrItems);
  2247. if (nHour == i)
  2248. {
  2249. if (nMin >= 6)
  2250. {
  2251. x = arrHalfHours[i].x;
  2252. y = arrHalfHours[i].y;
  2253. }
  2254. else
  2255. {
  2256. x = arrHours[i].x;
  2257. y = arrHours[i].y;
  2258. x = x > 0 ? x -1 : x == 0 ? 0 : x + 1;
  2259. y = y > 0 ? y -1 : y == 0 ? 0 : y + 1;
  2260. }
  2261. pDC->MoveTo(ptCenter);
  2262. pDC->LineTo(ptCenter.x+ x, ptCenter.y + y);
  2263. }
  2264. if (nMin == i)
  2265. {
  2266. pDC->MoveTo(ptCenter);
  2267. pDC->LineTo(ptCenter.x + arrHours[i].x,
  2268. ptCenter.y + arrHours[i].y);
  2269. }
  2270. }
  2272. return m_szClockRect.cx;
  2274. }
  2276. void CXTPCalendarPaintManager::SetControl(CXTPCalendarControl* pControl)
  2277. {
  2278. m_pControl = pControl;
  2279. }
  2281. int CXTPCalendarPaintManager::DrawIconChar(CDC* pDC, CRect rc, TCHAR ch)
  2282. {
  2283. if (!pDC || !m_pGlyphsFont || !m_pGlyphsFont->m_hObject)
  2284. {
  2285. ASSERT(FALSE);
  2286. return 0;
  2287. }
  2289. CFont* pPrevFnt = pDC->SelectObject(m_pGlyphsFont);
  2290. pDC->SetTextColor(GetControlPart()->GetTextColor());
  2291. TCHAR cszCh[2] = {ch, 0};
  2293. UINT uFlags = DT_VCENTER | DT_LEFT; // DT_CENTER;
  2295. //CSize szChar = pDC->GetTextExtent(szCh, 1);
  2296. CRect rcNeed = rc;
  2297. pDC->DrawText(cszCh, 1, rcNeed, uFlags | DT_CALCRECT);
  2298. rc.bottom = rc.top + rcNeed.Height();
  2300. pDC->DrawText(cszCh, 1, rc, uFlags);
  2302. pDC->SelectObject(pPrevFnt);
  2304. //return szChar.cx;
  2305. return rcNeed.Width();
  2306. }
  2308. int CXTPCalendarPaintManager::DrawIcons(CDC* pDC, CXTPCalendarViewEvent* pViewEvent)
  2309. {
  2310. if (!pViewEvent || !pViewEvent->GetEvent())
  2311. {
  2312. ASSERT(FALSE);
  2313. return 0;
  2314. }
  2317. BOOL bUseFont = XTP_SAFE_GET3(pViewEvent, GetCalendarControl(),
  2318. GetCalendarOptions(), bUseOutlookFontGlyphs, FALSE);
  2319. bUseFont = bUseFont && m_pGlyphsFont;
  2321. int nWidth = 0;
  2323. if (pViewEvent->GetEvent()->IsReminder() &&
  2324. !pViewEvent->GetReminderGlyphRect().IsRectEmpty())
  2325. {
  2326. if (bUseFont)
  2327. {
  2328. nWidth += DrawIconChar(pDC, pViewEvent->GetReminderGlyphRect(), 0x41);
  2329. }
  2330. else
  2331. {
  2332. nWidth += DrawBitmap(&m_ilGlyphs, pDC,
  2333. pViewEvent->GetReminderGlyphRect(), 0, DT_VCENTER);
  2334. }
  2335. }
  2337. int nRecurrenceState = pViewEvent->GetEvent()->GetRecurrenceState();
  2338. if (!pViewEvent->GetRecurrenceGlyphRect().IsRectEmpty())
  2339. {
  2340. if ((nRecurrenceState == xtpCalendarRecurrenceMaster) || (nRecurrenceState == xtpCalendarRecurrenceOccurrence))
  2341. {
  2342. if (bUseFont)
  2343. {
  2344. nWidth += DrawIconChar(pDC, pViewEvent->GetRecurrenceGlyphRect(), 0x43);
  2345. }
  2346. else
  2347. {
  2348. nWidth += DrawBitmap(&m_ilGlyphs, pDC,
  2349.  pViewEvent->GetRecurrenceGlyphRect(), 1, DT_VCENTER);
  2350. }
  2351. }
  2352. else if (nRecurrenceState == xtpCalendarRecurrenceException)
  2353. {
  2354. if (bUseFont)
  2355. {
  2356. nWidth += DrawIconChar(pDC, pViewEvent->GetRecurrenceGlyphRect(), 0x44);
  2357. }
  2358. else
  2359. {
  2360. nWidth += DrawBitmap(&m_ilGlyphs, pDC,
  2361. pViewEvent->GetRecurrenceGlyphRect(), 2, DT_VCENTER);
  2362. }
  2363. }
  2364. }
  2366. if (pViewEvent->GetEvent()->IsMeeting() &&
  2367. !pViewEvent->GetMeetingGlyphRect().IsRectEmpty())
  2368. {
  2369. if (bUseFont)
  2370. {
  2371. nWidth += DrawIconChar(pDC, pViewEvent->GetMeetingGlyphRect(), 0x45);
  2372. }
  2373. else
  2374. {
  2375. nWidth += DrawBitmap(&m_ilGlyphs, pDC,
  2376. pViewEvent->GetMeetingGlyphRect(), 3, DT_VCENTER);
  2377. }
  2378. }
  2380. if (pViewEvent->GetEvent()->IsPrivate() &&
  2381. !pViewEvent->GetPrivateGlyphRect().IsRectEmpty())
  2382. {
  2383. if (bUseFont)
  2384. {
  2385. nWidth += DrawIconChar(pDC, pViewEvent->GetPrivateGlyphRect(), 0x42);
  2386. }
  2387. else
  2388. {
  2389. nWidth += DrawBitmap(&m_ilGlyphs, pDC,
  2390. pViewEvent->GetPrivateGlyphRect(), 4, DT_VCENTER);
  2391. }
  2392. }
  2394. return nWidth;
  2395. }
  2397. void CXTPCalendarPaintManager::InitBusyStatusDefaultColors()
  2398. {
  2399. m_brushTentative.DeleteObject();
  2400. m_bmpTentativePattern.DeleteObject();
  2402. VERIFY(XTPResourceManager()->LoadBitmap(&m_bmpTentativePattern, XTP_IDB_CALENDAR_TENATIVE_PATTERN));
  2403. VERIFY(m_brushTentative.CreatePatternBrush(&m_bmpTentativePattern));
  2406. CXTPCalendarViewPartBrushValue* pBVal_Free = _GetAtGrow_BusyStatusBrushValue(xtpCalendarBusyStatusFree, TRUE);
  2407. CXTPCalendarViewPartBrushValue* pBVal_Tentative = _GetAtGrow_BusyStatusBrushValue(xtpCalendarBusyStatusTentative, TRUE);
  2408. CXTPCalendarViewPartBrushValue* pBVal_Busy = _GetAtGrow_BusyStatusBrushValue(xtpCalendarBusyStatusBusy, TRUE);
  2409. CXTPCalendarViewPartBrushValue* pBVal_OutOO = _GetAtGrow_BusyStatusBrushValue(xtpCalendarBusyStatusOutOfOffice, TRUE);
  2411. if (pBVal_Free)
  2412. {
  2413. pBVal_Free->SetStandardValue(new CBrush(RGB(0xFF, 0xFF, 0xFF)), TRUE);
  2414. }
  2415. if (pBVal_Tentative)
  2416. {
  2417. pBVal_Tentative->SetStandardValue(&m_brushTentative, FALSE);
  2418. }
  2419. if (pBVal_Busy)
  2420. {
  2421. pBVal_Busy->SetStandardValue(new CBrush(RGB(0, 0, 0xFF)), TRUE);
  2422. }
  2423. if (pBVal_OutOO)
  2424. {
  2425. pBVal_OutOO->SetStandardValue(new CBrush(RGB(132, 0, 132)), TRUE);
  2426. }
  2427. }
  2429. void CXTPCalendarPaintManager::SetBusyStatusBrush(int eBusyStatus, CBrush* pBrush, BOOL bAutodeleteBrush)
  2430. {
  2431. if (eBusyStatus < 0 || !pBrush)
  2432. {
  2433. ASSERT(FALSE);
  2434. return;
  2435. }
  2437. CXTPCalendarViewPartBrushValue* pBVal = _GetAtGrow_BusyStatusBrushValue(eBusyStatus, TRUE);
  2438. ASSERT(pBVal);
  2439. if (pBVal)
  2440. {
  2441. pBVal->SetCustomValue(pBrush, bAutodeleteBrush);
  2442. }
  2443. }
  2445. CBrush* CXTPCalendarPaintManager::GetBusyStatusBrush(int nBusyStatus)
  2446. {
  2447. CXTPCalendarViewPartBrushValue* pBVal = _GetAtGrow_BusyStatusBrushValue(nBusyStatus, TRUE);
  2448. ASSERT(pBVal);
  2449. if (pBVal)
  2450. {
  2451. CBrush* pBrush = pBVal->GetValue();
  2452. return pBrush;
  2453. }
  2455. return NULL;
  2456. }
  2458. CXTPCalendarViewPartBrushValue* CXTPCalendarPaintManager::_GetAtGrow_BusyStatusBrushValue(
  2459. int nBusyStatus, BOOL bGrow)
  2460. {
  2461. if (nBusyStatus < 0)
  2462. {
  2463. //ASSERT(FALSE);
  2464. nBusyStatus = 0;
  2465. }
  2467. int nCount = (int)m_arBusyStatusBrushes.GetSize();
  2469. if (nBusyStatus >= nCount || m_arBusyStatusBrushes[nBusyStatus] == NULL)
  2470. {
  2471. if (!bGrow)
  2472. {
  2473. return NULL;
  2474. }
  2475. m_arBusyStatusBrushes.SetAtGrow(nBusyStatus, new CXTPCalendarViewPartBrushValue);
  2476. }
  2477. CXTPCalendarViewPartBrushValue* pBVal = m_arBusyStatusBrushes[nBusyStatus];
  2478. return pBVal;
  2479. }
  2481. void CXTPCalendarPaintManager::DrawBusyStatus(CDC* pDC, CRect& rcRect, int eBusyStatus)
  2482. {
  2483. CBrush* pBrush = GetBusyStatusBrush(eBusyStatus);
  2484. if (!pBrush || !pDC)
  2485. {
  2486. ASSERT(FALSE);
  2487. return;
  2488. }
  2490. pDC->FillRect(&rcRect, pBrush);
  2491. }
  2493. void CXTPCalendarPaintManager::DrawBusyStatus(CDC* pDC, CRgn& rgnBusy, int eBusyStatus)
  2494. {
  2495. CBrush* pBrush = GetBusyStatusBrush(eBusyStatus);
  2496. if (!pBrush || !pDC)
  2497. {
  2498. ASSERT(FALSE);
  2499. return;
  2500. }
  2502. CBrush brBorder(m_clrWindowText);
  2504. VERIFY(pDC->FillRgn(&rgnBusy, pBrush));
  2505. VERIFY(pDC->FrameRgn(&rgnBusy, &brBorder, 1, 1));
  2506. }
  2508. //////////////////////////////////////////////////////////////////////////