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

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

对话框与窗口

开发平台：

Visual C++

XTPCalendarData.cpp：源码内容
  1. // XTPCalendarData.cpp: implementation of the CXTPCalendarData 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 "XTPCalendarData.h"
  25. #include "XTPCalendarMemoryDataProvider.h"
  26. #include "XTPCalendarCustomProperties.h"
  28. #include "Common/XTPNotifyConnection.h"
  29. #include "Common/XTPVC50Helpers.h"
  30. #include "Common/XTPPropExchange.h"
  32. #include "XTPCalendarControl.h"
  34. #include "XTPCalendarRecurrencePattern.h"
  35. #include "XTPCalendarEvent.h"
  36. #include "XTPCalendarEventLabel.h"
  38. #include "XTPCalendarNotifications.h"
  39. #include "XTPCalendarOptions.h"
  40. #include "XTPCalendarResource.h"
  42. #ifdef _DEBUG
  43. #define new DEBUG_NEW
  44. #undef THIS_FILE
  45. static char THIS_FILE[] = __FILE__;
  46. #endif
  49. #define DBG_CACHE_ASSERT ASSERT
  51. #ifndef DBG_CACHE_ASSERT
  52. #define DBG_CACHE_ASSERT
  53. #endif
  55. //===========================================================================
  56. // Summary:
  57. //     Define data provider cache hash table size. Should be a prime number!
  58. //     like: 503, 1021, 1511, 2003, 3001, 4001, 5003, 6007, 8009, 12007,
  59. //     16001, 32003, 48017, 64007
  60. // See Also: CMap overview
  61. //===========================================================================
  62. #define XTP_DP_CACHE_HASH_TABLE_SIZE 1021
  64. long VAR2long(const COleVariant& oleVar)
  65. {
  66. try
  67. {
  68. _variant_t vtValue((const VARIANT*)&oleVar);
  70. return (long)vtValue;
  71. }
  72. //catch(_com_error e)
  73. catch(...)
  74. {
  75. ASSERT(FALSE);
  76. }
  77. return 0;
  78. }
  80. ////////////////////////////////////////////////////////////////////////////
  81. CXTPCalendarData::CXTPDPCache::CXTPDPCache()
  82. {
  83. m_pCacheDP = NULL;
  84. m_eCacheMode = xtpCalendarDPCacheModeOff;
  86. m_mapIsDayInCache.InitHashTable(XTP_DP_CACHE_HASH_TABLE_SIZE, FALSE);
  87. }
  89. CXTPCalendarData::CXTPDPCache::~CXTPDPCache()
  90. {
  91. SafeClose();
  92. }
  94. void CXTPCalendarData::CXTPDPCache::SafeClose()
  95. {
  96. if (m_pCacheDP)
  97. {
  98. if (m_pCacheDP->IsOpen())
  99. {
  100. m_pCacheDP->Close();
  101. }
  102. }
  103. CMDTARGET_RELEASE(m_pCacheDP);
  105. m_eCacheMode = xtpCalendarDPCacheModeOff;
  106. }
  108. void CXTPCalendarData::CXTPDPCache::SafeRemoveAll()
  109. {
  110. if (m_pCacheDP)
  111. {
  112. m_pCacheDP->RemoveAllEvents();
  113. }
  114. m_mapIsDayInCache.RemoveAll();
  115. }
  117. BOOL CXTPCalendarData::CXTPDPCache::IsDayInCache(COleDateTime dtDay)
  118. {
  119. BOOL bIs = FALSE;
  120. return m_mapIsDayInCache.Lookup((DWORD)(DATE)dtDay, bIs) && bIs;
  121. }
  123. void CXTPCalendarData::CXTPDPCache::SetDayInCache(COleDateTime dtDay, BOOL bSet)
  124. {
  125. if (bSet)
  126. {
  127. m_mapIsDayInCache.SetAt((DWORD)(DATE)dtDay, TRUE);
  128. }
  129. else
  130. {
  131. m_mapIsDayInCache.RemoveKey((DWORD)(DATE)dtDay);
  132. }
  133. }
  135. BOOL CXTPCalendarData::CXTPDPCache::IsEventInCache(CXTPCalendarEvent* pEvent)
  136. {
  137. if (!pEvent || !m_pCacheDP)
  138. {
  139. ASSERT(FALSE);
  140. return FALSE;
  141. }
  143. int nRState = pEvent->GetRecurrenceState();
  145. if (nRState == xtpCalendarRecurrenceNotRecurring ||
  146. nRState == xtpCalendarRecurrenceMaster)
  147. {
  148. DWORD dwEventID = pEvent->GetEventID();
  149. CXTPCalendarEventPtr ptrEvInCache = m_pCacheDP->GetEvent(dwEventID);
  151. return ptrEvInCache != NULL;
  152. }
  153. else
  154. {
  155. ASSERT(nRState == xtpCalendarRecurrenceOccurrence || nRState == xtpCalendarRecurrenceException);
  157. DWORD dwRPatternID = pEvent->GetRecurrencePatternID();
  158. CXTPCalendarRecurrencePatternPtr ptrRPattern = m_pCacheDP->GetRecurrencePattern(dwRPatternID);
  159. return ptrRPattern != NULL;
  160. }
  161. }
  163. void CXTPCalendarData::CXTPDPCache::_AddToCacheIfNeed(CXTPCalendarRecurrencePattern* pPattern)
  164. {
  165. ASSERT(pPattern);
  166. if (!pPattern || !m_pCacheDP)
  167. {
  168. return;
  169. }
  171. DWORD dwRPatternID = pPattern->GetPatternID();
  172. CXTPCalendarRecurrencePatternPtr ptrRPattern = m_pCacheDP->GetRecurrencePattern(dwRPatternID);
  174. if (ptrRPattern)
  175. {
  176. return;
  177. }
  179. #ifdef _DEBUG
  180. {
  181. DWORD dwMasterEventID = pPattern->GetMasterEventID();
  182. CXTPCalendarEventPtr ptrMasterEvent = m_pCacheDP->GetEvent(dwMasterEventID);
  183. ASSERT(ptrMasterEvent == NULL);
  184. }
  185. #endif
  187. CXTPCalendarEventPtr ptrMasterEvent = pPattern->GetMasterEvent(); // this call also add master event to cache
  188. ASSERT(ptrMasterEvent);
  190. if (ptrMasterEvent)
  191. {
  192. // Must be added to cache in call: pPattern->GetMasterEvent();
  193. //
  194. DWORD dwMasterEventID = ptrMasterEvent->GetEventID();
  195. CXTPCalendarEventPtr ptrEvInCache = m_pCacheDP->GetEvent(dwMasterEventID);
  196. DBG_CACHE_ASSERT(ptrEvInCache);
  198. if (!ptrEvInCache)
  199. {
  200. // this strange, but add if it is still not here
  201. VERIFY(m_pCacheDP->AddEvent(ptrMasterEvent));
  202. }
  203. }
  204. }
  206. void CXTPCalendarData::CXTPDPCache::AddToCacheIfNeed(CXTPCalendarEvent* pEvent)
  207. {
  208. ASSERT(pEvent);
  209. if (!pEvent || !m_pCacheDP)
  210. {
  211. return;
  212. }
  214. int nRState = pEvent->GetRecurrenceState();
  216. if (nRState == xtpCalendarRecurrenceNotRecurring ||
  217. nRState == xtpCalendarRecurrenceMaster)
  218. {
  219. DWORD dwEventID = pEvent->GetEventID();
  220. CXTPCalendarEventPtr ptrEvInCache = m_pCacheDP->GetEvent(dwEventID);
  221. if (!ptrEvInCache)
  222. {
  223. VERIFY(m_pCacheDP->AddEvent(pEvent));
  224. }
  225. }
  226. else
  227. {
  228. // From previous version.
  229. // Non-Optimal. Should not be called.
  230. ASSERT(FALSE);
  231. }
  232. }
  234. void CXTPCalendarData::CXTPDPCache::AddToCache(CXTPCalendarEvents* pEvents, COleDateTime dtDay)
  235. {
  236. if (!pEvents)
  237. {
  238. return;
  239. }
  241. int nCount = pEvents->GetCount();
  242. for (int i = 0; i < nCount; i++)
  243. {
  244. CXTPCalendarEvent* pEvent = pEvents->GetAt(i ,FALSE);
  245. AddToCacheIfNeed(pEvent);
  246. }
  248. SetDayInCache(dtDay, TRUE);
  249. }
  251. void CXTPCalendarData::SetCacheMode(int eCacheMode, CXTPCalendarData* pCacheDataProvider)
  252. {
  253. if (eCacheMode == xtpCalendarDPCacheModeOff)
  254. {
  255. m_cache.SafeClose();
  256. }
  257. else
  258. {
  259. if (!m_cache.m_pCacheDP && !pCacheDataProvider)
  260. {
  261. m_cache.m_pCacheDP = new CXTPCalendarMemoryDataProvider();
  262. }
  263. else if (!m_cache.m_pCacheDP && pCacheDataProvider)
  264. {
  265. m_cache.m_pCacheDP = pCacheDataProvider;
  266. }
  267. else if (m_cache.m_pCacheDP && pCacheDataProvider)
  268. {
  269. m_cache.SafeClose();
  270. m_cache.m_pCacheDP = pCacheDataProvider;
  271. }
  272. else
  273. {
  274. ASSERT(m_cache.m_pCacheDP && !pCacheDataProvider);
  275. }
  277. if (!m_cache.m_pCacheDP)
  278. {
  279. return;
  280. }
  281. if (!m_cache.m_pCacheDP->IsOpen())
  282. {
  283. VERIFY( m_cache.m_pCacheDP->Open() );
  284. }
  285. m_cache.SafeRemoveAll();
  287. m_cache.m_eCacheMode = eCacheMode;
  288. }
  289. }
  291. void CXTPCalendarData::ClearCache()
  292. {
  293. m_cache.SafeRemoveAll();
  294. }
  296. void CXTPCalendarData::RemoveAllEvents()
  297. {
  298. if (!IsOpen())
  299. {
  300. ASSERT(FALSE);
  301. return;
  302. }
  304. m_cache.SafeRemoveAll();
  306. DoRemoveAllEvents();
  307. }
  309. //////////////////////////////////////////////////////////////////////////
  310. DWORD CXTPCalendarData::ms_dwNextFreeTempID = DWORD(-1);
  311. //===========================================================================
  312. IMPLEMENT_DYNAMIC(CXTPCalendarData, CCmdTarget)
  314. CXTPCalendarData::CXTPCalendarData()
  315. {
  316. m_pCalendarOptions = NULL;
  318. m_bOpened = FALSE;
  319. m_pConnect = new CXTPNotifyConnection();
  320. m_bDisableNotificationsSending = FALSE;
  322. m_pLabelList = new CXTPCalendarEventLabels();
  323. m_pLabelList->InitDefaultValues();
  325. m_typeProvider = xtpCalendarDataProviderUnknown;
  327. m_pCustomProperties = new CXTPCalendarCustomProperties();
  328. m_pSchedules = new CXTPCalendarSchedules();
  330. m_pEventCategories = new CXTPCalendarEventCategories();
  331. m_pEventCategories->InitDefaultValues();
  334. }
  336. CXTPCalendarData::~CXTPCalendarData()
  337. {
  338. if (m_pCalendarOptions)
  339. {
  340. m_pCalendarOptions->SetDataProvider(NULL);
  341. }
  342. ASSERT(!m_pCalendarOptions);
  343. //CMDTARGET_RELEASE(m_pCalendarOptions);
  345. CMDTARGET_RELEASE(m_pLabelList);
  346. CMDTARGET_RELEASE(m_pConnect);
  347. CMDTARGET_RELEASE(m_pCustomProperties);
  348. CMDTARGET_RELEASE(m_pSchedules);
  349. CMDTARGET_RELEASE(m_pEventCategories);
  350. }
  352. void CXTPCalendarData::SetLabelList(CXTPCalendarEventLabels* pLabelList)
  353. {
  354. CMDTARGET_RELEASE(m_pLabelList);
  356. m_pLabelList = pLabelList;
  358. CMDTARGET_ADDREF(m_pLabelList);
  359. }
  361. CXTPCalendarEventPtr CXTPCalendarData::CreateNewEvent(DWORD dwEventID)
  362. {
  363. CXTPCalendarEventPtr ptrEvent = new CXTPCalendarEvent(this);
  365. if (ptrEvent)
  366. {
  367. DWORD dwTempID = dwEventID != XTP_CALENDAR_UNKNOWN_EVENT_ID ? dwEventID: GetNextFreeTempID();
  368. ptrEvent->SetEventID(dwTempID);
  369. }
  371. return ptrEvent;
  372. }
  374. CXTPCalendarRecurrencePatternPtr CXTPCalendarData::CreateNewRecurrencePattern(DWORD dwPatternID)
  375. {
  376. CXTPCalendarRecurrencePatternPtr ptrPattern = new CXTPCalendarRecurrencePattern(this);
  377. if (ptrPattern)
  378. {
  379. DWORD dwTempID = dwPatternID != XTP_CALENDAR_UNKNOWN_RECURRENCE_PATTERN_ID? dwPatternID : GetNextFreeTempID();
  380. ptrPattern->SetPatternID(dwTempID);
  381. }
  382. return ptrPattern;
  383. }
  386. CString CXTPCalendarData::GetDataSource()
  387. {
  388. return CXTPCalendarControl::DataSourceFromConStr(m_strConnectionString);
  389. }
  391. CXTPCalendarEventsPtr CXTPCalendarData::RetrieveDayEvents(COleDateTime dtDay)
  392. {
  393. if (!IsOpen())
  394. {
  395. DBG_DATA_ASSERT(FALSE);
  396. return NULL;
  397. }
  398. dtDay = CXTPCalendarUtils::ResetTime(dtDay);
  400. CXTPCalendarEventsPtr ptrResult = NULL;
  402. if ((m_cache.m_eCacheMode & xtpCalendarDPCacheModeOnMask) &&
  403. m_cache.IsDayInCache(dtDay))
  404. {
  405. ASSERT(m_cache.m_pCacheDP);
  406. ptrResult = m_cache.m_pCacheDP->RetrieveDayEvents(dtDay);
  407. }
  408. else
  409. {
  410. ptrResult = DoRetrieveDayEvents(dtDay);
  411. if (!ptrResult)
  412. {
  413. return NULL;
  414. }
  416. _PostProcessRecurrenceIfNeed(ptrResult);
  418. if (m_cache.m_eCacheMode & xtpCalendarDPCacheModeOnMask)
  419. {
  420. ASSERT(m_cache.m_pCacheDP);
  421. m_cache.AddToCache(ptrResult, dtDay);
  422. }
  424. _PostProcessOccurrencesFromMaster(dtDay, ptrResult);
  426. _FilterDayEventsInstancesByEndTime(dtDay, ptrResult);
  427. }
  429. return ptrResult;
  430. }
  432. BOOL CXTPCalendarData::AddEvents(CXTPCalendarEvents* pEvents)
  433. {
  434. BOOL bResult = TRUE;
  435. int nEventsCount = pEvents->GetCount();
  436. for (int i = 0; i < nEventsCount; i++)
  437. {
  438. CXTPCalendarEvent* pEvent = pEvents->GetAt(i, FALSE);
  439. if (!AddEvent(pEvent))
  440. {
  441. bResult = FALSE;
  442. }
  443. }
  444. return bResult;
  445. }
  447. BOOL CXTPCalendarData::AddEvent(CXTPCalendarEvent* pEvent)
  448. {
  449. if (!IsOpen())
  450. {
  451. return FALSE;
  452. }
  454. if (!pEvent)
  455. {
  456. ASSERT(FALSE);
  457. return FALSE;
  458. }
  460. pEvent->ClearIntermediateData();
  462. COleDateTime dtNow = CXTPCalendarUtils::GetCurrentTime();
  463. pEvent->SetLastModificationTime(dtNow);
  465. DWORD dwNewEventID = pEvent->GetEventID();
  467. if (!DoCreate_Event(pEvent, dwNewEventID))
  468. {
  469. DBG_DATA_ASSERT(FALSE);
  470. return FALSE;
  471. }
  472. ASSERT(dwNewEventID != XTP_CALENDAR_UNKNOWN_EVENT_ID);
  473. pEvent->SetEventID(dwNewEventID);
  475. int nRState = (long)pEvent->GetRecurrenceState();
  477. BOOL bSendPatternAddedEvent = FALSE;
  478. DWORD dwPatternID = XTP_CALENDAR_UNKNOWN_RECURRENCE_PATTERN_ID;
  480. //- Process Recurrence Pattern for Master event -------------------------
  481. if (nRState == xtpCalendarRecurrenceMaster)
  482. {
  483. CXTPCalendarRecurrencePattern* pPatternRef = pEvent->GetRPatternRef();
  484. if (!pPatternRef)
  485. {
  486. ASSERT(FALSE);
  487. return FALSE;
  488. }
  490. pPatternRef->SetMasterEventID(dwNewEventID);
  492. //pPatternRef->ResetReminderForOccFromThePast(pEvent);
  494. VERIFY( pPatternRef->GetOccReminders()->Save(pPatternRef->GetCustomProperties(), pPatternRef) );
  496. BOOL bRes = DoCreate_RPattern(pPatternRef, dwPatternID);
  497. DBG_DATA_ASSERT(bRes);
  499. pPatternRef->GetOccReminders()->ClearProperties(pPatternRef->GetCustomProperties());
  501. if (!bRes)
  502. {
  503. return FALSE;
  504. }
  505. ASSERT(dwPatternID != XTP_CALENDAR_UNKNOWN_RECURRENCE_PATTERN_ID);
  507. DWORD dwPatternID_prev = pEvent->GetRecurrencePatternID();
  508. pEvent->SetRecurrencePatternID(dwPatternID);
  510. if (dwPatternID_prev != dwPatternID)
  511. {
  512. bRes = DoUpdate_Event(pEvent);
  513. DBG_DATA_ASSERT(bRes);
  514. if (!bRes)
  515. {
  516. return FALSE;
  517. }
  518. }
  520. bSendPatternAddedEvent = TRUE;
  521. }
  523. //---------------------------------------------------------------------------
  524. if (m_cache.m_eCacheMode == xtpCalendarDPCacheModeOnRepeat)
  525. {
  526. ASSERT(m_cache.m_pCacheDP);
  527. if (m_cache.m_pCacheDP) VERIFY( m_cache.m_pCacheDP->AddEvent(pEvent) );
  528. }
  529. else if (m_cache.m_eCacheMode == xtpCalendarDPCacheModeOnClear)
  530. {
  531. ASSERT(m_cache.m_pCacheDP);
  532. //m_cache.m_pCacheDP->RemoveAllEvents();
  533. m_cache.SafeRemoveAll();
  534. }
  536. //---------------------------------------------------------------------------
  537. SendNotification(XTP_NC_CALENDAREVENTWASADDED, (WPARAM)pEvent->GetEventID(), (LPARAM)pEvent);
  538. if (bSendPatternAddedEvent)
  539. {
  540. SendNotification(XTP_NC_CALENDARPATTERNWASADDED, dwPatternID, 0);
  541. }
  543. return TRUE;
  544. }
  546. BOOL CXTPCalendarData::ChangeEvent(CXTPCalendarEvent* pEvent)
  547. {
  548. if (!IsOpen())
  549. {
  550. return FALSE;
  551. }
  553. if (!pEvent)
  554. {
  555. ASSERT(FALSE);
  556. return FALSE;
  557. }
  559. pEvent->ClearIntermediateData();
  561. COleDateTime dtNow = CXTPCalendarUtils::GetCurrentTime();
  562. pEvent->SetLastModificationTime(dtNow);
  564. DWORD dwEventID = pEvent->GetEventID();
  565. ASSERT(dwEventID != XTP_CALENDAR_UNKNOWN_EVENT_ID);
  567. //- new recurrence state ---------------------------
  568. CXTPCalendarRecurrencePatternPtr ptrPattern_new;
  570. int nRState_new = pEvent->GetRecurrenceState();
  572. // - Add/Update/Remove Recurrence Exception --------------------
  573. if (nRState_new == xtpCalendarRecurrenceException ||
  574. nRState_new == xtpCalendarRecurrenceOccurrence)
  575. {
  576. return _ChangeRExceptionOccurrence_nf(pEvent, FALSE);
  577. }
  578. //===========================================================================
  580. //CXTPCalendarEventPtr ptrEventPrev = _GetEvent_UseCache(dwEventID);
  581. CXTPCalendarEventPtr ptrEventPrev = GetEvent(dwEventID);
  582. if (!ptrEventPrev)
  583. {
  584. ASSERT(FALSE);
  585. return FALSE;
  586. }
  588. //************************************************************
  589. CXTPCalendarRecurrencePatternPtr ptrPattern_prev;
  591. BOOL bSendPatternAddedEvent = FALSE;
  592. BOOL bSendPatternChangedEvent = FALSE;
  593. BOOL bSendPatternDeletedEvent = FALSE;
  594. DWORD dwPatternID = XTP_CALENDAR_UNKNOWN_RECURRENCE_PATTERN_ID;
  596. //- previous recurrence state ---------------------
  597. int nRState_prev = ptrEventPrev->GetRecurrenceState();
  599. //=== Update Event Recurrence Properties. IF NEED.
  600. //
  601. // 1.Event become recurrence
  602. if (nRState_prev == xtpCalendarRecurrenceNotRecurring &&
  603. nRState_new == xtpCalendarRecurrenceMaster)
  604. {
  605. ptrPattern_new.SetPtr(pEvent->GetRPatternRef(), TRUE);
  607. //      ptrPattern_new->ResetReminderForOccFromThePast(pEvent);
  609. if (!_AddRPatternWithExceptions(ptrPattern_new))
  610. {
  611. ASSERT(FALSE);
  612. return FALSE;
  613. }
  615. dwPatternID = ptrPattern_new->GetPatternID();
  616. ASSERT(dwPatternID != XTP_CALENDAR_UNKNOWN_RECURRENCE_PATTERN_ID);
  618. pEvent->SetRecurrencePatternID(dwPatternID);
  620. bSendPatternAddedEvent = TRUE;
  621. }
  622. // 2.Event become Not Recurrence
  623. else if (nRState_prev == xtpCalendarRecurrenceMaster &&
  624. nRState_new == xtpCalendarRecurrenceNotRecurring)
  625. {
  626. ptrPattern_prev.SetPtr(ptrEventPrev->GetRPatternRef(), TRUE);
  628. dwPatternID = ptrPattern_prev->GetPatternID();
  629. bSendPatternDeletedEvent = TRUE;
  631. if (!_RemoveRPatternWithExceptions(ptrPattern_prev))
  632. {
  633. ASSERT(FALSE);
  634. return FALSE;
  635. }
  636. }
  637. // 3. Update Recurrence Event
  638. else if (nRState_prev == xtpCalendarRecurrenceMaster &&
  639. nRState_new == xtpCalendarRecurrenceMaster)
  640. {
  641. ptrPattern_new.SetPtr(pEvent->GetRPatternRef(), TRUE);
  643. //ptrPattern_new->ResetReminderForOccFromThePast(pEvent);
  645. if (!_ChangeRPatternWithExceptions(ptrPattern_new))
  646. {
  647. DBG_DATA_ASSERT(FALSE);
  648. return FALSE;
  649. }
  650. dwPatternID = ptrPattern_new->GetPatternID();
  651. bSendPatternChangedEvent = TRUE;
  652. }
  654. // Update Event properties
  655. BOOL bRes = DoUpdate_Event(pEvent);
  656. DBG_DATA_ASSERT(bRes);
  657. if (!bRes)
  658. {
  659. return FALSE;
  660. }
  662. //---------------------------------------------------------------------------
  663. if (m_cache.m_eCacheMode == xtpCalendarDPCacheModeOnRepeat)
  664. {
  665. ASSERT(m_cache.m_pCacheDP);
  666. if (m_cache.IsEventInCache(pEvent))
  667. {
  668. if (m_cache.m_pCacheDP) VERIFY( m_cache.m_pCacheDP->ChangeEvent(pEvent) );
  669. }
  670. }
  671. else if (m_cache.m_eCacheMode == xtpCalendarDPCacheModeOnClear)
  672. {
  673. ASSERT(m_cache.m_pCacheDP);
  674. //m_cache.m_pCacheDP->RemoveAllEvents();
  675. m_cache.SafeRemoveAll();
  676. }
  677. //---------------------------------------------------------------------------
  679. SendNotification(XTP_NC_CALENDAREVENTWASCHANGED, (WPARAM)pEvent->GetEventID(), (LPARAM)pEvent);
  681. if (bSendPatternAddedEvent)
  682. {
  683. SendNotification(XTP_NC_CALENDARPATTERNWASADDED, dwPatternID, 0);
  684. }
  685. else if (bSendPatternChangedEvent)
  686. {
  687. SendNotification(XTP_NC_CALENDARPATTERNWASCHANGED, dwPatternID, 0);
  688. }
  689. else if (bSendPatternDeletedEvent)
  690. {
  691. SendNotification(XTP_NC_CALENDARPATTERNWASDELETED, dwPatternID, 0);
  692. }
  694. return TRUE;
  695. }
  697. BOOL CXTPCalendarData::DeleteEvent(CXTPCalendarEvent* pEvent)
  698. {
  699. if (!IsOpen())
  700. {
  701. return FALSE;
  702. }
  703. if (!pEvent)
  704. {
  705. ASSERT(FALSE);
  706. return FALSE;
  707. }
  709. DWORD dwEventID = pEvent->GetEventID();
  710. ASSERT(dwEventID != XTP_CALENDAR_UNKNOWN_EVENT_ID);
  712. BOOL bRes = TRUE;
  713. BOOL bSendPatternDeletedEvent = FALSE;
  714. DWORD dwPatternID = XTP_CALENDAR_UNKNOWN_RECURRENCE_PATTERN_ID;
  716. //- recurrence state ---------------------
  717. int nRState = pEvent->GetRecurrenceState();
  719. //1. remove occurrence (set deleted property to exception)
  720. if (nRState == xtpCalendarRecurrenceOccurrence || nRState == xtpCalendarRecurrenceException)
  721. {
  722. CXTPCalendarEventPtr ptrException = pEvent->CloneEvent();
  723. if (!ptrException)
  724. {
  725. return FALSE;
  726. }
  728. if (nRState == xtpCalendarRecurrenceOccurrence)
  729. {
  730. // make exception from Occurrence
  731. ptrException->MakeAsRException();
  732. }
  733. ptrException->SetRExceptionDeleted(TRUE);
  735. return _ChangeRExceptionOccurrence_nf(ptrException, TRUE);
  736. }
  737. else
  738. {
  739. if (!DoDelete_Event(pEvent))
  740. {
  741. bRes = FALSE;
  742. }
  744. //-----------------------------------------------------------------
  745. if (nRState == xtpCalendarRecurrenceMaster)
  746. {
  747. dwPatternID = pEvent->GetRecurrencePatternID();
  749. CXTPCalendarRecurrencePattern* pPattern = pEvent->GetRPatternRef();
  750. if (!_RemoveRPatternWithExceptions(pPattern))
  751. {
  752. bRes = FALSE;
  753. }
  754. bSendPatternDeletedEvent = bRes;
  755. }
  756. }
  758. //---------------------------------------------------------------------------
  759. if (m_cache.m_eCacheMode == xtpCalendarDPCacheModeOnRepeat)
  760. {
  761. ASSERT(m_cache.m_pCacheDP);
  762. if (m_cache.IsEventInCache(pEvent))
  763. {
  764. if (m_cache.m_pCacheDP) VERIFY( m_cache.m_pCacheDP->DeleteEvent(pEvent) );
  765. }
  766. }
  767. else if (m_cache.m_eCacheMode == xtpCalendarDPCacheModeOnClear)
  768. {
  769. ASSERT(m_cache.m_pCacheDP);
  770. //m_cache.m_pCacheDP->RemoveAllEvents();
  771. m_cache.SafeRemoveAll();
  772. }
  773. //---------------------------------------------------------------------------
  775. if (bRes)
  776. {
  777. SendNotification(XTP_NC_CALENDAREVENTWASDELETED, (WPARAM)pEvent->GetEventID(), (LPARAM)pEvent);
  778. }
  779. if (bSendPatternDeletedEvent)
  780. {
  781. SendNotification(XTP_NC_CALENDARPATTERNWASDELETED, dwPatternID, 0);
  782. }
  784. return bRes;
  785. }
  787. CXTPCalendarEventPtr CXTPCalendarData::GetEvent(DWORD dwEventID)
  788. {
  789. if (!IsOpen())
  790. {
  791. return NULL;
  792. }
  794. CXTPCalendarEventPtr ptrEvent;
  795. if ((m_cache.m_eCacheMode & xtpCalendarDPCacheModeOnMask))
  796. {
  797. ASSERT(m_cache.m_pCacheDP);
  798. if (m_cache.m_pCacheDP) ptrEvent = m_cache.m_pCacheDP->GetEvent(dwEventID);
  799. }
  801. if (!ptrEvent)
  802. {
  803. ptrEvent = _GetEvent_raw(dwEventID);
  804. if (!ptrEvent)
  805. return NULL;
  807. if (ptrEvent->GetRecurrenceState() != xtpCalendarRecurrenceNotRecurring &&
  808. ptrEvent->GetRecurrenceState() != xtpCalendarRecurrenceMaster)
  809. {
  810. return NULL;
  811. }
  813. if (m_cache.m_eCacheMode & xtpCalendarDPCacheModeOnMask)
  814. {
  815. ASSERT(m_cache.m_pCacheDP);
  816. m_cache.AddToCacheIfNeed(ptrEvent);
  817. }
  818. }
  820. return ptrEvent;
  821. }
  823. BOOL CXTPCalendarData::_PostProcessRecurrenceIfNeed(CXTPCalendarEvent* pEvent)
  824. {
  825. COleVariant varRState;
  826. COleVariant varRPatternID;
  828. BOOL bRState_prop = pEvent->GetCustomProperties()->GetProperty(cszProcess_RecurrenceState, varRState);
  829. BOOL bRPatternID_prop = pEvent->GetCustomProperties()->GetProperty(cszProcess_RecurrencePatternID, varRPatternID);
  831. pEvent->GetCustomProperties()->RemoveProperty(cszProcess_RecurrenceState);
  832. pEvent->GetCustomProperties()->RemoveProperty(cszProcess_RecurrencePatternID);
  834. if (!bRState_prop)
  835. {
  836. return FALSE;
  837. }
  839. int nRState = VAR2long(varRState);
  840. if (xtpCalendarRecurrenceMaster == nRState)
  841. {
  842. if (!bRPatternID_prop)
  843. {
  844. ASSERT(FALSE);
  845. return FALSE;
  846. }
  847. DWORD dwRPatternID = (DWORD)VAR2long(varRPatternID);
  849. CXTPCalendarRecurrencePatternPtr ptrPattern = _GetRecurrencePattern_raw(dwRPatternID);
  850. if (!ptrPattern)
  851. {
  852. ASSERT(FALSE);
  853. return FALSE;
  854. }
  856. VERIFY( pEvent->MakeEventAsRecurrence() );
  857. pEvent->SetRecurrencePatternID(dwRPatternID);
  858. VERIFY( pEvent->UpdateRecurrence(ptrPattern) );
  860. return TRUE;
  861. }
  862. else if (xtpCalendarRecurrenceException == nRState)
  863. {
  864. DWORD dwRPatternID = bRPatternID_prop ? (DWORD)VAR2long(varRPatternID) : 0;
  865. pEvent->SetRecurrencePatternID(dwRPatternID);
  867. if (pEvent->GetRecurrenceState() != xtpCalendarRecurrenceException)
  868. {
  869. pEvent->MakeAsRException(dwRPatternID);
  870. }
  871. }
  872. return FALSE;
  873. }
  875. void CXTPCalendarData::_PostProcessRecurrenceIfNeed(CXTPCalendarEvents* pEvents)
  876. {
  877. int nCount = pEvents ? pEvents->GetCount() : 0;
  878. for (int i = 0; i < nCount; i++)
  879. {
  880. CXTPCalendarEvent* pEvent = pEvents->GetAt(i, FALSE);
  881. ASSERT(pEvent);
  882. if (pEvent)
  883. {
  884. _PostProcessRecurrenceIfNeed(pEvent);
  885. }
  886. }
  887. }
  889. CXTPCalendarEventPtr CXTPCalendarData::_GetEvent_raw(DWORD dwEventID)
  890. {
  891. if (!IsOpen())
  892. {
  893. return NULL;
  894. }
  896. CXTPCalendarEventPtr ptrEvent = DoRead_Event(dwEventID);
  897. if (!ptrEvent)
  898. {
  899. return NULL;
  900. }
  902. _PostProcessRecurrenceIfNeed(ptrEvent);
  904. return ptrEvent;
  905. }
  907. CXTPCalendarRecurrencePatternPtr CXTPCalendarData::_GetRecurrencePattern_raw(DWORD dwPatternID)
  908. {
  909. CXTPCalendarRecurrencePatternPtr ptrPattern = DoRead_RPattern(dwPatternID);
  911. if (ptrPattern)
  912. {
  913. VERIFY( ptrPattern->GetOccReminders()->Load(ptrPattern->GetCustomProperties()) );
  914. ptrPattern->GetOccReminders()->ClearProperties(ptrPattern->GetCustomProperties());
  915. }
  916. return ptrPattern;
  917. }
  919. CXTPCalendarRecurrencePatternPtr CXTPCalendarData::GetRecurrencePattern(DWORD dwPatternID)
  920. {
  921. if (!IsOpen())
  922. {
  923. return NULL;
  924. }
  926. CXTPCalendarRecurrencePatternPtr ptrPattern;
  927. if ((m_cache.m_eCacheMode & xtpCalendarDPCacheModeOnMask))
  928. {
  929. ASSERT(m_cache.m_pCacheDP);
  930. if (m_cache.m_pCacheDP) ptrPattern = m_cache.m_pCacheDP->GetRecurrencePattern(dwPatternID);
  931. }
  933. if (!ptrPattern)
  934. {
  935. ptrPattern = _GetRecurrencePattern_raw(dwPatternID);
  937. if (ptrPattern && (m_cache.m_eCacheMode & xtpCalendarDPCacheModeOnMask))
  938. {
  939. m_cache._AddToCacheIfNeed(ptrPattern);
  940. }
  941. }
  943. return ptrPattern;
  944. }
  946. BOOL CXTPCalendarData::_AddRPatternWithExceptions(CXTPCalendarRecurrencePattern* pPattern)
  947. {
  948. if (!IsOpen())
  949. {
  950. return FALSE;
  951. }
  952. if (!pPattern)
  953. {
  954. ASSERT(FALSE);
  955. return FALSE;
  956. }
  958. VERIFY( pPattern->GetOccReminders()->Save(pPattern->GetCustomProperties(), pPattern) );
  960. DWORD dwNewPatternID = XTP_CALENDAR_UNKNOWN_RECURRENCE_PATTERN_ID;
  961. BOOL bRes = DoCreate_RPattern(pPattern, dwNewPatternID);
  962. DBG_DATA_ASSERT(bRes);
  964. pPattern->GetOccReminders()->ClearProperties(pPattern->GetCustomProperties());
  966. if (!bRes)
  967. {
  968. return FALSE;
  969. }
  970. ASSERT(dwNewPatternID != XTP_CALENDAR_UNKNOWN_RECURRENCE_PATTERN_ID);
  971. pPattern->SetPatternID(dwNewPatternID);
  973. BOOL bResult = TRUE;
  974. //-- Process exceptions ---------------------------------------------------
  975. CXTPCalendarEventsPtr prtExceptions = pPattern->GetExceptions();
  976. pPattern->RemoveAllExceptions();
  978. int nCount = prtExceptions ? prtExceptions->GetCount() : 0;
  979. for (int i = 0; i < nCount; i++)
  980. {
  981. CXTPCalendarEvent* pExc = prtExceptions->GetAt(i);
  982. ASSERT(pExc);
  983. if (!pExc)
  984. continue;
  986. DWORD dwNewEventID = XTP_CALENDAR_UNKNOWN_EVENT_ID;
  987. if (!DoCreate_Event(pExc, dwNewEventID))
  988. {
  989. bResult = FALSE;
  990. continue;
  991. }
  992. ASSERT(dwNewEventID != XTP_CALENDAR_UNKNOWN_EVENT_ID);
  993. pExc->SetEventID(dwNewEventID);
  995. pPattern->SetException(pExc);
  996. }
  997. //-------------------------------------------
  998. return bResult;
  999. }
  1001. BOOL CXTPCalendarData::_RemoveRPatternWithExceptions(CXTPCalendarRecurrencePattern* pPattern)
  1002. {
  1003. if (!IsOpen())
  1004. {
  1005. return FALSE;
  1006. }
  1007. if (!pPattern)
  1008. {
  1009. ASSERT(FALSE);
  1010. return FALSE;
  1011. }
  1013. BOOL bResult = TRUE;
  1014. //-- Process exceptions ---------------------------------------------------
  1015. CXTPCalendarEventsPtr prtExceptions = pPattern->GetExceptions();
  1017. int nCount = prtExceptions ? prtExceptions->GetCount() : 0;
  1018. for (int i = 0; i < nCount; i++)
  1019. {
  1020. CXTPCalendarEvent *pExc = prtExceptions->GetAt(i);
  1021. ASSERT(pExc);
  1022. if (!DoDelete_Event(pExc))
  1023. {
  1024. bResult = FALSE;
  1025. }
  1026. }
  1027. //-------------------------------------------
  1028. if (!DoDelete_RPattern(pPattern))
  1029. {
  1030. return FALSE;
  1031. }
  1033. //-------------------------------------------
  1034. return bResult;
  1035. }
  1037. BOOL CXTPCalendarData::_ChangeRPatternWithExceptions(CXTPCalendarRecurrencePattern* pPattern)
  1038. {
  1039. if (!IsOpen())
  1040. {
  1041. return FALSE;
  1042. }
  1044. if (!pPattern)
  1045. {
  1046. ASSERT(FALSE);
  1047. return FALSE;
  1048. }
  1050. DWORD dwPatternID = pPattern->GetPatternID();
  1051. //CXTPCalendarRecurrencePatternPtr ptrPatternPrev = _GetRecurrencePattern_UseCache(dwPatternID);
  1052. CXTPCalendarRecurrencePatternPtr ptrPatternPrev = GetRecurrencePattern(dwPatternID);
  1054. if (!ptrPatternPrev)
  1055. {
  1056. ASSERT(FALSE);
  1057. return FALSE;
  1058. }
  1060. //-------------------------------------
  1061. VERIFY( pPattern->GetOccReminders()->Save(pPattern->GetCustomProperties(), pPattern) );
  1063. BOOL bRes = DoUpdate_RPattern(pPattern);
  1065. pPattern->GetOccReminders()->ClearProperties(pPattern->GetCustomProperties());
  1067. if (!bRes)
  1068. {
  1069. return FALSE;
  1070. }
  1071. //-------------------------------------
  1073. BOOL bResult = TRUE;
  1074. //-- Process exceptions ---------------------------------------------------
  1075. CXTPCalendarEventsPtr prtExceptions_prev = ptrPatternPrev->GetExceptions();
  1076. CXTPCalendarEventsPtr prtExceptions_new = pPattern->GetExceptions();
  1078. //-- find deleted exceptions and remove them from DB
  1079. int nCount = (prtExceptions_prev && prtExceptions_new) ? prtExceptions_prev->GetCount() : 0;
  1080. int i;
  1081. for (i = 0; i < nCount; i++)
  1082. {
  1083. CXTPCalendarEvent* pExc = prtExceptions_prev->GetAt(i);
  1084. DWORD dwExcID = pExc ? pExc->GetEventID() : XTP_CALENDAR_UNKNOWN_EVENT_ID;
  1085. int nFIndex = prtExceptions_new->Find(dwExcID);
  1086. if (nFIndex < 0)
  1087. {
  1088. if (!DoDelete_Event(pExc))
  1089. {
  1090. bResult = FALSE;
  1091. }
  1092. }
  1093. }
  1095. //-- update existing or add new exceptions (int DB)
  1096. nCount = (prtExceptions_prev && prtExceptions_new) ? prtExceptions_new->GetCount() : 0;
  1097. for (i = 0; i < nCount; i++)
  1098. {
  1099. CXTPCalendarEvent* pExc = prtExceptions_new->GetAt(i);
  1100. if (!pExc)
  1101. {
  1102. ASSERT(FALSE);
  1103. continue;
  1104. }
  1106. DWORD dwExcID = pExc->GetEventID();
  1108. int nFIndex = prtExceptions_prev->Find(dwExcID);
  1110. if (nFIndex < 0)
  1111. {
  1112. // Add new exception
  1113. DWORD dwNewEventID = XTP_CALENDAR_UNKNOWN_EVENT_ID;
  1114. if (!DoCreate_Event(pExc, dwNewEventID))
  1115. {
  1116. bResult = FALSE;
  1117. continue;
  1118. }
  1119. ASSERT(dwNewEventID != XTP_CALENDAR_UNKNOWN_EVENT_ID);
  1120. pExc->SetEventID(dwNewEventID);
  1122. VERIFY( pPattern->RemoveException(pExc) );
  1123. if (!pPattern->SetException(pExc))
  1124. {
  1125. bResult = FALSE;
  1126. }
  1127. }
  1128. else
  1129. {
  1130. // Update existing exception
  1131. if (!DoUpdate_Event(pExc))
  1132. {
  1133. bResult = FALSE;
  1134. }
  1135. }
  1136. }
  1138. return bResult;
  1139. }
  1141. BOOL CXTPCalendarData::_ChangeRExceptionOccurrence_nf(CXTPCalendarEvent* pExcOcc,
  1142.  BOOL bSend_EventDeleted)
  1143. {
  1144. if (!pExcOcc)
  1145. {
  1146. ASSERT(FALSE);
  1147. return FALSE;
  1148. }
  1150. pExcOcc->ClearIntermediateData();
  1152. DWORD dwEventID = pExcOcc->GetEventID();
  1153. ASSERT(dwEventID != XTP_CALENDAR_UNKNOWN_EVENT_ID);
  1155. //- new recurrence state ---------------------------
  1156. CXTPCalendarRecurrencePatternPtr ptrPattern;
  1158. int nRState_new = pExcOcc->GetRecurrenceState();
  1160. // - Add/Update/Remove Recurrence Exception --------------------
  1161. if (nRState_new != xtpCalendarRecurrenceException &&
  1162. nRState_new != xtpCalendarRecurrenceOccurrence)
  1163. {
  1164. ASSERT(FALSE);
  1165. return FALSE;
  1166. }
  1168. DWORD dwPatternID_new = pExcOcc->GetRecurrencePatternID();
  1169. //ptrPattern = _GetRecurrencePattern_UseCache(dwPatternID_new);
  1170. ptrPattern = GetRecurrencePattern(dwPatternID_new);
  1171. if (!ptrPattern)
  1172. {
  1173. ASSERT(FALSE);
  1174. return FALSE;
  1175. }
  1177. DWORD dwMasterEventID = ptrPattern->GetMasterEventID();
  1178. //CXTPCalendarEventPtr ptrMasterEvent = _GetEvent_UseCache(dwMasterEventID);
  1179. CXTPCalendarEventPtr ptrMasterEvent = GetEvent(dwMasterEventID);
  1180. if (!ptrMasterEvent)
  1181. {
  1182. ASSERT(FALSE);
  1183. return FALSE;
  1184. }
  1186. ptrPattern.SetPtr(ptrMasterEvent->GetRPatternRef(), TRUE);
  1188. if (!ptrPattern)
  1189. {
  1190. ASSERT(FALSE);
  1191. return FALSE;
  1192. }
  1194. BOOL bSendPatternChangedEvent = FALSE;
  1195. BOOL bRes = FALSE;
  1196. if (nRState_new == xtpCalendarRecurrenceException)
  1197. {
  1198. bRes = ptrPattern->SetException(pExcOcc, ptrMasterEvent);
  1199. }
  1200. else if (nRState_new == xtpCalendarRecurrenceOccurrence)
  1201. {
  1202. bRes = ptrPattern->RemoveException(pExcOcc, ptrMasterEvent);
  1203. }
  1204. else
  1205. {
  1206. ASSERT(FALSE);
  1207. }
  1209. if (bRes)
  1210. {
  1211. bRes = _ChangeRPatternWithExceptions(ptrPattern);
  1212. bSendPatternChangedEvent = bRes;
  1213. }
  1214. if (bRes)
  1215. {
  1216. bRes = DoUpdate_Event(ptrMasterEvent);
  1217. }
  1219. //---------------------------------------------------------------------------
  1220. if (m_cache.m_eCacheMode == xtpCalendarDPCacheModeOnRepeat)
  1221. {
  1222. ASSERT(m_cache.m_pCacheDP);
  1223. if (m_cache.IsEventInCache(ptrMasterEvent))
  1224. {
  1225. if (m_cache.m_pCacheDP) VERIFY( m_cache.m_pCacheDP->ChangeEvent(ptrMasterEvent) );
  1226. }
  1227. }
  1228. else if (m_cache.m_eCacheMode == xtpCalendarDPCacheModeOnClear)
  1229. {
  1230. ASSERT(m_cache.m_pCacheDP);
  1231. //m_cache.m_pCacheDP->RemoveAllEvents();
  1232. m_cache.SafeRemoveAll();
  1233. }
  1234. //---------------------------------------------------------------------------
  1236. if (bRes)
  1237. {
  1238. XTP_NOTIFY_CODE nfCode = bSend_EventDeleted ?
  1239. XTP_NC_CALENDAREVENTWASDELETED : XTP_NC_CALENDAREVENTWASCHANGED;
  1240. SendNotification(nfCode, (WPARAM)pExcOcc->GetEventID(), (LPARAM)pExcOcc);
  1242. }
  1243. if (bSendPatternChangedEvent)
  1244. {
  1245. SendNotification(XTP_NC_CALENDARPATTERNWASCHANGED, ptrPattern->GetPatternID(), 0);
  1246. }
  1248. return bRes;
  1249. }
  1251. void CXTPCalendarData::_PostProcessOccurrencesFromMaster(COleDateTime dtDay, CXTPCalendarEvents* pEvents)
  1252. {
  1253. _PostProcessOccurrencesFromMaster2(dtDay, dtDay, pEvents);
  1254. }
  1256. void CXTPCalendarData::_PostProcessOccurrencesFromMaster2(COleDateTime dtDayFrom, COleDateTime dtDayTo, CXTPCalendarEvents* pEvents)
  1257. {
  1258. if (!pEvents)
  1259. {
  1260. return;
  1261. }
  1262. int nCount = pEvents->GetCount();
  1263. for (int i = nCount-1; i >= 0; i--)
  1264. {
  1265. CXTPCalendarEventPtr ptrEvent = pEvents->GetAt(i, TRUE);
  1266. if (!ptrEvent)
  1267. {
  1268. ASSERT(FALSE);
  1269. continue;
  1270. }
  1272. int nRState = ptrEvent->GetRecurrenceState();
  1273. if (xtpCalendarRecurrenceMaster == nRState)
  1274. {
  1275. pEvents->RemoveAt(i);
  1277. CXTPCalendarRecurrencePattern* pPattern = ptrEvent->GetRPatternRef();
  1278. if (!pPattern)
  1279. {
  1280. ASSERT(FALSE);
  1281. continue;
  1282. }
  1284. VERIFY(pPattern->GetOccurrences(pEvents, dtDayFrom, dtDayTo, ptrEvent));
  1285. }
  1286. }
  1287. }
  1289. void CXTPCalendarData::_FilterDayEventsInstancesByEndTime(COleDateTime dtDay,
  1290. CXTPCalendarEvents* pEvents)
  1291. {
  1292. ASSERT(pEvents);
  1293. if (!pEvents)
  1294. {
  1295. return;
  1296. }
  1297. dtDay = CXTPCalendarUtils::ResetTime(dtDay);
  1299. // filter events;
  1300. int nCount = pEvents->GetCount();
  1301. for (int i = nCount-1; i >= 0; i--)
  1302. {
  1303. CXTPCalendarEvent* pEvent = pEvents->GetAt(i);
  1304. if (!pEvent)
  1305. {
  1306. ASSERT(FALSE);
  1307. continue;
  1308. }
  1309. if (pEvent->GetRecurrenceState() == xtpCalendarRecurrenceMaster)
  1310. {
  1311. continue;
  1312. }
  1314. if (CXTPCalendarUtils::ResetTime(pEvent->GetStartTime()) < dtDay &&
  1315. CXTPCalendarUtils::IsEqual(pEvent->GetEndTime(), dtDay) )
  1316. {
  1317. pEvents->RemoveAt(i);
  1318. }
  1319. }
  1320. }
  1323. void CXTPCalendarData::SendNotification(XTP_NOTIFY_CODE EventCode, WPARAM wParam , LPARAM lParam)
  1324. {
  1325. if (m_pConnect && !m_bDisableNotificationsSending)
  1326. {
  1327. m_pConnect->SendEvent(EventCode, wParam, lParam);
  1328. }
  1329. }
  1331. CXTPCalendarEventsPtr CXTPCalendarData::GetUpcomingEvents(COleDateTime dtFrom, COleDateTimeSpan spPeriod)
  1332. {
  1333. CXTPCalendarEventsPtr ptrEvents = DoGetUpcomingEvents(dtFrom, spPeriod);
  1335. _PostProcessRecurrenceIfNeed(ptrEvents);
  1336. return ptrEvents;
  1337. }
  1339. CXTPCalendarEventsPtr CXTPCalendarData::GetAllEvents_raw()
  1340. {
  1341. CXTPCalendarEventsPtr ptrEvents = DoGetAllEvents_raw();
  1343. _PostProcessRecurrenceIfNeed(ptrEvents);
  1344. return ptrEvents;
  1345. }
  1347. void CXTPCalendarData::SetOptionsToUpdate(CXTPCalendarOptions* pOptions)
  1348. {
  1349. CMDTARGET_ADDREF(pOptions);
  1350. CMDTARGET_RELEASE(m_pCalendarOptions);
  1351. m_pCalendarOptions = pOptions;
  1352. }
  1354. CXTPCalendarEventsPtr CXTPCalendarData::DoGetAllEvents_raw()
  1355. {
  1356. return NULL;
  1357. }
  1359. CXTPCalendarEventsPtr CXTPCalendarData::DoGetUpcomingEvents(
  1360. COleDateTime dtFrom, COleDateTimeSpan spPeriod)
  1361. {
  1362. UNREFERENCED_PARAMETER(dtFrom); UNREFERENCED_PARAMETER(spPeriod);
  1363. //return DoRetrieveAllEvents_raw();
  1364. return NULL;
  1365. }
  1367. CXTPCalendarEventsPtr CXTPCalendarData::DoRetrieveDayEvents(COleDateTime dtDay)
  1368. {
  1369. UNREFERENCED_PARAMETER(dtDay);
  1370. return NULL;
  1371. }
  1373. void CXTPCalendarData::DoRemoveAllEvents()
  1374. {
  1375. }
  1377. CXTPCalendarEventPtr CXTPCalendarData::DoRead_Event(DWORD dwEventID)
  1378. {
  1379. UNREFERENCED_PARAMETER(dwEventID);
  1380. return NULL;
  1381. }
  1383. CXTPCalendarRecurrencePatternPtr CXTPCalendarData::DoRead_RPattern(DWORD dwPatternID)
  1384. {
  1385. UNREFERENCED_PARAMETER(dwPatternID);
  1386. return NULL;
  1387. }
  1389. BOOL CXTPCalendarData::DoCreate_Event(CXTPCalendarEvent* pEvent, DWORD& rdwNewEventID)
  1390. {
  1391. UNREFERENCED_PARAMETER(pEvent);
  1392. UNREFERENCED_PARAMETER(rdwNewEventID);
  1393. return TRUE;
  1394. }
  1396. BOOL CXTPCalendarData::DoUpdate_Event(CXTPCalendarEvent* pEvent)
  1397. {
  1398. UNREFERENCED_PARAMETER(pEvent);
  1399. return TRUE;
  1400. }
  1402. BOOL CXTPCalendarData::DoDelete_Event(CXTPCalendarEvent* pEvent)
  1403. {
  1404. UNREFERENCED_PARAMETER(pEvent);
  1405. return TRUE;
  1406. }
  1408. BOOL CXTPCalendarData::DoCreate_RPattern(CXTPCalendarRecurrencePattern* pPattern, DWORD& rdwNewPatternID)
  1409. {
  1410. UNREFERENCED_PARAMETER(pPattern);
  1411. UNREFERENCED_PARAMETER(rdwNewPatternID);
  1412. return TRUE;
  1413. }
  1415. BOOL CXTPCalendarData::DoUpdate_RPattern(CXTPCalendarRecurrencePattern* pPattern)
  1416. {
  1417. UNREFERENCED_PARAMETER(pPattern);
  1418. return TRUE;
  1419. }
  1421. BOOL CXTPCalendarData::DoDelete_RPattern(CXTPCalendarRecurrencePattern* pPattern)
  1422. {
  1423. UNREFERENCED_PARAMETER(pPattern);
  1424. return TRUE;
  1425. }