/**
 * @file XTPCalendarControlView.cpp
 *
 * @copyright
 * (c) 1998-2025 Codejock Software, All Rights Reserved.
 *
 * This source file is the property of Codejock Software and must not be
 * redistributed by any means without the explicit written permission of
 * Codejock Software.
 *
 * The use of this source code is governed by the terms and conditions specified
 * in the Toolkit Pro license agreement. Codejock Software grants you, as a
 * single software developer, the limited right to use this software on one
 * computer only.
 *
 * Contact Information:
 * support@codejock.com
 * http://www.codejock.com
 *
 */

#include "stdafx.h"

#include "Calendar/Resource.h"

#include "Common/XTPTypeId.h"
#include "Common/XTPCasting.h"
#include "Common/XTPFramework.h"
#include "Common/XTPSystemHelpers.h"
#include "Common/XTPSynchro.h"
#include "Common/XTPApplication.h"
#include "Common/XTPSingleton.h"
#include "Common/XTPGdiObjects.h"
#include "Common/XTPResourceManager.h"
#include "Common/XTPImageManager.h"
#include "Common/XTPDrawHelpers.h"
#include "Common/XTPNotifyConnection.h"
#include "Common/XTPSmartPtrInternalT.h"
#include "Common/XTPColorManager.h"

#include "Calendar/XTPCalendarUtils.h"
#include "Calendar/XTPCalendarDefines.h"
#include "Calendar/XTPCalendarNotifications.h"
#include "Calendar/XTPCalendarPtrCollectionT.h"
#include "Calendar/XTPCalendarView.h"
#include "Calendar/XTPCalendarViewDay.h"
#include "Calendar/XTPCalendarMonthView.h"
#include "Calendar/XTPCalendarDayView.h"
#include "Calendar/XTPCalendarDayViewTimeScale.h"
#include "Calendar/XTPCalendarControl.h"
#include "Calendar/XTPCalendarViewPart.h"
#include "Calendar/XTPCalendarPaintManager.h"
#include "Calendar/CaptionBar/XTPCalendarCaptionBarTheme.h"
#include "Calendar/CaptionBar/XTPCalendarCaptionBarControl.h"
#include "Calendar/XTPCalendarControlView.h"
#include "Calendar/XTPCalendarIIDs.h"

#include "Common/Base/Diagnostic/XTPDisableNoisyWarnings.h"

#ifdef _DEBUG
#	define new DEBUG_NEW
#	undef THIS_FILE
static char THIS_FILE[] = __FILE__;
#endif

//////////////////////////////////////////////////////////////////////////
// CBeforePrintState

CXTPCalendarControlView::CBeforePrintState::CBeforePrintState()
{
	ClearData();
}
void CXTPCalendarControlView::CBeforePrintState::ClearData()
{
	m_bDataValid = FALSE;

	m_spScale_orig = 0;
	m_nTopRow	  = 0;
}
void CXTPCalendarControlView::CBeforePrintState::Save(CXTPCalendarControlView* pView)
{
	m_bDataValid   = FALSE;
	m_spScale_orig = 0;
	m_nTopRow	  = 0;

	BOOL b		  = pView->GetCalendarCtrl().m_bMultiColumnWeekMode;
	int nViewType = pView->GetCalendarCtrl().GetActiveView()->GetViewType();
	if (nViewType == xtpCalendarDayView || (b && nViewType == xtpCalendarWeekView)
		|| nViewType == xtpCalendarWorkWeekView || nViewType == xtpCalendarFullWeekView)
	{
		CXTPCalendarDayView* pDayView = DYNAMIC_DOWNCAST(CXTPCalendarDayView,
														 pView->GetCalendarCtrl().GetDayView());
		_ASSERTE(pDayView);
		if (!pDayView)
			return;

		m_spScale_orig = pDayView->GetScaleInterval();
		m_nTopRow	  = pDayView->GetTopRow();

		m_bDataValid = TRUE;
	}
}

void CXTPCalendarControlView::CBeforePrintState::Restore(CXTPCalendarControlView* pView)
{
	if (!m_bDataValid)
		return;

	BOOL b		  = pView->GetCalendarCtrl().m_bMultiColumnWeekMode;
	int nViewType = pView->GetCalendarCtrl().GetActiveView()->GetViewType();
	if (nViewType == xtpCalendarDayView || (b && nViewType == xtpCalendarWeekView)
		|| nViewType == xtpCalendarWorkWeekView || nViewType == xtpCalendarFullWeekView)
	{
		CXTPCalendarDayView* pDayView = DYNAMIC_DOWNCAST(CXTPCalendarDayView,
														 pView->GetCalendarCtrl().GetDayView());
		if (!pDayView)
			return;

		pDayView->SetScaleInterval(m_spScale_orig);
		pView->GetCalendarCtrl().RedrawControl(TRUE);
		pView->CalendarDayView_ScrolV(m_nTopRow);
	}
	pView->GetCalendarCtrl().AdjustLayout();
}

////////////////////////////////////////////////////////////////////////////
AFX_INLINE void MoveRectToXY(CRect& rc, int nX, int nY)
{
	rc.right  = nX + rc.Width();
	rc.bottom = nY + rc.Height();

	rc.left = nX;
	rc.top  = nY;
}

//////////////////////////////////////////////////////

BEGIN_MESSAGE_MAP(CXTPCalendarPageSetupDialog, CPageSetupDialog)
	ON_BN_CLICKED(XTP_IDC_PRINT_DATE_HEADER, OnBnClickedPrintDateHeader)
	ON_BN_CLICKED(XTP_IDC_PRINT_DATE_HEADER_FONT_BUTTON, OnBnClickedDateHeaderFont)
	ON_BN_CLICKED(XTP_IDC_CALENDAR_HEADER_FORMAT_BTN, OnBnClickedHeaderFormat)
	ON_BN_CLICKED(XTP_IDC_CALENDAR_FOOTER_FORMAT_BTN, OnBnClickedFooterFormat)
	ON_BN_CLICKED(XTP_IDC_MONTH_VIEW_PRINT_RANGE, OnBnClickedMonthViewPrintRange)
END_MESSAGE_MAP()

CXTPCalendarPageSetupDialog::CXTPCalendarPageSetupDialog(
	CXTPCalendarControlViewPrintOptions* pOptions, DWORD dwFlags, CWnd* pParentWnd)
	: CPageSetupDialog(dwFlags, pParentWnd)
{
	_ASSERTE(pOptions);
	m_pOptions = pOptions;

	if (m_pOptions)
	{
		BOOL bIsInches  = m_pOptions->IsMarginsMeasureInches();
		DWORD dwMeasure = XTPToDWORD(bIsInches ? PSD_INTHOUSANDTHSOFINCHES
											   : PSD_INHUNDREDTHSOFMILLIMETERS);

		m_psd.Flags &= ~PSD_INWININIINTLMEASURE;
		m_psd.Flags |= dwMeasure;
	}

	m_psd.Flags |= PSD_ENABLEPAGESETUPTEMPLATEHANDLE;
	m_psd.hPageSetupTemplate = (HGLOBAL)XTPResourceManager()->LoadDialogTemplate(IDD);
	_ASSERTE(m_psd.hPageSetupTemplate);

	if (m_pOptions)
	{
		m_psd.rtMargin = m_pOptions->m_rcMargins;
	}

	m_nIDHelp = XTP_IDD_CALENDAR_PRINT_PAGE_SETUP;

	VERIFY(CXTPDrawHelpers::GetIconLogFont(&m_lfDateHeader));
}

CXTPCalendarPageSetupDialog::~CXTPCalendarPageSetupDialog()
{
}

#ifndef rad1
#	define rad1 0x0420
#	define rad2 0x0421

#	define grp4 0x0433
#endif

