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

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

对话框与窗口

开发平台：

Visual C++

XTPCalendarEventPropertiesDlg.cpp：源码内容
  1. // XTPCalendarEventPropertiesDlg.cpp: implementation of the CXTPCalendarEventPropertiesDlg.
  2. //
  3. // This file is a part of the XTREME CALENDAR MFC class library.
  4. // (c)1998-2008 Codejock Software, All Rights Reserved.
  5. //
  6. // THIS SOURCE FILE IS THE PROPERTY OF CODEJOCK SOFTWARE AND IS NOT TO BE
  7. // RE-DISTRIBUTED BY ANY MEANS WHATSOEVER WITHOUT THE EXPRESSED WRITTEN
  8. // CONSENT OF CODEJOCK SOFTWARE.
  9. //
  10. // THIS SOURCE CODE CAN ONLY BE USED UNDER THE TERMS AND CONDITIONS OUTLINED
  11. // IN THE XTREME TOOLKIT PRO LICENSE AGREEMENT. CODEJOCK SOFTWARE GRANTS TO
  12. // YOU (ONE SOFTWARE DEVELOPER) THE LIMITED RIGHT TO USE THIS SOFTWARE ON A
  13. // SINGLE COMPUTER.
  14. //
  15. // CONTACT INFORMATION:
  16. // support@codejock.com
  17. // http://www.codejock.com
  18. //
  19. /////////////////////////////////////////////////////////////////////////////
  21. #include "stdafx.h"
  22. #include "Resource.h"
  24. #include "Common/XTPResourceManager.h"
  25. #include "Common/XTPVC50Helpers.h"
  27. #include "XTPCalendarEventPropertiesDlg.h"
  28. #include "XTPCalendarEventRecurrenceDlg.h"
  29. #include "XTPCalendarOccurSeriesChooseDlg.h"
  31. #include "XTPCalendarUtils.h"
  32. #include "XTPCalendarDefines.h"
  33. #include "XTPCalendarData.h"
  34. #include "XTPCalendarControl.h"
  35. #include "XTPCalendarView.h"
  36. #include "XTPCalendarViewDay.h"
  37. #include "XTPCalendarEventLabel.h"
  38. #include "XTPCalendarThemeOffice2007.h"
  40. #ifdef _DEBUG
  41. #define new DEBUG_NEW
  42. #undef THIS_FILE
  43. static char THIS_FILE[] = __FILE__;
  44. #endif
  46. IMPLEMENT_DYNAMIC(CXTPCalendarEventPropertiesDlg, CDialog)
  47. /////////////////////////////////////////////////////////////////////////////
  48. // CXTPCalendarEventPropertiesDlg dialog
  50. BOOL XTPCalendarIsThemeOffice2007(CXTPCalendarControl* pCalendar)
  51. {
  52. ASSERT(pCalendar);
  54. if (!pCalendar || !pCalendar->GetTheme())
  55. return FALSE;
  57. CXTPCalendarThemeOffice2007* ptheme2007 = DYNAMIC_DOWNCAST(CXTPCalendarThemeOffice2007, pCalendar->GetTheme());
  59. return ptheme2007 != NULL;
  60. }
  62. CXTPCalendarEventCategoryComboBox::CXTPCalendarEventCategoryComboBox()
  63. {
  64. m_nLastKey = 0;
  65. m_pCategories = NULL;
  66. }
  68. CXTPCalendarEventCategoryComboBox::~CXTPCalendarEventCategoryComboBox()
  69. {
  70. CMDTARGET_RELEASE(m_pCategories);
  71. }
  73. BEGIN_MESSAGE_MAP(CXTPCalendarEventCategoryComboBox, CComboBox)
  74. //{{AFX_MSG_MAP(CXTPSyntaxEditColorComboBox)
  75. ON_CONTROL_REFLECT(CBN_SELENDOK, OnSelChange)
  76. ON_CONTROL_REFLECT(CBN_DROPDOWN, OnDropDown)
  77. ON_WM_KEYDOWN()
  78. //}}AFX_MSG_MAP
  79. END_MESSAGE_MAP()
  81. BOOL CXTPCalendarEventCategoryComboBox::Init(CXTPCalendarEventCategories* pCategories, CXTPCalendarEventCategoryIDs* pChecked)
  82. {
  83. ResetContent();
  85. if (!pCategories || !pChecked)
  86. {
  87. ASSERT(FALSE);
  88. return FALSE;
  89. }
  91. m_pCategories = pCategories;
  92. CMDTARGET_ADDREF(m_pCategories);
  94. int nCount = m_pCategories->GetCount();
  95. for (int i = 0; i < nCount; i++)
  96. {
  97. CXTPCalendarEventCategory* pCat = m_pCategories->GetAt(i);
  98. ASSERT(pCat);
  99. if (pCat)
  100. {
  101. int nIdx = AddString(pCat->GetName());
  102. SetItemDataPtr(nIdx, (void*)pCat);
  103. }
  104. }
  106. m_arChecked.RemoveAll();
  107. m_arChecked.Copy(*pChecked);
  109. return TRUE;
  110. }
  112. void CXTPCalendarEventCategoryComboBox::GetChecked(CXTPCalendarEventCategoryIDs* pChecked, BOOL* pbChanged)
  113. {
  114. if (!pChecked)
  115. return;
  117. if (pbChanged)
  118. {
  119. int nCount = m_arChecked.GetSize();
  120. if (nCount == pChecked->GetSize())
  121. {
  122. for (int i = 0; i < nCount; i++)
  123. {
  124. if (m_arChecked[i] != pChecked->GetAt(i))
  125. {
  126. *pbChanged |= TRUE;
  127. break;
  128. }
  129. }
  130. }
  131. else
  132. {
  133. *pbChanged |= TRUE;
  134. }
  135. }
  137. pChecked->RemoveAll();
  138. pChecked->Copy(m_arChecked);
  139. }
  141. void CXTPCalendarEventCategoryComboBox::MeasureItem(LPMEASUREITEMSTRUCT lpMIS)
  142. {
  143. ASSERT(lpMIS->CtlType == ODT_COMBOBOX);
  144. lpMIS->itemHeight = (::GetSystemMetrics(SM_CYVTHUMB)-::GetSystemMetrics(SM_CYEDGE)) + 4;
  145. lpMIS->itemWidth = 0;
  146. }
  148. void CXTPCalendarEventCategoryComboBox::DrawItem(LPDRAWITEMSTRUCT lpDIS)
  149. {
  150. CDC*  pDC       = CDC::FromHandle(lpDIS->hDC);
  151. UINT  itemState = lpDIS->itemState;
  152. UINT  itemID    = lpDIS->itemID;
  153. CRect rcItem    = lpDIS->rcItem;
  155. if (!m_pCategories)
  156. return;
  158. BOOL bDisabled = ((itemState & ODS_DISABLED) == ODS_DISABLED);
  160. if((itemState & ODS_COMBOBOXEDIT) == ODS_COMBOBOXEDIT)
  161. {
  162. if (bDisabled)
  163. {
  164. pDC->SetTextColor(GetXtremeColor(COLOR_GRAYTEXT));
  165. pDC->SetBkColor(GetXtremeColor(COLOR_3DFACE));
  166. pDC->FillSolidRect(&rcItem, GetXtremeColor(COLOR_3DFACE));
  167. }
  169. BOOL bCtrlFocused = GetFocus() == this;
  170. if (bCtrlFocused)
  171. {
  172. pDC->FillSolidRect(&rcItem, GetXtremeColor(COLOR_HIGHLIGHT));
  173. pDC->DrawFocusRect(&rcItem);
  174. }
  176. int nOffset = 0;
  177. int nCount = m_arChecked.GetSize();
  178. for (int i = 0; i < nCount; i++)
  179. {
  180. CXTPCalendarEventCategory* pCat = m_pCategories->Find(m_arChecked.GetAt(i));
  181. ASSERT(pCat);
  182. if (pCat)
  183. {
  184. // Draw category color
  185. CRect rcColor = rcItem;
  186. rcColor.left += nOffset;
  187. rcColor.right = rcColor.left + rcColor.Height();
  188. rcColor.DeflateRect(2, 2, 2, 2);
  190. nOffset += rcColor.Height() + 2;
  192. if (bCtrlFocused)
  193. {
  194. CRect rcColor2 = rcColor;
  195. rcColor2.InflateRect(1, 1, 1, 1);
  196. CXTPCalendarTheme::DrawRoundRect(pDC, rcColor2, RGB(255, 255, 255), TRUE, //NULL);
  197. CBrush::FromHandle((HBRUSH)GetStockObject(LTGRAY_BRUSH)));
  198. }
  200. CXTPCalendarTheme::DrawRoundRect(pDC, rcColor, pCat->GetBorderColor(), FALSE,
  201.  pCat->GetBackgroundColor());
  202. }
  203. }
  205. return;
  206. }
  208. if (itemID == (UINT)-1)
  209. return;
  211. CXTPCalendarEventCategory* pCat = (CXTPCalendarEventCategory*)GetItemDataPtr(itemID);
  212. ASSERT(pCat);
  213. if (!pCat)
  214. return;
  216. BOOL bFocus = ((itemState & ODS_FOCUS) == ODS_FOCUS);
  217. int nFIdx = m_arChecked.Find(pCat->GetID());
  219. pDC->SetBkColor(GetXtremeColor(COLOR_WINDOW));
  221. // draw focus rectangle.
  222. if (bFocus)
  223. {
  224. pDC->SetTextColor(GetXtremeColor(COLOR_HIGHLIGHTTEXT));
  225. pDC->FillSolidRect(&rcItem, GetXtremeColor(COLOR_HIGHLIGHT));
  227. pDC->DrawFocusRect(&rcItem);
  228. }
  229. else if (nFIdx >= 0)
  230. {
  231. pDC->SetTextColor(GetXtremeColor(COLOR_BTNTEXT));
  232. pDC->FillSolidRect(&rcItem, GetXtremeColor(COLOR_BTNFACE));
  233. }
  234. else
  235. {
  236. pDC->SetTextColor(GetXtremeColor(COLOR_WINDOWTEXT));
  237. pDC->FillSolidRect(&rcItem, GetXtremeColor(COLOR_WINDOW));
  238. }
  241. // Draw category color
  242. CRect rcColor = rcItem;
  243. rcColor.right = rcColor.left + rcColor.Height();
  244. rcColor.DeflateRect(3, 3, 3, 3);
  246. if (nFIdx >= 0)
  247. {
  248. CRect rcColor2 = rcColor;
  249. rcColor2.InflateRect(1, 1, 1, 1);
  250. CXTPCalendarTheme::DrawRoundRect(pDC, rcColor2, RGB(255, 255, 255), TRUE, //NULL);
  251. CBrush::FromHandle((HBRUSH)GetStockObject(LTGRAY_BRUSH)));
  252. }
  254. CXTPCalendarTheme::DrawRoundRect(pDC, rcColor, pCat->GetBorderColor(), FALSE,
  255.  pCat->GetBackgroundColor());
  257. // draw text.
  258. CRect rText = rcItem;
  259. rText.left = rcColor.right;
  260. rText.DeflateRect(4, 2, 2, 1);
  262. pDC->SetBkMode(TRANSPARENT);
  263. pDC->DrawText(pCat->GetName(), rText, DT_LEFT | DT_VCENTER| DT_SINGLELINE);
  264. }
  266. int CXTPCalendarEventCategoryComboBox::GetLBCurSel() const
  267. {
  268. if (GetDroppedState() == TRUE)
  269. {
  270. HWND hWnd = ::FindWindow(_T("ComboLBox"), NULL);
  271. if (::IsWindow(hWnd))
  272. {
  273. return (int)::SendMessage(hWnd, LB_GETCURSEL, 0, 0);
  274. }
  275. }
  276. return LB_ERR;
  277. }
  279. void CXTPCalendarEventCategoryComboBox::RedrawLB(BOOL bUpdateNow)
  280. {
  281. if (GetDroppedState() == TRUE)
  282. {
  283. HWND hWnd = ::FindWindow(_T("ComboLBox"), NULL);
  284. if (::IsWindow(hWnd))
  285. {
  286. if (bUpdateNow)
  287. ::UpdateWindow(hWnd);
  288. else
  289. ::InvalidateRect(hWnd, NULL, FALSE);
  290. }
  291. }
  292. }
  294. void CXTPCalendarEventCategoryComboBox::OnKeyDown(UINT nChar, UINT nRepCnt, UINT nFlags)
  295. {
  296. if (nChar == VK_SPACE && GetDroppedState())
  297. {
  298. _OnSelChange(GetLBCurSel());
  300. Invalidate(FALSE);
  301. RedrawLB();
  303. m_nLastKey = nChar;
  305. return;
  306. }
  308. if (nChar == VK_RETURN && m_nLastKey == VK_SPACE)
  309. {
  310. ShowDropDown(FALSE);
  311. Invalidate(FALSE);
  313. return;
  314. }
  316. m_nLastKey = nChar;
  318. CComboBox::OnKeyDown(nChar, nRepCnt, nFlags);
  319. }
  320. void CXTPCalendarEventCategoryComboBox::OnDropDown()
  321. {
  322. SetCurSel(CB_ERR);
  323. m_nLastKey = 0;
  324. }
  326. void CXTPCalendarEventCategoryComboBox::OnSelChange()
  327. {
  328. if (GetDroppedState())
  329. _OnSelChange(GetCurSel());
  330. }
  332. void CXTPCalendarEventCategoryComboBox::_OnSelChange(int nItemIndex)
  333. {
  334. if (!m_pCategories || nItemIndex == CB_ERR || GetDroppedState() == FALSE)
  335. return;
  337. CXTPCalendarEventCategory* pCat = (CXTPCalendarEventCategory*)GetItemDataPtr(nItemIndex);
  338. ASSERT(pCat);
  339. if (!pCat)
  340. return;
  342. int nFIdx = m_arChecked.Find(pCat->GetID());
  344. if (nFIdx < 0)
  345. m_arChecked.InsertAt(0, pCat->GetID());
  346. else
  347. m_arChecked.RemoveAt(nFIdx);
  348. }
  350. /////////////////////////////////////////////////////////////////////////////
  351. CXTPCalendarEventLabelComboBox::CXTPCalendarEventLabelComboBox()
  352. {
  353. m_pLabels = NULL;
  354. }
  356. CXTPCalendarEventLabelComboBox::~CXTPCalendarEventLabelComboBox()
  357. {
  358. CMDTARGET_RELEASE(m_pLabels);
  359. }
  361. void CXTPCalendarEventLabelComboBox::Init(CXTPCalendarEventLabels*  pLabels)
  362. {
  363. ResetContent();
  365. ASSERT(pLabels);
  366. if (!pLabels)
  367. return;
  369. m_pLabels = pLabels;
  370. CMDTARGET_ADDREF(m_pLabels);
  372. for (int i = 0; i < m_pLabels->GetCount(); i++)
  373. {
  374. CXTPCalendarEventLabel* pLbl = m_pLabels->GetAt(i);
  375. ASSERT(pLbl);
  376. if (!pLbl)
  377. continue;
  378. int nIdx = AddString(pLbl->m_strName);
  379. SetItemData(nIdx, (DWORD_PTR)pLbl->m_nLabelID);
  380. }
  381. }
  383. int CXTPCalendarEventLabelComboBox::GetLabelID() const
  384. {
  385. if (GetCurSel() == CB_ERR)
  386. return XTP_IDS_CALENDAR_EVENT_LABEL_NONE;
  388. return (int)GetItemData(GetCurSel());
  389. }
  391. void CXTPCalendarEventLabelComboBox::SetLabelID(int nID)
  392. {
  393. for (int i = 0; i < GetCount(); i++)
  394. {
  395. if (nID == (int)GetItemData(i))
  396. {
  397. SetCurSel(i);
  398. return;
  399. }
  400. }
  402. SetCurSel(CB_ERR);
  403. }
  405. void CXTPCalendarEventLabelComboBox::MeasureItem(LPMEASUREITEMSTRUCT lpMIS)
  406. {
  407. ASSERT(lpMIS->CtlType == ODT_COMBOBOX);
  408. lpMIS->itemHeight = (::GetSystemMetrics(SM_CYVTHUMB)-::GetSystemMetrics(SM_CYEDGE));
  409. lpMIS->itemWidth = 0;
  410. }
  412. void CXTPCalendarEventLabelComboBox::DrawItem(LPDRAWITEMSTRUCT lpDIS)
  413. {
  414. CDC*  pDC       = CDC::FromHandle(lpDIS->hDC);
  415. UINT  itemState = lpDIS->itemState;
  416. UINT  itemID    = lpDIS->itemID;
  417. CRect rcItem    = lpDIS->rcItem;
  419. if (itemID == (UINT)-1 || !m_pLabels)
  420. {
  421. return;
  422. }
  424. int nLabelID = (int)GetItemData(itemID);
  425. CXTPCalendarEventLabel* pLbl = m_pLabels->Find(nLabelID);
  426. if (!pLbl)
  427. return;
  429. BOOL bDisabled = ((itemState & ODS_DISABLED) == ODS_DISABLED);
  430. BOOL bSelected = ((itemState & ODS_SELECTED) == ODS_SELECTED);
  431. BOOL bFocus    = ((itemState & ODS_FOCUS)    == ODS_FOCUS);
  433. // draw background.
  434. if (bDisabled)
  435. {
  436. pDC->SetTextColor(GetXtremeColor(COLOR_GRAYTEXT));
  437. pDC->SetBkColor(GetXtremeColor(COLOR_3DFACE));
  438. pDC->FillSolidRect(&rcItem, GetXtremeColor(COLOR_3DFACE));
  439. }
  440. else
  441. {
  442. if (bSelected)
  443. {
  444. pDC->SetTextColor(GetXtremeColor(COLOR_HIGHLIGHTTEXT));
  445. pDC->SetBkColor(GetXtremeColor(COLOR_WINDOW));
  446. pDC->FillSolidRect(&rcItem, GetXtremeColor(COLOR_HIGHLIGHT));
  447. }
  448. else
  449. {
  450. pDC->SetTextColor(GetXtremeColor(COLOR_WINDOWTEXT));
  451. pDC->SetBkColor(GetXtremeColor(COLOR_WINDOW));
  452. pDC->FillSolidRect(&rcItem, GetXtremeColor(COLOR_WINDOW));
  453. }
  455. // draw focus rectangle.
  456. if (bFocus)
  457. {
  458. pDC->DrawFocusRect(&rcItem);
  459. }
  460. }
  462. // determine the size of the color rectangle.
  463. CRect rColor(rcItem);
  464. rColor.DeflateRect(2,2);
  465. rColor.right = rColor.left + rColor.Height();
  466. rColor.bottom = rColor.top + rColor.Height();
  468. // draw color rectangle.
  469. pDC->FillSolidRect(rColor,
  470. bDisabled? GetXtremeColor(COLOR_3DFACE): pLbl->m_clrColor);
  472. pDC->Draw3dRect(rColor,
  473. GetXtremeColor(bDisabled? COLOR_GRAYTEXT: COLOR_WINDOWTEXT),
  474. GetXtremeColor(bDisabled? COLOR_GRAYTEXT: COLOR_WINDOWTEXT));
  476. // determine the size of the text display.
  477. CRect rText(rColor);
  478. rText.top -= 2;
  479. rText.bottom = rText.top + (::GetSystemMetrics(SM_CYVTHUMB)-::GetSystemMetrics(SM_CYEDGE));
  480. rText.left = rText.right + 4;
  481. rText.right = rcItem.right;
  483. // draw text.
  484. pDC->SetBkMode(TRANSPARENT);
  485. pDC->DrawText(pLbl->m_strName, rText, DT_LEFT | DT_VCENTER | DT_SINGLELINE);
  486. }
  488. /////////////////////////////////////////////////////////////////////////////
  489. CXTPCalendarEventPropertiesDlg::CXTPCalendarEventPropertiesDlg(CXTPCalendarControl* pControl,
  490.  BOOL bAddEvent, CWnd* pParent,
  491.  CXTPCalendarEvent* pEditingEvent, UINT nIDTemplate)
  492. {
  493. InitModalIndirect(XTPResourceManager()->LoadDialogTemplate(nIDTemplate), pParent);
  495. m_nAllDayEventSet = -1;
  497. m_bAddEvent = bAddEvent;
  499. m_bAllDayEvent = FALSE;
  500. m_bPrivate = FALSE;
  501. m_bMeeting = FALSE;
  502. m_bReminder = FALSE;
  503. m_nBusyStatus = xtpCalendarBusyStatusUnknown;
  505. m_bOccurrence = TRUE;
  507. CXTPCalendarData* pData = pControl ? pControl->GetDataProvider() : NULL;
  508. if (!pControl || !pData)
  509. {
  510. ASSERT(FALSE);
  511. return;
  512. }
  513. m_ptrControl = pControl;
  515. m_bCategoriesEnabled = XTPCalendarIsThemeOffice2007(m_ptrControl);
  517. m_ptrEditingEvent.SetPtr(pEditingEvent, TRUE);
  518. if (!pEditingEvent)
  519. {
  520. m_ptrEditingEvent = pData->CreateNewEvent();
  521. if (m_ptrEditingEvent)
  522. {
  523. CXTPCalendarView* pView = m_ptrControl->GetActiveView();
  524. ASSERT(pView);
  526. if (pView)
  527. {
  528. COleDateTime dtSelBegin, dtSelEnd;
  529. BOOL bAllDayEvent = FALSE;
  530. int nGroupIndex = 0;
  532. if (!pView->GetSelection(&dtSelBegin, &dtSelEnd, &bAllDayEvent, &nGroupIndex))
  533. {
  534. dtSelBegin = COleDateTime::GetCurrentTime();
  535. dtSelEnd = dtSelBegin + COleDateTimeSpan(0,1, 0,0);
  536. nGroupIndex = 0;
  537. }
  538. UINT uSchID = XTP_SAFE_GET3(pView, GetViewDay_(0), GetViewGroup_(nGroupIndex), GetScheduleID(), XTP_CALENDAR_UNKNOWN_SCHEDULE_ID);
  540. m_ptrEditingEvent->SetStartTime(min(dtSelBegin, dtSelEnd));
  541. m_ptrEditingEvent->SetEndTime(max(dtSelBegin, dtSelEnd));
  542. m_ptrEditingEvent->SetScheduleID(uSchID);
  544. m_nAllDayEventSet = bAllDayEvent ? 1 : 0;
  546. if (!bAllDayEvent)
  547. m_ptrEditingEvent->SetBusyStatus(xtpCalendarBusyStatusBusy);
  548. }
  549. }
  550. }
  552. if (m_ptrEditingEvent)
  553. {
  554. m_dtStartDate = m_ptrEditingEvent->GetStartTime();
  555. m_dtStartTime = m_dtStartDate;
  557. m_dtEndDate = m_ptrEditingEvent->GetEndTime();
  558. m_dtEndTime = m_dtEndDate;
  560. if (m_ptrEditingEvent->IsAllDayEvent() && CXTPCalendarUtils::IsZeroTime(m_dtEndDate))
  561. {
  562. AddEndDate_ResetTime(m_dtStartDate, m_dtEndDate, -1);
  563. }
  564. }
  567. }
  570. #if _MSC_VER < 1200
  571. AFX_INLINE void DDX_DateTimeCtrl(CDataExchange* pDX, int nIDC, COleDateTime& value)
  572. {
  573. HWND hWndCtrl = pDX->PrepareCtrl(nIDC);
  574. if (pDX->m_bSaveAndValidate)
  575. CXTPDateTimeHelper::GetDateTimeCtrlTime(hWndCtrl, value);
  576. else
  577. CXTPDateTimeHelper::SetDateTimeCtrlTime(hWndCtrl, value);
  578. }
  579. #endif
  581. void CXTPCalendarEventPropertiesDlg::DoDataExchange(CDataExchange* pDX)
  582. {
  583. CDialog::DoDataExchange(pDX);
  585. DDX_Control(pDX, XTP_IDC_COMBO_SCHEDULEID, m_ctrlScheduleIDCB);
  586. DDX_Control(pDX, XTP_IDC_SCHEDULEID_TEXT, m_ctrlScheduleLabel);
  587. DDX_Control(pDX, XTP_IDC_COMBO_REMINDER, m_ctrlReminderCB);
  588. DDX_Control(pDX, XTP_IDC_COMBO_BUSYSTATE, m_ctrlBusyStatusCB);
  589. DDX_Text(pDX, XTP_IDC_EDIT_SUBJECT, m_strSubject);
  590. DDX_Text(pDX, XTP_IDC_EDIT_LOCATION, m_strLocation);
  591. DDX_Text(pDX, XTP_IDC_EDIT_BODY, m_strBody);
  592. DDX_DateTimeCtrl(pDX, XTP_IDC_DTP_START_DATE, m_dtStartDate);
  593. DDX_DateTimeCtrl(pDX, XTP_IDC_DTP_START_TIME, m_dtStartTime);
  594. DDX_DateTimeCtrl(pDX, XTP_IDC_DTP_END_DATE, m_dtEndDate);
  595. DDX_DateTimeCtrl(pDX, XTP_IDC_DTP_END_TIME, m_dtEndTime);
  597. DDX_CBIndex(pDX, XTP_IDC_COMBO_BUSYSTATE, m_nBusyStatus);
  599. DDX_Check(pDX, XTP_IDC_CHECK_ALLDAY_EVENT, m_bAllDayEvent);
  600. DDX_Check(pDX, XTP_IDC_CHECK_PRIVATE, m_bPrivate);
  601. DDX_Check(pDX, XTP_IDC_CHECK_MEETING, m_bMeeting);
  602. DDX_Check(pDX, XTP_IDC_CHECK_REMINDER, m_bReminder);
  603. }
  606. BEGIN_MESSAGE_MAP(CXTPCalendarEventPropertiesDlg, CDialog)
  607. ON_WM_CREATE()
  608. ON_BN_CLICKED(XTP_IDC_CHECK_REMINDER, OnCheckReminder)
  609. ON_BN_CLICKED(XTP_IDC_BUTTON_RECURRECNCE, OnBnClickedButtonRecurrecnce)
  610. ON_BN_CLICKED(XTP_IDC_CHECK_ALLDAY_EVENT, OnBnClickedCheckAlldayEvent)
  611. END_MESSAGE_MAP()
  613. /////////////////////////////////////////////////////////////////////////////
  614. // CXTPCalendarEventPropertiesDlg message handlers
  616. void CXTPCalendarEventPropertiesDlg::OnOK()
  617. {
  618. UpdateData();
  620. CString strReminder;
  621. m_ctrlReminderCB.GetWindowText(strReminder);
  622. int nReminderMinutes = CXTPCalendarUtils::ParceTimeDuration_min(strReminder);
  624. if (nReminderMinutes == INT_MIN)
  625. {
  626. m_ctrlReminderCB.SetFocus();
  627. XTPResourceManager()->ShowMessageBox(XTP_IDS_CALENDAR_WRONG_VALUE);
  628. return;
  629. }
  631. BOOL bChanged = FALSE;
  633. if (m_ptrEditingEvent->GetRecurrenceState() == xtpCalendarRecurrenceOccurrence)
  634. {
  635. VERIFY(m_ptrEditingEvent->MakeAsRException());
  636. }
  638. if (m_strSubject.Compare(m_ptrEditingEvent->GetSubject()))
  639. {
  640. m_ptrEditingEvent->SetSubject(m_strSubject);
  641. bChanged = TRUE;
  642. }
  643. if (m_strLocation.Compare(m_ptrEditingEvent->GetLocation()))
  644. {
  645. m_ptrEditingEvent->SetLocation(m_strLocation);
  646. bChanged = TRUE;
  647. }
  648. if (m_strBody.Compare(m_ptrEditingEvent->GetBody()))
  649. {
  650. m_ptrEditingEvent->SetBody(m_strBody);
  651. bChanged = TRUE;
  652. }
  654. if (m_bOccurrence)
  655. {
  656. COleDateTime dtStartTime(CXTPCalendarUtils::UpdateTime(m_dtStartDate,
  657.    m_dtStartTime));
  658. COleDateTime dtEndTime(CXTPCalendarUtils::UpdateTime(m_dtEndDate, m_dtEndTime));
  660. if (m_bAllDayEvent && CXTPCalendarUtils::IsZeroTime(m_dtEndDate))
  661. {
  662. AddEndDate_ResetTime(m_dtStartDate, dtEndTime, 1);
  663. }
  665. if (dtStartTime != m_ptrEditingEvent->GetStartTime())
  666. {
  667. m_ptrEditingEvent->SetStartTime(dtStartTime);
  668. bChanged = TRUE;
  669. }
  670. if (dtEndTime != m_ptrEditingEvent->GetEndTime())
  671. {
  672. m_ptrEditingEvent->SetEndTime(dtEndTime);
  673. bChanged = TRUE;
  674. }
  676. if (m_bAllDayEvent != m_ptrEditingEvent->IsAllDayEvent())
  677. {
  678. m_ptrEditingEvent->SetAllDayEvent(m_bAllDayEvent);
  679. bChanged = TRUE;
  680. }
  681. }
  682. else
  683. {
  684. //m_ptrEditingEvent->SetAllDayEvent(FALSE);
  685. m_ptrEditingEvent->SetAllDayEvent(m_bAllDayEvent);
  686. }
  688. if (m_nBusyStatus != m_ptrEditingEvent->GetBusyStatus())
  689. {
  690. m_ptrEditingEvent->SetBusyStatus(m_nBusyStatus);
  691. bChanged = TRUE;
  692. }
  694. if (m_bCategoriesEnabled)
  695. {
  696. m_ctrlCategories.GetChecked(m_ptrEditingEvent->GetCategories(), &bChanged);
  697. }
  698. else
  699. {
  700. if (m_ctrlLabelCB.GetLabelID() != m_ptrEditingEvent->GetLabelID())
  701. {
  702. m_ptrEditingEvent->SetLabelID(m_ctrlLabelCB.GetLabelID());
  703. bChanged = TRUE;
  704. }
  705. }
  707. if (m_bPrivate != m_ptrEditingEvent->IsPrivate())
  708. {
  709. m_ptrEditingEvent->SetPrivate(m_bPrivate);
  710. bChanged = TRUE;
  711. }
  713. if (m_bMeeting != m_ptrEditingEvent->IsMeeting())
  714. {
  715. m_ptrEditingEvent->SetMeeting(m_bMeeting);
  716. bChanged = TRUE;
  717. }
  719. if (m_bReminder != m_ptrEditingEvent->IsReminder())
  720. {
  721. m_ptrEditingEvent->SetReminder(m_bReminder);
  722. bChanged = TRUE;
  723. }
  725. if (m_bReminder)
  726. {
  727. if (nReminderMinutes != m_ptrEditingEvent->GetReminderMinutesBeforeStart())
  728. {
  729. m_ptrEditingEvent->SetReminderMinutesBeforeStart(nReminderMinutes);
  730. bChanged = TRUE;
  731. }
  732. }
  734. int nSelSch = m_ctrlScheduleIDCB.GetCurSel();
  735. if (nSelSch != CB_ERR)
  736. {
  737. UINT uSchID = (UINT)m_ctrlScheduleIDCB.GetItemData(nSelSch);
  738. if (uSchID != m_ptrEditingEvent->GetScheduleID())
  739. {
  740. m_ptrEditingEvent->SetScheduleID(uSchID);
  741. bChanged = TRUE;
  742. }
  743. }
  745. // Update event in data storage
  746. CXTPCalendarControl::CUpdateContext updateContext(m_ptrControl, xtpCalendarUpdateLayout | xtpCalendarUpdateRedraw);
  748. CXTPCalendarData* pData = m_ptrEditingEvent->GetDataProvider();
  749. if (m_bAddEvent)
  750. {
  751. VERIFY(pData->AddEvent(m_ptrEditingEvent));
  752. } else {
  753. VERIFY(pData->ChangeEvent(m_ptrEditingEvent));
  754. }
  756. m_ptrControl->Populate();
  758. CDialog::OnOK();
  759. }
  761. void CXTPCalendarEventPropertiesDlg::OnCancel()
  762. {
  763. CDialog::OnCancel();
  764. }
  766. void CXTPCalendarEventPropertiesDlg::UpdateControlsFromEvent()
  767. {
  768. ASSERT(m_ptrEditingEvent);
  770. m_strSubject = m_ptrEditingEvent->GetSubject();
  771. m_strLocation = m_ptrEditingEvent->GetLocation();
  772. m_strBody = m_ptrEditingEvent->GetBody();
  774. if (m_bCategoriesEnabled)
  775. {
  776. if (m_ptrEditingEvent->GetDataProvider())
  777. m_ctrlCategories.Init(m_ptrEditingEvent->GetDataProvider()->GetEventCategories(),
  778.   m_ptrEditingEvent->GetCategories());
  779. }
  780. else
  781. {
  782. if (m_ptrEditingEvent->GetDataProvider())
  783. m_ctrlLabelCB.Init(m_ptrEditingEvent->GetDataProvider()->GetLabelList());
  785. m_ctrlLabelCB.SetLabelID(m_ptrEditingEvent->GetLabelID());
  786. }
  789. if (m_nAllDayEventSet < 0)
  790. {
  791. m_bAllDayEvent = m_ptrEditingEvent->IsAllDayEvent();
  792. }
  793. else
  794. {
  795. m_bAllDayEvent = m_nAllDayEventSet != 0;
  797. if (m_bAllDayEvent && CXTPCalendarUtils::IsZeroTime(m_dtEndDate))
  798. {
  799. AddEndDate_ResetTime(m_dtStartDate, m_dtEndDate, -1);
  800. }
  801. }
  803. m_bPrivate = m_ptrEditingEvent->IsPrivate();
  804. m_bMeeting = m_ptrEditingEvent->IsMeeting();
  805. m_nBusyStatus = m_ptrEditingEvent->GetBusyStatus();
  807. m_bReminder = m_ptrEditingEvent->IsReminder();
  809. int nMinutes = m_ptrEditingEvent->GetReminderMinutesBeforeStart();
  810. CString strReminder = CXTPCalendarUtils::FormatTimeDuration(nMinutes, FALSE);
  812. m_ctrlReminderCB.SetWindowText(strReminder);
  814. //-----------------------------------------------
  815. CXTPCalendarSchedules* pSchedules = m_ptrEditingEvent->GetDataProvider()->GetSchedules();
  816. ASSERT(pSchedules);
  818. BOOL bSchEnabled = pSchedules && pSchedules->GetCount();
  820. m_ctrlScheduleIDCB.EnableWindow(bSchEnabled);
  821. m_ctrlScheduleLabel.EnableWindow(bSchEnabled);
  823. if (pSchedules)
  824. {
  825. m_ctrlScheduleIDCB.ResetContent();
  827. int nIdx = m_ctrlScheduleIDCB.AddString(_T("-"));
  828. m_ctrlScheduleIDCB.SetItemData(nIdx, (DWORD_PTR)XTP_CALENDAR_UNKNOWN_SCHEDULE_ID);
  830. int nCount = pSchedules->GetCount();
  831. for (int nSchNr = 0; nSchNr < nCount; nSchNr++)
  832. {
  833. CXTPCalendarSchedule* pSch = pSchedules->GetAt(nSchNr);
  834. ASSERT(pSch);
  835. if (pSch)
  836. {
  837. nIdx = m_ctrlScheduleIDCB.AddString(pSch->GetName());
  838. m_ctrlScheduleIDCB.SetItemData(nIdx, (DWORD_PTR)pSch->GetID());
  839. }
  840. }
  842. UINT uSchID = m_ptrEditingEvent->GetScheduleID();
  843. nCount = m_ctrlScheduleIDCB.GetCount();
  845. if (m_bAddEvent && nCount)
  846. {
  847. m_ctrlScheduleIDCB.SetCurSel(0);
  848. }
  850. for (int nSchIDCS = 0; nSchIDCS < nCount; nSchIDCS++)
  851. {
  852. if (m_ctrlScheduleIDCB.GetItemData(nSchIDCS) == uSchID)
  853. {
  854. m_ctrlScheduleIDCB.SetCurSel(nSchIDCS);
  855. break;
  856. }
  857. }
  858. }
  860. UpdateData(FALSE);
  863. }
  865. void CXTPCalendarEventPropertiesDlg::UpdateControlsState()
  866. {
  867. if (GetDlgItem(XTP_IDC_DTP_START_DATE))
  868. {
  869. GetDlgItem(XTP_IDC_DTP_START_DATE)->ShowWindow(m_bOccurrence ? SW_SHOW : SW_HIDE);
  870. }
  871. if (GetDlgItem(XTP_IDC_DTP_START_TIME))
  872. {
  873. GetDlgItem(XTP_IDC_DTP_START_TIME)->ShowWindow(m_bOccurrence && !m_bAllDayEvent ? SW_SHOW : SW_HIDE);
  874. }
  875. if (GetDlgItem(XTP_IDC_DTP_END_DATE))
  876. {
  877. GetDlgItem(XTP_IDC_DTP_END_DATE)->ShowWindow(m_bOccurrence ? SW_SHOW : SW_HIDE);
  878. }
  879. if (GetDlgItem(XTP_IDC_DTP_END_TIME))
  880. {
  881. GetDlgItem(XTP_IDC_DTP_END_TIME)->ShowWindow(m_bOccurrence && !m_bAllDayEvent ? SW_SHOW : SW_HIDE);
  882. }
  883. if (GetDlgItem(XTP_IDC_START_TEXT))
  884. {
  885. GetDlgItem(XTP_IDC_START_TEXT)->ShowWindow(m_bOccurrence ? SW_SHOW : SW_HIDE);
  886. }
  887. if (GetDlgItem(XTP_IDC_END_TEXT))
  888. {
  889. GetDlgItem(XTP_IDC_END_TEXT)->ShowWindow(m_bOccurrence ? SW_SHOW : SW_HIDE);
  890. }
  892. //  if (GetDlgItem(XTP_IDC_CHECK_ALLDAY_EVENT))
  893. //  {
  894. //      GetDlgItem(XTP_IDC_CHECK_ALLDAY_EVENT)->ShowWindow(m_bOccurrence ? SW_SHOW : SW_HIDE);
  895. //  }
  897. m_ctrlReminderCB.EnableWindow(m_bReminder);
  898. }
  900. void CXTPCalendarEventPropertiesDlg::InitReminderComboBox()
  901. {
  902. m_ctrlReminderCB.ResetContent();
  904. m_ctrlReminderCB.AddString(LoadString(XTP_IDS_CALENDAR_MINUTES_0));
  905. m_ctrlReminderCB.AddString(LoadString(XTP_IDS_CALENDAR_MINUTES_1));
  906. m_ctrlReminderCB.AddString(LoadString(XTP_IDS_CALENDAR_MINUTES_5));
  907. m_ctrlReminderCB.AddString(LoadString(XTP_IDS_CALENDAR_MINUTES_10));
  908. m_ctrlReminderCB.AddString(LoadString(XTP_IDS_CALENDAR_MINUTES_15));
  909. }
  911. void CXTPCalendarEventPropertiesDlg::InitBusyStatusComboBox()
  912. {
  913. m_ctrlBusyStatusCB.ResetContent();
  915. m_ctrlBusyStatusCB.AddString(LoadString(XTP_IDS_CALENDAR_TIME_STATUS_FREE));
  916. m_ctrlBusyStatusCB.AddString(LoadString(XTP_IDS_CALENDAR_TIME_STATUS_TENTATIVE));
  917. m_ctrlBusyStatusCB.AddString(LoadString(XTP_IDS_CALENDAR_TIME_STATUS_BUSY));
  918. m_ctrlBusyStatusCB.AddString(LoadString(XTP_IDS_CALENDAR_TIME_STATUS_OUTOFOFFICE));
  919. }
  922. BOOL CXTPCalendarEventPropertiesDlg::OnInitDialog()
  923. {
  924. CDialog::OnInitDialog();
  926. if (m_bCategoriesEnabled)
  927. {
  928. m_ctrlCategories.SubclassDlgItem(XTP_IDC_COMBO_LABEL, this);
  930. if (GetDlgItem(XTP_IDC_LABEL))
  931. {
  932. CString str = XTPResourceManager()->LoadString(XTP_IDS_CALENDAR_CATEGORIES_LABEL);
  933. GetDlgItem(XTP_IDC_LABEL)->SetWindowText(str + _T(":"));
  934. }
  935. }
  936. else
  937. {
  938. m_ctrlLabelCB.SubclassDlgItem(XTP_IDC_COMBO_LABEL, this);
  939. }
  941. InitReminderComboBox();
  943. InitBusyStatusComboBox();
  945. UpdateControlsFromEvent();
  946. UpdateControlsState();
  948. return TRUE;  // return TRUE unless you set the focus to a control
  949. // EXCEPTION: OCX Property Pages should return FALSE
  950. }
  952. void CXTPCalendarEventPropertiesDlg::OnBnClickedButtonRecurrecnce()
  953. {
  954. UpdateData();
  956. BOOL bWasNotRecur = FALSE;
  957. BOOL bUpdateFromEvent = FALSE;
  959. CXTPCalendarEventPtr ptrMasterEvent = m_ptrEditingEvent;
  960. int nRState = ptrMasterEvent->GetRecurrenceState();
  962. if (nRState != xtpCalendarRecurrenceMaster)
  963. {
  964. ptrMasterEvent = m_ptrEditingEvent->CloneEvent();
  966. if (nRState == xtpCalendarRecurrenceNotRecurring)
  967. {
  968. VERIFY(ptrMasterEvent->MakeEventAsRecurrence());
  969. bWasNotRecur = TRUE;
  971. CXTPCalendarRecurrencePatternPtr ptrPattern;
  972. ptrPattern = ptrMasterEvent->GetRecurrencePattern();
  974. COleDateTime dtStartDateTime(CXTPCalendarUtils::UpdateTime(m_dtStartDate, m_dtStartTime));
  975. COleDateTime dtEndDateTime(CXTPCalendarUtils::UpdateTime(m_dtEndDate, m_dtEndTime));
  977. COleDateTimeSpan spDuration = dtEndDateTime- dtStartDateTime;
  979. ptrPattern->SetStartTime(CXTPCalendarUtils::ResetDate(m_dtStartTime));
  980. ptrPattern->SetDurationMinutes((int) spDuration.GetTotalMinutes());
  982. ptrPattern->SetPatternStartDate(CXTPCalendarUtils::ResetTime(m_dtStartDate));
  984. ptrMasterEvent->UpdateRecurrence(ptrPattern);
  985. }
  986. else
  987. {
  988. bUpdateFromEvent = TRUE;
  990. ASSERT(nRState == xtpCalendarRecurrenceOccurrence ||
  991.    nRState == xtpCalendarRecurrenceException);
  993. CXTPCalendarRecurrencePatternPtr ptrPattern;
  994. ptrPattern = m_ptrEditingEvent->GetRecurrencePattern();
  995. ptrMasterEvent = ptrPattern->GetMasterEvent();
  996. }
  997. }
  999. CXTPCalendarEventRecurrenceDlg dlg(ptrMasterEvent, this);
  1000. dlg.m_bDisableRemove = bWasNotRecur;
  1002. int nRes = (int)dlg.DoModal();
  1003. if (nRes == IDOK || nRes == XTP_CALENDAR_DLGRESULT_REMOVE_RECURRENCE)
  1004. {
  1005. m_ptrEditingEvent = ptrMasterEvent;
  1007. m_bOccurrence = m_ptrEditingEvent->GetRecurrenceState() ==
  1008. xtpCalendarRecurrenceNotRecurring;
  1010. if (bUpdateFromEvent)
  1011. {
  1012. UpdateData();
  1013. UpdateControlsFromEvent();
  1014. }
  1016. UpdateControlsState();
  1017. }
  1018. }
  1020. int CXTPCalendarEventPropertiesDlg::OnCreate(LPCREATESTRUCT lpCreateStruct)
  1021. {
  1022. if (CDialog::OnCreate(lpCreateStruct) == -1)
  1023. return -1;
  1025. int nType = m_ptrEditingEvent->GetRecurrenceState();
  1027. if (nType == xtpCalendarRecurrenceOccurrence || nType == xtpCalendarRecurrenceException)
  1028. {
  1029. CXTPCalendarOccurSeriesChooseDlg dlg(0, XTP_IDS_CALENDAR_OCURR_SERIES_OPEN);
  1030. dlg.SetEvent(m_ptrEditingEvent);
  1032. if (dlg.DoModal() != IDOK)
  1033. return -1;
  1035. m_bOccurrence = dlg.m_bOccur;
  1036. if (!m_bOccurrence)
  1037. {
  1038. CXTPCalendarRecurrencePatternPtr ptrPatternRO;
  1039. ptrPatternRO = m_ptrEditingEvent->GetRecurrencePattern();
  1040. CXTPCalendarEventPtr ptrMasterRO = ptrPatternRO->GetMasterEvent();
  1042. m_ptrEditingEvent = ptrMasterRO->CloneEvent();
  1043. }
  1044. }
  1046. return 0;
  1047. }
  1049. void CXTPCalendarEventPropertiesDlg::OnBnClickedCheckAlldayEvent()
  1050. {
  1051. UpdateData();
  1052. UpdateControlsState();
  1054. if (m_bAllDayEvent && CXTPCalendarUtils::IsZeroTime(m_dtEndTime))
  1055. {
  1056. AddEndDate_ResetTime(m_dtStartDate, m_dtEndDate, -1);
  1057. UpdateData(FALSE);
  1058. }
  1059. else if (!m_bAllDayEvent && CXTPCalendarUtils::IsZeroTime(m_dtEndTime))
  1060. {
  1061. AddEndDate_ResetTime(m_dtStartDate, m_dtEndDate, 1);
  1062. UpdateData(FALSE);
  1063. }
  1064. }
  1067. void CXTPCalendarEventPropertiesDlg::OnCheckReminder()
  1068. {
  1069. UpdateData();
  1070. UpdateControlsState();
  1071. }
  1073. void CXTPCalendarEventPropertiesDlg::AddEndDate_ResetTime(COleDateTime dtStartDate, COleDateTime& rdtEndDate, int nDays)
  1074. {
  1075. COleDateTimeSpan spDiff = CXTPCalendarUtils::ResetTime(rdtEndDate) -
  1076. CXTPCalendarUtils::ResetTime(dtStartDate);
  1077. if (nDays > 0 || nDays < 0 && (DWORD)(double)spDiff >= (DWORD)(-1 * nDays) )
  1078. {
  1079. rdtEndDate = CXTPCalendarUtils::ResetTime(rdtEndDate) + COleDateTimeSpan(nDays,0,0,0);
  1080. }
  1081. }