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

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

对话框与窗口

开发平台：

Visual C++

XTPCalendarEventRecurrenceDlg.cpp：源码内容
  1. // XTPCalendarEventRecurrenceDlg.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 "XTPCalendarEventRecurrenceDlg.h"
  28. #include "XTPCalendarEventPropertiesDlg.h"
  30. #include "XTPCalendarEvent.h"
  31. #include "XTPCalendarRecurrencePattern.h"
  33. #define XTP_TIMER_ID_UPDATE_TIMEOUT 100
  35. #define XTP_TIMER_ID_START_CB_CHANGED       0x01
  36. #define XTP_TIMER_ID_END_CB_CHANGED         0x02
  37. #define XTP_TIMER_ID_DURATION_CB_CHANGED    0x04
  39. #define XTP_TIMER_ID_ALL_CB_CHANGED         0x07
  41. IMPLEMENT_DYNAMIC(CXTPCalendarEventRecurrenceDlg, CDialog)
  43. /////////////////////////////////////////////////////////////////////////////
  44. CXTPCalendarEventRecurrenceDlg::CXTPCalendarEventRecurrenceDlg(CXTPCalendarEvent* pMasterEvent,
  45.    CWnd* pParent, UINT nIDTemplate)
  46. :
  47. m_nOccurNum(10),
  48. m_dtEndDate(COleDateTime::GetCurrentTime()),
  49. m_nDayInterval(1),
  50. m_nWeeklyInterval(1),
  51. m_bMonday(TRUE),
  52. m_bTuesday(FALSE),
  53. m_bWednesday(FALSE),
  54. m_bThursday(FALSE),
  55. m_bFriday(FALSE),
  56. m_bSaturday(FALSE),
  57. m_bSunday(FALSE),
  58. m_MonthDate(1),
  59. m_nMonthInterval(1),
  60. m_nMonthInterval2(1),
  61. m_nDayOfMonth(m_dtEndDate.GetDay()),
  62. m_ptrMasterEvent(pMasterEvent, TRUE),
  63. m_bDisableRemove(FALSE)
  64. {
  65. InitModalIndirect(XTPResourceManager()->LoadDialogTemplate(nIDTemplate), pParent);
  67. ASSERT(m_ptrMasterEvent);
  69. m_ptrPattern = m_ptrMasterEvent->GetRecurrencePattern();
  70. m_dtStart = m_ptrPattern->GetStartTime();
  71. m_dtEnd = m_dtStart + m_ptrPattern->GetDuration();
  73. m_dtStartDate = m_ptrPattern->GetPatternStartDate();
  74. }
  76. CXTPCalendarEventRecurrenceDlg::~CXTPCalendarEventRecurrenceDlg()
  77. {
  78. }
  80. #if _MSC_VER < 1200
  81. AFX_INLINE void DDX_DateTimeCtrl(CDataExchange* pDX, int nIDC, COleDateTime& value)
  82. {
  83. HWND hWndCtrl = pDX->PrepareCtrl(nIDC);
  84. if (pDX->m_bSaveAndValidate)
  85. CXTPDateTimeHelper::GetDateTimeCtrlTime(hWndCtrl, value);
  86. else
  87. CXTPDateTimeHelper::SetDateTimeCtrlTime(hWndCtrl, value);
  88. }
  89. #endif
  91. void CXTPCalendarEventRecurrenceDlg::DoDataExchange(CDataExchange* pDX)
  92. {
  93. CDialog::DoDataExchange(pDX);
  95. DDX_Control(pDX, XTP_IDC_COMBO_SCHEDULEID, m_wndCbStart);
  96. DDX_Control(pDX, XTP_IDC_COMBO_REC_END, m_wndCbEnd);
  97. DDX_Control(pDX, XTP_IDC_COMBO_REC_DURATION, m_wndCbDuration);
  98. DDX_DateTimeCtrl(pDX, XTP_IDC_DATETIMEPICKER_START, m_dtStartDate);
  99. DDX_DateTimeCtrl(pDX, XTP_IDC_DATETIMEPICKER_ENDDATE, m_dtEndDate);
  100. DDX_Text(pDX, XTP_IDC_EDIT_OCCUR, m_nOccurNum);
  101. DDX_Text(pDX, XTP_IDC_EDIT_DAYINTERVAL, m_nDayInterval);
  102. DDX_Text(pDX, XTP_IDC_EDIT_WEEKLY_INTERVAL, m_nWeeklyInterval);
  103. DDX_Check(pDX, XTP_IDC_CHECK_MONDAY, m_bMonday);
  104. DDX_Check(pDX, XTP_IDC_CHECK_TUESDAY, m_bTuesday);
  105. DDX_Check(pDX, XTP_IDC_CHECK_WEDNESDAY, m_bWednesday);
  106. DDX_Check(pDX, XTP_IDC_CHECK_THURSDAY, m_bThursday);
  107. DDX_Check(pDX, XTP_IDC_CHECK_FRIDAY, m_bFriday);
  108. DDX_Check(pDX, XTP_IDC_CHECK_SATURDAY, m_bSaturday);
  109. DDX_Check(pDX, XTP_IDC_CHECK_SUNDAY, m_bSunday);
  110. DDX_Text(pDX, XTP_IDC_EDIT_MONTH_DATE, m_MonthDate);
  111. DDX_Text(pDX, XTP_IDC_EDIT_MONTH_MONTH, m_nMonthInterval);
  112. DDX_Text(pDX, XTP_IDC_EDIT_MONTH_MONTH2, m_nMonthInterval2);
  113. DDX_Control(pDX, XTP_IDC_COMBO_MONTH_DAY, m_wndCbMonthDay);
  114. DDX_Control(pDX, XTP_IDC_COMBO_MONTH_CRIT, m_wndCbMonthWhich);
  115. DDX_Text(pDX, XTP_IDC_EDIT_YEAR_DATE, m_nDayOfMonth);
  116. DDX_Control(pDX, XTP_IDC_COMBO_YEAR_MONTH, m_wndYearMonth);
  117. DDX_Control(pDX, XTP_IDC_COMBO_YEAR_MONTH2, m_wndComboYearMonth2);
  118. DDX_Control(pDX, XTP_IDC_COMBO_YEAR_CRIT, m_wndCbYearWhich);
  119. DDX_Control(pDX, XTP_IDC_COMBO_YEAR_DAY, m_wndCbYearDay);
  120. }
  122. BEGIN_MESSAGE_MAP(CXTPCalendarEventRecurrenceDlg, CDialog)
  123. ON_CBN_SELCHANGE(XTP_IDC_COMBO_SCHEDULEID, OnStartComboChanged)
  124. ON_CBN_SELCHANGE(XTP_IDC_COMBO_REC_END, OnEndComboChanged)
  125. ON_CBN_SELCHANGE(XTP_IDC_COMBO_REC_DURATION, OnDurationComboChanged)
  127. ON_CBN_KILLFOCUS(XTP_IDC_COMBO_SCHEDULEID, OnStartComboChanged)
  128. ON_CBN_KILLFOCUS(XTP_IDC_COMBO_REC_END, OnEndComboChanged)
  129. ON_CBN_KILLFOCUS(XTP_IDC_COMBO_REC_DURATION, OnDurationComboChanged)
  131. ON_CBN_EDITCHANGE(XTP_IDC_COMBO_SCHEDULEID, OnStartComboEdited)
  132. ON_CBN_EDITCHANGE(XTP_IDC_COMBO_REC_END, OnEndComboEdited)
  133. ON_CBN_EDITCHANGE(XTP_IDC_COMBO_REC_DURATION, OnDurationComboEdited)
  135. ON_BN_CLICKED(XTP_IDC_BUTTON_REMOVE_RECURRENCE, OnBnClickedButtonRemoveRecurrence)
  136. ON_CONTROL_RANGE(BN_CLICKED, XTP_IDC_RADIO_DAILY, XTP_IDC_RADIO_YEARLY, OnBnClickedRadioDailyYearly)
  137. ON_WM_TIMER()
  138. END_MESSAGE_MAP()
  140. void CXTPCalendarEventRecurrenceDlg::InitStartEndCB()
  141. {
  142. BOOL bInListStart = FALSE;
  143. BOOL bInListEnd = FALSE;
  145. CString strTimeFormat_HrMin = CXTPCalendarUtils::GetTimeFormatString_HrMin();
  146. CString strTime;
  148. // initializing m_wndCbStart and m_wndCbEnd combo boxes
  149. for (int i = 0; i < 24*60; i += 30)
  150. {
  151. int nHours = i / 60;
  152. int nMinutes = i % 60;
  154. strTime = CXTPCalendarUtils::GetTimeFormat(nHours, nMinutes, strTimeFormat_HrMin);
  156. int nIndex = m_wndCbStart.AddString(strTime);
  158. if (m_dtStart.GetHour() == nHours && m_dtStart.GetMinute() == nMinutes)
  159. {
  160. m_wndCbStart.SetCurSel(nIndex);
  161. bInListStart = TRUE;
  162. }
  164. nIndex = m_wndCbEnd.AddString(strTime);
  166. if (m_dtEnd.GetHour() == nHours && m_dtEnd.GetMinute() == nMinutes)
  167. {
  168. m_wndCbEnd.SetCurSel(nIndex);
  169. bInListEnd = TRUE;
  170. }
  171. }
  173. if (!bInListStart)
  174. {
  175. strTime = CXTPCalendarUtils::GetTimeFormat(m_dtStart.GetHour(), m_dtStart.GetMinute(), strTimeFormat_HrMin);
  176. m_wndCbStart.SetWindowText(strTime);
  177. }
  179. if (!bInListEnd)
  180. {
  181. strTime = CXTPCalendarUtils::GetTimeFormat(m_dtEnd.GetHour(), m_dtEnd.GetMinute(), strTimeFormat_HrMin);
  182. m_wndCbEnd.SetWindowText(strTime);
  183. }
  184. }
  186. int CXTPCalendarEventRecurrenceDlg::_AddString(CComboBox& wndCB, UINT nStrResID, DWORD_PTR dwItemData)
  187. {
  188. int nIndex = wndCB.AddString(CXTPCalendarUtils::LoadString(nStrResID));
  189. wndCB.SetItemData(nIndex, dwItemData);
  190. return nIndex;
  191. }
  193. int CXTPCalendarEventRecurrenceDlg::_AddLocaleString(CComboBox& wndCB, LCTYPE lcidStr, DWORD_PTR dwItemData)
  194. {
  195. int nIndex = wndCB.AddString(CXTPCalendarUtils::GetLocaleString(lcidStr, 255));
  196. wndCB.SetItemData(nIndex, dwItemData);
  197. return nIndex;
  198. }
  200. void CXTPCalendarEventRecurrenceDlg::InitDurationCB()
  201. {
  202. //initializing combo m_wndCbDuration combobox
  203. int nDuration_min = m_ptrPattern->GetDurationMinutes();
  205. _AddString(m_wndCbDuration, XTP_IDS_CALENDAR_MINUTES_0, 0);
  206. _AddString(m_wndCbDuration, XTP_IDS_CALENDAR_MINUTES_1, 1);
  207. _AddString(m_wndCbDuration, XTP_IDS_CALENDAR_MINUTES_5, 5);
  208. _AddString(m_wndCbDuration, XTP_IDS_CALENDAR_MINUTES_10, 10);
  209. _AddString(m_wndCbDuration, XTP_IDS_CALENDAR_MINUTES_15, 15);
  210. _AddString(m_wndCbDuration, XTP_IDS_CALENDAR_MINUTES_30, 30);
  212. _AddString(m_wndCbDuration, XTP_IDS_CALENDAR_HOURS_1, 1 * 60);
  213. _AddString(m_wndCbDuration, XTP_IDS_CALENDAR_HOURS_2, 2 * 60);
  214. _AddString(m_wndCbDuration, XTP_IDS_CALENDAR_HOURS_3, 3 * 60);
  215. _AddString(m_wndCbDuration, XTP_IDS_CALENDAR_HOURS_4, 4 * 60);
  216. _AddString(m_wndCbDuration, XTP_IDS_CALENDAR_HOURS_5, 5 * 60);
  217. _AddString(m_wndCbDuration, XTP_IDS_CALENDAR_HOURS_6, 6 * 60);
  218. _AddString(m_wndCbDuration, XTP_IDS_CALENDAR_HOURS_7, 7 * 60);
  219. _AddString(m_wndCbDuration, XTP_IDS_CALENDAR_HOURS_8, 8 * 60);
  220. _AddString(m_wndCbDuration, XTP_IDS_CALENDAR_HOURS_9, 9 * 60);
  221. _AddString(m_wndCbDuration, XTP_IDS_CALENDAR_HOURS_10, 10 * 60);
  222. _AddString(m_wndCbDuration, XTP_IDS_CALENDAR_HOURS_11, 11 * 60);
  223. _AddString(m_wndCbDuration, XTP_IDS_CALENDAR_DAYS_0_5, 12 * 60);
  224. _AddString(m_wndCbDuration, XTP_IDS_CALENDAR_HOURS_18, 18 * 60);
  226. _AddString(m_wndCbDuration, XTP_IDS_CALENDAR_DAYS_1, 1 * 24 * 60);
  227. _AddString(m_wndCbDuration, XTP_IDS_CALENDAR_DAYS_2, 2 * 24 * 60);
  228. _AddString(m_wndCbDuration, XTP_IDS_CALENDAR_DAYS_3, 3 * 24 * 60);
  230. _AddString(m_wndCbDuration, XTP_IDS_CALENDAR_WEEKS_1, 1 * 7 * 24 * 60);
  231. _AddString(m_wndCbDuration, XTP_IDS_CALENDAR_WEEKS_2, 2 * 7 * 24 * 60);
  233. int nCount = m_wndCbDuration.GetCount();
  234. for (int i = 0; i < nCount; i++)
  235. {
  236. if (nDuration_min == (int)m_wndCbDuration.GetItemData(i))
  237. {
  238. m_wndCbDuration.SetCurSel(i);
  239. return;
  240. }
  241. }
  243. CString strDuration = CXTPCalendarUtils::FormatTimeDuration(nDuration_min, FALSE);
  244. m_wndCbDuration.SetWindowText(strDuration);
  245. }
  247. void CXTPCalendarEventRecurrenceDlg::InitDayOfWeekCBs(CComboBox& wndCB)
  248. {
  249. _AddLocaleString(wndCB, LOCALE_SDAYNAME1, xtpCalendarDayMonday);
  250. _AddLocaleString(wndCB, LOCALE_SDAYNAME2, xtpCalendarDayTuesday);
  251. _AddLocaleString(wndCB, LOCALE_SDAYNAME3, xtpCalendarDayWednesday);
  252. _AddLocaleString(wndCB, LOCALE_SDAYNAME4, xtpCalendarDayThursday);
  253. _AddLocaleString(wndCB, LOCALE_SDAYNAME5, xtpCalendarDayFriday);
  254. _AddLocaleString(wndCB, LOCALE_SDAYNAME6, xtpCalendarDaySaturday);
  255. _AddLocaleString(wndCB, LOCALE_SDAYNAME7, xtpCalendarDaySunday);
  257. wndCB.SetCurSel(0);
  258. }
  260. void CXTPCalendarEventRecurrenceDlg::InitWhichDayCBs(CComboBox& wndCB)
  261. {
  262. _AddString(wndCB, XTP_IDS_CALENDAR_FIRST,   xtpCalendarWeekFirst);
  263. _AddString(wndCB, XTP_IDS_CALENDAR_SECOND,  xtpCalendarWeekSecond);
  264. _AddString(wndCB, XTP_IDS_CALENDAR_THIRD,   xtpCalendarWeekThird);
  265. _AddString(wndCB, XTP_IDS_CALENDAR_FOURTH,  xtpCalendarWeekFourth);
  266. _AddString(wndCB, XTP_IDS_CALENDAR_LAST,    xtpCalendarWeekLast);
  268. wndCB.SetCurSel(0);
  269. }
  271. void CXTPCalendarEventRecurrenceDlg::InitMonthCBs(CComboBox& wndCB)
  272. {
  273. for (int nMonth = 0; nMonth < 12; nMonth++)
  274. {
  275. _AddLocaleString(wndCB, LOCALE_SMONTHNAME1 + nMonth, nMonth + 1);
  276. }
  278. COleDateTime dtNow(COleDateTime::GetCurrentTime());
  279. wndCB.SetCurSel(dtNow.GetMonth() - 1);
  280. }
  282. // CXTPCalendarEventRecurrenceDlg message handlers
  283. BOOL CXTPCalendarEventRecurrenceDlg::OnInitDialog()
  284. {
  285. CDialog::OnInitDialog();
  287. InitStartEndCB();
  288. InitDurationCB();
  290. //initializing recurrence end properties
  291. int nRadio = XTP_IDC_RADIO_NOEND;
  292. XTPCalendarPatternEnd UseEnd = (XTPCalendarPatternEnd)
  293.  m_ptrPattern->GetUseEndMethod();
  294. switch (UseEnd)
  295. {
  296. case xtpCalendarPatternEndDate:
  297. nRadio = XTP_IDC_RADIO_ENDBY;
  298. m_dtEndDate = m_ptrPattern->GetPatternEndDate();
  299. break;
  300. case xtpCalendarPatternEndAfterOccurrences:
  301. nRadio = XTP_IDC_RADIO_ENDAFTER;
  302. m_nOccurNum = m_ptrPattern->GetEndAfterOccurrences();
  303. break;
  304. case xtpCalendarPatternEndNoDate:
  305. nRadio = XTP_IDC_RADIO_NOEND;
  306. break;
  307. }
  308. CheckRadioButton(XTP_IDC_RADIO_NOEND, XTP_IDC_RADIO_ENDBY, nRadio);
  310. if (!m_bDisableRemove)
  311. {
  312. ::EnableWindow(GetDlgItem(XTP_IDC_BUTTON_REMOVE_RECURRENCE)->GetSafeHwnd(), TRUE);
  313. }
  315. // initializing day/week/month/year recurrence settings
  316. CheckRadioButton(XTP_IDC_RADIO_EVERYDAY, XTP_IDC_RADIO_EVERYWORKDAY, XTP_IDC_RADIO_EVERYDAY);
  317. CheckRadioButton(XTP_IDC_RADIO_MONTH_RECUR, XTP_IDC_RADIO_MONTH_IN, XTP_IDC_RADIO_MONTH_RECUR);
  318. CheckRadioButton(XTP_IDC_RADIO_YEAR_RECUR, XTP_IDC_RADIO_YEAR_IN, XTP_IDC_RADIO_YEAR_RECUR);
  320. InitDayOfWeekCBs(m_wndCbMonthDay);
  321. InitDayOfWeekCBs(m_wndCbYearDay);
  323. InitWhichDayCBs(m_wndCbMonthWhich);
  324. InitWhichDayCBs(m_wndCbYearWhich);
  326. InitMonthCBs(m_wndYearMonth);
  327. InitMonthCBs(m_wndComboYearMonth2);
  329. nRadio = XTP_IDC_RADIO_WEEKLY;
  330. XTP_CALENDAR_RECURRENCE_OPTIONS opt = m_ptrPattern->GetRecurrenceOptions();
  331. int nRecType = m_ptrPattern->GetRecurrenceType();
  332. int i;
  333. switch (nRecType)
  334. {
  335. case xtpCalendarRecurrenceDaily:
  336. {
  337. nRadio = XTP_IDC_RADIO_DAILY;
  338. int nRd = XTP_IDC_RADIO_EVERYDAY;
  339. if (opt.m_Daily.bEveryWeekDayOnly)
  340. {
  341. m_nDayInterval = 1;
  342. nRd = XTP_IDC_RADIO_EVERYWORKDAY;
  343. }
  344. else
  345. {
  346. m_nDayInterval = opt.m_Daily.nIntervalDays;
  347. }
  348. CheckRadioButton(XTP_IDC_RADIO_EVERYDAY, XTP_IDC_RADIO_EVERYWORKDAY, nRd);
  349. }
  350. break;
  351. case xtpCalendarRecurrenceWeekly:
  352. nRadio = XTP_IDC_RADIO_WEEKLY;
  353. m_nWeeklyInterval = opt.m_Weekly.nIntervalWeeks;
  354. m_bMonday = (opt.m_Weekly.nDayOfWeekMask & xtpCalendarDayMonday) != 0;
  355. m_bTuesday = (opt.m_Weekly.nDayOfWeekMask & xtpCalendarDayTuesday) != 0;
  356. m_bWednesday = (opt.m_Weekly.nDayOfWeekMask & xtpCalendarDayWednesday) != 0;
  357. m_bThursday = (opt.m_Weekly.nDayOfWeekMask & xtpCalendarDayThursday) != 0;
  358. m_bFriday = (opt.m_Weekly.nDayOfWeekMask & xtpCalendarDayFriday) != 0;
  359. m_bSaturday = (opt.m_Weekly.nDayOfWeekMask & xtpCalendarDaySaturday) != 0;
  360. m_bSunday = (opt.m_Weekly.nDayOfWeekMask & xtpCalendarDaySunday) != 0;
  361. break;
  362. case xtpCalendarRecurrenceMonthly:
  363. nRadio = XTP_IDC_RADIO_MONTHLY;
  364. CheckRadioButton(XTP_IDC_RADIO_MONTH_RECUR, XTP_IDC_RADIO_MONTH_IN,
  365.  XTP_IDC_RADIO_MONTH_RECUR);
  366. m_nMonthInterval = opt.m_Monthly.nIntervalMonths;
  367. m_MonthDate = opt.m_Monthly.nDayOfMonth;
  368. break;
  369. case xtpCalendarRecurrenceMonthNth:
  370. {
  371. nRadio = XTP_IDC_RADIO_MONTHLY;
  372. CheckRadioButton(XTP_IDC_RADIO_MONTH_RECUR, XTP_IDC_RADIO_MONTH_IN,
  373.  XTP_IDC_RADIO_MONTH_IN);
  374. m_nMonthInterval2 = opt.m_MonthNth.nIntervalMonths;
  376. for (i = 0; i < m_wndCbMonthDay.GetCount(); i++)
  377. if (opt.m_MonthNth.nWhichDayMask & m_wndCbMonthDay.GetItemData(i))
  378. {
  379. m_wndCbMonthDay.SetCurSel(i);
  380. break;
  381. }
  382. for (i = 0; i < m_wndCbMonthWhich.GetCount(); i++)
  383. if (opt.m_MonthNth.nWhichDay == (int) m_wndCbMonthWhich.GetItemData(i))
  384. {
  385. m_wndCbMonthWhich.SetCurSel(i);
  386. break;
  387. }
  388. }
  389. break;
  390. case xtpCalendarRecurrenceYearly:
  391. {
  392. nRadio = XTP_IDC_RADIO_YEARLY;
  393. CheckRadioButton(XTP_IDC_RADIO_YEAR_RECUR, XTP_IDC_RADIO_YEAR_IN,
  394.  XTP_IDC_RADIO_YEAR_RECUR);
  395. m_nDayOfMonth = opt.m_Yearly.nDayOfMonth;
  396. for (i = 0; i < m_wndYearMonth.GetCount(); i++)
  397. {
  398. if (opt.m_Yearly.nMonthOfYear == (int) m_wndYearMonth.GetItemData(i))
  399. {
  400. m_wndYearMonth.SetCurSel(i);
  401. break;
  402. }
  403. }
  404. }
  405. break;
  406. case xtpCalendarRecurrenceYearNth:
  407. nRadio = XTP_IDC_RADIO_YEARLY;
  408. CheckRadioButton(XTP_IDC_RADIO_YEAR_RECUR, XTP_IDC_RADIO_YEAR_IN, XTP_IDC_RADIO_YEAR_IN);
  410. for (i = 0; i < m_wndComboYearMonth2.GetCount(); i++)
  411. if (opt.m_YearNth.nMonthOfYear == (int) m_wndComboYearMonth2.GetItemData(i))
  412. {
  413. m_wndComboYearMonth2.SetCurSel(i);
  414. break;
  415. }
  417. for (i = 0; i < m_wndCbYearWhich.GetCount(); i++)
  418. if (opt.m_YearNth.nWhichDay == (int) m_wndCbYearWhich.GetItemData(i))
  419. {
  420. m_wndCbYearWhich.SetCurSel(i);
  421. break;
  422. }
  424. for (i = 0; i < m_wndCbYearDay.GetCount(); i++)
  425. if (opt.m_YearNth.nWhichDayMask & m_wndCbYearDay.GetItemData(i))
  426. {
  427. m_wndCbYearDay.SetCurSel(i);
  428. break;
  429. }
  430. break;
  431. default:
  432. ASSERT(nRecType == xtpCalendarRecurrenceUnknown);
  433. }
  434. CheckRadioButton(XTP_IDC_RADIO_DAILY, XTP_IDC_RADIO_YEARLY, nRadio);
  435. OnBnClickedRadioDailyYearly(nRadio);
  437. UpdateData(FALSE);
  439. _MoveControlsBy_Y();
  441. return TRUE;
  442. }
  443. void CXTPCalendarEventRecurrenceDlg::OnTimer(UINT_PTR nIDEvent)
  444. {
  445. if (nIDEvent & XTP_TIMER_ID_ALL_CB_CHANGED)
  446. {
  447. KillTimer(nIDEvent);
  448. }
  449. else
  450. {
  451. ASSERT(FALSE);
  452. CDialog::OnTimer(nIDEvent);
  453. }
  455. if (nIDEvent & XTP_TIMER_ID_START_CB_CHANGED)
  456. {
  457. //TRACE(_T("_OnStartChanged() n"));
  458. _OnStartChanged();
  459. }
  460. if (nIDEvent & XTP_TIMER_ID_END_CB_CHANGED)
  461. {
  462. //TRACE(_T("_OnEndChanged() n"));
  463. _OnEndChanged();
  464. }
  465. if (nIDEvent & XTP_TIMER_ID_DURATION_CB_CHANGED)
  466. {
  467. //TRACE(_T("_OnDurationChanged() n"));
  468. _OnDurationChanged();
  469. }
  470. }
  472. void CXTPCalendarEventRecurrenceDlg::OnStartChanged()
  473. {
  474. SetTimer(XTP_TIMER_ID_START_CB_CHANGED, XTP_TIMER_ID_UPDATE_TIMEOUT, NULL);
  475. }
  477. void CXTPCalendarEventRecurrenceDlg::OnEndChanged()
  478. {
  479. SetTimer(XTP_TIMER_ID_END_CB_CHANGED, XTP_TIMER_ID_UPDATE_TIMEOUT, NULL);
  480. }
  482. void CXTPCalendarEventRecurrenceDlg::OnDurationChanged()
  483. {
  484. SetTimer(XTP_TIMER_ID_DURATION_CB_CHANGED, XTP_TIMER_ID_UPDATE_TIMEOUT, NULL);
  485. }
  487. int CXTPCalendarEventRecurrenceDlg::GetChangedComboTimeInMin(CComboBox& wndCb)
  488. {
  489. CString strCBtext;
  490. wndCb.GetWindowText(strCBtext);
  492. return CXTPCalendarUtils::ParceTimeString_min(strCBtext);
  493. }
  495. void CXTPCalendarEventRecurrenceDlg::OnStartComboEdited()
  496. {
  497. int nMin = GetChangedComboTimeInMin(m_wndCbStart);
  498. if (nMin >= 0)
  499. OnStartChanged();
  500. }
  502. void CXTPCalendarEventRecurrenceDlg::OnEndComboEdited()
  503. {
  504. int nMin = GetChangedComboTimeInMin(m_wndCbEnd);
  505. if (nMin >= 0)
  506. OnEndChanged();
  507. }
  509. void CXTPCalendarEventRecurrenceDlg::OnDurationComboEdited()
  510. {
  511. int nMin = GetDurationComboInMin();
  512. if (nMin >= 0)
  513. OnDurationChanged();
  514. }
  516. void CXTPCalendarEventRecurrenceDlg::OnStartComboChanged()
  517. {
  518. OnStartChanged();
  519. }
  521. void CXTPCalendarEventRecurrenceDlg::_OnStartChanged()
  522. {
  523. int nMin = GetChangedComboTimeInMin(m_wndCbStart);
  524. if (nMin == -1)
  525. {
  526. return;
  527. }
  529. m_dtStart.SetTime(nMin/60%24, nMin%60, 0);
  531. int nDurationMin = GetDurationComboInMin();
  532. if (nDurationMin < 0)
  533. {
  534. nDurationMin = 0;
  535. }
  537. COleDateTimeSpan spDiff((double)nDurationMin/((double)24*60));
  538. m_dtEnd = m_dtStart + spDiff;
  539. m_dtEnd = CXTPCalendarUtils::ResetDate(m_dtEnd);
  541. CString strTimeFormat_HrMin = CXTPCalendarUtils::GetTimeFormatString_HrMin();
  542. CString strTmp = CXTPCalendarUtils::GetTimeFormat(m_dtEnd.GetHour(), m_dtEnd.GetMinute(), strTimeFormat_HrMin);
  543. m_wndCbEnd.SetWindowText(strTmp);
  544. }
  546. void CXTPCalendarEventRecurrenceDlg::OnEndComboChanged()
  547. {
  548. OnEndChanged();
  549. }
  551. void CXTPCalendarEventRecurrenceDlg::_OnEndChanged()
  552. {
  553. int nMin = GetChangedComboTimeInMin(m_wndCbEnd);
  554. if (nMin == -1)
  555. {
  556. return;
  557. }
  559. COleDateTime dtPrevEnd = m_dtEnd;
  560. m_dtEnd.SetTime(nMin/60%24, nMin%60, 0);
  562. COleDateTimeSpan spDiff = m_dtEnd - dtPrevEnd;
  564. int nDuration = GetDurationComboInMin();
  565. if (nDuration < 0)
  566. {
  567. nDuration = 0;
  568. }
  569. nDuration += GETTOTAL_MINUTES_DTS(spDiff);
  571. if (m_dtEnd < m_dtStart && nDuration < 0)
  572. {
  573. spDiff = m_dtStart - m_dtEnd;
  574. nDuration = 24*60 - GETTOTAL_MINUTES_DTS(spDiff);
  575. }
  577. CString strDuration = CXTPCalendarUtils::FormatTimeDuration(nDuration, FALSE);
  578. m_wndCbDuration.SetWindowText(strDuration);
  579. }
  581. int CXTPCalendarEventRecurrenceDlg::GetDurationComboInMin()
  582. {
  583. CString strCBtext;
  584. m_wndCbDuration.GetWindowText(strCBtext);
  586. return CXTPCalendarUtils::ParceTimeDuration_min(strCBtext);
  587. }
  589. void CXTPCalendarEventRecurrenceDlg::OnDurationComboChanged()
  590. {
  591. OnDurationChanged();
  592. }
  594. void CXTPCalendarEventRecurrenceDlg::_OnDurationChanged()
  595. {
  596. int nDuration_min = GetDurationComboInMin();
  597. if (nDuration_min < 0)
  598. {
  599. return;
  600. }
  602. m_dtEnd = m_dtStart + CXTPCalendarUtils::Minutes2Span(nDuration_min);
  604. CString strTimeFormat_HrMin = CXTPCalendarUtils::GetTimeFormatString_HrMin();
  605. CString strTmp = CXTPCalendarUtils::GetTimeFormat(m_dtEnd.GetHour(), m_dtEnd.GetMinute(), strTimeFormat_HrMin);
  607. m_wndCbEnd.SetWindowText(strTmp);
  608. }
  610. void CXTPCalendarEventRecurrenceDlg::MsgBox_WrongValue(CWnd* pWnd)
  611. {
  612. pWnd->SetFocus();
  613. XTPResourceManager()->ShowMessageBox(XTP_IDS_CALENDAR_WRONG_VALUE);
  614. }
  616. void CXTPCalendarEventRecurrenceDlg::MsgBox_WrongValueRange(UINT nCtrlID, int nMin, int nMax)
  617. {
  618. if (GetDlgItem(nCtrlID))
  619. GetDlgItem(nCtrlID)->SetFocus();
  621. CString strFormat = CXTPCalendarUtils::LoadString(XTP_IDS_CALENDAR_WRONG_VALUE_RANGE);
  622. CString strMsg, strVal1, strVal2;
  623. strVal1.Format(_T("%d"), nMin);
  624. strVal2.Format(_T("%d"), nMax);
  626. strMsg.Format(strFormat, (LPCTSTR)strVal1, (LPCTSTR)strVal2);
  628. XTPResourceManager()->ShowMessageBox(strMsg);
  629. }
  631. void CXTPCalendarEventRecurrenceDlg::OnOK()
  632. {
  633. int nMin = GetChangedComboTimeInMin(m_wndCbStart);
  634. if (nMin == -1)
  635. {
  636. MsgBox_WrongValue(&m_wndCbStart);
  637. return;
  638. }
  640. nMin = GetChangedComboTimeInMin(m_wndCbEnd);
  641. if (nMin == -1)
  642. {
  643. MsgBox_WrongValue(&m_wndCbEnd);
  644. return;
  645. }
  647. int nDuration_min = GetDurationComboInMin();
  648. if (nDuration_min < 0)
  649. {
  650. MsgBox_WrongValue(&m_wndCbDuration);
  651. return;
  652. }
  654. UpdateData();
  656. CXTPCalendarEventsPtr ptrExceptions = m_ptrPattern->GetExceptions();
  657. if (ptrExceptions && ptrExceptions->GetCount())
  658. {
  659. // Any exceptions associated with this recurring appointment will be lost. If any of the exceptions are meetings, the attendees will not be notified. Is this OK?
  660. int nRes = XTPResourceManager()->ShowMessageBox(XTP_IDS_CALENDAR_REMOVE_EXCEPTIONS, MB_OKCANCEL);
  661. if (nRes != IDOK)
  662. {
  663. return;
  664. }
  665. m_ptrPattern->RemoveAllExceptions();
  666. }
  668. m_dtStart = CXTPCalendarUtils::ResetDate(m_dtStart);
  669. m_ptrPattern->SetStartTime(m_dtStart);
  671. m_ptrPattern->SetDurationMinutes(nDuration_min);
  673. //----------------------------------------------------------
  674. XTP_CALENDAR_RECURRENCE_OPTIONS opt;
  676. int nRadio = GetCheckedRadioButton(XTP_IDC_RADIO_DAILY, XTP_IDC_RADIO_YEARLY);
  677. switch (nRadio)
  678. {
  679. case XTP_IDC_RADIO_DAILY:
  680. {
  681. if (m_nDayInterval < 1 || m_nDayInterval > 999)
  682. {
  683. MsgBox_WrongValueRange(XTP_IDC_EDIT_DAYINTERVAL, 1, 999);
  684. return;
  685. }
  687. opt.m_nRecurrenceType = xtpCalendarRecurrenceDaily;
  688. opt.m_Daily.bEveryWeekDayOnly = GetCheckedRadioButton(XTP_IDC_RADIO_EVERYDAY,
  689.   XTP_IDC_RADIO_EVERYWORKDAY) ==
  690. XTP_IDC_RADIO_EVERYWORKDAY;
  691. if (opt.m_Daily.bEveryWeekDayOnly)
  692. opt.m_Daily.nIntervalDays = 1;
  693. else
  694. opt.m_Daily.nIntervalDays = m_nDayInterval;
  695. break;
  696. }
  697. case XTP_IDC_RADIO_WEEKLY:
  699. if (m_nWeeklyInterval < 1 || m_nWeeklyInterval > 999)
  700. {
  701. MsgBox_WrongValueRange(XTP_IDC_EDIT_WEEKLY_INTERVAL, 1, 999);
  702. return;
  703. }
  705. opt.m_nRecurrenceType = xtpCalendarRecurrenceWeekly;
  706. opt.m_Weekly.nIntervalWeeks = m_nWeeklyInterval;
  707. opt.m_Weekly.nDayOfWeekMask = 0;
  708. if (m_bMonday)
  709. opt.m_Weekly.nDayOfWeekMask |= xtpCalendarDayMonday;
  710. if (m_bTuesday)
  711. opt.m_Weekly.nDayOfWeekMask |= xtpCalendarDayTuesday;
  712. if (m_bWednesday)
  713. opt.m_Weekly.nDayOfWeekMask |= xtpCalendarDayWednesday;
  714. if (m_bThursday)
  715. opt.m_Weekly.nDayOfWeekMask |= xtpCalendarDayThursday;
  716. if (m_bFriday)
  717. opt.m_Weekly.nDayOfWeekMask |= xtpCalendarDayFriday;
  718. if (m_bSaturday)
  719. opt.m_Weekly.nDayOfWeekMask |= xtpCalendarDaySaturday;
  720. if (m_bSunday)
  721. opt.m_Weekly.nDayOfWeekMask |= xtpCalendarDaySunday;
  723. break;
  724. case XTP_IDC_RADIO_MONTHLY:
  725. if (GetCheckedRadioButton(XTP_IDC_RADIO_MONTH_RECUR, XTP_IDC_RADIO_MONTH_IN) ==
  726. XTP_IDC_RADIO_MONTH_RECUR)
  727. {
  728. if (m_nMonthInterval < 1 || m_nMonthInterval > 999)
  729. {
  730. MsgBox_WrongValueRange(XTP_IDC_EDIT_MONTH_MONTH, 1, 999);
  731. return;
  732. }
  733. if (m_MonthDate < 1 || m_MonthDate > 31)
  734. {
  735. MsgBox_WrongValueRange(XTP_IDC_EDIT_MONTH_DATE, 1, 31);
  736. return;
  737. }
  739. opt.m_nRecurrenceType = xtpCalendarRecurrenceMonthly;
  740. opt.m_Monthly.nIntervalMonths = m_nMonthInterval;
  741. opt.m_Monthly.nDayOfMonth = m_MonthDate;
  742. }
  743. else
  744. {
  745. if (m_nMonthInterval2 < 1 || m_nMonthInterval2 > 999)
  746. {
  747. MsgBox_WrongValueRange(XTP_IDC_EDIT_MONTH_MONTH2, 1, 999);
  748. return;
  749. }
  751. opt.m_MonthNth.nIntervalMonths = m_nMonthInterval2;
  752. opt.m_nRecurrenceType = xtpCalendarRecurrenceMonthNth;
  753. opt.m_MonthNth.nWhichDayMask = (int)m_wndCbMonthDay.GetItemData(m_wndCbMonthDay.GetCurSel());
  755. opt.m_MonthNth.nWhichDay = (int)m_wndCbMonthWhich.GetItemData(m_wndCbMonthWhich.GetCurSel());
  756. }
  758. break;
  759. case XTP_IDC_RADIO_YEARLY:
  760. opt.m_nRecurrenceType = xtpCalendarRecurrenceYearly;
  761. if (GetCheckedRadioButton(XTP_IDC_RADIO_YEAR_RECUR, XTP_IDC_RADIO_YEAR_IN) ==
  762. XTP_IDC_RADIO_YEAR_RECUR)
  763. {
  764. if (m_nDayOfMonth < 1 || m_nDayOfMonth > 31)
  765. {
  766. MsgBox_WrongValueRange(XTP_IDC_EDIT_YEAR_DATE, 1, 31);
  767. return;
  768. }
  770. opt.m_Yearly.nDayOfMonth = m_nDayOfMonth;
  771. opt.m_Yearly.nMonthOfYear = (int)m_wndYearMonth.GetItemData(m_wndYearMonth.GetCurSel());
  772. }
  773. else
  774. {
  775. opt.m_nRecurrenceType = xtpCalendarRecurrenceYearNth;
  777. opt.m_YearNth.nMonthOfYear = (int)m_wndComboYearMonth2.GetItemData(m_wndComboYearMonth2.GetCurSel());
  779. opt.m_YearNth.nWhichDay = (int)m_wndCbYearWhich.GetItemData(m_wndCbYearWhich.GetCurSel());
  781. opt.m_YearNth.nWhichDayMask = (int)m_wndCbYearDay.GetItemData(m_wndCbYearDay.GetCurSel());
  782. }
  784. break;
  785. }
  787. m_ptrPattern->SetRecurrenceOptions(opt);
  789. //-----------------------------------------------------------------------
  790. m_dtStartDate = CXTPCalendarUtils::ResetTime(m_dtStartDate);
  791. m_ptrPattern->SetPatternStartDate(m_dtStartDate);
  793. nRadio = GetCheckedRadioButton(XTP_IDC_RADIO_NOEND, XTP_IDC_RADIO_ENDBY);
  794. switch (nRadio)
  795. {
  796. case XTP_IDC_RADIO_ENDBY:
  797. if (m_dtEndDate < m_dtStartDate)
  798. {
  799. MsgBox_WrongValue(GetDlgItem(XTP_IDC_DATETIMEPICKER_ENDDATE));
  800. return;
  801. }
  802. m_ptrPattern->SetPatternEndDate(m_dtEndDate);
  803. break;
  805. case XTP_IDC_RADIO_ENDAFTER:
  806. if (m_nOccurNum < 1 || m_nOccurNum > 999)
  807. {
  808. MsgBox_WrongValueRange(XTP_IDC_EDIT_OCCUR, 1, 999);
  809. return;
  810. }
  811. m_ptrPattern->SetEndAfterOccurrences(m_nOccurNum);
  812. break;
  813. case XTP_IDC_RADIO_NOEND:
  814. m_ptrPattern->SetNoEndDate();
  815. break;
  816. }
  818. //-----------------------------------------------------------------------
  819. VERIFY(m_ptrMasterEvent->UpdateRecurrence(m_ptrPattern));
  821. CDialog::OnOK();
  822. }
  824. void CXTPCalendarEventRecurrenceDlg::OnBnClickedButtonRemoveRecurrence()
  825. {
  826. VERIFY(m_ptrMasterEvent->RemoveRecurrence());
  828. EndDialog(XTP_CALENDAR_DLGRESULT_REMOVE_RECURRENCE);
  829. }
  831. void CXTPCalendarEventRecurrenceDlg::OnBnClickedRadioDailyYearly(UINT nID)
  832. {
  833. ShowWindow(XTP_IDC_RADIO_EVERYDAY, FALSE);
  834. ShowWindow(XTP_IDC_RADIO_EVERYWORKDAY, FALSE);
  835. ShowWindow(XTP_IDC_EDIT_DAYINTERVAL, FALSE);
  836. ShowWindow(XTP_IDC_STATIC_DAY, FALSE);
  838. ShowWindow(XTP_IDC_STATIC_WEEKLY_RECEVERY, FALSE);
  839. ShowWindow(XTP_IDC_EDIT_WEEKLY_INTERVAL, FALSE);
  840. ShowWindow(XTP_IDC_STATIC_WEEKLY_FOLLDAYS, FALSE);
  841. ShowWindow(XTP_IDC_CHECK_MONDAY, FALSE);
  842. ShowWindow(XTP_IDC_CHECK_TUESDAY, FALSE);
  843. ShowWindow(XTP_IDC_CHECK_WEDNESDAY, FALSE);
  844. ShowWindow(XTP_IDC_CHECK_THURSDAY, FALSE);
  845. ShowWindow(XTP_IDC_CHECK_FRIDAY, FALSE);
  846. ShowWindow(XTP_IDC_CHECK_SATURDAY, FALSE);
  847. ShowWindow(XTP_IDC_CHECK_SUNDAY, FALSE);
  849. ShowWindow(XTP_IDC_RADIO_MONTH_RECUR, FALSE);
  850. ShowWindow(XTP_IDC_RADIO_MONTH_IN, FALSE);
  851. ShowWindow(XTP_IDC_EDIT_MONTH_DATE, FALSE);
  852. ShowWindow(XTP_IDC_STATIC_MONTH_NUMEVERY, FALSE);
  853. ShowWindow(XTP_IDC_EDIT_MONTH_MONTH, FALSE);
  854. ShowWindow(XTP_IDC_STATIC_MONTH_MONTH, FALSE);
  855. ShowWindow(XTP_IDC_COMBO_MONTH_CRIT, FALSE);
  856. ShowWindow(XTP_IDC_COMBO_MONTH_DAY, FALSE);
  857. ShowWindow(XTP_IDC_STATIC_MONTH_EVERY, FALSE);
  858. ShowWindow(XTP_IDC_EDIT_MONTH_MONTH2, FALSE);
  859. ShowWindow(XTP_IDC_STATIC_MONTH_MONTH2, FALSE);
  861. ShowWindow(XTP_IDC_RADIO_YEAR_RECUR, FALSE);
  862. ShowWindow(XTP_IDC_RADIO_YEAR_IN, FALSE);
  863. ShowWindow(XTP_IDC_EDIT_YEAR_DATE, FALSE);
  864. ShowWindow(XTP_IDC_COMBO_YEAR_MONTH, FALSE);
  865. ShowWindow(XTP_IDC_COMBO_YEAR_CRIT, FALSE);
  866. ShowWindow(XTP_IDC_COMBO_YEAR_DAY, FALSE);
  867. ShowWindow(XTP_IDC_COMBO_YEAR_MONTH2, FALSE);
  868. ShowWindow(XTP_IDC_STATIC_YEAR_OF, FALSE);
  870. switch (nID)
  871. {
  872. case XTP_IDC_RADIO_DAILY:
  873. ShowWindow(XTP_IDC_RADIO_EVERYDAY);
  874. ShowWindow(XTP_IDC_RADIO_EVERYWORKDAY);
  875. ShowWindow(XTP_IDC_EDIT_DAYINTERVAL);
  876. ShowWindow(XTP_IDC_STATIC_DAY);
  877. break;
  878. case XTP_IDC_RADIO_WEEKLY:
  879. ShowWindow(XTP_IDC_STATIC_WEEKLY_RECEVERY);
  880. ShowWindow(XTP_IDC_EDIT_WEEKLY_INTERVAL);
  881. ShowWindow(XTP_IDC_STATIC_WEEKLY_FOLLDAYS);
  882. ShowWindow(XTP_IDC_CHECK_MONDAY);
  883. ShowWindow(XTP_IDC_CHECK_TUESDAY);
  884. ShowWindow(XTP_IDC_CHECK_WEDNESDAY);
  885. ShowWindow(XTP_IDC_CHECK_THURSDAY);
  886. ShowWindow(XTP_IDC_CHECK_FRIDAY);
  887. ShowWindow(XTP_IDC_CHECK_SATURDAY);
  888. ShowWindow(XTP_IDC_CHECK_SUNDAY);
  889. break;
  890. case XTP_IDC_RADIO_MONTHLY:
  891. ShowWindow(XTP_IDC_RADIO_MONTH_RECUR);
  892. ShowWindow(XTP_IDC_RADIO_MONTH_IN);
  893. ShowWindow(XTP_IDC_EDIT_MONTH_DATE);
  894. ShowWindow(XTP_IDC_STATIC_MONTH_NUMEVERY);
  895. ShowWindow(XTP_IDC_EDIT_MONTH_MONTH);
  896. ShowWindow(XTP_IDC_STATIC_MONTH_MONTH);
  897. ShowWindow(XTP_IDC_COMBO_MONTH_CRIT);
  898. ShowWindow(XTP_IDC_COMBO_MONTH_DAY);
  899. ShowWindow(XTP_IDC_STATIC_MONTH_EVERY);
  900. ShowWindow(XTP_IDC_EDIT_MONTH_MONTH2);
  901. ShowWindow(XTP_IDC_STATIC_MONTH_MONTH2);
  902. break;
  903. case XTP_IDC_RADIO_YEARLY:
  904. ShowWindow(XTP_IDC_RADIO_YEAR_RECUR);
  905. ShowWindow(XTP_IDC_RADIO_YEAR_IN);
  906. ShowWindow(XTP_IDC_EDIT_YEAR_DATE);
  907. ShowWindow(XTP_IDC_COMBO_YEAR_MONTH);
  908. ShowWindow(XTP_IDC_COMBO_YEAR_CRIT);
  909. ShowWindow(XTP_IDC_COMBO_YEAR_DAY);
  910. ShowWindow(XTP_IDC_COMBO_YEAR_MONTH2);
  911. ShowWindow(XTP_IDC_STATIC_YEAR_OF);
  912. break;
  913. }
  914. }
  916. CRect CXTPCalendarEventRecurrenceDlg::GetCtrlRect(int nID)
  917. {
  918. ASSERT(GetDlgItem(nID));
  920. CRect rcRect(0, 0, 0, 0);
  922. if (GetDlgItem(nID))
  923. GetDlgItem(nID)->GetWindowRect(&rcRect);
  925. return rcRect;
  926. }
  928. void CXTPCalendarEventRecurrenceDlg::MoveWindow_Y(int nID, int nYOffset)
  929. {
  930. if (GetDlgItem(nID))
  931. {
  932. CRect rcRect = GetCtrlRect(nID);
  933. ScreenToClient(&rcRect);
  935. rcRect.top += nYOffset;
  936. rcRect.bottom += nYOffset;
  938. GetDlgItem(nID)->MoveWindow(rcRect);
  939. }
  940. else
  941. {
  942. ASSERT(FALSE);
  943. }
  944. }
  946. void CXTPCalendarEventRecurrenceDlg::_MoveControlsBy_Y()
  947. {
  948. CRect rcBase = GetCtrlRect(XTP_IDC_RADIO_DAILY);
  949. rcBase.top += 10;
  951. CRect rcBase2 = GetCtrlRect(XTP_IDC_RADIO_EVERYDAY);
  952. int nYOffset = rcBase.top - rcBase2.top;
  954. MoveWindow_Y(XTP_IDC_RADIO_EVERYDAY,    nYOffset);
  955. MoveWindow_Y(XTP_IDC_RADIO_EVERYWORKDAY,nYOffset);
  956. MoveWindow_Y(XTP_IDC_EDIT_DAYINTERVAL,  nYOffset);
  957. MoveWindow_Y(XTP_IDC_STATIC_DAY,        nYOffset);
  959. rcBase2 = GetCtrlRect(XTP_IDC_STATIC_WEEKLY_RECEVERY);
  960. nYOffset = rcBase.top - rcBase2.top;
  962. MoveWindow_Y(XTP_IDC_STATIC_WEEKLY_RECEVERY,nYOffset);
  963. MoveWindow_Y(XTP_IDC_EDIT_WEEKLY_INTERVAL,  nYOffset);
  964. MoveWindow_Y(XTP_IDC_STATIC_WEEKLY_FOLLDAYS,nYOffset);
  965. MoveWindow_Y(XTP_IDC_CHECK_MONDAY,          nYOffset);
  966. MoveWindow_Y(XTP_IDC_CHECK_TUESDAY,         nYOffset);
  967. MoveWindow_Y(XTP_IDC_CHECK_WEDNESDAY,       nYOffset);
  968. MoveWindow_Y(XTP_IDC_CHECK_THURSDAY,        nYOffset);
  969. MoveWindow_Y(XTP_IDC_CHECK_FRIDAY,          nYOffset);
  970. MoveWindow_Y(XTP_IDC_CHECK_SATURDAY,        nYOffset);
  971. MoveWindow_Y(XTP_IDC_CHECK_SUNDAY,          nYOffset);
  973. rcBase2 = GetCtrlRect(XTP_IDC_RADIO_MONTH_RECUR);
  974. nYOffset = rcBase.top - rcBase2.top;
  976. MoveWindow_Y(XTP_IDC_RADIO_MONTH_RECUR,     nYOffset);
  977. MoveWindow_Y(XTP_IDC_RADIO_MONTH_IN,        nYOffset);
  978. MoveWindow_Y(XTP_IDC_EDIT_MONTH_DATE,       nYOffset);
  979. MoveWindow_Y(XTP_IDC_STATIC_MONTH_NUMEVERY, nYOffset);
  980. MoveWindow_Y(XTP_IDC_EDIT_MONTH_MONTH,      nYOffset);
  981. MoveWindow_Y(XTP_IDC_STATIC_MONTH_MONTH,    nYOffset);
  982. MoveWindow_Y(XTP_IDC_COMBO_MONTH_CRIT,      nYOffset);
  983. MoveWindow_Y(XTP_IDC_COMBO_MONTH_DAY,       nYOffset);
  984. MoveWindow_Y(XTP_IDC_STATIC_MONTH_EVERY,    nYOffset);
  985. MoveWindow_Y(XTP_IDC_EDIT_MONTH_MONTH2,     nYOffset);
  986. MoveWindow_Y(XTP_IDC_STATIC_MONTH_MONTH2,   nYOffset);
  988. rcBase2 = GetCtrlRect(XTP_IDC_RADIO_YEAR_RECUR);
  989. nYOffset = rcBase.top - rcBase2.top;
  991. MoveWindow_Y(XTP_IDC_RADIO_YEAR_RECUR,  nYOffset);
  992. MoveWindow_Y(XTP_IDC_RADIO_YEAR_IN,     nYOffset);
  993. MoveWindow_Y(XTP_IDC_EDIT_YEAR_DATE,    nYOffset);
  994. MoveWindow_Y(XTP_IDC_COMBO_YEAR_MONTH,  nYOffset);
  995. MoveWindow_Y(XTP_IDC_COMBO_YEAR_CRIT,   nYOffset);
  996. MoveWindow_Y(XTP_IDC_COMBO_YEAR_DAY,    nYOffset);
  997. MoveWindow_Y(XTP_IDC_COMBO_YEAR_MONTH2, nYOffset);
  998. MoveWindow_Y(XTP_IDC_STATIC_YEAR_OF,    nYOffset);
  1000. //------------------------------------------------------------------------
  1001. CRect rcDialog;
  1002. GetWindowRect(&rcDialog);
  1004. CRect rcOK = GetCtrlRect(IDOK);
  1005. rcDialog.bottom = rcOK.bottom + 10;
  1007. SetWindowPos(NULL, 0, 0, rcDialog.Width(), rcDialog.Height(), SWP_NOMOVE | SWP_NOZORDER);
  1008. }