BOOL CXTPCalendarPageSetupDialog::OnInitDialog()
{
	CPageSetupDialog::OnInitDialog();

	_ASSERTE(m_pOptions);

	VERIFY(m_ctrlPrintFromCmb.SubclassDlgItem(XTP_IDC_PRINT_FROM_COMBO, this));
	VERIFY(m_ctrlPrintToCmb.SubclassDlgItem(XTP_IDC_PRINT_TO_COMBO, this));
	VERIFY(m_ctrlPrintFromTo.SubclassDlgItem(XTP_IDC_PRINT_FROMTO, this));
	VERIFY(m_ctrlPrintDateHeader.SubclassDlgItem(XTP_IDC_PRINT_DATE_HEADER, this));
	VERIFY(m_ctrlDateHeaderFontLabel.SubclassDlgItem(XTP_IDC_PRINT_DATE_HEADER_FONT_LABEL, this));
	VERIFY(m_ctrlDateHeaderFont.SubclassDlgItem(XTP_IDC_PRINT_DATE_HEADER_FONT, this));
	VERIFY(m_ctrlDateHeaderFontButton.SubclassDlgItem(XTP_IDC_PRINT_DATE_HEADER_FONT_BUTTON, this));
	VERIFY(m_ctrlBlackWhitePrinting.SubclassDlgItem(XTP_IDC_PRINT_BLACK_WHITE, this));
	if (GetDlgItem(XTP_IDC_PREV_NEXT))
		VERIFY(m_ctrl3SmallCal.SubclassDlgItem(XTP_IDC_PREV_NEXT, this));
	VERIFY(m_ctrlHeaderFormat.SubclassDlgItem(XTP_IDC_CALENDAR_HEADER_FORMAT, this));
	VERIFY(m_ctrlFooterFormat.SubclassDlgItem(XTP_IDC_CALENDAR_FOOTER_FORMAT, this));
	VERIFY(m_ctrlHeaderFormatBtn.SubclassDlgItem(XTP_IDC_CALENDAR_HEADER_FORMAT_BTN, this));
	VERIFY(m_ctrlFooterFormatBtn.SubclassDlgItem(XTP_IDC_CALENDAR_FOOTER_FORMAT_BTN, this));

	VERIFY(m_ctrlMonthViewPrintFrom.SubclassDlgItem(XTP_IDC_MONTHVIEW_BEGIN_DATETIMEPICKER, this));
	VERIFY(m_ctrlMonthViewPrintTo.SubclassDlgItem(XTP_IDC_MONTHVIEW_END_DATETIMEPICKER, this));
	VERIFY(m_ctrlMonthViewPrintRange.SubclassDlgItem(XTP_IDC_MONTH_VIEW_PRINT_RANGE, this));

	CString strTimeFormat_HrMin = CXTPCalendarUtils::GetTimeFormatString_HrMin();
	CString strTime;
	for (int i = 0; i <= 24 * 60; i += 30)
	{
		if (i < 24 * 60)
			strTime = CXTPCalendarUtils::GetTimeFormat((int)(i / 60), (int)(i % 60),
													   strTimeFormat_HrMin);
		else
			strTime = _T("23:59:59");
		m_ctrlPrintFromCmb.AddString(strTime);
		m_ctrlPrintToCmb.AddString(strTime);
	}

	if (m_pOptions)
	{
		strTime = CXTPCalendarUtils::GetTimeFormat(m_pOptions->m_dtPrintFrom, strTimeFormat_HrMin);
		m_ctrlPrintFromCmb.SetWindowText(strTime);
		int iFr = m_ctrlPrintFromCmb.FindStringExact(0, strTime);
		if (iFr > -1)
			m_ctrlPrintFromCmb.SetCurSel(iFr);

		strTime = CXTPCalendarUtils::GetTimeFormat(m_pOptions->m_dtPrintTo, strTimeFormat_HrMin);
		m_ctrlPrintToCmb.SetWindowText(strTime);
		int iTo = m_ctrlPrintToCmb.FindStringExact(0, strTime);
		if (iTo > -1)
			m_ctrlPrintToCmb.SetCurSel(iTo);

		m_ctrlPrintFromTo.SetCheck(m_pOptions->m_bPrintFromToExactly ? 1 : 0);

		m_ctrlPrintDateHeader.SetCheck(m_pOptions->m_bPrintDateHeader ? 1 : 0);
		m_ctrlBlackWhitePrinting.SetCheck(m_pOptions->m_bBlackWhitePrinting ? 1 : 0);

		if (GetDlgItem(XTP_IDC_PREV_NEXT))
			m_ctrl3SmallCal.SetCheck(m_pOptions->m_b3SmallCal ? 1 : 0);

		m_lfDateHeader = m_pOptions->m_lfDateHeaderFont;

		CString strFont = FormatFontName(m_lfDateHeader);
		m_ctrlDateHeaderFont.SetWindowText(strFont);

		if (m_pOptions->GetPageHeader())
			m_ctrlHeaderFormat.SetWindowText(m_pOptions->GetPageHeader()->m_strFormatString);

		if (m_pOptions->GetPageFooter())
			m_ctrlFooterFormat.SetWindowText(m_pOptions->GetPageFooter()->m_strFormatString);

		OnBnClickedPrintDateHeader();
	}

	XTP_SAFE_CALL1(GetDlgItem(rad1), EnableWindow(TRUE)); // 1056 Portrait
	XTP_SAFE_CALL1(GetDlgItem(rad2), EnableWindow(TRUE)); // 1057 Landscape

	BOOL bIsInches = m_pOptions ? m_pOptions->IsMarginsMeasureInches() : FALSE;

	UINT uStrID		   = XTPToUInt(bIsInches ? XTP_IDS_CALENDAR_MARGINS_INCH
										 : XTP_IDS_CALENDAR_MARGINS_MM);
	CString strCaption = CXTPCalendarUtils::LoadString(uStrID);

	if (!strCaption.IsEmpty() && GetDlgItem(grp4))
		GetDlgItem(grp4)->SetWindowText(strCaption);

	if (m_pOptions->m_dtMonthViewPrintBeginDate.GetStatus() == COleDateTime::valid
		&& m_pOptions->m_dtMonthViewPrintEndDate.GetStatus() == COleDateTime::valid)
	{
		m_ctrlMonthViewPrintRange.SetCheck(BST_CHECKED);
	}
	else
	{
		m_ctrlMonthViewPrintRange.SetCheck(BST_UNCHECKED);
	}

	UpdateMonthViewDateControls();

	return FALSE;
}

void CXTPCalendarPageSetupDialog::UpdateMonthViewDateControls()
{
	if (m_pOptions->m_dtMonthViewPrintBeginDate.GetStatus() == COleDateTime::valid)
	{
		m_ctrlMonthViewPrintFrom.EnableWindow(TRUE);
		m_ctrlMonthViewPrintFrom.SetTime(m_pOptions->m_dtMonthViewPrintBeginDate);
	}
	else
	{
		m_ctrlMonthViewPrintFrom.EnableWindow(FALSE);
	}

	if (m_pOptions->m_dtMonthViewPrintEndDate.GetStatus() == COleDateTime::valid)
	{
		m_ctrlMonthViewPrintTo.EnableWindow(TRUE);
		m_ctrlMonthViewPrintTo.SetTime(m_pOptions->m_dtMonthViewPrintEndDate);
	}
	else
	{
		m_ctrlMonthViewPrintTo.EnableWindow(FALSE);
	}
}

void CXTPCalendarPageSetupDialog::OnBnClickedPrintDateHeader()
{
	int nCheck = m_ctrlPrintDateHeader.GetCheck();

	m_ctrlDateHeaderFont.EnableWindow(nCheck != 0);
	m_ctrlDateHeaderFontLabel.EnableWindow(nCheck != 0);
	m_ctrlDateHeaderFontButton.EnableWindow(nCheck != 0);
}

void CXTPCalendarPageSetupDialog::OnOK()
{
	_ASSERTE(m_pOptions);
	if (!m_pOptions)
	{
		CPageSetupDialog::OnOK();
		return;
	}

	CString strFrom, strTo;
	m_ctrlPrintFromCmb.GetWindowText(strFrom);
	if (strFrom.Find(_T(":")) == -1)
		strFrom += _T(":00");
	int nFrom_min = CXTPCalendarUtils::ParceTimeString_min(strFrom);

	m_ctrlPrintToCmb.GetWindowText(strTo);
	if (strTo.Find(_T(":")) == -1)
		strTo += _T(":00");
	int nTo_min = CXTPCalendarUtils::ParceTimeString_min(strTo);

	m_pOptions->m_dtPrintFrom.SetTime(nFrom_min / 60, nFrom_min % 60, 0);
	m_pOptions->m_dtPrintTo.SetTime(nTo_min / 60, nTo_min % 60, 0);

	m_pOptions->m_bPrintFromToExactly = m_ctrlPrintFromTo.GetCheck() != 0;
	m_pOptions->m_bBlackWhitePrinting = m_ctrlBlackWhitePrinting.GetCheck() != 0;
	if (GetDlgItem(XTP_IDC_PREV_NEXT))
		m_pOptions->m_b3SmallCal = m_ctrl3SmallCal.GetCheck() != 0;

	m_pOptions->m_bPrintDateHeader = m_ctrlPrintDateHeader.GetCheck() != 0;
	if (m_pOptions->m_bPrintDateHeader)
		m_pOptions->m_lfDateHeaderFont = m_lfDateHeader;

	m_pOptions->m_rcMargins = m_psd.rtMargin;

	if (m_pOptions->GetPageHeader())
		m_ctrlHeaderFormat.GetWindowText(m_pOptions->GetPageHeader()->m_strFormatString);

	if (m_pOptions->GetPageFooter())
		m_ctrlFooterFormat.GetWindowText(m_pOptions->GetPageFooter()->m_strFormatString);

	int iCheck = m_ctrlMonthViewPrintRange.GetCheck();
	if (iCheck == BST_CHECKED)
	{
		m_ctrlMonthViewPrintFrom.GetTime(m_pOptions->m_dtMonthViewPrintBeginDate);
		m_ctrlMonthViewPrintTo.GetTime(m_pOptions->m_dtMonthViewPrintEndDate);
	}
	else
	{
		m_pOptions->m_dtMonthViewPrintBeginDate.SetStatus(COleDateTime::invalid);
		m_pOptions->m_dtMonthViewPrintEndDate.SetStatus(COleDateTime::invalid);
	}

	CPageSetupDialog::OnOK();
}

CString CXTPCalendarPageSetupDialog::FormatFontName(const LOGFONT& lfFont)
{
	CClientDC dc(this);
	double dLogPixelY = dc.GetDeviceCaps(LOGPIXELSY);
	double dPointSize = abs(lfFont.lfHeight) * 72.0 / dLogPixelY;
	int nPointSize	= (int)(dPointSize + 0.5);

	CString strFont;
	strFont.Format(_T(" %d pt. %s"), nPointSize, lfFont.lfFaceName);

	CString strAttr;
	if (lfFont.lfWeight >= FW_BOLD)
		strAttr += _T(" Bold");

	if (lfFont.lfItalic)
	{
		if (!strAttr.IsEmpty())
			strAttr += _T(",");

		strAttr += _T(" Italic");
	}

	if (!strAttr.IsEmpty())
	{
		strFont += _T("\n");
		strFont += strAttr;
	}

	return strFont;
}

void CXTPCalendarPageSetupDialog::OnBnClickedDateHeaderFont()
{
	CFontDialog dlgFont(&m_lfDateHeader);
	int nDlgRes = (int)dlgFont.DoModal();

	if (nDlgRes == IDOK)
	{
		dlgFont.GetCurrentFont(&m_lfDateHeader);

		CString strFont = FormatFontName(m_lfDateHeader);
		m_ctrlDateHeaderFont.SetWindowText(strFont);
	}
}

void CXTPCalendarPageSetupDialog::OnBnClickedHeaderFormat()
{
	CXTPPrintPageHeaderFooter::DoInsertHFFormatSpecifierViaMenu(this, &m_ctrlHeaderFormat,
																&m_ctrlHeaderFormatBtn);
}

void CXTPCalendarPageSetupDialog::OnBnClickedFooterFormat()
{
	CXTPPrintPageHeaderFooter::DoInsertHFFormatSpecifierViaMenu(this, &m_ctrlFooterFormat,
																&m_ctrlFooterFormatBtn);
}

void CXTPCalendarPageSetupDialog::OnBnClickedMonthViewPrintRange()
{
	int iCheck = m_ctrlMonthViewPrintRange.GetCheck();
	if (iCheck == BST_CHECKED)
	{
		m_pOptions->m_dtMonthViewPrintBeginDate = CXTPCalendarUtils::GetCurrentTime();
		m_pOptions->m_dtMonthViewPrintEndDate   = CXTPCalendarUtils::GetCurrentTime();
	}
	else
	{
		m_pOptions->m_dtMonthViewPrintBeginDate.SetStatus(COleDateTime::invalid);
		m_pOptions->m_dtMonthViewPrintEndDate.SetStatus(COleDateTime::invalid);
	}

	UpdateMonthViewDateControls();
}

/////////////////////////////////////////////////////////////////////////////

IMPLEMENT_DYNAMIC(CXTPCalendarControlViewPrintOptions, CXTPPrintOptions)

