// CalendarDemoView.cpp
//
// (c)1998-2025 Codejock Software, All Rights Reserved.
//
// THIS SOURCE FILE IS THE PROPERTY OF CODEJOCK SOFTWARE AND IS NOT TO BE
// RE-DISTRIBUTED BY ANY MEANS WHATSOEVER WITHOUT THE EXPRESSED WRITTEN
// CONSENT OF CODEJOCK SOFTWARE.
//
// THIS SOURCE CODE CAN ONLY BE USED UNDER THE TERMS AND CONDITIONS OUTLINED
// IN THE XTREME TOOLKIT PRO LICENSE AGREEMENT. CODEJOCK SOFTWARE GRANTS TO
// YOU (ONE SOFTWARE DEVELOPER) THE LIMITED RIGHT TO USE THIS SOFTWARE ON A
// SINGLE COMPUTER.
//
// CONTACT INFORMATION:
// support@codejock.com
// http://www.codejock.com
//
/////////////////////////////////////////////////////////////////////////////

#include "stdafx.h"
#include "CalendarDemo.h"

#include "MainFrm.h"
#include "CalendarDemoDoc.h"
#include "CalendarDemoView.h"
#include "DataProvidersOptions.h"
#include "AdvancedCalendarOptionsDlg.h"
#include "CalendarEventColorDlg.h"

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

//////////////////////////////////////////////////////////////////////////
extern CString GetDPName(int nDPType);
extern int GetDPType(CXTPCalendarData* pData);

//////////////////////////////////////////////////////////////////////////
static CXTPCalendarRemindersDialog* s_pDlgReminders = NULL;

CString cstrMarkupDynamicSample(
	_T("<StackPanel Margin='2, 2, 2, 2' VerticalAlignment='Top' HorizontalAlignment='Center'>")
	_T("<TextBlock Padding='0,10,0,0' TextWrapping='Wrap'>")
	_T("<Italic>Dynamically Customized ")
	_T("Subject:</Italic><Bold>/Calendar/Events/Event/Subject</Bold></TextBlock>")
	_T("<TextBlock Padding='0,10,0,0'>Dynamically Customized Body:</TextBlock>")
	_T("<TextBlock Padding='10,10,0,0' TextWrapping='Wrap'>")
	_T("/Calendar/Events/Event/Body")
	_T("</TextBlock>")
	_T("<TextBlock Padding='10,10,0,0'> - Regards</TextBlock>")
	_T("</StackPanel>"));

/////////////////////////////////////////////////////////////////////////////
// CCalendarDemoView

IMPLEMENT_DYNCREATE(CCalendarDemoView, CXTPCalendarControlView)

BEGIN_MESSAGE_MAP(CCalendarDemoView, CXTPCalendarControlView)
	//{{AFX_MSG_MAP(CCalendarDemoView)
	ON_WM_CREATE()
	//}}AFX_MSG_MAP
	// Standard printing commands
	ON_COMMAND(ID_FILE_PAGE_SETUP, CXTPCalendarControlView::OnFilePageSetup)
	ON_COMMAND(ID_FILE_PRINT, CXTPCalendarControlView::OnFilePrint)
	ON_COMMAND(ID_FILE_PRINT_PREVIEW, OnFilePrintPreview)

	ON_COMMAND(ID_FILE_SAVE, OnFileSave)
	ON_COMMAND(ID_FILE_SAVE_AS, OnFileSaveAs)

	ON_UPDATE_COMMAND_UI(ID_FILE_SAVE, OnUpdateFileSave)
	ON_UPDATE_COMMAND_UI(ID_FILE_SAVE_AS, OnUpdateFileSaveAs)
	// User commands
	ON_COMMAND(ID_VIEW_REMINDERS, OnViewReminders)
	ON_UPDATE_COMMAND_UI(ID_VIEW_REMINDERS, OnUpdateViewReminders)

	ON_COMMAND(ID_CALENDAR_VIEW_DAY, OnCalendarViewDay)
	ON_COMMAND(ID_CALENDAR_VIEW_WORKWEEK, OnCalendarViewWorkWeek)
	ON_COMMAND(ID_CALENDAR_VIEW_WEEK, OnCalendarViewWeek)
	ON_COMMAND(ID_CALENDAR_VIEW_MONTH, OnCalendarViewMonth)
	ON_COMMAND(ID_CALENDAR_VIEW_SCHEDULE, OnCalendarTimeline)
	ON_UPDATE_COMMAND_UI(ID_CALENDAR_VIEW_DAY, OnUpdateCalendarViewDay)
	ON_UPDATE_COMMAND_UI(ID_CALENDAR_VIEW_WORKWEEK, OnUpdateCalendarViewWorkWeek)
	ON_UPDATE_COMMAND_UI(ID_CALENDAR_VIEW_WEEK, OnUpdateCalendarViewWeek)
	ON_UPDATE_COMMAND_UI(ID_CALENDAR_VIEW_MONTH, OnUpdateCalendarViewMonth)
	ON_UPDATE_COMMAND_UI(ID_CALENDAR_VIEW_SCHEDULE, OnUpdateCalendarTimeline)

	ON_COMMAND(ID_CALENDAR_CHANGETIMESCALE_60MINUTES, OnCalendarTimescale60)
	ON_COMMAND(ID_CALENDAR_CHANGETIMESCALE_30MINUTES, OnCalendarTimescale30)
	ON_COMMAND(ID_CALENDAR_CHANGETIMESCALE_15MINUTES, OnCalendarTimescale15)
	ON_COMMAND(ID_CALENDAR_CHANGETIMESCALE_10MINUTES, OnCalendarTimescale10)
	ON_COMMAND(ID_CALENDAR_CHANGETIMESCALE_6MINUTES, OnCalendarTimescale6)
	ON_COMMAND(ID_CALENDAR_CHANGETIMESCALE_5MINUTES, OnCalendarTimescale5)
	ON_UPDATE_COMMAND_UI(ID_CALENDAR_CHANGETIMESCALE_60MINUTES, OnUpdateCalendarTimescale60)
	ON_UPDATE_COMMAND_UI(ID_CALENDAR_CHANGETIMESCALE_30MINUTES, OnUpdateCalendarTimescale30)
	ON_UPDATE_COMMAND_UI(ID_CALENDAR_CHANGETIMESCALE_15MINUTES, OnUpdateCalendarTimescale15)
	ON_UPDATE_COMMAND_UI(ID_CALENDAR_CHANGETIMESCALE_10MINUTES, OnUpdateCalendarTimescale10)
	ON_UPDATE_COMMAND_UI(ID_CALENDAR_CHANGETIMESCALE_6MINUTES, OnUpdateCalendarTimescale6)
	ON_UPDATE_COMMAND_UI(ID_CALENDAR_CHANGETIMESCALE_5MINUTES, OnUpdateCalendarTimescale5)

	ON_COMMAND(ID_CALENDAR_CHANGETIMESCALE_CHANGETIMEZONE, OnCalendarTimezone)
	ON_COMMAND(ID_CALENDAR_ADD_NEW_EVENT, OnAddNewEvent)

	ON_COMMAND(ID_CALENDAR_GOTO_TODAY, OnGoToToday)

	//	ON_COMMAND(ID_CALENDAR_LANGUAGE_RUSSIAN,  OnCalendarLangRussian)
	//	ON_COMMAND(ID_CALENDAR_LANGUAGE_DEFAULT,  OnCalendarLangDefault)

	ON_BN_CLICKED(IDC_TIME_ZONE_BTN, OnCalendarTimezone)
	ON_BN_CLICKED(IDC_ADVANCED_OPT_BTN, OnAdvancedOptions)

	ON_COMMAND(ID_CATEGORIES_ADDTEST, OnAddTestCategory)
	ON_UPDATE_COMMAND_UI(ID_CATEGORIES_ADDTEST, OnUpdateAddTestCategory)

	ON_COMMAND_RANGE(ID_CATEGORIES_ALLCATEGORIES, ID_CATEGORIES_ALLCATEGORIESANDLABELS,
					 OnCategories)

	ON_COMMAND(ID_CALENDAR_MEETING_OPEN, OnCalendarMeetingOpen)
	ON_COMMAND(ID_CALENDAR_MEETING_DELETE, OnCalendarMeetingDelete)
	ON_COMMAND(ID_CALENDAR_MEETING_PRIVATE, OnCalendarMeetingPrivate)
	ON_COMMAND(ID_CALENDAR_MEETING_MEETING, OnCalendarMeetingMeeting)
	ON_COMMAND(ID_CALENDAR_MEETING_REMINDER, OnCalendarMeetingReminder)

	ON_UPDATE_COMMAND_UI(ID_CALENDAR_MEETING_PRIVATE, OnUpdateCalendarMeetingPrivate)
	ON_UPDATE_COMMAND_UI(ID_CALENDAR_MEETING_MEETING, OnUpdateCalendarMeetingMeeting)
	ON_UPDATE_COMMAND_UI(ID_CALENDAR_MEETING_REMINDER, OnUpdateCalendarMeetingReminder)

END_MESSAGE_MAP()

/////////////////////////////////////////////////////////////////////////////
// CCalendarDemoView construction/destruction

