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

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

对话框与窗口

开发平台：

Visual C++

XTPCalendarMemoryDataProvider.cpp：源码内容
  1. // XTPCalendarMemoryDataProvider.cpp: implementation of the CXTPCalendarMemoryDataProvider 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"
  22. #include "XTPCalendarMemoryDataProvider.h"
  23. #include "XTPCalendarEvents.h"
  24. #include "XTPCalendarEvent.h"
  25. #include "XTPCalendarRecurrencePattern.h"
  26. #include "XTPCalendarNotifications.h"
  27. #include "XTPCalendarControl.h"
  28. #include "XTPCalendarResource.h"
  29. #include "Common/XTPPropExchange.h"
  31. #define _XML_FILE
  33. #ifdef _DEBUG
  34. #define new DEBUG_NEW
  35. #undef THIS_FILE
  36. static char THIS_FILE[] = __FILE__;
  37. #endif
  39. #define XTP_MEM_DP_DATA_VER 1
  41. //===========================================================================
  42. //    Should be a prime number:
  43. // 37, 53, 67, 79, 101, 127, 199, 503, 1021, 1511, 2003, 3001
  44. //===========================================================================
  45. #define XTP_MEMDP_TMP_HASH_TABLE_SIZE 67
  47. //{{AFX_CODEJOCK_PRIVATE
  48. class CXTPCalendarEventHelper : public CXTPCalendarEvent
  49. {
  50. public:
  51. virtual CXTPCalendarRecurrencePattern* GetRPatternRef()
  52. {
  53. return CXTPCalendarEvent::GetRPatternRef();
  54. }
  55. };
  56. //}}AFX_CODEJOCK_PRIVATE
  58. /////////////////////////////////////////////////////////////////////////////
  59. // CXTPCalendarMemoryDataProvider implementation
  60. /////////////////////////////////////////////////////////////////////////////
  62. IMPLEMENT_DYNAMIC(CXTPCalendarMemoryDataProvider, CXTPCalendarData)
  64. //////////////////////////////////////////////////////////////////////
  65. CXTPCalendarMemoryDataProvider::CXTPCalendarMemoryDataProvider() :
  66. m_EventsStorage(XTP_EVENTS_STORAGE_HASH_TABLE_SIZE)
  67. {
  68. m_typeProvider = xtpCalendarDataProviderMemory;
  69. }
  71. CXTPCalendarMemoryDataProvider::~CXTPCalendarMemoryDataProvider()
  72. {
  73. }
  75. CString CXTPCalendarMemoryDataProvider::GetXMLEncoding()
  76. {
  77. CString strConnStr_lower = m_strConnectionString;
  78. strConnStr_lower.MakeLower();
  80. int nIndex = strConnStr_lower.Find(_T("encoding="));
  81. if (nIndex == -1)
  82. return _T("UTF-8");
  84. CString strEncoding = m_strConnectionString.Mid(nIndex + 9);
  86. nIndex = strEncoding.Find(_T(';'));
  87. if (nIndex != -1)
  88. strEncoding = strEncoding.Left(nIndex);
  90. return strEncoding;
  91. }
  93. BOOL CXTPCalendarMemoryDataProvider::IsProviderXML(BOOL bCheckXMLsupport, BOOL* pbXMLsupportError)
  94. {
  95. if (pbXMLsupportError)
  96. {
  97. *pbXMLsupportError = FALSE;
  98. }
  100. CString strConnStr_lower = m_strConnectionString;
  101. strConnStr_lower.MakeLower();
  103. if (strConnStr_lower.IsEmpty())
  104. return FALSE;
  106. if (strConnStr_lower.Find(_T("provider=xml")) == -1)
  107. return FALSE;
  109. if (bCheckXMLsupport)
  110. {
  111. CXTPDOMDocumentPtr xmlDocPtr;
  112. BOOL bCreated = SUCCEEDED(xmlDocPtr.CreateInstance(CLSID_XTPDOMDocument));
  114. if (pbXMLsupportError)
  115. {
  116. *pbXMLsupportError = !bCreated;
  117. }
  118. return bCreated;
  120. }
  122. return TRUE;
  123. }
  126. BOOL CXTPCalendarMemoryDataProvider::Open()
  127. {
  128. CString strFileName = GetDataSource();
  130. const int cnErrSize = 4096;
  131. TCHAR szError[cnErrSize+1];
  132. ZeroMemory(szError, sizeof(szError));
  134. CXTPCalendarData::Open();
  135. RemoveAllEvents();
  137. if (strFileName.IsEmpty())
  138. {
  139. return TRUE;
  140. }
  141. BOOL bResult = TRUE;
  143. try
  144. {
  145. BOOL bXMLsupportError = FALSE;
  146. if (!IsProviderXML(TRUE, &bXMLsupportError))
  147. {
  148. if (bXMLsupportError)
  149. {
  150. TRACE(_T("Warning: CXTPCalendarMemoryDataProvider::Open() cannot create XML parcer instance.n"));
  151. TRACE(_T("tperhaps AfxOleInit() has not been called, or msxml3.dll not found. n"));
  152. TRACE(_T("tThe binary data format is used. n."));
  153. }
  155. CFile fileData(strFileName, CFile::modeRead);
  157. if (fileData.GetLength() >= 8)
  158. {
  159. CArchive arData(&fileData, CArchive::load);
  160. CXTPPropExchangeArchive px(arData);
  161. bResult = _Load(&px);
  162. }
  163. }
  164. else
  165. {
  166. bResult = FALSE;
  167. #ifndef _XTP_EXCLUDE_XML
  168. CXTPPropExchangeXMLNode px(TRUE, 0, _T("Calendar"));
  169. px.SetEncoding(GetXMLEncoding());
  170. if (px.LoadFromFile(strFileName))
  171. {
  172. bResult = _Load(&px);
  173. }
  174. #else
  175. //bResult = FALSE;
  176. #endif
  177. }
  178. }
  179. catch(CFileException* pEfile)
  180. {
  181. if (pEfile->GetErrorMessage(szError, cnErrSize))
  182. {
  183. TRACE(_T("WARNING! MemoryDataProvider: Load Events data file error: %s n"), szError);
  184. }
  185. pEfile->Delete();
  186. bResult = FALSE;
  187. }
  188. catch(CArchiveException* pEarc)
  189. {
  190. if (pEarc->GetErrorMessage(szError, cnErrSize))
  191. {
  192. TRACE(_T("WARNING! MemoryDataProvider: Load Events data archive error: %s n"), szError);
  193. }
  194. //pEarc->ReportError();
  195. pEarc->Delete();
  196. bResult = FALSE;
  197. }
  198. catch(_com_error& e)
  199. {
  200. const TCHAR* pErrStr = e.ErrorMessage();
  202. if (pErrStr)
  203. {
  204. TRACE(_T("WARNING! MemoryDataProvider: Store Events data COM error: %s n"), pErrStr);
  205. }
  206. bResult = FALSE;
  207. }
  209. if (!bResult)
  210. {
  211. CXTPCalendarData::Close();
  212. }
  213. return bResult;
  214. }
  216. BOOL CXTPCalendarMemoryDataProvider::Create()
  217. {
  218. CXTPCalendarData::Create();
  220. return Save();
  221. }
  223. BOOL CXTPCalendarMemoryDataProvider::Save()
  224. {
  225. CString strFileName = GetDataSource();
  227. if (strFileName.IsEmpty())
  228. {
  229. return TRUE;
  230. }
  232. const int cnErrSize = 4096;
  233. TCHAR szError[cnErrSize+1];
  234. ZeroMemory(szError, sizeof(szError));
  236. try
  237. {
  238. BOOL bXMLsupportError = FALSE;
  239. if (!IsProviderXML(TRUE, &bXMLsupportError))
  240. {
  241. if (bXMLsupportError)
  242. {
  243. TRACE(_T("Warning: CXTPCalendarMemoryDataProvider::Save() cannot create XML parcer instance.n"));
  244. TRACE(_T("tperhaps AfxOleInit() has not been called, or msxml3.dll not found. n"));
  245. TRACE(_T("tThe binary data format is used. n."));
  246. }
  248. CFile fileData(strFileName, CFile::modeWrite | CFile::modeCreate);
  249. CArchive arData(&fileData, CArchive::store);
  251. CXTPPropExchangeArchive px(arData);
  252. _Save(&px);
  253. }
  254. else
  255. {
  256. #ifndef _XTP_EXCLUDE_XML
  257. CXTPPropExchangeXMLNode px(FALSE, 0, _T("Calendar"));
  258. px.SetEncoding(GetXMLEncoding());
  259. _Save(&px);
  260. px.SaveToFile(strFileName);
  261. #else
  262. return FALSE;
  263. #endif
  264. }
  266. }
  267. catch(CFileException* pEfile)
  268. {
  269. if (pEfile->GetErrorMessage(szError, cnErrSize))
  270. {
  271. TRACE(_T("WARNING! MemoryDataProvider: Store Events data file error: %s n"), szError);
  272. }
  273. pEfile->Delete();
  274. return FALSE;
  275. }
  276. catch(CArchiveException* pEarc)
  277. {
  278. if (pEarc->GetErrorMessage(szError, cnErrSize))
  279. {
  280. TRACE(_T("WARNING! MemoryDataProvider: Store Events data archive error: %s n"), szError);
  281. }
  282. pEarc->Delete();
  283. return FALSE;
  284. }
  285. catch(_com_error& e)
  286. {
  287. const TCHAR* pErrStr = e.ErrorMessage();
  289. if (pErrStr)
  290. {
  291. TRACE(_T("WARNING! MemoryDataProvider: Store Events data COM error: %s n"), pErrStr);
  292. }
  293. return FALSE;
  294. }
  296. return TRUE;
  297. }
  299. void CXTPCalendarMemoryDataProvider::Close()
  300. {
  301. if (!IsOpen())
  302. {
  303. CXTPCalendarData::Open();
  304. }
  306. RemoveAllEvents();
  308. CXTPCalendarData::Close();
  309. }
  311. CXTPCalendarEventsPtr CXTPCalendarMemoryDataProvider::DoRetrieveDayEvents(COleDateTime dtDay)
  312. {
  313. CXTPCalendarEventsPtr ptrEvents = new CXTPCalendarEvents;
  314. if (!ptrEvents)
  315. {
  316. return NULL;
  317. }
  318. m_tree.SearchForEvents((DWORD)dtDay, (DWORD)dtDay, ptrEvents);
  320. _PostProcessOccurrencesFromMaster2(dtDay, dtDay, ptrEvents);
  322. // call this function here to increase performance (to avoid clone events which will be removed)
  323. _FilterDayEventsInstancesByEndTime(dtDay, ptrEvents);
  325. ptrEvents->CloneEvents();
  327. return ptrEvents;
  328. }
  330. CXTPCalendarEventsPtr CXTPCalendarMemoryDataProvider::RetrieveEvents(COleDateTime dtStartDay, COleDateTime dtEndDay)
  331. {
  332. CXTPCalendarEventsPtr ptrEvents= new CXTPCalendarEvents;
  333. if (!ptrEvents)
  334. return NULL;
  336. m_tree.SearchForEvents((DWORD)dtStartDay, (DWORD)dtEndDay, ptrEvents);
  338. _PostProcessOccurrencesFromMaster2(dtStartDay, dtEndDay, ptrEvents);
  340. // to remove multiday events which end day is dtStartDay.
  341. _FilterDayEventsInstancesByEndTime(dtStartDay, ptrEvents);
  343. ptrEvents->CloneEvents();
  345. return ptrEvents;
  346. }
  348. CXTPCalendarEventsPtr CXTPCalendarMemoryDataProvider::DoGetAllEvents_raw()
  349. {
  350. CXTPCalendarEventsPtr ptrArray = new CXTPCalendarEvents();
  351. if (!ptrArray)
  352. return NULL;
  354. POSITION pos = m_EventsStorage.GetStartPosition();
  355. while (pos)
  356. {
  357. DWORD dwID = 0;
  358. CXTPCalendarEvent* pEvent = m_EventsStorage.GetNextElement(pos, dwID);
  359. if (pEvent)
  360. {
  361. ptrArray->Add(pEvent, TRUE);
  362. }
  363. }
  365. ptrArray->CloneEvents();
  367. return ptrArray;
  368. }
  370. CXTPCalendarEventsPtr CXTPCalendarMemoryDataProvider::DoGetUpcomingEvents(
  371. COleDateTime dtFrom, COleDateTimeSpan spPeriod)
  372. {
  373. UNREFERENCED_PARAMETER(dtFrom); UNREFERENCED_PARAMETER(spPeriod);
  374. return DoGetAllEvents_raw();
  375. }
  378. //////////////////////////////////////////////////////////////////////////
  379. //
  380. // Internal search algorithms and structures
  381. //
  382. //////////////////////////////////////////////////////////////////////////
  383. // DSTNode
  384. //////////////////////////////////////////////////////////////////////////
  385. CXTPCalendarMemoryDataProvider::DSTNode::DSTNode() :
  386. m_pMapEvents(NULL), pLeft(NULL), pRight(NULL)
  387. {}
  389. CXTPCalendarMemoryDataProvider::DSTNode::~DSTNode()
  390. {
  391. if (m_pMapEvents)
  392. delete m_pMapEvents;
  393. if (pLeft)
  394. delete pLeft;
  395. if (pRight)
  396. delete pRight;
  397. }
  398. void CXTPCalendarMemoryDataProvider::DSTNode::Mark(CXTPCalendarEvent* pEvent)
  399. {
  400. if (!m_pMapEvents)
  401. {
  402. m_pMapEvents = new EventsMap;
  404. if (!m_pMapEvents) {
  405. return;
  406. }
  407. }
  408. m_pMapEvents->SetAt(pEvent, TRUE);
  409. }
  410. void CXTPCalendarMemoryDataProvider::DSTNode::Unmark(CXTPCalendarEvent* pEvent)
  411. {
  412. if (m_pMapEvents)
  413. {
  414. m_pMapEvents->RemoveKey(pEvent);
  415. }
  416. }
  417. BOOL CXTPCalendarMemoryDataProvider::DSTNode::IsMarked(CXTPCalendarEvent* pEvent)
  418. {
  419. if (m_pMapEvents)
  420. {
  421. BOOL bValue;
  422. return m_pMapEvents->Lookup(pEvent, bValue);
  423. }
  424. return FALSE;
  425. }
  428. void CXTPCalendarMemoryDataProvider::DSTNode::AppendAll(CMapIDtoEvent* pMapEvents)
  429. {
  430. if (!pMapEvents || !m_pMapEvents)
  431. return;
  433. // enumerate all elements of the map
  434. POSITION pos = m_pMapEvents->GetStartPosition();
  435. BOOL bMark;
  436. CXTPCalendarEvent* pEvent = NULL;
  437. while (pos != NULL)
  438. {
  439. m_pMapEvents->GetNextAssoc(pos, pEvent, bMark);
  440. if (bMark && pEvent)
  441. {
  442. pMapEvents->SetAt(pEvent->GetEventID(),  pEvent);
  443. }
  444. }
  446. }
  447. //////////////////////////////////////////////////////////////////////////
  448. // DST
  449. //////////////////////////////////////////////////////////////////////////
  450. const int xtpBitsScan = sizeof(DWORD) * 8 - 1;
  452. CXTPCalendarMemoryDataProvider::DST::DST() :
  453. tmp_mapEvents(64)
  454. {
  455. pHead = new DSTNode();
  457. tmp_mapEvents.InitHashTable(XTP_MEMDP_TMP_HASH_TABLE_SIZE, FALSE);
  458. }
  460. CXTPCalendarMemoryDataProvider::DST::~DST()
  461. {
  462. if (pHead)
  463. delete pHead;
  464. }
  466. void CXTPCalendarMemoryDataProvider::DST::Insert(CXTPCalendarEvent* pEvent)
  467. {
  468. MarkRange(pEvent, dstScanMark);
  469. }
  471. void CXTPCalendarMemoryDataProvider::DST::Remove(CXTPCalendarEvent* pEvent)
  472. {
  473. MarkRange(pEvent, dstScanUnmark);
  474. }
  476. void CXTPCalendarMemoryDataProvider::DST::Clear()
  477. {
  478. if (pHead)
  479. delete pHead;
  481. pHead = new DSTNode();
  482. }
  484. void CXTPCalendarMemoryDataProvider::DST::MarkRange(CXTPCalendarEvent* pEvent, const DSTScanType eScanType)
  485. {
  486. DWORD dwStartDay = (DWORD)pEvent->GetStartTime();
  487. DWORD dwEndDay = (DWORD)pEvent->GetEndTime();
  489. ScanRange(pHead, xtpBitsScan - 1, 0, (DWORD)(1 << xtpBitsScan),
  490.   dwStartDay, dwEndDay,
  491.   pEvent, NULL, eScanType);
  492. }
  494. void CXTPCalendarMemoryDataProvider::DST::SearchForEvents(DWORD dwStart, DWORD dwEnd, CXTPCalendarEvents* pEvents)
  495. {
  496. if (!pEvents)
  497. return;
  499. tmp_mapEvents.RemoveAll();
  501. ScanRange(pHead, xtpBitsScan - 1, 0, (DWORD)(1 << xtpBitsScan),
  502.   dwStart, dwEnd,
  503.   NULL, &tmp_mapEvents, dstScanFind);
  506. // move events from temp map to array
  507. int nCount = (int)tmp_mapEvents.GetCount();
  508. if (nCount)
  509. {
  510. int nIndex = pEvents->GetCount();
  511. pEvents->SetSize(nIndex + nCount); // to avoid multi-reallocks
  513. DWORD dwKey;
  514. CXTPCalendarEvent* pEvent;
  515. POSITION pos = tmp_mapEvents.GetStartPosition();
  516. while(pos)
  517. {
  518. tmp_mapEvents.GetNextAssoc(pos, dwKey, pEvent);
  519. ASSERT(pEvent);
  520. if (pEvent)
  521. pEvents->SetAt(nIndex, pEvent, TRUE);
  523. nIndex++;
  524. }
  525. ASSERT(nIndex == pEvents->GetCount());
  527. tmp_mapEvents.RemoveAll();
  528. }
  529. }
  531. void CXTPCalendarMemoryDataProvider::DST::ScanRange(
  532. DSTNode* const pNode, const int nDepth,
  533. const DWORD dwMinValue, const DWORD dwMaxValue,
  534. const DWORD dwStart, const DWORD dwEnd,
  535. CXTPCalendarEvent* const pEvent, CMapIDtoEvent* pMapEvents,
  536. const DSTScanType eScanType)
  537. {
  538. DWORD dwMediumValue = dwMinValue | (nDepth >= 0 ? 1 << nDepth : 0);
  540. switch(eScanType)
  541. {
  542. case dstScanMark:
  543. case dstScanUnmark:
  544. // check if range contained in the min-max range
  545. if (dwStart <= dwMinValue && dwEnd >= dwMaxValue - 1)
  546. {
  547. switch(eScanType)
  548. {
  549. case dstScanMark:
  550. // Add this event to this entire range node.
  551. pNode->Mark(pEvent);
  552. return;
  553. case dstScanUnmark:
  554. // Delete this event from this entire range node.
  555. pNode->Unmark(pEvent);
  556. return;
  557. }
  558. }
  559. break;
  560. case dstScanFind:
  561. if (dwEnd >= dwMinValue && dwStart < dwMaxValue)
  562. {
  563. pNode->AppendAll(pMapEvents);
  564. }
  565. break;
  566. }
  568. // check for end recursion
  569. if (nDepth < 0)
  570. return;
  572. // run left search
  573. if (dwStart <= dwMediumValue)
  574. {
  575. if (!pNode->pLeft && eScanType == dstScanMark)
  576. pNode->pLeft = new DSTNode();
  578. if (pNode->pLeft)
  579. {
  580. ScanRange(pNode->pLeft, nDepth - 1,
  581.   dwMinValue, dwMediumValue,
  582.   dwStart, dwEnd,
  583.   pEvent, pMapEvents,
  584.   eScanType);
  585. }
  586. }
  588. // run right search
  589. if (dwEnd >= dwMediumValue)
  590. {
  591. if (!pNode->pRight && eScanType == dstScanMark)
  592. pNode->pRight = new DSTNode;
  594. if (pNode->pRight)
  595. {
  596. ScanRange(pNode->pRight, nDepth - 1,
  597.   dwMediumValue, dwMaxValue,
  598.   dwStart, dwEnd,
  599.   pEvent, pMapEvents,
  600.   eScanType);
  601. }
  602. }
  604. }
  606. ////////////////////////////////////////////////////////////////////////////
  607. void CXTPCalendarMemoryDataProvider::Serialize(CArchive& ar)
  608. {
  609. CXTPPropExchangeArchive px(ar);
  610. DoPropExchange(&px);
  611. }
  612. void CXTPCalendarMemoryDataProvider::DoPropExchange(CXTPPropExchange* pPX)
  613. {
  614. if (pPX->IsLoading())
  615. {
  616. VERIFY(_Load(pPX));
  617. }
  618. else
  619. {
  620. VERIFY(_Save(pPX));
  621. }
  622. }
  624. BOOL CXTPCalendarMemoryDataProvider::_Load(CXTPPropExchange* pPX)
  625. {
  626. //------------------------------------
  627. // - File data ver
  628. //
  629. // ..... - Events one by one
  630. //
  631. // a) MasterEvent
  632. // b) RecurrencePttern
  633. // c) DWORD - Exceptions count
  634. // d) ..... - RecurrencePttern_Exceptions one by one
  635. //
  636. // ..... - Events one by one
  637. //
  639. CXTPAutoResetValue<BOOL> autoReset(m_bDisableNotificationsSending, FALSE);
  640. m_bDisableNotificationsSending = TRUE;
  642. long nSchema = 0;
  644. PX_Long(pPX, _T("Version"), (long&)nSchema);
  645. pPX->ExchangeLocale();
  647. if (nSchema != XTP_MEM_DP_DATA_VER)
  648. {
  649. //AfxMessageBox(_T("Unsupported data file version."));
  650. TRACE(_T("ERROR! MemoryDataProvider: Unsupported data file version. (%d) n"), nSchema);
  651. return FALSE;
  652. }
  654. CXTPPropExchangeSection secOptions(pPX->GetSection(_T("Options")));
  655. if (m_pCalendarOptions)
  656. {
  657. m_pCalendarOptions->DoPropExchange(&secOptions);
  658. }
  660. CXTPPropExchangeSection sec(pPX->GetSection(_T("Events")));
  661. CXTPPropExchangeEnumeratorPtr pEnumerator(sec->GetEnumerator(_T("Event")));
  662. POSITION pos = pEnumerator->GetPosition();
  664. DWORD dwMinEventID = (DWORD)-1;
  666. while (pos)
  667. {
  668. CXTPCalendarEventPtr ptrEvent = CreateNewEvent();
  669. if (!ptrEvent)
  670. {
  671. return FALSE;
  672. }
  673. CXTPPropExchangeSection secEvent(pEnumerator->GetNext(pos));
  674. ptrEvent->DoPropExchange(&secEvent);
  676. dwMinEventID = min(dwMinEventID, ptrEvent->GetEventID());
  678. int nRecState = ptrEvent->GetRecurrenceState();
  679. ASSERT(nRecState == xtpCalendarRecurrenceMaster || nRecState == xtpCalendarRecurrenceNotRecurring);
  681. if (nRecState == xtpCalendarRecurrenceMaster)
  682. {
  683. CXTPCalendarRecurrencePatternPtr ptrPattern = ptrEvent->GetRecurrencePattern();
  684. if (!ptrPattern || !ptrPattern)
  685. {
  686. ASSERT(FALSE);
  687. continue;
  688. }
  690. CXTPPropExchangeSection secPattern(secEvent->GetSection(_T("Pattern")));
  691. ptrPattern->DoPropExchange(&secPattern);
  693. DWORD dwPatternID = ptrPattern->GetPatternID();
  694. dwMinEventID = min(dwMinEventID, dwPatternID);
  696. CXTPPropExchangeEnumeratorPtr pEnumeratorExc(secPattern->GetEnumerator(_T("Exception")));
  697. POSITION posExc = pEnumeratorExc->GetPosition();
  699. while (posExc)
  700. {
  701. CXTPCalendarEventPtr ptrExcept = CreateNewEvent();
  702. if (!ptrExcept)
  703. {
  704. return TRUE;
  705. }
  707. CXTPPropExchangeSection secExceptEvent(pEnumeratorExc->GetNext(posExc));
  708. ptrExcept->DoPropExchange(&secExceptEvent);
  709. dwMinEventID = min(dwMinEventID, ptrExcept->GetEventID());
  711. nRecState = ptrExcept->GetRecurrenceState();
  712. ASSERT(nRecState == xtpCalendarRecurrenceException);
  714. ptrPattern->SetException(ptrExcept);
  715. }
  717. //=======================================================
  718. ptrEvent->UpdateRecurrence(ptrPattern);
  719. }
  721. VERIFY(AddEvent(ptrEvent));
  722. }
  724. //-----------------------------------------
  725. ms_dwNextFreeTempID = dwMinEventID;
  726. GetNextFreeTempID();
  728. //=========================================
  729. if (m_pSchedules)
  730. {
  731. CXTPPropExchangeSection secSchedules(pPX->GetSection(_T("EventsSchedules")));
  732. m_pSchedules->DoPropExchange(&secSchedules);
  733. }
  735. return TRUE;
  736. }
  738. BOOL CXTPCalendarMemoryDataProvider::_Save(CXTPPropExchange* pPX)
  739. {
  740. //------------------------------------
  741. // - File data ver
  742. //
  743. // ..... - Events one by one
  744. //
  745. // a) MasterEvent
  746. // b) RecurrencePttern
  747. // c) DWORD - Exceptions count
  748. // d) ..... - RecurrencePttern_Exceptions one by one
  749. //
  750. // ..... - Events one by one
  751. //
  753. long nSchema = XTP_MEM_DP_DATA_VER;
  754. PX_Long(pPX, _T("Version"), (long&)nSchema);
  755. pPX->ExchangeLocale();
  757. CXTPPropExchangeSection secOptions(pPX->GetSection(_T("Options")));
  758. secOptions->EmptySection();
  759. if (m_pCalendarOptions)
  760. {
  761. m_pCalendarOptions->DoPropExchange(&secOptions);
  762. }
  764. CXTPPropExchangeSection sec(pPX->GetSection(_T("Events")));
  765. sec->EmptySection();
  767. CXTPPropExchangeEnumeratorPtr pEnumerator(sec->GetEnumerator(_T("Event")));
  768. POSITION posEnum = pEnumerator->GetPosition(m_EventsStorage.GetCount());
  770. POSITION pos = m_EventsStorage.GetStartPosition();
  771. while (pos)
  772. {
  773. DWORD dwId = 0;
  774. CXTPCalendarEvent* pEvent = m_EventsStorage.GetNextElement(pos, dwId);
  776. int nRecState = pEvent->GetRecurrenceState();
  777. ASSERT(nRecState == xtpCalendarRecurrenceMaster || nRecState == xtpCalendarRecurrenceNotRecurring);
  779. CXTPCalendarRecurrencePatternPtr ptrPattern;
  780. if (nRecState == xtpCalendarRecurrenceMaster)
  781. {
  782. ptrPattern = pEvent->GetRecurrencePattern();
  783. ASSERT(ptrPattern);
  784. if (ptrPattern == NULL)
  785. continue;
  786. }
  788. CXTPPropExchangeSection secEvent(pEnumerator->GetNext(posEnum));
  789. pEvent->DoPropExchange(&secEvent);
  791. if (nRecState == xtpCalendarRecurrenceMaster)
  792. {
  793. CXTPPropExchangeSection secPattern(secEvent->GetSection(_T("Pattern")));
  794. ptrPattern->DoPropExchange(&secPattern);
  796. CXTPCalendarEventsPtr ptrExceptions = ptrPattern->GetExceptions();
  798. DWORD dwExcCount = ptrExceptions ? ptrExceptions->GetCount() : 0;
  800. CXTPPropExchangeEnumeratorPtr pEnumeratorExc(secPattern->GetEnumerator(_T("Exception")));
  801. POSITION posExc = pEnumeratorExc->GetPosition(dwExcCount);
  803. for (int n = 0; n < (int)dwExcCount; n++)
  804. {
  805. CXTPCalendarEvent* pExcept = ptrExceptions->GetAt(n, FALSE);
  806. ASSERT(pExcept->GetRecurrenceState() == xtpCalendarRecurrenceException);
  808. CXTPPropExchangeSection secExceptEvent(pEnumeratorExc->GetNext(posExc));
  809. pExcept->DoPropExchange(&secExceptEvent);
  810. }
  811. }
  812. }
  814. //=========================================
  815. if (m_pSchedules)
  816. {
  817. CXTPPropExchangeSection secSchedules(pPX->GetSection(_T("EventsSchedules")));
  818. m_pSchedules->DoPropExchange(&secSchedules);
  819. }
  821. return TRUE;
  822. }
  824. void CXTPCalendarMemoryDataProvider::DoRemoveAllEvents()
  825. {
  826. m_EventsStorage.RemoveAll();
  827. m_mapPatterns.RemoveAll();
  829. m_tree.Clear();
  830. }
  832. CXTPCalendarEventPtr CXTPCalendarMemoryDataProvider::DoRead_Event(DWORD dwEventID)
  833. {
  834. CXTPCalendarEvent* pEvent = m_EventsStorage.Get(dwEventID);
  835. if (!pEvent)
  836. {
  837. return NULL;
  838. }
  840. return pEvent->CloneEvent();
  841. }
  843. CXTPCalendarRecurrencePatternPtr CXTPCalendarMemoryDataProvider::DoRead_RPattern(DWORD dwPatternID)
  844. {
  845. CXTPCalendarRecurrencePattern* pPattern = m_mapPatterns.Get(dwPatternID);
  846. if (!pPattern)
  847. {
  848. return NULL;
  849. }
  851. CXTPCalendarRecurrencePatternPtr ptrPattern2 = pPattern->ClonePattern();
  852. if (ptrPattern2)
  853. {
  854. VERIFY( pPattern->GetOccReminders()->Save(ptrPattern2->GetCustomProperties(), NULL) );
  855. }
  856. return ptrPattern2;
  857. }
  859. BOOL CXTPCalendarMemoryDataProvider::DoCreate_Event(CXTPCalendarEvent* pEvent, DWORD& rdwNewEventID)
  860. {
  861. if (!pEvent)
  862. {
  863. ASSERT(FALSE);
  864. return FALSE;
  865. }
  866. DWORD dwEventID = pEvent->GetEventID();
  868. int nRState = pEvent->GetRecurrenceState();
  869. if (nRState == xtpCalendarRecurrenceException)
  870. {
  871. rdwNewEventID = _UniqueID_Event(dwEventID);
  872. return TRUE;
  873. }
  875. ASSERT(nRState == xtpCalendarRecurrenceMaster || nRState == xtpCalendarRecurrenceNotRecurring);
  877. CXTPCalendarEventPtr ptrEvent2 = pEvent->CloneEvent();
  878. if (!ptrEvent2)
  879. {
  880. return FALSE;
  881. }
  883. rdwNewEventID = _UniqueID_Event(dwEventID);
  885. ptrEvent2->SetEventID(rdwNewEventID);
  886. pEvent->SetEventID(rdwNewEventID);
  888. dwEventID = rdwNewEventID;
  890. // add to storage
  891. m_EventsStorage.Add(dwEventID, ptrEvent2);
  893. // add to search tree
  894. m_tree.Insert(ptrEvent2);
  896. //- Process recurrence event -------------------------
  897. if (nRState == xtpCalendarRecurrenceMaster)
  898. {
  899. CXTPCalendarEventHelper* pEvent2Ex = (CXTPCalendarEventHelper*)(CXTPCalendarEvent*)ptrEvent2;
  900. CXTPCalendarRecurrencePattern* pPatternRef = pEvent2Ex->GetRPatternRef();
  901. ASSERT(pPatternRef);
  902. if (pPatternRef)
  903. {
  904. DWORD dwPatternID = ptrEvent2->GetRecurrencePatternID();
  905. DWORD dwPatternIDnew = _UniqueID_Patern(dwPatternID);
  907. ptrEvent2->SetRecurrencePatternID(dwPatternIDnew);
  908. pEvent->SetRecurrencePatternID(dwPatternIDnew);
  910. m_mapPatterns.Add(dwPatternID, pPatternRef);
  911. }
  912. }
  913. //----------------------------------------------------
  914. return TRUE;
  915. }
  917. BOOL CXTPCalendarMemoryDataProvider::DoUpdate_Event(CXTPCalendarEvent* pEvent)
  918. {
  919. DWORD dwEventID = pEvent->GetEventID();
  921. ASSERT(dwEventID != XTP_CALENDAR_UNKNOWN_EVENT_ID);
  923. //- new recurrence state ---------------------------
  924. int nRState = pEvent->GetRecurrenceState();
  926. if (nRState == xtpCalendarRecurrenceException ||
  927. nRState == xtpCalendarRecurrenceOccurrence)
  928. {
  929. ASSERT(nRState == xtpCalendarRecurrenceException);
  930. return TRUE;
  931. }
  933. //-------------------------------------------------------
  934. CXTPCalendarEventPtr ptrMainEvent(m_EventsStorage.Get(dwEventID), TRUE);
  935. if (!ptrMainEvent)
  936. {
  937. ASSERT(FALSE);
  938. return FALSE;
  939. }
  941. // update event in search tree
  942. m_tree.Remove(ptrMainEvent);
  944. VERIFY( m_EventsStorage.Remove(dwEventID) );
  945. if (ptrMainEvent->GetRecurrenceState() == xtpCalendarRecurrenceMaster)
  946. {
  947. DWORD dwPatternID = ptrMainEvent->GetRecurrencePatternID();
  948. m_mapPatterns.Remove(dwPatternID);
  949. }
  950. //******************************
  951. DWORD dwNewID;
  952. BOOL bRes = DoCreate_Event(pEvent, dwNewID);
  953. ASSERT(dwNewID == dwEventID);
  955. return bRes;
  956. }
  958. BOOL CXTPCalendarMemoryDataProvider::DoDelete_Event(CXTPCalendarEvent* pEvent)
  959. {
  960. DWORD dwEventID = pEvent->GetEventID();
  961. ASSERT(dwEventID != XTP_CALENDAR_UNKNOWN_EVENT_ID);
  963. //- new recurrence state ---------------------------
  964. int nRState = pEvent->GetRecurrenceState();
  966. if (nRState == xtpCalendarRecurrenceException ||
  967. nRState == xtpCalendarRecurrenceOccurrence)
  968. {
  969. ASSERT(nRState == xtpCalendarRecurrenceException);
  970. return TRUE;
  971. }
  973. //-------------------------------------------------------
  974. CXTPCalendarEventPtr ptrEvent(m_EventsStorage.Get(dwEventID), TRUE);
  975. if (!ptrEvent)
  976. {
  977. ASSERT(FALSE);
  978. return FALSE;
  979. }
  981. // remove event from storage
  982. BOOL bRes = m_EventsStorage.Remove(dwEventID);
  984. if (!bRes)
  985. {
  986. return FALSE;
  987. }
  988. // remove event from search tree
  989. m_tree.Remove(ptrEvent);
  991. return TRUE;
  992. }
  994. BOOL CXTPCalendarMemoryDataProvider::DoCreate_RPattern(CXTPCalendarRecurrencePattern* pPattern, DWORD& rdwNewPatternID)
  995. {
  996. if (!pPattern)
  997. {
  998. ASSERT(FALSE);
  999. return FALSE;
  1000. }
  1001. rdwNewPatternID = pPattern->GetPatternID();
  1003. CXTPCalendarRecurrencePattern* pPatternRef = m_mapPatterns.Get(rdwNewPatternID);
  1004. if (pPatternRef)
  1005. {
  1006. VERIFY( pPatternRef->Update(pPattern) );
  1007. }
  1009. return TRUE;
  1010. }
  1012. BOOL CXTPCalendarMemoryDataProvider::DoUpdate_RPattern(CXTPCalendarRecurrencePattern* pPattern)
  1013. {
  1014. if (!pPattern)
  1015. {
  1016. ASSERT(FALSE);
  1017. return FALSE;
  1018. }
  1019. DWORD dwPatternID = pPattern->GetPatternID();
  1021. ASSERT(m_mapPatterns.IsExist(dwPatternID));
  1023. CXTPCalendarRecurrencePattern* pPatternRef = m_mapPatterns.Get(dwPatternID);
  1024. ASSERT(pPatternRef);
  1025. if (pPatternRef)
  1026. {
  1027. VERIFY( pPatternRef->Update(pPattern) );
  1028. }
  1030. return TRUE;
  1031. }
  1033. BOOL CXTPCalendarMemoryDataProvider::DoDelete_RPattern(CXTPCalendarRecurrencePattern* pPattern)
  1034. {
  1035. if (!pPattern)
  1036. {
  1037. ASSERT(FALSE);
  1038. return FALSE;
  1039. }
  1040. DWORD dwPatternID = pPattern->GetPatternID();
  1042. return m_mapPatterns.Remove(dwPatternID);
  1043. }
  1045. DWORD CXTPCalendarMemoryDataProvider::_UniqueID_Event(DWORD dwID)
  1046. {
  1047. if (dwID == XTP_CALENDAR_UNKNOWN_EVENT_ID)
  1048. {
  1049. dwID = GetNextFreeTempID();
  1050. }
  1051. for (int i = 0; i < 1000 && m_EventsStorage.IsExist(dwID); i++)
  1052. {
  1053. dwID = GetNextFreeTempID();
  1054. }
  1055. ASSERT(m_EventsStorage.IsExist(dwID) == FALSE);
  1056. return dwID;
  1057. }
  1059. DWORD CXTPCalendarMemoryDataProvider::_UniqueID_Patern(DWORD dwID)
  1060. {
  1061. if (dwID == XTP_CALENDAR_UNKNOWN_RECURRENCE_PATTERN_ID)
  1062. {
  1063. dwID = GetNextFreeTempID();
  1064. }
  1065. for (int i = 0; i < 1000 && m_mapPatterns.IsExist(dwID); i++)
  1066. {
  1067. dwID = GetNextFreeTempID();
  1068. }
  1069. ASSERT(m_mapPatterns.IsExist(dwID) == FALSE);
  1070. return dwID;
  1071. }