CXTPCalendarControlViewPrintOptions::CXTPCalendarControlViewPrintOptions()
{
	m_dtPrintFrom.SetTime(8, 0, 0);
	m_dtPrintTo.SetTime(19, 0, 0);
	m_bPrintFromToExactly = TRUE;

	LOGFONT lfIcon;
	VERIFY(CXTPDrawHelpers::GetIconLogFont(&lfIcon));

	m_bPrintDateHeader			= TRUE;
	m_b3SmallCal				= TRUE;
	m_lfDateHeaderFont			= lfIcon;
	m_lfDateHeaderFont.lfHeight = -24;
	m_lfDateHeaderFont.lfWeight = FW_BOLD;

	m_lfDateHeaderWeekDayFont		   = lfIcon;
	m_lfDateHeaderWeekDayFont.lfHeight = -max(abs(lfIcon.lfHeight),
											  abs(m_lfDateHeaderFont.lfHeight * 2 / 3));

	m_lfDateHeaderCalendarFont = lfIcon;

	m_dtMonthViewPrintBeginDate.SetStatus(COleDateTime::invalid);
	m_dtMonthViewPrintEndDate.SetStatus(COleDateTime::invalid);

#ifdef _XTP_ACTIVEX
	EnableAutomation();
	EnableTypeLib();
#endif
}

LCID CXTPCalendarControlViewPrintOptions::GetActiveLCID()
{
	return CXTPCalendarUtils::GetActiveLCID();
}

void CXTPCalendarControlViewPrintOptions::Set(const CXTPCalendarControlViewPrintOptions* pSrc)
{
	if (!pSrc)
		return;

	CXTPPrintOptions::Set(pSrc);

	m_dtPrintFrom		  = pSrc->m_dtPrintFrom;
	m_dtPrintTo			  = pSrc->m_dtPrintTo;
	m_bPrintFromToExactly = pSrc->m_bPrintFromToExactly;
	m_b3SmallCal		  = pSrc->m_b3SmallCal;

	m_dtMonthViewPrintBeginDate = pSrc->m_dtMonthViewPrintBeginDate;
	m_dtMonthViewPrintEndDate   = pSrc->m_dtMonthViewPrintEndDate;

	m_bPrintDateHeader		   = pSrc->m_bPrintDateHeader;
	m_lfDateHeaderFont		   = pSrc->m_lfDateHeaderFont;
	m_lfDateHeaderCalendarFont = pSrc->m_lfDateHeaderCalendarFont;
}

/////////////////////////////////////////////////////////////////////////////
// CXTPCalendarControlView

IMPLEMENT_DYNCREATE(CXTPCalendarControlView, CView)

CXTPCalendarControlView::CXTPCalendarControlView()
{
	m_pSink = new CXTPNotifySink();

	m_pCalendar					  = new CXTPCalendarControl();
	m_bReleaseCalendarWhenDestroy = TRUE;

	m_pUpdateContext = NULL;

	m_bPrintDirect			 = FALSE;
	m_bResizeControlWithView = TRUE;

	m_bShowCaptionBar			   = FALSE;
	m_bDayViewMode				   = FALSE;
	m_bPrintFineMode			   = TRUE;
	m_bPrintRepeatHeaderFooterMode = FALSE;
	m_bDF_mode					   = TRUE;

	m_pVScrollBar = NULL;
	m_pHScrollBar = NULL;

	m_nInitialTopCell = 0;

	m_bPrintFullScale = TRUE; // print timescale range - if FALSE - print working hours range

	m_pPrintOptions = new CXTPCalendarControlViewPrintOptions();
}

CXTPCalendarControlView::~CXTPCalendarControlView()
{
	if (m_bReleaseCalendarWhenDestroy)
		SAFE_DELETE(m_pCalendar);

	SAFE_DELETE(m_pUpdateContext);

	CMDTARGET_RELEASE(m_pPrintOptions);

	m_pSink->Delete();
}

CXTPCalendarControl& CXTPCalendarControlView::GetCalendarCtrl()
{
	_ASSERTE(m_pCalendar);
	return *m_pCalendar;
}

void CXTPCalendarControlView::SetCalendarCtrl(CXTPCalendarControl* pCalendar,
											  BOOL bReleaseWhenDestroy)
{
	if (m_pCalendar && ::IsWindow(m_pCalendar->GetSafeHwnd()))
		m_pCalendar->DestroyWindow();

	if (m_bReleaseCalendarWhenDestroy)
		SAFE_DELETE(m_pCalendar);

	m_pCalendar					  = pCalendar;
	m_bReleaseCalendarWhenDestroy = bReleaseWhenDestroy;

	m_pSink->UnadviseAll();
	m_pSink->Advise(
		GetCalendarCtrl().GetConnection(), XTP_NC_CALENDAR_THEME_CHANGED,
		CreateNotfySinkClassDelegate(this, &CXTPCalendarControlView::OnEvent_CalendarThemeChanged));

	_ResizeControls();
}

void CXTPCalendarControlView::SetScrollBarCtrl(CScrollBar* pScrollBar, int nBar /*=SB_VERT*/)
{
	if (nBar == SB_VERT)
		m_pVScrollBar = pScrollBar;

	if (nBar == SB_HORZ)
		m_pHScrollBar = pScrollBar;
}

#include "Common/Base/Diagnostic/XTPBeginAfxMap.h"
BEGIN_MESSAGE_MAP(CXTPCalendarControlView, CView)
	//{{AFX_MSG_MAP(CXTPCalendarControlView)
	ON_WM_ERASEBKGND()
	ON_WM_SIZE()
	ON_WM_CREATE()
	ON_WM_DESTROY()
	ON_WM_SETFOCUS()
	ON_WM_PAINT()
	ON_WM_VSCROLL()
	ON_WM_HSCROLL()

	ON_COMMAND(ID_FILE_PAGE_SETUP, OnFilePageSetup)
	ON_COMMAND(ID_FILE_PRINT, CView::OnFilePrint)
	ON_COMMAND(ID_FILE_PRINT_PREVIEW, CView::OnFilePrintPreview)

	ON_BN_CLICKED(ID_EDIT_UNDO, OnUndo)
	ON_BN_CLICKED(ID_EDIT_CUT, OnCut)
	ON_BN_CLICKED(ID_EDIT_COPY, OnCopy)
	ON_BN_CLICKED(ID_EDIT_PASTE, OnPaste)
	ON_BN_CLICKED(ID_EDIT_SELECT_ALL, OnSelectAll)
	ON_UPDATE_COMMAND_UI(ID_EDIT_UNDO, OnUpdateCommand)
	ON_UPDATE_COMMAND_UI(ID_EDIT_CUT, OnUpdateCommand)
	ON_UPDATE_COMMAND_UI(ID_EDIT_COPY, OnUpdateCommand)
	ON_UPDATE_COMMAND_UI(ID_EDIT_PASTE, OnUpdateCommand)
	ON_UPDATE_COMMAND_UI(ID_EDIT_SELECT_ALL, OnUpdateCommand)
	//}}AFX_MSG_MAP
END_MESSAGE_MAP()
#include "Common/Base/Diagnostic/XTPEndAfxMap.h"

/////////////////////////////////////////////////////////////////////////////
// CXTPCalendarControlView drawing

void CXTPCalendarControlView::OnDraw(CDC* /*pDC*/)
{
}

void CXTPCalendarControlView::OnPaint()
{
	Default();
}

/////////////////////////////////////////////////////////////////////////////
// CXTPCalendarControlView diagnostics

#ifdef _DEBUG
void CXTPCalendarControlView::AssertValid() const
{
	CView::AssertValid();
}

void CXTPCalendarControlView::Dump(CDumpContext& dc) const
{
	CView::Dump(dc);
}
#endif //_DEBUG

/////////////////////////////////////////////////////////////////////////////
// CXTPCalendarControlView message handlers

BOOL CXTPCalendarControlView::OnEraseBkgnd(CDC* pDC)
{
	// fill small rectangle in bottom corner where horizontal / vertical scrollbars intersect.
	if (GetCalendarCtrl().m_bTimelineMode && ::IsWindow(m_pVScrollBar->GetSafeHwnd()))
	{
		CXTPClientRect rcClient(this);

		int cxVScroll = ::GetSystemMetrics(SM_CXVSCROLL);
		int cyHScroll = ::GetSystemMetrics(SM_CYHSCROLL);

		if (GetCalendarCtrl().IsLayoutRTL())
		{
			rcClient.right = rcClient.left + cxVScroll;
			rcClient.top   = rcClient.bottom - cyHScroll;
		}
		else
		{
			rcClient.left = rcClient.right - cxVScroll;
			rcClient.top  = rcClient.bottom - cyHScroll;
		}

		CXTPCalendarPaintManager* pPaintManager = GetCalendarCtrl().GetPaintManager();
		COLORREF crBack = pPaintManager ? pPaintManager->m_clrTLVBack.operator DWORD()
										: ::GetSysColor(COLOR_BTNFACE);
		pDC->FillSolidRect(rcClient, crBack);
	}

	return TRUE;
}

CScrollBar* CXTPCalendarControlView::GetScrollBarCtrl(int nBar) const
{
	if (nBar == SB_VERT && m_pVScrollBar)
		return m_pVScrollBar;

	if (nBar == SB_HORZ && m_pHScrollBar)
		return m_pHScrollBar;

	return CView::GetScrollBarCtrl(nBar);
}

void CXTPCalendarControlView::OnVScroll(UINT nSBCode, UINT nPos, CScrollBar* pScrollBar)
{
	if (m_pVScrollBar && pScrollBar == m_pVScrollBar)
		GetCalendarCtrl().OnVScroll(nSBCode, nPos, 0);

	CView::OnVScroll(nSBCode, nPos, pScrollBar);
}

void CXTPCalendarControlView::OnHScroll(UINT nSBCode, UINT nPos, CScrollBar* pScrollBar)
{
	if (m_pHScrollBar && pScrollBar == m_pHScrollBar)
		GetCalendarCtrl().OnHScroll(nSBCode, nPos, 0);

	CView::OnHScroll(nSBCode, nPos, pScrollBar);
}

void CXTPCalendarControlView::OnSize(UINT nType, int cx, int cy)
{
	CView::OnSize(nType, cx, cy);

	if (!m_bResizeControlWithView)
		return;

	_ResizeControls();
}