CCalendarDemoView::CCalendarDemoView()
{
	m_dsDayViewDays.SetDateTimeSpan(4, 0, 0, 0);

	SetCalendarCtrl(&m_wndCalendarEx, FALSE);

	// Advise To Notifications
	CXTPNotifyConnection* ptrCalendarConn = GetCalendarCtrl().GetConnection();
	_ASSERTE(ptrCalendarConn);

	if (!ptrCalendarConn)
		return;

	m_nScale = -1;

	m_Sink.Advise(ptrCalendarConn, XTP_NC_CALENDARCONTEXTMENU,
				  &CCalendarDemoView::OnEvent_Calendar);
	m_Sink.Advise(ptrCalendarConn, XTP_NC_CALENDARLBUTTONDBLCLICK,
				  &CCalendarDemoView::OnEvent_Calendar);
	m_Sink.Advise(ptrCalendarConn, XTP_NC_CALENDARKEYDOWN, &CCalendarDemoView::OnEvent_Calendar);

	m_Sink.Advise(ptrCalendarConn, XTP_NC_CALENDAR_IS_EVENT_EDIT_OPERATION_DISABLED,
				  &CCalendarDemoView::OnEvent_IsEditActionDisabled);
	m_Sink.Advise(ptrCalendarConn, XTP_NC_CALENDAR_BEFORE_EVENT_EDIT_OPERATION,
				  &CCalendarDemoView::OnEvent_BeforeEditAction);

	m_Sink.Advise(ptrCalendarConn, XTP_NC_CALENDAR_PREPOPULATE,
				  &CCalendarDemoView::OnEvent_PrePopulate);

	m_Sink.Advise(ptrCalendarConn, XTP_NC_CALENDAR_SELECTION_CHANGED,
				  &CCalendarDemoView::OnEventSelChanged);

	// Advise to Calendar Data Provider notifications
	m_Sink.Advise(ptrCalendarConn, XTP_NC_CALENDAREVENTWASADDED,
				  &CCalendarDemoView::OnEvent_CalendarData);
	m_Sink.Advise(ptrCalendarConn, XTP_NC_CALENDAREVENTWASDELETED,
				  &CCalendarDemoView::OnEvent_CalendarData);
	m_Sink.Advise(ptrCalendarConn, XTP_NC_CALENDAREVENTWASCHANGED,
				  &CCalendarDemoView::OnEvent_CalendarData);

	m_Sink.Advise(ptrCalendarConn, XTP_NC_CALENDARPATTERNWASADDED,
				  &CCalendarDemoView::OnEvent_CalendarData);
	m_Sink.Advise(ptrCalendarConn, XTP_NC_CALENDARPATTERNWASDELETED,
				  &CCalendarDemoView::OnEvent_CalendarData);
	m_Sink.Advise(ptrCalendarConn, XTP_NC_CALENDARPATTERNWASCHANGED,
				  &CCalendarDemoView::OnEvent_CalendarData);

	//	m_Sink.Advise(ptrCalendarConn, XTP_NC_CALENDAR_ON_REMINDERS,
	//&CCalendarDemoView::OnReminders);

	m_Sink.Advise(ptrCalendarConn, XTP_NC_CALENDAR_BEFORE_DRAW_THEMEOBJECT,
				  &CCalendarDemoView::OnBeforeDrawThemeObject);

	m_Sink.Advise(ptrCalendarConn, XTP_NC_CALENDAR_GETITEMTEXT,
				  &CCalendarDemoView::OnEvent_GetItemText);

	CXTPCalendarDayView* pDayView = DYNAMIC_DOWNCAST(CXTPCalendarDayView,
													 GetCalendarCtrl().GetDayView());
	if (pDayView)
	{
		COleDateTime dtMinTime;
		dtMinTime.SetTime(6, 0, 0);

		COleDateTime dtMaxTime;
		dtMaxTime.SetTime(23, 59, 59);

		pDayView->SetScaleMinTime(dtMinTime);
		pDayView->SetScaleMaxTime(dtMaxTime);

		GetCalendarCtrl().GetCalendarOptions()->dtScaleMinTime = dtMinTime;
		GetCalendarCtrl().GetCalendarOptions()->dtScaleMaxTime = dtMaxTime;
	}

	GetCalendarCtrl().m_bTimelineMode = FALSE;

	m_bTestCategory = FALSE;
}

CCalendarDemoView::~CCalendarDemoView()
{
	if (s_pDlgReminders)
		delete s_pDlgReminders;
	s_pDlgReminders = NULL;
}

BOOL CCalendarDemoView::PreCreateWindow(CREATESTRUCT& cs)
{
	// TODO: Modify the Window class or styles here by modifying
	//  the CREATESTRUCT cs
	cs.style &= ~WS_BORDER;
	cs.dwExStyle &= ~(WS_EX_STATICEDGE | WS_EX_CLIENTEDGE);

	return CXTPCalendarControlView::PreCreateWindow(cs);
}

/////////////////////////////////////////////////////////////////////////////
// CCalendarDemoView drawing

void CCalendarDemoView::OnDraw(CDC* pDC)
{
	UNREFERENCED_PARAMETER(pDC);

	CCalendarDemoDoc* pDoc = GetDocument();
	ASSERT_VALID(pDoc);
}

/////////////////////////////////////////////////////////////////////////////
// CCalendarDemoView diagnostics

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

void CCalendarDemoView::Dump(CDumpContext& dc) const
{
	CXTPCalendarControlView::Dump(dc);
}

CCalendarDemoDoc* CCalendarDemoView::GetDocument() // non-debug version is inline
{
	_ASSERTE(m_pDocument->IsKindOf(RUNTIME_CLASS(CCalendarDemoDoc)));
	return (CCalendarDemoDoc*)m_pDocument;
}
#endif //_DEBUG

/////////////////////////////////////////////////////////////////////////////
// CCalendarDemoView message handlers

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

	((CWnd*)&GetCalendarCtrl())->EnableToolTips(TRUE);

	CCalendarDemoDoc* pDoc = GetDocument();
	if (pDoc)
	{
		pDoc->m_pCalendar = &GetCalendarCtrl();
	}

	m_CalendarController.SetCalendar(&GetCalendarCtrl());

#ifdef _XTP_INCLUDE_COMMANDBARS
	m_wndVScrollBar.Create(WS_CHILD | WS_VISIBLE | SBS_VERT, CRect(0, 0, 0, 0), this, 100);
	m_wndVScrollBar.SetScrollBarStyle(xtpScrollStyleOffice2007Dark);
	SetScrollBarCtrl(&m_wndVScrollBar);

	m_wndHScrollBar.Create(WS_CHILD | WS_VISIBLE | SBS_HORZ, CRect(0, 0, 0, 0), this, 101);
	m_wndHScrollBar.SetScrollBarStyle(xtpScrollStyleOffice2007Dark);
	SetScrollBarCtrl(&m_wndHScrollBar, SB_HORZ);
#endif
	return 0;
}

//////////////////////////////////////////////////////////////////////////
//  User message handlers
//

void CCalendarDemoView::SetView(XTPCalendarViewType viewType)
{
	GetCalendarCtrl().SwitchActiveView(viewType);
	// if (viewType == xtpCalendarMonthView)
	//{
	//	GetCalendarCtrl().GetActiveView()->SetDayHeaderFormatLong(_T("MMMM d"));
	//	GetCalendarCtrl().GetActiveView()->SetDayHeaderFormatShort(_T("d"));
	//}

	// GetCalendarCtrl().GetActiveView()->SetDayHeaderFormatLong(_T("dddd, d MMMM yyyy 'year'"));
	// GetCalendarCtrl().GetActiveView()->SetDayHeaderFormatMiddle(_T("ddd, d MMM yy"));
	// GetCalendarCtrl().GetActiveView()->SetDayHeaderFormatShort(_T("d MMMM"));
	// GetCalendarCtrl().GetActiveView()->SetDayHeaderFormatShortest(_T("d MMM"));

	((CMainFrame*)GetParentFrame())->m_dlgOptions.OnViewChanged(viewType);
}

void CCalendarDemoView::SetCalendarToolTipMode(int nToolTipMode)
{
	m_wndCalendarEx.m_nToolTipMode = nToolTipMode;

	GetCalendarCtrl().EnableToolTips(nToolTipMode == ctmStandard);
}

void CCalendarDemoView::SetCalendarTimeScale(int nScale)
{
	m_nScale = nScale;
	OnUpdateTimeScale();
}

void CCalendarDemoView::OnCalendarTimescale60()
{
	SetCalendarTimeScale(60);
}

void CCalendarDemoView::OnCalendarTimescale30()
{
	SetCalendarTimeScale(30);
}

void CCalendarDemoView::OnCalendarTimescale15()
{
	SetCalendarTimeScale(15);
}

void CCalendarDemoView::OnCalendarTimescale10()
{
	SetCalendarTimeScale(10);
}

void CCalendarDemoView::OnCalendarTimescale6()
{
	SetCalendarTimeScale(6);
}

void CCalendarDemoView::OnCalendarTimescale5()
{
	SetCalendarTimeScale(5);
}

void CCalendarDemoView::OnUpdateCalendarTimescale60(CCmdUI* pCmdUI)
{
	OnUpdateCalendarTimescale(pCmdUI, 60);
}

void CCalendarDemoView::OnUpdateCalendarTimescale30(CCmdUI* pCmdUI)
{
	OnUpdateCalendarTimescale(pCmdUI, 30);
}

void CCalendarDemoView::OnUpdateCalendarTimescale15(CCmdUI* pCmdUI)
{
	OnUpdateCalendarTimescale(pCmdUI, 15);
}

void CCalendarDemoView::OnUpdateCalendarTimescale10(CCmdUI* pCmdUI)
{
	OnUpdateCalendarTimescale(pCmdUI, 10);
}

void CCalendarDemoView::OnUpdateCalendarTimescale6(CCmdUI* pCmdUI)
{
	OnUpdateCalendarTimescale(pCmdUI, 6);
}

void CCalendarDemoView::OnUpdateCalendarTimescale5(CCmdUI* pCmdUI)
{
	OnUpdateCalendarTimescale(pCmdUI, 5);
}

void CCalendarDemoView::OnUpdateCalendarTimescale(CCmdUI* pCmdUI, int nScale)
{
	BOOL bEnable  = FALSE;
	BOOL bChecked = FALSE;

	CXTPCalendarDayView* pDayView = DYNAMIC_DOWNCAST(CXTPCalendarDayView,
													 GetCalendarCtrl().GetActiveView());
	if (pDayView)
	{
		bEnable = TRUE;

		if (pDayView->GetScaleInterval().GetTotalMinutes() == nScale)
			bChecked = TRUE;
	}

	pCmdUI->Enable(bEnable);
	pCmdUI->SetCheck(bChecked);
}

void CCalendarDemoView::OnUpdateViewReminders(CCmdUI* pCmdUI)
{
	pCmdUI->Enable(GetCalendarCtrl().IsRemindersEnabled());
}

