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

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

对话框与窗口

开发平台：

Visual C++

XTPCalendarRecurrencePattern.cpp：源码内容
  1. // XTPCalendarRecurrencePattern.cpp: implementation of the CXTPCalendarRecurrencePattern class.
  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"
  23. #include "Common/XTPPropExchange.h"
  24. #include "Common/XTPVC50Helpers.h"
  25. #include "Common/XTPVC80Helpers.h"
  27. #include "XTPCalendarRecurrencePattern.h"
  28. #include "XTPCalendarEvents.h"
  29. #include "XTPCalendarEvent.h"
  30. #include "XTPCalendarUtils.h"
  31. #include "XTPCalendarData.h"
  32. #include "XTPCalendarCustomProperties.h"
  33. #include "XTPCalendarRemindersManager.h"
  35. static LPCTSTR cszRPatt_PatternID = _T("PatternID");
  36. static LPCTSTR cszRPatt_StartTime = _T("StartTime");
  38. static LPCTSTR cszRPatt_DurationMinutes = _T("DurationMinutes");
  39. static LPCTSTR cszRPatt_RecurrenceType = _T("RecurrenceType");
  40. static LPCTSTR cszRPatt_RecurrenceOpt_Data1 = _T("RecurrenceOpt_Data1");
  41. static LPCTSTR cszRPatt_RecurrenceOpt_Data2 = _T("RecurrenceOpt_Data2");
  42. static LPCTSTR cszRPatt_RecurrenceOpt_Data3 = _T("RecurrenceOpt_Data3");
  44. static LPCTSTR cszRPatt_PatternStartDate = _T("PatternStartDate");
  45. static LPCTSTR cszRPatt_UseEndMethod = _T("UseEndMethod");
  46. static LPCTSTR cszRPatt_PatternEndDate = _T("PatternEndDate");
  47. static LPCTSTR cszRPatt_EndAfterOccurrences = _T("EndAfterOccurrences");
  49. static LPCTSTR cszRPatt_MasterEventID = _T("MasterEventID");
  51. //===========================================================================
  52. static const LPCTSTR cszOccRMD_Count        = _T("*xtp*OccRMD_Count");
  54. static const LPCTSTR cszOccRMD_StartTime    = _T("*xtp*OccRMD_Start");
  55. static const LPCTSTR cszOccRMD_EndTime      = _T("*xtp*OccRMD_End");
  57. static const LPCTSTR cszOccRMD_IsReminder                 = _T("*xtp*OccRMD_IsReminder");
  58. static const LPCTSTR cszOccRMD_NextReminderTime_Snoozed = _T("*xtp*OccRMD_NextReminderTime_Snoozed");
  59. //===========================================================================
  61. #ifdef _DEBUG
  62. #define new DEBUG_NEW
  63. #undef THIS_FILE
  64. static char THIS_FILE[] = __FILE__;
  65. #endif
  66. ////////////////////////////////////////////////////////////////////////////
  67. #define XTP_RECPATT_PROP_SET_DATA_VER 1
  68. ////////////////////////////////////////////////////////////////////////////
  70. IMPLEMENT_DYNAMIC(CXTPCalendarRecurrencePattern, CCmdTarget)
  72. /////////////////////////////////////////////////////////////////////////////
  73. CXTPCalendarRecurrencePattern::CXTPCalendarRecurrencePattern(CXTPCalendarData* pDataProvider)
  74. {
  75. ASSERT(pDataProvider);
  77. m_ptrDataProvider = pDataProvider;
  78. CMDTARGET_ADDREF(m_ptrDataProvider);
  80. m_dwPatternID = XTP_CALENDAR_UNKNOWN_RECURRENCE_PATTERN_ID;
  81. m_dwMasterEventID = XTP_CALENDAR_UNKNOWN_EVENT_ID;
  83. m_dtStartTime = (DATE)0; //.SetStatus(COleDateTime::null);
  84. m_nDurationMinutes = 0;
  86. m_Options.m_nRecurrenceType = xtpCalendarRecurrenceUnknown;
  88. m_dtPatternStartDate = (DATE)0; //.SetStatus(COleDateTime::null);
  90. m_pCustomProperties = new CXTPCalendarCustomProperties;
  92. }
  94. CXTPCalendarRecurrencePattern::~CXTPCalendarRecurrencePattern()
  95. {
  96. CMDTARGET_RELEASE(m_ptrDataProvider);
  97. CMDTARGET_RELEASE(m_pCustomProperties);
  98. }
  100. COleDateTime CXTPCalendarRecurrencePattern::GetStartOccurrenceTime(COleDateTime dtOccurrenceStartDate) const
  101. {
  102. COleDateTime dtStartOcc = GetStartTime();
  103. dtStartOcc = CXTPCalendarUtils::UpdateDate(dtStartOcc, dtOccurrenceStartDate);
  105. return dtStartOcc;
  106. }
  108. COleDateTime CXTPCalendarRecurrencePattern::GetEndOccurrenceTime(COleDateTime dtOccurrenceStartDate) const
  109. {
  110. COleDateTimeSpan spDuration = GetDuration();
  111. COleDateTime dtEndOcc = GetStartOccurrenceTime(dtOccurrenceStartDate);
  113. dtEndOcc += spDuration;
  115. return dtEndOcc;
  116. }
  118. void CXTPCalendarRecurrencePattern::_GetOccurrenceStartEnd(const COleDateTime& dtOccStartDate, COleDateTime& rdtOccStart, COleDateTime& rdtOccEnd) const
  119. {
  120. rdtOccStart = GetStartTime();
  121. rdtOccStart = CXTPCalendarUtils::UpdateDate(rdtOccStart, dtOccStartDate);
  123. COleDateTimeSpan spDuration = GetDuration();
  124. rdtOccEnd = rdtOccStart + spDuration;
  125. }
  127. void CXTPCalendarRecurrencePattern::SetPatternStartDate(COleDateTime dtStart)
  128. {
  129. m_dtPatternStartDate = CXTPCalendarUtils::ResetTime(dtStart);
  131. if (m_dtPatternStartDate.GetStatus() == COleDateTime::valid &&
  132. m_PatternEnd.m_dtPatternEndDate.GetStatus() == COleDateTime::valid &&
  133. m_dtPatternStartDate > m_PatternEnd.m_dtPatternEndDate)
  134. {
  135. m_PatternEnd.m_dtPatternEndDate = m_dtPatternStartDate;
  136. }
  137. }
  139. void CXTPCalendarRecurrencePattern::SetPatternEndDate(COleDateTime dtEnd)
  140. {
  141. m_PatternEnd.m_dtPatternEndDate = CXTPCalendarUtils::ResetTime(dtEnd);
  142. m_PatternEnd.m_nUseEnd = xtpCalendarPatternEndDate;
  144. if (m_dtPatternStartDate.GetStatus() == COleDateTime::valid &&
  145. m_PatternEnd.m_dtPatternEndDate.GetStatus() == COleDateTime::valid &&
  146. m_PatternEnd.m_dtPatternEndDate < m_dtPatternStartDate)
  147. {
  148. m_dtPatternStartDate = m_PatternEnd.m_dtPatternEndDate;
  149. }
  150. }
  152. BOOL CXTPCalendarRecurrencePattern::GetOccurrences(CXTPCalendarEvents* pEventsArray,
  153. COleDateTime dtStart, COleDateTime dtEnd,
  154. CXTPCalendarEvent* pMasterEvent)
  155. {
  156. if (!pMasterEvent || !pEventsArray)
  157. {
  158. ASSERT(FALSE);
  159. return FALSE;
  160. }
  162. //------
  163. COleDateTime dtStartOcc, dtEndOcc;
  164. _GetOccurrenceStartEnd(dtStart, dtStartOcc, dtEndOcc);
  166. int nOccDays = CXTPCalendarUtils::GetEventPeriodDays(dtStartOcc, dtEndOcc);
  167. ASSERT(nOccDays > 0);
  168. nOccDays = max(1, nOccDays);
  170. COleDateTime dtStartCheckOcc = dtStart;
  172. if (dtStart == dtEnd)
  173. {
  174. //- check for previous multiday occurrences ---
  175. if (nOccDays > 1)
  176. {
  177. COleDateTimeSpan spCheckMDOcc(nOccDays - 1, 0, 0, 0);
  178. dtStartCheckOcc = dtStart - spCheckMDOcc;
  179. }
  180. }
  181. CXTPCalendarDatesArray arDates;
  182. GetOccurrencesDates(arDates, dtStartCheckOcc, dtEnd);
  184. COleDateTime dtI;
  185. int nCount = (int)arDates.GetSize();
  186. for (int i = 0; i < nCount; i++)
  187. {
  188. dtI = arDates[i];
  190. _GetOccurrenceStartEnd(dtI, dtStartOcc, dtEndOcc);
  192. ASSERT(!(CXTPCalendarUtils::ResetTime(dtEndOcc) < CXTPCalendarUtils::ResetTime(dtStart) ||
  193. CXTPCalendarUtils::ResetTime(dtStartOcc) > CXTPCalendarUtils::ResetTime(dtEnd)));
  195. CXTPCalendarEventPtr ptrOccurrenceEvent(FindException(dtStartOcc, dtEndOcc), TRUE);
  197. if (ptrOccurrenceEvent)
  198. {
  199. continue;
  200. }
  201. else
  202. {
  203. ptrOccurrenceEvent = pMasterEvent->CloneForOccurrence(dtStartOcc, dtEndOcc);
  205. if (ptrOccurrenceEvent && ptrOccurrenceEvent->GetStartTime() <
  206. pMasterEvent->GetLastModificationTime())
  207. {
  208. ptrOccurrenceEvent->SetReminder(FALSE);
  209. }
  210. }
  212. if (ptrOccurrenceEvent)
  213. {
  214. m_arOccReminders.UpdateOccIfNeed(ptrOccurrenceEvent, this);
  216. pEventsArray->Add(ptrOccurrenceEvent);
  217. }
  218. }
  220. FindExceptions(pEventsArray, dtStart, dtEnd);
  222. return TRUE;
  223. }
  225. void CXTPCalendarRecurrencePattern::GetOccurrencesDates(CXTPCalendarDatesArray& rArDates,
  226. COleDateTime dtStart, COleDateTime dtEnd) const
  227. {
  228. COleDateTime dtStart0 = CXTPCalendarUtils::ResetTime(dtStart);
  229. COleDateTime dtEnd0 = CXTPCalendarUtils::SetTime_235959(dtEnd);
  231. int nMaxOccCount = INT_MAX;
  232. int nOccCount = 0;
  233. COleDateTime dtI;
  234. COleDateTime dtE1(9999, 1, 1, 0, 0, 0);
  235. COleDateTime dtS1 = max(dtStart0, m_dtPatternStartDate);
  237. switch (m_PatternEnd.m_nUseEnd)
  238. {
  239. case xtpCalendarPatternEndDate:
  240. dtE1 = min(m_PatternEnd.m_dtPatternEndDate, dtEnd0);
  241. break;
  242. case xtpCalendarPatternEndAfterOccurrences:
  243. nMaxOccCount = m_PatternEnd.m_nEndAfterOccurrences;
  244. dtE1 = dtEnd0;
  245. break;
  246. case xtpCalendarPatternEndNoDate:
  247. dtE1 = dtEnd0;
  248. break;
  249. default:
  250. ASSERT(FALSE);
  251. return;
  252. }
  254. switch (m_Options.m_nRecurrenceType)
  255. {
  256. case xtpCalendarRecurrenceDaily:
  257. {
  258. //------------------------------------------------------
  259. // 1. Every N days:
  260. //      m_nInterval = N,
  261. //      m_nDayOfWeekMask = xtpCalendarDayAllWeek
  262. //------------------------------------------------------
  263. // 2. Every week day (Mo-Fr):
  264. //      m_nInterval = 1,
  265. //      m_nDayOfWeekMask = xtpCalendarDayMo_Fr
  266. //------------------------------------------------------
  268. int nDays = m_Options.m_Daily.nIntervalDays;
  270. if (m_Options.m_Daily.bEveryWeekDayOnly)
  271. {
  272. ASSERT(nDays == 1);
  273. nDays = 1;
  274. }
  276. COleDateTimeSpan spStep(nDays, 0, 0, 0);
  278. if (m_dtPatternStartDate < dtStart0)
  279. {
  280. //--- shift start date --------------
  281. COleDateTimeSpan spDiff = dtStart0 - m_dtPatternStartDate;
  282. int nDiff_Days = (int)GETTOTAL_DAYS_DTS(spDiff);
  283. ASSERT(nDiff_Days >= 1);
  285. int nJump_Days = (nDiff_Days / nDays) * nDays;
  286. spDiff.SetDateTimeSpan(nJump_Days, 0, 0, 0);
  288. dtS1 = m_dtPatternStartDate + spDiff;
  289. if (dtS1 < dtStart0)
  290. {
  291. dtS1 += spStep;
  292. }
  294. //--- calculate occurrences ----------
  295. if (nMaxOccCount != INT_MAX)
  296. {
  297. nOccCount = nDiff_Days / nDays;
  299. if (m_Options.m_Daily.bEveryWeekDayOnly)
  300. {
  301. int nWDstart = m_dtPatternStartDate.GetDayOfWeek();
  303. int nBasis1_days = (nDiff_Days - (7 - nWDstart));
  304. int nSatDays = nBasis1_days / 7 + ((nBasis1_days % 7) ? 1 : 0);
  306. int nBasis6_days = (nDiff_Days - (6 - nWDstart));
  307. int nSunDays = nBasis6_days / 7 + ((nBasis6_days % 7) ? 1 : 0);
  309. nOccCount -= nSatDays + nSunDays;
  310. }
  311. }
  312. }
  313. else
  314. {
  315. dtS1 = m_dtPatternStartDate;
  316. }
  318. for (dtI = dtS1; dtI <= dtE1 && nOccCount < nMaxOccCount; dtI += spStep)
  319. {
  320. if (m_Options.m_Daily.bEveryWeekDayOnly)
  321. {
  322. int nWD = dtI.GetDayOfWeek(); // 1-Sunday, 2 - Monday, ...
  323. if (nWD == 1 || nWD == 7)
  324. {
  325. continue;
  326. }
  327. }
  328. ASSERT(dtI >= dtStart0 && dtI <= dtE1);
  329. rArDates.Add(dtI);
  330. nOccCount++;
  331. }
  332. }
  333. break;
  335. case xtpCalendarRecurrenceWeekly:
  336. {
  337. //------------------------------------------------------
  338. // 1. Every N weeks:
  339. //      m_nInterval = N,
  340. //      m_nDayOfWeekMask = <*MASK*>
  341. //------------------------------------------------------
  343. int nWeeksStep = m_Options.m_Weekly.nIntervalWeeks;
  344. if (nWeeksStep <= 0)
  345. {
  346. ASSERT(FALSE);
  347. nWeeksStep = 1;
  348. }
  349. COleDateTimeSpan spStep(1, 0, 0, 0);
  350. COleDateTimeSpan spStepWeeks((nWeeksStep)*7, 0, 0, 0);
  352. //================================================================
  353. int nFirstDayOfWeekIndex = 2; // Always Monday (as in MS Outlook)
  355. COleDateTimeSpan spWeek(7, 0, 0, 0);
  356. COleDateTime dtPatSW = CXTPCalendarUtils::ShiftDateToWeekBegin(m_dtPatternStartDate, nFirstDayOfWeekIndex);
  357. dtPatSW = CXTPCalendarUtils::ResetTime(dtPatSW);
  359. COleDateTime dtOccFrame1 = dtPatSW;
  360. COleDateTime dtOccFrame2 = dtOccFrame1 + spWeek;
  362. if (m_dtPatternStartDate < dtStart0)
  363. {
  364. COleDateTime dtStart0SW = CXTPCalendarUtils::ShiftDateToWeekBegin(dtStart0, nFirstDayOfWeekIndex);
  366. COleDateTimeSpan spDiff = dtStart0SW - dtPatSW;
  368. int nDiff_Weeks = (int)spDiff.GetTotalDays() / 7;
  369. ASSERT((int)spDiff.GetTotalDays() % 7 == 0);
  371. int nJump_Weeks = (nDiff_Weeks / nWeeksStep) * nWeeksStep;
  372. spDiff.SetDateTimeSpan(nJump_Weeks * 7, 0, 0, 0);
  374. dtOccFrame1 = dtPatSW + spDiff;
  375. dtOccFrame2 = dtOccFrame1 + spWeek;
  377. nOccCount = CXTPCalendarUtils::GetDayOfWeekCount(m_Options.m_Weekly.nDayOfWeekMask);
  378. nOccCount *= nJump_Weeks / nWeeksStep;
  380. //------------------------------------------------------------
  381. int nSkippedMask = CXTPCalendarUtils::MakeDaysOfWeekMask_Mo_(m_dtPatternStartDate.GetDayOfWeek());
  382. nOccCount -= CXTPCalendarUtils::GetDayOfWeekCount(nSkippedMask & m_Options.m_Weekly.nDayOfWeekMask);
  383. //------------------------------------------------------------
  384. int nAddedMask = CXTPCalendarUtils::MakeDaysOfWeekMask_Mo_(dtS1.GetDayOfWeek());
  385. nOccCount += CXTPCalendarUtils::GetDayOfWeekCount(nAddedMask & m_Options.m_Weekly.nDayOfWeekMask);
  386. }
  387. //================================================================
  389. for (dtI = dtS1; dtI <= dtE1 && nOccCount < nMaxOccCount; dtI += spStep)
  390. {
  391. if (nWeeksStep > 1 && !(dtOccFrame1 <= dtI && dtI < dtOccFrame2))
  392. {
  393. dtOccFrame1 += spStepWeeks;
  394. dtOccFrame2 = dtOccFrame1 + spWeek;
  396. dtI = dtOccFrame1 - spStep;
  397. continue;
  398. }
  400. int nWD = dtI.GetDayOfWeek(); // 1-Sunday, 2 - Monday, ...
  401. int nWDMask = CXTPCalendarUtils::GetDayOfWeekMask(nWD);
  403. if (m_Options.m_Weekly.nDayOfWeekMask & nWDMask)
  404. {
  405. ASSERT(dtI >= dtStart0 && dtI <= dtE1);
  406. rArDates.Add(dtI);
  407. nOccCount++;
  408. }
  409. }
  410. }
  411. break;
  413. case xtpCalendarRecurrenceMonthly:
  414. {
  415. //------------------------------------------------------
  416. // 1. Day N of every M month(s):
  417. //      m_nDayOfMonth = N,
  418. //      m_nInterval = M
  419. //------------------------------------------------------
  421. //================================================================
  422. int nMInterval = m_Options.m_Monthly.nIntervalMonths;
  423. if (nMInterval <= 0)
  424. {
  425. ASSERT(FALSE);
  426. nMInterval = 1;
  427. }
  429. COleDateTime dtOccFrame1 = CXTPCalendarUtils::ResetTime(m_dtPatternStartDate);
  430. CXTPCalendarUtils::UpdateMonthDay(dtOccFrame1, 1);
  432. if (m_dtPatternStartDate < dtStart0)
  433. {
  434. int nPS_Year = m_dtPatternStartDate.GetYear();
  435. int nPS_Month = m_dtPatternStartDate.GetMonth();
  436. int nPS_GlobalMonth = nPS_Year * 12 + nPS_Month;
  438. int nS0_Year = dtStart0.GetYear();
  439. int nS0_Month = dtStart0.GetMonth();
  440. int nS0_GlobalMonth = nS0_Year * 12 + nS0_Month;
  442. int nMonthDiff = nS0_GlobalMonth - nPS_GlobalMonth;
  443. int nJump_Month = (nMonthDiff / nMInterval) * nMInterval;
  445. CXTPCalendarUtils::ShiftDate_Month(dtOccFrame1, nJump_Month, 1);
  447. nOccCount = nJump_Month / nMInterval;
  449. //------------------------------------------------------------
  450. if (m_dtPatternStartDate.GetDay() > m_Options.m_Monthly.nDayOfMonth)
  451. {
  452. nOccCount--;
  453. }
  454. //------------------------------------------------------------
  455. if (dtS1.GetDay() > m_Options.m_Monthly.nDayOfMonth)
  456. {
  457. nOccCount++;
  458. }
  459. }
  460. //================================================================
  462. COleDateTime dtOcc(dtOccFrame1);
  463. VERIFY(CXTPCalendarUtils::UpdateMonthDay(dtOcc, m_Options.m_Monthly.nDayOfMonth));
  464. if (dtOcc >= dtS1)
  465. {
  466. dtS1 = dtOcc;
  467. }
  468. else
  469. {
  470. dtS1 = dtOcc;
  471. CXTPCalendarUtils::ShiftDate_Month(dtS1, m_Options.m_Monthly.nIntervalMonths,
  472. m_Options.m_Monthly.nDayOfMonth);
  473. }
  475. for (dtI = dtS1; dtI <= dtE1 && nOccCount < nMaxOccCount;)
  476. {
  477. ASSERT(dtI >= dtStart0 && dtI <= dtE1);
  478. rArDates.Add(dtI);
  479. nOccCount++;
  481. CXTPCalendarUtils::ShiftDate_Month(dtI, m_Options.m_Monthly.nIntervalMonths,
  482. m_Options.m_Monthly.nDayOfMonth);
  483. }
  484. }
  485. break;
  487. case xtpCalendarRecurrenceMonthNth:
  488. {
  489. //------------------------------------------------------
  490. //~ The I:{First, second, ..., Last>
  491. //~         W:{Day, WeekDay, WeekEndDay, Su, Mo, ...}
  492. //~             of every M month(s):
  493. //------------------------------------------------------
  495. //================================================================
  496. int nMInterval = m_Options.m_MonthNth.nIntervalMonths;
  497. if (nMInterval <= 0)
  498. {
  499. ASSERT(FALSE);
  500. nMInterval = 1;
  501. }
  503. COleDateTime dtOccFrame1 = CXTPCalendarUtils::ResetTime(m_dtPatternStartDate);
  504. CXTPCalendarUtils::UpdateMonthDay(dtOccFrame1, 1);
  506. if (m_dtPatternStartDate < dtStart0)
  507. {
  508. int nPS_Year = m_dtPatternStartDate.GetYear();
  509. int nPS_Month = m_dtPatternStartDate.GetMonth();
  510. int nPS_GlobalMonth = nPS_Year * 12 + nPS_Month;
  512. int nS0_Year = dtStart0.GetYear();
  513. int nS0_Month = dtStart0.GetMonth();
  514. int nS0_GlobalMonth = nS0_Year * 12 + nS0_Month;
  516. int nMonthDiff = nS0_GlobalMonth - nPS_GlobalMonth;
  517. int nJump_Month = (nMonthDiff / nMInterval) * nMInterval;
  519. CXTPCalendarUtils::ShiftDate_Month(dtOccFrame1, nJump_Month, 1);
  521. nOccCount = nJump_Month / nMInterval;
  523. //------------------------------------------------------------
  524. COleDateTime dtTestMD(m_dtPatternStartDate);
  525. CXTPCalendarUtils::CalcDayOfMonth(dtTestMD,
  526. m_Options.m_MonthNth.nWhichDay,
  527. m_Options.m_MonthNth.nWhichDayMask);
  529. if (m_dtPatternStartDate.GetDay() > dtTestMD.GetDay())
  530. {
  531. nOccCount--;
  532. }
  533. //------------------------------------------------------------
  534. dtTestMD = dtS1;
  535. CXTPCalendarUtils::CalcDayOfMonth(dtTestMD,
  536. m_Options.m_MonthNth.nWhichDay,
  537. m_Options.m_MonthNth.nWhichDayMask);
  539. if (dtS1.GetDay() > dtTestMD.GetDay())
  540. {
  541. nOccCount++;
  542. }
  543. }
  544. //================================================================
  546. COleDateTime dtOcc(dtOccFrame1);
  548. BOOL bRes = CXTPCalendarUtils::CalcDayOfMonth(dtOcc, m_Options.m_MonthNth.nWhichDay,
  549. m_Options.m_MonthNth.nWhichDayMask);
  550. if (!bRes)
  551. {
  552. return;
  553. }
  555. if (dtOcc >= dtS1)
  556. {
  557. dtS1 = dtOcc;
  558. }
  559. else
  560. {
  561. dtS1 = dtOcc;
  562. CXTPCalendarUtils::ShiftDate_Month(dtS1, nMInterval);
  563. bRes = CXTPCalendarUtils::CalcDayOfMonth(dtS1, m_Options.m_MonthNth.nWhichDay,
  564. m_Options.m_MonthNth.nWhichDayMask);
  565. if (!bRes)
  566. {
  567. return;
  568. }
  569. }
  571. for (dtI = dtS1; dtI <= dtE1 && nOccCount < nMaxOccCount;)
  572. {
  573. ASSERT(dtI >= dtStart0 && dtI <= dtE1);
  574. rArDates.Add(dtI);
  575. nOccCount++;
  577. CXTPCalendarUtils::ShiftDate_Month(dtI, nMInterval);
  578. bRes = CXTPCalendarUtils::CalcDayOfMonth(dtI, m_Options.m_MonthNth.nWhichDay,
  579. m_Options.m_MonthNth.nWhichDayMask);
  580. if (!bRes)
  581. {
  582. ASSERT(FALSE);
  583. break;
  584. }
  585. }
  586. }
  587. break;
  589. case xtpCalendarRecurrenceYearly:
  590. {
  591. //------------------------------------------------------
  592. // Every M:{month} D:{Day}
  593. //      m_nMonthOfYear = M
  594. //      m_nDayOfMonth = D
  595. //------------------------------------------------------
  597. COleDateTime dtOcc(dtS1.GetYear(), m_Options.m_Yearly.nMonthOfYear,
  598.    1, 0, 0, 0);
  599. CXTPCalendarUtils::UpdateMonthDay(dtOcc, m_Options.m_Yearly.nDayOfMonth);
  601. if (dtOcc >= dtS1)
  602. {
  603. dtS1 = dtOcc;
  604. }
  605. else
  606. {
  607. dtS1 = dtOcc;
  608. CXTPCalendarUtils::ShiftDate_Year(dtS1, 1, m_Options.m_Yearly.nDayOfMonth);
  609. }
  611. for (dtI = dtS1; dtI <= dtE1 && nOccCount < nMaxOccCount;
  612.  CXTPCalendarUtils::ShiftDate_Year(dtI, 1, m_Options.m_Yearly.nDayOfMonth))
  613. {
  614. ASSERT(dtI >= dtStart0 && dtI <= dtE1);
  615. rArDates.Add(dtI);
  616. nOccCount++;
  617. }
  618. }
  619. break;
  621. case xtpCalendarRecurrenceYearNth:
  622. {
  623. //------------------------------------------------------
  624. //~ The I:{First, second, ..., Last>
  625. //~         W:{Day, WeekDay, WeekEndDay, Su, Mo, ...}
  626. //~             of M:{month}
  627. //------------------------------------------------------
  628. COleDateTime dtOcc(dtS1.GetYear(), m_Options.m_YearNth.nMonthOfYear,
  629. 1, 0, 0, 0);
  631. BOOL bRes = CXTPCalendarUtils::CalcDayOfMonth(dtOcc,
  632. m_Options.m_YearNth.nWhichDay,
  633. m_Options.m_YearNth.nWhichDayMask);
  634. if (!bRes)
  635. {
  636. return;
  637. }
  639. if (dtOcc >= dtS1)
  640. {
  641. dtS1 = dtOcc;
  642. }
  643. else
  644. {
  645. dtS1 = dtOcc;
  646. CXTPCalendarUtils::ShiftDate_Year(dtS1, 1);
  647. bRes = CXTPCalendarUtils::CalcDayOfMonth(dtS1, m_Options.m_YearNth.nWhichDay,
  648. m_Options.m_YearNth.nWhichDayMask);
  649. if (!bRes)
  650. {
  651. return;
  652. }
  653. }
  655. for (dtI = dtS1; dtI <= dtE1 && nOccCount < nMaxOccCount;)
  656. {
  657. ASSERT(dtI >= dtStart0 && dtI <= dtE1);
  658. rArDates.Add(dtI);
  659. nOccCount++;
  661. CXTPCalendarUtils::ShiftDate_Year(dtI, 1);
  662. bRes = CXTPCalendarUtils::CalcDayOfMonth(dtI, m_Options.m_YearNth.nWhichDay,
  663. m_Options.m_YearNth.nWhichDayMask);
  664. if (!bRes)
  665. {
  666. ASSERT(FALSE);
  667. break;
  668. }
  669. }
  670. }
  671. }
  672. }
  675. void CXTPCalendarRecurrencePattern::SetRecurrenceOptions(const XTP_CALENDAR_RECURRENCE_OPTIONS& Options)
  676. {
  677. m_Options = Options;
  679. if (m_Options.m_nRecurrenceType == xtpCalendarRecurrenceDaily &&
  680. m_Options.m_Daily.bEveryWeekDayOnly)
  681. {
  682. m_Options.m_Daily.nIntervalDays = 1;
  683. }
  684. }
  687. void CXTPCalendarRecurrencePattern::SetPatternEnd(const XTP_CALENDAR_PATTERN_END& patternEnd)
  688. {
  689. m_PatternEnd = patternEnd;
  691. if (m_PatternEnd.m_nUseEnd == xtpCalendarPatternEndDate)
  692. {
  693. m_PatternEnd.m_dtPatternEndDate = CXTPCalendarUtils::ResetTime(m_PatternEnd.m_dtPatternEndDate);
  695. if (m_dtPatternStartDate.GetStatus() == COleDateTime::valid &&
  696. m_PatternEnd.m_dtPatternEndDate.GetStatus() == COleDateTime::valid &&
  697. m_PatternEnd.m_dtPatternEndDate < m_dtPatternStartDate)
  698. {
  699. m_dtPatternStartDate = m_PatternEnd.m_dtPatternEndDate;
  700. }
  701. }
  702. }
  705. CXTPCalendarRecurrencePatternPtr CXTPCalendarRecurrencePattern::ClonePattern()
  706. {
  707. if (!m_ptrDataProvider)
  708. {
  709. ASSERT(FALSE);
  710. return NULL;
  711. }
  713. DWORD dwPatternID = GetPatternID();
  714. DWORD dwMasterID = GetMasterEventID();
  716. CXTPCalendarRecurrencePatternPtr ptrNew = m_ptrDataProvider->CreateNewRecurrencePattern();
  717. if (!ptrNew)
  718. {
  719. ASSERT(FALSE);
  720. return NULL;
  721. }
  722. ptrNew->SetPatternID(dwPatternID);
  723. ptrNew->SetMasterEventID(dwMasterID);
  725. if (!ptrNew->Update(this))
  726. {
  727. ASSERT(FALSE);
  728. return NULL;
  729. }
  731. return ptrNew;
  732. }
  734. BOOL CXTPCalendarRecurrencePattern::Update(CXTPCalendarRecurrencePattern* pNewData)
  735. {
  736. if (pNewData == this)
  737. {
  738. return TRUE;
  739. }
  741. COleDateTime dtTmp = pNewData->GetStartTime();
  742. SetStartTime(dtTmp);
  744. int nTmp = pNewData->GetDurationMinutes();
  745. SetDurationMinutes(nTmp);
  747. const XTP_CALENDAR_RECURRENCE_OPTIONS& rOpt = pNewData->GetRecurrenceOptions();
  748. SetRecurrenceOptions(rOpt);
  750. dtTmp = pNewData->GetPatternStartDate();
  751. SetPatternStartDate(dtTmp);
  753. const XTP_CALENDAR_PATTERN_END& rPatternEnd = pNewData->GetPatternEnd();
  754. SetPatternEnd(rPatternEnd);
  756. RemoveAllExceptions();
  758. CXTPCalendarEventsPtr ptrExceptions = pNewData->GetExceptions();
  760. int nCount = XTP_SAFE_GET1(ptrExceptions, GetCount(), 0);
  761. for (int i = 0; i < nCount; i++)
  762. {
  763. CXTPCalendarEvent* pException = ptrExceptions->GetAt(i, FALSE);
  764. if (pException)
  765. {
  766. if (!SetException(pException))
  767. {
  768. ASSERT(FALSE);
  769. }
  770. }
  771. }
  773. ASSERT(pNewData->GetCustomProperties());
  774. pNewData->GetCustomProperties()->CopyTo(m_pCustomProperties);
  776. m_arOccReminders.RemoveAll();
  777. m_arOccReminders.Append(pNewData->m_arOccReminders);
  779. return TRUE;
  780. }
  782. BOOL CXTPCalendarRecurrencePattern::SetException(CXTPCalendarEvent* pException, CXTPCalendarEvent* pMasterEventToUpdate)
  783. {
  784. if (!pException)
  785. {
  786. ASSERT(FALSE);
  787. return FALSE;
  788. }
  790. DWORD dwExcID = pException->GetEventID();
  791. CXTPCalendarEvent* pExc = m_arExceptionEvents.FindEvent(dwExcID);
  793. if (!pExc)
  794. {
  795. COleDateTime dtStartOcc = pException->GetRException_StartTimeOrig();
  796. COleDateTime dtEndOcc = pException->GetRException_EndTimeOrig();
  798. pExc = FindException(dtStartOcc, dtEndOcc);
  799. }
  801. BOOL bRes = TRUE;
  802. if (pExc)
  803. {
  804. pExc->SetEventID(pException->GetEventID());
  805. bRes = pExc->Update(pException);
  806. ASSERT(bRes);
  807. }
  808. else
  809. {
  810. CXTPCalendarEventPtr ptrExc = pException->CloneEvent();
  811. m_arExceptionEvents.Add(ptrExc);
  812. pExc = ptrExc;
  813. }
  814. pExc->SetRecurrencePatternID(m_dwPatternID);
  816. if (pMasterEventToUpdate)
  817. {
  818. pMasterEventToUpdate->UpdateStartEndDatesFromPatternExceptions();
  819. }
  821. return bRes;
  822. }
  824. BOOL CXTPCalendarRecurrencePattern::RemoveException(CXTPCalendarEvent* pException,
  825. CXTPCalendarEvent* pMasterEventToUpdate)
  826. {
  827. if (!pException)
  828. {
  829. ASSERT(FALSE);
  830. return FALSE;
  831. }
  833. int nRState = pException->GetRecurrenceState();
  834. ASSERT(nRState == xtpCalendarRecurrenceOccurrence || nRState == xtpCalendarRecurrenceException);
  836. COleDateTime dtStartOcc, dtEndOcc;
  838. if (nRState == xtpCalendarRecurrenceOccurrence)
  839. {
  840. dtStartOcc = pException->GetStartTime();
  841. dtEndOcc = pException->GetEndTime();
  842. }
  843. else
  844. {
  845. if (nRState == xtpCalendarRecurrenceException)
  846. {
  847. dtStartOcc = pException->GetRException_StartTimeOrig();
  848. dtEndOcc = pException->GetRException_EndTimeOrig();
  849. }
  850. else
  851. {
  852. return FALSE;
  853. }
  854. }
  856. int nCount = m_arExceptionEvents.GetCount();
  857. int nFExcIdx = FindExceptionIndex(dtStartOcc, dtEndOcc);
  859. if (nFExcIdx >= 0 && nFExcIdx < nCount)
  860. {
  861. m_arExceptionEvents.RemoveAt(nFExcIdx);
  863. if (pMasterEventToUpdate)
  864. {
  865. pMasterEventToUpdate->UpdateStartEndDatesFromPatternExceptions();
  866. }
  868. return TRUE;
  869. }
  871. return FALSE;
  872. }
  875. void CXTPCalendarRecurrencePattern::RemoveAllExceptions()
  876. {
  877. m_arExceptionEvents.RemoveAll();
  879. m_arOccReminders.RemoveAll();
  880. }
  882. CXTPCalendarEvent* CXTPCalendarRecurrencePattern::FindException(COleDateTime dtStartOrig, COleDateTime dtEndOrig) const
  883. {
  884. int nCount = m_arExceptionEvents.GetCount();
  885. int nFExcIdx = FindExceptionIndex(dtStartOrig, dtEndOrig);
  887. if (nFExcIdx >= 0 && nFExcIdx < nCount)
  888. {
  889. CXTPCalendarEvent* pEvent = m_arExceptionEvents.GetAt(nFExcIdx, FALSE);
  890. return pEvent;
  891. }
  892. return NULL;
  893. }
  895. int CXTPCalendarRecurrencePattern::FindExceptionIndex(COleDateTime dtStartOrig, COleDateTime dtEndOrig) const
  896. {
  897. COleDateTime dtTmpS, dtTmpE;
  899. int nCount = m_arExceptionEvents.GetCount();
  900. for (int i = 0; i < nCount; i++)
  901. {
  902. CXTPCalendarEvent* pEvent = m_arExceptionEvents.GetAt(i, FALSE);
  904. ASSERT(pEvent->GetRecurrenceState() == xtpCalendarRecurrenceException);
  906. dtTmpS = pEvent->GetRException_StartTimeOrig();
  907. dtTmpE = pEvent->GetRException_EndTimeOrig();
  909. if (CXTPCalendarUtils::IsEqual(dtTmpS, dtStartOrig) &&
  910. CXTPCalendarUtils::IsEqual(dtTmpE, dtEndOrig))
  911. {
  912. return i;
  913. }
  914. }
  915. return -1;
  916. }
  918. BOOL CXTPCalendarRecurrencePattern::FindExceptions(CXTPCalendarEvents* pEvents,
  919.    COleDateTime dtStart,
  920.    COleDateTime dtEnd) const
  921. {
  922. dtStart = CXTPCalendarUtils::ResetTime(dtStart);
  923. dtEnd = CXTPCalendarUtils::ResetTime(dtEnd);
  925. COleDateTime dtTmpS, dtTmpE;
  927. int nCount = m_arExceptionEvents.GetCount();
  928. for (int i = 0; i < nCount; i++)
  929. {
  930. CXTPCalendarEvent* pEvent = m_arExceptionEvents.GetAt(i, FALSE);
  932. ASSERT(pEvent->GetRecurrenceState() == xtpCalendarRecurrenceException);
  934. dtTmpS = CXTPCalendarUtils::ResetTime(pEvent->GetStartTime());
  935. dtTmpE = CXTPCalendarUtils::ResetTime(pEvent->GetEndTime());
  937. if (dtStart <= dtTmpS && dtTmpS <= dtEnd ||
  938. dtStart <= dtTmpE && dtTmpE <= dtEnd ||
  939. dtTmpS <= dtStart && dtStart <= dtTmpE ||
  940. dtTmpS <= dtEnd && dtEnd <= dtTmpE)
  941. {
  942. if (!pEvent->IsRExceptionDeleted())
  943. {
  944. pEvents->Add(pEvent);
  945. }
  946. }
  947. }
  948. return TRUE;
  949. }
  951. CXTPCalendarEventsPtr CXTPCalendarRecurrencePattern::GetExceptions()
  952. {
  953. CXTPCalendarEventsPtr ptrExceptions = new CXTPCalendarEvents();
  954. if (!ptrExceptions)
  955. {
  956. return NULL;
  957. }
  959. int nCount = m_arExceptionEvents.GetCount();
  960. for (int i = 0; i < nCount; i++)
  961. {
  962. CXTPCalendarEvent* pEvent = m_arExceptionEvents.GetAt(i, FALSE);
  963. ASSERT(pEvent);
  965. CXTPCalendarEventPtr ptrEventCopy = pEvent ? pEvent->CloneEvent() : NULL;
  966. if (ptrEventCopy)
  967. {
  968. ptrExceptions->Add(ptrEventCopy);
  969. }
  970. }
  971. return ptrExceptions;
  972. }
  974. CXTPCalendarEventPtr CXTPCalendarRecurrencePattern::GetMasterEvent() const
  975. {
  976. if (!m_ptrDataProvider)
  977. {
  978. ASSERT(FALSE);
  979. return NULL;
  980. }
  982. CXTPCalendarEventPtr ptrMEvent = m_ptrDataProvider->GetEvent(m_dwMasterEventID);
  983. ASSERT(ptrMEvent);
  984. return ptrMEvent;
  985. }
  987. void CXTPCalendarRecurrencePattern::SetPatternID(DWORD dwID)
  988. {
  989. m_dwPatternID = dwID;
  991. int nCount = m_arExceptionEvents.GetCount();
  992. for (int i = 0; i < nCount; i++)
  993. {
  994. CXTPCalendarEvent* pEvent = m_arExceptionEvents.GetAt(i, FALSE);
  995. ASSERT(pEvent);
  996. if (pEvent)
  997. {
  998. pEvent->SetRecurrencePatternID(m_dwPatternID);
  999. }
  1000. }
  1001. }
  1003. void CXTPCalendarRecurrencePattern::DoPropExchange(CXTPPropExchange* pPX)
  1004. {
  1005. long nVersion = XTP_RECPATT_PROP_SET_DATA_VER;
  1006. PX_Long(pPX, _T("Version"), nVersion, XTP_RECPATT_PROP_SET_DATA_VER);
  1008. PX_DWord(pPX, cszRPatt_PatternID, m_dwPatternID, XTP_CALENDAR_UNKNOWN_RECURRENCE_PATTERN_ID);
  1009. PX_DateTime(pPX, cszRPatt_StartTime, m_dtStartTime);
  1010. PX_Int(pPX, cszRPatt_DurationMinutes, m_nDurationMinutes, 0);
  1012. PX_Enum(pPX, cszRPatt_RecurrenceType, m_Options.m_nRecurrenceType, xtpCalendarRecurrenceUnknown);
  1014. PX_Int(pPX, cszRPatt_RecurrenceOpt_Data1, m_Options.m_YearNth.nWhichDay, 0);
  1015. PX_Int(pPX, cszRPatt_RecurrenceOpt_Data2, m_Options.m_YearNth.nWhichDayMask, 0);
  1016. PX_Int(pPX, cszRPatt_RecurrenceOpt_Data3, m_Options.m_YearNth.nMonthOfYear, 0);
  1018. PX_DateTime(pPX, cszRPatt_PatternStartDate, m_dtPatternStartDate);
  1020. PX_Enum(pPX, cszRPatt_UseEndMethod, m_PatternEnd.m_nUseEnd, xtpCalendarPatternEndNoDate);
  1022. if (m_PatternEnd.m_nUseEnd == xtpCalendarPatternEndDate)
  1023. {
  1024. PX_DateTime(pPX, cszRPatt_PatternEndDate, m_PatternEnd.m_dtPatternEndDate);
  1025. }
  1026. else if (m_PatternEnd.m_nUseEnd == xtpCalendarPatternEndAfterOccurrences)
  1027. {
  1028. PX_Int(pPX, cszRPatt_EndAfterOccurrences, m_PatternEnd.m_nEndAfterOccurrences, 1);
  1029. }
  1031. PX_DWord(pPX, cszRPatt_MasterEventID, m_dwMasterEventID, XTP_CALENDAR_UNKNOWN_EVENT_ID);
  1033. //------------------------------------------------------------------------
  1034. if (pPX->IsStoring())
  1035. {
  1036. VERIFY( m_arOccReminders.Save(m_pCustomProperties, this) );
  1037. }
  1039. //-------------------------------------------
  1040. m_pCustomProperties->DoPropExchange(pPX);
  1042. //-------------------------------------------
  1043. if (pPX->IsLoading())
  1044. {
  1045. VERIFY( m_arOccReminders.Load(m_pCustomProperties) );
  1046. }
  1048. m_arOccReminders.ClearProperties(m_pCustomProperties);
  1049. }
  1051. void CXTPCalendarRecurrencePattern::SetOccReminder(
  1052. CXTPCalendarEvent* pOccEvent,
  1053. int nbIsReminder,
  1054. DATE dtNextReminderTime_Snoozed)
  1055. {
  1056. ASSERT(pOccEvent);
  1057. if (!pOccEvent)
  1058. {
  1059. return;
  1060. }
  1062. int nIndex = m_arOccReminders.Find(pOccEvent);
  1063. if (nIndex < 0)
  1064. {
  1065. CXTPCalendarReminderForOccurrence tmpData;
  1066. tmpData.m_dtOccurrenceStartTime = pOccEvent->GetStartTime();
  1067. tmpData.m_dtOccurrenceEndTime = pOccEvent->GetEndTime();
  1069. nIndex = (int)m_arOccReminders.Add(tmpData);
  1070. }
  1071. CXTPCalendarReminderForOccurrence* pOccRmdData;
  1072. pOccRmdData = &m_arOccReminders[nIndex];
  1074. if (nbIsReminder != xtpCalendarRmdPrm_DontChange)
  1075. {
  1076. pOccRmdData->m_nbIsReminder = nbIsReminder;
  1077. }
  1079. if (dtNextReminderTime_Snoozed != xtpCalendarRmdPrm_DontChange)
  1080. {
  1081. pOccRmdData->m_dtNextReminderTime_Snoozed = dtNextReminderTime_Snoozed;
  1082. }
  1084. m_arOccReminders.UpdateOccIfNeedEx(pOccEvent, pOccRmdData, this);
  1086. if (pOccRmdData->m_nbIsReminder == xtpCalendarRmdPrm_Default &&
  1087. pOccRmdData->m_dtNextReminderTime_Snoozed == xtpCalendarRmdPrm_Default)
  1088. {
  1089. m_arOccReminders.RemoveAt(nIndex);
  1090. }
  1091. }
  1094. ////////////////////////////////////////////////////////////////////////////
  1095. CXTPCalendarReminderForOccurrence::CXTPCalendarReminderForOccurrence()
  1096. {
  1097. m_dtOccurrenceStartTime = 0;
  1098. m_dtOccurrenceEndTime = 0;
  1100. m_nbIsReminder = xtpCalendarRmdPrm_Default;
  1101. m_dtNextReminderTime_Snoozed = (DATE)xtpCalendarRmdPrm_Default;
  1102. }
  1104. CXTPCalendarReminderForOccurrence::~CXTPCalendarReminderForOccurrence()
  1105. {
  1106. }
  1109. const CXTPCalendarReminderForOccurrence& CXTPCalendarReminderForOccurrence::operator=(
  1110. const CXTPCalendarReminderForOccurrence& rSrc)
  1111. {
  1112. m_dtOccurrenceStartTime = rSrc.m_dtOccurrenceStartTime;
  1113. m_dtOccurrenceEndTime = rSrc.m_dtOccurrenceEndTime;
  1115. m_nbIsReminder = rSrc.m_nbIsReminder;
  1116. m_dtNextReminderTime_Snoozed = rSrc.m_dtNextReminderTime_Snoozed;
  1118. return *this;
  1119. }
  1121. //===========================================================================
  1122. CXTPCalendarReminderForOccurrenceArray::CXTPCalendarReminderForOccurrenceArray()
  1123. {
  1124. }
  1126. CXTPCalendarReminderForOccurrenceArray::~CXTPCalendarReminderForOccurrenceArray()
  1127. {
  1128. }
  1130. int CXTPCalendarReminderForOccurrenceArray::Find(CXTPCalendarEvent* pOccEvent)
  1131. {
  1132. ASSERT(pOccEvent);
  1133. if (!pOccEvent)
  1134. {
  1135. return -1;
  1136. }
  1137. ASSERT(pOccEvent->GetRecurrenceState() == xtpCalendarRecurrenceOccurrence);
  1139. DATE dtOcctartTime = pOccEvent->GetStartTime();
  1140. DATE dtOccEndTime = pOccEvent->GetEndTime();
  1142. int nFIndex = Find(dtOcctartTime, dtOccEndTime);
  1143. return nFIndex;
  1144. }
  1146. int CXTPCalendarReminderForOccurrenceArray::Find(DATE dtOccStartTime, DATE dtOccEndTime)
  1147. {
  1148. int nCount = (int)GetSize();
  1149. for (int i = 0; i < nCount; i++)
  1150. {
  1151. const CXTPCalendarReminderForOccurrence& rData = ElementAt(i);
  1153. if (CXTPCalendarUtils::IsEqual(dtOccStartTime, rData.m_dtOccurrenceStartTime) &&
  1154. CXTPCalendarUtils::IsEqual(dtOccEndTime, rData.m_dtOccurrenceEndTime))
  1155. {
  1156. return i;
  1157. }
  1158. }
  1159. return -1;
  1160. }
  1162. int CXTPCalendarReminderForOccurrenceArray::UpdateOccIfNeed(
  1163. CXTPCalendarEvent* pOccEvent,
  1164. CXTPCalendarRecurrencePattern* pPattern)
  1165. {
  1166. if (!pOccEvent || !pPattern)
  1167. {
  1168. ASSERT(FALSE);
  1169. return 0;
  1170. }
  1172. int nFIndex = Find(pOccEvent);
  1173. if (nFIndex < 0)
  1174. {
  1175. return 0;
  1176. }
  1178. CXTPCalendarReminderForOccurrence* pOccRmdData;
  1179. pOccRmdData = &ElementAt(nFIndex);
  1181. int nRes = UpdateOccIfNeedEx(pOccEvent, pOccRmdData, pPattern);
  1182. return nRes;
  1183. }
  1185. int CXTPCalendarReminderForOccurrenceArray::UpdateOccIfNeedEx(
  1186. CXTPCalendarEvent* pOccEvent,
  1187. const CXTPCalendarReminderForOccurrence* pOccRmdData,
  1188. CXTPCalendarRecurrencePattern* pPattern)
  1189. {
  1190. if (!pOccEvent || !pOccRmdData || !pPattern)
  1191. {
  1192. ASSERT(FALSE);
  1193. return 0;
  1194. }
  1196. // IsReminder
  1197. if (pOccRmdData->m_nbIsReminder == xtpCalendarRmdPrm_Default)
  1198. {
  1199. CXTPCalendarEventPtr ptrMasterEvent = pPattern->GetMasterEvent();
  1200. if (!ptrMasterEvent)
  1201. {
  1202. ASSERT(FALSE);
  1203. return 0;
  1204. }
  1205. pOccEvent->SetReminder(ptrMasterEvent->IsReminder());
  1206. }
  1207. else if (pOccRmdData->m_nbIsReminder != xtpCalendarRmdPrm_DontChange)
  1208. {
  1209. pOccEvent->SetReminder(pOccRmdData->m_nbIsReminder != 0);
  1210. }
  1212. // MinutesBeforeStart_Snoozed
  1213. if (pOccRmdData->m_dtNextReminderTime_Snoozed == xtpCalendarRmdPrm_Default)
  1214. {
  1215. pOccEvent->GetCustomProperties()->RemoveProperty(cszEventCustProp_NextReminderTime_Snoozed);
  1216. }
  1217. else if (pOccRmdData->m_dtNextReminderTime_Snoozed != xtpCalendarRmdPrm_DontChange)
  1218. {
  1219. VERIFY( pOccEvent->GetCustomProperties()->SetProperty(
  1220. cszEventCustProp_NextReminderTime_Snoozed,
  1221. pOccRmdData->m_dtNextReminderTime_Snoozed) );
  1223. }
  1224. return 1;
  1225. }
  1227. BOOL CXTPCalendarReminderForOccurrenceArray::Load(CXTPCalendarCustomProperties* pProps)
  1228. {
  1229. ASSERT(pProps);
  1230. if (!pProps)
  1231. {
  1232. return FALSE;
  1233. }
  1234. RemoveAll();
  1236. COleVariant varCount;
  1237. BOOL bExists = pProps->GetProperty(cszOccRMD_Count, varCount);
  1238. if (!bExists)
  1239. {
  1240. return TRUE;
  1241. }
  1242. COleVariant varValue;
  1243. CString strPropNameI;
  1245. int nCount = (int)(long)_variant_t(varCount);
  1246. for (int i = 0; i < nCount; i++)
  1247. {
  1248. CXTPCalendarReminderForOccurrence rmdData;
  1250. _PropName(cszOccRMD_StartTime, i, strPropNameI);
  1251. if (pProps->GetProperty(strPropNameI, varValue))
  1252. {
  1253. rmdData.m_dtOccurrenceStartTime = (DATE)_variant_t(varValue);
  1254. }
  1256. _PropName(cszOccRMD_EndTime, i, strPropNameI);
  1257. if (pProps->GetProperty(strPropNameI, varValue))
  1258. {
  1259. rmdData.m_dtOccurrenceEndTime = (DATE)_variant_t(varValue);
  1260. }
  1262. _PropName(cszOccRMD_IsReminder, i, strPropNameI);
  1263. if (pProps->GetProperty(strPropNameI, varValue))
  1264. {
  1265. rmdData.m_nbIsReminder = (long)_variant_t(varValue);
  1266. }
  1268. _PropName(cszOccRMD_NextReminderTime_Snoozed, i, strPropNameI);
  1269. if (pProps->GetProperty(strPropNameI, varValue))
  1270. {
  1271. rmdData.m_dtNextReminderTime_Snoozed = (DATE)_variant_t(varValue);
  1272. }
  1274. Add(rmdData);
  1275. }
  1276. return TRUE;
  1277. }
  1279. BOOL CXTPCalendarReminderForOccurrenceArray::Save(CXTPCalendarCustomProperties* pProps,
  1280.  CXTPCalendarRecurrencePattern* pPattern)
  1281. {
  1282. ASSERT(pProps);
  1283. if (!pProps)
  1284. {
  1285. return FALSE;
  1286. }
  1287. ClearProperties(pProps);
  1289. CString strPropNameI;
  1290. int nCount = (int)GetSize();
  1291. int i;
  1293. //===========================================================================
  1294. if (pPattern)
  1295. {
  1296. for (i = nCount-1; i >= 0; i--)
  1297. {
  1298. const CXTPCalendarReminderForOccurrence& rData = ElementAt(i);
  1300. int nFExcIdx = pPattern->FindExceptionIndex(rData.m_dtOccurrenceStartTime,
  1301. rData.m_dtOccurrenceEndTime);
  1302. if (nFExcIdx >= 0)
  1303. {
  1304. RemoveAt(i);
  1305. }
  1306. }
  1307. }
  1309. //===========================================================================
  1310. nCount = (int)GetSize();
  1311. for (i = 0; i < nCount; i++)
  1312. {
  1313. const CXTPCalendarReminderForOccurrence& rData = ElementAt(i);
  1315. _PropName(cszOccRMD_StartTime, i, strPropNameI);
  1316. VERIFY( pProps->SetProperty(strPropNameI, COleDateTime(rData.m_dtOccurrenceStartTime)) );
  1318. _PropName(cszOccRMD_EndTime, i, strPropNameI);
  1319. VERIFY( pProps->SetProperty(strPropNameI, COleDateTime(rData.m_dtOccurrenceEndTime)) );
  1321. _PropName(cszOccRMD_IsReminder, i, strPropNameI);
  1322. VERIFY( pProps->SetProperty(strPropNameI, (long)rData.m_nbIsReminder) );
  1324. if (rData.m_dtNextReminderTime_Snoozed != xtpCalendarRmdPrm_Default)
  1325. {
  1326. ASSERT(rData.m_dtNextReminderTime_Snoozed >= xtpCalendarDateTime_min && rData.m_dtNextReminderTime_Snoozed <= xtpCalendarDateTime_max);
  1327. _PropName(cszOccRMD_NextReminderTime_Snoozed, i, strPropNameI);
  1328. VERIFY( pProps->SetProperty(strPropNameI, COleDateTime(rData.m_dtNextReminderTime_Snoozed)) );
  1329. }
  1330. }
  1332. BOOL bRes = pProps->SetProperty(cszOccRMD_Count, (long)nCount);
  1333. ASSERT(bRes);
  1335. return bRes;
  1336. }
  1338. void CXTPCalendarReminderForOccurrenceArray::ClearProperties(CXTPCalendarCustomProperties* pProps)
  1339. {
  1340. ASSERT(pProps);
  1341. if (!pProps)
  1342. {
  1343. return;
  1344. }
  1345. COleVariant varCount;
  1346. BOOL bExists = pProps->GetProperty(cszOccRMD_Count, varCount);
  1347. if (!bExists)
  1348. {
  1349. return;
  1350. }
  1351. CString strPropNameI;
  1353. int nCount = (int)(long)_variant_t(varCount);
  1354. for (int i = 0; i < nCount; i++)
  1355. {
  1356. _PropName(cszOccRMD_StartTime, i, strPropNameI);
  1357. pProps->RemoveProperty(strPropNameI);
  1359. _PropName(cszOccRMD_EndTime, i, strPropNameI);
  1360. pProps->RemoveProperty(strPropNameI);
  1362. _PropName(cszOccRMD_IsReminder, i, strPropNameI);
  1363. pProps->RemoveProperty(strPropNameI);
  1365. _PropName(cszOccRMD_NextReminderTime_Snoozed, i, strPropNameI);
  1366. pProps->RemoveProperty(strPropNameI);
  1367. }
  1369. pProps->RemoveProperty(cszOccRMD_Count);
  1370. }
  1371. void CXTPCalendarReminderForOccurrenceArray::_PropName(LPCTSTR pcszProp, int nIndex, CString& rstrPropNameI)
  1372. {
  1373. TCHAR szIndex[64];
  1374. ITOT_S(nIndex, szIndex, 64, 10);
  1376. rstrPropNameI = pcszProp;
  1377. rstrPropNameI += _T("[");
  1378. rstrPropNameI += szIndex;
  1379. rstrPropNameI += _T("]");
  1380. }