void CXTPCalendarControlView::_ResizeControls()
{
	if (!m_bResizeControlWithView)
		return;

	CXTPClientRect rcClient(this);
	int cx			 = rcClient.Width();
	int cy			 = rcClient.Height();
	int cyCaptionBar = 0;

	if (::IsWindow(m_wndCalendarCaptionBar.m_hWnd))
	{
		if (m_bShowCaptionBar)
		{
			CRect rcCaptionBar = m_wndCalendarCaptionBar.CalcMinRect(FALSE);
			cyCaptionBar	   = rcCaptionBar.Height();

			if ((m_wndCalendarCaptionBar.GetStyle() & WS_VISIBLE) == 0)
			{
				BOOL b = m_wndCalendarCaptionBar.IsUseOneLine();
				m_wndCalendarCaptionBar.ShowWindow(SW_SHOW);
				m_wndCalendarCaptionBar.GetTheme()->AttachCalendar(&GetCalendarCtrl());
				m_wndCalendarCaptionBar.UseOneLine(b);
			}
		}
		else
		{
			if ((m_wndCalendarCaptionBar.GetStyle() & WS_VISIBLE))
			{
				m_wndCalendarCaptionBar.ShowWindow(SW_HIDE);
				m_wndCalendarCaptionBar.GetTheme()->AttachCalendar(NULL);
			}
		}

		m_wndCalendarCaptionBar.MoveWindow(0, 0, cx, cyCaptionBar);
	}

	if (::IsWindow(GetCalendarCtrl().m_hWnd))
	{
		int cxVScroll = ::GetSystemMetrics(SM_CXVSCROLL);
		int cyHScroll = 0;

		if (GetCalendarCtrl().m_bTimelineMode)
		{
			cyHScroll = ::GetSystemMetrics(SM_CYHSCROLL);
		}

		CRect rcCalendar;
		rcCalendar.left   = 0;
		rcCalendar.top	= cyCaptionBar;
		rcCalendar.right  = cx;
		rcCalendar.bottom = cy;

		if (::IsWindow(m_pHScrollBar->GetSafeHwnd()))
		{
			rcCalendar.bottom -= cyHScroll;

			if (GetCalendarCtrl().IsLayoutRTL())
			{
				m_pHScrollBar->MoveWindow(cxVScroll, cy - cyHScroll, cx - cxVScroll, cyHScroll);
			}
			else
			{
				m_pHScrollBar->MoveWindow(0, cy - cyHScroll, cx - cxVScroll, cyHScroll);
			}
		}

		if (::IsWindow(m_pVScrollBar->GetSafeHwnd()))
		{
			if (GetCalendarCtrl().IsLayoutRTL())
			{
				m_pVScrollBar->MoveWindow(0, cyCaptionBar, cxVScroll,
										  max(0, cy - cyCaptionBar) - cyHScroll);

				rcCalendar.left = cxVScroll;
			}
			else
			{
				m_pVScrollBar->MoveWindow(cx - cxVScroll, cyCaptionBar, cxVScroll,
										  max(0, cy - cyCaptionBar) - cyHScroll);

				rcCalendar.right = max(0, cx - cxVScroll);
			}
		}

		GetCalendarCtrl().MoveWindow(rcCalendar);
	}
}

BOOL CXTPCalendarControlView::IsShowCaptionBar() const
{
	return m_bShowCaptionBar;
}

void CXTPCalendarControlView::ShowCaptionBar(BOOL bShow)
{
	if (m_bShowCaptionBar != bShow)
	{
		m_bShowCaptionBar = bShow;

		_ResizeControls();

		if (m_hWnd)
			Invalidate(NULL);

		CRect rcCaptionBar = m_wndCalendarCaptionBar.CalcMinRect(NULL);
		if (bShow)
			GetCalendarCtrl().m_nCaptionHeight = rcCaptionBar.Height();
		else
			GetCalendarCtrl().m_nCaptionHeight = 0;
	}
}

void CXTPCalendarControlView::OnEvent_CalendarThemeChanged(XTP_NOTIFY_CODE Event, WPARAM wParam,
														   LPARAM lParam)
{
	UNREFERENCED_PARAMETER(Event);
	UNREFERENCED_PARAMETER(wParam);
	UNREFERENCED_PARAMETER(lParam);

	_ASSERTE(Event == XTP_NC_CALENDAR_THEME_CHANGED);

	_ResizeControls();

	if (m_hWnd)
		Invalidate(NULL);
}

int CXTPCalendarControlView::OnCreate(LPCREATESTRUCT lpCreateStruct)
{
	if (CView::OnCreate(lpCreateStruct) == -1)
		return -1;

	if (!m_wndCalendarCaptionBar.Create(WS_CHILD | WS_TABSTOP, CRect(0, 0, 0, 0), this,
										XTP_ID_CALENDARCAPTIONBAR_CONTROL))
	{
		TRACE(_T("Failed to create Calendar Caption Bar control window\n"));
		return -1;
	}

	if (!GetCalendarCtrl().Create(WS_CHILD | WS_TABSTOP | WS_VISIBLE, CRect(0, 0, 0, 0), this,
								  XTP_ID_CALENDAR_CONTROL))
	{
		TRACE(_T("Failed to create Calendar control window\n"));
		return -1;
	}

	_ResizeControls();

	return 0;
}

void CXTPCalendarControlView::OnDestroy()
{
	SAFE_DELETE(m_pUpdateContext);
	CView::OnDestroy();
}

void CXTPCalendarControlView::OnSetFocus(CWnd* pOldWnd)
{
	CView::OnSetFocus(pOldWnd);

	GetCalendarCtrl().SetFocus();
}

BOOL CXTPCalendarControlView::OnPreparePrinting(CPrintInfo* pInfo)
{
	pInfo->m_bDirect = m_bPrintDirect;

	pInfo->SetMinPage(1);
	pInfo->SetMaxPage(1);

	return DoPreparePrinting(pInfo);
}

void CXTPCalendarControlView::OnBeginPrinting(CDC* /*pDC*/, CPrintInfo* pInfo)
{
	pInfo->m_bContinuePrinting = TRUE;
	m_PageStart.RemoveAll();

	m_pritAdjustContext.Reset();
	GetCalendarCtrl().EnableSendNotifications(FALSE);
	_ASSERTE(m_pUpdateContext == NULL);
	SAFE_DELETE(m_pUpdateContext);
	m_pUpdateContext = new CXTPCalendarControl::CUpdateContext(&GetCalendarCtrl(),
															   xtpCalendarUpdateRedraw);
	m_beforePrintState.Save(this);

	m_dtPrintFrom = m_pPrintOptions->m_dtPrintFrom;
	m_dtPrintTo   = m_pPrintOptions->m_dtPrintTo;

	m_dtPrintFrom.SetTime(m_dtPrintFrom.GetHour(), m_dtPrintFrom.GetMinute(), 0);

	if (m_dtPrintTo.GetStatus() != COleDateTime::valid)
	{
		m_dtPrintTo.SetTime(23, 59, 59);
		m_dtPrintTo.SetStatus(COleDateTime::valid);
	}
	else
		m_dtPrintTo.SetTime(m_dtPrintTo.GetHour(), m_dtPrintTo.GetMinute(), 0);

	if (m_dtPrintFrom > m_dtPrintTo)
	{
		COleDateTime dtT = m_dtPrintTo;
		m_dtPrintTo		 = m_dtPrintFrom;
		m_dtPrintFrom	= dtT;
	}
	else if (m_dtPrintFrom == m_dtPrintTo)
	{
		if (m_dtPrintTo.GetHour() < 23)
			m_dtPrintTo += COleDateTimeSpan(0, 1, 0, 0);
		else if (m_dtPrintFrom.GetHour() > 1)
			m_dtPrintFrom -= COleDateTimeSpan(0, 1, 0, 0);
	}

	m_bDayViewMode   = FALSE;
	m_bMonthViewMode = FALSE;

	XTPCalendarViewType nViewType = GetCalendarCtrl().GetActiveView()->GetViewType();

	if (nViewType == xtpCalendarMonthView)
		m_bMonthViewMode = TRUE;

	BOOL b						  = GetCalendarCtrl().m_bMultiColumnWeekMode;
	CXTPCalendarDayView* pDayView = DYNAMIC_DOWNCAST(CXTPCalendarDayView,
													 GetCalendarCtrl().GetDayView());
	if (nViewType == xtpCalendarDayView || (b && nViewType == xtpCalendarWeekView)
		|| nViewType == xtpCalendarWorkWeekView || nViewType == xtpCalendarFullWeekView)
	{
		if (pDayView)
		{
			m_nInitialTopCell			   = pDayView->GetTopRow();
			pDayView->m_nCurPage		   = 0;
			m_bDayViewMode				   = TRUE;
			m_bPrintFineMode			   = !pDayView->m_bDraftMode;
			m_bPrintRepeatHeaderFooterMode = pDayView->m_bPrintRepeatHeaderFooterMode;
			m_bDF_mode					   = pDayView->m_bDF_mode;
			m_bPrintFullScale			   = pDayView->m_bPrintFullScale;

			if (m_bDF_mode)
			{
				m_dtInitialScaleInterval = pDayView->GetScaleInterval();

				if (pDayView->m_nDayViewPrintInterval == 60)
					pDayView->SetScaleInterval(COleDateTimeSpan(0, 1, 0, 0));
				else
					pDayView->SetScaleInterval(
						COleDateTimeSpan(0, 0, pDayView->m_nDayViewPrintInterval, 0));

				GetCalendarCtrl().RedrawControl(TRUE);
			}
			m_dtTimeScaleOldMaxTime = pDayView->GetScaleMaxTime();
			m_dtTimeScaleOldMinTime = pDayView->GetScaleMinTime();

			if (!m_pPrintOptions->m_bPrintFromToExactly)
			{
				if (m_bPrintFullScale)
				{
					m_dtPrintFrom = pDayView->GetScaleMinTime();
					m_dtPrintTo   = pDayView->GetScaleMaxTime();
				}
				else
				{
					GetCalendarCtrl().GetWorkDayStartTime(m_dtPrintFrom);
					GetCalendarCtrl().GetWorkDayEndTime(m_dtPrintTo);
				}
			}
			else
			{
				pDayView->SetScaleMinTime(m_dtPrintFrom);
				pDayView->SetScaleMaxTime(m_dtPrintTo);
				pDayView->ScrollToWorkDayBegin();
			}
		}
	}

	if (m_bDayViewMode)
	{
		CRect rcCalendar;
		GetCalendarCtrl().GetClientRect(&rcCalendar);

		m_nStartCell = pDayView->GetCellNumber(m_dtPrintFrom, FALSE);
		m_nEndCell   = pDayView->GetCellNumber(m_dtPrintTo, TRUE);
		m_nCellSteps = pDayView->GetVisibleRowCount();
		// int iVisibleEventsMaxCount = pDayView->GetAllDayEventsMaxCount();

		int nCellCount = m_nEndCell - m_nStartCell + 1;
		m_nCurCell	 = m_nStartCell;
		double dRatio  = ((double)(nCellCount) / (double)(m_nCellSteps));
		int nMaxPage   = (int)dRatio + 1;
		pInfo->SetMaxPage(XTPToUIntChecked(nMaxPage)); // estimation only - can be adjusted later
		pInfo->m_nNumPreviewPages		= 1;
		AfxGetApp()->m_nNumPreviewPages = pInfo->m_nNumPreviewPages;
	}
	else if (m_bMonthViewMode)
	{
		pInfo->m_nNumPreviewPages = 1;

		m_dtMonthViewPrintBeginDate = m_pPrintOptions->m_dtMonthViewPrintBeginDate;
		m_dtMonthViewPrintEndDate   = m_pPrintOptions->m_dtMonthViewPrintEndDate;

		if (m_dtMonthViewPrintBeginDate.GetStatus() != COleDateTime::valid
			|| m_dtMonthViewPrintEndDate.GetStatus() != COleDateTime::valid)
		{
			m_dtMonthViewPrintBeginDate =
				GetCalendarCtrl().GetMonthView()->GetGrid()->GetBeginDate();
			m_dtMonthViewPrintEndDate = GetCalendarCtrl().GetMonthView()->GetGrid()->GetBeginDate();
		}

		UINT uPagesCount = CalculateMonthViewPrintPagesCount();
		pInfo->SetMaxPage(uPagesCount);
		pInfo->m_pPD->m_pd.nToPage		= (WORD)uPagesCount;
		AfxGetApp()->m_nNumPreviewPages = pInfo->m_nNumPreviewPages;

		m_dtSavedMonthViewBeginDate = GetCalendarCtrl().GetMonthView()->GetGrid()->GetBeginDate();
	}
	else
	{
		pInfo->m_nNumPreviewPages = 1;
		pInfo->SetMaxPage(1);
		AfxGetApp()->m_nNumPreviewPages = pInfo->m_nNumPreviewPages;
	}

	pInfo->m_nCurPage = 1;
}