CString GetModulePath()
{
	TCHAR szCurPath[_MAX_PATH + 2];
	::GetModuleFileName(AfxGetInstanceHandle(), szCurPath, _MAX_PATH);

	CString strCurPath(szCurPath);
	strCurPath = strCurPath.Left(strCurPath.ReverseFind('\\') + 1);

	return strCurPath;
}

// void CCalendarDemoView::OnCalendarLangDefault()
//{
//	XTPResourceManager()->SetResourceFile(_T(""));
//
//	GetCalendarCtrl().Populate();
//
//	((CMainFrame*) GetParentFrame())->m_dlgDatePicker.m_wndDatePicker.AdjustLayout();
//	((CMainFrame*) GetParentFrame())->m_dlgDatePicker.m_wndDatePicker.RedrawControl();
//}
//
// void CCalendarDemoView::OnCalendarLangRussian()
//{
//	CString strRCpath = GetModulePath();
//
//	strRCpath += _T("Translations\\ToolkitPro.ResourceRu.dll");
//
//	XTPResourceManager()->SetResourceFile(strRCpath);
//
//	GetCalendarCtrl().Populate();
//
//	((CMainFrame*) GetParentFrame())->m_dlgDatePicker.m_wndDatePicker.AdjustLayout();
//	((CMainFrame*) GetParentFrame())->m_dlgDatePicker.m_wndDatePicker.RedrawControl();
//}

//////////////////////////////////////////////////////////////////////////
//
void CCalendarDemoView::OnAddNewEvent()
{
	AddNewEvent();
}

void CCalendarDemoView::AddNewEvent(CPoint* /*pPtHitContext*/)
{
	CXTPCalendarEventPropertiesDlg dlg(&GetCalendarCtrl(), TRUE, this);
	if (dlg.DoModal() == IDOK)
	{
		CXTPCalendarData* pCalendarData = GetCalendarCtrl().GetDataProvider();
		DWORD dNewEventID				= dlg.GetLastEventID();
		if (dNewEventID > 0)
		{
			CXTPCalendarEventPtr evPtr = pCalendarData->GetEvent(dNewEventID);
			CXTPCalendarView* pView	= GetCalendarCtrl().GetActiveView();
			if (pView && (pView->GetViewType() == xtpCalendarMonthView))
			{
				for (UINT i = 0; i < pView->GetDiscreteSelectionCount(); i++)
				{
					COleDateTime dt = pView->GetDiscreteSelectionValue(i);
					if (dt.m_status == COleDateTime::valid)
					{
						// AfxMessageBox(dt.Format());
						// Need a function to copy event with new datetime
					}
				}
			}
		}
	}
}

void CCalendarDemoView::AddNewTimeEvent(XTP_CALENDAR_HITTESTINFO hitInfo)
{
	COleDateTime dtInitial(hitInfo.dt);
	CXTPCalendarEventPropertiesDlg dlg(&GetCalendarCtrl(), TRUE, this, NULL,
									   XTP_IDD_CALENDAR_EVENT_PROPERTIES, dtInitial);
	if (dlg.DoModal() == IDOK)
	{
		CXTPCalendarData* pCalendarData = GetCalendarCtrl().GetDataProvider();
		DWORD dNewEventID				= dlg.GetLastEventID();
		if (dNewEventID > 0)
		{
			CXTPCalendarEventPtr evPtr = pCalendarData->GetEvent(dNewEventID);
			CXTPCalendarView* pView	= GetCalendarCtrl().GetActiveView();
			if (pView && (pView->GetViewType() == xtpCalendarMonthView))
			{
				for (UINT i = 0; i < pView->GetDiscreteSelectionCount(); i++)
				{
					COleDateTime dt = pView->GetDiscreteSelectionValue(i);
					if (dt.m_status == COleDateTime::valid)
					{
						// AfxMessageBox(dt.Format());
						// Need a function to copy event with new datetime
					}
				}
			}
		}
	}
}

void CCalendarDemoView::OnCalendarTimezone()
{
	TRACE(_T("Time zone dialog.\n"));

	CXTPCalendarOptions* pOptions = GetCalendarCtrl().GetCalendarOptions();
	_ASSERTE(pOptions);
	if (pOptions)
	{
		CXTPCalendarTimeScalePropertiesDlg dlg;
		// init parameters
		dlg.m_strCaption1		  = pOptions->strDayView_ScaleLabel;
		dlg.m_strCaption2		  = pOptions->strDayView_AdditionalScaleLabel;
		BOOL bPrevAdditionalScale = pOptions->bDayView_AdditionalScaleLeftVisible
									|| pOptions->bDayView_AdditionalScaleRightVisible;
		dlg.m_bShowAdditionalScale = bPrevAdditionalScale;
		dlg.m_tziScale2			   = pOptions->tziDayView_AdditionalScaleTimeZone;

		// execute and save
		if (dlg.DoModal() == IDOK)
		{
			// first time scale
			pOptions->strDayView_ScaleLabel = dlg.m_strCaption1;

			// second time scale
			pOptions->bDayView_AdditionalScaleLeftVisible =
				dlg.m_bShowAdditionalScale
				&& (bPrevAdditionalScale ? pOptions->bDayView_AdditionalScaleLeftVisible
										 : pOptions->bDayView_ScaleLeftVisible);

			pOptions->bDayView_AdditionalScaleRightVisible =
				dlg.m_bShowAdditionalScale
				&& (bPrevAdditionalScale ? pOptions->bDayView_AdditionalScaleRightVisible
										 : pOptions->bDayView_ScaleRightVisible);

			if (dlg.m_bShowAdditionalScale)
			{
				pOptions->strDayView_AdditionalScaleLabel	= dlg.m_strCaption2;
				pOptions->tziDayView_AdditionalScaleTimeZone = dlg.m_tziScale2;
			}

			pOptions->OnOptionsChanged();
			// redraw
			GetCalendarCtrl().Populate();
		}
	}
}

void CCalendarDemoView::OnAdvancedOptions()
{
	CAdvancedCalendarOptionsDlg dlgOptEx(&GetCalendarCtrl(), this);

	dlgOptEx.DoModal();
}

void CCalendarDemoView::OnInitialUpdate()
{
	CXTPCalendarControlView::OnInitialUpdate();

	// date picker
	CMainFrame* pWnd = (CMainFrame*)AfxGetMainWnd();

	// m_CalendarController.SetBoldDaysPerIdleStep(1);
	// m_CalendarController.SetBoldDaysIdleStepTime_ms(999);
	m_CalendarController.SetDatePicker(&pWnd->m_dlgDatePicker.m_wndDatePicker);

	// pWnd->m_dlgDatePicker.m_wndDatePicker.AllowNoncontinuousSelection(FALSE);//default - TRUE
	//---------------------------------------------------------------------------
	m_dtDayViewStart = COleDateTime::GetCurrentTime();
	//---------------------------------------------------------------------------

	((CMainFrame*)GetParentFrame())->m_dlgOptions.Init();

	m_nScale = GetCalendarCtrl().GetCalendarOptions()->nDayView_ScaleInterval;

	// initial settings
	OnCalendarViewWorkWeek();

	CXTPCalendarDayView* pDayView = DYNAMIC_DOWNCAST(CXTPCalendarDayView,
													 GetCalendarCtrl().GetDayView());
	if (pDayView)
	{
		// test min and max scale times
		// pDayView->SetScaleMinTime(0.25);
		// pDayView->SetScaleMaxTime(0.75);

		// initialize
		// pDayView->m_bDraftMode = TRUE;
		// pDayView->m_bEcoMode = TRUE;
		pDayView->ScrollToWorkDayBegin();
	}
	// GetCalendarCtrl().GetCalendarOptions()->nDayView_ScaleInterval = 10; //5;
	// GetCalendarCtrl().GetCalendarOptions()->bDayView_TimeScaleShowMinutes = TRUE;
	// GetCalendarCtrl().GetCalendarOptions()->OnOptionsChanged();

	CreateRemindersWindow();

	GetCalendarCaptionBarCtrl().EnableTimeline(TRUE);

	ShowCaptionBar(TRUE);

	GetCalendarCtrl().GetDayView()->SetDayHeaderFormatLong(_T("MMMM d"));
	GetCalendarCtrl().GetWeekView()->SetDayHeaderFormatLong(_T("MMMM d"));
	GetCalendarCtrl().GetMonthView()->SetDayHeaderFormatLong(_T("MMMM d"));
	GetCalendarCtrl().SetLongDayHeaderFormat(_T("MMMM d"));
	GetCalendarCtrl().SetSmallDayHeaderFormat(_T("d"));

	SetTheme(xtpCalendarThemeOffice2013);
	OnCalendarViewWorkWeek();

	// GetCalendarCtrl().m_bMultiColumnWeekMode = FALSE;
	COleDateTime dt;
	dt.SetTime(0, 0, 0);
	GetPrintOptions()->m_dtPrintFrom = dt;
	dt.SetTime(23, 59, 59);
	GetPrintOptions()->m_dtPrintTo = dt;
}

void CCalendarDemoView::OnUpdateTimeScale()
{
	CXTPCalendarDayView* pDayView = DYNAMIC_DOWNCAST(CXTPCalendarDayView,
													 GetCalendarCtrl().GetActiveView());
	if (pDayView)
	{
		pDayView->SetScaleInterval(COleDateTimeSpan(0, m_nScale / 60, m_nScale % 60, 0));
	}
	else
	{
		GetCalendarCtrl().GetCalendarOptions()->nDayView_ScaleInterval = m_nScale;
		GetCalendarCtrl().GetCalendarOptions()->OnOptionsChanged();
	}

	// GetCalendarCtrl().GetDayView()->SetScaleMinTime(COleDateTime(2013, 01, 23, 9, 00, 00));
	// GetCalendarCtrl().GetDayView()->SetScaleMinTime(COleDateTime(2013, 01, 23, 18, 00, 00));
}

