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

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

对话框与窗口

开发平台：

Visual C++

XTPCalendarEvent.cpp：源码内容
  1. // XTPCalendarEvent.cpp: implementation of the CXTPCalendarEvent 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"
  25. #include "XTPCalendarEvent.h"
  26. #include "XTPCalendarRecurrencePattern.h"
  27. #include "XTPCalendarUtils.h"
  28. #include "XTPCalendarData.h"
  29. #include "XTPCalendarEventLabel.h"
  30. #include "XTPCalendarCustomProperties.h"
  32. #ifdef _DEBUG
  33. #define new DEBUG_NEW
  34. #undef THIS_FILE
  35. static char THIS_FILE[] = __FILE__;
  36. #endif
  38. static LPCTSTR cszEventProp_EventID = _T("EventID");
  39. static LPCTSTR cszEventProp_ScheduleID= _T("ScheduleID");
  40. static LPCTSTR cszEventProp_StartTime = _T("StartTime");
  41. static LPCTSTR cszEventProp_EndTime = _T("EndTime");
  43. static LPCTSTR cszEventProp_Subject = _T("Subject");
  44. static LPCTSTR cszEventProp_Location = _T("Location");
  45. static LPCTSTR cszEventProp_Body                    = _T("Body");
  47. // OLD. used to read old data files
  48. static LPCTSTR cszEventPropOld_Description          = _T("Description");
  50. static LPCTSTR cszEventProp_AllDayEvent = _T("AllDayEvent");
  51. static LPCTSTR cszEventProp_LabelID = _T("LabelID");
  52. static LPCTSTR cszEventProp_BusyStatus = _T("BusyStatus");
  53. static LPCTSTR cszEventProp_Importance = _T("Importance");
  55. static LPCTSTR cszEventProp_ReminderMinutesBeforeStart = _T("ReminderMinutesBeforeStart");
  56. static LPCTSTR cszEventProp_ReminderSoundFile = _T("ReminderSoundFile");
  58. static LPCTSTR cszEventProp_CreationTime = _T("CreationTime");
  59. static LPCTSTR cszEventProp_LastModificationTime = _T("LastModificationTime");
  61. static LPCTSTR cszEventProp_RecurrenceState = _T("RecurrenceState");
  63. static LPCTSTR cszEventProp_IsMeeting = _T("IsMeeting");
  64. static LPCTSTR cszEventProp_IsPrivate = _T("IsPrivate");
  65. static LPCTSTR cszEventProp_IsReminder              = _T("IsReminder");
  67. //## Recurrence Event properties
  68. static LPCTSTR cszEventProp_RecurrencePatternID = _T("RecurrencePatternID");
  70. //## Recurrence Event Exception properties
  71. static LPCTSTR cszEventProp_RExceptionDeleted = _T("RExceptionDeleted");
  72. static LPCTSTR cszEventProp_RException_StartTimeOrig= _T("RException_StartTimeOrig");
  73. static LPCTSTR cszEventProp_RException_EndTimeOrig = _T("RException_EndTimeOrig");
  75. /////////////////////////////////////////////////////////////////////////////
  76. #define XTP_EVENT_PROP_SET_DATA_VER_1 1
  77. #define XTP_EVENT_PROP_SET_DATA_VER_2 2
  78. #define XTP_EVENT_PROP_SET_DATA_VER 3
  80. IMPLEMENT_DYNAMIC(CXTPCalendarEvent, CCmdTarget)
  82. /////////////////////////////////////////////////////////////////////////////
  85. /////////////////////////////////////////////////////////////////////////////
  86. CXTPCalendarEvent::CXTPCalendarEvent(CXTPCalendarData* pDataProvider)
  87. {
  88. ASSERT(pDataProvider);
  89. m_pDataProvider = pDataProvider;
  91. if (m_pDataProvider)
  92. {
  93. m_pDataProvider->InternalAddRef();
  94. }
  96. m_dwEventID = XTP_CALENDAR_UNKNOWN_EVENT_ID;
  97. m_nLabelID = XTP_CALENDAR_DEFAULT_LABEL_ID;
  98. m_uScheduleID = XTP_CALENDAR_UNKNOWN_SCHEDULE_ID;
  100. m_nBusyStatus = xtpCalendarBusyStatusFree;
  101. m_nImportance = xtpCalendarImportanceNormal;
  103. m_dwRecurrencePatternID = XTP_CALENDAR_UNKNOWN_RECURRENCE_PATTERN_ID;
  104. m_nRecurrenceState = xtpCalendarRecurrenceNotRecurring;
  105. m_bRExceptionDeleted = FALSE;
  108. m_bAllDayEvent = FALSE;
  109. m_dtStartTime = (DATE)0; //.SetStatus(COleDateTime::null);
  110. m_dtEndTime = (DATE)0; //.SetStatus(COleDateTime::null);
  112. m_dtCreationTime = m_dtLastModificationTime = CXTPCalendarUtils::GetCurrentTime();
  114. m_bReminder = FALSE;
  115. m_nReminderMinutesBeforeStart = XTP_CALENDAR_DEFAULT_REMINDER_MINUTES;
  117. m_dtRException_StartTimeOrig = (DATE)0; // .SetStatus(COleDateTime::null);
  118. m_dtRException_EndTimeOrig = (DATE)0; // .SetStatus(COleDateTime::null);
  120. m_bMeeting = FALSE;
  121. m_bPrivate = FALSE;
  123. m_dwRecurrencePatternID_ToUse = XTP_CALENDAR_UNKNOWN_RECURRENCE_PATTERN_ID;
  125. m_pCustomProperties = new CXTPCalendarCustomProperties;
  126. m_pCustomIconsIDs = new CXTPCalendarCustomIconIDs;
  127. m_pEventCategoryIDs = new CXTPCalendarEventCategoryIDs;
  130. }
  132. CXTPCalendarEvent::~CXTPCalendarEvent()
  133. {
  134. CMDTARGET_RELEASE(m_pDataProvider);
  135. CMDTARGET_RELEASE(m_pCustomProperties);
  136. CMDTARGET_RELEASE(m_pCustomIconsIDs);
  137. CMDTARGET_RELEASE(m_pEventCategoryIDs);
  138. }
  140. CXTPCalendarEventLabel* CXTPCalendarEvent::GetLabel() const
  141. {
  142. CXTPCalendarEventLabel* pResultLab = NULL;
  144. if (m_pDataProvider && m_pDataProvider->GetLabelList())
  145. {
  146. pResultLab = m_pDataProvider->GetLabelList()->Find(m_nLabelID);
  147. }
  149. return pResultLab;
  150. }
  152. void CXTPCalendarEvent::SetStartTime(COleDateTime dtStart)
  153. {
  154. if (m_nRecurrenceState == xtpCalendarRecurrenceOccurrence ||
  155. m_nRecurrenceState == xtpCalendarRecurrenceMaster)
  156. {
  157. ASSERT(FALSE);
  158. return;
  159. }
  161. m_dtStartTime = dtStart;
  163. if (m_dtStartTime.GetStatus() == COleDateTime::valid &&
  164. m_dtEndTime.GetStatus() == COleDateTime::valid &&
  165. (m_dtStartTime > m_dtEndTime ||
  166.  CXTPCalendarUtils::IsEqual(m_dtEndTime, m_dtStartTime)))
  167. {
  168. m_dtEndTime = m_dtStartTime;
  169. }
  170. }
  172. void CXTPCalendarEvent::SetEndTime(COleDateTime dtEnd)
  173. {
  174. if (m_nRecurrenceState == xtpCalendarRecurrenceOccurrence ||
  175. m_nRecurrenceState == xtpCalendarRecurrenceMaster)
  176. {
  177. ASSERT(FALSE);
  178. return;
  179. }
  181. m_dtEndTime = dtEnd;
  183. if (m_dtStartTime.GetStatus() == COleDateTime::valid &&
  184. m_dtEndTime.GetStatus() == COleDateTime::valid &&
  185. (m_dtEndTime < m_dtStartTime ||
  186.  CXTPCalendarUtils::IsEqual(m_dtEndTime, m_dtStartTime)))
  187. {
  188. m_dtStartTime = m_dtEndTime;
  189. }
  190. }
  192. void CXTPCalendarEvent::SetDuration(COleDateTimeSpan spDuration, BOOL bKeepStart)
  193. {
  194. if (bKeepStart)
  195. {
  196. SetEndTime(m_dtStartTime + spDuration);
  197. }
  198. else
  199. {
  200. SetStartTime(m_dtEndTime - spDuration);
  201. }
  202. }
  204. void CXTPCalendarEvent::MoveEvent(COleDateTime dtNewStartTime)
  205. {
  206. COleDateTimeSpan spDuration = m_dtEndTime - m_dtStartTime;
  207. SetStartTime(dtNewStartTime);
  208. SetEndTime(dtNewStartTime + spDuration);
  209. }
  211. int CXTPCalendarEvent::GetDurationMinutes() const
  212. {
  213. return CXTPCalendarUtils::GetDurationMinutes(m_dtStartTime, m_dtEndTime, m_bAllDayEvent);
  214. }
  216. COleDateTimeSpan CXTPCalendarEvent::GetDuration() const
  217. {
  218. COleDateTimeSpan spDuration;
  220. if (m_bAllDayEvent)
  221. {
  222. spDuration = CXTPCalendarUtils::ResetTime(m_dtEndTime) -
  223.  CXTPCalendarUtils::ResetTime(m_dtStartTime);
  224. }
  225. else
  226. {
  227. spDuration = m_dtEndTime - m_dtStartTime;
  228. }
  229. return spDuration;
  230. }
  233. CXTPCalendarRecurrencePatternPtr CXTPCalendarEvent::GetRecurrencePattern() const
  234. {
  235. if (m_ptrRPattern)
  236. {
  237. ASSERT(m_nRecurrenceState == xtpCalendarRecurrenceMaster);
  239. CXTPCalendarRecurrencePatternPtr ptrPattern = m_ptrRPattern->ClonePattern();
  240. return ptrPattern;
  241. }
  243. if (!m_pDataProvider)
  244. {
  245. ASSERT(FALSE);
  246. return NULL;
  247. }
  248. CXTPCalendarRecurrencePatternPtr ptrPattern = m_pDataProvider->GetRecurrencePattern(m_dwRecurrencePatternID);
  249. return ptrPattern;
  250. }
  252. BOOL CXTPCalendarEvent::SetRecurrenceState_Master(CXTPCalendarRecurrencePattern* pPattern)
  253. {
  254. if (!pPattern || m_nRecurrenceState != xtpCalendarRecurrenceNotRecurring)
  255. {
  256. ASSERT(FALSE);
  257. return FALSE;
  258. }
  259. ASSERT(!m_ptrRPattern);
  261. m_nRecurrenceState = xtpCalendarRecurrenceMaster;
  263. m_ptrRPattern = pPattern;
  264. m_ptrRPattern->InternalAddRef();
  265. m_dwRecurrencePatternID = m_ptrRPattern->GetPatternID();
  267. m_ptrRPattern->SetMasterEventID(m_dwEventID);
  269. BOOL bRes = CalcStartEndDatesFromPattern();
  270. ASSERT(bRes);
  272. return bRes;
  273. }
  275. BOOL CXTPCalendarEvent::SetRecurrenceState_ExceptionOccurrence(XTPCalendarEventRecurrenceState nState, DWORD dwNewPatternID)
  276. {
  277. ASSERT(nState == xtpCalendarRecurrenceOccurrence || nState == xtpCalendarRecurrenceException);
  279. if (m_ptrRPattern || m_nRecurrenceState == xtpCalendarRecurrenceMaster)
  280. {
  281. ASSERT(FALSE); //set new recur. state to master event. strange! why ???
  282. return FALSE;
  283. }
  285. // update original Start/End times for exception event
  286. if (nState == xtpCalendarRecurrenceException)
  287. {
  288. // You should change state to exception only for occurrence or new event (event copy).
  289. // !!! Otherwise this may not work correctly !!!
  290. //ASSERT(m_nRecurrenceState == xtpCalendarRecurrenceOccurrence);
  291. ASSERT(m_nRecurrenceState == xtpCalendarRecurrenceNotRecurring ||
  292.    m_nRecurrenceState == xtpCalendarRecurrenceOccurrence ||
  293.    m_nRecurrenceState == xtpCalendarRecurrenceException);
  295. COleDateTime dtTmpOrig = GetStartTime();
  296. SetRException_StartTimeOrig(dtTmpOrig);
  298. dtTmpOrig = GetEndTime();
  299. SetRException_EndTimeOrig(dtTmpOrig);
  300. }
  302. m_nRecurrenceState = nState;
  304. if (dwNewPatternID != XTP_CALENDAR_UNKNOWN_RECURRENCE_PATTERN_ID)
  305. {
  306. m_dwRecurrencePatternID = dwNewPatternID;
  307. }
  308. //ASSERT(m_dwRecurrencePatternID != XTP_CALENDAR_UNKNOWN_RECURRENCE_PATTERN_ID);
  310. return TRUE;
  311. }
  313. BOOL CXTPCalendarEvent::SetRecurrenceState_NotRecurring()
  314. {
  315. if (m_ptrRPattern)
  316. {
  317. m_ptrRPattern->SetMasterEventID(XTP_CALENDAR_UNKNOWN_EVENT_ID);
  318. }
  319. m_dwRecurrencePatternID_ToUse = m_dwRecurrencePatternID;
  321. m_nRecurrenceState = xtpCalendarRecurrenceNotRecurring;
  322. m_ptrRPattern = NULL;
  323. m_dwRecurrencePatternID = XTP_CALENDAR_UNKNOWN_RECURRENCE_PATTERN_ID;
  325. return TRUE;
  326. }
  328. BOOL CXTPCalendarEvent::CalcStartEndDatesFromPattern()
  329. {
  330. if (m_nRecurrenceState != xtpCalendarRecurrenceMaster || !m_ptrRPattern)
  331. {
  332. ASSERT(FALSE);
  333. return FALSE;
  334. }
  336. COleDateTime dtS = m_ptrRPattern->GetPatternStartDate();
  337. COleDateTime dtE(9999, 1, 1, 0, 0, 0);
  339. if (m_ptrRPattern->GetUseEndMethod() == xtpCalendarPatternEndDate ||
  340. m_ptrRPattern->GetUseEndMethod() == xtpCalendarPatternEndAfterOccurrences &&
  341. m_ptrRPattern->GetEndAfterOccurrences() < 4000)
  342. {
  343. CXTPCalendarDatesArray arDates;
  344. m_ptrRPattern->GetOccurrencesDates(arDates, dtS, dtE);
  345. int nCount = (int)arDates.GetSize();
  346. if (nCount)
  347. {
  348. dtS = arDates[0];
  349. dtE = arDates[nCount-1];
  351. //SetStartTime(m_ptrRPattern->GetStartOccurrenceTime(dtS));
  352. //SetEndTime(m_ptrRPattern->GetEndOccurrenceTime(dtS));
  353. m_dtStartTime = m_ptrRPattern->GetStartOccurrenceTime(dtS);
  354. m_dtEndTime = m_ptrRPattern->GetEndOccurrenceTime(dtS);
  356. ASSERT(GetEventPeriodDays() > 0);
  357. int nDays = max(1, GetEventPeriodDays());
  359. dtE += COleDateTimeSpan(nDays-1, 0, 0, 0);
  360. }
  361. else
  362. {
  363. dtE = dtS;
  364. }
  365. }
  367. //SetStartTime(dtS);
  368. //SetEndTime(dtE);
  370. m_dtStartTime = dtS;
  371. m_dtEndTime = dtE;
  373. UpdateStartEndDatesFromPatternExceptions();
  375. return TRUE;
  376. }
  378. BOOL CXTPCalendarEvent::UpdateStartEndDatesFromPatternExceptions()
  379. {
  380. COleDateTime dtS = GetStartTime();
  381. COleDateTime dtE = GetEndTime();
  383. BOOL bRes = FALSE;
  384. //---------------------------------------------------------------------------
  385. CXTPCalendarEventsPtr ptrExceptions = m_ptrRPattern->GetExceptions();
  386. int nCount = ptrExceptions ? ptrExceptions->GetCount() : 0;
  387. for (int i = 0; i < nCount; i++)
  388. {
  389. CXTPCalendarEvent* pExcept = ptrExceptions->GetAt(i);
  390. if (pExcept->GetStartTime() < dtS)
  391. {
  392. dtS = pExcept->GetStartTime();
  393. bRes = TRUE;
  394. }
  395. if (pExcept->GetEndTime() > dtE)
  396. {
  397. dtE = pExcept->GetEndTime();
  398. bRes = TRUE;
  399. }
  400. }
  401. //---------------------------------------------------------------------------
  403. if (bRes)
  404. {
  405. //SetStartTime(dtS);
  406. //SetEndTime(dtE);
  408. m_dtStartTime = dtS;
  409. m_dtEndTime = dtE;
  410. }
  412. return bRes;
  413. }
  415. CXTPCalendarEventPtr CXTPCalendarEvent::CloneEvent()
  416. {
  417. if (!m_pDataProvider)
  418. {
  419. ASSERT(FALSE);
  420. return NULL;
  421. }
  423. CXTPCalendarEventPtr ptrNewEvent = m_pDataProvider->CreateNewEvent(GetEventID());
  425. if (!ptrNewEvent)
  426. {
  427. ASSERT(FALSE);
  428. return NULL;
  429. }
  431. if (CloneEventTo(ptrNewEvent))
  432. {
  433. return ptrNewEvent;
  434. }
  435. ASSERT(FALSE);
  436. return NULL;
  437. }
  439. BOOL CXTPCalendarEvent::CloneEventTo(CXTPCalendarEvent* pEventDest)
  440. {
  441. if (!m_pDataProvider || !pEventDest)
  442. {
  443. ASSERT(FALSE);
  444. return FALSE;
  445. }
  447. pEventDest->Clear();
  449. BOOL bRes = pEventDest->Update(this);
  450. if (!bRes)
  451. {
  452. ASSERT(FALSE);
  453. return FALSE;
  454. }
  456. XTPCalendarEventRecurrenceState nRState = GetRecurrenceState();
  458. if (nRState == xtpCalendarRecurrenceMaster)
  459. {
  460. CXTPCalendarRecurrencePatternPtr ptrRPattern = GetRecurrencePattern();
  461. bRes = pEventDest->SetRecurrenceState_Master(ptrRPattern);
  462. }
  463. else
  464. if (nRState != xtpCalendarRecurrenceNotRecurring)
  465. {
  466. ASSERT(nRState == xtpCalendarRecurrenceException || nRState == xtpCalendarRecurrenceOccurrence);
  467. DWORD dwPatternID = GetRecurrencePatternID();
  468. bRes = pEventDest->SetRecurrenceState_ExceptionOccurrence(nRState, dwPatternID);
  469. }
  471. if (nRState == xtpCalendarRecurrenceException)
  472. {
  473. COleDateTime dtTmpOrig = GetRException_StartTimeOrig();
  474. pEventDest->SetRException_StartTimeOrig(dtTmpOrig);
  476. dtTmpOrig = GetRException_EndTimeOrig();
  477. pEventDest->SetRException_EndTimeOrig(dtTmpOrig);
  478. }
  479. pEventDest->m_dwRecurrencePatternID_ToUse = m_dwRecurrencePatternID_ToUse;
  481. ASSERT(bRes);
  482. return bRes;
  483. }
  485. BOOL CXTPCalendarEvent::Update(CXTPCalendarEvent* pNewData)
  486. {
  487. if (pNewData == this)
  488. {
  489. return TRUE;
  490. }
  492. UINT uScheduleID = pNewData->GetScheduleID();
  493. SetScheduleID(uScheduleID);
  495. CString strTmp = pNewData->GetSubject();
  496. SetSubject(strTmp);
  498. strTmp = pNewData->GetLocation();
  499. SetLocation(strTmp);
  501. int nTmp = pNewData->GetLabelID();
  502. SetLabelID(nTmp);
  504. BOOL bTmp = pNewData->IsAllDayEvent();
  505. SetAllDayEvent(bTmp);
  507. COleDateTime dtTmp = pNewData->GetStartTime();
  508. m_dtStartTime = dtTmp;
  510. dtTmp = pNewData->GetEndTime();
  511. m_dtEndTime = dtTmp;
  513. bTmp = pNewData->IsReminder();
  514. SetReminder(bTmp);
  516. nTmp = pNewData->GetReminderMinutesBeforeStart();
  517. SetReminderMinutesBeforeStart(nTmp);
  519. strTmp = pNewData->GetReminderSoundFile();
  520. SetReminderSoundFile(strTmp);
  522. strTmp = pNewData->GetBody();
  523. SetBody(strTmp);
  525. nTmp = pNewData->GetBusyStatus();
  526. SetBusyStatus(nTmp);
  528. nTmp = pNewData->GetImportance();
  529. SetImportance(nTmp);
  531. dtTmp = pNewData->GetCreationTime();
  532. SetCreationTime(dtTmp);
  534. dtTmp = pNewData->GetLastModificationTime();
  535. SetLastModificationTime(dtTmp);
  537. nTmp = pNewData->IsMeeting();
  538. SetMeeting(nTmp);
  540. nTmp = pNewData->IsPrivate();
  541. SetPrivate(nTmp);
  543. bTmp = pNewData->IsRExceptionDeleted();
  544. SetRExceptionDeleted(bTmp);
  546. dtTmp = pNewData->GetRException_StartTimeOrig();
  547. SetRException_StartTimeOrig(dtTmp);
  549. dtTmp = pNewData->GetRException_EndTimeOrig();
  550. SetRException_EndTimeOrig(dtTmp);
  552. // Custom properties
  553. ASSERT(pNewData->GetCustomProperties());
  554. if (pNewData->GetCustomProperties())
  555. {
  556. pNewData->GetCustomProperties()->CopyTo(m_pCustomProperties);
  557. }
  559. // Custom Icons
  560. if (GetCustomIcons() && pNewData->GetCustomIcons())
  561. {
  562. GetCustomIcons()->Copy(*pNewData->GetCustomIcons());
  563. }
  564. else
  565. {
  566. XTP_SAFE_CALL1(GetCustomIcons(), RemoveAll());
  567. }
  569. // Event categories
  570. if (GetCategories() && pNewData->GetCategories())
  571. {
  572. GetCategories()->Copy(*pNewData->GetCategories());
  573. }
  574. else
  575. {
  576. XTP_SAFE_CALL1(GetCategories(), RemoveAll());
  577. }
  579. return TRUE;
  580. }
  582. CXTPCalendarEventPtr CXTPCalendarEvent::CloneForOccurrence(COleDateTime dtStart,
  583. COleDateTime dtEnd, DWORD dwNewEventID)
  584. {
  585. int eRecurrenceState = GetRecurrenceState();
  586. if (eRecurrenceState != xtpCalendarRecurrenceMaster || !m_pDataProvider)
  587. {
  588. ASSERT(FALSE);
  589. return NULL;
  590. }
  592. CXTPCalendarEventPtr ptrNewEvent = m_pDataProvider->CreateNewEvent(dwNewEventID);
  593. if (!ptrNewEvent)
  594. {
  595. ASSERT(FALSE);
  596. return FALSE;
  597. }
  599. BOOL bRes = ptrNewEvent->Update(this);
  600. if (!bRes)
  601. {
  602. ASSERT(FALSE);
  603. return NULL;
  604. }
  606. ptrNewEvent->SetStartTime(dtStart);
  607. ptrNewEvent->SetEndTime(dtEnd);
  609. ptrNewEvent->SetRecurrenceState_ExceptionOccurrence(xtpCalendarRecurrenceOccurrence, m_dwRecurrencePatternID);
  611. ptrNewEvent->SetRExceptionDeleted(FALSE);
  613. return ptrNewEvent;
  614. }
  616. BOOL CXTPCalendarEvent::MakeEventAsRecurrence()
  617. {
  618. if (m_nRecurrenceState != xtpCalendarRecurrenceNotRecurring || !m_pDataProvider)
  619. {
  620. ASSERT(FALSE);
  621. return FALSE;
  622. }
  623. ASSERT(m_ptrRPattern == NULL);
  625. CXTPCalendarRecurrencePatternPtr ptrPattern;
  626. ptrPattern = m_pDataProvider->CreateNewRecurrencePattern(m_dwRecurrencePatternID_ToUse);
  628. if (!SetRecurrenceState_Master(ptrPattern))
  629. {
  630. ASSERT(FALSE);
  631. return FALSE;
  632. }
  633. return TRUE;
  634. }
  636. BOOL CXTPCalendarEvent::UpdateRecurrence(CXTPCalendarRecurrencePattern* pRPattern)
  637. {
  638. if (m_nRecurrenceState != xtpCalendarRecurrenceMaster ||
  639. !m_pDataProvider || !m_ptrRPattern || !pRPattern)
  640. {
  641. ASSERT(FALSE);
  642. return FALSE;
  643. }
  645. //ASSERT(m_dwRecurrencePatternID == m_ptrRPattern->GetPatternID());
  646. //ASSERT(m_dwEventID == m_ptrRPattern->GetMasterEventID());
  648. //DWORD dwPatternID2 = pRPattern->GetPatternID();
  649. //DWORD dwMasterID2 = pRPattern->GetMasterEventID();
  651. //if (m_dwRecurrencePatternID != dwPatternID2 || m_dwEventID != dwMasterID2)
  652. //{
  653. //  ASSERT(FALSE);
  654. //  return FALSE;
  655. //}
  656. //------------------------------------------------
  657. BOOL bRes = m_ptrRPattern->Update(pRPattern);
  658. if (!bRes)
  659. {
  660. ASSERT(FALSE);
  661. return FALSE;
  662. }
  664. m_dwRecurrencePatternID = m_ptrRPattern->GetPatternID();
  665. m_ptrRPattern->SetMasterEventID(m_dwEventID);
  667. bRes = CalcStartEndDatesFromPattern();
  668. ASSERT(bRes);
  670. return bRes;
  671. }
  673. BOOL CXTPCalendarEvent::RemoveRecurrence()
  674. {
  675. COleDateTime dtStart, dtEnd;
  676. BOOL bIsMaster = GetRecurrenceState() == xtpCalendarRecurrenceMaster;
  678. if (bIsMaster && m_ptrRPattern)
  679. {
  680. dtStart = CXTPCalendarUtils::UpdateTime(m_ptrRPattern->GetPatternStartDate(),
  681. m_ptrRPattern->GetStartTime());
  683. dtEnd = dtStart + m_ptrRPattern->GetDuration();
  684. }
  685. else
  686. {
  687. bIsMaster = FALSE;
  688. }
  690. if (!SetRecurrenceState_NotRecurring())
  691. {
  692. ASSERT(FALSE);
  693. return FALSE;
  694. }
  696. if (bIsMaster)
  697. {
  698. SetStartTime(dtStart);
  699. SetEndTime(dtEnd);
  700. }
  702. return TRUE;
  703. }
  705. CXTPCalendarRecurrencePattern* CXTPCalendarEvent::GetRPatternRef()
  706. {
  707. ASSERT(GetRecurrenceState() == xtpCalendarRecurrenceMaster);
  709. return m_ptrRPattern;
  710. }
  712. int CXTPCalendarEvent::GetEventPeriodDays() const
  713. {
  714. return CXTPCalendarUtils::GetEventPeriodDays(GetStartTime(), GetEndTime());
  715. }
  717. BOOL CXTPCalendarEvent::IsEqualStartEnd(CXTPCalendarEvent* pEvent) const
  718. {
  719. COleDateTime dtStart2 = pEvent->GetStartTime();
  720. COleDateTime dtEnd2 = pEvent->GetEndTime();
  722. BOOL bRes = CXTPCalendarUtils::IsEqual(m_dtStartTime, dtStart2, TRUE) &&
  723. CXTPCalendarUtils::IsEqual(m_dtEndTime, dtEnd2, TRUE);
  724. return bRes;
  725. }
  727. BOOL CXTPCalendarEvent::IsEqualIDs(CXTPCalendarEvent* pEvent) const
  728. {
  729. if (!pEvent)
  730. {
  731. ASSERT(FALSE);
  732. return FALSE;
  733. }
  735. int nRState2 = pEvent->GetRecurrenceState();
  737. BOOL bRes = FALSE;
  738. if (m_nRecurrenceState == xtpCalendarRecurrenceNotRecurring &&
  739. nRState2 == xtpCalendarRecurrenceNotRecurring)
  740. {
  741. DWORD dwEventID2 = pEvent->GetEventID();
  742. bRes = (m_dwEventID == dwEventID2);
  743. }
  744. else
  745. {
  746. DWORD dwPatternID2 = pEvent->GetRecurrencePatternID();
  748. // for xtpCalendarRecurrenceMaster & xtpCalendarRecurrenceOccurrence
  749. COleDateTime dtStart = m_dtStartTime;
  750. COleDateTime dtEnd = m_dtEndTime;
  752. COleDateTime dtStart2 = pEvent->GetStartTime();
  753. COleDateTime dtEnd2 = pEvent->GetEndTime();
  755. if (m_nRecurrenceState == xtpCalendarRecurrenceException)
  756. {
  757. dtStart = GetRException_StartTimeOrig();
  758. dtEnd = GetRException_EndTimeOrig();
  759. }
  761. if (pEvent->GetRecurrenceState() == xtpCalendarRecurrenceException)
  762. {
  763. dtStart2 = pEvent->GetRException_StartTimeOrig();
  764. dtEnd2 = pEvent->GetRException_EndTimeOrig();
  765. }
  767. bRes = m_dwRecurrencePatternID == dwPatternID2 &&
  768.    CXTPCalendarUtils::IsEqual(dtStart, dtStart2, TRUE) &&
  769.    CXTPCalendarUtils::IsEqual(dtEnd, dtEnd2, TRUE);
  770. }
  771. return bRes;
  772. }
  774. void CXTPCalendarEvent::Clear()
  775. {
  776. CXTPCalendarEventPtr ptrEmptyEvent = m_pDataProvider->CreateNewEvent(GetEventID());
  777. if (!ptrEmptyEvent)
  778. {
  779. ASSERT(FALSE);
  780. return;
  781. }
  783. SetRecurrenceState_NotRecurring();
  784. Update(ptrEmptyEvent);
  785. }
  787. void CXTPCalendarEvent::DoPropExchange(CXTPPropExchange* pPX)
  788. {
  789. long nVersion = XTP_EVENT_PROP_SET_DATA_VER;
  790. PX_Long(pPX, _T("Version"), nVersion, XTP_EVENT_PROP_SET_DATA_VER);
  792. // TODO:
  793. PX_DWord(pPX, cszEventProp_ScheduleID, (DWORD&)m_uScheduleID, 0);
  795. PX_DWord(pPX, cszEventProp_EventID, m_dwEventID, XTP_CALENDAR_UNKNOWN_EVENT_ID);
  796. PX_DateTime(pPX, cszEventProp_StartTime, m_dtStartTime);
  797. PX_DateTime(pPX, cszEventProp_EndTime, m_dtEndTime);
  799. PX_String(pPX, cszEventProp_Subject, m_strSubject, _T(""));
  800. PX_String(pPX, cszEventProp_Location, m_strLocation, _T(""));
  802. if (nVersion > XTP_EVENT_PROP_SET_DATA_VER_1)
  803. {
  804. PX_String(pPX, cszEventProp_Body, m_strBody, _T(""));
  805. }
  806. else
  807. {
  808. PX_String(pPX, cszEventPropOld_Description, m_strBody, _T(""));
  809. }
  811. PX_Bool(pPX, cszEventProp_AllDayEvent, m_bAllDayEvent, FALSE);
  812. PX_Int(pPX, cszEventProp_LabelID, m_nLabelID, XTP_CALENDAR_DEFAULT_LABEL_ID);
  814. PX_Int(pPX, cszEventProp_BusyStatus, m_nBusyStatus, xtpCalendarBusyStatusFree);
  815. PX_Int(pPX, cszEventProp_Importance, m_nImportance, xtpCalendarImportanceNormal);
  817. if (nVersion > XTP_EVENT_PROP_SET_DATA_VER_1)
  818. {
  819. PX_Bool(pPX, cszEventProp_IsReminder, m_bReminder, FALSE);
  820. }
  822. PX_Int(pPX, cszEventProp_ReminderMinutesBeforeStart, m_nReminderMinutesBeforeStart, 15);
  823. PX_String(pPX, cszEventProp_ReminderSoundFile, m_strReminderSoundFile, _T(""));
  825. PX_DateTime(pPX, cszEventProp_CreationTime, m_dtCreationTime);
  826. PX_DateTime(pPX, cszEventProp_LastModificationTime, m_dtLastModificationTime);
  828. PX_Bool(pPX, cszEventProp_IsMeeting, m_bMeeting, FALSE);
  829. PX_Bool(pPX, cszEventProp_IsPrivate, m_bPrivate, FALSE);
  831. if (pPX->IsStoring())
  832. {
  833. PX_Enum(pPX, cszEventProp_RecurrenceState, m_nRecurrenceState, xtpCalendarRecurrenceNotRecurring);
  834. PX_DWord(pPX, cszEventProp_RecurrencePatternID, m_dwRecurrencePatternID, XTP_CALENDAR_UNKNOWN_RECURRENCE_PATTERN_ID);
  836. if (m_nRecurrenceState == xtpCalendarRecurrenceException)
  837. {
  838. PX_Bool(pPX, cszEventProp_RExceptionDeleted, m_bRExceptionDeleted, FALSE);
  839. PX_DateTime(pPX, cszEventProp_RException_StartTimeOrig, m_dtRException_StartTimeOrig);
  840. PX_DateTime(pPX, cszEventProp_RException_EndTimeOrig, m_dtRException_EndTimeOrig);
  841. }
  842. }
  843. else
  844. {
  845. //===========================================================================
  846. XTPCalendarEventRecurrenceState nRecurrenceState = m_nRecurrenceState = xtpCalendarRecurrenceNotRecurring;
  847. PX_Enum(pPX, cszEventProp_RecurrenceState, nRecurrenceState, xtpCalendarRecurrenceNotRecurring);
  849. DWORD dwRecurrencePatternID = XTP_CALENDAR_UNKNOWN_RECURRENCE_PATTERN_ID;
  850. PX_DWord(pPX, cszEventProp_RecurrencePatternID, dwRecurrencePatternID, XTP_CALENDAR_UNKNOWN_RECURRENCE_PATTERN_ID);
  852. if (nRecurrenceState == xtpCalendarRecurrenceMaster)
  853. {
  854. if (!MakeEventAsRecurrence())
  855. {
  856. ASSERT(FALSE);
  857. return;
  858. }
  859. }
  860. else if (nRecurrenceState == xtpCalendarRecurrenceException || nRecurrenceState == xtpCalendarRecurrenceOccurrence)
  861. {
  862. SetRecurrenceState_ExceptionOccurrence(nRecurrenceState, dwRecurrencePatternID);
  864. if (nRecurrenceState == xtpCalendarRecurrenceException)
  865. {
  866. PX_Bool(pPX, cszEventProp_RExceptionDeleted, m_bRExceptionDeleted, FALSE);
  867. PX_DateTime(pPX, cszEventProp_RException_StartTimeOrig, m_dtRException_StartTimeOrig);
  868. PX_DateTime(pPX, cszEventProp_RException_EndTimeOrig, m_dtRException_EndTimeOrig);
  869. }
  870. }
  871. }
  873. //------------------------------------------------------------------------
  874. if (m_pCustomProperties)
  875. m_pCustomProperties->DoPropExchange(pPX);
  877. if (m_pCustomIconsIDs)
  878. m_pCustomIconsIDs->DoPropExchange(pPX);
  880. if (m_pEventCategoryIDs && nVersion > XTP_EVENT_PROP_SET_DATA_VER_2)
  881. m_pEventCategoryIDs->DoPropExchange(pPX);
  882. }
  884. void CXTPCalendarEvent::ClearIntermediateData()
  885. {
  886. m_dwRecurrencePatternID_ToUse = XTP_CALENDAR_UNKNOWN_RECURRENCE_PATTERN_ID;
  888. if (!IsReminder() && m_pCustomProperties)
  889. {
  890. // clear this property if reminder disabled
  891. m_pCustomProperties->RemoveProperty(cszEventCustProp_NextReminderTime_Snoozed);
  892. }
  894. if (!IsReminder() && m_ptrRPattern)
  895. {
  896. ASSERT(m_nRecurrenceState == xtpCalendarRecurrenceMaster);
  898. // clear reminders info for occurrences
  899. // if reminder disabled for whole series.
  900. m_ptrRPattern->GetOccReminders()->RemoveAll();
  901. }
  902. }
  904. void CXTPCalendarEvent::SetRecurrencePatternID(DWORD dwRecurrencePatternID)
  905. {
  906. m_dwRecurrencePatternID = dwRecurrencePatternID;
  908. if (m_ptrRPattern)
  909. {
  910. ASSERT(m_nRecurrenceState == xtpCalendarRecurrenceMaster);
  911. m_ptrRPattern->SetPatternID(dwRecurrencePatternID);
  912. }
  913. }
  915. void CXTPCalendarEvent::SetEventID(DWORD dwEventID)
  916. {
  917. m_dwEventID = dwEventID;
  919. if (m_nRecurrenceState == xtpCalendarRecurrenceMaster)
  920. {
  921. ASSERT(m_ptrRPattern);
  922. if (m_ptrRPattern)
  923. {
  924. m_ptrRPattern->SetMasterEventID(m_dwEventID);
  925. }
  926. }
  927. }
  929. ////////////////////////////////////////////////////////////////////////////
  932. ////////////////////////////////////////////////////////////////////////////