UINT CXTPCalendarControlView::CalculateMonthViewPrintPagesCount()
{
	const int nWeeksPerPage = GetCalendarCtrl().GetMonthView()->GetGrid()->GetWeeksCount();
	if (nWeeksPerPage <= 0)
		return 1; // by default we show 1 empty page

	const int nDaysPerWeek = 7;

	GetCalendarCtrl().GetMonthView()->GetGrid()->SetBeginDate(m_dtMonthViewPrintBeginDate);
	COleDateTime dtRealViewBeginDate = GetCalendarCtrl().GetMonthView()->GetGrid()->GetBeginDate();

	COleDateTimeSpan dtPrintRange = m_dtMonthViewPrintEndDate - dtRealViewBeginDate;
	const int nTotalDaysInRange   = (int)dtPrintRange.GetTotalDays();
	int nPagesCount				  = nTotalDaysInRange / (nWeeksPerPage * nDaysPerWeek) + 1;
	if (nPagesCount < 1)
		nPagesCount = 1;

	return (UINT)nPagesCount;
}

void CXTPCalendarControlView::OnEndPrinting(CDC* /*pDC*/, CPrintInfo* pInfo)
{
	m_beforePrintState.Restore(this);
	m_beforePrintState.ClearData();

	m_PageStart.RemoveAll();

	if (m_bDayViewMode)
	{
		CXTPCalendarDayView* pDayView = DYNAMIC_DOWNCAST(CXTPCalendarDayView,
														 GetCalendarCtrl().GetDayView());
		if (pDayView)
		{
			pDayView->m_nCurPage = 0;
			pDayView->SetScaleMinTime(m_dtTimeScaleOldMinTime);
			pDayView->SetScaleMaxTime(m_dtTimeScaleOldMaxTime);
			pDayView->ScrollToWorkDayBegin();
			if (m_bDF_mode)
			{
				pDayView->SetScaleInterval(m_dtInitialScaleInterval);
				GetCalendarCtrl().RedrawControl(TRUE);
			}
			pDayView->ScrollV(m_nInitialTopCell, m_nInitialTopCell);
			GetCalendarCtrl().AdjustScrollBarEx(SB_VERT);
		}
	}

	if (m_bMonthViewMode) // restore original month view content
	{
		GetCalendarCtrl().GetMonthView()->GetGrid()->SetBeginDate(m_dtSavedMonthViewBeginDate);
		GetCalendarCtrl().GetMonthView()->Populate();
	}

	GetCalendarCtrl().AdjustLayout();
	GetCalendarCtrl().EnableSendNotifications();

	m_pritAdjustContext.Reset();

	m_bmpGrayDC.DeleteObject();

	SAFE_DELETE(m_pUpdateContext);

	m_bPrintFineMode  = TRUE;
	pInfo->m_nCurPage = 1;
}

CRect CXTPCalendarControlView::AdjustCalendarForPrint(CDC* pDC, CRect rcCalendar,
													  CPrintInfo* /*pInfo*/)
{
	GetCalendarCtrl().AdjustLayout(pDC, rcCalendar);

	if (m_bDayViewMode)
	{
		CXTPCalendarDayView* pDayView = DYNAMIC_DOWNCAST(CXTPCalendarDayView,
														 GetCalendarCtrl().GetDayView());
		if (pDayView)
		{
			int nCellCount = m_nEndCell - m_nCurCell + 1;
			int nCellSteps = pDayView->GetVisibleRowCount();
			int nCelHeight = pDayView->GetRowHeight();
			if (nCellCount <= nCellSteps)
				rcCalendar.bottom -= (nCellSteps - nCellCount) * nCelHeight;

			GetCalendarCtrl().AdjustLayout(pDC, rcCalendar);
			pDayView->_ScrollV(m_nCurCell, m_nCurCell);
		}
	}

	return rcCalendar;
}

void CXTPCalendarControlView::OnPrepareDC(CDC* pDC, CPrintInfo* pInfo)
{
	_ASSERTE(this);
	_ASSERTE(pDC);
	_ASSERTE(pInfo != NULL);

	pDC->SetMapMode(MM_ANISOTROPIC);
	pDC->SetViewportExt(pDC->GetDeviceCaps(LOGPIXELSX), pDC->GetDeviceCaps(LOGPIXELSY));
	pDC->SetWindowExt(96, 96);
	pDC->OffsetWindowOrg(0, 0);

	if (pInfo->m_bPreview) // PRINT MODE in RTL does not work!
	{
		//------------------------------------------------------------
		if (GetCalendarCtrl().GetExStyle() & WS_EX_RTLREADING)
			pDC->SetTextAlign(TA_RTLREADING);

		if (GetCalendarCtrl().GetExStyle() & WS_EX_LAYOUTRTL)
			XTPDrawHelpers()->SetContextRTL(pDC, LAYOUT_RTL);
		//------------------------------------------------------------
	}
}

void CXTPCalendarControlView::OnPrint(CDC* pDC, CPrintInfo* pInfo)
{
	if (!m_pPrintOptions || !pDC || !pInfo)
	{
		_ASSERTE(FALSE);
		return;
	}

	SetupCurrentPrintPage(pDC, pInfo);

	DoPrintPage(pDC, pInfo);

	SelectNextPrintPage(pInfo);
}

void CXTPCalendarControlView::SetupCurrentPrintPage(CDC* pDC, CPrintInfo* pInfo)
{
	if (m_bDayViewMode)
	{
		SetupCurrentDayViewPrintPage(pDC, pInfo);
		return;
	}

	if (m_bMonthViewMode)
	{
		SetupCurrentMonthViewPrintPage(pInfo);
		return;
	}
}

void CXTPCalendarControlView::SetupCurrentDayViewPrintPage(CDC* pDC, CPrintInfo* pInfo)
{
	if (pInfo->m_nCurPage == 1)
	{
		m_nCurCell = m_nStartCell;
		if (m_PageStart.GetSize() == 0)
			m_PageStart.Add(XTPToUIntChecked(m_nCurCell));
	}

	if (pInfo->m_bPreview) // to allow preview go back
	{
		if ((int)pInfo->m_nCurPage - 1 < m_PageStart.GetSize())
			m_nCurCell = XTPToIntChecked(
				m_PageStart.GetAt(XTPToIntPtrChecked(pInfo->m_nCurPage - 1)));
	}

	CRect rcCalendar;
	GetCalendarCtrl().GetClientRect(&rcCalendar);

	CXTPCalendarDayView* pDayView = DYNAMIC_DOWNCAST(CXTPCalendarDayView,
													 GetCalendarCtrl().GetDayView());
	if (pDayView)
	{
		pDayView->m_LayoutX.m_nTopRow = m_nCurCell;

		rcCalendar.left += pDayView->GetTimeScale()->CalcWidth(pDC) / 2;
		pDayView->m_nCurPage = (int)pInfo->m_nCurPage - 1;

		if (GetCalendarCtrl().GetTheme())
			pDayView->AdjustLayout2(pDC, rcCalendar);
		else
			pDayView->AdjustLayout(pDC, rcCalendar);
	}
}

void CXTPCalendarControlView::SetupCurrentMonthViewPrintPage(CPrintInfo* pInfo)
{
	int nZeroBasedCurPage	  = XTPToIntChecked(pInfo->m_nCurPage - 1);
	COleDateTime m_dtPeriodBeg = m_dtMonthViewPrintBeginDate;
	int nWeeksCount			   = GetCalendarCtrl().GetMonthView()->GetGrid()->GetWeeksCount();
	m_dtPeriodBeg = m_dtPeriodBeg + COleDateTimeSpan(7 * nWeeksCount * nZeroBasedCurPage, 0, 0, 0);

	GetCalendarCtrl().GetMonthView()->GetGrid()->SetBeginDate(m_dtPeriodBeg);
	GetCalendarCtrl().GetMonthView()->Populate();
}

void CXTPCalendarControlView::SelectNextPrintPage(CPrintInfo* pInfo)
{
	if (m_bDayViewMode)
	{
		SelectNextDayViewPrintPage(pInfo);
	}
	// else
	//{
	//  pInfo->m_nCurPage++;
	//}
}

void CXTPCalendarControlView::SelectNextDayViewPrintPage(CPrintInfo* pInfo)
{
	CXTPCalendarDayView* pDayView = DYNAMIC_DOWNCAST(CXTPCalendarDayView,
													 GetCalendarCtrl().GetDayView());
	if (pDayView)
		m_nCellSteps = pDayView->GetVisibleRowCount();

	if (!pInfo->m_bPreview) // print is going forward only
	{
		m_nCurCell += m_nCellSteps;

		if (m_nCurCell > m_nEndCell)
			pInfo->m_bContinuePrinting = FALSE;
		else
			pInfo->m_nCurPage++;
	}
	else // preview mode - user can switch form page to page in any direction
	{
		if (m_PageStart.GetSize() == (int)pInfo->m_nCurPage)
		{
			m_nCurCell = XTPToIntChecked(m_PageStart.GetAt(XTPToIntPtr(pInfo->m_nCurPage - 1))
										 + m_nCellSteps);
			m_PageStart.Add(XTPToUIntChecked(m_nCurCell));
		}

		if (m_nEndCell - m_nCurCell > 0) // at least one page left to print
			pInfo->m_nCurPage++;
		else
		{
			pInfo->m_bContinuePrinting = FALSE;
			pInfo->SetMaxPage(pInfo->m_nCurPage);

			//              if (pInfo->m_nCurPage >= pInfo->GetMaxPage() - 1)
			//                  pInfo->SetMaxPage(pInfo->m_nCurPage);
		}
	}
}