void CCalendarDemoView::OnEvent_Calendar(XTP_NOTIFY_CODE idEvent, WPARAM wParam, LPARAM lParam)
{
	UNREFERENCED_PARAMETER(lParam);

	if (!GetCalendarCtrl().GetActiveView())
		return;

	CPoint ptHit(wParam);
	XTP_CALENDAR_HITTESTINFO hitInfo;
	BOOL bHitTest = GetCalendarCtrl().GetActiveView()->HitTest(ptHit, &hitInfo);

	if (XTP_NC_CALENDARKEYDOWN == idEvent)
	{
		if (wParam == VK_RETURN && !GetCalendarCtrl().GetActiveView()->IsEditingSubject()
			&& GetCalendarCtrl().GetActiveView()->GetDraggingMode() == xtpCalendaDragModeUnknown)
		{
			CXTPCalendarViewEvents* selectedEvents =
				GetCalendarCtrl().GetActiveView()->GetSelectedViewEvents();

			if (selectedEvents && selectedEvents->GetCount() > 0)
			{
				CXTPCalendarEventPtr ptrEvent = selectedEvents->GetAt(0)->GetEvent()->CloneEvent();

				CXTPCalendarEventPropertiesDlg dlg(&GetCalendarCtrl(), FALSE, this, ptrEvent);
				dlg.DoModal();
			}
			else
			{
				AddNewEvent();
			}
		}
	}
	else if (XTP_NC_CALENDARCONTEXTMENU == idEvent)
	{
		if (bHitTest)
		{
			CPoint ptMenu = ptHit;
			GetCalendarCtrl().ClientToScreen(&ptMenu);

			if (hitInfo.pViewEvent)
			{
				CMenu menu;
				VERIFY(menu.LoadMenu(IDR_MENU_CONTEXT_EVENT));

				// track menu
#ifndef _XTP_INCLUDE_COMMANDBARS
				int nMenuResult = menu.GetSubMenu(0)->TrackPopupMenu(TPM_RETURNCMD | TPM_LEFTALIGN
																		 | TPM_RIGHTBUTTON,
																	 ptMenu.x, ptMenu.y, this,
																	 NULL);
#else
				int nMenuResult = CXTPCommandBars::TrackPopupMenu(menu.GetSubMenu(0),
																  TPM_NONOTIFY | TPM_RETURNCMD
																	  | TPM_LEFTALIGN
																	  | TPM_RIGHTBUTTON,
																  ptMenu.x, ptMenu.y, this, NULL);
#endif

				// general items processing
				switch (nMenuResult)
				{
					case ID_POPUP_COPYEVENT:
					{
						_ASSERTE(hitInfo.pViewEvent);
						if (hitInfo.pViewEvent)
						{
							CXTPCalendarEvent* pEvent = hitInfo.pViewEvent->GetEvent();
							if (pEvent)
							{
								GetCalendarCtrl().GetActiveView()->SelectEvent(pEvent);
								GetCalendarCtrl().OnCopy();
							}
						}
					}
					break;
					case ID_POPUP_DELETEEVENT:
					{
						VERIFY(GetCalendarCtrl().DoDeleteSelectedEvents(hitInfo.pViewEvent));

						GetCalendarCtrl().Populate();
					}
					break;
					case ID_POPUP_PROPERTIES:
					{
						_ASSERTE(hitInfo.pViewEvent);
						if (hitInfo.pViewEvent)
						{
							CXTPCalendarEvent* pEvent	 = hitInfo.pViewEvent->GetEvent();
							CXTPCalendarEventPtr ptrEvent = pEvent->CloneEvent();

							CXTPCalendarControl::CUpdateContext updateContext(
								&GetCalendarCtrl(),
								xtpCalendarUpdateLayout | xtpCalendarUpdateRedraw);
							CXTPCalendarEventPropertiesDlg dlg(&GetCalendarCtrl(), FALSE, this,
															   ptrEvent);
							dlg.m_bOccurrence = TRUE;
							dlg.DoModal();
						}
					}
					break;
				}
			}
			else if (GetCalendarCtrl().GetActiveView()->IsKindOf(
						 RUNTIME_CLASS(CXTPCalendarDayView)))
			{
				CMenu menu;
				VERIFY(menu.LoadMenu(IDR_MENU_CONTEXT_DAY));

				CXTPCalendarDayView* pDayView = DYNAMIC_DOWNCAST(CXTPCalendarDayView,
																 GetCalendarCtrl().GetActiveView());
				if (pDayView)
				{
					int nInterval = (int)pDayView->GetScaleInterval().GetTotalMinutes();
					int nMenuItem =
						nInterval >= 60
							? ID_CALENDAR_CHANGETIMESCALE_60MINUTES
							: (nInterval >= 30
								   ? ID_CALENDAR_CHANGETIMESCALE_30MINUTES
								   : (nInterval >= 15
										  ? ID_CALENDAR_CHANGETIMESCALE_15MINUTES
										  : (nInterval >= 10
												 ? ID_CALENDAR_CHANGETIMESCALE_10MINUTES
												 : (nInterval >= 6
														? ID_CALENDAR_CHANGETIMESCALE_6MINUTES
														: (nInterval >= 5
															   ? ID_CALENDAR_CHANGETIMESCALE_5MINUTES
															   : 0)))));
					menu.CheckMenuItem(nMenuItem, MF_CHECKED);
				}

				// track menu
#ifndef _XTP_INCLUDE_COMMANDBARS
				int nMenuResult = menu.GetSubMenu(0)->TrackPopupMenu(TPM_RETURNCMD | TPM_LEFTALIGN
																		 | TPM_RIGHTBUTTON,
																	 ptMenu.x, ptMenu.y, this,
																	 NULL);
#else
				int nMenuResult = CXTPCommandBars::TrackPopupMenu(menu.GetSubMenu(0),
																  TPM_NONOTIFY | TPM_RETURNCMD
																	  | TPM_LEFTALIGN
																	  | TPM_RIGHTBUTTON,
																  ptMenu.x, ptMenu.y, this, NULL);
#endif

				// general items processing
				switch (nMenuResult)
				{
					case ID_CALENDAR_CHANGETIMESCALE_60MINUTES: OnCalendarTimescale60(); break;
					case ID_CALENDAR_CHANGETIMESCALE_30MINUTES: OnCalendarTimescale30(); break;
					case ID_CALENDAR_CHANGETIMESCALE_15MINUTES: OnCalendarTimescale15(); break;
					case ID_CALENDAR_CHANGETIMESCALE_10MINUTES: OnCalendarTimescale10(); break;
					case ID_CALENDAR_CHANGETIMESCALE_6MINUTES: OnCalendarTimescale6(); break;
					case ID_CALENDAR_CHANGETIMESCALE_5MINUTES: OnCalendarTimescale5(); break;
					case ID_CALENDAR_CHANGETIMESCALE_CHANGETIMEZONE: OnCalendarTimezone(); break;
					case ID_CALENDAR_ADD_NEW_EVENT: AddNewEvent(&ptHit); break;
					default: _ASSERTE(nMenuResult == 0);
				}
			}
			else // if
				 // (GetCalendarCtrl().GetActiveView()->IsKindOf(RUNTIME_CLASS(CXTPCalendarWeekView)))
			{
				CMenu menu;
				VERIFY(menu.LoadMenu(IDR_MENU_CONTEXT_WEEK));

				if (GetCalendarCtrl().GetActiveView()->IsKindOf(
						RUNTIME_CLASS(CXTPCalendarTimeLineView)))
					menu.GetSubMenu(0)->RemoveMenu(ID_POPUP_GOTOTHISDAY, MF_BYCOMMAND);

					// track menu
#ifndef _XTP_INCLUDE_COMMANDBARS
				int nMenuResult = menu.GetSubMenu(0)->TrackPopupMenu(TPM_RETURNCMD | TPM_LEFTALIGN
																		 | TPM_RIGHTBUTTON,
																	 ptMenu.x, ptMenu.y, this,
																	 NULL);
#else
				int nMenuResult = CXTPCommandBars::TrackPopupMenu(menu.GetSubMenu(0),
																  TPM_NONOTIFY | TPM_RETURNCMD
																	  | TPM_LEFTALIGN
																	  | TPM_RIGHTBUTTON,
																  ptMenu.x, ptMenu.y, this, NULL);
#endif

				// general items processing
				switch (nMenuResult)
				{
					case ID_POPUP_GOTOTHISDAY:
					{
						GetCalendarCtrl().SwitchActiveView(xtpCalendarDayView);
						CXTPCalendarDayView* pDayView = DYNAMIC_DOWNCAST(
							CXTPCalendarDayView, GetCalendarCtrl().GetActiveView());
						if (pDayView)
						{
							COleDateTime dtThisDay(hitInfo.dt);
							pDayView->ResetSelection();
							pDayView->ShowDay(dtThisDay);
						}
					}
					break;
					case ID_CALENDAR_ADD_NEW_EVENT:
						if (GetCalendarCtrl().GetActiveView()->IsKindOf(
								RUNTIME_CLASS(CXTPCalendarTimeLineView)))
							AddNewTimeEvent(hitInfo);
						else
							AddNewEvent(&ptHit);
						break;
				}
			}
		}
	}

	else if (XTP_NC_CALENDARLBUTTONDBLCLICK == idEvent)
	{
		if (bHitTest && hitInfo.pViewEvent)
		{
			// mouse double clicked - show event edit dialog
			CXTPCalendarEvent* pEvent	 = hitInfo.pViewEvent->GetEvent();
			CXTPCalendarEventPtr ptrEvent = pEvent->CloneEvent();

			if (hitInfo.pViewEvent->IsShowingToolTip())
			{
				hitInfo.pViewEvent->HideToolTip();
			}

			CXTPCalendarEventPropertiesDlg dlg(&GetCalendarCtrl(), FALSE, this, ptrEvent);
			dlg.m_bOccurrence = FALSE;
			dlg.DoModal();
		}
		else if (bHitTest
				 && (hitInfo.uHitCode & (xtpCalendarHitTestDayArea | xtpCalendarHitTestDayHeader)))
		{
			AddNewEvent(&ptHit);
		}
	}
}

