1356 lines
39 KiB
C++
1356 lines
39 KiB
C++
// CalendarDemoView.cpp : implementation of the CCalendarDemoView class
|
|
//
|
|
// This file is a part of the XTREME TOOLKIT PRO MFC class library.
|
|
// (c)1998-2008 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 "resource.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'")
|
|
_T("HorizontalAlignment='Center'>")
|
|
_T("<TextBlock Padding='0,10,0,0' TextWrapping='Wrap'>")
|
|
_T("<Italic>Dynamically Customized 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, CXTPCalendarControlView::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_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_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_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)
|
|
|
|
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();
|
|
ASSERT(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::OnEvent_SelChanged);
|
|
|
|
// 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);
|
|
|
|
}
|
|
|
|
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;
|
|
|
|
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
|
|
{
|
|
ASSERT(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());
|
|
|
|
m_wndScrollBar.Create(WS_CHILD | WS_VISIBLE | SBS_VERT, CRect(0, 0, 0, 0), this, 100);
|
|
m_wndScrollBar.SetScrollBarStyle(xtpScrollStyleOffice2007Dark);
|
|
SetScrollBarCtrl(&m_wndScrollBar);
|
|
|
|
return 0;
|
|
}
|
|
|
|
//////////////////////////////////////////////////////////////////////////
|
|
// User message handlers
|
|
//
|
|
|
|
void CCalendarDemoView::SetView(XTPCalendarViewType viewType)
|
|
{
|
|
GetCalendarCtrl().SwitchActiveView(viewType);
|
|
|
|
//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::OnCalendarViewDay()
|
|
{
|
|
if(GetCalendarCtrl().GetActiveView() &&
|
|
GetCalendarCtrl().GetActiveView()->GetViewType() != xtpCalendarDayView)
|
|
{
|
|
TRACE(_T("Switch to 1 day view.\n"));
|
|
SetView(xtpCalendarDayView);
|
|
|
|
OnUpdateTimeScale();
|
|
}
|
|
}
|
|
|
|
void CCalendarDemoView::OnCalendarViewWorkWeek()
|
|
{
|
|
if(GetCalendarCtrl().GetActiveView() &&
|
|
GetCalendarCtrl().GetActiveView()->GetViewType() != xtpCalendarWorkWeekView)
|
|
{
|
|
TRACE(_T("Switch to work week day view.\n"));
|
|
SetView(xtpCalendarWorkWeekView);
|
|
|
|
OnUpdateTimeScale();
|
|
}
|
|
}
|
|
|
|
void CCalendarDemoView::OnCalendarViewWeek()
|
|
{
|
|
if(GetCalendarCtrl().GetActiveView() &&
|
|
GetCalendarCtrl().GetActiveView()->GetViewType() != xtpCalendarWeekView)
|
|
{
|
|
TRACE(_T("Switch to week view.\n"));
|
|
SetView(xtpCalendarWeekView);
|
|
}
|
|
}
|
|
|
|
void CCalendarDemoView::OnCalendarViewMonth()
|
|
{
|
|
// CXTPCalendarControl::CUpdateContext cnt(&GetCalendarCtrl(), xtpCalendarUpdateLayout);
|
|
|
|
if(GetCalendarCtrl().GetActiveView() &&
|
|
GetCalendarCtrl().GetActiveView()->GetViewType() != xtpCalendarMonthView)
|
|
{
|
|
TRACE(_T("Switch to month view.\n"));
|
|
SetView(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"));
|
|
|
|
// // In month view Shortest format is always used for not first month day header
|
|
//GetCalendarCtrl().GetActiveView()->SetDayHeaderFormatShortest(_T("d"));
|
|
}
|
|
|
|
void CCalendarDemoView::OnUpdateCalendarViewDay(CCmdUI* pCmdUI)
|
|
{
|
|
BOOL bViewDay = FALSE;
|
|
CXTPCalendarView* pView = GetCalendarCtrl().GetActiveView();
|
|
if (pView && pView->GetViewType() == xtpCalendarDayView) {
|
|
bViewDay = TRUE;
|
|
}
|
|
pCmdUI->SetCheck(bViewDay);
|
|
}
|
|
|
|
void CCalendarDemoView::OnUpdateCalendarViewWorkWeek(CCmdUI* pCmdUI)
|
|
{
|
|
BOOL bViewDays = FALSE;
|
|
CXTPCalendarView* pView = GetCalendarCtrl().GetActiveView();
|
|
if (pView && pView->GetViewType() == xtpCalendarWorkWeekView) {
|
|
bViewDays = TRUE;
|
|
}
|
|
pCmdUI->SetCheck(bViewDays);
|
|
}
|
|
|
|
void CCalendarDemoView::OnUpdateCalendarViewWeek(CCmdUI* pCmdUI)
|
|
{
|
|
BOOL bViewWeek = FALSE;
|
|
CXTPCalendarView* pView = GetCalendarCtrl().GetActiveView();
|
|
if (pView && pView->GetViewType() == xtpCalendarWeekView)
|
|
bViewWeek = TRUE;
|
|
pCmdUI->SetCheck(bViewWeek);
|
|
}
|
|
|
|
void CCalendarDemoView::OnUpdateCalendarViewMonth(CCmdUI* pCmdUI)
|
|
{
|
|
BOOL bViewMonth = FALSE;
|
|
CXTPCalendarView* pView = GetCalendarCtrl().GetActiveView();
|
|
if (pView && pView->GetViewType() == xtpCalendarMonthView)
|
|
bViewMonth = TRUE;
|
|
pCmdUI->SetCheck(bViewMonth);
|
|
}
|
|
|
|
//////////////////////////////////////////////////////////////////////////
|
|
|
|
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();
|
|
//
|
|
// m_wndDatePicker.AdjustLayout();
|
|
// m_wndDatePicker.RedrawControl();
|
|
//}
|
|
|
|
//void CCalendarDemoView::OnCalendarLangRussian()
|
|
//{
|
|
// CString strRCpath = GetModulePath();
|
|
//
|
|
// strRCpath += _T("Translations\\ToolkitPro.ResourceRu.dll");
|
|
//
|
|
// XTPResourceManager()->SetResourceFile(strRCpath);
|
|
//
|
|
// GetCalendarCtrl().Populate();
|
|
//
|
|
// m_wndDatePicker.AdjustLayout();
|
|
// m_wndDatePicker.RedrawControl();
|
|
//
|
|
//}
|
|
|
|
//////////////////////////////////////////////////////////////////////////
|
|
//
|
|
void CCalendarDemoView::OnAddNewEvent()
|
|
{
|
|
AddNewEvent();
|
|
}
|
|
|
|
void CCalendarDemoView::AddNewEvent(CPoint* /*pPtHitContext*/)
|
|
{
|
|
CXTPCalendarEventPropertiesDlg dlg(&GetCalendarCtrl(), TRUE, this);
|
|
dlg.DoModal();
|
|
}
|
|
|
|
void CCalendarDemoView::OnCalendarTimezone()
|
|
{
|
|
TRACE(_T("Time zone dialog.\n"));
|
|
|
|
CXTPCalendarOptions* pOptions = GetCalendarCtrl().GetCalendarOptions();
|
|
ASSERT(pOptions);
|
|
if (pOptions)
|
|
{
|
|
CXTPCalendarTimeScalePropertiesDlg dlg;
|
|
// init parameters
|
|
dlg.m_strCaption1 = pOptions->strDayView_ScaleLabel;
|
|
dlg.m_strCaption2 = pOptions->strDayView_Scale2Label;
|
|
dlg.m_bShowScale2 = pOptions->bDayView_Scale2Visible;
|
|
dlg.m_tziScale2 = pOptions->tziDayView_Scale2TimeZone;
|
|
|
|
// execute and save
|
|
if (dlg.DoModal() == IDOK)
|
|
{
|
|
// first time scale
|
|
pOptions->strDayView_ScaleLabel = dlg.m_strCaption1;
|
|
|
|
// second time scale
|
|
pOptions->bDayView_Scale2Visible = dlg.m_bShowScale2;
|
|
if (dlg.m_bShowScale2)
|
|
{
|
|
pOptions->strDayView_Scale2Label = dlg.m_strCaption2;
|
|
pOptions->tziDayView_Scale2TimeZone = 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);
|
|
|
|
//---------------------------------------------------------------------------
|
|
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) {
|
|
pDayView->ScrollToWorkDayBegin();
|
|
}
|
|
//---------------------------------------------------------------------------
|
|
OnOfficeThemeChanged(xtpCalendarThemeOffice2007);
|
|
|
|
CreateRemindersWindow();
|
|
|
|
ShowCaptionBar(TRUE);
|
|
}
|
|
|
|
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();
|
|
}
|
|
}
|
|
|
|
|
|
void CCalendarDemoView::OnEvent_Calendar(XTP_NOTIFY_CODE Event, 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 == Event)
|
|
{
|
|
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 == Event)
|
|
{
|
|
if (bHitTest)
|
|
{
|
|
CPoint ptMenu = ptHit;
|
|
GetCalendarCtrl().ClientToScreen(&ptMenu);
|
|
|
|
if (hitInfo.pViewEvent)
|
|
{
|
|
CMenu menu;
|
|
VERIFY(menu.LoadMenu(IDR_MENU_CONTEXT_EVENT));
|
|
|
|
// track menu
|
|
int nMenuResult = CXTPCommandBars::TrackPopupMenu(menu.GetSubMenu(0),
|
|
TPM_NONOTIFY | TPM_RETURNCMD | TPM_LEFTALIGN |TPM_RIGHTBUTTON,
|
|
ptMenu.x, ptMenu.y, this, NULL);
|
|
|
|
// general items processing
|
|
switch (nMenuResult)
|
|
{
|
|
case ID_POPUP_DELETEEVENT:
|
|
{
|
|
VERIFY( GetCalendarCtrl().DoDeleteSelectedEvents(hitInfo.pViewEvent) );
|
|
|
|
GetCalendarCtrl().Populate();
|
|
}
|
|
break;
|
|
case ID_POPUP_PROPERTIES:
|
|
{
|
|
ASSERT(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.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
|
|
int nMenuResult = CXTPCommandBars::TrackPopupMenu(menu.GetSubMenu(0),
|
|
TPM_NONOTIFY | TPM_RETURNCMD | TPM_LEFTALIGN |TPM_RIGHTBUTTON,
|
|
ptMenu.x, ptMenu.y, this, NULL);
|
|
|
|
// 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:
|
|
ASSERT(nMenuResult == 0);
|
|
}
|
|
}
|
|
else //if (GetCalendarCtrl().GetActiveView()->IsKindOf( RUNTIME_CLASS(CXTPCalendarWeekView) ))
|
|
{
|
|
CMenu menu;
|
|
VERIFY(menu.LoadMenu(IDR_MENU_CONTEXT_WEEK));
|
|
|
|
// track menu
|
|
int nMenuResult = CXTPCommandBars::TrackPopupMenu(menu.GetSubMenu(0),
|
|
TPM_NONOTIFY | TPM_RETURNCMD | TPM_LEFTALIGN |TPM_RIGHTBUTTON,
|
|
ptMenu.x, ptMenu.y, this, NULL);
|
|
|
|
// 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:
|
|
AddNewEvent(&ptHit);
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
else if (XTP_NC_CALENDARLBUTTONDBLCLICK == Event)
|
|
{
|
|
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.DoModal();
|
|
}
|
|
else if (bHitTest && (hitInfo.uHitCode & (xtpCalendarHitTestDayArea|xtpCalendarHitTestDayHeader)))
|
|
{
|
|
AddNewEvent(&ptHit);
|
|
}
|
|
}
|
|
}
|
|
|
|
void CCalendarDemoView::OnFileSave()
|
|
{
|
|
CXTPCalendarData* pData = GetCalendarCtrl().GetDataProvider();
|
|
if(!pData) {
|
|
ASSERT(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, strFileName);
|
|
AfxMessageBox(strMsg);
|
|
}
|
|
}
|
|
}
|
|
|
|
void CCalendarDemoView::OnFileSaveAs()
|
|
{
|
|
CXTPCalendarData* pData = GetCalendarCtrl().GetDataProvider();
|
|
if(!pData) {
|
|
ASSERT(FALSE);
|
|
return;
|
|
}
|
|
if(GetDPType(pData) != xtpCalendarDataProviderMemory) {
|
|
ASSERT(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, strFileName);
|
|
AfxMessageBox(strMsg);
|
|
}
|
|
}
|
|
|
|
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 Event,
|
|
WPARAM wParam, LPARAM lParam)
|
|
{
|
|
if (XTP_NC_CALENDAR_IS_EVENT_EDIT_OPERATION_DISABLED != Event) {
|
|
ASSERT(FALSE);
|
|
return;
|
|
}
|
|
|
|
XTP_EVENT_EDIT_OPERATION_PARAMS* pOPparams = (XTP_EVENT_EDIT_OPERATION_PARAMS*)wParam;
|
|
BOOL* pbCancel = (BOOL*)lParam;
|
|
ASSERT(pbCancel);
|
|
|
|
// check is already canceled/handled
|
|
if(!pOPparams || !pbCancel || *pbCancel) {
|
|
return;
|
|
}
|
|
|
|
// Disable dragging for recurrence events
|
|
//
|
|
// CXTPCalendarEvent* pEvent = pOPparams->pEventViews->GetAt(0)->GetEvent();
|
|
// ASSERT(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 Event,
|
|
WPARAM wParam, LPARAM lParam)
|
|
{
|
|
if (XTP_NC_CALENDAR_BEFORE_EVENT_EDIT_OPERATION != Event) {
|
|
ASSERT(FALSE);
|
|
return;
|
|
}
|
|
|
|
XTP_EVENT_EDIT_OPERATION_PARAMS* pOPparams = (XTP_EVENT_EDIT_OPERATION_PARAMS*)wParam;
|
|
BOOL* pbHandled = (BOOL*)lParam;
|
|
ASSERT(pbHandled && pOPparams);
|
|
|
|
// check is already canceled/handled
|
|
if(!pOPparams || !pbHandled || *pbHandled) {
|
|
return;
|
|
}
|
|
|
|
if(pOPparams->eOperation == xtpCalendarEO_DeleteEvent)
|
|
{
|
|
if(!pOPparams->pEventViews || !pOPparams->pEventViews->GetAt(0)) {
|
|
ASSERT(FALSE);
|
|
return;
|
|
}
|
|
|
|
CXTPCalendarEvent* pEvent = pOPparams->pEventViews->GetAt(0)->GetEvent();
|
|
if(!pEvent) {
|
|
ASSERT(FALSE);
|
|
return;
|
|
}
|
|
|
|
if(pEvent->GetRecurrenceState() == xtpCalendarRecurrenceNotRecurring)
|
|
{
|
|
CString strMsg;
|
|
strMsg.Format(_T("Would you like to delete event: \"%s\" ?"), pEvent->GetSubject());
|
|
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;
|
|
// ASSERT(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 Event, WPARAM wParam, LPARAM lParam)
|
|
{
|
|
UNREFERENCED_PARAMETER(lParam);
|
|
UNREFERENCED_PARAMETER(wParam);
|
|
|
|
CString strActionText;
|
|
|
|
switch(Event)
|
|
{
|
|
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:
|
|
ASSERT(FALSE);
|
|
return;
|
|
}
|
|
|
|
//===========================================================================
|
|
CXTPCalendarData* pData = GetCalendarCtrl().GetDataProvider();
|
|
if(!pData) {
|
|
ASSERT(FALSE);
|
|
return;
|
|
}
|
|
|
|
if(Event == XTP_NC_CALENDAREVENTWASADDED || Event == XTP_NC_CALENDAREVENTWASDELETED ||
|
|
Event == 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,
|
|
pEvent->GetEventID(), dtStart.Format(), dtEnd.Format(), strSubject);
|
|
}
|
|
else {
|
|
TRACE(_T("%s (pEvent=%x) \n"), strActionText, wParam);
|
|
}
|
|
}
|
|
else {
|
|
//PATTERN:
|
|
CXTPCalendarRecurrencePatternPtr ptrPattern = pData->GetRecurrencePattern((DWORD)wParam);
|
|
if(ptrPattern)
|
|
{
|
|
COleDateTime dtStartPatt = ptrPattern->GetPatternStartDate();
|
|
CXTPCalendarEventPtr ptrMasterEvent = ptrPattern->GetMasterEvent();
|
|
ASSERT(ptrMasterEvent);
|
|
CString strSubject = ptrMasterEvent ? ptrMasterEvent->GetSubject() : _T("");
|
|
|
|
TRACE(_T("%s (ID=%d): pattern starts at %s, '%s' \n"), strActionText,
|
|
wParam, dtStartPatt.Format(), strSubject);
|
|
}
|
|
else {
|
|
TRACE(_T("%s (ID=%d) \n"), strActionText, 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 Event, WPARAM wParam , LPARAM lParam)
|
|
//{
|
|
// UNREFERENCED_PARAMETER(lParam);
|
|
//
|
|
// if (Event != XTP_NC_CALENDAR_ON_REMINDERS) {
|
|
// ASSERT(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 Event, WPARAM wParam , LPARAM lParam)
|
|
{
|
|
ASSERT(Event == XTP_NC_CALENDAR_BEFORE_DRAW_THEMEOBJECT);
|
|
if (Event != XTP_NC_CALENDAR_BEFORE_DRAW_THEMEOBJECT)
|
|
return;
|
|
|
|
CXTPCalendarThemeOffice2007* pTheme2007 = DYNAMIC_DOWNCAST(CXTPCalendarThemeOffice2007, GetCalendarCtrl().GetTheme());
|
|
ASSERT(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 Event, WPARAM wParam, LPARAM lParam)
|
|
{
|
|
UNREFERENCED_PARAMETER(lParam);
|
|
XTP_CALENDAR_GETITEMTEXT_PARAMS* pParams = (XTP_CALENDAR_GETITEMTEXT_PARAMS*)wParam ;
|
|
|
|
if (XTP_NC_CALENDAR_GETITEMTEXT != Event || !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()),
|
|
hitTest.pViewEvent->FormatEventTime(hitTest.pViewEvent->GetEvent()->GetEndTime()),
|
|
hitTest.pViewEvent->GetEvent()->GetSubject()
|
|
);
|
|
|
|
int nBuffSize = strToolText.GetLength()*2 +10;
|
|
TCHAR* pBuffer = (TCHAR*)malloc(nBuffSize);
|
|
|
|
STRCPY_S(pBuffer, nBuffSize, (LPCTSTR)strToolText);
|
|
|
|
pTI->lpszText = pBuffer;
|
|
|
|
return 333;
|
|
}
|
|
}
|
|
}
|
|
|
|
return CXTPCalendarControl::OnToolHitTest(point, pTI);
|
|
}
|
|
|
|
void CCalendarDemoView::OnEvent_PrePopulate(XTP_NOTIFY_CODE Event,
|
|
WPARAM wParam, LPARAM lParam)
|
|
{
|
|
UNREFERENCED_PARAMETER(wParam);
|
|
|
|
if (XTP_NC_CALENDAR_PREPOPULATE != Event) {
|
|
ASSERT(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;
|
|
ASSERT(pEvents);
|
|
if (!pEvents)
|
|
return;
|
|
|
|
int nCount = pEvents->GetCount();
|
|
for (int i = 0; i < nCount; i++)
|
|
{
|
|
CXTPCalendarEvent* pEvent = pEvents->GetAt(i);
|
|
ASSERT(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::OnEvent_SelChanged(XTP_NOTIFY_CODE Event,
|
|
// WPARAM wParam, LPARAM lParam)
|
|
//{
|
|
// if (XTP_NC_CALENDAR_SELECTION_CHANGED != Event) {
|
|
// ASSERT(FALSE);
|
|
// return;
|
|
// }
|
|
// if(wParam != xtpCalendarSelectionEvents) {
|
|
// return;
|
|
// }
|
|
//
|
|
// static BOOL s_bInProgress = FALSE;
|
|
//
|
|
// CXTPCalendarView* pView = GetCalendarCtrl().GetActiveView();
|
|
//
|
|
// if(!pView || s_bInProgress) {
|
|
// return;
|
|
// }
|
|
//
|
|
// if(pView->GetSelectedEvents()->GetCount() <= 1) {
|
|
// return;
|
|
// }
|
|
//
|
|
// // Protect from processing self sending notifications.
|
|
// //
|
|
// // see lines below:
|
|
// // pView->UnselectAllEvents(); // will send XTP_NC_CALENDAR_SELECTION_CHANGED
|
|
// // pView->SelectEvent(pLastSelEView->GetEvent()); // will send XTP_NC_CALENDAR_SELECTION_CHANGED
|
|
// //
|
|
// s_bInProgress = TRUE;
|
|
//
|
|
// CXTPCalendarViewEvent* pLastSelEView = pView->GetLastSelectedViewEvent();
|
|
// if(pLastSelEView)
|
|
// {
|
|
// // Lock event view
|
|
// // for case when it can be destroyed in UnselectAllEvents() call.
|
|
// pLastSelEView->InternalAddRef();
|
|
//
|
|
// pView->UnselectAllEvents();
|
|
// pView->SelectEvent(pLastSelEView->GetEvent());
|
|
//
|
|
// // Unlock event view
|
|
// pLastSelEView->InternalRelease();
|
|
// }
|
|
//
|
|
// s_bInProgress = FALSE;
|
|
//}
|
|
|
|
void CCalendarDemoView::OnOfficeThemeChanged(int nCalendarTheme)
|
|
{
|
|
CXTPCalendarControl::CUpdateContext updateContext(&GetCalendarCtrl(), xtpCalendarUpdateAll);
|
|
|
|
GetCalendarCtrl().SetPaintTheme((XTPCalendarTheme)nCalendarTheme);
|
|
|
|
if (nCalendarTheme == xtpCalendarThemeOffice2007)
|
|
{
|
|
m_wndScrollBar.SetScrollBarStyle(xtpScrollStyleOffice2007Dark);
|
|
}
|
|
else
|
|
{
|
|
m_wndScrollBar.SetScrollBarStyle(xtpScrollStyleDefault);
|
|
}
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|