void CXTPCalendarControlView::DoPrintPage(CDC* pDC, CPrintInfo* pInfo)
{
	CRect rcPrint = ExcludeMarginsFromDrawRect(pDC, pInfo);

	if (!m_pPrintOptions->m_bBlackWhitePrinting && m_bPrintFineMode)
	{
		_OnPrint2(pDC, pInfo, rcPrint);
	}
	else
	{
		CRect rcPrint00(0, 0, rcPrint.Width(), rcPrint.Height());

		CDC memDC;
		VERIFY(memDC.CreateCompatibleDC(pDC));
		memDC.m_bPrinting = TRUE;

		if (!m_bmpGrayDC.m_hObject || m_bmpGrayDC.GetBitmapDimension() != rcPrint00.Size())
		{
			m_bmpGrayDC.DeleteObject();
			m_bmpGrayDC.CreateCompatibleBitmap(pDC, rcPrint00.Width(), rcPrint00.Height());
		}

		CXTPBitmapDC autoBitmap(&memDC, &m_bmpGrayDC);
		memDC.FillSolidRect(rcPrint00, RGB(255, 255, 255));

		_OnPrint2(&memDC, pInfo, rcPrint00);

		//      rcPrint00.bottom += rcPrint.top;

		int nCC = max(0, min(m_pPrintOptions->m_nBlackWhiteContrast, 255));
		XTPImageManager()->BlackWhiteBitmap(memDC, rcPrint00, nCC);

		pDC->BitBlt(rcPrint.left, rcPrint.top, rcPrint.Width(), rcPrint.Height(), &memDC, 0, 0,
					SRCCOPY); // ORIG
	}
}

CRect CXTPCalendarControlView::ExcludeMarginsFromDrawRect(CDC* pDC, CPrintInfo* pInfo)
{
	CRect rcMargins = m_pPrintOptions->GetMarginsLP(pDC);
	CRect rcPrint   = pInfo->m_rectDraw;
	rcPrint.DeflateRect(rcMargins);

	return rcPrint;
}

void CXTPCalendarControlView::_OnPrint2(CDC* pDC, CPrintInfo* pInfo, CRect rcPrint)
{
	UNREFERENCED_PARAMETER(pInfo);

	m_pritAdjustContext.m_rcHeader = rcPrint;
	m_pritAdjustContext.m_rcFooter = rcPrint;
	CString strTitle			   = CXTPPrintPageHeaderFooter::GetParentFrameTitle(this);

	m_pPrintOptions->GetPageHeader()->FormatTexts(pInfo, strTitle);
	m_pPrintOptions->GetPageFooter()->FormatTexts(pInfo, strTitle);

	if (m_bPrintFineMode)
	{
		m_pPrintOptions->GetPageFooter()->Draw(pDC, m_pritAdjustContext.m_rcFooter, TRUE);
		m_pPrintOptions->GetPageHeader()->Draw(pDC, m_pritAdjustContext.m_rcHeader);

		rcPrint.top += m_pritAdjustContext.m_rcHeader.Height();
		rcPrint.bottom -= m_pritAdjustContext.m_rcFooter.Height();
	}
	CRect rcCalendar = rcPrint;

	if (m_bPrintFineMode && m_pPrintOptions->m_bPrintDateHeader
		&& (m_bPrintRepeatHeaderFooterMode || pInfo->m_nCurPage == 1))
	{
		m_pritAdjustContext.m_rcDateHeader = rcPrint;

		DrawDateHeader(FALSE, pDC, m_pritAdjustContext.m_rcDateHeader);

		rcCalendar.top = m_pritAdjustContext.m_rcDateHeader.bottom + XTP_DPI_Y(2);
	}

	rcCalendar.DeflateRect(XTP_DPI_X(2), XTP_DPI_Y(2), XTP_DPI_X(2), XTP_DPI_Y(2));

	m_pritAdjustContext.m_rcCalendar	= AdjustCalendarForPrint(pDC, rcCalendar, pInfo);
	m_pritAdjustContext.m_rectDraw_prev = rcCalendar;

	pDC->IntersectClipRect(&m_pritAdjustContext.m_rcCalendar);

	GetCalendarCtrl().OnDraw(pDC);

	pDC->SelectClipRgn(NULL);

	CRect rcBorder = m_pritAdjustContext.m_rcCalendar;

	rcBorder.InflateRect(XTP_DPI_X(1), XTP_DPI_Y(1), XTP_DPI_X(1), XTP_DPI_Y(1));
	pDC->Draw3dRect(&rcBorder, 0, 0);

	rcBorder.InflateRect(XTP_DPI_X(1), XTP_DPI_Y(1), XTP_DPI_X(1), XTP_DPI_Y(1));
	pDC->Draw3dRect(&rcBorder, 0, 0);

	if (m_bPrintFineMode)
		m_pPrintOptions->GetPageFooter()->Draw(pDC, m_pritAdjustContext.m_rcFooter);
}

void CXTPCalendarControlView::DrawDateHeader(BOOL bCalculate, CDC* pDC, CRect& rrcHeader)
{
	COleDateTime dtYearMonth1, dtYearMonth2;
	CString strHeader1, strHeader2, strHeaderWeekDay;

	int nMonths = _GetDateHeaderMonths(dtYearMonth1, dtYearMonth2, strHeader1, strHeader2,
									   strHeaderWeekDay);

	if (!strHeader2.IsEmpty())
		strHeader1 += _T(" -");

	CRect rcCalendar1 = rrcHeader;
	CRect rcCalendar2(0, 0, 0, 0);
	CRect rcCalendar3(0, 0, 0, 0);

	BOOL bRTL = GetCalendarCtrl().IsLayoutRTL();

	int iYear  = dtYearMonth1.GetYear();
	int iMonth = dtYearMonth1.GetMonth();
	if (nMonths == 1 && m_pPrintOptions->m_b3SmallCal)
	{
		if (bRTL)
		{
			if (iMonth > 1)
				iMonth--;
			else
			{
				iMonth = 12;
				iYear--;
			}
			dtYearMonth1.SetDateTime(iYear, iMonth, 1, 0, 0, 0);
		}
		else
		{
			if (iMonth < 12)
				iMonth++;
			else
			{
				iMonth = 1;
				iYear++;
			}
			dtYearMonth1.SetDateTime(iYear, iMonth, 1, 0, 0, 0);
		}
	}

	_DrawDateHeaderCalendar(TRUE, pDC, dtYearMonth1, rcCalendar1);

	int nCalendar1XPos = rrcHeader.right - rcCalendar1.Width() * 11 / 10;
	int nCalendar2XPos = nCalendar1XPos;

	CXTPFont fntDateHeader;
	CXTPFont fntDateHeaderWeekDay;

	VERIFY(fntDateHeader.CreateFontIndirect(&m_pPrintOptions->m_lfDateHeaderFont));
	CXTPFontDC fntDC(pDC, &fntDateHeader);
	CSize sizeText = pDC->GetTextExtent(strHeader1);

	VERIFY(fntDateHeaderWeekDay.CreateFontIndirect(&m_pPrintOptions->m_lfDateHeaderWeekDayFont));
	fntDC.SetFont(&fntDateHeaderWeekDay);
	CSize sizeTextWD = pDC->GetTextExtent(_T("WD"), 2);

	int nDatesCaptionHeight = sizeText.cy * 225 / 100 + sizeTextWD.cy * 125 / 100;
	int nMaxHeight			= max(rcCalendar1.Height() * 11 / 10, nDatesCaptionHeight);

	rrcHeader.bottom = rrcHeader.top + nMaxHeight;

	int nCalendarYPos = rrcHeader.top + nMaxHeight / 2 - rcCalendar1.Height() / 2;
	MoveRectToXY(rcCalendar1, nCalendar1XPos, nCalendarYPos);

	if (bCalculate)
		return;

	COLORREF clrPrev = pDC->SetTextColor(0);
	int nBkModePrev  = pDC->SetBkMode(TRANSPARENT);

	if (nMonths > 1)
	{
		rcCalendar2	= rcCalendar1;
		nCalendar2XPos = nCalendar1XPos - rcCalendar1.Width() * 11 / 10;
		MoveRectToXY(rcCalendar1, nCalendar2XPos, nCalendarYPos);
	}

	if (!m_pPrintOptions->m_bBlackWhitePrinting)
		pDC->FillSolidRect(&rrcHeader, RGB(229, 229, 229));

	pDC->Draw3dRect(&rrcHeader, 0, 0);

	_DrawDateHeaderCalendar(bCalculate, pDC, dtYearMonth1, rcCalendar1);

	if (nMonths > 1)
		_DrawDateHeaderCalendar(FALSE, pDC, dtYearMonth2, rcCalendar2);

	if (nMonths == 1 && m_pPrintOptions->m_b3SmallCal)
	{
		rcCalendar2	= rcCalendar1;
		nCalendar2XPos = nCalendar1XPos - rcCalendar1.Width() * 11 / 10;
		MoveRectToXY(rcCalendar2, nCalendar2XPos, nCalendarYPos);

		if (bRTL)
		{
			if (iMonth < 12)
				iMonth++;
			else
			{
				iMonth = 1;
				iYear++;
			}
			dtYearMonth1.SetDateTime(iYear, iMonth, 1, 0, 0, 0);
		}
		else
		{
			if (iMonth > 1)
				iMonth--;
			else
			{
				iMonth = 12;
				iYear--;
			}
			dtYearMonth1.SetDateTime(iYear, iMonth, 1, 0, 0, 0);
		}

		_DrawDateHeaderCalendar(bCalculate, pDC, dtYearMonth1, rcCalendar2);

		rcCalendar3	= rcCalendar2;
		nCalendar2XPos = nCalendar2XPos - rcCalendar2.Width() * 11 / 10;
		MoveRectToXY(rcCalendar3, nCalendar2XPos, nCalendarYPos);

		if (bRTL)
		{
			if (iMonth < 12)
				iMonth++;
			else
			{
				iMonth = 1;
				iYear++;
			}
			dtYearMonth1.SetDateTime(iYear, iMonth, 1, 0, 0, 0);
		}
		else
		{
			if (iMonth > 1)
				iMonth--;
			else
			{
				iMonth = 12;
				iYear--;
			}
			dtYearMonth1.SetDateTime(iYear, iMonth, 1, 0, 0, 0);
		}

		_DrawDateHeaderCalendar(bCalculate, pDC, dtYearMonth1, rcCalendar3);
	}

	CRect rcHeader1(0, 0, 0, 0);
	CRect rcHeader2(0, 0, 0, 0);
	CRect rcHeader3(0, 0, 0, 0);

	rcHeader1 = rrcHeader;
	rcHeader1.DeflateRect(XTP_DPI_X(10), XTP_DPI_Y(5), XTP_DPI_X(10), XTP_DPI_Y(5));
	rcHeader1.right = nCalendar2XPos - XTP_DPI_X(20);

	rcHeader2 = rcHeader1;

	fntDC.SetFont(&fntDateHeader);

	UINT uDrawFlags = DT_TOP | DT_LEFT | DT_WORDBREAK | DT_NOPREFIX;
	int nHeight1	= pDC->DrawText(strHeader1, &rcHeader1, uDrawFlags);

	if (!strHeader2.IsEmpty())
	{
		rcHeader2.top += nHeight1 + sizeText.cy / 4;
		if (rcHeader2.top < rcHeader2.bottom)
			pDC->DrawText(strHeader2, &rcHeader2, uDrawFlags);
	}

	if (!strHeaderWeekDay.IsEmpty())
	{
		fntDC.SetFont(&fntDateHeaderWeekDay);

		rcHeader3 = rcHeader2;
		rcHeader3.top += nHeight1 + sizeTextWD.cy / 5;

		if (rcHeader3.top < rcHeader3.bottom)
			pDC->DrawText(strHeaderWeekDay, &rcHeader3, uDrawFlags);
	}

	pDC->SetTextColor(clrPrev);
	pDC->SetBkMode(nBkModePrev);
}