void CCalendarDemoView::OnFileSave()
{
	CXTPCalendarData* pData = GetCalendarCtrl().GetDataProvider();
	if (!pData)
	{
		_ASSERTE(FALSE);
		return;
	}
	if (GetDPType(pData) == xtpCalendarDataProviderMemory)
	{
		CString strFileName = AfxGetApp()->GetProfileString(cstrDP_Opt_section,
															cstrUseDP_Mem_File_opt);
		if (!pData->Save())
		{
			CString strDPname = GetDPName(xtpCalendarDataProviderMemory);
			CString strMsg;
			strMsg.Format(_T("%s cannot create file: \n%s"), strDPname.operator LPCTSTR(),
						  strFileName.operator LPCTSTR());
			AfxMessageBox(strMsg);
		}
	}
}

void CCalendarDemoView::OnFileSaveAs()
{
	CXTPCalendarData* pData = GetCalendarCtrl().GetDataProvider();
	if (!pData)
	{
		_ASSERTE(FALSE);
		return;
	}
	if (GetDPType(pData) != xtpCalendarDataProviderMemory)
	{
		_ASSERTE(FALSE);
		return;
	}

	CDataProvidersOptions optDlg;
	optDlg.m_strTitle	 = _T("Save calendar data as:");
	optDlg.m_bOpenMode	= FALSE;
	optDlg.m_bWarnIfExist = TRUE;
	optDlg.m_eMode		  = CDataProvidersOptions::modeMemOnly;

	int nDlgRes = (int)optDlg.DoModal();
	if (nDlgRes != IDOK)
	{
		return;
	}

	CString strFileName = AfxGetApp()->GetProfileString(cstrDP_Opt_section, cstrUseDP_Mem_File_opt);
	if (!pData->Save())
	{
		CString strDPname = GetDPName(xtpCalendarDataProviderMemory);
		CString strMsg;
		strMsg.Format(_T("%s cannot create file: \n%s"), strDPname.operator LPCTSTR(),
					  strFileName.operator LPCTSTR());
		AfxMessageBox(strMsg);
	}
}

void CCalendarDemoView::OnGoToToday()
{
	CXTPCalendarView* pView = GetCalendarCtrl().GetActiveView();
	if (pView)
	{
		pView->ResetSelection();
		COleDateTime dtThisDay = COleDateTime::GetCurrentTime();
		pView->SelectDay(dtThisDay);
	}
}

void CCalendarDemoView::OnUpdateFileSave(CCmdUI* pCmdUI)
{
	CXTPCalendarData* pData = GetCalendarCtrl().GetDataProvider();

	int nDPType = GetDPType(pData);

	pCmdUI->Enable(nDPType == xtpCalendarDataProviderMemory);
}

void CCalendarDemoView::OnUpdateFileSaveAs(CCmdUI* pCmdUI)
{
	OnUpdateFileSave(pCmdUI);
}

void CCalendarDemoView::OnEvent_IsEditActionDisabled(XTP_NOTIFY_CODE idEvent, WPARAM wParam,
													 LPARAM lParam)
{
	if (XTP_NC_CALENDAR_IS_EVENT_EDIT_OPERATION_DISABLED != idEvent)
	{
		_ASSERTE(FALSE);
		return;
	}

	XTP_EVENT_EDIT_OPERATION_PARAMS* pOPparams = (XTP_EVENT_EDIT_OPERATION_PARAMS*)wParam;
	BOOL* pbCancel							   = (BOOL*)lParam;
	_ASSERTE(pbCancel);

	// check is already canceled/handled
	if (!pOPparams || !pbCancel || *pbCancel)
	{
		return;
	}

	// Disable dragging for recurrence events
	//
	//	CXTPCalendarEvent* pEvent = pOPparams->pEventViews->GetAt(0)->GetEvent();
	//	_ASSERTE(pEvent);

	//	if ((pOPparams->eOperation == xtpCalendarEO_DragCopy || pOPparams->eOperation ==
	// xtpCalendarEO_DragMove || 		pOPparams->eOperation == xtpCalendarEO_DragResizeBegin ||
	// pOPparams->eOperation == xtpCalendarEO_DragResizeEnd)
	//		&& pEvent
	//		&& pEvent->GetRecurrenceState() != xtpCalendarRecurrenceNotRecurring)
	//	{
	//		*pbCancel = TRUE;
	//	}
}

void CCalendarDemoView::OnEvent_BeforeEditAction(XTP_NOTIFY_CODE idEvent, WPARAM wParam,
												 LPARAM lParam)
{
	if (XTP_NC_CALENDAR_BEFORE_EVENT_EDIT_OPERATION != idEvent)
	{
		_ASSERTE(FALSE);
		return;
	}

	XTP_EVENT_EDIT_OPERATION_PARAMS* pOPparams = (XTP_EVENT_EDIT_OPERATION_PARAMS*)wParam;
	BOOL* pbHandled							   = (BOOL*)lParam;
	_ASSERTE(pbHandled && pOPparams);

	// check is already canceled/handled
	if (!pOPparams || !pbHandled || *pbHandled)
	{
		return;
	}

	if (pOPparams->eOperation == xtpCalendarEO_DeleteEvent)
	{
		if (!pOPparams->pEventViews || !pOPparams->pEventViews->GetAt(0))
		{
			_ASSERTE(FALSE);
			return;
		}

		CXTPCalendarEvent* pEvent = pOPparams->pEventViews->GetAt(0)->GetEvent();
		if (!pEvent)
		{
			_ASSERTE(FALSE);
			return;
		}

		if (pEvent->GetRecurrenceState() == xtpCalendarRecurrenceNotRecurring)
		{
			CString strMsg;
			strMsg.Format(_T("Would you like to delete event: \"%s\" ?"),
						  pEvent->GetSubject().operator LPCTSTR());
			int nRes = AfxMessageBox(strMsg, MB_YESNO);
			if (nRes == IDNO)
			{
				*pbHandled = TRUE;
			}
		}
	}

	//**  since ver 9.81
	//******************
	// if (pOPparams->eOperation == xtpCalendarEO_DragMove ||
	//	pOPparams->eOperation == xtpCalendarEO_DragCopy )
	//{
	//	XTP_EVENT_DRAG_OPERATION_PARAMS* pOpDrag = (XTP_EVENT_DRAG_OPERATION_PARAMS*)pOPparams;
	//	_ASSERTE(pOpDrag->pDraggingEvent && pOpDrag->pDraggingEventNew);
	//
	//	if (pOpDrag->pDraggingEvent && pOpDrag->pDraggingEventNew)
	//	{
	//		COleDateTime dtOrigStart = pOpDrag->pDraggingEvent->GetStartTime();
	//		COleDateTime dtNewStart = pOpDrag->pDraggingEventNew->GetStartTime();;
	//
	//		if (CXTPCalendarUtils::ResetTime(dtOrigStart) !=
	// CXTPCalendarUtils::ResetTime(dtNewStart)
	//			|| pOpDrag->pDraggingEvent->IsAllDayEvent() !=
	// pOpDrag->pDraggingEventNew->IsAllDayEvent())
	//		{
	//			*pbHandled = TRUE;
	//		}
	//	}
	//}

	//**  for ver 9.80
	//******************
	// if (pOPparams->eOperation == xtpCalendarEO_DragMove &&
	//	GetCalendarCtrl().GetActiveView()->GetDraggingEventOrig())
	//{
	//	CPoint pt;
	//	GetCursorPos(&pt);
	//	GetCalendarCtrl().ScreenToClient(&pt);

	//	XTP_CALENDAR_HITTESTINFO hitInfo;
	//	if (GetCalendarCtrl().GetActiveView()->HitTest(pt, &hitInfo))
	//	{
	//		COleDateTime dtOrigStart =
	// GetCalendarCtrl().GetActiveView()->GetDraggingEventOrig()->GetStartTime();
	//
	//		// store previous version to rollback
	//		CXTPCalendarEventPtr ptrEventPrev =
	// GetCalendarCtrl().GetActiveView()->GetDraggingEventNew()->CloneEvent();
	//
	//		if (GetCalendarCtrl().GetActiveView()->OnDragging(pt, &hitInfo))
	//		{
	//			CXTPCalendarEvent* pEventNew =
	// GetCalendarCtrl().GetActiveView()->GetDraggingEventNew(); 			COleDateTime dtNewStart
	// = pEventNew->GetStartTime();
	//
	//			if (CXTPCalendarUtils::ResetTime(dtOrigStart) !=
	//				CXTPCalendarUtils::ResetTime(dtNewStart) )
	//			{
	//				*pbHandled = TRUE;
	//			}
	//
	//			pEventNew->Update(ptrEventPrev);
	//
	//			//TRACE(_T("orig: %s - point: %s = [%d] \n"), dtOrigStart.Format(),
	// hitInfo.dt.Format(),
	//			//		*pbHandled);
	//		}
	//	}
	//}
}

void CCalendarDemoView::OnEvent_CalendarData(XTP_NOTIFY_CODE idEvent, WPARAM wParam, LPARAM lParam)
{
	UNREFERENCED_PARAMETER(lParam);
	UNREFERENCED_PARAMETER(wParam);

	CString strActionText;

	switch (idEvent)
	{
		case XTP_NC_CALENDAREVENTWASADDED: strActionText = _T("Event_WasAdded"); break;
		case XTP_NC_CALENDAREVENTWASDELETED: strActionText = _T("Event_WasDeleted"); break;
		case XTP_NC_CALENDAREVENTWASCHANGED: strActionText = _T("Event_WasChanged"); break;

		case XTP_NC_CALENDARPATTERNWASADDED: strActionText = _T("Pattern_WasAdded"); break;
		case XTP_NC_CALENDARPATTERNWASDELETED: strActionText = _T("Pattern_WasDeleted"); break;
		case XTP_NC_CALENDARPATTERNWASCHANGED: strActionText = _T("Pattern_WasChanged"); break;
		default: _ASSERTE(FALSE); return;
	}

	//===========================================================================
	CXTPCalendarData* pData = GetCalendarCtrl().GetDataProvider();
	if (!pData)
	{
		_ASSERTE(FALSE);
		return;
	}

	if (idEvent == XTP_NC_CALENDAREVENTWASADDED || idEvent == XTP_NC_CALENDAREVENTWASDELETED
		|| idEvent == XTP_NC_CALENDAREVENTWASCHANGED)
	{
		// EVENT:
		CXTPCalendarEvent* pEvent = (CXTPCalendarEvent*)lParam;
		if (pEvent)
		{
			COleDateTime dtStart = pEvent->GetStartTime();
			COleDateTime dtEnd   = pEvent->GetEndTime();
			CString strSubject   = pEvent->GetSubject();
			TRACE(_T("%s (ID=%d): %s-%s, '%s' \n"), strActionText.operator LPCTSTR(),
				  pEvent->GetEventID(), dtStart.Format().operator LPCTSTR(),
				  dtEnd.Format().operator LPCTSTR(), strSubject.operator LPCTSTR());
		}
		else
		{
			TRACE(_T("%s (pEvent=%x) \n"), strActionText.operator LPCTSTR(), wParam);
		}
	}
	else
	{
		// PATTERN:
		CXTPCalendarRecurrencePatternPtr ptrPattern = pData->GetRecurrencePattern((DWORD)wParam);
		if (ptrPattern)
		{
			COleDateTime dtStartPatt			= ptrPattern->GetPatternStartDate();
			CXTPCalendarEventPtr ptrMasterEvent = ptrPattern->GetMasterEvent();
			_ASSERTE(ptrMasterEvent);
			CString strSubject = ptrMasterEvent ? ptrMasterEvent->GetSubject() : _T("");

			TRACE(_T("%s (ID=%d): pattern starts at %s, '%s' \n"), strActionText.operator LPCTSTR(),
				  wParam, dtStartPatt.Format().operator LPCTSTR(), strSubject.operator LPCTSTR());
		}
		else
		{
			TRACE(_T("%s (ID=%d) \n"), strActionText.operator LPCTSTR(), wParam);
		}
	}
}

