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

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

对话框与窗口

开发平台：

Visual C++

CalendarDemoView.cpp：源码内容
  1. // CalendarDemoView.cpp : implementation of the CCalendarDemoView class
  2. //
  3. // This file is a part of the XTREME TOOLKIT PRO MFC class library.
  4. // (c)1998-2008 Codejock Software, All Rights Reserved.
  5. //
  6. // THIS SOURCE FILE IS THE PROPERTY OF CODEJOCK SOFTWARE AND IS NOT TO BE
  7. // RE-DISTRIBUTED BY ANY MEANS WHATSOEVER WITHOUT THE EXPRESSED WRITTEN
  8. // CONSENT OF CODEJOCK SOFTWARE.
  9. //
  10. // THIS SOURCE CODE CAN ONLY BE USED UNDER THE TERMS AND CONDITIONS OUTLINED
  11. // IN THE XTREME TOOLKIT PRO LICENSE AGREEMENT. CODEJOCK SOFTWARE GRANTS TO
  12. // YOU (ONE SOFTWARE DEVELOPER) THE LIMITED RIGHT TO USE THIS SOFTWARE ON A
  13. // SINGLE COMPUTER.
  14. //
  15. // CONTACT INFORMATION:
  16. // support@codejock.com
  17. // http://www.codejock.com
  18. //
  19. /////////////////////////////////////////////////////////////////////////////
  21. #include "stdafx.h"
  22. #include "CalendarDemo.h"
  24. #include "MainFrm.h"
  25. #include "CalendarDemoDoc.h"
  26. #include "CalendarDemoView.h"
  27. #include "DataProvidersOptions.h"
  28. #include "AdvancedCalendarOptionsDlg.h"
  30. #include "resource.h"
  33. #ifdef _DEBUG
  34. #define new DEBUG_NEW
  35. #undef THIS_FILE
  36. static char THIS_FILE[] = __FILE__;
  37. #endif
  39. //////////////////////////////////////////////////////////////////////////
  40. extern CString GetDPName(int nDPType);
  41. extern int GetDPType(CXTPCalendarData* pData);
  43. //////////////////////////////////////////////////////////////////////////
  44. static CXTPCalendarRemindersDialog* s_pDlgReminders = NULL;
  46. CString cstrMarkupDynamicSample(
  47. _T("<StackPanel Margin='2, 2, 2, 2' VerticalAlignment='Top'")
  48. _T("HorizontalAlignment='Center'>")
  49. _T("<TextBlock Padding='0,10,0,0' TextWrapping='Wrap'>")
  50. _T("<Italic>Dynamically Customized Subject:</Italic><Bold>/Calendar/Events/Event/Subject</Bold></TextBlock>")
  51. _T("<TextBlock Padding='0,10,0,0'>Dynamically Customized Body:</TextBlock>")
  52. _T("<TextBlock Padding='10,10,0,0' TextWrapping='Wrap'>")
  53. _T("/Calendar/Events/Event/Body")
  54. _T("</TextBlock>")
  55. _T("<TextBlock Padding='10,10,0,0'> - Regards</TextBlock>")
  56. _T("</StackPanel>"));
  58. /////////////////////////////////////////////////////////////////////////////
  59. // CCalendarDemoView
  61. IMPLEMENT_DYNCREATE(CCalendarDemoView, CXTPCalendarControlView)
  63. BEGIN_MESSAGE_MAP(CCalendarDemoView, CXTPCalendarControlView)
  64. //{{AFX_MSG_MAP(CCalendarDemoView)
  65. ON_WM_CREATE()
  66. //}}AFX_MSG_MAP
  67. // Standard printing commands
  68. ON_COMMAND(ID_FILE_PAGE_SETUP, CXTPCalendarControlView::OnFilePageSetup)
  69. ON_COMMAND(ID_FILE_PRINT, CXTPCalendarControlView::OnFilePrint)
  70. ON_COMMAND(ID_FILE_PRINT_PREVIEW, CXTPCalendarControlView::OnFilePrintPreview)
  72. ON_COMMAND(ID_FILE_SAVE, OnFileSave)
  73. ON_COMMAND(ID_FILE_SAVE_AS, OnFileSaveAs)
  75. ON_UPDATE_COMMAND_UI(ID_FILE_SAVE, OnUpdateFileSave)
  76. ON_UPDATE_COMMAND_UI(ID_FILE_SAVE_AS, OnUpdateFileSaveAs)
  77. // User commands
  78. ON_COMMAND(ID_VIEW_REMINDERS, OnViewReminders)
  79. ON_UPDATE_COMMAND_UI(ID_VIEW_REMINDERS,  OnUpdateViewReminders)
  81. ON_COMMAND(ID_CALENDAR_VIEW_DAY, OnCalendarViewDay)
  82. ON_COMMAND(ID_CALENDAR_VIEW_WORKWEEK, OnCalendarViewWorkWeek)
  83. ON_COMMAND(ID_CALENDAR_VIEW_WEEK, OnCalendarViewWeek)
  84. ON_COMMAND(ID_CALENDAR_VIEW_MONTH, OnCalendarViewMonth)
  85. ON_UPDATE_COMMAND_UI(ID_CALENDAR_VIEW_DAY, OnUpdateCalendarViewDay)
  86. ON_UPDATE_COMMAND_UI(ID_CALENDAR_VIEW_WORKWEEK, OnUpdateCalendarViewWorkWeek)
  87. ON_UPDATE_COMMAND_UI(ID_CALENDAR_VIEW_WEEK, OnUpdateCalendarViewWeek)
  88. ON_UPDATE_COMMAND_UI(ID_CALENDAR_VIEW_MONTH, OnUpdateCalendarViewMonth)
  89. ON_COMMAND(ID_CALENDAR_CHANGETIMESCALE_60MINUTES, OnCalendarTimescale60)
  90. ON_COMMAND(ID_CALENDAR_CHANGETIMESCALE_30MINUTES, OnCalendarTimescale30)
  91. ON_COMMAND(ID_CALENDAR_CHANGETIMESCALE_15MINUTES, OnCalendarTimescale15)
  92. ON_COMMAND(ID_CALENDAR_CHANGETIMESCALE_10MINUTES, OnCalendarTimescale10)
  93. ON_COMMAND(ID_CALENDAR_CHANGETIMESCALE_6MINUTES,  OnCalendarTimescale6)
  94. ON_COMMAND(ID_CALENDAR_CHANGETIMESCALE_5MINUTES,  OnCalendarTimescale5)
  95. ON_UPDATE_COMMAND_UI(ID_CALENDAR_CHANGETIMESCALE_60MINUTES, OnUpdateCalendarTimescale60)
  96. ON_UPDATE_COMMAND_UI(ID_CALENDAR_CHANGETIMESCALE_30MINUTES, OnUpdateCalendarTimescale30)
  97. ON_UPDATE_COMMAND_UI(ID_CALENDAR_CHANGETIMESCALE_15MINUTES, OnUpdateCalendarTimescale15)
  98. ON_UPDATE_COMMAND_UI(ID_CALENDAR_CHANGETIMESCALE_10MINUTES, OnUpdateCalendarTimescale10)
  99. ON_UPDATE_COMMAND_UI(ID_CALENDAR_CHANGETIMESCALE_6MINUTES,  OnUpdateCalendarTimescale6)
  100. ON_UPDATE_COMMAND_UI(ID_CALENDAR_CHANGETIMESCALE_5MINUTES,  OnUpdateCalendarTimescale5)
  101. ON_COMMAND(ID_CALENDAR_CHANGETIMESCALE_CHANGETIMEZONE,  OnCalendarTimezone)
  102. ON_COMMAND(ID_CALENDAR_ADD_NEW_EVENT, OnAddNewEvent)
  104. // ON_COMMAND(ID_CALENDAR_LANGUAGE_RUSSIAN,  OnCalendarLangRussian)
  105. // ON_COMMAND(ID_CALENDAR_LANGUAGE_DEFAULT,  OnCalendarLangDefault)
  107. ON_BN_CLICKED(IDC_TIME_ZONE_BTN, OnCalendarTimezone)
  108. ON_BN_CLICKED(IDC_ADVANCED_OPT_BTN, OnAdvancedOptions)
  110. END_MESSAGE_MAP()
  113. /////////////////////////////////////////////////////////////////////////////
  114. // CCalendarDemoView construction/destruction
  116. CCalendarDemoView::CCalendarDemoView()
  117. {
  118. m_dsDayViewDays.SetDateTimeSpan(4,0,0,0);
  120. SetCalendarCtrl(&m_wndCalendarEx, FALSE);
  122. // Advise To Notifications
  123. CXTPNotifyConnection* ptrCalendarConn = GetCalendarCtrl().GetConnection();
  124. ASSERT(ptrCalendarConn);
  126. if(!ptrCalendarConn) {
  127. return;
  128. }
  130. m_nScale = -1;
  132. m_Sink.Advise(ptrCalendarConn, XTP_NC_CALENDARCONTEXTMENU, &CCalendarDemoView::OnEvent_Calendar);
  133. m_Sink.Advise(ptrCalendarConn, XTP_NC_CALENDARLBUTTONDBLCLICK, &CCalendarDemoView::OnEvent_Calendar);
  134. m_Sink.Advise(ptrCalendarConn, XTP_NC_CALENDARKEYDOWN, &CCalendarDemoView::OnEvent_Calendar);
  136. m_Sink.Advise(ptrCalendarConn, XTP_NC_CALENDAR_IS_EVENT_EDIT_OPERATION_DISABLED, &CCalendarDemoView::OnEvent_IsEditActionDisabled);
  137. m_Sink.Advise(ptrCalendarConn, XTP_NC_CALENDAR_BEFORE_EVENT_EDIT_OPERATION, &CCalendarDemoView::OnEvent_BeforeEditAction);
  139. m_Sink.Advise(ptrCalendarConn, XTP_NC_CALENDAR_PREPOPULATE, &CCalendarDemoView::OnEvent_PrePopulate);
  141. //m_Sink.Advise(ptrCalendarConn, XTP_NC_CALENDAR_SELECTION_CHANGED, &CCalendarDemoView::OnEvent_SelChanged);
  142.     
  143. // Advise to Calendar Data Provider notifications
  144. m_Sink.Advise(ptrCalendarConn, XTP_NC_CALENDAREVENTWASADDED, &CCalendarDemoView::OnEvent_CalendarData);
  145. m_Sink.Advise(ptrCalendarConn, XTP_NC_CALENDAREVENTWASDELETED, &CCalendarDemoView::OnEvent_CalendarData);
  146. m_Sink.Advise(ptrCalendarConn, XTP_NC_CALENDAREVENTWASCHANGED, &CCalendarDemoView::OnEvent_CalendarData);
  148. m_Sink.Advise(ptrCalendarConn, XTP_NC_CALENDARPATTERNWASADDED, &CCalendarDemoView::OnEvent_CalendarData);
  149. m_Sink.Advise(ptrCalendarConn, XTP_NC_CALENDARPATTERNWASDELETED, &CCalendarDemoView::OnEvent_CalendarData);
  150. m_Sink.Advise(ptrCalendarConn, XTP_NC_CALENDARPATTERNWASCHANGED, &CCalendarDemoView::OnEvent_CalendarData);
  152. // m_Sink.Advise(ptrCalendarConn, XTP_NC_CALENDAR_ON_REMINDERS, &CCalendarDemoView::OnReminders);
  154. m_Sink.Advise(ptrCalendarConn, XTP_NC_CALENDAR_BEFORE_DRAW_THEMEOBJECT, &CCalendarDemoView::OnBeforeDrawThemeObject);
  156. m_Sink.Advise(ptrCalendarConn, XTP_NC_CALENDAR_GETITEMTEXT, &CCalendarDemoView::OnEvent_GetItemText);
  158. }
  160. CCalendarDemoView::~CCalendarDemoView()
  161. {
  162. if (s_pDlgReminders)
  163. delete s_pDlgReminders;
  164. s_pDlgReminders = NULL;
  165. }
  167. BOOL CCalendarDemoView::PreCreateWindow(CREATESTRUCT& cs)
  168. {
  169. // TODO: Modify the Window class or styles here by modifying
  170. //  the CREATESTRUCT cs
  171. cs.style &= ~WS_BORDER;
  173. return CXTPCalendarControlView::PreCreateWindow(cs);
  174. }
  176. /////////////////////////////////////////////////////////////////////////////
  177. // CCalendarDemoView drawing
  179. void CCalendarDemoView::OnDraw(CDC* pDC)
  180. {
  181. UNREFERENCED_PARAMETER(pDC);
  183. CCalendarDemoDoc* pDoc = GetDocument();
  184. ASSERT_VALID(pDoc);
  185. }
  187. /////////////////////////////////////////////////////////////////////////////
  188. // CCalendarDemoView diagnostics
  190. #ifdef _DEBUG
  191. void CCalendarDemoView::AssertValid() const
  192. {
  193. CXTPCalendarControlView::AssertValid();
  194. }
  196. void CCalendarDemoView::Dump(CDumpContext& dc) const
  197. {
  198. CXTPCalendarControlView::Dump(dc);
  199. }
  201. CCalendarDemoDoc* CCalendarDemoView::GetDocument() // non-debug version is inline
  202. {
  203. ASSERT(m_pDocument->IsKindOf(RUNTIME_CLASS(CCalendarDemoDoc)));
  204. return (CCalendarDemoDoc*)m_pDocument;
  205. }
  206. #endif //_DEBUG
  208. /////////////////////////////////////////////////////////////////////////////
  209. // CCalendarDemoView message handlers
  211. int CCalendarDemoView::OnCreate(LPCREATESTRUCT lpCreateStruct) 
  212. {
  213. if (CXTPCalendarControlView::OnCreate(lpCreateStruct) == -1)
  214. return -1;
  216. ((CWnd*)&GetCalendarCtrl())->EnableToolTips(TRUE);
  218. CCalendarDemoDoc* pDoc = GetDocument();
  219. if (pDoc)
  220. {
  221. pDoc->m_pCalendar = &GetCalendarCtrl();
  222. }
  223.     
  224. m_CalendarController.SetCalendar(&GetCalendarCtrl());
  226. m_wndScrollBar.Create(WS_CHILD | WS_VISIBLE | SBS_VERT, CRect(0, 0, 0, 0), this, 100);
  227. m_wndScrollBar.SetScrollBarStyle(xtpScrollStyleOffice2007Dark);
  228. SetScrollBarCtrl(&m_wndScrollBar);
  230. return 0;
  231. }
  233. //////////////////////////////////////////////////////////////////////////
  234. //  User message handlers
  235. //
  237. void CCalendarDemoView::SetView(XTPCalendarViewType viewType)
  238. {
  239. GetCalendarCtrl().SwitchActiveView(viewType);
  241. //GetCalendarCtrl().GetActiveView()->SetDayHeaderFormatLong(_T("dddd, d MMMM yyyy 'year'"));
  242. //GetCalendarCtrl().GetActiveView()->SetDayHeaderFormatMiddle(_T("ddd, d MMM yy"));
  243. //GetCalendarCtrl().GetActiveView()->SetDayHeaderFormatShort(_T("d MMMM"));
  244. //GetCalendarCtrl().GetActiveView()->SetDayHeaderFormatShortest(_T("d MMM"));
  246. ((CMainFrame*)GetParentFrame())->m_dlgOptions.OnViewChanged(viewType);
  247. }
  251. void CCalendarDemoView::OnCalendarViewDay() 
  252. {
  253. if(GetCalendarCtrl().GetActiveView() && 
  254. GetCalendarCtrl().GetActiveView()->GetViewType() != xtpCalendarDayView) 
  255. {
  256. TRACE(_T("Switch to 1 day view.n"));
  257. SetView(xtpCalendarDayView);
  259. OnUpdateTimeScale();
  260. }
  261. }
  263. void CCalendarDemoView::OnCalendarViewWorkWeek() 
  264. {
  265. if(GetCalendarCtrl().GetActiveView() && 
  266. GetCalendarCtrl().GetActiveView()->GetViewType() != xtpCalendarWorkWeekView) 
  267. {
  268. TRACE(_T("Switch to work week day view.n"));
  269. SetView(xtpCalendarWorkWeekView);
  271. OnUpdateTimeScale();
  272. }
  273. }
  275. void CCalendarDemoView::OnCalendarViewWeek() 
  276. {
  277. if(GetCalendarCtrl().GetActiveView() && 
  278. GetCalendarCtrl().GetActiveView()->GetViewType() != xtpCalendarWeekView) 
  279. {
  280. TRACE(_T("Switch to week view.n"));
  281. SetView(xtpCalendarWeekView);
  282. }
  283. }
  285. void CCalendarDemoView::OnCalendarViewMonth() 
  286. {   
  287. // CXTPCalendarControl::CUpdateContext cnt(&GetCalendarCtrl(), xtpCalendarUpdateLayout);
  289. if(GetCalendarCtrl().GetActiveView() && 
  290. GetCalendarCtrl().GetActiveView()->GetViewType() != xtpCalendarMonthView) 
  291. {
  292. TRACE(_T("Switch to month view.n"));
  293. SetView(xtpCalendarMonthView);
  295. }
  297. // In month view Long, Middle and Short formats are always used for first month day header
  298. //GetCalendarCtrl().GetActiveView()->SetDayHeaderFormatLong(_T("d MMMM yyy"));
  299. //GetCalendarCtrl().GetActiveView()->SetDayHeaderFormatMiddle(_T("d MMM yy"));
  300. //GetCalendarCtrl().GetActiveView()->SetDayHeaderFormatShort(_T("d MMM"));
  302. // // In month view Shortest format is always used for not first month day header
  303. //GetCalendarCtrl().GetActiveView()->SetDayHeaderFormatShortest(_T("d"));
  304. }
  306. void CCalendarDemoView::OnUpdateCalendarViewDay(CCmdUI* pCmdUI) 
  307. {
  308. BOOL bViewDay = FALSE;
  309. CXTPCalendarView* pView = GetCalendarCtrl().GetActiveView();
  310. if (pView && pView->GetViewType() == xtpCalendarDayView) {
  311. bViewDay = TRUE;
  312. }
  313. pCmdUI->SetCheck(bViewDay);
  314. }
  316. void CCalendarDemoView::OnUpdateCalendarViewWorkWeek(CCmdUI* pCmdUI) 
  317. {
  318. BOOL bViewDays = FALSE;
  319. CXTPCalendarView* pView = GetCalendarCtrl().GetActiveView();
  320. if (pView && pView->GetViewType() == xtpCalendarWorkWeekView) {
  321. bViewDays = TRUE;
  322. }
  323. pCmdUI->SetCheck(bViewDays);
  324. }
  326. void CCalendarDemoView::OnUpdateCalendarViewWeek(CCmdUI* pCmdUI) 
  327. {
  328. BOOL bViewWeek = FALSE;
  329. CXTPCalendarView* pView = GetCalendarCtrl().GetActiveView();
  330. if (pView && pView->GetViewType() == xtpCalendarWeekView) 
  331. bViewWeek = TRUE;
  332. pCmdUI->SetCheck(bViewWeek);
  333. }
  335. void CCalendarDemoView::OnUpdateCalendarViewMonth(CCmdUI* pCmdUI) 
  336. {
  337. BOOL bViewMonth = FALSE;
  338. CXTPCalendarView* pView = GetCalendarCtrl().GetActiveView();
  339. if (pView && pView->GetViewType() == xtpCalendarMonthView) 
  340. bViewMonth = TRUE; 
  341. pCmdUI->SetCheck(bViewMonth);
  342. }
  344. //////////////////////////////////////////////////////////////////////////
  346. void CCalendarDemoView::SetCalendarToolTipMode(int nToolTipMode)
  347. {
  348. m_wndCalendarEx.m_nToolTipMode = nToolTipMode;
  350. GetCalendarCtrl().EnableToolTips(nToolTipMode == ctmStandard);
  351. }
  353. void CCalendarDemoView::SetCalendarTimeScale(int nScale)
  354. {
  355. m_nScale = nScale;
  356. OnUpdateTimeScale();
  357. }
  359. void CCalendarDemoView::OnCalendarTimescale60() 
  360. {
  361. SetCalendarTimeScale(60);
  362. }
  364. void CCalendarDemoView::OnCalendarTimescale30() 
  365. {
  366. SetCalendarTimeScale(30);
  367. }
  369. void CCalendarDemoView::OnCalendarTimescale15() 
  370. {
  371. SetCalendarTimeScale(15);
  372. }
  374. void CCalendarDemoView::OnCalendarTimescale10() 
  375. {
  376. SetCalendarTimeScale(10);
  377. }
  379. void CCalendarDemoView::OnCalendarTimescale6() 
  380. {
  381. SetCalendarTimeScale(6);
  382. }
  384. void CCalendarDemoView::OnCalendarTimescale5() 
  385. {
  386. SetCalendarTimeScale(5);
  387. }
  389. void CCalendarDemoView::OnUpdateCalendarTimescale60(CCmdUI* pCmdUI)
  390. {
  391. OnUpdateCalendarTimescale(pCmdUI, 60);
  392. }
  394. void CCalendarDemoView::OnUpdateCalendarTimescale30(CCmdUI* pCmdUI)
  395. {
  396. OnUpdateCalendarTimescale(pCmdUI, 30);
  397. }
  399. void CCalendarDemoView::OnUpdateCalendarTimescale15(CCmdUI* pCmdUI)
  400. {
  401. OnUpdateCalendarTimescale(pCmdUI, 15);
  402. }
  404. void CCalendarDemoView::OnUpdateCalendarTimescale10(CCmdUI* pCmdUI)
  405. {
  406. OnUpdateCalendarTimescale(pCmdUI, 10);
  407. }
  409. void CCalendarDemoView::OnUpdateCalendarTimescale6(CCmdUI* pCmdUI)
  410. {
  411. OnUpdateCalendarTimescale(pCmdUI, 6);
  412. }
  414. void CCalendarDemoView::OnUpdateCalendarTimescale5(CCmdUI* pCmdUI)
  415. {
  416. OnUpdateCalendarTimescale(pCmdUI, 5);
  417. }
  421. void CCalendarDemoView::OnUpdateCalendarTimescale(CCmdUI* pCmdUI, int nScale) 
  422. {
  423. BOOL bEnable = FALSE;
  424. BOOL bChecked = FALSE;
  426. CXTPCalendarDayView* pDayView = DYNAMIC_DOWNCAST(CXTPCalendarDayView, GetCalendarCtrl().GetActiveView());
  427. if (pDayView) 
  428. {
  429. bEnable = TRUE;
  431. if (pDayView->GetScaleInterval().GetTotalMinutes() == nScale) 
  432. bChecked = TRUE;
  433. }
  435. pCmdUI->Enable(bEnable);
  436. pCmdUI->SetCheck(bChecked);
  437. }
  439. void CCalendarDemoView::OnUpdateViewReminders(CCmdUI* pCmdUI)
  440. {
  441. pCmdUI->Enable(GetCalendarCtrl().IsRemindersEnabled());
  442. }
  444. CString GetModulePath()
  445. {
  446. TCHAR szCurPath[_MAX_PATH + 2];
  447. ::GetModuleFileName(AfxGetInstanceHandle(), szCurPath, _MAX_PATH);
  449. CString strCurPath(szCurPath);
  450. strCurPath = strCurPath.Left(strCurPath.ReverseFind('\')+1);
  452. return strCurPath;
  453. }
  455. //void CCalendarDemoView::OnCalendarLangDefault()
  456. //{
  457. // XTPResourceManager()->SetResourceFile(_T(""));
  458. //
  459. // GetCalendarCtrl().Populate();
  460. //
  461. // m_wndDatePicker.AdjustLayout();
  462. // m_wndDatePicker.RedrawControl();
  463. //}
  465. //void CCalendarDemoView::OnCalendarLangRussian()
  466. //{
  467. // CString strRCpath = GetModulePath();
  468. //
  469. // strRCpath += _T("Translations\ToolkitPro.ResourceRu.dll");
  470. //  
  471. // XTPResourceManager()->SetResourceFile(strRCpath);
  472. //
  473. // GetCalendarCtrl().Populate();
  474. //
  475. // m_wndDatePicker.AdjustLayout();
  476. // m_wndDatePicker.RedrawControl();
  477. //
  478. //}
  480. //////////////////////////////////////////////////////////////////////////
  481. //
  482. void CCalendarDemoView::OnAddNewEvent() 
  483. {
  484. AddNewEvent();
  485. }
  487. void CCalendarDemoView::AddNewEvent(CPoint* /*pPtHitContext*/) 
  488. {
  489. CXTPCalendarEventPropertiesDlg dlg(&GetCalendarCtrl(), TRUE, this);
  490. dlg.DoModal();
  491. }
  493. void CCalendarDemoView::OnCalendarTimezone() 
  494. {
  495. TRACE(_T("Time zone dialog.n"));
  497. CXTPCalendarOptions* pOptions = GetCalendarCtrl().GetCalendarOptions();
  498. ASSERT(pOptions);
  499. if (pOptions) 
  500. {
  501. CXTPCalendarTimeScalePropertiesDlg dlg;
  502. // init parameters
  503. dlg.m_strCaption1 = pOptions->strDayView_ScaleLabel;
  504. dlg.m_strCaption2 = pOptions->strDayView_Scale2Label;
  505. dlg.m_bShowScale2 = pOptions->bDayView_Scale2Visible;
  506. dlg.m_tziScale2   = pOptions->tziDayView_Scale2TimeZone;
  508. // execute and save
  509. if (dlg.DoModal() == IDOK)
  510. {
  511. // first time scale
  512. pOptions->strDayView_ScaleLabel = dlg.m_strCaption1;
  514. // second time scale
  515. pOptions->bDayView_Scale2Visible = dlg.m_bShowScale2;
  516. if (dlg.m_bShowScale2)
  517. {
  518. pOptions->strDayView_Scale2Label = dlg.m_strCaption2;
  519. pOptions->tziDayView_Scale2TimeZone = dlg.m_tziScale2;
  520. }
  522. pOptions->OnOptionsChanged();
  523. // redraw
  524. GetCalendarCtrl().Populate();
  525. }
  526. }
  527. }
  529. void CCalendarDemoView::OnAdvancedOptions()
  530. {
  531. CAdvancedCalendarOptionsDlg dlgOptEx(&GetCalendarCtrl(), this);
  533. dlgOptEx.DoModal();
  534. }
  537. void CCalendarDemoView::OnInitialUpdate() 
  538. {
  539. CXTPCalendarControlView::OnInitialUpdate();
  541. // date picker
  542. CMainFrame* pWnd = (CMainFrame*)AfxGetMainWnd();
  544. //m_CalendarController.SetBoldDaysPerIdleStep(1);
  545. //m_CalendarController.SetBoldDaysIdleStepTime_ms(999);
  546. m_CalendarController.SetDatePicker(&pWnd->m_dlgDatePicker.m_wndDatePicker);
  547.     
  548. //---------------------------------------------------------------------------
  549. m_dtDayViewStart = COleDateTime::GetCurrentTime();
  550. //---------------------------------------------------------------------------
  552. ((CMainFrame*)GetParentFrame())->m_dlgOptions.Init();
  554. m_nScale = GetCalendarCtrl().GetCalendarOptions()->nDayView_ScaleInterval;
  555.     
  556. // initial settings
  557. OnCalendarViewWorkWeek();
  559. CXTPCalendarDayView* pDayView = DYNAMIC_DOWNCAST(CXTPCalendarDayView, GetCalendarCtrl().GetDayView() );
  560. if(pDayView) {
  561. pDayView->ScrollToWorkDayBegin();
  562. }
  563. //---------------------------------------------------------------------------
  564. OnOfficeThemeChanged(xtpCalendarThemeOffice2007);
  566. CreateRemindersWindow();
  568. ShowCaptionBar(TRUE);
  569. }
  571. void CCalendarDemoView::OnUpdateTimeScale()
  572. {   
  573. CXTPCalendarDayView* pDayView = DYNAMIC_DOWNCAST(CXTPCalendarDayView, GetCalendarCtrl().GetActiveView());
  574. if (pDayView) 
  575. {
  576. pDayView->SetScaleInterval(COleDateTimeSpan(0, m_nScale/60, m_nScale%60, 0));
  577. } 
  578. else {
  579. GetCalendarCtrl().GetCalendarOptions()->nDayView_ScaleInterval = m_nScale;
  580. GetCalendarCtrl().GetCalendarOptions()->OnOptionsChanged();
  581. }
  582. }
  585. void CCalendarDemoView::OnEvent_Calendar(XTP_NOTIFY_CODE Event, WPARAM wParam, LPARAM lParam)
  586. {
  587. UNREFERENCED_PARAMETER(lParam);
  589. if (!GetCalendarCtrl().GetActiveView())
  590. return;
  592. CPoint ptHit(wParam);
  593. XTP_CALENDAR_HITTESTINFO hitInfo;
  594. BOOL bHitTest = GetCalendarCtrl().GetActiveView()->HitTest(ptHit, &hitInfo);
  596. if (XTP_NC_CALENDARKEYDOWN == Event)
  597. {
  598. if (wParam == VK_RETURN && !GetCalendarCtrl().GetActiveView()->IsEditingSubject()
  599. && GetCalendarCtrl().GetActiveView()->GetDraggingMode() == xtpCalendaDragModeUnknown)
  600. {
  601. CXTPCalendarViewEvents* selectedEvents = GetCalendarCtrl().GetActiveView()->GetSelectedViewEvents();
  603. if (selectedEvents && selectedEvents->GetCount() > 0)
  604. {
  606. CXTPCalendarEventPtr ptrEvent = selectedEvents->GetAt(0)->GetEvent()->CloneEvent();
  608. CXTPCalendarEventPropertiesDlg dlg(&GetCalendarCtrl(), FALSE, this, ptrEvent);
  609. dlg.DoModal();
  611. }
  612. else
  613. {
  614. AddNewEvent();
  616. }
  617. }
  618. }
  619. else if (XTP_NC_CALENDARCONTEXTMENU == Event)
  620. {
  621. if (bHitTest)
  622. {
  623. CPoint ptMenu = ptHit;
  624. GetCalendarCtrl().ClientToScreen(&ptMenu);
  626. if (hitInfo.pViewEvent)
  627. {
  628. CMenu menu;
  629. VERIFY(menu.LoadMenu(IDR_MENU_CONTEXT_EVENT));
  631. // track menu
  632. int nMenuResult = CXTPCommandBars::TrackPopupMenu(menu.GetSubMenu(0), 
  633. TPM_NONOTIFY | TPM_RETURNCMD | TPM_LEFTALIGN |TPM_RIGHTBUTTON, 
  634. ptMenu.x, ptMenu.y, this, NULL);
  636. // general items processing
  637. switch (nMenuResult)
  638. {
  639. case ID_POPUP_DELETEEVENT:
  640. {
  641. VERIFY( GetCalendarCtrl().DoDeleteSelectedEvents(hitInfo.pViewEvent) );
  643. GetCalendarCtrl().Populate();
  644. }
  645. break;
  646. case ID_POPUP_PROPERTIES:
  647. {
  648. ASSERT(hitInfo.pViewEvent);
  649. if(hitInfo.pViewEvent)
  650. {
  651. CXTPCalendarEvent* pEvent = hitInfo.pViewEvent->GetEvent();
  652. CXTPCalendarEventPtr ptrEvent = pEvent->CloneEvent();
  654. CXTPCalendarControl::CUpdateContext updateContext(&GetCalendarCtrl(), xtpCalendarUpdateLayout|xtpCalendarUpdateRedraw);
  655. CXTPCalendarEventPropertiesDlg dlg(&GetCalendarCtrl(), FALSE, this, ptrEvent);
  656. dlg.DoModal();
  657. }
  658. }
  659. break;
  660. }
  661. }
  662. else if (GetCalendarCtrl().GetActiveView()->IsKindOf( RUNTIME_CLASS(CXTPCalendarDayView) ))
  663. {
  664. CMenu menu;
  665. VERIFY(menu.LoadMenu(IDR_MENU_CONTEXT_DAY));
  667. CXTPCalendarDayView* pDayView = DYNAMIC_DOWNCAST(CXTPCalendarDayView, GetCalendarCtrl().GetActiveView());
  668. if (pDayView)
  669. {
  670. int nInterval = (int)pDayView->GetScaleInterval().GetTotalMinutes();
  671. int nMenuItem = nInterval >= 60 ? ID_CALENDAR_CHANGETIMESCALE_60MINUTES :
  672. (nInterval >= 30 ? ID_CALENDAR_CHANGETIMESCALE_30MINUTES :
  673. (nInterval >= 15 ? ID_CALENDAR_CHANGETIMESCALE_15MINUTES :
  674. (nInterval >= 10 ? ID_CALENDAR_CHANGETIMESCALE_10MINUTES :
  675. (nInterval >=  6 ? ID_CALENDAR_CHANGETIMESCALE_6MINUTES :
  676. (nInterval >=  5 ? ID_CALENDAR_CHANGETIMESCALE_5MINUTES : 0)))));
  677. menu.CheckMenuItem(nMenuItem, MF_CHECKED);
  678. }
  680. // track menu
  681. int nMenuResult = CXTPCommandBars::TrackPopupMenu(menu.GetSubMenu(0), 
  682. TPM_NONOTIFY | TPM_RETURNCMD | TPM_LEFTALIGN |TPM_RIGHTBUTTON, 
  683. ptMenu.x, ptMenu.y, this, NULL);
  685. // general items processing
  686. switch (nMenuResult)
  687. {
  688. case ID_CALENDAR_CHANGETIMESCALE_60MINUTES:
  689. OnCalendarTimescale60();
  690. break;
  691. case ID_CALENDAR_CHANGETIMESCALE_30MINUTES:
  692. OnCalendarTimescale30();
  693. break;
  694. case ID_CALENDAR_CHANGETIMESCALE_15MINUTES:
  695. OnCalendarTimescale15();
  696. break;
  697. case ID_CALENDAR_CHANGETIMESCALE_10MINUTES:
  698. OnCalendarTimescale10();
  699. break;
  700. case ID_CALENDAR_CHANGETIMESCALE_6MINUTES:
  701. OnCalendarTimescale6();
  702. break;
  703. case ID_CALENDAR_CHANGETIMESCALE_5MINUTES:
  704. OnCalendarTimescale5();
  705. break;
  706. case ID_CALENDAR_CHANGETIMESCALE_CHANGETIMEZONE:
  707. OnCalendarTimezone();
  708. break;
  709. case ID_CALENDAR_ADD_NEW_EVENT:
  710. AddNewEvent(&ptHit);
  711. break;
  712. default:
  713. ASSERT(nMenuResult == 0);
  714. }
  715. }
  716. else //if (GetCalendarCtrl().GetActiveView()->IsKindOf( RUNTIME_CLASS(CXTPCalendarWeekView) ))
  717. {
  718. CMenu menu;
  719. VERIFY(menu.LoadMenu(IDR_MENU_CONTEXT_WEEK));
  721. // track menu
  722. int nMenuResult = CXTPCommandBars::TrackPopupMenu(menu.GetSubMenu(0), 
  723. TPM_NONOTIFY | TPM_RETURNCMD | TPM_LEFTALIGN |TPM_RIGHTBUTTON, 
  724. ptMenu.x, ptMenu.y, this, NULL);
  726. // general items processing
  727. switch (nMenuResult)
  728. {
  729. case ID_POPUP_GOTOTHISDAY:
  730. {
  731. GetCalendarCtrl().SwitchActiveView(xtpCalendarDayView);
  732. CXTPCalendarDayView* pDayView = DYNAMIC_DOWNCAST(CXTPCalendarDayView, GetCalendarCtrl().GetActiveView());
  733. if (pDayView)
  734. {
  735. COleDateTime dtThisDay(hitInfo.dt);
  736. pDayView->ResetSelection();
  737. pDayView->ShowDay(dtThisDay);
  738. }
  739. }
  740. break;
  741. case ID_CALENDAR_ADD_NEW_EVENT:
  742. AddNewEvent(&ptHit);
  743. break;
  744. }
  745. }
  746. }
  747. }
  748. else if (XTP_NC_CALENDARLBUTTONDBLCLICK == Event)
  749. {
  750. if (bHitTest && hitInfo.pViewEvent)
  751. {
  752. // mouse double clicked - show event edit dialog
  753. CXTPCalendarEvent* pEvent = hitInfo.pViewEvent->GetEvent();
  754. CXTPCalendarEventPtr ptrEvent = pEvent->CloneEvent();
  755.             
  756. if(hitInfo.pViewEvent->IsShowingToolTip()) { 
  757. hitInfo.pViewEvent->HideToolTip(); 
  758. }
  760. CXTPCalendarEventPropertiesDlg dlg(&GetCalendarCtrl(), FALSE, this, ptrEvent);
  761. dlg.DoModal();
  762. }
  763. else if (bHitTest && (hitInfo.uHitCode & (xtpCalendarHitTestDayArea|xtpCalendarHitTestDayHeader)))
  764. {
  765. AddNewEvent(&ptHit);
  766. }
  767. }
  768. }
  770. void CCalendarDemoView::OnFileSave()
  771. {
  772. CXTPCalendarData* pData = GetCalendarCtrl().GetDataProvider();
  773. if(!pData) {
  774. ASSERT(FALSE);
  775. return;
  776. }
  777. if(GetDPType(pData) == xtpCalendarDataProviderMemory) 
  778. {
  779. CString strFileName = AfxGetApp()->GetProfileString(cstrDP_Opt_section, cstrUseDP_Mem_File_opt);
  780. if(!pData->Save()) 
  781. {
  782. CString strDPname = GetDPName(xtpCalendarDataProviderMemory);
  783. CString strMsg;
  784. strMsg.Format(_T("%s cannot create file: n%s"), strDPname, strFileName);
  785. AfxMessageBox(strMsg);
  786. }
  787. }  
  788. }
  790. void CCalendarDemoView::OnFileSaveAs()
  791. {
  792. CXTPCalendarData* pData = GetCalendarCtrl().GetDataProvider();
  793. if(!pData) {
  794. ASSERT(FALSE);
  795. return;
  796. }
  797. if(GetDPType(pData) != xtpCalendarDataProviderMemory) {
  798. ASSERT(FALSE);
  799. return;
  800. }  
  802. CDataProvidersOptions optDlg;
  803. optDlg.m_strTitle = _T("Save calendar data as:");
  804. optDlg.m_bOpenMode = FALSE;
  805. optDlg.m_bWarnIfExist = TRUE;
  806. optDlg.m_eMode = CDataProvidersOptions::modeMemOnly;
  808. int nDlgRes = (int)optDlg.DoModal();
  809. if(nDlgRes != IDOK) {
  810. return;
  811. }
  813. CString strFileName = AfxGetApp()->GetProfileString(cstrDP_Opt_section, cstrUseDP_Mem_File_opt);
  814. if(!pData->Save()) 
  815. {
  816. CString strDPname = GetDPName(xtpCalendarDataProviderMemory);
  817. CString strMsg;
  818. strMsg.Format(_T("%s cannot create file: n%s"), strDPname, strFileName);
  819. AfxMessageBox(strMsg);
  820. }
  821. }
  823. void CCalendarDemoView::OnUpdateFileSave(CCmdUI* pCmdUI)
  824. {
  825. CXTPCalendarData* pData = GetCalendarCtrl().GetDataProvider();
  827. int nDPType = GetDPType(pData);
  829. pCmdUI->Enable(nDPType == xtpCalendarDataProviderMemory);
  830. }
  832. void CCalendarDemoView::OnUpdateFileSaveAs(CCmdUI* pCmdUI)
  833. {
  834. OnUpdateFileSave(pCmdUI);
  835. }
  837. void CCalendarDemoView::OnEvent_IsEditActionDisabled(XTP_NOTIFY_CODE Event, 
  838. WPARAM wParam, LPARAM lParam)
  839. {   
  840. if (XTP_NC_CALENDAR_IS_EVENT_EDIT_OPERATION_DISABLED != Event) {
  841. ASSERT(FALSE);
  842. return;
  843. }
  845. XTP_EVENT_EDIT_OPERATION_PARAMS* pOPparams = (XTP_EVENT_EDIT_OPERATION_PARAMS*)wParam;
  846. BOOL* pbCancel = (BOOL*)lParam;
  847. ASSERT(pbCancel);
  849. // check is already canceled/handled
  850. if(!pOPparams || !pbCancel || *pbCancel) {
  851. return;
  852. }
  854. // Disable dragging for recurrence events
  855. //
  856. // CXTPCalendarEvent* pEvent = pOPparams->pEventViews->GetAt(0)->GetEvent();
  857. // ASSERT(pEvent);
  859. // if((pOPparams->eOperation == xtpCalendarEO_DragCopy || pOPparams->eOperation == xtpCalendarEO_DragMove ||
  860. // pOPparams->eOperation == xtpCalendarEO_DragResizeBegin || pOPparams->eOperation == xtpCalendarEO_DragResizeEnd)
  861. // && pEvent 
  862. // && pEvent->GetRecurrenceState() != xtpCalendarRecurrenceNotRecurring) 
  863. // {
  864. // *pbCancel = TRUE;
  865. // }
  866. }
  868. void CCalendarDemoView::OnEvent_BeforeEditAction(XTP_NOTIFY_CODE Event, 
  869. WPARAM wParam, LPARAM lParam)
  870. {   
  871. if (XTP_NC_CALENDAR_BEFORE_EVENT_EDIT_OPERATION != Event) {
  872. ASSERT(FALSE);
  873. return;
  874. }
  875.     
  876. XTP_EVENT_EDIT_OPERATION_PARAMS* pOPparams = (XTP_EVENT_EDIT_OPERATION_PARAMS*)wParam;
  877. BOOL* pbHandled = (BOOL*)lParam;
  878. ASSERT(pbHandled && pOPparams);
  880. // check is already canceled/handled
  881. if(!pOPparams || !pbHandled || *pbHandled) {
  882. return;
  883. }
  885. if(pOPparams->eOperation == xtpCalendarEO_DeleteEvent)
  886. {
  887. if(!pOPparams->pEventViews || !pOPparams->pEventViews->GetAt(0)) {
  888. ASSERT(FALSE);
  889. return;
  890. }
  892. CXTPCalendarEvent* pEvent = pOPparams->pEventViews->GetAt(0)->GetEvent();
  893. if(!pEvent) {
  894. ASSERT(FALSE);
  895. return;
  896. }
  898. if(pEvent->GetRecurrenceState() == xtpCalendarRecurrenceNotRecurring)
  899. {
  900. CString strMsg;
  901. strMsg.Format(_T("Would you like to delete event: "%s" ?"), pEvent->GetSubject());
  902. int nRes = AfxMessageBox(strMsg, MB_YESNO);
  903. if(nRes == IDNO) 
  904. {
  905. *pbHandled = TRUE;
  906. }
  907. }
  908. }
  910. //**  since ver 9.81
  911. //******************
  912. //if (pOPparams->eOperation == xtpCalendarEO_DragMove ||
  913. // pOPparams->eOperation == xtpCalendarEO_DragCopy )
  914. //{
  915. // XTP_EVENT_DRAG_OPERATION_PARAMS* pOpDrag = (XTP_EVENT_DRAG_OPERATION_PARAMS*)pOPparams;
  916. // ASSERT(pOpDrag->pDraggingEvent && pOpDrag->pDraggingEventNew);
  917. //
  918. // if(pOpDrag->pDraggingEvent && pOpDrag->pDraggingEventNew)
  919. // {
  920. // COleDateTime dtOrigStart = pOpDrag->pDraggingEvent->GetStartTime();
  921. // COleDateTime dtNewStart = pOpDrag->pDraggingEventNew->GetStartTime();;
  922. //
  923. // if (CXTPCalendarUtils::ResetTime(dtOrigStart) != CXTPCalendarUtils::ResetTime(dtNewStart) 
  924. // || pOpDrag->pDraggingEvent->IsAllDayEvent() != pOpDrag->pDraggingEventNew->IsAllDayEvent()) 
  925. // {
  926. // *pbHandled = TRUE;
  927. // }
  928. // }
  929. //}
  931. //**  for ver 9.80
  932. //******************
  933. //if(pOPparams->eOperation == xtpCalendarEO_DragMove &&
  934. // GetCalendarCtrl().GetActiveView()->GetDraggingEventOrig())
  935. //{
  936. // CPoint pt;
  937. // GetCursorPos(&pt);
  938. // GetCalendarCtrl().ScreenToClient(&pt);
  940. // XTP_CALENDAR_HITTESTINFO hitInfo;
  941. // if(GetCalendarCtrl().GetActiveView()->HitTest(pt, &hitInfo)) 
  942. // {
  943. // COleDateTime dtOrigStart = GetCalendarCtrl().GetActiveView()->GetDraggingEventOrig()->GetStartTime(); 
  944. //
  945. // // store previous version to rollback
  946. // CXTPCalendarEventPtr ptrEventPrev = GetCalendarCtrl().GetActiveView()->GetDraggingEventNew()->CloneEvent(); 
  947. //
  948. // if(GetCalendarCtrl().GetActiveView()->OnDragging(pt, &hitInfo))
  949. // {
  950. // CXTPCalendarEvent* pEventNew = GetCalendarCtrl().GetActiveView()->GetDraggingEventNew();
  951. // COleDateTime dtNewStart = pEventNew->GetStartTime();
  952. //
  953. // if(CXTPCalendarUtils::ResetTime(dtOrigStart) !=
  954. // CXTPCalendarUtils::ResetTime(dtNewStart) ) 
  955. // {
  956. // *pbHandled = TRUE;
  957. // }
  958. //
  959. // pEventNew->Update(ptrEventPrev);
  960. //
  961. // //TRACE(_T("orig: %s - point: %s = [%d] n"), dtOrigStart.Format(), hitInfo.dt.Format(),
  962. // // *pbHandled);
  963. // }
  964. // }
  965. //}
  966. }
  968. void CCalendarDemoView::OnEvent_CalendarData(XTP_NOTIFY_CODE Event, WPARAM wParam, LPARAM lParam)
  969. {
  970. UNREFERENCED_PARAMETER(lParam);
  971. UNREFERENCED_PARAMETER(wParam);
  973. CString strActionText;
  974.     
  975. switch(Event)
  976. {
  977. case XTP_NC_CALENDAREVENTWASADDED:
  978. strActionText = _T("Event_WasAdded");
  979. break;
  980. case XTP_NC_CALENDAREVENTWASDELETED:
  981. strActionText = _T("Event_WasDeleted");
  982. break;
  983. case XTP_NC_CALENDAREVENTWASCHANGED:
  984. strActionText = _T("Event_WasChanged");
  985. break;
  987. case XTP_NC_CALENDARPATTERNWASADDED:
  988. strActionText = _T("Pattern_WasAdded");
  989. break;
  990. case XTP_NC_CALENDARPATTERNWASDELETED:
  991. strActionText = _T("Pattern_WasDeleted");
  992. break;
  993. case XTP_NC_CALENDARPATTERNWASCHANGED:
  994. strActionText = _T("Pattern_WasChanged");
  995. break;
  996. default:
  997. ASSERT(FALSE);
  998. return;
  999. }
  1001. //===========================================================================
  1002. CXTPCalendarData* pData = GetCalendarCtrl().GetDataProvider();
  1003. if(!pData) {
  1004. ASSERT(FALSE);
  1005. return;
  1006. }
  1008. if(Event == XTP_NC_CALENDAREVENTWASADDED || Event == XTP_NC_CALENDAREVENTWASDELETED ||
  1009. Event == XTP_NC_CALENDAREVENTWASCHANGED)
  1010. {
  1011. //EVENT:
  1012. CXTPCalendarEvent* pEvent = (CXTPCalendarEvent*)lParam;
  1013. if(pEvent)
  1014. {
  1015. COleDateTime dtStart = pEvent->GetStartTime();
  1016. COleDateTime dtEnd = pEvent->GetEndTime();
  1017. CString strSubject = pEvent->GetSubject();
  1018. TRACE(_T("%s (ID=%d): %s-%s, '%s' n"), strActionText, 
  1019. pEvent->GetEventID(), dtStart.Format(), dtEnd.Format(), strSubject);
  1020. } 
  1021. else {
  1022. TRACE(_T("%s (pEvent=%x) n"), strActionText, wParam);
  1023. }
  1024. }
  1025. else {
  1026. //PATTERN:
  1027. CXTPCalendarRecurrencePatternPtr ptrPattern = pData->GetRecurrencePattern((DWORD)wParam);
  1028. if(ptrPattern)
  1029. {
  1030. COleDateTime dtStartPatt = ptrPattern->GetPatternStartDate();
  1031. CXTPCalendarEventPtr ptrMasterEvent = ptrPattern->GetMasterEvent();
  1032. ASSERT(ptrMasterEvent);
  1033. CString strSubject = ptrMasterEvent ? ptrMasterEvent->GetSubject() : _T("");
  1035. TRACE(_T("%s (ID=%d): pattern starts at %s, '%s' n"), strActionText, 
  1036. wParam, dtStartPatt.Format(), strSubject);
  1037. } 
  1038. else {
  1039. TRACE(_T("%s (ID=%d) n"), strActionText, wParam);
  1040. }
  1041. }
  1042. }
  1044. void CCalendarDemoView::CreateRemindersWindow()
  1045. {
  1046. if(!s_pDlgReminders || !s_pDlgReminders->GetSafeHwnd()) 
  1047. {
  1048. if(!s_pDlgReminders)
  1049. s_pDlgReminders = new CXTPCalendarRemindersDialog();
  1051. VERIFY( s_pDlgReminders->Create() );
  1052. s_pDlgReminders->CenterWindow();
  1054. s_pDlgReminders->SetRemindersManager(&GetCalendarCtrl());
  1055. }
  1056. }
  1058. void CCalendarDemoView::OnViewReminders()
  1059. {
  1060. s_pDlgReminders->ShowWindow(SW_SHOWNORMAL);
  1061. }
  1063. //void CCalendarDemoView::OnReminders(XTP_NOTIFY_CODE Event, WPARAM wParam , LPARAM lParam)
  1064. //{
  1065. // UNREFERENCED_PARAMETER(lParam);
  1066. //
  1067. // if (Event != XTP_NC_CALENDAR_ON_REMINDERS) {
  1068. // ASSERT(FALSE);
  1069. // return;
  1070. // }
  1071. //
  1072. // int eAction = (int)wParam;
  1073. // if (eAction == xtpCalendarRemindersMonitoringStarted)
  1074. // {
  1075. // CreateRemindersWindow();
  1076. // }
  1077. // if (eAction == xtpCalendarRemindersMonitoringStopped)
  1078. // {
  1079. // if (s_pDlgReminders)
  1080. // {
  1081. // delete s_pDlgReminders;
  1082. // s_pDlgReminders = NULL;
  1083. // }
  1084. // }
  1085. //}
  1087. void CCalendarDemoView::OnBeforeDrawThemeObject(XTP_NOTIFY_CODE Event, WPARAM wParam , LPARAM lParam)
  1088. {
  1089. ASSERT(Event == XTP_NC_CALENDAR_BEFORE_DRAW_THEMEOBJECT);
  1090. if (Event != XTP_NC_CALENDAR_BEFORE_DRAW_THEMEOBJECT)
  1091. return;
  1093. CXTPCalendarThemeOffice2007* pTheme2007 = DYNAMIC_DOWNCAST(CXTPCalendarThemeOffice2007, GetCalendarCtrl().GetTheme());
  1094. ASSERT(pTheme2007);
  1095. if (!pTheme2007)
  1096. return;
  1098. static CFont s_fntStriked;
  1099. if (s_fntStriked.m_hObject == NULL)
  1100. {
  1101. LOGFONT lfIcon;
  1102. VERIFY(::SystemParametersInfo(SPI_GETICONTITLELOGFONT, sizeof(lfIcon), &lfIcon, 0));
  1103. lfIcon.lfWeight = FW_BOLD;
  1105. lfIcon.lfStrikeOut = 1;
  1107. s_fntStriked.CreateFontIndirect(&lfIcon);
  1108. }
  1110. if (wParam == xtpCalendarBeforeDraw_DayViewEvent)
  1111. {
  1112. CXTPCalendarDayViewEvent* pViewEvent = (CXTPCalendarDayViewEvent*)lParam;
  1113. if (pViewEvent && pViewEvent->GetEvent()->GetSubject().Left(1) == _T("*"))
  1114. {
  1116. pTheme2007->GetDayViewPartX()->GetDayPartX()->GetGroupPartX()->GetSingleDayEventPartX()->m_fcsetNormal.fcsetSubject.fntFont.SetCustomValue(&s_fntStriked);
  1117. pTheme2007->GetDayViewPartX()->GetDayPartX()->GetGroupPartX()->GetMultiDayEventPartX()->m_fcsetNormal.fcsetSubject.fntFont.SetCustomValue(&s_fntStriked);
  1119. pTheme2007->GetDayViewPartX()->GetDayPartX()->GetGroupPartX()->GetSingleDayEventPartX()->m_fcsetSelected.fcsetSubject.fntFont.SetCustomValue(&s_fntStriked);
  1120. pTheme2007->GetDayViewPartX()->GetDayPartX()->GetGroupPartX()->GetMultiDayEventPartX()->m_fcsetSelected.fcsetSubject.fntFont.SetCustomValue(&s_fntStriked);
  1121. }
  1122. }
  1124. if (wParam == xtpCalendarBeforeDraw_MonthViewDay)
  1125. {
  1126. CXTPCalendarMonthViewDay* pDay = (CXTPCalendarMonthViewDay*)lParam;
  1128. if (pDay->GetDayDate().GetDayOfWeek() == 3)
  1129. {
  1130. pTheme2007->GetMonthViewPartX()->GetDayPartX()->m_clrBackgroundDark = RGB(196, 128, 128);
  1131. pTheme2007->GetMonthViewPartX()->GetDayPartX()->m_clrBackgroundLight = RGB(230, 128, 128);
  1132. pTheme2007->GetMonthViewPartX()->GetDayPartX()->m_clrBackgroundSelected = RGB(128, 228, 228);
  1133. }
  1134. }
  1135. }
  1137. void CCalendarDemoView::OnEvent_GetItemText(XTP_NOTIFY_CODE Event, WPARAM wParam, LPARAM lParam)
  1138. {
  1139. UNREFERENCED_PARAMETER(lParam);
  1140. XTP_CALENDAR_GETITEMTEXT_PARAMS* pParams = (XTP_CALENDAR_GETITEMTEXT_PARAMS*)wParam ;
  1142. if (XTP_NC_CALENDAR_GETITEMTEXT != Event || !pParams)
  1143. return;
  1145. if (xtpCalendarItemText_EventMarkupTemplate == pParams->nItem)
  1146. {
  1147. pParams->pstrText->Format(cstrMarkupDynamicSample);
  1148. }
  1150. if (xtpCalendarItemText_EventSubject == pParams->nItem)
  1151. {
  1152. // Dynamically customize Location text
  1153. pParams->pstrText->MakeReverse();
  1154. }
  1156. }
  1158. CXTPCalendarControl_Custom::CXTPCalendarControl_Custom()
  1159. {
  1160. m_nToolTipMode = ctmStandard;
  1161. }
  1163. INT_PTR CXTPCalendarControl_Custom::OnToolHitTest(CPoint point, TOOLINFO* pTI) const
  1164. {
  1165. if(m_nToolTipMode == ctmCustom)
  1166. {
  1167. XTP_CALENDAR_HITTESTINFO hitTest;
  1168. if( ((CXTPCalendarControl*)this)->GetActiveView()->HitTest(point, &hitTest))
  1169. {
  1170. if(hitTest.pViewEvent) 
  1171. {
  1172. pTI->hwnd = m_hWnd; //   Handle to a window 
  1173. pTI->uId = (UINT_PTR)m_hWnd; //   Handle to a child window 
  1174. pTI->uFlags |= TTF_IDISHWND | TTF_NOTBUTTON; 
  1176. CString strToolText;
  1177. strToolText.Format(_T("[ID = 0x%08X] (%s - %s) %s"),
  1178. hitTest.pViewEvent->GetEvent()->GetEventID(),
  1179. hitTest.pViewEvent->FormatEventTime(hitTest.pViewEvent->GetEvent()->GetStartTime()),
  1180. hitTest.pViewEvent->FormatEventTime(hitTest.pViewEvent->GetEvent()->GetEndTime()),
  1181. hitTest.pViewEvent->GetEvent()->GetSubject()
  1182. );
  1184. int nBuffSize = strToolText.GetLength()*2 +10;
  1185. TCHAR* pBuffer = (TCHAR*)malloc(nBuffSize);
  1187. STRCPY_S(pBuffer, nBuffSize, (LPCTSTR)strToolText);
  1189. pTI->lpszText = pBuffer;
  1191. return 333;
  1192. }
  1193. }
  1194. }
  1196. return CXTPCalendarControl::OnToolHitTest(point, pTI);
  1197. }
  1199. void CCalendarDemoView::OnEvent_PrePopulate(XTP_NOTIFY_CODE Event, 
  1200.  WPARAM wParam, LPARAM lParam)
  1201. {   
  1202. UNREFERENCED_PARAMETER(wParam);
  1204. if (XTP_NC_CALENDAR_PREPOPULATE != Event) {
  1205. ASSERT(FALSE);
  1206. return;
  1207. }
  1209. // Theme 2007.
  1210. CXTPCalendarThemeOffice2007* pTheme2007 = DYNAMIC_DOWNCAST(CXTPCalendarThemeOffice2007, GetCalendarCtrl().GetTheme());
  1211. if (!pTheme2007)
  1212. return;
  1214. // pTheme2007->SetBeforeDrawFlags(pTheme2007->GetBeforeDrawFlags() | xtpCalendarBeforeDraw_MonthViewDay);
  1215. // pTheme2007->SetBeforeDrawFlags(pTheme2007->GetBeforeDrawFlags() | xtpCalendarBeforeDraw_DayViewEvent);
  1217. // add icons for reminder and meting flags as custom icons
  1218. // See Also: 
  1219. // CAdvancedCalendarOptionsDlg::OnOK() 
  1220. // The custom icons images added there and IDs assigned to them. 
  1222. // wParam - [in] CXTPCalendarViewGroup* - A pointer to Group View.
  1223. // lParam - [in/out] CXTPCalendarEvents* - A pointer to events array to draw.
  1225. CXTPCalendarEvents* pEvents = (CXTPCalendarEvents*)lParam;
  1226. ASSERT(pEvents);
  1227. if (!pEvents)
  1228. return;
  1230. int nCount = pEvents->GetCount();
  1231. for (int i = 0; i < nCount; i++)
  1232. {
  1233. CXTPCalendarEvent* pEvent = pEvents->GetAt(i);
  1234. ASSERT(pEvent);
  1236. if (!pEvent)
  1237. continue;
  1239. if (pEvent->IsReminder()) {
  1240. pEvent->GetCustomIcons()->AddIfNeed((UINT)xtpCalendarEventIconIDReminder);
  1241. }
  1242. else {
  1243. pEvent->GetCustomIcons()->RemoveID((UINT)xtpCalendarEventIconIDReminder);
  1244. }
  1246. if (pEvent->IsMeeting()) {
  1247. pEvent->GetCustomIcons()->AddIfNeed((UINT)xtpCalendarEventIconIDMeeting);
  1248. }
  1249. else {
  1250. pEvent->GetCustomIcons()->RemoveID((UINT)xtpCalendarEventIconIDMeeting);
  1251. }
  1253. //-------------------------------------------------------------------
  1254. // There are 3 standard icons for Office2007 theme: 
  1255. //  * recurrence occurrence
  1256. //  * recurrence exception
  1257. //  * private
  1258. // Its IDs are from from XTPCalendarEventIconIDs enum.
  1259. // If custom icons have an icon with the same ID as standard 
  1260. // icon - custom icon will be used instead of standard.
  1261. //-------------------------------------------------------------------
  1263. // this code customize private icon from the standard Office2007 
  1264. // theme set. 
  1265. //
  1266. // uncomment code below to see the customization. 
  1268. //if (pEvent->IsPrivate()) {
  1269. // pEvent->GetCustomIcons()->AddIfNeed((UINT)xtpCalendarEventIconIDPrivate);
  1270. //}
  1271. //else 
  1272. {
  1273. pEvent->GetCustomIcons()->RemoveID((UINT)xtpCalendarEventIconIDPrivate);
  1274. }
  1276. }
  1277. }
  1279. //void CCalendarDemoView::OnEvent_SelChanged(XTP_NOTIFY_CODE Event, 
  1280. //  WPARAM wParam, LPARAM lParam)
  1281. //{   
  1282. // if (XTP_NC_CALENDAR_SELECTION_CHANGED != Event) {
  1283. // ASSERT(FALSE);
  1284. // return;
  1285. // }
  1286. // if(wParam != xtpCalendarSelectionEvents) {
  1287. // return;
  1288. // }
  1289. //
  1290. // static BOOL s_bInProgress = FALSE;
  1291. //
  1292. // CXTPCalendarView* pView = GetCalendarCtrl().GetActiveView();
  1293. //
  1294. // if(!pView || s_bInProgress) {
  1295. // return;
  1296. // }
  1297. //
  1298. // if(pView->GetSelectedEvents()->GetCount() <= 1) {
  1299. // return;
  1300. // }
  1301. //
  1302. // // Protect from processing self sending notifications.
  1303. // //
  1304. // // see lines below:
  1305. // // pView->UnselectAllEvents(); // will send XTP_NC_CALENDAR_SELECTION_CHANGED
  1306. // // pView->SelectEvent(pLastSelEView->GetEvent()); // will send XTP_NC_CALENDAR_SELECTION_CHANGED
  1307. // //
  1308. // s_bInProgress = TRUE;
  1309. //
  1310. // CXTPCalendarViewEvent* pLastSelEView = pView->GetLastSelectedViewEvent();
  1311. // if(pLastSelEView) 
  1312. // {
  1313. // // Lock event view
  1314. // // for case when it can be destroyed in UnselectAllEvents() call.
  1315. // pLastSelEView->InternalAddRef();
  1316. //
  1317. // pView->UnselectAllEvents();
  1318. // pView->SelectEvent(pLastSelEView->GetEvent());
  1319. //
  1320. // // Unlock event view 
  1321. // pLastSelEView->InternalRelease();
  1322. // }
  1323. //
  1324. // s_bInProgress = FALSE;
  1325. //}
  1327. void CCalendarDemoView::OnOfficeThemeChanged(int nCalendarTheme)
  1328. {
  1329. CXTPCalendarControl::CUpdateContext updateContext(&GetCalendarCtrl(), xtpCalendarUpdateAll);
  1331. GetCalendarCtrl().SetPaintTheme((XTPCalendarTheme)nCalendarTheme);
  1333. if (nCalendarTheme == xtpCalendarThemeOffice2007)
  1334. {
  1335. m_wndScrollBar.SetScrollBarStyle(xtpScrollStyleOffice2007Dark);
  1336. }
  1337. else
  1338. {
  1339. m_wndScrollBar.SetScrollBarStyle(xtpScrollStyleDefault);
  1340. }
  1341. }