void CXTPCalendarControlView::_DrawDateHeaderCalendar(BOOL bCalculate, CDC* pDC,
													  COleDateTime dtYearMonth,
													  CRect& rrcHeaderCalendar)
{
	ASSERT_VALID(pDC);

	LOGFONT lfCalWeek  = m_pPrintOptions->m_lfDateHeaderCalendarFont;
	lfCalWeek.lfHeight = lfCalWeek.lfHeight * 8 / 10;
	CXTPFont fntCalendarWeek;
	VERIFY(fntCalendarWeek.CreateFontIndirect(&lfCalWeek));

	CXTPFont fntCalendar;
	VERIFY(fntCalendar.CreateFontIndirect(&m_pPrintOptions->m_lfDateHeaderCalendarFont));
	CXTPFontDC fntDC(pDC, &fntCalendar);

	CSize sizeCellText = pDC->GetTextExtent(_T("88"), 2);

	CSize sizeCell = sizeCellText;
	sizeCell.cx	= sizeCell.cx * 13 / 10;
	sizeCell.cy	= sizeCell.cy * 11 / 10;
	int nMonthRowY = sizeCellText.cy;
	int nWSaysRowY = sizeCellText.cy * 13 / 10;

	rrcHeaderCalendar.right  = rrcHeaderCalendar.left + sizeCell.cx * 9;
	rrcHeaderCalendar.bottom = rrcHeaderCalendar.top + nMonthRowY + nWSaysRowY + sizeCell.cy * 6;
	if (bCalculate)
		return;

	int nFirstDayOfWeek = GetCalendarCtrl().GetFirstDayOfWeek();

	COleDateTime dtMonthFirst = dtYearMonth;
	VERIFY(CXTPCalendarUtils::UpdateMonthDay(dtMonthFirst, 1));
	int nMaxMonthDay = CXTPCalendarUtils::GetMaxMonthDay(dtYearMonth);

	CStringArray arWDNames;
	int i;
	for (i = 0; i < 7; i++)
	{
		CString sWD = CXTPCalendarUtils::GetLocaleString(
			XTPToUInt(CXTPCalendarUtils::GetDayOfWeekLocaleStringId(((i - 1 + 7) % 7) + 1)), 100);

		// RTL case fix
		if (GetCalendarCtrl().IsLayoutRTL())
		{
			if (sWD.Find(_T(" ")) > -1)
				sWD = sWD.Right(1);
			else
				sWD = sWD.Left(1);
		}

		arWDNames.Add(sWD);
	}
	int nMonth = dtYearMonth.GetMonth();
	int nYear  = dtYearMonth.GetYear();
	CString strMonthName =
		CXTPCalendarUtils::GetLocaleString(XTPToUInt(LOCALE_SMONTHNAME1 + nMonth - 1), 100);
	CString strMonthYear;
	strMonthYear.Format(_T("%s  %d"), (LPCTSTR)strMonthName, nYear);

	COLORREF clrPrev = pDC->SetTextColor(0);
	int nBkModePrev  = pDC->SetBkMode(TRANSPARENT);

	CRect rcText = rrcHeaderCalendar;
	rcText.left += sizeCell.cx;
	pDC->DrawText(strMonthYear, &rcText, DT_TOP | DT_CENTER | DT_SINGLELINE);

	rcText = rrcHeaderCalendar;
	rcText.top += sizeCell.cy;
	for (i = 0; i < 7; i++)
	{
		rcText.left += sizeCell.cx;
		rcText.right = rcText.left + sizeCell.cx;

		int nMidx	 = (nFirstDayOfWeek - 1 + i) % 7;
		CString strWD = arWDNames[nMidx];

		pDC->DrawText((LPCTSTR)strWD, 1, &rcText, DT_TOP | DT_RIGHT | DT_SINGLELINE);
	}

	CRect rcLine1 = rrcHeaderCalendar;
	rcLine1.left += sizeCell.cx - 0;
	rcLine1.top += nMonthRowY + nWSaysRowY - XTP_DPI_Y(1);
	rcLine1.bottom = rcLine1.top + XTP_DPI_Y(1);

	CRect rcLine2 = rrcHeaderCalendar;
	rcLine2.left  = rcLine1.left;
	rcLine2.right = rcLine2.left + XTP_DPI_X(1);
	rcLine2.top   = rcLine1.top;

	pDC->FillSolidRect(&rcLine1, 0);
	pDC->FillSolidRect(&rcLine2, 0);

	int nDay = 1 - (dtMonthFirst.GetDayOfWeek() - nFirstDayOfWeek + 7) % 7;

	int nFirstWeekOfYearDays = GetCalendarCtrl().GetFirstWeekOfYearDays();
	// int nFirstWeekOfYearDays = 1;
	COleDateTimeSpan spFWofY(nFirstWeekOfYearDays - 1);
	COleDateTime dtWeekLast = dtMonthFirst + COleDateTimeSpan(nDay + 6 - 1);
	int nFirstWeekNumber	= ((dtWeekLast - spFWofY).GetDayOfYear() - 1) / 7 + 1;

	//--------------------------
	int nTodayDay_toMark = 0;
	COleDateTime dtToday = CXTPCalendarUtils::GetCurrentTime();
	if (dtYearMonth.GetYear() == dtToday.GetYear() && dtYearMonth.GetMonth() == dtToday.GetMonth())
		nTodayDay_toMark = dtToday.GetDay();

	CString strDay, strWeek;
	for (int w = 0; w < 6; w++)
	{
		rcText.top = rrcHeaderCalendar.top + nMonthRowY + nWSaysRowY + sizeCell.cy * w;

		if (nDay <= nMaxMonthDay)
		{
			CRect rcWeek = rcText;
			rcWeek.left  = rrcHeaderCalendar.left;
			rcWeek.right = rcWeek.left + sizeCell.cx - XTP_DPI_X(2);
			int iw		 = nFirstWeekNumber + w;

			if (nMonth == 1 && w == 1 && iw > 52)
				iw = 1;
			if (iw > 53)
				iw = iw % 53;
			strWeek.Format(_T("%d"), iw);

			CXTPFontDC fntDCweek(pDC, &fntCalendarWeek);
			pDC->DrawText(strWeek, &rcWeek, DT_TOP | DT_RIGHT | DT_SINGLELINE);
		}

		for (i = 0; i < 7; i++)
		{
			if (nDay > 0 && nDay <= nMaxMonthDay)
			{
				rcText.left  = rrcHeaderCalendar.left + sizeCell.cx * (i + 1);
				rcText.right = rcText.left + sizeCell.cx;

				strDay.Format(_T("%d"), nDay);

				pDC->DrawText(strDay, &rcText, DT_TOP | DT_RIGHT | DT_SINGLELINE);

				if (nDay == nTodayDay_toMark)
				{
					CRect rcToday = rcText;
					rcToday.left += max(XTP_DPI_X(1), sizeCell.cx / 10);
					rcToday.right += max(XTP_DPI_X(1), sizeCell.cx / 10);
					rcToday.bottom = rcToday.top + sizeCell.cy;

					CBrush brFrame(RGB(82, 82, 82));
					pDC->FrameRect(&rcToday, &brFrame);
					brFrame.DeleteObject();
				}
			}
			nDay++;
		}
	}

	pDC->SetTextColor(clrPrev);
	pDC->SetBkMode(nBkModePrev);
}