void CCalendarDemoView::CreateRemindersWindow()
{
	if (!s_pDlgReminders || !s_pDlgReminders->GetSafeHwnd())
	{
		if (!s_pDlgReminders)
			s_pDlgReminders = new CXTPCalendarRemindersDialog();

		VERIFY(s_pDlgReminders->Create());
		s_pDlgReminders->CenterWindow();

		// s_pDlgReminders->SetRemindersManager(&GetCalendarCtrl());
	}
}

void CCalendarDemoView::OnViewReminders()
{
	s_pDlgReminders->ShowWindow(SW_SHOWNORMAL);
}

// void CCalendarDemoView::OnReminders(XTP_NOTIFY_CODE idEvent, WPARAM wParam , LPARAM lParam)
//{
//	UNREFERENCED_PARAMETER(lParam);
//
//	if (idEvent != XTP_NC_CALENDAR_ON_REMINDERS)
//{
//		_ASSERTE(FALSE);
//		return;
//	}
//
//	int eAction = (int)wParam;
//	if (eAction == xtpCalendarRemindersMonitoringStarted)
//	{
//		CreateRemindersWindow();
//	}
//	if (eAction == xtpCalendarRemindersMonitoringStopped)
//	{
//		if (s_pDlgReminders)
//		{
//			delete s_pDlgReminders;
//			s_pDlgReminders = NULL;
//		}
//	}
//}

void CCalendarDemoView::OnBeforeDrawThemeObject(XTP_NOTIFY_CODE idEvent, WPARAM wParam,
												LPARAM lParam)
{
	_ASSERTE(idEvent == XTP_NC_CALENDAR_BEFORE_DRAW_THEMEOBJECT);
	if (idEvent != XTP_NC_CALENDAR_BEFORE_DRAW_THEMEOBJECT)
		return;

	CXTPCalendarThemeOffice2007* pTheme2007 = DYNAMIC_DOWNCAST(CXTPCalendarThemeOffice2007,
															   GetCalendarCtrl().GetTheme());
	_ASSERTE(pTheme2007);
	if (!pTheme2007)
		return;

	static CFont s_fntStriked;
	if (s_fntStriked.m_hObject == NULL)
	{
		LOGFONT lfIcon;
		VERIFY(::SystemParametersInfo(SPI_GETICONTITLELOGFONT, sizeof(lfIcon), &lfIcon, 0));
		lfIcon.lfWeight = FW_BOLD;

		lfIcon.lfStrikeOut = 1;

		s_fntStriked.CreateFontIndirect(&lfIcon);
	}

	if (wParam == xtpCalendarBeforeDraw_DayViewEvent)
	{
		CXTPCalendarDayViewEvent* pViewEvent = (CXTPCalendarDayViewEvent*)lParam;
		if (pViewEvent && pViewEvent->GetEvent()->GetSubject().Left(1) == _T("*"))
		{
			pTheme2007->GetDayViewPartX()
				->GetDayPartX()
				->GetGroupPartX()
				->GetSingleDayEventPartX()
				->m_fcsetNormal.fcsetSubject.fntFont.SetCustomValue(&s_fntStriked);
			pTheme2007->GetDayViewPartX()
				->GetDayPartX()
				->GetGroupPartX()
				->GetMultiDayEventPartX()
				->m_fcsetNormal.fcsetSubject.fntFont.SetCustomValue(&s_fntStriked);

			pTheme2007->GetDayViewPartX()
				->GetDayPartX()
				->GetGroupPartX()
				->GetSingleDayEventPartX()
				->m_fcsetSelected.fcsetSubject.fntFont.SetCustomValue(&s_fntStriked);
			pTheme2007->GetDayViewPartX()
				->GetDayPartX()
				->GetGroupPartX()
				->GetMultiDayEventPartX()
				->m_fcsetSelected.fcsetSubject.fntFont.SetCustomValue(&s_fntStriked);
		}
	}

	if (wParam == xtpCalendarBeforeDraw_MonthViewDay)
	{
		CXTPCalendarMonthViewDay* pDay = (CXTPCalendarMonthViewDay*)lParam;

		if (pDay->GetDayDate().GetDayOfWeek() == 3)
		{
			pTheme2007->GetMonthViewPartX()->GetDayPartX()->m_clrBackgroundDark		= RGB(196, 128,
																					  128);
			pTheme2007->GetMonthViewPartX()->GetDayPartX()->m_clrBackgroundLight	= RGB(230, 128,
																						  128);
			pTheme2007->GetMonthViewPartX()->GetDayPartX()->m_clrBackgroundSelected = RGB(128, 228,
																						  228);
		}
	}
}

void CCalendarDemoView::OnEvent_GetItemText(XTP_NOTIFY_CODE idEvent, WPARAM wParam, LPARAM lParam)
{
	UNREFERENCED_PARAMETER(lParam);
	XTP_CALENDAR_GETITEMTEXT_PARAMS* pParams = (XTP_CALENDAR_GETITEMTEXT_PARAMS*)wParam;

	if (XTP_NC_CALENDAR_GETITEMTEXT != idEvent || !pParams)
		return;

	if (xtpCalendarItemText_EventMarkupTemplate == pParams->nItem)
	{
		pParams->pstrText->Format(cstrMarkupDynamicSample);
	}

	if (xtpCalendarItemText_EventSubject == pParams->nItem)
	{
		// Dynamically customize Location text
		pParams->pstrText->MakeReverse();
	}
}

CXTPCalendarControl_Custom::CXTPCalendarControl_Custom()
{
	m_nToolTipMode = ctmStandard;
}

INT_PTR CXTPCalendarControl_Custom::OnToolHitTest(CPoint point, TOOLINFO* pTI) const
{
	if (m_nToolTipMode == ctmCustom)
	{
		XTP_CALENDAR_HITTESTINFO hitTest;
		if (((CXTPCalendarControl*)this)->GetActiveView()->HitTest(point, &hitTest))
		{
			if (hitTest.pViewEvent)
			{
				pTI->hwnd = m_hWnd;			  //   Handle to a window
				pTI->uId  = (UINT_PTR)m_hWnd; //   Handle to a child window
				pTI->uFlags |= TTF_IDISHWND | TTF_NOTBUTTON;

				CString strToolText;
				strToolText.Format(
					_T("[ID = 0x%08X] (%s - %s) %s"), hitTest.pViewEvent->GetEvent()->GetEventID(),
					hitTest.pViewEvent
						->FormatEventTime(hitTest.pViewEvent->GetEvent()->GetStartTime())
						.
					operator LPCTSTR(),
					hitTest.pViewEvent
						->FormatEventTime(hitTest.pViewEvent->GetEvent()->GetEndTime())
						.
					operator LPCTSTR(),
					hitTest.pViewEvent->GetEvent()->GetSubject().operator LPCTSTR());

				int nTextSize  = strToolText.GetLength() + 1;
				TCHAR* pBuffer = (TCHAR*)::calloc(nTextSize, sizeof(TCHAR));
				STRCPY_S(pBuffer, nTextSize, (LPCTSTR)strToolText);
				pTI->lpszText = pBuffer;

				return 333;
			}
		}
	}

	return CXTPCalendarControl::OnToolHitTest(point, pTI);
}

