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

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

对话框与窗口

开发平台：

Visual C++

XTPCalendarControlView.cpp：源码内容
  1. // XTPCalendarControlView.cpp : implementation of the CXTPCalendarControlView class.
  2. //
  3. // This file is a part of the XTREME CALENDAR MFC class library.
  4. // (c)1998-2008 Codejock Software, All Rights Reserved.
  5. //
  6. // THIS SOURCE FILE IS THE PROPERTY OF CODEJOCK SOFTWARE AND IS NOT TO BE
  7. // RE-DISTRIBUTED BY ANY MEANS WHATSOEVER WITHOUT THE EXPRESSED WRITTEN
  8. // CONSENT OF CODEJOCK SOFTWARE.
  9. //
  10. // THIS SOURCE CODE CAN ONLY BE USED UNDER THE TERMS AND CONDITIONS OUTLINED
  11. // IN THE XTREME TOOLKIT PRO LICENSE AGREEMENT. CODEJOCK SOFTWARE GRANTS TO
  12. // YOU (ONE SOFTWARE DEVELOPER) THE LIMITED RIGHT TO USE THIS SOFTWARE ON A
  13. // SINGLE COMPUTER.
  14. //
  15. // CONTACT INFORMATION:
  16. // support@codejock.com
  17. // http://www.codejock.com
  18. //
  19. /////////////////////////////////////////////////////////////////////////////
  21. #include "stdafx.h"
  23. #include "Common/XTPVC50Helpers.h"
  24. #include "Common/XTPVC80Helpers.h"
  25. #include "Common/XTPResourceManager.h"
  26. #include "Common/XTPImageManager.h"
  27. #include "Common/resource.h"
  29. #include "XTPCalendarControlView.h"
  30. #include "XTPCalendarMonthView.h"
  31. #include "XTPCalendarThemeOffice2007.h"
  33. #ifdef _DEBUG
  34. #define new DEBUG_NEW
  35. #undef THIS_FILE
  36. static char THIS_FILE[] = __FILE__;
  37. #endif
  39. ////////////////////////////////////////////////////////////////////////////
  40. AFX_INLINE void MoveRectToXY(CRect& rc, int nX, int nY)
  41. {
  42. rc.right = nX + rc.Width();
  43. rc.bottom = nY + rc.Height();
  45. rc.left = nX;
  46. rc.top = nY;
  47. }
  49. //////////////////////////////////////////////////////
  51. BEGIN_MESSAGE_MAP(CXTPCalendarPageSetupDialog, CPageSetupDialog)
  52. ON_BN_CLICKED(XTP_IDC_PRINT_DATE_HEADER, OnBnClickedPrintDateHeader)
  53. ON_BN_CLICKED(XTP_IDC_PRINT_DATE_HEADER_FONT_BUTTON, OnBnClickedDateHeaderFont)
  54. ON_BN_CLICKED(XTP_IDC_CALENDAR_HEADER_FORMAT_BTN, OnBnClickedHeaderFormat)
  55. ON_BN_CLICKED(XTP_IDC_CALENDAR_FOOTER_FORMAT_BTN, OnBnClickedFooterFormat)
  56. END_MESSAGE_MAP()
  58. CXTPCalendarPageSetupDialog::CXTPCalendarPageSetupDialog(
  59. CXTPCalendarControlViewPrintOptions* pOptions,
  60. DWORD dwFlags, CWnd* pParentWnd)
  61. : CPageSetupDialog(dwFlags, pParentWnd)
  62. {
  63. ASSERT(pOptions);
  64. m_pOptions = pOptions;
  66. if (m_pOptions)
  67. {
  68. BOOL bIsInches = m_pOptions->IsMarginsMeasureInches();
  69. DWORD dwMeasure = bIsInches ? PSD_INTHOUSANDTHSOFINCHES : PSD_INHUNDREDTHSOFMILLIMETERS;
  71. m_psd.Flags &= ~PSD_INWININIINTLMEASURE;
  72. m_psd.Flags |= dwMeasure;
  73. }
  75. m_psd.Flags |= PSD_ENABLEPAGESETUPTEMPLATEHANDLE;
  76. m_psd.hPageSetupTemplate = XTPResourceManager()->LoadDialogTemplate2(MAKEINTRESOURCE(IDD));
  77. ASSERT(m_psd.hPageSetupTemplate);
  79. if (m_pOptions)
  80. {
  81. m_psd.rtMargin = m_pOptions->m_rcMargins;
  82. }
  84. m_nIDHelp = XTP_IDD_CALENDAR_PRINT_PAGE_SETUP;
  86. VERIFY( ::SystemParametersInfo( SPI_GETICONTITLELOGFONT, sizeof(LOGFONT), &m_lfDateHeader, 0 ) );
  87. }
  89. CXTPCalendarPageSetupDialog::~CXTPCalendarPageSetupDialog()
  90. {
  91. }
  93. #ifndef rad1
  94. #define rad1        0x0420
  95. #define rad2        0x0421
  97. #define grp4        0x0433
  98. #endif
  100. BOOL CXTPCalendarPageSetupDialog::OnInitDialog ()
  101. {
  102. CPageSetupDialog::OnInitDialog();
  104. ASSERT(m_pOptions);
  106. VERIFY( m_ctrlPrintFromCmb.SubclassDlgItem(XTP_IDC_PRINT_FROM_COMBO, this) );
  107. VERIFY( m_ctrlPrintToCmb.SubclassDlgItem(XTP_IDC_PRINT_TO_COMBO, this) );
  109. VERIFY( m_ctrlPrintFromTo.SubclassDlgItem(XTP_IDC_PRINT_FROMTO, this) );
  111. VERIFY( m_ctrlPrintDateHeader.SubclassDlgItem(XTP_IDC_PRINT_DATE_HEADER, this) );
  112. VERIFY( m_ctrlDateHeaderFontLabel.SubclassDlgItem(XTP_IDC_PRINT_DATE_HEADER_FONT_LABEL, this) );
  113. VERIFY( m_ctrlDateHeaderFont.SubclassDlgItem(XTP_IDC_PRINT_DATE_HEADER_FONT, this) );
  114. VERIFY( m_ctrlDateHeaderFontButton.SubclassDlgItem(XTP_IDC_PRINT_DATE_HEADER_FONT_BUTTON, this) );
  116. VERIFY( m_ctrlBlackWhitePrinting.SubclassDlgItem(XTP_IDC_PRINT_BLACK_WHITE, this) );
  118. VERIFY( m_ctrlHeaderFormat.SubclassDlgItem(XTP_IDC_CALENDAR_HEADER_FORMAT, this) );
  119. VERIFY( m_ctrlFooterFormat.SubclassDlgItem(XTP_IDC_CALENDAR_FOOTER_FORMAT, this) );
  121. VERIFY( m_ctrlHeaderFormatBtn.SubclassDlgItem(XTP_IDC_CALENDAR_HEADER_FORMAT_BTN, this) );
  122. VERIFY( m_ctrlFooterFormatBtn.SubclassDlgItem(XTP_IDC_CALENDAR_FOOTER_FORMAT_BTN, this) );
  124. CString strTimeFormat_HrMin = CXTPCalendarUtils::GetTimeFormatString_HrMin();
  125. CString strTime;
  126. for (int i = 0; i < 24*60; i += 30)
  127. {
  128. strTime = CXTPCalendarUtils::GetTimeFormat((int)(i / 60), (int)(i % 60), strTimeFormat_HrMin);
  130. m_ctrlPrintFromCmb.AddString(strTime);
  131. m_ctrlPrintToCmb.AddString(strTime);
  132. }
  134. if(m_pOptions)
  135. {
  136. strTime = CXTPCalendarUtils::GetTimeFormat(m_pOptions->m_dtPrintFrom, strTimeFormat_HrMin);
  137. m_ctrlPrintFromCmb.SetWindowText(strTime);
  139. strTime = CXTPCalendarUtils::GetTimeFormat(m_pOptions->m_dtPrintTo, strTimeFormat_HrMin);
  140. m_ctrlPrintToCmb.SetWindowText(strTime);
  142. m_ctrlPrintFromTo.SetCheck(m_pOptions->m_bPrintFromToExactly ? 1 : 0);
  144. m_ctrlPrintDateHeader.SetCheck(m_pOptions->m_bPrintDateHeader ? 1 : 0);
  145. m_ctrlBlackWhitePrinting.SetCheck(m_pOptions->m_bBlackWhitePrinting? 1 : 0);
  147. m_lfDateHeader = m_pOptions->m_lfDateHeaderFont;
  149. CString strFont = FormatFontName(m_lfDateHeader);
  150. m_ctrlDateHeaderFont.SetWindowText(strFont);
  152. if (m_pOptions->GetPageHeader())
  153. m_ctrlHeaderFormat.SetWindowText(m_pOptions->GetPageHeader()->m_strFormatString);
  155. if (m_pOptions->GetPageFooter())
  156. m_ctrlFooterFormat.SetWindowText(m_pOptions->GetPageFooter()->m_strFormatString);
  158. OnBnClickedPrintDateHeader();
  159. }
  161. XTP_SAFE_CALL1(GetDlgItem(rad1), EnableWindow(TRUE)); //1056 Portrait
  162. XTP_SAFE_CALL1(GetDlgItem(rad2), EnableWindow(TRUE)); //1057 Landscape
  164. BOOL bIsInches = m_pOptions ? m_pOptions->IsMarginsMeasureInches() : FALSE;
  166. UINT uStrID = bIsInches ? XTP_IDS_CALENDAR_MARGINS_INCH : XTP_IDS_CALENDAR_MARGINS_MM;
  167. CString strCaption = CXTPCalendarUtils::LoadString(uStrID);
  169. if (!strCaption.IsEmpty() && GetDlgItem(grp4))
  170. {
  171. GetDlgItem(grp4)->SetWindowText(strCaption);
  172. }
  174. HICON hBtnIcon = XTPResourceManager()->LoadIcon(XTP_IDI_BTN_ARROW_R, CSize(0,0));
  175. ASSERT(hBtnIcon);
  176. if (hBtnIcon)
  177. {
  178. m_ctrlHeaderFormatBtn.SetIcon(hBtnIcon);
  179. m_ctrlFooterFormatBtn.SetIcon(hBtnIcon);
  180. }
  182. return FALSE;
  183. }
  185. void CXTPCalendarPageSetupDialog::OnBnClickedPrintDateHeader()
  186. {
  187. int nCheck = m_ctrlPrintDateHeader.GetCheck();
  189. m_ctrlDateHeaderFont.EnableWindow(nCheck != 0);
  190. m_ctrlDateHeaderFontLabel.EnableWindow(nCheck != 0);
  191. m_ctrlDateHeaderFontButton.EnableWindow(nCheck != 0);
  192. }
  194. void CXTPCalendarPageSetupDialog::OnOK()
  195. {
  196. ASSERT(m_pOptions);
  197. if (!m_pOptions)
  198. {
  199. CPageSetupDialog::OnOK();
  200. return;
  201. }
  203. CString strFrom, strTo;
  204. m_ctrlPrintFromCmb.GetWindowText(strFrom);
  205. int nFrom_min = CXTPCalendarUtils::ParceTimeString_min(strFrom);
  207. m_ctrlPrintToCmb.GetWindowText(strTo);
  208. int nTo_min = CXTPCalendarUtils::ParceTimeString_min(strTo);
  210. m_pOptions->m_dtPrintFrom.SetTime(nFrom_min / 60, nFrom_min % 60, 0);
  211. m_pOptions->m_dtPrintTo.SetTime(nTo_min / 60, nTo_min % 60, 0);
  213. m_pOptions->m_bPrintFromToExactly = m_ctrlPrintFromTo.GetCheck() != 0;
  214. m_pOptions->m_bBlackWhitePrinting = m_ctrlBlackWhitePrinting.GetCheck() != 0;
  216. m_pOptions->m_bPrintDateHeader = m_ctrlPrintDateHeader.GetCheck() != 0;
  217. if (m_pOptions->m_bPrintDateHeader)
  218. {
  219. m_pOptions->m_lfDateHeaderFont = m_lfDateHeader;
  220. }
  222. m_pOptions->m_rcMargins = m_psd.rtMargin;
  224. if (m_pOptions->GetPageHeader())
  225. m_ctrlHeaderFormat.GetWindowText(m_pOptions->GetPageHeader()->m_strFormatString);
  227. if (m_pOptions->GetPageFooter())
  228. m_ctrlFooterFormat.GetWindowText(m_pOptions->GetPageFooter()->m_strFormatString);
  230. CPageSetupDialog::OnOK();
  231. }
  233. CString CXTPCalendarPageSetupDialog::FormatFontName(const LOGFONT& lfFont)
  234. {
  235. CClientDC dc(this);
  236. double dLogPixelY = dc.GetDeviceCaps(LOGPIXELSY);
  237. double dPointSize = abs(lfFont.lfHeight) * 72.0 / dLogPixelY;
  238. int nPointSize = (int)(dPointSize + 0.5);
  240. CString strFont;
  241. strFont.Format(_T(" %d pt. %s"), nPointSize, lfFont.lfFaceName);
  243. CString strAttr;
  244. if (lfFont.lfWeight >= FW_BOLD)
  245. {
  246. strAttr += _T(" Bold");
  247. }
  248. if (lfFont.lfItalic)
  249. {
  250. if (!strAttr.IsEmpty())
  251. {
  252. strAttr += _T(",");
  253. }
  254. strAttr += _T(" Italic");;
  255. }
  257. if (!strAttr.IsEmpty())
  258. {
  259. strFont += _T("n");
  260. strFont += strAttr;
  261. }
  263. return strFont;
  264. }
  266. void CXTPCalendarPageSetupDialog::OnBnClickedDateHeaderFont()
  267. {
  268. CFontDialog dlgFont(&m_lfDateHeader);
  269. int nDlgRes = (int)dlgFont.DoModal();
  271. if (nDlgRes == IDOK)
  272. {
  273. dlgFont.GetCurrentFont(&m_lfDateHeader);
  275. CString strFont = FormatFontName(m_lfDateHeader);
  276. m_ctrlDateHeaderFont.SetWindowText(strFont);
  277. }
  278. }
  280. void CXTPCalendarPageSetupDialog::OnBnClickedHeaderFormat()
  281. {
  282. CXTPPrintPageHeaderFooter::DoInsertHFFormatSpecifierViaMenu(
  283. this, &m_ctrlHeaderFormat, &m_ctrlHeaderFormatBtn);
  284. }
  286. void CXTPCalendarPageSetupDialog::OnBnClickedFooterFormat()
  287. {
  288. CXTPPrintPageHeaderFooter::DoInsertHFFormatSpecifierViaMenu(
  289. this, &m_ctrlFooterFormat, &m_ctrlFooterFormatBtn);
  290. }
  292. /////////////////////////////////////////////////////////////////////////////
  294. IMPLEMENT_DYNAMIC(CXTPCalendarControlViewPrintOptions, CXTPPrintOptions)
  296. CXTPCalendarControlViewPrintOptions::CXTPCalendarControlViewPrintOptions()
  297. {
  298. m_dtPrintFrom.SetTime(8, 0, 0);
  299. m_dtPrintTo.SetTime(19, 0, 0);
  300. m_bPrintFromToExactly = TRUE;
  302. LOGFONT lfIcon;
  303. VERIFY( ::SystemParametersInfo( SPI_GETICONTITLELOGFONT, sizeof( lfIcon ), &lfIcon, 0 ) );
  305. m_bPrintDateHeader = TRUE;
  307. m_lfDateHeaderFont = lfIcon;
  308. m_lfDateHeaderFont.lfHeight = -24;
  309. m_lfDateHeaderFont.lfWeight = FW_BOLD;
  311. m_lfDateHeaderWeekDayFont = lfIcon;
  312. m_lfDateHeaderWeekDayFont.lfHeight = -max(abs(lfIcon.lfHeight), abs(m_lfDateHeaderFont.lfHeight*2/3));
  314. m_lfDateHeaderCalendarFont = lfIcon;
  316. }
  318. LCID CXTPCalendarControlViewPrintOptions::GetActiveLCID()
  319. {
  320. return CXTPCalendarUtils::GetActiveLCID();
  321. }
  323. void CXTPCalendarControlViewPrintOptions::Set(const CXTPCalendarControlViewPrintOptions* pSrc)
  324. {
  325. if (!pSrc)
  326. {
  327. return;
  328. }
  329. CXTPPrintOptions::Set(pSrc);
  331. m_dtPrintFrom = pSrc->m_dtPrintFrom;
  332. m_dtPrintTo = pSrc->m_dtPrintTo;
  333. m_bPrintFromToExactly = pSrc->m_bPrintFromToExactly;
  335. m_bPrintDateHeader = pSrc->m_bPrintDateHeader;
  336. m_lfDateHeaderFont = pSrc->m_lfDateHeaderFont;
  337. m_lfDateHeaderCalendarFont = pSrc->m_lfDateHeaderCalendarFont;
  338. }
  340. /////////////////////////////////////////////////////////////////////////////
  341. // CXTPCalendarControlView
  343. IMPLEMENT_DYNCREATE(CXTPCalendarControlView, CView)
  345. CXTPCalendarControlView::CXTPCalendarControlView()
  346. {
  347. m_pCalendar = NULL;
  348. m_pUpdateContect = NULL;
  350. m_bReleaseCalendarWhenDestroy = FALSE;
  351. m_bPrintDirect = FALSE;
  352. m_bResizeControlWithView = TRUE;
  354. m_bShowCaptionBar = FALSE;
  356. m_pScrollBar = NULL;
  358. m_pPrintOptions = new CXTPCalendarControlViewPrintOptions();
  359. }
  361. CXTPCalendarControlView::~CXTPCalendarControlView()
  362. {
  363. if (m_bReleaseCalendarWhenDestroy)
  364. {
  365. CMDTARGET_RELEASE(m_pCalendar);
  366. }
  368. ASSERT(m_pUpdateContect == NULL);
  369. SAFE_DELETE(m_pUpdateContect);
  371. CMDTARGET_RELEASE(m_pPrintOptions);
  372. }
  374. CXTPCalendarControl& CXTPCalendarControlView::GetCalendarCtrl()
  375. {
  376. return m_pCalendar == NULL ? m_wndCalendar : *m_pCalendar;
  377. }
  379. void CXTPCalendarControlView::SetCalendarCtrl(CXTPCalendarControl* pCalendar,
  380.   BOOL bReleaseWhenDestroy)
  381. {
  382. if (::IsWindow(m_wndCalendar.GetSafeHwnd()))
  383. m_wndCalendar.DestroyWindow();
  385. m_pCalendar = pCalendar;
  386. m_bReleaseCalendarWhenDestroy = bReleaseWhenDestroy;
  388. m_Sink.UnadviseAll();
  389. m_Sink.Advise(GetCalendarCtrl().GetConnection(), XTP_NC_CALENDAR_THEME_CHANGED, &CXTPCalendarControlView::OnEvent_CalendarThemeChanged);
  391. _ResizeControls();
  392. }
  394. void CXTPCalendarControlView::SetScrollBarCtrl(CScrollBar* pScrollBar)
  395. {
  396. m_pScrollBar = pScrollBar;
  397. }
  399. BEGIN_MESSAGE_MAP(CXTPCalendarControlView, CView)
  400. //{{AFX_MSG_MAP(CXTPCalendarControlView)
  401. ON_WM_ERASEBKGND()
  402. ON_WM_SIZE()
  403. ON_WM_CREATE()
  404. ON_WM_SETFOCUS()
  405. ON_WM_PAINT()
  406. ON_WM_VSCROLL()
  407. ON_COMMAND(ID_FILE_PRINT, OnFilePrint)
  408. ON_BN_CLICKED(ID_EDIT_UNDO, OnUndo)
  409. ON_BN_CLICKED(ID_EDIT_CUT, OnCut)
  410. ON_BN_CLICKED(ID_EDIT_COPY, OnCopy)
  411. ON_BN_CLICKED(ID_EDIT_PASTE, OnPaste)
  412. ON_UPDATE_COMMAND_UI(ID_EDIT_UNDO, OnUpdateCommand)
  413. ON_UPDATE_COMMAND_UI(ID_EDIT_CUT, OnUpdateCommand)
  414. ON_UPDATE_COMMAND_UI(ID_EDIT_COPY, OnUpdateCommand)
  415. ON_UPDATE_COMMAND_UI(ID_EDIT_PASTE, OnUpdateCommand)
  416. //}}AFX_MSG_MAP
  417. END_MESSAGE_MAP()
  419. /////////////////////////////////////////////////////////////////////////////
  420. // CXTPCalendarControlView drawing
  422. void CXTPCalendarControlView::OnDraw(CDC* /*pDC*/)
  423. {
  424. }
  426. void CXTPCalendarControlView::OnPaint()
  427. {
  428. Default();
  429. }
  432. /////////////////////////////////////////////////////////////////////////////
  433. // CXTPCalendarControlView diagnostics
  435. #ifdef _DEBUG
  436. void CXTPCalendarControlView::AssertValid() const
  437. {
  438. CView::AssertValid();
  439. }
  441. void CXTPCalendarControlView::Dump(CDumpContext& dc) const
  442. {
  443. CView::Dump(dc);
  444. }
  445. #endif //_DEBUG
  447. /////////////////////////////////////////////////////////////////////////////
  448. // CXTPCalendarControlView message handlers
  450. BOOL CXTPCalendarControlView::OnEraseBkgnd(CDC* )
  451. {
  452. return TRUE;
  453. }
  455. CScrollBar* CXTPCalendarControlView::GetScrollBarCtrl(int nBar) const
  456. {
  457. if (nBar == SB_VERT && m_pScrollBar)
  458. return m_pScrollBar;
  460. return CView::GetScrollBarCtrl(nBar);
  461. }
  463. void CXTPCalendarControlView::OnVScroll(UINT nSBCode, UINT nPos, CScrollBar* pScrollBar)
  464. {
  465. if (m_pScrollBar && pScrollBar == m_pScrollBar)
  466. GetCalendarCtrl().OnVScroll(nSBCode, nPos, 0);
  468. CView::OnVScroll(nSBCode, nPos, pScrollBar);
  469. }
  471. void CXTPCalendarControlView::OnSize(UINT nType, int cx, int cy)
  472. {
  473. CView::OnSize(nType, cx, cy);
  475. if (!m_bResizeControlWithView)
  476. return;
  478. _ResizeControls();
  479. }
  481. void CXTPCalendarControlView::_ResizeControls()
  482. {
  483. if (!m_bResizeControlWithView)
  484. return;
  486. CXTPClientRect rcClient(this);
  487. int cx = rcClient.Width();
  488. int cy = rcClient.Height();
  490. int nCalendarY = 0;
  491. //BOOL bThemeOffice2007 = !!DYNAMIC_DOWNCAST(CXTPCalendarThemeOffice2007, GetCalendarCtrl().GetTheme());
  493. if (m_wndCalendarCaptionBar.GetSafeHwnd())
  494. {
  495. if (m_bShowCaptionBar/* && bThemeOffice2007*/)
  496. {
  497. CRect rcCaptionBar = m_wndCalendarCaptionBar.CalcMinRect(NULL);
  499. nCalendarY = rcCaptionBar.Height();
  501. if ((m_wndCalendarCaptionBar.GetStyle() & WS_VISIBLE) == 0)
  502. {
  503. m_wndCalendarCaptionBar.ShowWindow(SW_SHOW);
  504. m_wndCalendarCaptionBar.GetTheme()->AttachCalendar(&GetCalendarCtrl());
  505. }
  506. }
  507. else
  508. {
  509. if ((m_wndCalendarCaptionBar.GetStyle() & WS_VISIBLE))
  510. {
  511. m_wndCalendarCaptionBar.ShowWindow(SW_HIDE);
  512. m_wndCalendarCaptionBar.GetTheme()->AttachCalendar(NULL);
  513. }
  515. }
  517. m_wndCalendarCaptionBar.MoveWindow(0, 0, cx, nCalendarY);
  518. }
  520. if (m_pScrollBar && m_pScrollBar->GetSafeHwnd())
  521. {
  522. int nScroll = GetSystemMetrics(SM_CXVSCROLL);
  523. m_pScrollBar->MoveWindow(cx - nScroll, nCalendarY, nScroll, cy - nCalendarY);
  524. cx -= nScroll;
  525. }
  527. if (GetCalendarCtrl().GetSafeHwnd())
  528. {
  529. GetCalendarCtrl().MoveWindow(0, nCalendarY, cx, max(0, cy - nCalendarY));
  530. }
  531. }
  533. BOOL CXTPCalendarControlView::IsShowCaptionBar()
  534. {
  535. return m_bShowCaptionBar;
  536. }
  538. void CXTPCalendarControlView::ShowCaptionBar(BOOL bShow)
  539. {
  540. if (m_bShowCaptionBar != bShow)
  541. {
  542. m_bShowCaptionBar = bShow;
  544. _ResizeControls();
  546. if (m_hWnd)
  547. Invalidate(NULL);
  548. }
  549. }
  551. void CXTPCalendarControlView::OnEvent_CalendarThemeChanged(XTP_NOTIFY_CODE Event, WPARAM wParam , LPARAM lParam)
  552. {
  553. UNREFERENCED_PARAMETER(Event);  UNREFERENCED_PARAMETER(wParam); UNREFERENCED_PARAMETER(lParam);
  555. ASSERT(Event == XTP_NC_CALENDAR_THEME_CHANGED);
  557. _ResizeControls();
  559. if (m_hWnd)
  560. Invalidate(NULL);
  561. }
  563. int CXTPCalendarControlView::OnCreate(LPCREATESTRUCT lpCreateStruct)
  564. {
  565. if (CView::OnCreate(lpCreateStruct) == -1)
  566. return -1;
  568. if (!m_wndCalendarCaptionBar.Create(WS_CHILD | WS_TABSTOP/* | WS_VISIBLE*/,
  569.   CRect(0, 0, 0, 0), this, XTP_ID_CALENDARCAPTIONBAR_CONTROL) )
  570. {
  571. TRACE(_T("Failed to create Calendar Caption Bar control windown"));
  572. return -1;
  573. }
  575. if (!GetCalendarCtrl().Create(WS_CHILD | WS_TABSTOP | WS_VISIBLE,
  576.   CRect(0, 0, 0, 0), this, XTP_ID_CALENDAR_CONTROL) )
  577. {
  578. TRACE(_T("Failed to create Calendar control windown"));
  579. return -1;
  580. }
  582. _ResizeControls();
  584. return 0;
  585. }
  587. void CXTPCalendarControlView::OnSetFocus(CWnd* pOldWnd)
  588. {
  589. CView::OnSetFocus(pOldWnd);
  591. GetCalendarCtrl().SetFocus();
  592. }
  595. /////////////////////////////////////////////////////////////////////////////
  596. // CReportSampleView printing
  598. BOOL CXTPCalendarControlView::OnPreparePrinting(CPrintInfo* pInfo)
  599. {
  600. pInfo->m_bDirect = m_bPrintDirect;
  602. pInfo->m_nNumPreviewPages = 1;
  603. pInfo->SetMinPage(1);
  604. pInfo->SetMaxPage(1);
  606. // default preparation
  607. return DoPreparePrinting(pInfo);
  608. }
  610. void CXTPCalendarControlView::OnBeginPrinting(CDC* pDC, CPrintInfo* pInfo)
  611. {
  612. UNREFERENCED_PARAMETER(pDC);    UNREFERENCED_PARAMETER(pInfo);
  614. m_pritAdjustContext.Reset();
  616. GetCalendarCtrl().EnableSendNotifications(FALSE);
  618. ASSERT(m_pUpdateContect == NULL);
  619. SAFE_DELETE(m_pUpdateContect);
  620. m_pUpdateContect = new CXTPCalendarControl::CUpdateContext(&GetCalendarCtrl(), xtpCalendarUpdateRedraw);
  622. m_beforePrintState.Save(this);
  623. }
  625. void CXTPCalendarControlView::OnEndPrinting(CDC* /*pDC*/, CPrintInfo* /*pInfo*/)
  626. {
  627. m_beforePrintState.Restore(this);
  628. m_beforePrintState.ClearData();
  630. GetCalendarCtrl().AdjustLayout();
  631. GetCalendarCtrl().EnableSendNotifications();
  633. m_pritAdjustContext.Reset();
  635. m_bmpGrayDC.DeleteObject();
  637. ASSERT(m_pUpdateContect);
  638. SAFE_DELETE(m_pUpdateContect);
  639. }
  641. CRect CXTPCalendarControlView::AdjustCalendarForPrint(CDC* pDC, CRect rcCalendar,
  642. CXTPCalendarControlViewPrintOptions* pOptions)
  644. {
  645. //===========================================================================
  646. GetCalendarCtrl().AdjustLayout(pDC, rcCalendar);
  648. //===========================================================================
  649. int nViewType = GetCalendarCtrl().GetActiveView()->GetViewType();
  650. if (nViewType == xtpCalendarDayView || nViewType == xtpCalendarWorkWeekView)
  651. {
  652. CXTPCalendarDayView* pDayView = DYNAMIC_DOWNCAST(CXTPCalendarDayView, GetCalendarCtrl().GetDayView());
  653. ASSERT(pDayView);
  654. if (!pDayView)
  655. {
  656. return rcCalendar;
  657. }
  659. int dbg_nAdjustSmall = 0;
  660. int dbg_nAdjustScale = 0;
  662. int nHeightNeed_prev = 0;
  663. for (int nLoop = 0; nLoop < 100; nLoop++)
  664. {
  665. int nStartCell = pDayView->GetCellNumber(pOptions->m_dtPrintFrom, FALSE);
  666. int nEndCell = pDayView->GetCellNumber(pOptions->m_dtPrintTo, TRUE);
  667. int nCellCount = nEndCell - nStartCell + 1;
  669. int nCelHeight = pDayView->GetRowHeight();
  670. CRect rcHeader = pDayView->GetDayHeaderRectangle();
  671. CRect rcAllDayArea = pDayView->GetAllDayEventsRectangle();
  673. int nHeightNeed = nCellCount * nCelHeight + rcHeader.Height() +
  674. rcAllDayArea.Height();
  676. if (rcCalendar.Height() >= nHeightNeed)
  677. {
  678. if (!pOptions->m_bPrintFromToExactly)
  679. {
  680. pDayView->_ScrollV(nStartCell, nStartCell);
  681. break;
  682. }
  683. else
  684. {
  685. dbg_nAdjustSmall++;
  687. rcCalendar.bottom = rcCalendar.top + nHeightNeed;
  689. GetCalendarCtrl().AdjustLayout(pDC, rcCalendar);
  691. pDayView->_ScrollV(nStartCell, nStartCell);
  693. if (nHeightNeed_prev == nHeightNeed)
  694. {
  695. //GetCalendarCtrl().AdjustLayout(pDC, rcCalendar);
  696. break;
  697. }
  698. nHeightNeed_prev = nHeightNeed;
  699. }
  700. }
  701. else
  702. {
  703. COleDateTimeSpan spScale = pDayView->GetScaleInterval();
  704. int nScale_min = GETTOTAL_MINUTES_DTS(spScale);
  706. if (nScale_min < 60)
  707. {
  708. dbg_nAdjustScale++;
  710. //int arIntervals[] = {5, 10, 15, 30, 60, 120, 150, 180};
  711. int arIntervals[] = {5, 10, 15, 30, 60};
  712. for (int i = 0; i < _countof(arIntervals); i++)
  713. {
  714. if (arIntervals[i] > nScale_min)
  715. {
  716. spScale = CXTPCalendarUtils::Minutes2Span(arIntervals[i]);
  717. break;
  718. }
  719. }
  721. pDayView->SetScaleInterval(spScale);
  722. GetCalendarCtrl().AdjustLayout(pDC, rcCalendar);
  723. }
  724. else
  725. {
  726. break;
  727. }
  728. }
  729. }
  730. GetCalendarCtrl().AdjustLayout(pDC, rcCalendar);
  732. //TRACE(_T("DBG. Calendar, PrePrintAdjust Counts: Scale = %d, small = %d, All Loops (max 100)= %d n"),
  733. //  dbg_nAdjustScale, dbg_nAdjustSmall, nLoop+1);
  734. }
  735. return rcCalendar;
  736. }
  739. void CXTPCalendarControlView::OnPrint(CDC* pDC, CPrintInfo* pInfo)
  740. {
  741. if (!m_pPrintOptions || !pDC || !pInfo)
  742. {
  743. ASSERT(FALSE);
  744. return;
  745. }
  747. CRect rcMargins = m_pPrintOptions->GetMarginsLP(pDC);
  748. CRect rcPrint = pInfo->m_rectDraw;
  749. rcPrint.DeflateRect(rcMargins);
  751. //----------------------------------------------------------
  752. if (!m_pPrintOptions->m_bBlackWhitePrinting)
  753. {
  754. _OnPrint2(pDC, pInfo, rcPrint);
  755. }
  756. else
  757. {
  758. CRect rcPrint00(0, 0, rcPrint.Width(), rcPrint.Height());
  760. CDC memDC;
  761. VERIFY(memDC.CreateCompatibleDC(pDC));
  762. memDC.m_bPrinting = TRUE;
  764. if (!m_bmpGrayDC.m_hObject || m_bmpGrayDC.GetBitmapDimension() != rcPrint00.Size())
  765. {
  766. m_bmpGrayDC.DeleteObject();
  767. m_bmpGrayDC.CreateCompatibleBitmap(pDC, rcPrint00.Width(), rcPrint00.Height());
  768. }
  770. CXTPBitmapDC autpBmp(&memDC, &m_bmpGrayDC);
  772. //----------------------------------------------------
  773. memDC.FillSolidRect(rcPrint00, RGB(255, 255, 255));
  775. _OnPrint2(&memDC, pInfo, rcPrint00);
  777. int nCC = max(0, min(m_pPrintOptions->m_nBlackWhiteContrast, 255));
  778. XTPImageManager()->BlackWhiteBitmap(memDC, rcPrint00, nCC);
  780. pDC->BitBlt(rcPrint.left, rcPrint.top, rcPrint.Width(), rcPrint.Height(),
  781. &memDC, 0, 0, SRCCOPY);
  782. }
  783. }
  785. void CXTPCalendarControlView::_OnPrint2(CDC* pDC, CPrintInfo* pInfo, CRect rcPrint)
  786. {
  787. UNREFERENCED_PARAMETER(pInfo);
  789. m_pritAdjustContext.m_rcHeader = rcPrint;
  790. m_pritAdjustContext.m_rcFooter = rcPrint;
  792. CString strTitle = CXTPPrintPageHeaderFooter::GetParentFrameTitle(this);
  794. m_pPrintOptions->GetPageHeader()->FormatTexts(pInfo, strTitle);
  795. m_pPrintOptions->GetPageFooter()->FormatTexts(pInfo, strTitle);
  797. m_pPrintOptions->GetPageFooter()->Draw(pDC, m_pritAdjustContext.m_rcFooter, TRUE);
  798. m_pPrintOptions->GetPageHeader()->Draw(pDC, m_pritAdjustContext.m_rcHeader);
  800. rcPrint.top += m_pritAdjustContext.m_rcHeader.Height();
  801. rcPrint.bottom -= m_pritAdjustContext.m_rcFooter.Height();
  803. //-----------------------------------------------------------------------
  804. CRect rcCalendar = rcPrint;
  806. if (m_pPrintOptions->m_bPrintDateHeader)
  807. {
  808. m_pritAdjustContext.m_rcDateHeader = rcPrint;
  809. DrawDateHeader(FALSE, pDC, m_pPrintOptions, m_pritAdjustContext.m_rcDateHeader);
  811. rcCalendar.top = m_pritAdjustContext.m_rcDateHeader.bottom + 2;
  812. }
  814. rcCalendar.DeflateRect(2, 2, 2, 2);
  816. if (m_pritAdjustContext.m_bAdjust ||
  817. m_pritAdjustContext.m_rectDraw_prev != rcCalendar)
  818. {
  819. m_pritAdjustContext.m_rcCalendar = AdjustCalendarForPrint(pDC, rcCalendar, m_pPrintOptions);
  821. m_pritAdjustContext.m_rectDraw_prev = rcCalendar;
  823. m_pritAdjustContext.m_bAdjust = FALSE;
  824. }
  825. //===========================================================================
  827. pDC->IntersectClipRect(&m_pritAdjustContext.m_rcCalendar);
  829. //************************************************************************
  830. GetCalendarCtrl().OnDraw(pDC);
  832. //************************************************************************
  833. pDC->SelectClipRgn(NULL);
  835. CRect rcBorder = m_pritAdjustContext.m_rcCalendar;
  837. rcBorder.InflateRect(1, 1, 1, 1);
  838. pDC->Draw3dRect(&rcBorder, 0, 0);
  840. rcBorder.InflateRect(1, 1, 1, 1);
  841. pDC->Draw3dRect(&rcBorder, 0, 0);
  843. m_pPrintOptions->GetPageFooter()->Draw(pDC, m_pritAdjustContext.m_rcFooter);
  844. }
  846. void CXTPCalendarControlView::OnPrepareDC(CDC* pDC, CPrintInfo* pInfo)
  847. {
  848. UNREFERENCED_PARAMETER(pInfo);
  850. ASSERT_VALID(this);
  851. ASSERT_VALID(pDC);
  852. ASSERT(pInfo != NULL);  // overriding OnPaint -- never get this.
  854. pDC->SetMapMode(MM_ANISOTROPIC);
  856. pDC->SetViewportExt(pDC->GetDeviceCaps(LOGPIXELSX),
  857. pDC->GetDeviceCaps(LOGPIXELSY));
  859. pDC->SetWindowExt(100, 100);
  861. // ptOrg is in logical coordinates
  862. pDC->OffsetWindowOrg(0, 0);
  863. }
  865. void CXTPCalendarControlView::DrawDateHeader(BOOL bCalculate, CDC* pDC,
  866. CXTPCalendarControlViewPrintOptions* pOptions,
  867. CRect& rrcHeader)
  868. {
  869. COleDateTime dtYearMonth1, dtYearMonth2;
  870. CString strHeader1, strHeader2, strHeaderWeekDay;
  872. int nMonths = _GetDateHeaderMonths(dtYearMonth1, dtYearMonth2, strHeader1,
  873.    strHeader2, strHeaderWeekDay);
  875. if (!strHeader2.IsEmpty())
  876. {
  877. strHeader1 += _T(" -");
  878. }
  880. CRect rcCalendar1 = rrcHeader;
  881. CRect rcCalendar2(0, 0, 0, 0);
  883. _DrawDateHeaderCalendar(TRUE, pDC, pOptions, dtYearMonth1, rcCalendar1);
  885. int nCalendar1XPos = rrcHeader.right - rcCalendar1.Width() * 11/10;
  886. int nCalendar2XPos = nCalendar1XPos;
  888. CFont fntDateHeader;
  889. VERIFY( fntDateHeader.CreateFontIndirect(&pOptions->m_lfDateHeaderFont) );
  890. CXTPFontDC fntDC(pDC, &fntDateHeader);
  891. CSize sizeText = pDC->GetTextExtent(strHeader1);
  893. CFont fntDateHeaderWeekDay;
  894. VERIFY( fntDateHeaderWeekDay.CreateFontIndirect(&pOptions->m_lfDateHeaderWeekDayFont) );
  895. fntDC.SetFont(&fntDateHeaderWeekDay);
  896. CSize sizeTextWD = pDC->GetTextExtent(_T("WD"), 2);
  898. int nDatesCaptionHeight = sizeText.cy * 225/100 + sizeTextWD.cy * 125/100;
  899. int nMaxHeight = max(rcCalendar1.Height() * 11/10, nDatesCaptionHeight);
  901. rrcHeader.bottom = rrcHeader.top + nMaxHeight;
  903. int nCalendarYPos = rrcHeader.top + nMaxHeight/2 - rcCalendar1.Height() / 2;
  904. MoveRectToXY(rcCalendar1, nCalendar1XPos, nCalendarYPos);
  906. if (bCalculate)
  907. {
  908. return;
  909. }
  911. //===========================================================================
  912. COLORREF clrPrev = pDC->SetTextColor(0);
  913. int nBkModePrev = pDC->SetBkMode(TRANSPARENT);
  915. //---------------------------------------------------------------------------
  916. if (nMonths > 1)
  917. {
  918. rcCalendar2 = rcCalendar1;
  919. nCalendar2XPos = nCalendar1XPos - rcCalendar1.Width() * 11 / 10;
  920. MoveRectToXY(rcCalendar1, nCalendar2XPos, nCalendarYPos);
  921. }
  923. if (!m_pPrintOptions->m_bBlackWhitePrinting)
  924. pDC->FillSolidRect(&rrcHeader, RGB(229, 229, 229));
  926. pDC->Draw3dRect(&rrcHeader, 0, 0);
  928. _DrawDateHeaderCalendar(FALSE, pDC, pOptions, dtYearMonth1, rcCalendar1);
  930. if (nMonths > 1)
  931. {
  932. _DrawDateHeaderCalendar(FALSE, pDC, pOptions, dtYearMonth2, rcCalendar2);
  933. }
  935. CRect rcHeader1(0, 0, 0, 0);
  936. CRect rcHeader2(0, 0, 0, 0);
  937. CRect rcHeader3(0, 0, 0, 0);
  939. rcHeader1 = rrcHeader;
  940. rcHeader1.DeflateRect(10, 5, 10, 5);
  941. rcHeader1.right = nCalendar2XPos - 20;
  943. rcHeader2 = rcHeader1;
  945. fntDC.SetFont(&fntDateHeader);
  947. UINT uDrawFlags = DT_TOP | DT_LEFT | DT_WORDBREAK | DT_NOPREFIX;
  948. int nHeight1 = pDC->DrawText(strHeader1, &rcHeader1, uDrawFlags);
  950. if (!strHeader2.IsEmpty())
  951. {
  952. rcHeader2.top += nHeight1 + sizeText.cy / 4;
  953. if (rcHeader2.top < rcHeader2.bottom)
  954. {
  955. pDC->DrawText(strHeader2, &rcHeader2, uDrawFlags);
  956. }
  957. }
  959. if (!strHeaderWeekDay.IsEmpty())
  960. {
  961. fntDC.SetFont(&fntDateHeaderWeekDay);
  963. rcHeader3 = rcHeader2;
  964. rcHeader3.top += nHeight1 + sizeTextWD.cy / 5;
  966. if (rcHeader3.top < rcHeader3.bottom)
  967. {
  968. pDC->DrawText(strHeaderWeekDay, &rcHeader3, uDrawFlags);
  969. }
  970. }
  972. //---------------------------------------------------------------------------
  973. pDC->SetTextColor(clrPrev);
  974. pDC->SetBkMode(nBkModePrev);
  975. }
  978. void CXTPCalendarControlView::_DrawDateHeaderCalendar(BOOL bCalculate,
  979. CDC* pDC,
  980. CXTPCalendarControlViewPrintOptions* pOptions,
  981. COleDateTime dtYearMonth,
  982. CRect& rrcHeaderCalendar)
  983. {
  984. LOGFONT lfCalWeek = pOptions->m_lfDateHeaderCalendarFont;
  985. lfCalWeek.lfHeight = lfCalWeek.lfHeight * 8 / 10;
  986. CFont fntCalendarWeek;
  987. VERIFY( fntCalendarWeek.CreateFontIndirect(&lfCalWeek) );
  989. CFont fntCalendar;
  990. VERIFY( fntCalendar.CreateFontIndirect(&pOptions->m_lfDateHeaderCalendarFont) );
  991. CXTPFontDC fntDC(pDC, &fntCalendar);
  994. CSize sizeCellText = pDC->GetTextExtent(_T("88"), 2);
  996. CSize sizeCell = sizeCellText;
  997. sizeCell.cx = sizeCell.cx * 13 / 10;
  998. sizeCell.cy = sizeCell.cy * 11 / 10;
  999. int nMonthRowY = sizeCellText.cy;
  1000. int nWSaysRowY = sizeCellText.cy * 13 / 10;
  1002. rrcHeaderCalendar.right = rrcHeaderCalendar.left + sizeCell.cx * 9;
  1003. rrcHeaderCalendar.bottom = rrcHeaderCalendar.top + nMonthRowY + nWSaysRowY
  1004. + sizeCell.cy * 6;
  1006. if (bCalculate)
  1007. {
  1008. return;
  1009. }
  1011. int nFirstDayOfWeek = GetCalendarCtrl().GetFirstDayOfWeek();
  1013. COleDateTime dtMonthFirst = dtYearMonth;
  1014. VERIFY( CXTPCalendarUtils::UpdateMonthDay(dtMonthFirst, 1) );
  1015. int nMaxMonthDay = CXTPCalendarUtils::GetMaxMonthDay(dtYearMonth);
  1017. CStringArray arWDNames;
  1018. int i;
  1019. for (i = 0; i < 7; i++)
  1020. {
  1021. CString sWD = CXTPCalendarUtils::GetLocaleString(LOCALE_SABBREVDAYNAME1 + ((i-1+7)%7), 100);
  1022. arWDNames.Add(sWD);
  1023. }
  1024. int nMonth = dtYearMonth.GetMonth();
  1025. int nYear = dtYearMonth.GetYear();
  1026. CString strMonthName = CXTPCalendarUtils::GetLocaleString(LOCALE_SMONTHNAME1 + nMonth - 1, 100);
  1027. CString strMonthYear;
  1028. strMonthYear.Format(_T("%s  %d"), (LPCTSTR)strMonthName, nYear);
  1030. //===========================================================================
  1031. COLORREF clrPrev = pDC->SetTextColor(0);
  1032. int nBkModePrev = pDC->SetBkMode(TRANSPARENT);
  1033. //---------------------------------------------------------------------------
  1034. CRect rcText = rrcHeaderCalendar;
  1035. rcText.left += sizeCell.cx;
  1036. pDC->DrawText(strMonthYear, &rcText, DT_TOP | DT_CENTER | DT_SINGLELINE);
  1038. rcText = rrcHeaderCalendar;
  1039. rcText.top += sizeCell.cy;
  1040. for (i = 0; i < 7; i++)
  1041. {
  1042. rcText.left += sizeCell.cx;
  1043. rcText.right = rcText.left + sizeCell.cx;
  1045. int nMidx = (nFirstDayOfWeek-1+i) % 7;
  1046. CString strWD = arWDNames[nMidx];
  1048. pDC->DrawText((LPCTSTR)strWD, 1, &rcText, DT_TOP | DT_RIGHT | DT_SINGLELINE);
  1049. }
  1051. CRect rcLine1 = rrcHeaderCalendar;
  1052. rcLine1.left += sizeCell.cx - 0;
  1053. rcLine1.top += nMonthRowY + nWSaysRowY - 1;
  1054. rcLine1.bottom = rcLine1.top + 1;
  1056. CRect rcLine2 = rrcHeaderCalendar;
  1057. rcLine2.left = rcLine1.left;
  1058. rcLine2.right = rcLine2.left + 1;
  1059. rcLine2.top = rcLine1.top;
  1061. pDC->FillSolidRect(&rcLine1, 0);
  1062. pDC->FillSolidRect(&rcLine2, 0);
  1064. int nDay = 1 - (dtMonthFirst.GetDayOfWeek() - nFirstDayOfWeek + 7) % 7;
  1066. int nFirstWeekOfYearDays = 1;
  1067. COleDateTimeSpan spFWofY(nFirstWeekOfYearDays - 1);
  1068. COleDateTime dtWeekLast = dtMonthFirst + COleDateTimeSpan(nDay+6-1);
  1069. int nFirstWeekNumber = ((dtWeekLast - spFWofY).GetDayOfYear() - 1) / 7 + 1;
  1071. //--------------------------
  1072. int nTodayDay_toMark = 0;
  1073. COleDateTime dtToday = CXTPCalendarUtils::GetCurrentTime();
  1074. if (dtYearMonth.GetYear() == dtToday.GetYear() &&
  1075. dtYearMonth.GetMonth() == dtToday.GetMonth())
  1076. {
  1077. nTodayDay_toMark = dtToday.GetDay();
  1078. }
  1080. CString strDay, strWeek;
  1081. for (int w = 0; w < 6; w++)
  1082. {
  1083. rcText.top = rrcHeaderCalendar.top + nMonthRowY + nWSaysRowY + sizeCell.cy * w;
  1085. if (nDay <= nMaxMonthDay)
  1086. {
  1087. CRect rcWeek = rcText;
  1088. rcWeek.left = rrcHeaderCalendar.left;
  1089. rcWeek.right = rcWeek.left + sizeCell.cx - 2;
  1091. strWeek.Format(_T("%d"), nFirstWeekNumber + w);
  1093. CXTPFontDC fntDCweek(pDC, &fntCalendarWeek);
  1094. pDC->DrawText(strWeek, &rcWeek, DT_TOP | DT_RIGHT | DT_SINGLELINE);
  1095. }
  1097. //--------------------------------------------------------------------
  1098. for (i = 0; i < 7; i++)
  1099. {
  1100. if (nDay > 0 && nDay <= nMaxMonthDay)
  1101. {
  1102. rcText.left = rrcHeaderCalendar.left + sizeCell.cx * (i + 1);
  1103. rcText.right = rcText.left + sizeCell.cx;
  1105. strDay.Format(_T("%d"), nDay);
  1107. pDC->DrawText(strDay, &rcText, DT_TOP | DT_RIGHT | DT_SINGLELINE);
  1109. if (nDay == nTodayDay_toMark)
  1110. {
  1111. CRect rcToday = rcText;
  1112. rcToday.left += max(1, sizeCell.cx/10);
  1113. rcToday.right += max(1, sizeCell.cx/10);
  1114. rcToday.bottom = rcToday.top + sizeCell.cy;
  1116. CBrush brFrame(RGB(82, 82, 82));
  1117. pDC->FrameRect(&rcToday, &brFrame);
  1118. }
  1119. }
  1120. nDay++;
  1121. }
  1122. }
  1124. //---------------------------------------------------------------------------
  1125. pDC->SetTextColor(clrPrev);
  1126. pDC->SetBkMode(nBkModePrev);
  1127. }
  1129. int CXTPCalendarControlView::_GetDateHeaderMonths(COleDateTime& dtYearMonth1, COleDateTime& dtYearMonth2,
  1130.   CString& strHeader1, CString& strHeader2,
  1131.   CString& strHeaderWeekDay)
  1132. {
  1133. strHeader1 = strHeader2 = strHeaderWeekDay = _T("");
  1134. dtYearMonth1 = dtYearMonth2 = (DATE)0;
  1136. SYSTEMTIME st;
  1138. int nViewType = GetCalendarCtrl().GetActiveView()->GetViewType();
  1139. if (nViewType == xtpCalendarDayView ||
  1140. nViewType == xtpCalendarWorkWeekView || nViewType == xtpCalendarFullWeekView)
  1141. {
  1142. CXTPCalendarDayView* pDayView = DYNAMIC_DOWNCAST(CXTPCalendarDayView, GetCalendarCtrl().GetDayView());
  1143. ASSERT(pDayView);
  1144. if (!pDayView)
  1145. {
  1146. return 0;
  1147. }
  1149. dtYearMonth1 = pDayView->GetViewDayDate(0);
  1150. GETASSYSTEMTIME_DT(dtYearMonth1, st);
  1151. strHeader1 = CXTPCalendarUtils::GetDateFormat(&st, _T("d MMMM"));
  1153. int nCount = pDayView->GetViewDayCount();
  1154. if (nCount > 1)
  1155. {
  1156. dtYearMonth2 = pDayView->GetViewDayDate(nCount-1);
  1157. GETASSYSTEMTIME_DT(dtYearMonth2, st);
  1158. strHeader2 = CXTPCalendarUtils::GetDateFormat(&st, _T("d MMMM"));
  1160. if (dtYearMonth1.GetMonth() != dtYearMonth2.GetMonth())
  1161. {
  1162. return 2;
  1163. }
  1164. }
  1166. if (nCount == 1)
  1167. {
  1168. COleDateTime dtDay0 = pDayView->GetViewDayDate(0);
  1169. int nWd = dtDay0.GetDayOfWeek();
  1170. int nWdShift = (nWd-1 + 6)%7;
  1172. strHeaderWeekDay = CXTPCalendarUtils::GetLocaleString(LOCALE_SDAYNAME1 + nWdShift, 100);
  1173. }
  1175. return 1;
  1176. }
  1177. else if (nViewType == xtpCalendarWeekView)
  1178. {
  1179. CXTPCalendarView* pView = GetCalendarCtrl().GetActiveView();
  1180. ASSERT(pView);
  1181. if (!pView)
  1182. {
  1183. return 0;
  1184. }
  1186. dtYearMonth1 = pView->GetViewDayDate(0);
  1187. dtYearMonth2 = pView->GetViewDayDate(pView->GetViewDayCount()-1);
  1189. CString strHeaderFormat = pView->GetDayHeaderFormat();
  1191. GETASSYSTEMTIME_DT(dtYearMonth1, st);
  1192. strHeader1 = CXTPCalendarUtils::GetDateFormat(&st, strHeaderFormat);
  1194. GETASSYSTEMTIME_DT(dtYearMonth2, st);
  1195. strHeader2 = CXTPCalendarUtils::GetDateFormat(&st, strHeaderFormat);
  1197. return 1;
  1198. }
  1199. else if (nViewType == xtpCalendarMonthView)
  1200. {
  1201. CXTPCalendarMonthView* pMonthView = DYNAMIC_DOWNCAST(CXTPCalendarMonthView, GetCalendarCtrl().GetMonthView());
  1203. if (!pMonthView || !pMonthView->GetGrid())
  1204. {
  1205. ASSERT(FALSE);
  1206. return 0;
  1207. }
  1209. int nWeeksCount = pMonthView->GetGrid()->GetWeeksCount();
  1210. ASSERT(nWeeksCount);
  1211. if (nWeeksCount)
  1212. {
  1213. CXTPCalendarMonthViewDay* pMVday1 = pMonthView->GetGrid()->GetViewDay(0, 6);
  1214. CXTPCalendarMonthViewDay* pMVday2 = pMonthView->GetGrid()->GetViewDay(nWeeksCount-1, 0);
  1215. if (pMVday1 && pMVday2)
  1216. {
  1217. dtYearMonth1 = pMVday1->GetDayDate();
  1219. GETASSYSTEMTIME_DT(dtYearMonth1, st);
  1220. strHeader1 = CXTPCalendarUtils::GetDateFormat(&st, _T("MMMM yyyy"));
  1222. COleDateTime dtLast = pMVday2->GetDayDate();
  1223. if (dtYearMonth1.GetMonth() != dtLast.GetMonth())
  1224. {
  1225. dtYearMonth2 = dtLast;
  1226. GETASSYSTEMTIME_DT(dtYearMonth2, st);
  1227. strHeader2 = CXTPCalendarUtils::GetDateFormat(&st, _T("MMMM yyyy"));
  1228. return 2;
  1229. }
  1230. return 1;
  1231. }
  1232. }
  1233. }
  1234. else
  1235. {
  1236. ASSERT(FALSE);
  1237. }
  1239. return 0;
  1240. }
  1242. CRect CXTPCalendarControlView::_HimetricToLP(CDC* pDC, const CRect rcHimetric)
  1243. {
  1244. CSize szLT(rcHimetric.left, rcHimetric.top);
  1245. CSize szRB(rcHimetric.right, rcHimetric.bottom);
  1247. pDC->HIMETRICtoLP(&szLT);
  1248. pDC->HIMETRICtoLP(&szRB);
  1250. CRect rcLP(szLT.cx, szLT.cy, szRB.cx, szRB.cy);
  1252. return rcLP;
  1253. }
  1256. //////////////////////////////////////////////////////////////////////////
  1257. // Clipboard operations
  1259. void CXTPCalendarControlView::OnUndo()
  1260. {
  1261. GetCalendarCtrl().OnUndo();
  1262. }
  1264. void CXTPCalendarControlView::OnCut()
  1265. {
  1266. CWnd* pFocusWnd = GetFocus();
  1267. if (pFocusWnd)
  1268. {
  1269. LRESULT lRes = pFocusWnd->SendMessage(WM_COMMAND, ID_EDIT_CUT, NULL);
  1270. if (!lRes)
  1271. {
  1272. pFocusWnd->SendMessage(WM_CUT);
  1273. }
  1274. }
  1275. }
  1277. void CXTPCalendarControlView::OnCopy()
  1278. {
  1279. CWnd* pFocusWnd = GetFocus();
  1280. if (pFocusWnd)
  1281. {
  1282. LRESULT lRes = pFocusWnd->SendMessage(WM_COMMAND, ID_EDIT_COPY, NULL);
  1283. if (!lRes)
  1284. {
  1285. pFocusWnd->SendMessage(WM_COPY);
  1286. }
  1287. }
  1288. }
  1290. void CXTPCalendarControlView::OnPaste()
  1291. {
  1292. CWnd* pFocusWnd = GetFocus();
  1293. if (pFocusWnd)
  1294. {
  1295. LRESULT lRes = pFocusWnd->SendMessage(WM_COMMAND, ID_EDIT_PASTE, NULL);
  1296. if (!lRes)
  1297. {
  1298. pFocusWnd->SendMessage(WM_PASTE);
  1299. }
  1300. }
  1301. }
  1303. void CXTPCalendarControlView::OnUpdateCommand(CCmdUI* pCmdUI)
  1304. {
  1305. GetCalendarCtrl().OnUpdateCmdUI(pCmdUI);
  1306. }
  1308. void CXTPCalendarControlView::OnFilePageSetup()
  1309. {
  1310. DWORD dwFlags = PSD_MARGINS | PSD_INWININIINTLMEASURE;
  1311. CXTPCalendarPageSetupDialog dlgPageSetup(GetPrintOptions(), dwFlags, this);
  1313. XTPGetPrinterDeviceDefaults(dlgPageSetup.m_psd.hDevMode, dlgPageSetup.m_psd.hDevNames);
  1315. int nDlgRes = (int)dlgPageSetup.DoModal();
  1317. if (nDlgRes == IDOK)
  1318. {
  1319. AfxGetApp()->SelectPrinter(dlgPageSetup.m_psd.hDevNames, dlgPageSetup.m_psd.hDevMode, FALSE);
  1320. }
  1321. }