int CXTPCalendarControlView::_GetDateHeaderMonths(COleDateTime& dtYearMonth1,
												  COleDateTime& dtYearMonth2, CString& strHeader1,
												  CString& strHeader2, CString& strHeaderWeekDay)
{
	strHeader1 = strHeader2 = strHeaderWeekDay = _T("");
	dtYearMonth1 = dtYearMonth2 = (DATE)0;

	SYSTEMTIME st;

	BOOL b		  = GetCalendarCtrl().m_bMultiColumnWeekMode;
	int nViewType = GetCalendarCtrl().GetActiveView()->GetViewType();
	if (nViewType == xtpCalendarDayView || (b && nViewType == xtpCalendarWeekView)
		|| nViewType == xtpCalendarWorkWeekView || (b && nViewType == xtpCalendarFullWeekView))
	{
		CXTPCalendarDayView* pDayView = DYNAMIC_DOWNCAST(CXTPCalendarDayView,
														 GetCalendarCtrl().GetDayView());
		if (!pDayView)
			return 0;

		dtYearMonth1 = pDayView->GetViewDayDate(0);
		CXTPCalendarUtils::GetAsSystemTime(dtYearMonth1, st);
		strHeader1 = CXTPCalendarUtils::GetDateFormat(&st, _T("d MMMM"));

		int nCount = pDayView->GetViewDayCount();
		if (nCount > 1)
		{
			dtYearMonth2 = pDayView->GetViewDayDate(nCount - 1);
			CXTPCalendarUtils::GetAsSystemTime(dtYearMonth2, st);
			strHeader2 = CXTPCalendarUtils::GetDateFormat(&st, _T("d MMMM"));

			if (dtYearMonth1.GetMonth() != dtYearMonth2.GetMonth())
				return 2;
		}

		if (nCount == 1)
		{
			COleDateTime dtDay0 = pDayView->GetViewDayDate(0);
			int nWd				= dtDay0.GetDayOfWeek();
			int nWdShift		= (nWd - 1 + 6) % 7;
			strHeaderWeekDay =
				CXTPCalendarUtils::GetLocaleString(XTPToUInt(LOCALE_SDAYNAME1 + nWdShift), 100);
		}

		return 1;
	}
	else if (nViewType == xtpCalendarWeekView || (!b && nViewType == xtpCalendarFullWeekView))
	{
		CXTPCalendarView* pView = GetCalendarCtrl().GetActiveView();
		if (!pView)
			return 0;

		dtYearMonth1 = pView->GetViewDayDate(0);
		dtYearMonth2 = pView->GetViewDayDate(pView->GetViewDayCount() - 1);

		CString strHeaderFormat = pView->GetDayHeaderFormat();
		if (strHeaderFormat.IsEmpty())
			strHeaderFormat = _T("d MMMM");

		CXTPCalendarUtils::GetAsSystemTime(dtYearMonth1, st);
		strHeader1 = CXTPCalendarUtils::GetDateFormat(&st, strHeaderFormat);

		CXTPCalendarUtils::GetAsSystemTime(dtYearMonth2, st);
		strHeader2 = CXTPCalendarUtils::GetDateFormat(&st, strHeaderFormat);

		return 1;
	}
	else if (nViewType == xtpCalendarMonthView)
	{
		CXTPCalendarMonthView* pMonthView = DYNAMIC_DOWNCAST(CXTPCalendarMonthView,
															 GetCalendarCtrl().GetMonthView());

		if (!pMonthView || !pMonthView->GetGrid())
			return 0;

		int nWeeksCount = pMonthView->GetGrid()->GetWeeksCount();
		_ASSERTE(nWeeksCount);
		if (nWeeksCount)
		{
			CXTPCalendarViewDay* pMVday1 =
				(CXTPCalendarViewDay*)pMonthView->GetGrid()->GetViewDay(0, 6);
			CXTPCalendarViewDay* pMVday2 =
				(CXTPCalendarViewDay*)pMonthView->GetGrid()->GetViewDay(nWeeksCount - 1, 0);
			if (pMVday1 && pMVday2)
			{
				dtYearMonth1 = pMVday1->GetDayDate();

				CXTPCalendarUtils::GetAsSystemTime(dtYearMonth1, st);
				strHeader1 = CXTPCalendarUtils::GetDateFormat(&st, _T("MMMM yyyy"));

				COleDateTime dtLast = pMVday2->GetDayDate();
				if (dtYearMonth1.GetMonth() != dtLast.GetMonth())
				{
					dtYearMonth2 = dtLast;
					CXTPCalendarUtils::GetAsSystemTime(dtYearMonth2, st);
					strHeader2 = CXTPCalendarUtils::GetDateFormat(&st, _T("MMMM yyyy"));
					return 2;
				}
				return 1;
			}
		}
	}
	return 0;
}

CRect AFX_CDECL CXTPCalendarControlView::_HimetricToLP(CDC* pDC, const CRect rcHimetric)
{
	CSize szLT(rcHimetric.left, rcHimetric.top);
	CSize szRB(rcHimetric.right, rcHimetric.bottom);

	pDC->HIMETRICtoLP(&szLT);
	pDC->HIMETRICtoLP(&szRB);

	CRect rcLP(szLT.cx, szLT.cy, szRB.cx, szRB.cy);

	return rcLP;
}

//////////////////////////////////////////////////////////////////////////
// Clipboard operations

void CXTPCalendarControlView::OnUndo()
{
	GetCalendarCtrl().OnUndo();
}

void CXTPCalendarControlView::OnCut()
{
	CWnd* pFocusWnd = GetFocus();
	if (pFocusWnd)
	{
		LRESULT lRes = pFocusWnd->SendMessage(WM_COMMAND, ID_EDIT_CUT, NULL);
		if (!lRes)
			pFocusWnd->SendMessage(WM_CUT);
	}
}

void CXTPCalendarControlView::OnSelectAll()
{
	CWnd* pFocusWnd = GetFocus();
	if (pFocusWnd)
	{
		LRESULT lRes = pFocusWnd->SendMessage(WM_COMMAND, ID_EDIT_SELECT_ALL, NULL);
		if (!lRes && pFocusWnd->IsKindOf(RUNTIME_CLASS(CEdit)))
			((CEdit*)pFocusWnd)->SetSel(0, -1);
	}
}

void CXTPCalendarControlView::OnCopy()
{
	CWnd* pFocusWnd = GetFocus();
	if (pFocusWnd)
	{
		LRESULT lRes = pFocusWnd->SendMessage(WM_COMMAND, ID_EDIT_COPY, NULL);
		if (!lRes)
			pFocusWnd->SendMessage(WM_COPY);
	}
}

void CXTPCalendarControlView::OnPaste()
{
	CWnd* pFocusWnd = GetFocus();
	if (pFocusWnd)
	{
		LRESULT lRes = pFocusWnd->SendMessage(WM_COMMAND, ID_EDIT_PASTE, NULL);
		if (!lRes)
			pFocusWnd->SendMessage(WM_PASTE);
	}
}

void CXTPCalendarControlView::OnUpdateCommand(CCmdUI* pCmdUI)
{
	GetCalendarCtrl().OnUpdateCmdUI(pCmdUI);
}

void CXTPCalendarControlView::OnFilePageSetup()
{
	DWORD dwFlags = PSD_MARGINS | PSD_INWININIINTLMEASURE;
	CXTPCalendarPageSetupDialog dlgPageSetup(GetPrintOptions(), dwFlags, this);

	XTPGetPrinterDeviceDefaults(dlgPageSetup.m_psd.hDevMode, dlgPageSetup.m_psd.hDevNames);

	int nDlgRes = (int)dlgPageSetup.DoModal();

	if (nDlgRes == IDOK)
		AfxGetApp()->SelectPrinter(dlgPageSetup.m_psd.hDevNames, dlgPageSetup.m_psd.hDevMode,
								   FALSE);
}

void CXTPCalendarControlView::CalendarDayView_ScrolV(int nTopRow)
{
	CXTPCalendarDayView* pDayView = DYNAMIC_DOWNCAST(CXTPCalendarDayView,
													 GetCalendarCtrl().GetDayView());
	_ASSERTE(pDayView);
	if (pDayView)
		pDayView->_ScrollV(nTopRow, nTopRow);
}

#ifdef _XTP_ACTIVEX

LPFONTDISP AxCreateOleFont(const LOGFONT& logFont, CObject* pParent, LPFNFONTCHANGED lpFontChanged);

#	define DISP_PROPERTY_2EX_ID(theClass, szExternalName, dispid, vtPropType)                     \
		DISP_PROPERTY_EX_ID(theClass, #szExternalName, dispid, OleGet##szExternalName,             \
							OleSet##szExternalName, vtPropType)

BEGIN_DISPATCH_MAP(CXTPCalendarControlViewPrintOptions, CXTPPrintOptions)

	DISP_PROPERTY_ID(CXTPCalendarControlViewPrintOptions, "PrintFrom", 11, m_dtPrintFrom, VT_DATE)
	DISP_PROPERTY_ID(CXTPCalendarControlViewPrintOptions, "PrintTo", 12, m_dtPrintTo, VT_DATE)
	DISP_PROPERTY_ID(CXTPCalendarControlViewPrintOptions, "PrintFromToExactly", 13,
					 m_bPrintFromToExactly, VT_BOOL)
	DISP_PROPERTY_ID(CXTPCalendarControlViewPrintOptions, "ThreeSmallCal", 14, m_b3SmallCal,
					 VT_BOOL)
	DISP_PROPERTY_ID(CXTPCalendarControlViewPrintOptions, "MonthViewPrintBeginDate", 24,
					 m_dtMonthViewPrintBeginDate, VT_DATE)
	DISP_PROPERTY_ID(CXTPCalendarControlViewPrintOptions, "MonthViewPrintEndDate", 25,
					 m_dtMonthViewPrintEndDate, VT_DATE)

	DISP_PROPERTY_ID(CXTPCalendarControlViewPrintOptions, "PrintDateHeader", 21, m_bPrintDateHeader,
					 VT_BOOL)
	DISP_PROPERTY_2EX_ID(CXTPCalendarControlViewPrintOptions, DateHeaderFont, 22, VT_FONT)
	DISP_PROPERTY_2EX_ID(CXTPCalendarControlViewPrintOptions, DateHeaderWeekDayFont, 26, VT_FONT)
	DISP_PROPERTY_2EX_ID(CXTPCalendarControlViewPrintOptions, DateHeaderCalendarFont, 23, VT_FONT)

END_DISPATCH_MAP()

BEGIN_INTERFACE_MAP(CXTPCalendarControlViewPrintOptions, CXTPPrintOptions)
	INTERFACE_PART(CXTPCalendarControlViewPrintOptions, XTPDIID_CalendarPrintOptions, Dispatch)
END_INTERFACE_MAP()

IMPLEMENT_OLETYPELIB_EX(CXTPCalendarControlViewPrintOptions, XTPDIID_CalendarPrintOptions)

LPFONTDISP CXTPCalendarControlViewPrintOptions::OleGetDateHeaderFont()
{
	return AxCreateOleFont(
		m_lfDateHeaderFont, this,
		(LPFNFONTCHANGED)&CXTPCalendarControlViewPrintOptions::OleSetDateHeaderFont);
}

void CXTPCalendarControlViewPrintOptions::OleSetDateHeaderFont(LPFONTDISP pFontDisp)
{
	VERIFY(AxGetLogFont(m_lfDateHeaderFont, pFontDisp));
}

LPFONTDISP CXTPCalendarControlViewPrintOptions::OleGetDateHeaderWeekDayFont()
{
	return AxCreateOleFont(
		m_lfDateHeaderWeekDayFont, this,
		(LPFNFONTCHANGED)&CXTPCalendarControlViewPrintOptions::OleSetDateHeaderWeekDayFont);
}

void CXTPCalendarControlViewPrintOptions::OleSetDateHeaderWeekDayFont(LPFONTDISP pFontDisp)
{
	VERIFY(AxGetLogFont(m_lfDateHeaderWeekDayFont, pFontDisp));
}

LPFONTDISP CXTPCalendarControlViewPrintOptions::OleGetDateHeaderCalendarFont()
{
	return AxCreateOleFont(
		m_lfDateHeaderCalendarFont, this,
		(LPFNFONTCHANGED)&CXTPCalendarControlViewPrintOptions::OleSetDateHeaderCalendarFont);
}

void CXTPCalendarControlViewPrintOptions::OleSetDateHeaderCalendarFont(LPFONTDISP pFontDisp)
{
	VERIFY(AxGetLogFont(m_lfDateHeaderCalendarFont, pFontDisp));
}

#endif