void CCalendarDemoView::OnEvent_PrePopulate(XTP_NOTIFY_CODE idEvent, WPARAM wParam, LPARAM lParam)
{
	UNREFERENCED_PARAMETER(wParam);

	if (XTP_NC_CALENDAR_PREPOPULATE != idEvent)
	{
		_ASSERTE(FALSE);
		return;
	}

	// Theme 2007.
	CXTPCalendarThemeOffice2007* pTheme2007 = DYNAMIC_DOWNCAST(CXTPCalendarThemeOffice2007,
															   GetCalendarCtrl().GetTheme());
	if (!pTheme2007)
		return;

	//	pTheme2007->SetBeforeDrawFlags(pTheme2007->GetBeforeDrawFlags() |
	// xtpCalendarBeforeDraw_MonthViewDay);
	//	pTheme2007->SetBeforeDrawFlags(pTheme2007->GetBeforeDrawFlags() |
	// xtpCalendarBeforeDraw_DayViewEvent);

	// add icons for reminder and meting flags as custom icons
	// See Also:
	//	CAdvancedCalendarOptionsDlg::OnOK()
	//	The custom icons images added there and IDs assigned to them.

	// wParam - [in] CXTPCalendarViewGroup* - A pointer to Group View.
	// lParam - [in/out] CXTPCalendarEvents* - A pointer to events array to draw.

	CXTPCalendarEvents* pEvents = (CXTPCalendarEvents*)lParam;
	_ASSERTE(pEvents);
	if (!pEvents)
		return;

	int nCount = pEvents->GetCount();
	for (int i = 0; i < nCount; i++)
	{
		CXTPCalendarEvent* pEvent = pEvents->GetAt(i);
		_ASSERTE(pEvent);

		if (!pEvent)
			continue;

		if (pEvent->IsReminder())
		{
			pEvent->GetCustomIcons()->AddIfNeed((UINT)xtpCalendarEventIconIDReminder);
		}
		else
		{
			pEvent->GetCustomIcons()->RemoveID((UINT)xtpCalendarEventIconIDReminder);
		}

		if (pEvent->IsMeeting())
		{
			pEvent->GetCustomIcons()->AddIfNeed((UINT)xtpCalendarEventIconIDMeeting);
		}
		else
		{
			pEvent->GetCustomIcons()->RemoveID((UINT)xtpCalendarEventIconIDMeeting);
		}

		//-------------------------------------------------------------------
		// There are 3 standard icons for Office2007 theme:
		//  * recurrence occurrence
		//  * recurrence exception
		//  * private
		// Its IDs are from from XTPCalendarEventIconIDs enum.
		// If custom icons have an icon with the same ID as standard
		// icon - custom icon will be used instead of standard.
		//-------------------------------------------------------------------

		// this code customize private icon from the standard Office2007
		// theme set.
		//
		// uncomment code below to see the customization.

		if (pEvent->IsPrivate())
		{
			pEvent->GetCustomIcons()->AddIfNeed((UINT)xtpCalendarEventIconIDPrivate);
		}
		else
		{
			pEvent->GetCustomIcons()->RemoveID((UINT)xtpCalendarEventIconIDPrivate);
		}
	}
}

void CCalendarDemoView::OnEventSelChanged(XTP_NOTIFY_CODE idEvent, WPARAM wParam, LPARAM /*lParam*/)
{
#ifdef _XTP_INCLUDE_COMMANDBARS

	_ASSERTE(XTP_NC_CALENDAR_SELECTION_CHANGED == idEvent);

	if (XTP_NC_CALENDAR_SELECTION_CHANGED != idEvent)
		return;

	if (wParam != xtpCalendarSelectionDays)
		return;

	CXTPCalendarView* pView = GetCalendarCtrl().GetActiveView();
	if (!pView)
		return;

	CMainFrame* pMainFrame = (CMainFrame*)AfxGetMainWnd();
	if (!pMainFrame)
		return;

	CXTPRibbonBar* pRibbonBar = pMainFrame->m_pRibbonBar;
	if (!pRibbonBar)
		return;

	CXTPRibbonTab* pTabMeeting = pRibbonBar->FindTab(ID_TAB_MEETING);

	if (pView->IsSingleEventSelected())
	{
		CXTPCalendarViewEvent* pViewEvent = pView->GetLastSelectedViewEvent();

		if (!pViewEvent)
			return;

		if (!pTabMeeting)
		{
			pTabMeeting = pRibbonBar->AddTab(ID_TAB_MEETING);

			if (!pTabMeeting)
				return;

			pTabMeeting->SetContextTab(xtpRibbonTabContextColorGreen, _T("Calendar Tools"));

			CXTPRibbonGroup* pGroupActions = pTabMeeting->AddGroup(_T("Actions"));
			if (pGroupActions)
			{
				pGroupActions->Add(xtpControlButton, ID_CALENDAR_MEETING_OPEN);
				pGroupActions->Add(xtpControlButton, ID_CALENDAR_MEETING_DELETE);
			}

			CXTPRibbonGroup* pGroupTags = pTabMeeting->AddGroup(_T("Tags"));
			if (pGroupTags)
			{
				CXTPControlPopup* pPopup = (CXTPControlPopup*)pGroupTags->Add(
					xtpControlPopup, ID_CALENDAR_MEETING_CATEGORIZE);

				CMenu menu;
				VERIFY(menu.LoadMenu(IDR_MENU_CATEGORIES));
				pPopup->SetCommandBar(menu.GetSubMenu(0));

				pGroupTags->Add(xtpControlButton, ID_CALENDAR_MEETING_REMINDER)
					->SetStyle(xtpButtonIconAndCaption);
				pGroupTags->Add(xtpControlButton, ID_CALENDAR_MEETING_PRIVATE)
					->SetStyle(xtpButtonIconAndCaption);
				pGroupTags->Add(xtpControlButton, ID_CALENDAR_MEETING_MEETING)
					->SetStyle(xtpButtonIconAndCaption);
			}

			if (pTabMeeting)
			{
				pRibbonBar->SetCurSel(pTabMeeting->GetIndex());
			}
		}
	}
	else
	{
		if (pTabMeeting)
		{
			pRibbonBar->RemoveTab(pTabMeeting->GetIndex());
		}
	}

#else
	UNREFERENCED_PARAMETER(idEvent);
	UNREFERENCED_PARAMETER(wParam);
#endif /*_XTP_INCLUDE_COMMANDBARS*/
}

void CCalendarDemoView::SetTheme(XTPCalendarTheme nCalendarTheme)
{
	CXTPCalendarControl::CUpdateContext updateContext(&GetCalendarCtrl(), xtpCalendarUpdateAll);

	CXTPCalendarControl& wndCalendar = GetCalendarCtrl();
	wndCalendar.SetPaintTheme(nCalendarTheme);
	wndCalendar.SetBorders(XTP_DPI_X(1), 0, 0, 0);

	CXTPCalendarCaptionBarControl& wndCaptionBar = GetCalendarCaptionBarCtrl();
	CXTPCalendarCaptionBarTheme* pTheme			 = wndCaptionBar.GetTheme();
	if (pTheme)
	{
		pTheme->SetSwitchViewButtons(!(nCalendarTheme >= xtpCalendarThemeOffice2013));
		_ResizeControls();
	}

	switch (nCalendarTheme)
	{
		case xtpCalendarThemeOffice2013:
		// case xtpCalendarThemeOffice2016:
		case xtpCalendarThemeVisualStudio2015:
		case xtpCalendarThemeVisualStudio2017:
		case xtpCalendarThemeVisualStudio2019:
		case xtpCalendarThemeVisualStudio2022:
			wndCaptionBar.SetBorders(XTP_DPI_X(1), 0, 0, 0);
			break;
		default: wndCaptionBar.SetBorders(XTP_DPI_X(1), XTP_DPI_Y(1), 0, 0); break;
	}

	if (nCalendarTheme == xtpCalendarThemeResource)
	{
		CXTPCalendarThemeOffice2007* pTheme2007 = DYNAMIC_DOWNCAST(CXTPCalendarThemeOffice2007,
																   pTheme);
		if (pTheme2007)
		{
			CXTPImageManager* pIM = pTheme2007->GetCustomIconsList();
			if (pIM)
			{
				pIM->SetIcon(IDI_MEETING_ICON, (UINT)xtpCalendarEventIconIDMeeting, CSize(16, 16));
				pIM->SetIcon(IDI_PRIVATE_ICON, (UINT)xtpCalendarEventIconIDPrivate, CSize(16, 16));
			}
		}
	}

#ifdef _XTP_INCLUDE_COMMANDBARS
	if (nCalendarTheme == xtpCalendarThemeResource)
	{
		m_wndVScrollBar.SetScrollBarStyle(xtpScrollStyleOffice2007Dark);
		m_wndHScrollBar.SetScrollBarStyle(xtpScrollStyleOffice2007Dark);
	}
	else
	{
		m_wndVScrollBar.SetScrollBarStyle(xtpScrollStyleDefault);
		m_wndHScrollBar.SetScrollBarStyle(xtpScrollStyleDefault);
	}
#endif
}

void CCalendarDemoView::OnAddTestCategory()
{
	if (m_bTestCategory)
		return;

	CXTPCalendarData* pData = GetCalendarCtrl().GetDataProvider();
	if (pData)
	{
		COLORREF clrTeal  = RGB(117, 202, 177);
		COLORREF clrOlive = RGB(171, 187, 141);

		// add a new label to the calendar event label list.
		int nIndex = XTP_SAFE_GET2(pData, GetLabelList(), GetCount(), 0);
		pData->AddEventLabel(nIndex, _T("Olive Label (Test)"), clrOlive);

		// add a new category to the calendar event category list.
		UINT uID = XTP_SAFE_GET2(pData, GetEventCategories(), GetCount(), 1) + 1;
		pData->AddEventCategory(uID, _T("Teal Category (Test)"),
								CXTPDrawHelpers::DarkenColorLum(clrTeal, 0.60), clrTeal);

		m_bTestCategory = TRUE;
	}
}

void CCalendarDemoView::OnUpdateAddTestCategory(CCmdUI* pCmdUI)
{
	pCmdUI->SetCheck(m_bTestCategory);
}

void CCalendarDemoView::OnFilePrintPreview()
{
#ifdef _XTP_INCLUDE_COMMANDBARS
	// In derived classes, implement special window handling here
	// Be sure to Unhook Frame Window close if hooked.

	// must not create this on the frame.  Must outlive this function
	CPrintPreviewState* pState = new CPrintPreviewState;

	// DoPrintPreview's return value does not necessarily indicate that
	// Print preview succeeded or failed, but rather what actions are necessary
	// at this point.  If DoPrintPreview returns TRUE, it means that
	// OnEndPrintPreview will be (or has already been) called and the
	// pState structure will be/has been deleted.
	// If DoPrintPreview returns FALSE, it means that OnEndPrintPreview
	// WILL NOT be called and that cleanup, including deleting pState
	// must be done here.

	if (!DoPrintPreview(XTP_IDD_PREVIEW_DIALOGBAR, this, RUNTIME_CLASS(CXTPPreviewView), pState))
	{
		// In derived classes, reverse special window handling here for
		// Preview failure case
		TRACE0("Error: DoPrintPreview failed.\n");
		AfxMessageBox(AFX_IDP_COMMAND_FAILURE);
		delete pState; // preview failed to initialize, delete State now
	}
#else
	CXTPCalendarControlView::OnFilePrintPreview();
#endif
}

CXTPCalendarEvent* CCalendarDemoView::GetSelEvent()
{
	return XTP_SAFE_GET2(GetCalendarCtrl().GetActiveView(), GetLastSelectedViewEvent(), GetEvent(),
						 NULL);
}

void CCalendarDemoView::OnCalendarMeetingOpen()
{
	CXTPCalendarEvent* pEvent	 = GetSelEvent();
	CXTPCalendarEventPtr ptrEvent = pEvent->CloneEvent();

	CXTPCalendarEventPropertiesDlg dlg(&GetCalendarCtrl(), FALSE, this, ptrEvent);
	dlg.m_bOccurrence = FALSE;
	dlg.DoModal();
}

void CCalendarDemoView::OnCalendarMeetingDelete()
{
	if (AfxMessageBox(_T("Delete the selected event?"), MB_YESNO | MB_ICONQUESTION) == IDYES)
	{
		CXTPCalendarData* pData = GetCalendarCtrl().GetDataProvider();
		if (pData)
		{
			pData->DeleteEvent(GetSelEvent());
		}
	}
}

void CCalendarDemoView::OnCategories(UINT nStyle)
{
	switch (nStyle)
	{
		case ID_CATEGORIES_ALLCATEGORIES:
		{
			CXTPCalendarEventColorDlg dlg(TRUE, &GetCalendarCtrl(), this);
			dlg.DoModal();
		}
		break;

		case ID_CATEGORIES_ALLLABELS:
		{
			CXTPCalendarEventColorDlg dlg(FALSE, &GetCalendarCtrl(), this);
			dlg.DoModal();
		}
		break;

		case ID_CATEGORIES_ALLCATEGORIESANDLABELS:
		{
			CCalendarEventColorDlg dlg(&GetCalendarCtrl(), this);
			dlg.DoModal();
		}
		break;
	}
}

BOOL CCalendarDemoView::IsNotRecurring(CXTPCalendarEvent* pEvent)
{
	return (xtpCalendarRecurrenceNotRecurring == pEvent->GetRecurrenceState());
}

void CCalendarDemoView::OnCalendarMeetingPrivate()
{
	CXTPCalendarEvent* pEvent = GetSelEvent();
	if (pEvent)
	{
		BOOL bPrivate = pEvent->IsPrivate();
		pEvent->SetPrivate(!bPrivate);

		CXTPCalendarControl::CUpdateContext updateContext(&GetCalendarCtrl(),
														  xtpCalendarUpdateLayout
															  | xtpCalendarUpdateRedraw);

		CXTPCalendarData* pData = GetCalendarCtrl().GetDataProvider();
		if (pData)
		{
			VERIFY(pData->ChangeEvent(pEvent));
		}
	}
}

void CCalendarDemoView::OnCalendarMeetingMeeting()
{
	CXTPCalendarEvent* pEvent = GetSelEvent();
	if (pEvent)
	{
		BOOL bMeeting = pEvent->IsMeeting();
		pEvent->SetMeeting(!bMeeting);

		CXTPCalendarControl::CUpdateContext updateContext(&GetCalendarCtrl(),
														  xtpCalendarUpdateLayout
															  | xtpCalendarUpdateRedraw);

		CXTPCalendarData* pData = GetCalendarCtrl().GetDataProvider();
		if (pData)
		{
			VERIFY(pData->ChangeEvent(pEvent));
		}
	}
}

void CCalendarDemoView::OnCalendarMeetingReminder()
{
	CXTPCalendarEvent* pEvent = GetSelEvent();
	if (pEvent)
	{
		BOOL bReminder = pEvent->IsReminder();
		pEvent->SetReminder(!bReminder);

		CXTPCalendarControl::CUpdateContext updateContext(&GetCalendarCtrl(),
														  xtpCalendarUpdateLayout
															  | xtpCalendarUpdateRedraw);

		CXTPCalendarData* pData = GetCalendarCtrl().GetDataProvider();
		if (pData)
		{
			VERIFY(pData->ChangeEvent(pEvent));
		}
	}
}

void CCalendarDemoView::OnUpdateCalendarMeetingPrivate(CCmdUI* pCmdUI)
{
	CXTPCalendarEvent* pEvent = GetSelEvent();
	if (pEvent)
	{
		pCmdUI->SetCheck(pEvent->IsPrivate());
		pCmdUI->Enable(IsNotRecurring(pEvent));
	}
}

void CCalendarDemoView::OnUpdateCalendarMeetingMeeting(CCmdUI* pCmdUI)
{
	CXTPCalendarEvent* pEvent = GetSelEvent();
	if (pEvent)
	{
		pCmdUI->SetCheck(pEvent->IsMeeting());
		pCmdUI->Enable(IsNotRecurring(pEvent));
	}
}

void CCalendarDemoView::OnUpdateCalendarMeetingReminder(CCmdUI* pCmdUI)
{
	CXTPCalendarEvent* pEvent = GetSelEvent();
	if (pEvent)
	{
		pCmdUI->SetCheck(pEvent->IsReminder());
		pCmdUI->Enable(IsNotRecurring(pEvent));
	}
}

void CCalendarDemoView::SetCalendarView(XTPEnumCalendarTimeScaleParamsID eScaleID,
										XTPCalendarViewType calendarViewType)
{
	GetCalendarCtrl().m_nTimelineScale = eScaleID;

	if (GetCalendarCtrl().m_bTimelineMode)
	{
		SetView(xtpCalendarTimeLineView);

		CXTPCalendarTimeLineView* pTimeLineView =
			DYNAMIC_DOWNCAST(CXTPCalendarTimeLineView, GetCalendarCtrl().GetActiveView());
		if (pTimeLineView)
		{
			COleDateTime dtNow(COleDateTime::GetCurrentTime());
			pTimeLineView->SetStartViewDate(dtNow);
			pTimeLineView->SetTimeScaleID(eScaleID);
		}
	}
	else
	{
		if (GetCalendarCtrl().GetActiveView()
			&& GetCalendarCtrl().GetActiveView()->GetViewType() != calendarViewType)
		{
			SetView(calendarViewType);
			OnUpdateTimeScale();
		}
	}
}

void CCalendarDemoView::OnCalendarViewDay()
{
	SetCalendarView(xtpTSPID_Day, xtpCalendarDayView);
}

void CCalendarDemoView::OnCalendarViewWorkWeek()
{
	SetCalendarView(xtpTSPID_WorkWeek, xtpCalendarWorkWeekView);
}

void CCalendarDemoView::OnCalendarViewWeek()
{
	SetCalendarView(xtpTSPID_Week, xtpCalendarWeekView);
}

void CCalendarDemoView::OnCalendarViewMonth()
{
	SetCalendarView(xtpTSPID_Month, xtpCalendarMonthView);

	// In month view Long, Middle and Short formats are always used for first month day header
	// GetCalendarCtrl().GetActiveView()->SetDayHeaderFormatLong(_T("d MMMM yyy"));
	// GetCalendarCtrl().GetActiveView()->SetDayHeaderFormatMiddle(_T("d MMM yy"));
	// GetCalendarCtrl().GetActiveView()->SetDayHeaderFormatShort(_T("d MMM"));
	// GetCalendarCtrl().GetActiveView()->SetDayHeaderFormatShortest(_T("d"));
}

void CCalendarDemoView::OnCalendarTimeline()
{
	GetCalendarCtrl().OnCalendarTimeline();
}

void CCalendarDemoView::OnUpdateCalendarViewDay(CCmdUI* pCmdUI)
{
	BOOL value = FALSE;

	CXTPCalendarView* pView = GetCalendarCtrl().GetActiveView();
	if (pView
		&& (pView->GetViewType() == xtpCalendarDayView || IsTimeLineViewWithScale(xtpTSPID_Day)))
	{
		value = TRUE;
	}

	pCmdUI->SetCheck(value);
}

void CCalendarDemoView::OnUpdateCalendarViewWorkWeek(CCmdUI* pCmdUI)
{
	BOOL value = FALSE;

	CXTPCalendarView* pView = GetCalendarCtrl().GetActiveView();
	if (pView
		&& (pView->GetViewType() == xtpCalendarWorkWeekView
			|| IsTimeLineViewWithScale(xtpTSPID_WorkWeek)))
	{
		value = TRUE;
	}

	pCmdUI->SetCheck(value);
}

void CCalendarDemoView::OnUpdateCalendarViewWeek(CCmdUI* pCmdUI)
{
	BOOL value = FALSE;

	CXTPCalendarView* pView = GetCalendarCtrl().GetActiveView();
	if (pView
		&& (pView->GetViewType() == xtpCalendarWeekView
			|| pView->GetViewType() == xtpCalendarFullWeekView
			|| IsTimeLineViewWithScale(xtpTSPID_Week)))
	{
		value = TRUE;
	}

	pCmdUI->SetCheck(value);
}

void CCalendarDemoView::OnUpdateCalendarViewMonth(CCmdUI* pCmdUI)
{
	BOOL value = FALSE;

	CXTPCalendarView* pView = GetCalendarCtrl().GetActiveView();
	if (pView
		&& (pView->GetViewType() == xtpCalendarMonthView
			|| IsTimeLineViewWithScale(xtpTSPID_Month)))
	{
		value = TRUE;
	}

	pCmdUI->SetCheck(value);
}

void CCalendarDemoView::OnUpdateCalendarTimeline(CCmdUI* pCmdUI)
{
	pCmdUI->SetCheck(GetCalendarCtrl().m_bTimelineMode);
}

BOOL CCalendarDemoView::IsTimeLineViewWithScale(XTPEnumCalendarTimeScaleParamsID eScaleID)
{
	BOOL bTLV_result = FALSE;

	XTPCalendarViewType calendarViewType = GetCalendarCtrl().GetActiveView()->GetViewType();
	if (calendarViewType == xtpCalendarTimeLineView)
	{
		CXTPCalendarTimeLineView* pTLView = DYNAMIC_DOWNCAST(CXTPCalendarTimeLineView,
															 GetCalendarCtrl().GetActiveView());
		_ASSERTE(pTLView != NULL);

		bTLV_result = ((XTPEnumCalendarTimeScaleParamsID)pTLView->GetTimeScaleID() == eScaleID);
	}

	return bTLV_result;
}