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

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

对话框与窗口

开发平台：

Visual C++

XTPCalendarMAPIDataProvider.cpp：源码内容
  1. // XTPCalendarMAPIDataProvider.cpp: implementation of the CXTPCalendarMAPIDataProvider 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/XTPVC80Helpers.h"
  24. #include "Common/XTPVC50Helpers.h"
  25. #include "Common/XTPPropExchange.h"
  26. #include "Common/XTPNotifyConnection.h"
  28. #include "XTPCalendarMAPIDataProvider.h"
  29. #include "XTPCalendarMemoryDataProvider.h"
  30. #include "XTPCalendarCustomProperties.h"
  31. #include "XTPCalendarNotifications.h"
  33. #ifdef _DEBUG
  34. #define new DEBUG_NEW
  35. #undef THIS_FILE
  36. static char THIS_FILE[] = __FILE__;
  37. #endif
  39. //#define XTP_TRACE_READ_EVENTS TRACE
  40. #ifndef XTP_TRACE_READ_EVENTS
  41. #define XTP_TRACE_READ_EVENTS //1 ? (void)0 : TRACE
  42. #endif
  44. //#define XTP_TRACE_READ_IDS TRACE
  45. #ifndef XTP_TRACE_READ_IDS
  46. #define XTP_TRACE_READ_IDS //1 ? (void)0 : TRACE
  47. #endif
  49. //#define XTP_TRACE_MAPI_NF TRACE
  50. #ifndef XTP_TRACE_MAPI_NF
  51. #define XTP_TRACE_MAPI_NF //1 ? (void)0 : TRACE
  52. #endif
  54. #define MAPI_FREEBUFFER(pProvider, pBuffer) if (pProvider && pBuffer) { pProvider->MAPIFreeBuffer(pBuffer); pBuffer = NULL;}
  55. #define MAPI_RELEASE(pProvider, x) if (pProvider && x) { pProvider->UlRelease(x); x = 0;}
  57. //long xtp_dbg_SafeRelease(void* pp)
  58. //{
  59. //  IUnknown** ppInterface = (IUnknown**)pp;
  60. //
  61. //  long nRes = -1;
  62. //  if (ppInterface && *ppInterface)
  63. //  {
  64. //      nRes = (*ppInterface)->Release();
  65. //      *ppInterface = 0;
  66. //  }
  67. //  return nRes;
  68. //}
  69. //#define MAPI_RELEASE(pProvider, x) xtp_dbg_SafeRelease(&x);
  71. #define cFileTimeUnitsPerSecond 10000000i64
  72. //////////////////////////////////////////////////////////////////////////
  74. IMPLEMENT_DYNAMIC(CXTPCalendarMAPIDataProvider, CXTPCalendarData)
  76. /////////////////////////////////////////////////////////////////////////////
  77. template<class _T>
  78. _T xtpGetDataT(const CByteArray& arData, int nOffset)
  79. {
  80. if (nOffset < 0)
  81. {
  82. return 0;
  83. }
  84. if ((int)(nOffset + sizeof(_T)) > (int)arData.GetSize())
  85. {
  86. ASSERT(FALSE);
  87. return 0;
  88. }
  90. const _T* pDataT = (const _T*)(arData.GetData() + nOffset);
  92. return *pDataT;
  93. }
  95. //---------------------------------------------------------------------------
  96. template<class _T>
  97. _T xtpGetNextDataT(const BYTE*& rpData, const BYTE* pMax = NULL)
  98. {
  99. if (!rpData || pMax && (rpData + sizeof(_T)) > pMax)
  100. {
  101. ASSERT(FALSE);
  102. return 0;
  103. }
  105. const _T* pDataT = (const _T*)(rpData);
  106. rpData += sizeof(_T);
  108. return *pDataT;
  109. }
  111. //---------------------------------------------------------------------------
  112. CString xtpGetNextData_MapiExcStr8(const BYTE*& rpData, const BYTE* pMax = NULL)
  113. {
  114. if (!rpData)
  115. {
  116. ASSERT(FALSE);
  117. return _T("");
  118. }
  120. // layout: [w:buf-size][w:str-len][ascii-char: count=len]
  121. int nBuffer = (int)xtpGetNextDataT<WORD>(rpData, pMax);
  122. UNUSED_ALWAYS(nBuffer);
  123. int nStrLen = (int)xtpGetNextDataT<WORD>(rpData, pMax);
  125. if (pMax && (rpData + nStrLen) > pMax)
  126. {
  127. ASSERT(FALSE);
  128. return _T("");
  129. }
  131. CString strData = CONSTRUCT_S((char*)rpData, nStrLen);
  132. rpData += nStrLen;
  134. return strData;
  135. }
  137. //===========================================================================
  138. template<class _T>
  139. void xtpAddDataT(CByteArray& rarData, _T tValue)
  140. {
  141. int nSize = sizeof(_T);
  142. BYTE* pBytes = (BYTE*)&tValue;
  143. for (int i = 0; i < nSize; i++)
  144. {
  145. rarData.Add(pBytes[i]);
  146. }
  147. }
  149. //---------------------------------------------------------------------------
  150. template<class _T>
  151. int xtpSetDataT(CByteArray& rarData, int nOffset, _T tValue)
  152. {
  153. if (nOffset < 0)
  154. {
  155. return nOffset;
  156. }
  158. int nValueSize = sizeof(_T);
  159. if (rarData.GetSize() < nOffset + nValueSize)
  160. {
  161. rarData.SetSize(nOffset + nValueSize, 4096);
  162. }
  164. _T* pValue = &tValue;
  165. _T* pDest = (_T*)(rarData.GetData() + nOffset);
  167. *pDest = *pValue;
  169. return nOffset + nValueSize;
  170. }
  172. //---------------------------------------------------------------------------
  173. void xtpAddData_MapiExcStr8(CByteArray& rarData, LPCTSTR pcszString)
  174. {
  175. // layout: [w:buf-size][w:str-len][ascii-char: count=len]
  176. int nStrLenW = (int)_tcslen(pcszString);
  177. int nStrSize = nStrLenW*2 + 1;
  178. CHAR* pStr = new CHAR[nStrSize];
  179. if (!pStr)
  180. {
  181. xtpAddDataT<WORD>(rarData, 1);
  182. xtpAddDataT<WORD>(rarData, 0);
  183. return;
  184. }
  186. ZeroMemory(pStr, nStrSize);
  188. WCSTOMBS_S(pStr, pcszString, nStrSize-1);
  190. int nStrLen = (int)strlen(pStr);
  191. int nBuffer = nStrLen + 1;
  193. xtpAddDataT<WORD>(rarData, (WORD)nBuffer);
  194. xtpAddDataT<WORD>(rarData, (WORD)nStrLen);
  196. int nSize = (int)rarData.GetSize();
  197. rarData.SetSize(nSize + nStrLen, 4096);
  198. void* pDest = rarData.GetData() + nSize;
  200. MEMCPY_S(pDest, pStr, nStrLen);
  202. delete[] pStr;
  203. }
  205. //===========================================================================
  206. void xtp_GetWinTZInfo(const CByteArray& arMapiTZInfo,
  207.   TIME_ZONE_INFORMATION* pTZInfo)
  208. {
  209. if (arMapiTZInfo.GetSize() < sizeof(XTP_MAPI_TIME_ZONE_INFORMATION) || !pTZInfo)
  210. {
  211. ASSERT(FALSE);
  212. return;
  213. }
  214. XTP_MAPI_TIME_ZONE_INFORMATION* pMapiTZInfo;
  215. pMapiTZInfo = (XTP_MAPI_TIME_ZONE_INFORMATION*)arMapiTZInfo.GetData();
  217. ZeroMemory(pTZInfo, sizeof(TIME_ZONE_INFORMATION));
  219. pTZInfo->Bias         = pMapiTZInfo->Bias;
  220. pTZInfo->StandardBias = pMapiTZInfo->StandardBias;
  221. pTZInfo->DaylightBias = pMapiTZInfo->DaylightBias;
  222. pTZInfo->StandardDate = pMapiTZInfo->StandardDate;
  223. pTZInfo->DaylightDate = pMapiTZInfo->DaylightDate;
  224. }
  226. void xtp_GetMapiTZInfo(TIME_ZONE_INFORMATION* pTZInfo, CByteArray& arMapiTZInfo)
  227. {
  228. XTP_MAPI_TIME_ZONE_INFORMATION* pMapiTZInfo;
  230. arMapiTZInfo.SetSize(sizeof(XTP_MAPI_TIME_ZONE_INFORMATION));
  231. pMapiTZInfo = (XTP_MAPI_TIME_ZONE_INFORMATION*)arMapiTZInfo.GetData();
  233. ZeroMemory(pMapiTZInfo, sizeof(XTP_MAPI_TIME_ZONE_INFORMATION));
  234. pMapiTZInfo->Bias         = pTZInfo->Bias;
  235. pMapiTZInfo->StandardBias = pTZInfo->StandardBias;
  236. pMapiTZInfo->DaylightBias = pTZInfo->DaylightBias;
  237. pMapiTZInfo->StandardDate = pTZInfo->StandardDate;
  238. pMapiTZInfo->DaylightDate = pTZInfo->DaylightDate;
  239. }
  241. COleDateTime xtp_UtcToTzTime(const TIME_ZONE_INFORMATION* pTZI,
  242.  const SYSTEMTIME& stUtcTime)
  243. {
  244. SYSTEMTIME stTzTime;
  246. if (!CXTPCalendarUtils::SystemTimeToTzSpecificLocalTime(pTZI, &stUtcTime, &stTzTime))
  247. {
  248. return (DATE)0;
  249. }
  251. COleDateTime dtTzTime(stTzTime);
  253. return dtTzTime;
  254. }
  256. SYSTEMTIME xtp_TimeToUtc(const COleDateTime& dtTzTime)
  257. {
  258. SYSTEMTIME stUtcTime;
  259. ZeroMemory(&stUtcTime, sizeof(stUtcTime));
  261. SYSTEMTIME stTzTime;
  262. if (!GETASSYSTEMTIME_DT(dtTzTime, stTzTime) )
  263. {
  264. return stUtcTime;
  265. }
  267. FILETIME ftTz;
  268. if (!SystemTimeToFileTime(&stTzTime, &ftTz))
  269. {
  270. return stUtcTime;
  271. }
  273. FILETIME ftUtc;
  274. if (!LocalFileTimeToFileTime(&ftTz, &ftUtc))
  275. {
  276. return stUtcTime;
  277. }
  279. if (!FileTimeToSystemTime(&ftUtc, &stUtcTime))
  280. {
  281. ZeroMemory(&stUtcTime, sizeof(stUtcTime));
  282. }
  284. return stUtcTime;
  285. }
  287. /////////////////////////////////////////////////////////////////////////////
  288. class CXTPCalendarMAPI_Recurrence
  289. {
  290. public:
  292. // Holds byte offsets of data fields within MAPI binary field
  293. struct XTP_RCDATA_LAYOUT
  294. {
  295. int     nType;          // radioSelector;
  296. int     nType2;         // type
  297. int     nRCShiftX;      // magic MAPI number. Probably used to generate occurrences.
  298. int     nInterval;      // interval;
  299. int     nRegenerate;    // regenerate   // for tasks only
  300. int     nWeekDayMask;   // weekDayMask  // week Of Month
  301. int     nInstance;      // instance
  302. int     nEndByType;     // endByType
  303. int     nOccurrences;
  304. int     nDynData;       // Unaligned data offset
  305. };
  307. // 0 - Daily, 1 - Weekly, 2 - MonYearly, 3 - MonYearly_Nth
  308. static XTP_RCDATA_LAYOUT s_arRCDataLayout[4];
  310. //=======================================================================
  311. class CXTPRcException
  312. {
  313. public:
  314. DWORD   dwNewStart;
  315. DWORD   dwNewEnd;
  316. DWORD   dwOrigStart;
  318. BOOL    bDeleted;
  320. WORD    wFlags;
  322. CString strSubject;     // xtpMAPIRcED_Subject
  323. BOOL    bIsMeeting;     // xtpMAPIRcED_IsMeeting
  324. int     nReminderTime;  // xtpMAPIRcED_ReminderTime
  325. BOOL    bIsReminder;    // xtpMAPIRcED_IsReminder
  326. CString strLocation;    // xtpMAPIRcED_Location
  327. int     nBusyStatus;    // xtpMAPIRcED_BusyStatus - enum XTPCalendarEventBusyStatus
  328. BOOL    bIsAllDay;      // xtpMAPIRcED_IsAllDay
  329. int     nLabel;         // xtpMAPIRcED_Label
  331. CXTPRcException();
  332. const CXTPRcException& operator=(const CXTPRcException& rSrc);
  333. void Set(CXTPCalendarEvent* pExc, CXTPCalendarEvent* pMaster);
  334. };
  336. class CXTPRcExceptions : public CArray<CXTPRcException, CXTPRcException&>
  337. {
  338. public:
  339. CXTPRcExceptions(){};
  340. virtual ~CXTPRcExceptions(){};
  342. int FindByOrigStart(DWORD dwOrigStart);
  344. void SortByOrigStart();
  345. void SortByNewStart();
  346. protected:
  347. typedef int (_cdecl* T_CompareFunc)(const CXTPRcException* pExc1, const CXTPRcException* pExc2);
  348. void _Sort(T_CompareFunc);
  350. static int _cdecl CompareAsc_ByOrigStart(const CXTPRcException* pExc1, const CXTPRcException* pExc2);
  351. static int _cdecl CompareAsc_ByNewStart(const CXTPRcException* pExc1, const CXTPRcException* pExc2);
  352. };
  354. //=======================================================================
  355. //struct XTP_RCDATA
  356. class CXTPRcData
  357. {
  358. public:
  359. WORD    wType;
  360. BYTE    ucType2;
  361. DWORD   dwRCShiftX;
  362. DWORD   dwInterval;
  363. DWORD   dwWeekDayMask;
  364. BYTE    ucInstance;
  366. DWORD   dwEndByType;
  367. DWORD   dwOccurrences;
  368. DWORD   dwEndDate;
  370. DWORD   dwStartDate;
  372. DWORD   dwOccStartTime;
  373. DWORD   dwOccEndTime;
  375. CXTPRcExceptions arExceptions;
  377. CXTPRcData();
  378. virtual ~CXTPRcData(){};
  380. };
  382. static BOOL ReadRCData(CXTPRcData& rRCData, const CByteArray& arRCData);
  384. static void SetRecurrenceOptions(CXTPCalendarRecurrencePattern* pPattern,
  385. const CXTPRcData& RCData);
  386. static void SetRecurrenceExceptions(CXTPCalendarEvent* pMasterEvent,
  387. CXTPCalendarRecurrencePattern* pPattern,
  388. const CXTPRcData& RCData);
  390. //-----------------------------------------------------------------------
  391. static BOOL FillRCData( CXTPRcData& rRCData,
  392. CXTPCalendarRecurrencePattern* pPattern,
  393. CXTPCalendarEvent* pMaster);
  395. static BOOL RCDataToBin(CXTPRcData& rRCData, CByteArray& rarRCData);
  397. static COleDateTime ConvertRecurrenceMinutesToDate(DWORD dwMinutes);
  398. static DWORD ConvertRecurrenceDateToMinutes(COleDateTime date);
  400. protected:
  401. static void _ReadRCDataExceptions (CXTPRcData& rRCData, const BYTE* pExcData,
  402. const BYTE* pMaxPtr, const BYTE* pExclusions);
  404. static DWORD _CalcRCShiftX(CXTPCalendarRecurrencePattern* pPattern);
  405. };
  407. //
  408. //  MAPI recurrence layouts definitions
  409. //
  410. CXTPCalendarMAPI_Recurrence::XTP_RCDATA_LAYOUT
  411. CXTPCalendarMAPI_Recurrence::s_arRCDataLayout[] =
  412. {
  413. //  daily
  414. {
  415. 4,  // type
  416. 6,  // type2
  417. 10, // RCShiftX
  418. 14, // interval
  419. 18, // regenerate
  420. -1, // weekDayMask
  421. -1, // instance
  422. 22, // endByType
  423. 26, // nOccurrences
  424. 26 + 2 * sizeof(DWORD) // nDynData
  425. },
  426. //  weakly
  427. {
  428. 4,  // type
  429. 6,  // type2
  430. 10, // RCShiftX
  431. 14, // interval
  432. 18, // regenerate
  433. 22, // weekDayMask
  434. -1, // instance
  435. 26, // endByType
  436. 30, // nOccurrences
  437. 30 + 2 * sizeof(DWORD) // nDynData
  438. },
  439. //  monthly
  440. {
  441. 4,  // type
  442. 6,  // type2
  443. 10, // RCShiftX
  444. 14, // interval
  445. 18, // regenerate
  446. -1, // weekDayMask
  447. 22, // instance
  448. 26, // endByType
  449. 30, // nOccurrences
  450. 30 + 2 * sizeof(DWORD) // nDynData
  451. },
  452. //  monthly Nth ()
  453. {
  454. 4,  // type
  455. 6,  // type2
  456. 10, // RCShiftX
  457. 14, // interval
  458. 18, // regenerate
  459. 22, // weekDayMask
  460. 26, // instance
  461. 30, // endByType
  462. 34, // nOccurrences
  463. 34 + 2 * sizeof(DWORD) // nDynData
  464. },
  465. };
  467. //////////////////////////////////////////////////////////////////////////
  468. CXTPCalendarMAPI_Recurrence::CXTPRcException::CXTPRcException()
  469. {
  470. dwNewStart = 0;
  471. dwNewEnd = 0;
  472. dwOrigStart = 0;
  474. bDeleted = FALSE;
  476. wFlags = 0;
  477. //strSubject;
  478. bIsMeeting = FALSE;
  479. nReminderTime = 0;
  480. bIsReminder = FALSE;
  481. //strLocation;
  482. nBusyStatus = 0;
  483. bIsAllDay = FALSE;
  484. nLabel = 0;
  485. }
  487. void CXTPCalendarMAPI_Recurrence::CXTPRcException::Set(CXTPCalendarEvent* pExc, CXTPCalendarEvent* pMaster)
  488. {
  489. CXTPRcException rexZero;
  490. *this = rexZero;
  492. if (!pExc || !pMaster)
  493. {
  494. ASSERT(FALSE);
  495. return;
  496. }
  498. wFlags = 0;
  500. bDeleted = pExc->IsRExceptionDeleted();
  502. dwOrigStart = CXTPCalendarMAPI_Recurrence::ConvertRecurrenceDateToMinutes(pExc->GetRException_StartTimeOrig());
  504. if (bDeleted)
  505. {
  506. return;
  507. }
  509. dwNewStart = CXTPCalendarMAPI_Recurrence::ConvertRecurrenceDateToMinutes(pExc->GetStartTime());
  510. dwNewEnd = CXTPCalendarMAPI_Recurrence::ConvertRecurrenceDateToMinutes(pExc->GetEndTime());
  512. if (pExc->GetSubject() != pMaster->GetSubject())
  513. {
  514. wFlags |= xtpMAPIRcED_Subject;
  515. strSubject = pExc->GetSubject();
  516. }
  517. if (pExc->IsMeeting() != pMaster->IsMeeting())
  518. {
  519. wFlags |= xtpMAPIRcED_IsMeeting;
  520. bIsMeeting = pExc->IsMeeting();
  521. }
  522. if (pExc->GetReminderMinutesBeforeStart() != pMaster->GetReminderMinutesBeforeStart())
  523. {
  524. wFlags |= xtpMAPIRcED_ReminderTime;
  525. nReminderTime = pExc->GetReminderMinutesBeforeStart();
  526. }
  527. if (pExc->IsReminder() != pMaster->IsReminder())
  528. {
  529. wFlags |= xtpMAPIRcED_IsReminder;
  530. bIsReminder = pExc->IsReminder();
  531. }
  532. if (pExc->GetLocation() != pMaster->GetLocation())
  533. {
  534. wFlags |= xtpMAPIRcED_Location;
  535. strLocation = pExc->GetLocation();
  536. }
  537. if (pExc->GetBusyStatus() != pMaster->GetBusyStatus())
  538. {
  539. wFlags |= xtpMAPIRcED_BusyStatus;
  540. nBusyStatus = pExc->GetBusyStatus();
  541. }
  542. if (pExc->IsAllDayEvent() != pMaster->IsAllDayEvent())
  543. {
  544. wFlags |= xtpMAPIRcED_IsAllDay;
  545. bIsAllDay = pExc->IsAllDayEvent();
  546. }
  547. if (pExc->GetLabelID() != pMaster->GetLabelID())
  548. {
  549. wFlags |= xtpMAPIRcED_Label;
  550. nLabel = pExc->GetLabelID();
  551. }
  552. }
  554. const CXTPCalendarMAPI_Recurrence::CXTPRcException&
  555. CXTPCalendarMAPI_Recurrence::CXTPRcException::operator= (
  556. const CXTPCalendarMAPI_Recurrence::CXTPRcException& rSrc)
  557. {
  558. dwNewStart = rSrc.dwNewStart;
  559. dwNewEnd = rSrc.dwNewEnd;
  560. dwOrigStart = rSrc.dwOrigStart;
  562. bDeleted = rSrc.bDeleted;
  564. wFlags = rSrc.wFlags;
  566. strSubject = rSrc.strSubject;
  567. bIsMeeting = rSrc.bIsMeeting;
  568. nReminderTime = rSrc.nReminderTime;
  569. bIsReminder = rSrc.bIsReminder;
  570. strLocation = rSrc.strLocation;
  571. nBusyStatus = rSrc.nBusyStatus;
  572. bIsAllDay = rSrc.bIsAllDay;
  573. nLabel = rSrc.nLabel;
  575. return *this;
  576. }
  578. int CXTPCalendarMAPI_Recurrence::CXTPRcExceptions::FindByOrigStart(DWORD dwOrigStart)
  579. {
  580. int nCount = (int)GetSize();
  581. for (int i = 0; i < nCount; i++)
  582. {
  583. const CXTPRcException& rce = ElementAt(i);
  585. if (rce.dwOrigStart == dwOrigStart)
  586. {
  587. return i;
  588. }
  589. }
  590. return -1;
  591. }
  593. void CXTPCalendarMAPI_Recurrence::CXTPRcExceptions::SortByOrigStart()
  594. {
  595. _Sort(CompareAsc_ByOrigStart);
  596. }
  598. void CXTPCalendarMAPI_Recurrence::CXTPRcExceptions::SortByNewStart()
  599. {
  600. _Sort(CompareAsc_ByNewStart);
  601. }
  603. void CXTPCalendarMAPI_Recurrence::CXTPRcExceptions::_Sort(T_CompareFunc pCompareFunc)
  604. {
  605. typedef int (_cdecl *GENERICCOMPAREFUNC)(const void *, const void*);
  607. qsort(GetData(), (size_t)GetSize(), sizeof(CXTPRcException),
  608.  (GENERICCOMPAREFUNC)pCompareFunc);
  609. }
  611. int _cdecl CXTPCalendarMAPI_Recurrence::CXTPRcExceptions::CompareAsc_ByOrigStart(const CXTPRcException* pExc1, const CXTPRcException* pExc2)
  612. {
  613. if (pExc1->dwOrigStart < pExc2->dwOrigStart)
  614. {
  615. return -1;
  616. }
  617. if (pExc1->dwOrigStart > pExc2->dwOrigStart)
  618. {
  619. return 1;
  620. }
  621. return 0;
  622. }
  624. int _cdecl CXTPCalendarMAPI_Recurrence::CXTPRcExceptions::CompareAsc_ByNewStart(const CXTPRcException* pExc1, const CXTPRcException* pExc2)
  625. {
  626. if (pExc1->dwNewStart < pExc2->dwNewStart)
  627. {
  628. return -1;
  629. }
  630. if (pExc1->dwNewStart > pExc2->dwNewStart)
  631. {
  632. return 1;
  633. }
  634. return 0;
  635. }
  637. /////////////////////////////////////////////////////////////////////////////
  638. CXTPCalendarMAPI_Recurrence::CXTPRcData::CXTPRcData()
  639. {
  640. wType = 0;
  641. ucType2 = 0;
  642. dwRCShiftX = 0;
  643. dwInterval = 0;
  644. dwWeekDayMask = 0;
  645. ucInstance = 0;
  647. dwEndByType = 0;
  648. dwOccurrences = 0;
  649. dwEndDate = 0;
  651. dwStartDate = 0;
  653. dwOccStartTime = 0;
  654. dwOccEndTime = 0;
  656. //arExceptions;
  657. }
  660. BOOL CXTPCalendarMAPI_Recurrence::ReadRCData(
  661. CXTPCalendarMAPI_Recurrence::CXTPRcData& rRCData,
  662. const CByteArray& arRCData)
  663. {
  664. XTPCalendarMAPIRcType eRCType;
  665. XTPCalendarMAPIRcType2 eRCType2;
  666. eRCType =  (XTPCalendarMAPIRcType)xtpGetDataT<WORD>(arRCData, s_arRCDataLayout[0].nType);
  667. eRCType2 = (XTPCalendarMAPIRcType2)xtpGetDataT<BYTE>(arRCData, s_arRCDataLayout[0].nType2);
  669. BOOL bTypeValid = eRCType == xtpMAPIRcType_Daily    || eRCType == xtpMAPIRcType_Weekly ||
  670.   eRCType == xtpMAPIRcType_Monthly    || eRCType == xtpMAPIRcType_Yearly;
  672. if (eRCType2 < xtpMAPIRcType2_First || eRCType2 > xtpMAPIRcType2_Last || !bTypeValid)
  673. {
  674. return FALSE;
  675. }
  677. XTP_RCDATA_LAYOUT RCLayout;
  678. ::ZeroMemory(&RCLayout, sizeof(RCLayout));
  680. // select layout
  681. RCLayout = s_arRCDataLayout[eRCType2];
  683. rRCData.wType = xtpGetDataT<WORD>(arRCData, RCLayout.nType);
  684. rRCData.ucType2 = xtpGetDataT<BYTE>(arRCData, RCLayout.nType2);
  685. rRCData.dwRCShiftX = xtpGetDataT<DWORD>(arRCData, RCLayout.nRCShiftX);
  686. rRCData.dwInterval = xtpGetDataT<DWORD>(arRCData, RCLayout.nInterval);
  687. rRCData.dwWeekDayMask = xtpGetDataT<DWORD>(arRCData, RCLayout.nWeekDayMask);
  688. rRCData.ucInstance = xtpGetDataT<BYTE>(arRCData, RCLayout.nInstance);
  689. rRCData.dwEndByType = xtpGetDataT<DWORD>(arRCData, RCLayout.nEndByType);
  690. rRCData.dwOccurrences = xtpGetDataT<DWORD>(arRCData, RCLayout.nOccurrences);
  692. //
  693. const BYTE* p = arRCData.GetData() + RCLayout.nDynData;
  694. const BYTE* pMax = arRCData.GetData() + arRCData.GetSize();
  696. const BYTE* pExclusions = p;
  698. // skip old and new dates
  699. p += sizeof(DWORD) * (xtpGetNextDataT<DWORD>(p, pMax)); // skip old start dates
  700. p += sizeof(DWORD) * (xtpGetNextDataT<DWORD>(p, pMax)); // old new start dates
  702. // pick up start/end dates
  704. //Pattern Start Date
  705. rRCData.dwStartDate = xtpGetNextDataT<DWORD>(p, pMax);
  706. // /*DBG*/ ConvertRecurrenceMinutesToDate(rRCData.dwStartDate);
  708. //Pattern End Date
  709. rRCData.dwEndDate = xtpGetNextDataT<DWORD>(p, pMax);
  710. // /*DBG*/ ConvertRecurrenceMinutesToDate(rRCData.dwEndDate);
  712. // skip unknown reserved fields
  713. xtpGetNextDataT<DWORD>(p, pMax);
  714. xtpGetNextDataT<DWORD>(p, pMax);
  716. // Occurrence start/end time - in minutes from the day begin
  717. // hour = time / 60, minute = time % 60
  718. rRCData.dwOccStartTime = xtpGetNextDataT<DWORD>(p, pMax);
  719. rRCData.dwOccEndTime = xtpGetNextDataT<DWORD>(p, pMax);
  721. //p - points to detailed exceptions information.
  723. _ReadRCDataExceptions(rRCData, p, pMax, pExclusions);
  725. return TRUE;
  726. }
  728. void CXTPCalendarMAPI_Recurrence::_ReadRCDataExceptions(
  729. CXTPCalendarMAPI_Recurrence::CXTPRcData& rRCData,
  730. const BYTE* pExcData, const BYTE* pMaxPtr,
  731. const BYTE* pExclusions
  732. )
  733. {
  734. // read detailed recurrence exceptions information
  735. int nCount = (int)xtpGetNextDataT<WORD>(pExcData, pMaxPtr);
  736. int i;
  737. for (i = 0; i < nCount; i++)
  738. {
  739. CXTPRcException RCExc;
  741. RCExc.dwNewStart = xtpGetNextDataT<DWORD>(pExcData, pMaxPtr);
  742. RCExc.dwNewEnd = xtpGetNextDataT<DWORD>(pExcData, pMaxPtr);
  743. RCExc.dwOrigStart = xtpGetNextDataT<DWORD>(pExcData, pMaxPtr);
  745. RCExc.wFlags = xtpGetNextDataT<WORD>(pExcData, pMaxPtr);
  747. if (RCExc.wFlags & xtpMAPIRcED_Subject)
  748. {
  749. // layout: [w:buf-size][w:str-len][ascii-char: count=len]
  750. RCExc.strSubject = xtpGetNextData_MapiExcStr8(pExcData, pMaxPtr);
  751. }
  752. if (RCExc.wFlags & xtpMAPIRcED_IsMeeting)
  753. {
  754. // layout: [dw] - bool(0|1)
  755. RCExc.bIsMeeting = xtpGetNextDataT<DWORD>(pExcData, pMaxPtr) != 0;
  756. }
  757. if (RCExc.wFlags & xtpMAPIRcED_ReminderTime)
  758. {
  759. // layout: [dw] minutes before start
  760. RCExc.nReminderTime = xtpGetNextDataT<DWORD>(pExcData, pMaxPtr);
  761. }
  762. if (RCExc.wFlags & xtpMAPIRcED_IsReminder)
  763. {
  764. // layout: [dw] - bool(0|1)
  765. RCExc.bIsReminder = xtpGetNextDataT<DWORD>(pExcData, pMaxPtr) != 0;
  766. }
  767. if (RCExc.wFlags & xtpMAPIRcED_Location)
  768. {
  769. // layout: [w:buf-size][w:str-len][ascii-char: count=len]
  770. RCExc.strLocation = xtpGetNextData_MapiExcStr8(pExcData, pMaxPtr);
  771. }
  772. if (RCExc.wFlags & xtpMAPIRcED_BusyStatus)
  773. {
  774. // layout: [dw] - busy status [0..3] = XTPCalendarEventBusyStatus
  775. RCExc.nBusyStatus = xtpGetNextDataT<DWORD>(pExcData, pMaxPtr);
  776. }
  777. if (RCExc.wFlags & xtpMAPIRcED_IsAllDay)
  778. {
  779. // layout: [dw] - bool(0|1)
  780. RCExc.bIsAllDay = xtpGetNextDataT<DWORD>(pExcData, pMaxPtr) != 0;
  781. }
  782. if (RCExc.wFlags & xtpMAPIRcED_Label)
  783. {
  784. // layout: [dw] -
  785. RCExc.nLabel = xtpGetNextDataT<DWORD>(pExcData, pMaxPtr);
  786. }
  788. rRCData.arExceptions.Add(RCExc);
  789. }
  791. ASSERT(rRCData.dwOccEndTime >= rRCData.dwOccStartTime);
  793. // determine and add deleted exceptions
  794. nCount = (int)xtpGetNextDataT<DWORD>(pExclusions, pMaxPtr);
  795. for (i = 0; i < nCount; i++)
  796. {
  797. CXTPRcException RCExc;
  798. RCExc.dwOrigStart = xtpGetNextDataT<DWORD>(pExclusions, pMaxPtr);
  799. RCExc.dwOrigStart += rRCData.dwOccStartTime;
  800. RCExc.bDeleted = TRUE;
  802. if (rRCData.arExceptions.FindByOrigStart(RCExc.dwOrigStart) < 0)
  803. {
  804. rRCData.arExceptions.Add(RCExc);
  805. }
  806. }
  807. }
  810. void CXTPCalendarMAPI_Recurrence::SetRecurrenceOptions(
  811. CXTPCalendarRecurrencePattern* pPattern,
  812. const CXTPCalendarMAPI_Recurrence::CXTPRcData& RCData)
  813. {
  814. ASSERT(pPattern);
  815. if (!pPattern)
  816. {
  817. return;
  818. }
  820. XTP_CALENDAR_RECURRENCE_OPTIONS opt;
  822. // Recurrence type
  823. switch(RCData.wType)
  824. {
  825. case xtpMAPIRcType_Daily:
  826. {
  827. opt.m_nRecurrenceType = xtpCalendarRecurrenceDaily;
  828. opt.m_Daily.bEveryWeekDayOnly = (RCData.ucType2 == xtpMAPIRcType2_Weekly);
  830. if (opt.m_Daily.bEveryWeekDayOnly)
  831. {
  832. opt.m_Daily.nIntervalDays = 1;
  833. }
  834. else
  835. {
  836. ASSERT(RCData.dwInterval % (24 * 60) == 0);
  837. opt.m_Daily.nIntervalDays = (int)RCData.dwInterval / (24 * 60);
  838. }
  839. }
  840. break;
  842. case xtpMAPIRcType_Weekly:
  843. {
  844. opt.m_nRecurrenceType = xtpCalendarRecurrenceWeekly;
  845. ASSERT(RCData.ucType2 == xtpMAPIRcType2_Weekly); // == 1, 0 only for tasks
  847. opt.m_Weekly.nIntervalWeeks = (int)RCData.dwInterval;
  848. opt.m_Weekly.nDayOfWeekMask = (int)RCData.dwWeekDayMask;
  849. }
  850. break;
  852. case xtpMAPIRcType_Monthly:
  853. {
  854. if (RCData.ucType2 == xtpMAPIRcType2_MonYearly)
  855. {
  856. opt.m_nRecurrenceType = xtpCalendarRecurrenceMonthly;
  857. opt.m_Monthly.nIntervalMonths = (int)RCData.dwInterval;
  858. opt.m_Monthly.nDayOfMonth = (int)RCData.ucInstance;
  859. }
  860. else if (RCData.ucType2 == xtpMAPIRcType2_MonYearly_Nth)
  861. {
  862. opt.m_nRecurrenceType = xtpCalendarRecurrenceMonthNth;
  863. opt.m_MonthNth.nIntervalMonths = (int)RCData.dwInterval;
  864. opt.m_MonthNth.nWhichDay = (int)RCData.ucInstance; // ???
  865. opt.m_MonthNth.nWhichDayMask = (int)RCData.dwWeekDayMask; // ???
  866. }
  867. else
  868. {
  869. ASSERT(FALSE);
  870. }
  871. }
  872. break;
  874. case xtpMAPIRcType_Yearly:
  875. {
  876. ASSERT(RCData.dwInterval % 12 == 0 && RCData.dwInterval);
  878. //---------------------------------------------------------------
  879. int nMonthOfYear = 1;
  880. // days per month   - jan feb mar apr may jun   jul aug sep oct nov dec
  881. static int arDays[] = {31, 28, 31, 30, 31, 30,   31, 31, 30, 31, 30, 31};
  882. int nDaysInMinutes = 0;
  883. for (int i = 0; i < 12; i++)
  884. {
  885. if (nDaysInMinutes >= (int)RCData.dwRCShiftX)
  886. {
  887. nMonthOfYear = i+1;
  888. break;
  889. }
  890. nDaysInMinutes += arDays[i] * 24 * 60;
  891. }
  892. ASSERT(nDaysInMinutes == (int)RCData.dwRCShiftX);
  894. //---------------------------------------------------------------
  895. if (RCData.ucType2 == xtpMAPIRcType2_MonYearly)
  896. {
  897. opt.m_nRecurrenceType = xtpCalendarRecurrenceYearly;
  898. opt.m_Yearly.nDayOfMonth = RCData.ucInstance;
  899. opt.m_Yearly.nMonthOfYear = nMonthOfYear;
  900. }
  901. else if (RCData.ucType2 == xtpMAPIRcType2_MonYearly_Nth)
  902. {
  903. opt.m_nRecurrenceType = xtpCalendarRecurrenceYearNth;
  904. opt.m_YearNth.nWhichDay = RCData.ucInstance;
  905. opt.m_YearNth.nWhichDayMask = RCData.dwWeekDayMask;
  906. opt.m_YearNth.nMonthOfYear = nMonthOfYear;
  907. }
  908. else
  909. {
  910. ASSERT(FALSE);
  911. }
  912. }
  913. break;
  914. default:
  915. ASSERT(FALSE);
  916. }
  917. pPattern->SetRecurrenceOptions(opt);
  919. pPattern->SetPatternStartDate(ConvertRecurrenceMinutesToDate(RCData.dwStartDate));
  921. XTP_CALENDAR_PATTERN_END rpEnd;
  922. switch(RCData.dwEndByType)
  923. {
  924. case xtpMAPIRcEnd_Date:
  925. rpEnd.m_nUseEnd = xtpCalendarPatternEndDate;
  926. rpEnd.m_dtPatternEndDate = ConvertRecurrenceMinutesToDate(RCData.dwEndDate);
  927. break;
  928. case xtpMAPIRcEnd_Number:
  929. rpEnd.m_nUseEnd = xtpCalendarPatternEndAfterOccurrences;
  930. rpEnd.m_nEndAfterOccurrences = RCData.dwOccurrences;
  931. break;
  932. case xtpMAPIRcEnd_Never:
  933. rpEnd.m_nUseEnd = xtpCalendarPatternEndNoDate;
  934. break;
  935. default: // Use no end date by default
  936. rpEnd.m_nUseEnd = xtpCalendarPatternEndNoDate;
  937. }
  938. pPattern->SetPatternEnd(rpEnd);
  940. COleDateTime dtOccStartTime;
  941. dtOccStartTime.SetTime(RCData.dwOccStartTime / 60, RCData.dwOccStartTime % 60, 0);
  943. pPattern->SetStartTime(dtOccStartTime);
  945. int nDuration = RCData.dwOccEndTime - RCData.dwOccStartTime;
  946. ASSERT(nDuration >= 0);
  947. pPattern->SetDurationMinutes(nDuration);
  948. }
  950. void CXTPCalendarMAPI_Recurrence::SetRecurrenceExceptions(
  951. CXTPCalendarEvent* pMasterEvent,
  952. CXTPCalendarRecurrencePattern* pPattern,
  953. const CXTPRcData& RCData)
  954. {
  955. if (!pMasterEvent || !pPattern)
  956. {
  957. ASSERT(FALSE);
  958. return;
  959. }
  961. int nCount = (int)RCData.arExceptions.GetSize();
  962. for (int i = 0; i < nCount; i++)
  963. {
  964. const CXTPRcException& RCExc = RCData.arExceptions[i];
  966. COleDateTime dtOrigStart = ConvertRecurrenceMinutesToDate(RCExc.dwOrigStart);
  968. COleDateTime dtOrigEnd = dtOrigStart + pPattern->GetDuration();
  970. CXTPCalendarEventPtr ptrExc = pMasterEvent->CloneForOccurrence(dtOrigStart, dtOrigEnd);
  971. if (!ptrExc)
  972. {
  973. return;
  974. }
  975. VERIFY( ptrExc->MakeAsRException() );
  977. if (RCExc.bDeleted)
  978. {
  979. ptrExc->SetRExceptionDeleted(TRUE);
  980. VERIFY( pPattern->SetException(ptrExc) );
  981. continue;
  982. }
  984. //---------------------------------------------------------------
  985. COleDateTime dtNewStart = dtOrigStart;
  986. COleDateTime dtNewEnd = dtOrigEnd;
  988. if (RCExc.dwNewStart)
  989. {
  990. dtNewStart = ConvertRecurrenceMinutesToDate(RCExc.dwNewStart);
  991. }
  992. if (RCExc.dwNewEnd)
  993. {
  994. dtNewEnd = ConvertRecurrenceMinutesToDate(RCExc.dwNewEnd);
  995. }
  997. ptrExc->SetStartTime(dtNewStart);
  998. ptrExc->SetEndTime(dtNewEnd);
  1000. //---------------------------------------------------------------
  1001. if (RCExc.wFlags & xtpMAPIRcED_Subject)
  1002. {
  1003. ptrExc->SetSubject(RCExc.strSubject);
  1004. }
  1005. if (RCExc.wFlags & xtpMAPIRcED_IsMeeting)
  1006. {
  1007. ptrExc->SetMeeting(RCExc.bIsMeeting);
  1008. }
  1009. if (RCExc.wFlags & xtpMAPIRcED_ReminderTime)
  1010. {
  1011. ptrExc->SetReminderMinutesBeforeStart(RCExc.nReminderTime);
  1012. }
  1013. if (RCExc.wFlags & xtpMAPIRcED_IsReminder)
  1014. {
  1015. ptrExc->SetReminder(RCExc.bIsReminder);
  1016. }
  1017. if (RCExc.wFlags & xtpMAPIRcED_Location)
  1018. {
  1019. ptrExc->SetLocation(RCExc.strLocation);
  1020. }
  1021. if (RCExc.wFlags & xtpMAPIRcED_BusyStatus)
  1022. {
  1023. ASSERT(RCExc.nBusyStatus < 4);
  1024. if (RCExc.nBusyStatus >= 0 && RCExc.nBusyStatus < 4)
  1025. {
  1026. ptrExc->SetBusyStatus(RCExc.nBusyStatus);
  1027. }
  1028. }
  1030. ASSERT((RCExc.wFlags & xtpMAPIRcED_Reserved) == 0);
  1032. if (RCExc.wFlags & xtpMAPIRcED_IsAllDay)
  1033. {
  1034. ptrExc->SetAllDayEvent(RCExc.bIsAllDay);
  1035. }
  1037. if (RCExc.wFlags & xtpMAPIRcED_Label)
  1038. {
  1039. ptrExc->SetLabelID(RCExc.nLabel);
  1040. }
  1042. VERIFY( pPattern->SetException(ptrExc) );
  1043. }
  1044. }
  1046. BOOL CXTPCalendarMAPI_Recurrence::FillRCData(CXTPRcData& rRCData,
  1047. CXTPCalendarRecurrencePattern* pPattern,
  1048. CXTPCalendarEvent* pMaster)
  1049. {
  1050. // FileTime zero date
  1051. static const COleDateTime cdtFTZero(1601, 1, 1, 0, 0, 0);
  1053. if (!pPattern || !pMaster)
  1054. {
  1055. ASSERT(FALSE);
  1056. return FALSE;
  1057. }
  1058. XTP_CALENDAR_RECURRENCE_OPTIONS opt = pPattern->GetRecurrenceOptions();
  1060. switch(opt.m_nRecurrenceType)
  1061. {
  1062. case xtpCalendarRecurrenceDaily:
  1063. {
  1064. rRCData.wType = xtpMAPIRcType_Daily;
  1066. if (opt.m_Daily.bEveryWeekDayOnly)
  1067. {
  1068. rRCData.ucType2 = xtpMAPIRcType2_Weekly;
  1069. rRCData.dwInterval = 1;
  1070. rRCData.dwWeekDayMask = xtpCalendarDayMo_Fr;
  1071. }
  1072. else
  1073. {
  1074. rRCData.ucType2 = xtpMAPIRcType2_Daily;
  1075. rRCData.dwInterval = opt.m_Daily.nIntervalDays * 24 * 60;
  1076. }
  1077. }
  1078. break;
  1080. case xtpCalendarRecurrenceWeekly:
  1081. {
  1082. rRCData.wType = xtpMAPIRcType_Weekly;
  1083. rRCData.ucType2 = xtpMAPIRcType2_Weekly; // = 1, 0 only for tasks
  1085. rRCData.dwInterval = opt.m_Weekly.nIntervalWeeks;
  1086. rRCData.dwWeekDayMask = opt.m_Weekly.nDayOfWeekMask;
  1087. }
  1088. break;
  1090. case xtpCalendarRecurrenceMonthly:
  1091. {
  1092. rRCData.wType = xtpMAPIRcType_Monthly;
  1093. rRCData.ucType2 = xtpMAPIRcType2_MonYearly;
  1095. rRCData.dwInterval = (DWORD)opt.m_Monthly.nIntervalMonths;
  1096. rRCData.ucInstance = (BYTE)opt.m_Monthly.nDayOfMonth;
  1097. }
  1098. break;
  1100. case xtpCalendarRecurrenceMonthNth:
  1101. {
  1102. rRCData.wType = xtpMAPIRcType_Monthly;
  1103. rRCData.ucType2 = xtpMAPIRcType2_MonYearly_Nth;
  1105. rRCData.dwInterval = (DWORD)opt.m_MonthNth.nIntervalMonths;
  1106. rRCData.ucInstance = (BYTE)opt.m_MonthNth.nWhichDay;
  1107. rRCData.dwWeekDayMask = (DWORD)opt.m_MonthNth.nWhichDayMask;
  1108. }
  1109. break;
  1111. case xtpCalendarRecurrenceYearly:
  1112. {
  1113. rRCData.wType = xtpMAPIRcType_Yearly;
  1114. rRCData.ucType2 = xtpMAPIRcType2_MonYearly;
  1116. rRCData.ucInstance = (BYTE)opt.m_Yearly.nDayOfMonth;
  1118. rRCData.dwInterval = 12;
  1119. }
  1120. break;
  1122. case xtpCalendarRecurrenceYearNth:
  1123. {
  1124. rRCData.wType = xtpMAPIRcType_Yearly;
  1125. rRCData.ucType2 = xtpMAPIRcType2_MonYearly_Nth;
  1127. rRCData.ucInstance = (BYTE)opt.m_YearNth.nWhichDay;
  1128. rRCData.dwWeekDayMask = (DWORD)opt.m_YearNth.nWhichDayMask;
  1130. rRCData.dwInterval = 12;
  1131. }
  1132. break;
  1133. default:
  1134. ASSERT(FALSE);
  1135. }
  1136. rRCData.dwRCShiftX = _CalcRCShiftX(pPattern);
  1138. rRCData.dwStartDate = ConvertRecurrenceDateToMinutes(pPattern->GetPatternStartDate());
  1140. CXTPCalendarDatesArray arOccDates;
  1141. XTP_CALENDAR_PATTERN_END rpEnd = pPattern->GetPatternEnd();
  1142. switch(rpEnd.m_nUseEnd)
  1143. {
  1144. case xtpCalendarPatternEndDate:
  1145. rRCData.dwEndByType  = xtpMAPIRcEnd_Date;
  1146. rRCData.dwEndDate = ConvertRecurrenceDateToMinutes(rpEnd.m_dtPatternEndDate);
  1147. pPattern->GetOccurrencesDates(arOccDates, pPattern->GetPatternStartDate(), pPattern->GetPatternEndDate());
  1148. rRCData.dwOccurrences = (DWORD)arOccDates.GetSize();
  1149. break;
  1150. case xtpCalendarPatternEndAfterOccurrences:
  1151. rRCData.dwEndByType  = xtpMAPIRcEnd_Number;
  1152. rRCData.dwOccurrences = rpEnd.m_nEndAfterOccurrences;
  1153. rRCData.dwEndDate = ConvertRecurrenceDateToMinutes(pMaster->GetEndTime());
  1154. break;
  1155. case xtpCalendarPatternEndNoDate:
  1156. rRCData.dwEndByType  = xtpMAPIRcEnd_Never;
  1157. break;
  1158. default: // Use No end date by default
  1159. rRCData.dwEndByType  = xtpMAPIRcEnd_Never;
  1160. }
  1162. COleDateTime dtOccStartTime = pPattern->GetStartTime();
  1163. rRCData.dwOccStartTime = dtOccStartTime.GetHour() * 60 + dtOccStartTime.GetMinute();
  1165. int nOccDuration = pPattern->GetDurationMinutes();
  1166. if (pMaster->IsAllDayEvent() && ( (nOccDuration % (24 * 60)) || nOccDuration == 0) )
  1167. {
  1168. // align occurrence duration for full day(s) duration
  1169. nOccDuration = (nOccDuration / (24 * 60) + 1) * 24 * 60;
  1170. }
  1171. rRCData.dwOccEndTime = rRCData.dwOccStartTime + nOccDuration;
  1173. //------------------------------------------
  1174. CXTPCalendarEventsPtr ptrExcAr = pPattern->GetExceptions();
  1175. int nExcCount = ptrExcAr ? ptrExcAr->GetCount() : 0;
  1176. for (int i = 0; i < nExcCount; i++)
  1177. {
  1178. CXTPCalendarEvent* pExc = ptrExcAr->GetAt(i);
  1180. CXTPRcException rceTmp;
  1181. rceTmp.Set(pExc, pMaster);
  1183. rRCData.arExceptions.Add(rceTmp);
  1184. }
  1186. return TRUE;
  1187. }
  1189. BOOL CXTPCalendarMAPI_Recurrence::RCDataToBin(CXTPRcData& RCData, CByteArray& rarData)
  1190. {
  1191. XTP_RCDATA_LAYOUT RCLayout;
  1192. ::ZeroMemory(&RCLayout, sizeof(RCLayout));
  1194. ASSERT(RCData.ucType2 <= 3);
  1195. if (RCData.ucType2 > 3)
  1196. {
  1197. return FALSE;
  1198. }
  1199. // select layout
  1200. RCLayout = s_arRCDataLayout[RCData.ucType2];
  1202. rarData.SetSize(RCLayout.nDynData, 4096);
  1204. // Set header
  1205.  xtpSetDataT<DWORD>(rarData, 0, 0x30043004);
  1207. // Set generic recurrence fields
  1208. xtpSetDataT<WORD> (rarData, RCLayout.nType,         RCData.wType);
  1209. xtpSetDataT<BYTE> (rarData, RCLayout.nType2,        RCData.ucType2);
  1210. xtpSetDataT<DWORD>(rarData, RCLayout.nRCShiftX,     RCData.dwRCShiftX);
  1211. xtpSetDataT<DWORD>(rarData, RCLayout.nInterval,     RCData.dwInterval);
  1212. xtpSetDataT<DWORD>(rarData, RCLayout.nWeekDayMask,  RCData.dwWeekDayMask);
  1213. xtpSetDataT<BYTE> (rarData, RCLayout.nInstance,     RCData.ucInstance);
  1214. xtpSetDataT<DWORD>(rarData, RCLayout.nEndByType,    RCData.dwEndByType);
  1215. xtpSetDataT<DWORD>(rarData, RCLayout.nOccurrences,   RCData.dwOccurrences);
  1217. // Add information about exceptions
  1218. //
  1219. ASSERT(rarData.GetSize() == RCLayout.nDynData);
  1221. int i = 0;
  1223. //- add ALL exceptions dates -----------------------------------------
  1224. RCData.arExceptions.SortByOrigStart();
  1226. int nExcCount = (int)RCData.arExceptions.GetSize();
  1227. xtpAddDataT<DWORD>(rarData, nExcCount);
  1228. for (i = 0; i < nExcCount; i++)
  1229. {
  1230. const CXTPRcException& rce = RCData.arExceptions[i];
  1231. DWORD dwOrigSartDate = (rce.dwOrigStart / 24 / 60) * 24 * 60;
  1232. xtpAddDataT<DWORD>(rarData, dwOrigSartDate);
  1233. }
  1235. //- add changed exception dates -----------------------------------------
  1236. RCData.arExceptions.SortByNewStart();
  1238. int nChangExcCountOffset = (int)rarData.GetSize();
  1239. xtpAddDataT<DWORD>(rarData, 0);
  1240. DWORD dwChangExcCount = 0;
  1242. for (i = 0; i < nExcCount; i++)
  1243. {
  1244. const CXTPRcException& rce = RCData.arExceptions[i];
  1245. if (!rce.bDeleted)
  1246. {
  1247. ASSERT(rce.dwNewStart != 0 && rce.dwNewEnd != 0);
  1248. DWORD dwNewSartDate = (rce.dwNewStart / 24 / 60) * 24 * 60;
  1249. xtpAddDataT<DWORD>(rarData, dwNewSartDate);
  1250. dwChangExcCount++;
  1251. }
  1252. }
  1253. xtpSetDataT<DWORD>(rarData, nChangExcCountOffset, dwChangExcCount);
  1255. // start/end date
  1256. xtpAddDataT<DWORD>(rarData, RCData.dwStartDate);
  1258. if (RCData.dwEndByType == xtpMAPIRcEnd_Date || RCData.dwEndByType == xtpMAPIRcEnd_Number)
  1259. {
  1260. xtpAddDataT<DWORD>(rarData, RCData.dwEndDate);
  1261. }
  1262. else
  1263. {
  1264. ASSERT(RCData.dwEndByType == xtpMAPIRcEnd_Never);
  1265. xtpAddDataT<DWORD>(rarData, 0x5AE980DF);
  1266. }
  1268. // unknown
  1269. xtpAddDataT<DWORD>(rarData, 0x00003006);
  1270. xtpAddDataT<DWORD>(rarData, 0x00003006);
  1272. // start/end time
  1273. xtpAddDataT<DWORD>(rarData, RCData.dwOccStartTime);
  1274. xtpAddDataT<DWORD>(rarData, RCData.dwOccEndTime);
  1276. // detailed exceptions
  1277. xtpAddDataT<WORD>(rarData, (WORD)dwChangExcCount);
  1279. for (i = 0; i < nExcCount; i++)
  1280. {
  1281. const CXTPRcException& rce = RCData.arExceptions[i];
  1282. if (rce.bDeleted)
  1283. {
  1284. continue;
  1285. }
  1287. ASSERT(rce.dwNewStart && rce.dwNewEnd && rce.dwOrigStart);
  1289. xtpAddDataT<DWORD>(rarData, rce.dwNewStart);
  1290. xtpAddDataT<DWORD>(rarData, rce.dwNewEnd);
  1291. xtpAddDataT<DWORD>(rarData, rce.dwOrigStart);
  1293. xtpAddDataT<WORD>(rarData, rce.wFlags);
  1295. if (rce.wFlags & xtpMAPIRcED_Subject)
  1296. {
  1297. xtpAddData_MapiExcStr8(rarData, rce.strSubject);
  1298. }
  1299. if (rce.wFlags & xtpMAPIRcED_IsMeeting)
  1300. {
  1301. // layout: [dw] - bool(0|1)
  1302. xtpAddDataT<DWORD>(rarData, rce.bIsMeeting);
  1303. }
  1304. if (rce.wFlags & xtpMAPIRcED_ReminderTime)
  1305. {
  1306. // layout: [dw] minutes before start
  1307. xtpAddDataT<DWORD>(rarData, rce.nReminderTime);
  1308. }
  1309. if (rce.wFlags & xtpMAPIRcED_IsReminder)
  1310. {
  1311. // layout: [dw] - bool(0|1)
  1312. xtpAddDataT<DWORD>(rarData, rce.bIsReminder);
  1313. }
  1314. if (rce.wFlags & xtpMAPIRcED_Location)
  1315. {
  1316. xtpAddData_MapiExcStr8(rarData, rce.strLocation);
  1317. }
  1318. if (rce.wFlags & xtpMAPIRcED_BusyStatus)
  1319. {
  1320. // layout: [dw] - busy status [0..3] = XTPCalendarEventBusyStatus
  1321. xtpAddDataT<DWORD>(rarData, rce.nBusyStatus);
  1322. }
  1323. if (rce.wFlags & xtpMAPIRcED_IsAllDay)
  1324. {
  1325. // layout: [dw] - bool(0|1)
  1326. xtpAddDataT<DWORD>(rarData, rce.bIsAllDay);
  1327. }
  1328. if (rce.wFlags & xtpMAPIRcED_Label)
  1329. {
  1330. // layout: [dw] -
  1331. xtpAddDataT<DWORD>(rarData, rce.nLabel);
  1332. }
  1333. }
  1335. return TRUE;
  1336. }
  1340. DWORD CXTPCalendarMAPI_Recurrence::_CalcRCShiftX(CXTPCalendarRecurrencePattern* pPattern)
  1341. {
  1342. // FileTime zero date
  1343. static const COleDateTime cdtFTZero(1601, 1, 1, 0, 0, 0);
  1345. ASSERT(pPattern);
  1346. if (!pPattern)
  1347. {
  1348. return 0;
  1349. }
  1350. DWORD dwRCShiftX = 0;
  1352. COleDateTime dtPatternStart = pPattern->GetPatternStartDate();
  1353. COleDateTimeSpan spX;
  1355. XTP_CALENDAR_RECURRENCE_OPTIONS opt = pPattern->GetRecurrenceOptions();
  1357. // xtpMAPIRcType2_Daily
  1358. if (opt.m_nRecurrenceType == xtpCalendarRecurrenceDaily && !opt.m_Daily.bEveryWeekDayOnly)
  1359. {
  1361. spX = dtPatternStart - cdtFTZero;
  1362. int nIntervalDays = max(1, opt.m_Daily.nIntervalDays);
  1363. int nDay = (int)GETTOTAL_DAYS_DTS(spX);
  1365. dwRCShiftX = nDay % nIntervalDays;
  1366. dwRCShiftX *= 24 * 60; // convert to minutes
  1367. }
  1368. // xtpMAPIRcType2_Weekly
  1369. else if (opt.m_nRecurrenceType == xtpCalendarRecurrenceDaily && opt.m_Daily.bEveryWeekDayOnly ||
  1370.  opt.m_nRecurrenceType == xtpCalendarRecurrenceWeekly)
  1371. {
  1372. int nIntervalWeeks = 1;
  1373. if (opt.m_nRecurrenceType == xtpCalendarRecurrenceWeekly)
  1374. {
  1375. nIntervalWeeks = opt.m_Weekly.nIntervalWeeks;
  1376. }
  1378. spX = dtPatternStart - cdtFTZero;
  1379. int nWeek = ((int)(GETTOTAL_DAYS_DTS(spX) + 1)) / 7;
  1381. dwRCShiftX = (nWeek * 7 - 1) % (nIntervalWeeks * 7);
  1382. dwRCShiftX *= 24 * 60; // convert to minutes
  1383. }
  1384. else
  1385. {
  1386. //xtpMAPIRcType2_MonYearly
  1387. //xtpMAPIRcType2_MonYearly_Nth
  1389. int nIntervalMonths = -1;
  1391. if (opt.m_nRecurrenceType == xtpCalendarRecurrenceMonthly)
  1392. {
  1393. nIntervalMonths = opt.m_Monthly.nIntervalMonths;
  1394. }
  1395. else if (opt.m_nRecurrenceType == xtpCalendarRecurrenceMonthNth)
  1396. {
  1397. nIntervalMonths = opt.m_MonthNth.nIntervalMonths;
  1398. }
  1399. else if (opt.m_nRecurrenceType == xtpCalendarRecurrenceYearly ||
  1400.  opt.m_nRecurrenceType == xtpCalendarRecurrenceYearNth)
  1401. {
  1402. nIntervalMonths = 12;
  1403. }
  1404. else
  1405. {
  1406. ASSERT(FALSE);
  1407. return 0;
  1408. }
  1409. nIntervalMonths = max(1, nIntervalMonths);
  1411. // days per month   - jan feb mar apr may jun   jul aug sep oct nov dec
  1412. static int arDays[] = {31, 28, 31, 30, 31, 30,   31, 31, 30, 31, 30, 31};
  1413. int nMonth = dtPatternStart.GetMonth() + 12 * (dtPatternStart.GetYear() - 1601);
  1415. for (int i = 1 ; i < ((nMonth - 1) % nIntervalMonths) + 1; i++ )
  1416. {
  1417. dwRCShiftX += arDays[(i - 1) % 12];
  1418. }
  1419. dwRCShiftX *= 24 * 60; // convert to minutes
  1420. }
  1422. return dwRCShiftX;
  1423. }
  1425. COleDateTime CXTPCalendarMAPI_Recurrence::ConvertRecurrenceMinutesToDate(DWORD dwMinutes)
  1426. {
  1427. COleDateTime dt = (DATE)0;
  1429. ULONGLONG   ullDT = (ULONGLONG) dwMinutes * 60i64 * cFileTimeUnitsPerSecond;
  1430. FILETIME    ft = *((FILETIME*)&ullDT); // { (DWORD) ( fileTimeUnitsBeforeStart & 0xFFFFFFFF), (DWORD) ( fileTimeUnitsBeforeStart >> 32)};
  1432. SYSTEMTIME  st;
  1433. BOOL bRes = ::FileTimeToSystemTime(&ft, &st);
  1434. ASSERT(bRes);
  1435. if (bRes)
  1436. {
  1437. dt = st;
  1438. }
  1439. //  TRACE(_T("MAPItime to DT %d = %sn"), dwMinutes, dt.Format());
  1441. return dt;
  1442. }
  1444. DWORD CXTPCalendarMAPI_Recurrence::ConvertRecurrenceDateToMinutes(COleDateTime dt)
  1445. {
  1446. SYSTEMTIME st;
  1447. FILETIME ft = {0, 0};
  1449. if (!GETASSYSTEMTIME_DT(dt, st))
  1450. {
  1451. ASSERT(FALSE);
  1452. return 0;
  1453. }
  1454. if (!SystemTimeToFileTime(&st, &ft))
  1455. {
  1456. ASSERT(FALSE);
  1457. return 0;
  1458. }
  1460. ULONGLONG ullMinutes =  *((ULONGLONG*)&ft); //( ( (ULONGLONG) ft.dwHighDateTime) << 32) + ft.dwLowDateTime;
  1461. ullMinutes = ullMinutes / 60i64;
  1462. ullMinutes = ullMinutes / cFileTimeUnitsPerSecond;
  1463. return (DWORD)ullMinutes;
  1464. }
  1466. //////////////////////////////////////////////////////////////////////////
  1467. // see KB239795
  1469. STDMETHODIMP CXTPCalendarMAPIDataProvider::OpenInbox(
  1470. LPMDB lpMDB, LPMAPIFOLDER *lpInboxFolder, LPMAPIFOLDER *lpCalendarFolder, CXTPCalendarMAPIDataProvider* pProvider)
  1471. {
  1472. if (!lpMDB || !pProvider)
  1473. return E_POINTER;
  1475. ULONG        cbInbox;
  1476. LPENTRYID    lpbInbox;
  1477. ULONG        ulObjType;
  1478. HRESULT      hRes = S_OK;
  1479. LPMAPIFOLDER    lpTempFolder = NULL;
  1481. ULONG pCount; SPropValue *props;
  1482. SizedSPropTagArray(1, spec) = {1, {XTP_TAG_ID_MAPI_CALENDAR_FOLDER}};
  1484. *lpInboxFolder = NULL;
  1485. *lpCalendarFolder = NULL;
  1487. // The Inbox is usually the default receive folder for the message store
  1488. // You call this function as a shortcut to get it's Entry ID
  1489. hRes = lpMDB->GetReceiveFolder(
  1490. NULL,      // Get default receive folder
  1491. NULL,      // Flags
  1492. &cbInbox,  // Size and ...
  1493. &lpbInbox, // Value of the EntryID to be returned
  1494. NULL);     // You don't care to see the class returned
  1495. if (SUCCEEDED(hRes))
  1496. {
  1497. hRes = lpMDB->OpenEntry(
  1498. cbInbox,                      // Size and...
  1499. lpbInbox,                     // Value of the Inbox's EntryID
  1500. NULL,                         // We want the default interface    (IMAPIFolder)
  1501. MAPI_BEST_ACCESS,             // Flags
  1502. &ulObjType,                   // Object returned type
  1503. (LPUNKNOWN *) &lpTempFolder); // Returned folder
  1504. if (SUCCEEDED(hRes))
  1505. {
  1506. // Assign the out parameter
  1507. *lpInboxFolder = lpTempFolder;
  1509. // Open Calendar Folder
  1510. hRes = (*lpInboxFolder)->GetProps((SPropTagArray*)&spec, 0, &pCount, &props);
  1512. if (hRes == S_OK || hRes == MAPI_W_ERRORS_RETURNED)
  1513. {
  1514. if (props[0].ulPropTag != PT_ERROR)
  1515. {
  1516. hRes = lpMDB->OpenEntry(
  1517. props[0].Value.bin.cb,            // Size and...
  1518. (ENTRYID*)props[0].Value.bin.lpb, // Value of the Calendar's EntryID
  1519. NULL,                         // We want the default interface (IMAPIFolder)
  1520. MAPI_BEST_ACCESS,             // Flags
  1521. &ulObjType,                   // Object returned type
  1522. (LPUNKNOWN *) &lpTempFolder); // Returned folder
  1523. if (SUCCEEDED(hRes))
  1524. {
  1525. // Assign the out parameter
  1526. *lpCalendarFolder = lpTempFolder;
  1527. }
  1528. }
  1529. }
  1531. if (props)
  1532. {
  1533. pProvider->MAPIFreeBuffer(props);
  1534. props = NULL;
  1535. }
  1536. }
  1537. }
  1539. // Cleanup
  1540. pProvider->MAPIFreeBuffer(lpbInbox);
  1541. return hRes;
  1542. }
  1544. STDMETHODIMP CXTPCalendarMAPIDataProvider::OpenDefaultMessageStore(
  1545.    LPMAPISESSION lpMAPISession, LPMDB * lpMDB, CXTPCalendarMAPIDataProvider* pProvider)
  1546. {
  1547. if (!lpMAPISession || !pProvider)
  1548. return E_POINTER;
  1550. LPMAPITABLE pStoresTbl = NULL;
  1551. LPSRowSet   pRow = NULL;
  1552. static      SRestriction sres;
  1553. SPropValue  spv;
  1554. HRESULT     hRes;
  1555. LPMDB       lpTempMDB = NULL;
  1557. enum {EID, NAME, NUM_COLS};
  1558. static SizedSPropTagArray(NUM_COLS,sptCols) = {NUM_COLS, PR_ENTRYID, PR_DISPLAY_NAME};
  1560. *lpMDB = NULL;
  1562. //Get the table of all the message stores available
  1563. hRes = lpMAPISession->GetMsgStoresTable(0, &pStoresTbl);
  1564. if (SUCCEEDED(hRes))
  1565. {
  1566. //Set up restriction for the default store
  1567. sres.rt = RES_PROPERTY; //Comparing a property
  1568. sres.res.resProperty.relop = RELOP_EQ; //Testing equality
  1569. sres.res.resProperty.ulPropTag = PR_DEFAULT_STORE; //Tag to compare
  1570. sres.res.resProperty.lpProp = &spv; //Prop tag and value to compare against
  1572. spv.ulPropTag = PR_DEFAULT_STORE; //Tag type
  1573. spv.Value.b   = TRUE; //Tag value
  1575. //Convert the table to an array which can be stepped through
  1576. //Only one message store should have PR_DEFAULT_STORE set to true, so only one will be returned
  1577. hRes = pProvider->HrQueryAllRows(
  1578. pStoresTbl, //Table to query
  1579. (LPSPropTagArray) &sptCols, //Which columns to get
  1580. &sres, //Restriction to use
  1581. NULL, //No sort order
  1582. 0, //Max number of rows (0 means no limit)
  1583. &pRow); //Array to return
  1584. if (SUCCEEDED(hRes))
  1585. {
  1586. //Open the first returned (default) message store
  1587. hRes = lpMAPISession->OpenMsgStore(
  1588.   NULL,//Window handle for dialogs
  1589.   pRow->aRow[0].lpProps[EID].Value.bin.cb,//size and...
  1590.   (LPENTRYID)pRow->aRow[0].lpProps[EID].Value.bin.lpb,//value of entry to open
  1591.   NULL,//Use default interface (IMsgStore) to open store
  1592.   MAPI_BEST_ACCESS,//Flags
  1593.   &lpTempMDB);//Pointer to place the store in
  1594. if (SUCCEEDED(hRes))
  1595. {
  1596. //Assign the out parameter
  1597. *lpMDB = lpTempMDB;
  1598. }
  1599. }
  1600. }
  1602. // clean up
  1603. pProvider->FreeProws(pRow);
  1604. MAPI_RELEASE(pProvider, pStoresTbl);
  1605. if (FAILED(hRes))
  1606. {
  1607. LPMAPIERROR lpError;
  1608. HRESULT hr = lpMAPISession->GetLastError(hRes, 0, &lpError);
  1609. if (SUCCEEDED(hr) && lpError)
  1610. {
  1611. TRACE(_T("%sn%sn"), lpError->lpszError, lpError->lpszComponent);
  1612. pProvider->MAPIFreeBuffer(lpError);
  1613. }
  1614. }
  1615. return hRes;
  1616. }
  1618. /////////////////////////////////////////////////////////////////////////////
  1619. CXTPCalendarMAPIDataProvider::CXTPCalendarMemDPInternal::CXTPCalendarMemDPInternal(CXTPCalendarData* pDPExternal)
  1620. {
  1621. ASSERT(pDPExternal);
  1622. m_pDPExternal = pDPExternal;
  1623. }
  1625. void CXTPCalendarMAPIDataProvider::CXTPCalendarMemDPInternal::SendNotification(XTP_NOTIFY_CODE EventCode, WPARAM wParam , LPARAM lParam)
  1626. {
  1627. class CXTPCalendarDataSnNf : public CXTPCalendarData
  1628. {
  1629. public:
  1630. using CXTPCalendarData::SendNotification;
  1631. };
  1632. //===================================
  1633. if (m_bDisableNotificationsSending)
  1634. {
  1635. return;
  1636. }
  1637. if (m_pDPExternal)
  1638. {
  1639. ((CXTPCalendarDataSnNf*)m_pDPExternal)->SendNotification(EventCode, wParam, lParam);
  1640. }
  1641. else
  1642. {
  1643. CXTPCalendarData::SendNotification(EventCode, wParam, lParam);
  1644. }
  1645. }
  1646. //////////////////////////////////////////////////////////////////////////
  1647. CXTPCalendarMAPIDataProvider::CXTPCalendarMAPIDataProvider()
  1648. {
  1649. m_MapiHelper.m_pProvider = this;
  1651. m_typeProvider = xtpCalendarDataProviderMAPI;
  1653. m_bMAPIInitialized = FALSE;
  1654. m_lpMAPISession = NULL;
  1655. m_lpMDB = NULL;
  1656. m_lpCalendarFolder = NULL;
  1658. m_ulMAPIConID0 = 0;
  1659. m_ulMAPIConID1 = 0;
  1661. m_lpAdviseSink = NULL;
  1662. m_lpAdviseSink_ThrSafe = NULL;
  1664. //m_pMemDP = new CXTPCalendarMemoryDataProvider();
  1665. m_pMemDP = new CXTPCalendarMemDPInternal(this);
  1667. }
  1669. CXTPCalendarMAPIDataProvider::~CXTPCalendarMAPIDataProvider()
  1670. {
  1671. CMDTARGET_RELEASE(m_pMemDP);
  1672. }
  1674. CXTPCalendarEventsPtr CXTPCalendarMAPIDataProvider::DoRetrieveDayEvents(COleDateTime dtDay)
  1675. {
  1676. return m_pMemDP ? m_pMemDP->RetrieveDayEvents(dtDay) : NULL;
  1677. }
  1679. void CXTPCalendarMAPIDataProvider::DoRemoveAllEvents()
  1680. {
  1681. if (m_pMemDP)
  1682. {
  1683. m_pMemDP->RemoveAllEvents();
  1684. }
  1685. }
  1687. CXTPCalendarEventPtr CXTPCalendarMAPIDataProvider::DoRead_Event(DWORD dwEventID)
  1688. {
  1689. return m_pMemDP ? m_pMemDP->GetEvent(dwEventID) : NULL;
  1690. }
  1692. CXTPCalendarRecurrencePatternPtr CXTPCalendarMAPIDataProvider::DoRead_RPattern(DWORD dwPatternID)
  1693. {
  1694. return m_pMemDP ? m_pMemDP->GetRecurrencePattern(dwPatternID) : NULL;
  1695. }
  1697. BOOL CXTPCalendarMAPIDataProvider::DoCreate_Event(CXTPCalendarEvent* pEvent, DWORD& rdwNewEventID)
  1698. {
  1699. CXTPAutoResetValue<BOOL> autoReset(m_bDisableNotificationsSending, FALSE);
  1700. m_bDisableNotificationsSending = TRUE;
  1702. if (!IsOpen())
  1703. {
  1704. return FALSE;
  1705. }
  1707. if (!m_lpCalendarFolder || !m_pMemDP || !pEvent)
  1708. {
  1709. ASSERT(FALSE);
  1710. return FALSE;
  1711. }
  1712. DWORD dwEventID = pEvent->GetEventID();
  1714. int nRState = pEvent->GetRecurrenceState();
  1716. if (nRState != xtpCalendarRecurrenceNotRecurring &&
  1717. nRState != xtpCalendarRecurrenceMaster)
  1718. {
  1719. ASSERT(nRState == xtpCalendarRecurrenceException);
  1720. rdwNewEventID = GetNextUniqueEventID(dwEventID);
  1721. return TRUE;
  1722. }
  1724. LPMESSAGE pMessage = NULL;
  1725. HRESULT hr = m_lpCalendarFolder->CreateMessage(NULL, 0, &pMessage);
  1726. if (FAILED(hr) || !pMessage)
  1727. {
  1728. ASSERT(FALSE);
  1729. return FALSE;
  1730. }
  1732. if (!UpdateMAPIEvent(pMessage, pEvent))
  1733. {
  1734. MAPI_RELEASE(this, pMessage);
  1735. return FALSE;
  1736. }
  1738. // to ensure that PR_SEARCH_KEY property is valid
  1739. hr = pMessage->SaveChanges(KEEP_OPEN_READONLY);
  1740. if (FAILED(hr))
  1741. {
  1742. ASSERT(FALSE);
  1744. MAPI_RELEASE(this, pMessage);
  1745. return FALSE;
  1746. }
  1748. _SetEventRuntimeProps(pEvent->GetCustomProperties(), pMessage);
  1750. //-----------------------------------------------------------------------
  1751. CByteArray arSearchKey;
  1752. HRESULT hrID = _getPropVal(pMessage, PR_SEARCH_KEY, arSearchKey);
  1754. if (FAILED(hrID))
  1755. {
  1756. ASSERT(FALSE);
  1758. MAPI_RELEASE(this, pMessage);
  1759. return NULL;
  1760. }
  1762. rdwNewEventID = GetEventID((int)arSearchKey.GetSize(),
  1763.    (LPENTRYID)arSearchKey.GetData(), TRUE);
  1764. //-----------------------------------------------------------------------
  1765. pEvent->SetEventID(rdwNewEventID);
  1766. BOOL bRes = m_pMemDP->AddEvent(pEvent);
  1768. MAPI_RELEASE(this, pMessage);
  1770. return bRes;
  1771. }
  1773. BOOL CXTPCalendarMAPIDataProvider::DoUpdate_Event(CXTPCalendarEvent* pEvent)
  1774. {
  1775. CXTPAutoResetValue<BOOL> autoReset(m_bDisableNotificationsSending, FALSE);
  1776. m_bDisableNotificationsSending = TRUE;
  1778. if (!IsOpen())
  1779. {
  1780. return FALSE;
  1781. }
  1783. if (!m_lpCalendarFolder || !m_pMemDP || !pEvent)
  1784. {
  1785. ASSERT(FALSE);
  1786. return FALSE;
  1787. }
  1789. //=================================================
  1790. int nRState = pEvent->GetRecurrenceState();
  1792. if (nRState != xtpCalendarRecurrenceNotRecurring &&
  1793. nRState != xtpCalendarRecurrenceMaster)
  1794. {
  1795. ASSERT(nRState == xtpCalendarRecurrenceException);
  1796. return TRUE;
  1797. }
  1799. //=================================================
  1800. BOOL bRes = m_pMemDP->ChangeEvent(pEvent);
  1801. if (!bRes)
  1802. {
  1803. return FALSE;
  1804. }
  1806. DWORD dwEventID = pEvent->GetEventID();
  1807. CXTPMAPIBinary eKey;
  1809. if (!m_mapID.Lookup(dwEventID, eKey))
  1810. {
  1811. ASSERT(FALSE);
  1812. return FALSE;
  1813. }
  1815. LPMESSAGE pMessage = NULL;
  1816. ULONG ulObjType = NULL;
  1818. // Get event ID by its SearchKey
  1819. CXTPMAPIBinary eid = GetEntryID(eKey);
  1821. // open event from Calendar Folder storage
  1822. HRESULT hr = m_lpCalendarFolder->OpenEntry(
  1823. eid.GetBinarySize(), (LPENTRYID)eid.GetBinaryData(),
  1824. NULL,//default interface
  1825. MAPI_BEST_ACCESS,
  1826. &ulObjType,
  1827. (LPUNKNOWN*)&pMessage);
  1829. ASSERT(ulObjType == 5);
  1830. ASSERT(pMessage);
  1831. if (FAILED(hr) || !pMessage)
  1832. {
  1833. ASSERT(FALSE);
  1834. return FALSE;
  1835. }
  1837. if (!UpdateMAPIEvent(pMessage, pEvent))
  1838. {
  1839. MAPI_RELEASE(this, pMessage);
  1840. return FALSE;
  1841. }
  1843. hr = pMessage->SaveChanges(KEEP_OPEN_READONLY);
  1844. if (FAILED(hr))
  1845. {
  1846. ASSERT(FALSE);
  1848. MAPI_RELEASE(this, pMessage);
  1849. return FALSE;
  1850. }
  1851. //-----------------------------------------------------------------------
  1852. //  BOOL bRes = m_pMemDP->ChangeEvent(pEvent);
  1854. MAPI_RELEASE(this, pMessage);
  1856. return TRUE;
  1857. }
  1859. BOOL CXTPCalendarMAPIDataProvider::DoDelete_Event(CXTPCalendarEvent* pEvent)
  1860. {
  1861. CXTPAutoResetValue<BOOL> autoReset(m_bDisableNotificationsSending, FALSE);
  1862. m_bDisableNotificationsSending = TRUE;
  1864. if (!IsOpen())
  1865. {
  1866. return FALSE;
  1867. }
  1869. if (!m_lpCalendarFolder || !m_pMemDP || !pEvent)
  1870. {
  1871. ASSERT(FALSE);
  1872. return FALSE;
  1873. }
  1875. int nRState = pEvent->GetRecurrenceState();
  1877. if (nRState != xtpCalendarRecurrenceNotRecurring &&
  1878. nRState != xtpCalendarRecurrenceMaster)
  1879. {
  1880. ASSERT(nRState == xtpCalendarRecurrenceException);
  1881. return TRUE;
  1882. }
  1884. CXTPMAPIBinary eKey;
  1885. DWORD dwEventID = pEvent->GetEventID();
  1887. if (!m_mapID.Lookup(dwEventID, eKey))
  1888. {
  1889. // ASSERT(FALSE); // possible when copied appointments
  1890. return FALSE;
  1891. }
  1893. // get event ID by its SearchKey
  1894. CXTPMAPIBinary eid = GetEntryID(eKey);
  1896. // delete event
  1897. ENTRYLIST eidList1;
  1898. SBinary   eidBinary;
  1900. eidList1.cValues = 1;
  1901. eidList1.lpbin = &eidBinary;
  1903. eidBinary.cb = eid.GetBinarySize();
  1904. eidBinary.lpb = (BYTE*)eid.GetBinaryData();
  1906. HRESULT hr = m_lpCalendarFolder->DeleteMessages(&eidList1, 0, NULL, 0);
  1908. if (FAILED(hr))
  1909. {
  1910. ASSERT(FALSE);
  1911. return FALSE;
  1912. }
  1914. //-----------------------------------------------------------------------
  1915. return m_pMemDP ? m_pMemDP->DeleteEvent(pEvent) : FALSE;
  1916. }
  1918. BOOL CXTPCalendarMAPIDataProvider::DoCreate_RPattern(CXTPCalendarRecurrencePattern* pPattern, DWORD& rdwNewPatternID)
  1919. {
  1920. rdwNewPatternID = pPattern->GetPatternID();
  1921. return TRUE;
  1922. }
  1924. BOOL CXTPCalendarMAPIDataProvider::DoUpdate_RPattern(CXTPCalendarRecurrencePattern* pPattern)
  1925. {
  1926. UNREFERENCED_PARAMETER(pPattern);
  1927. return TRUE;
  1928. }
  1930. BOOL CXTPCalendarMAPIDataProvider::DoDelete_RPattern(CXTPCalendarRecurrencePattern* pPattern)
  1931. {
  1932. UNREFERENCED_PARAMETER(pPattern);
  1933. return TRUE;
  1934. }
  1936. CXTPCalendarEventsPtr CXTPCalendarMAPIDataProvider::DoGetUpcomingEvents(COleDateTime dtFrom, COleDateTimeSpan spPeriod)
  1937. {
  1938. UNREFERENCED_PARAMETER(dtFrom); UNREFERENCED_PARAMETER(spPeriod);
  1939. return DoGetAllEvents_raw();
  1940. }
  1943. CXTPCalendarEventsPtr CXTPCalendarMAPIDataProvider::DoGetAllEvents_raw()
  1944. {
  1945. return m_pMemDP ? m_pMemDP->GetAllEvents_raw() : NULL;
  1946. }
  1948. BOOL AFX_CDECL CXTPCalendarMAPIDataProvider::GetParameterValueFromConStr(LPCTSTR lpszConnectionString, LPCTSTR pcszParameterName, CString& rstrValue)
  1949. {
  1950. rstrValue.Empty();
  1952. ASSERT(lpszConnectionString && pcszParameterName);
  1954. if (!lpszConnectionString || !pcszParameterName ||
  1955. 0 == _tcslen(lpszConnectionString) || 0 == _tcslen(pcszParameterName))
  1956. {
  1957. return FALSE;
  1958. }
  1960. CString strConnStr_lower = lpszConnectionString;
  1961. strConnStr_lower.MakeLower();
  1963. CString strParameterName_lower = pcszParameterName;
  1964. strParameterName_lower.MakeLower();
  1966. int nIndex = strConnStr_lower.Find(strParameterName_lower + _T("="));
  1967. if (nIndex == -1)
  1968. nIndex = strConnStr_lower.Find(strParameterName_lower + _T(" ="));
  1970. if (nIndex == -1)
  1971. return FALSE;
  1973. int nParamNameLen = (int)_tcslen(pcszParameterName);
  1974. CString strParam = lpszConnectionString;
  1975. strParam = strParam.Mid(nIndex + nParamNameLen);
  1977. if (strParam[0] == _T(' '))
  1978. DELETE_S(strParam, 0);
  1979. if (strParam[0] == _T('='))
  1980. DELETE_S(strParam, 0);
  1982. if (strParam.IsEmpty())
  1983. return TRUE;
  1985. if (strParam[0] == _T(''') || strParam[0] == _T('"'))
  1986. {
  1987. if (strParam.GetLength() <= 2)
  1988. return TRUE;
  1990. TCHAR chQuot = strParam[0];
  1992. DELETE_S(strParam, 0);
  1994. int nQuot2Idx = FIND_S(strParam, chQuot, 0);
  1996. if (nQuot2Idx >= 0)
  1997. {
  1998. DELETE_S(strParam, nQuot2Idx, strParam.GetLength() - nQuot2Idx);
  1999. }
  2000. }
  2001. else
  2002. {
  2003. int nParamEndIdx = FIND_S(strParam, _T(';'), 0);
  2004. if (nParamEndIdx >= 0)
  2005. {
  2006. DELETE_S(strParam, nParamEndIdx, strParam.GetLength() - nParamEndIdx);
  2007. }
  2008. }
  2010. rstrValue = strParam;
  2012. return TRUE;
  2013. }
  2015. void CXTPCalendarMAPIDataProvider::GetMAPILogonParams(LPTSTR& rpszProfile, LPTSTR& rpszPassword, FLAGS& ruFlags)
  2016. {
  2017. rpszProfile = NULL;
  2018. rpszPassword = NULL;
  2019. ruFlags = MAPI_LOGON_UI; //Allow a profile picker box to show if not logged in
  2021. if (GetParameterValueFromConStr(m_strConnectionString, cszMAPIProfileName, m_strProfile_tmp))
  2022. rpszProfile = (LPTSTR)(LPCTSTR)m_strProfile_tmp;
  2024. if (GetParameterValueFromConStr(m_strConnectionString, cszMAPIPassword, m_strPassword_tmp))
  2025. rpszPassword = (LPTSTR)(LPCTSTR)m_strPassword_tmp;
  2027. CString strFlags;
  2029. if (GetParameterValueFromConStr(m_strConnectionString, cszMAPIFlags, strFlags))
  2030. {
  2031. DWORD dwFlags = 0;
  2032. SCANF_S(strFlags, _T("%x"), &dwFlags);
  2034. ruFlags = dwFlags;
  2035. }
  2036. }
  2038. BOOL CXTPCalendarMAPIDataProvider::Open()
  2039. {
  2040. if (m_pMemDP)
  2041. {
  2042. m_pMemDP->Open();
  2043. }
  2045. HRESULT       hRes;
  2046. LPMAPIFOLDER  lpInboxFolder = NULL;
  2047. LPSPropValue  lpCalendarFolderEntryID = NULL;
  2049. hRes = this->MAPIInitialize(NULL);
  2050. if (SUCCEEDED(hRes))
  2051. {
  2053. LPTSTR pcszProfile;
  2054. LPTSTR pcszPassword;
  2055. FLAGS uFlags;
  2057. GetMAPILogonParams(pcszProfile, pcszPassword, uFlags);
  2059. m_bMAPIInitialized = TRUE;
  2061. hRes = this->MAPILogonEx(0, pcszProfile, pcszPassword, uFlags, &m_lpMAPISession);
  2063. if (SUCCEEDED(hRes))
  2064. {
  2065. hRes = OpenDefaultMessageStore(m_lpMAPISession, &m_lpMDB, this);
  2066. if (SUCCEEDED(hRes))
  2067. {
  2068. hRes = OpenInbox(m_lpMDB, &lpInboxFolder, &m_lpCalendarFolder, this);
  2070. if (SUCCEEDED(hRes))
  2071. {
  2072. //Checking to see that we did get the Calendar folder
  2073. hRes = this->HrGetOneProp(m_lpCalendarFolder, PR_ENTRYID,
  2074. &lpCalendarFolderEntryID);
  2076. if (SUCCEEDED(hRes))
  2077. {
  2078. m_eidCalendarFolder.Set(lpCalendarFolderEntryID);
  2079. }
  2080. }
  2081. }
  2082. }
  2083. }
  2085. if (SUCCEEDED(hRes))
  2086. {
  2087. // copy all events to the cache data provider
  2088. if (m_pMemDP)
  2089. {
  2090. CXTPAutoResetValue<BOOL> autoReset(m_bDisableNotificationsSending, FALSE);
  2091. m_bDisableNotificationsSending = TRUE;
  2093. m_pMemDP->AddEvents(ImportAllEvents());
  2094. }
  2096. // advise to MAPI notifications
  2097. hRes = this->HrAllocAdviseSink(MAPICallBack_OnNotify, this, &m_lpAdviseSink);
  2098. ASSERT(SUCCEEDED(hRes) && m_lpAdviseSink);
  2100. hRes = this->HrThisThreadAdviseSink(m_lpAdviseSink, &m_lpAdviseSink_ThrSafe);
  2101. ASSERT(SUCCEEDED(hRes) && m_lpAdviseSink_ThrSafe);
  2103. if (SUCCEEDED(hRes) && m_lpAdviseSink_ThrSafe)
  2104. {
  2105. ULONG uEventsMask = fnevObjectCreated | fnevObjectDeleted | fnevObjectModified |
  2106. fnevObjectMoved; // | fnevObjectCopied;
  2108. ULONG uEIDsize =  lpCalendarFolderEntryID->Value.bin.cb;
  2109. LPENTRYID pEIDdata = (LPENTRYID)lpCalendarFolderEntryID->Value.bin.lpb;
  2111. hRes = m_lpMDB->Advise(0, NULL, uEventsMask, m_lpAdviseSink_ThrSafe,
  2112. &m_ulMAPIConID0);
  2113. ASSERT(SUCCEEDED(hRes));
  2115. // to receive fnevObjectDeleted notification
  2116. hRes = m_lpMDB->Advise(uEIDsize, pEIDdata, uEventsMask,
  2117. m_lpAdviseSink_ThrSafe, &m_ulMAPIConID1);
  2118. ASSERT(SUCCEEDED(hRes));
  2120. // to force Advise call in the RPC.
  2121. ULONG nValues = 0;
  2122. LPSPropValue pPropArray;
  2123. hRes = m_lpMDB->GetProps(NULL, 0, &nValues, &pPropArray);
  2124. ASSERT(SUCCEEDED(hRes));
  2126. MAPI_FREEBUFFER(this, pPropArray);
  2127. }
  2128. }
  2130. MAPI_FREEBUFFER(this, lpCalendarFolderEntryID);
  2131. MAPI_RELEASE(this, lpInboxFolder);
  2133. if (FAILED(hRes))
  2134. {
  2135. // cleanup
  2136. m_bOpened = TRUE; // to let Close run.
  2137. Close();
  2138. }
  2140. if (SUCCEEDED(hRes))
  2141. {
  2142. CXTPCalendarData::Open();
  2143. }
  2145. return SUCCEEDED(hRes);
  2146. }
  2148. BOOL CXTPCalendarMAPIDataProvider::Create()
  2149. {
  2150. return Open();
  2151. }
  2153. BOOL CXTPCalendarMAPIDataProvider::Save()
  2154. {
  2155. CXTPCalendarData::Save();
  2156. return TRUE;
  2157. }
  2159. void CXTPCalendarMAPIDataProvider::Close()
  2160. {
  2161. if (!m_bOpened)
  2162. return;
  2164. if (m_pMemDP)
  2165. {
  2166. m_pMemDP->Close();
  2167. }
  2169. HRESULT hRes = 0;
  2171. // Unadvise -------------------------------------
  2172. if (m_ulMAPIConID0)
  2173. {
  2174. hRes = m_lpMDB->Unadvise(m_ulMAPIConID0);
  2175. ASSERT(SUCCEEDED(hRes));
  2176. m_ulMAPIConID0 = 0;
  2177. }
  2179. if (m_ulMAPIConID1)
  2180. {
  2181. hRes = m_lpMDB->Unadvise(m_ulMAPIConID1);
  2182. ASSERT(SUCCEEDED(hRes));
  2183. m_ulMAPIConID1 = 0;
  2184. }
  2186. // release opened objects -----------------------
  2187. MAPI_RELEASE(this, m_lpAdviseSink_ThrSafe);
  2188. MAPI_RELEASE(this, m_lpAdviseSink);
  2190. MAPI_RELEASE(this, m_lpCalendarFolder);
  2191. MAPI_RELEASE(this, m_lpMDB);
  2193. // LogOff session -------------------------------
  2194. if (m_lpMAPISession)
  2195. {
  2196. hRes = m_lpMAPISession->Logoff(0, 0, 0);
  2197. ASSERT(SUCCEEDED(hRes));
  2198. }
  2199. MAPI_RELEASE(this, m_lpMAPISession);
  2201. // Initialize MAPI dll --------------------------
  2202. if (m_bMAPIInitialized)
  2203. {
  2204. this->MAPIUninitialize();
  2205. m_bMAPIInitialized = FALSE;
  2206. }
  2208. CXTPCalendarData::Close();
  2209. }
  2211. BOOL CXTPCalendarMAPIDataProvider::IsOpen()
  2212. {
  2213. return m_lpCalendarFolder != NULL;
  2214. }
  2216. //LPSRestriction CXTPCalendarMAPIDataProvider::BuildDayRestriction(const COleDateTime dtDay)
  2217. //{
  2218. //  return 0;
  2219. ///*    static SRestriction sres;
  2220. //  static SPropValue spv[2];
  2221. //  static SRestriction sr[2];
  2222. //  ZeroMemory(spv, 2 * sizeof(SPropValue));
  2223. //  // Set up restriction for the current day event
  2224. //  sres.rt = RES_AND; // Comparing a property
  2225. //  sres.res.resAnd.cRes = 2; // Count of restrictions
  2226. //  sres.res.resAnd.lpRes = sr;
  2227. //
  2228. //  // Start time is current or less
  2229. //  sr[0].rt = RES_PROPERTY; // Comparing a property
  2230. //  sr[0].res.resProperty.relop = RELOP_LE; // lower or equal
  2231. //  sr[0].res.resProperty.ulPropTag = XTP_PR_MAPI_EVENT_START_TIME; // Tag to compare
  2232. //  sr[0].res.resProperty.lpProp = &spv[0]; // Prop tag and value to compare against
  2233. //
  2234. //  spv[0].ulPropTag = XTP_PR_MAPI_EVENT_START_TIME; // Tag type
  2235. //  SYSTEMTIME st;
  2236. //  COleDateTime dtEndDay = CXTPCalendarUtils::ResetTime(dtDay) + COleDateTimeSpan(0, 23, 59, 59);
  2237. //  if (dtEndDay.GetAsSystemTime(st))
  2238. //  {
  2239. //      SystemTimeToFileTime(&st, &spv[0].Value.ft); // Tag value
  2240. //  }
  2241. //
  2242. //  // End time is more or current
  2243. //  sr[1].rt = RES_PROPERTY; // Comparing a property
  2244. //  sr[1].res.resProperty.relop = RELOP_GE; // greater or equal
  2245. //  sr[1].res.resProperty.ulPropTag = XTP_PR_MAPI_EVENT_END_TIME; // Tag to compare
  2246. //  sr[1].res.resProperty.lpProp = &spv[1]; // Prop tag and value to compare against
  2247. //
  2248. //  spv[1].ulPropTag = XTP_PR_MAPI_EVENT_END_TIME; // Tag type
  2249. //  if (CXTPCalendarUtils::ResetTime(dtDay).GetAsSystemTime(st))
  2250. //  {
  2251. //      SystemTimeToFileTime(&st, &spv[1].Value.ft); // Tag value
  2252. //  }
  2253. //
  2254. //  return &sres;
  2255. //  */
  2256. //}
  2258. LPSRestriction CXTPCalendarMAPIDataProvider::BuildBinaryRestriction(ULONG cbSize, LPBYTE lpData, ULONG ulPropTag)
  2259. {
  2260. static SRestriction sres;
  2261. static SPropValue spv;
  2262. ZeroMemory(&spv, sizeof(SPropValue));
  2263. // Set up restriction for the current day event
  2264. sres.rt = RES_PROPERTY; // Comparing a property
  2265. sres.res.resProperty.relop = RELOP_EQ; // Equal
  2266. sres.res.resProperty.ulPropTag = ulPropTag; // Entry ID
  2267. sres.res.resProperty.lpProp = &spv; // Prop tag and value to compare against
  2269. spv.ulPropTag = ulPropTag; // Tag type
  2270. spv.Value.bin.cb = cbSize;
  2271. spv.Value.bin.lpb = lpData;
  2273. return &sres;
  2274. }
  2276. void CXTPCalendarMAPIDataProvider::_SetEventRuntimeProps(CXTPCalendarCustomProperties* pEventProps, LPMESSAGE pMessage)
  2277. {
  2278. ASSERT(pEventProps && pMessage);
  2279. if (!pEventProps || !pMessage)
  2280. return;
  2282. CByteArray arEntryID, arSearchKey;
  2284. HRESULT hrID = _getPropVal(pMessage, PR_ENTRYID, arEntryID);
  2285. if (SUCCEEDED(hrID))
  2286. {
  2287. COleVariant varEntryID(arEntryID);
  2288. pEventProps->SetProperty(cszMAPIpropVal_EntryID, varEntryID);
  2289. }
  2291. hrID = _getPropVal(pMessage, PR_SEARCH_KEY, arSearchKey);
  2292. if (SUCCEEDED(hrID))
  2293. {
  2294. COleVariant varSearchKey(arSearchKey);
  2295. pEventProps->SetProperty(cszMAPIpropVal_SearchKey, varSearchKey);
  2296. }
  2297. }
  2299. void CXTPCalendarMAPIDataProvider::_MoveMAPIEventRuntimeProps(CXTPCalendarCustomProperties* pDest,
  2300. CXTPCalendarCustomProperties* pSrc)
  2301. {
  2302. ASSERT(pSrc && pDest);
  2303. if (!pSrc || !pDest)
  2304. return;
  2306. COleVariant varValue;
  2308. if (pDest && pSrc->GetProperty(cszMAPIpropVal_EntryID, varValue))
  2309. {
  2310. pDest->SetProperty(cszMAPIpropVal_EntryID, varValue);
  2311. }
  2312. pSrc->RemoveProperty(cszMAPIpropVal_EntryID);
  2314. if (pDest && pSrc->GetProperty(cszMAPIpropVal_SearchKey, varValue))
  2315. {
  2316. pDest->SetProperty(cszMAPIpropVal_SearchKey, varValue);
  2317. }
  2318. pSrc->RemoveProperty(cszMAPIpropVal_SearchKey);
  2319. }
  2321. CXTPCalendarEventPtr CXTPCalendarMAPIDataProvider::ImportEvent_FromCalendarFolderOnly(
  2322. ULONG cbEntryID, LPENTRYID lpEntryID)
  2323. {
  2324. LPSRestriction pRestriction = BuildBinaryRestriction(cbEntryID, (LPBYTE)lpEntryID, PR_ENTRYID);
  2325. CXTPCalendarEventsPtr ptrEvents = ImportAllEvents(pRestriction);
  2327. CXTPCalendarEventPtr ptrEvent;
  2328. if (ptrEvents && ptrEvents->GetCount())
  2329. {
  2330. ASSERT(ptrEvents->GetCount() == 1);
  2331. ptrEvent = ptrEvents->GetAt(0, TRUE);
  2332. }
  2333. return ptrEvent;
  2334. }
  2336. CXTPCalendarEventPtr CXTPCalendarMAPIDataProvider::ImportEvent(LPSRow lpRow)
  2337. {
  2338. if (!lpRow)
  2339. return NULL;
  2341. // ------- ID --------
  2342. if (PR_ENTRYID != lpRow->lpProps[0].ulPropTag)
  2343. {
  2344. ASSERT(FALSE);
  2345. return NULL;
  2346. }
  2348. CXTPCalendarEventPtr ptrEvent = ImportEvent(lpRow->lpProps[0].Value.bin.cb,
  2349. (LPENTRYID)lpRow->lpProps[0].Value.bin.lpb);
  2351. return ptrEvent;
  2352. }
  2354. CXTPCalendarEventPtr CXTPCalendarMAPIDataProvider::ImportEvent(ULONG cbEntryID,
  2355. LPENTRYID lpEntryID)
  2356. {
  2357. if (cbEntryID == 0 || !lpEntryID)
  2358. {
  2359. ASSERT(FALSE);
  2360. return NULL;
  2361. }
  2363. LPMESSAGE pMessage = NULL;
  2364. ULONG ulObjType = NULL;
  2366. // open event from Calendar Folder storage
  2367. m_lpCalendarFolder->OpenEntry(cbEntryID, lpEntryID,
  2368. NULL,//default interface
  2369. MAPI_BEST_ACCESS,
  2370. &ulObjType,
  2371. (LPUNKNOWN*)&pMessage);
  2373. ASSERT(ulObjType == 5);
  2374. ASSERT(pMessage);
  2375. if (!pMessage)
  2376. return NULL;
  2378. CXTPCalendarEventPtr ptrEvent = ImportEvent(pMessage);
  2380. MAPI_RELEASE(this, pMessage);
  2382. return ptrEvent;
  2383. }
  2386. CXTPCalendarEventPtr CXTPCalendarMAPIDataProvider::ImportEvent(LPMESSAGE pMessage)
  2387. {
  2388. ASSERT(pMessage);
  2389. if (!pMessage)
  2390. return NULL;
  2392. //-----------------------------------------------------------------------
  2393. CByteArray arSearchKey;
  2394. HRESULT hrID = _getPropVal(pMessage, PR_SEARCH_KEY, arSearchKey);
  2395. if (FAILED(hrID))
  2396. {
  2397. ASSERT(FALSE);
  2398. return NULL;
  2399. }
  2401. DWORD dwEventID = GetEventID((int)arSearchKey.GetSize(),
  2402.  (LPENTRYID)arSearchKey.GetData(), TRUE);
  2404. //============================================================
  2405. CXTPCalendarEventPtr ptrEvent(CreateNewEvent(dwEventID));
  2407. // ------- Is Recurrence --------
  2408. int nIsRecurrence = _getPropVal_int(pMessage, xtpMAPIpropEvent_IsRecuring);
  2410. // get TimeZone
  2411. TIME_ZONE_INFORMATION tziEvent;
  2412. GetTimeZoneInformation(&tziEvent);
  2414. if (nIsRecurrence)
  2415. {
  2416. ULONG ulTZTag = m_MapiHelper.GetPropTagByID(pMessage, xtpMAPIpropEvent_TimeZone);
  2417. CByteArray arTZIData;
  2418. HRESULT hrTZ = _getPropVal(pMessage, ulTZTag, arTZIData);
  2420. if (SUCCEEDED(hrTZ))
  2421. {
  2422. xtp_GetWinTZInfo(arTZIData, &tziEvent);
  2423. }
  2424. }
  2426. XTP_TRACE_READ_EVENTS(_T("nEvent:------------------n"));
  2428. // ------- Subject --------
  2429. CString strTmp = _getPropVal_str(pMessage, PR_SUBJECT);
  2430. ptrEvent->SetSubject(strTmp);
  2431. XTP_TRACE_READ_EVENTS(_T("Subject: %sn"), strTmp);
  2433. // ------- Body --------
  2434. strTmp = _getPropVal_str(pMessage, PR_BODY);
  2435. ptrEvent->SetBody(strTmp);
  2436. XTP_TRACE_READ_EVENTS(_T("Body: %sn"), strTmp.Left(255));
  2438. // ------- StartTime --------
  2439. SYSTEMTIME stUTC = _getPropVal_UtcTime(pMessage, xtpMAPIpropEvent_StartTime);
  2440. //TRACE(_T("StartTime orig: %sn"), dtTmp.Format());
  2441. COleDateTime dtTmp = xtp_UtcToTzTime(&tziEvent, stUTC);
  2442. ptrEvent->SetStartTime(dtTmp);
  2443. XTP_TRACE_READ_EVENTS(_T("StartTime tz  : %sn"), dtTmp.Format());
  2445. // ------- EndTime --------
  2446. stUTC = _getPropVal_UtcTime(pMessage, xtpMAPIpropEvent_EndTime);
  2447. dtTmp = xtp_UtcToTzTime(&tziEvent, stUTC);
  2448. ptrEvent->SetEndTime(dtTmp);
  2449. //XTP_TRACE_READ_EVENTS(_T("EndTime: %sn"), ptrEvent->GetEndTime().Format());
  2451. // ------- LOCATION --------
  2452. strTmp = _getPropVal_str(pMessage, xtpMAPIpropEvent_Location);
  2453. ptrEvent->SetLocation(strTmp);
  2454. XTP_TRACE_READ_EVENTS(_T("LOCATION: %sn"), strTmp.Left(255));
  2456. // ------- AllDayEvent --------
  2457. int nTmp = _getPropVal_int(pMessage, xtpMAPIpropEvent_AllDay);
  2458. ptrEvent->SetAllDayEvent(nTmp != 0);
  2459. XTP_TRACE_READ_EVENTS(_T("All day: %dn"), nTmp);
  2461. // ------- IsReminder --------
  2462. nTmp = _getPropVal_int(pMessage, xtpMAPIpropCommon_ReminderSet);
  2463. ptrEvent->SetReminder(nTmp);
  2465. // ------- ReminderMinutesBeforeStart --------
  2466. nTmp = _getPropVal_int(pMessage, xtpMAPIpropCommon_ReminderMinutesBefore);
  2467. ptrEvent->SetReminderMinutesBeforeStart(nTmp);
  2469. // ------- BusyStatus --------
  2470. nTmp = _getPropVal_int(pMessage, xtpMAPIpropEvent_BusyStatus);
  2471. ptrEvent->SetBusyStatus(nTmp);
  2473. // ------- Importance --------
  2474. nTmp = _getPropVal_int(pMessage, PR_IMPORTANCE);
  2475. ptrEvent->SetImportance(nTmp);
  2477. // ------- Label --------
  2478. nTmp = _getPropVal_int(pMessage, xtpMAPIpropEvent_Color);
  2479. ptrEvent->SetLabelID(nTmp);
  2481. // ------- Meeting --------
  2482. nTmp = _getPropVal_int(pMessage, xtpMAPIpropEvent_MeetingStatus);
  2483. ptrEvent->SetMeeting(nTmp != 0);
  2485. // ------- Private --------
  2486. nTmp = _getPropVal_int(pMessage, xtpMAPIpropCommon_IsPrivate);
  2487. ptrEvent->SetPrivate(nTmp != 0);
  2489. // ------- CreationTime --------
  2490. stUTC = _getPropVal_UtcTime(pMessage, PR_CREATION_TIME);
  2491. dtTmp = xtp_UtcToTzTime(&tziEvent, stUTC);
  2492. ptrEvent->SetCreationTime(dtTmp);
  2494. // ------- LastModificationTime --------
  2495. stUTC = _getPropVal_UtcTime(pMessage, PR_LAST_MODIFICATION_TIME);
  2496. dtTmp = xtp_UtcToTzTime(&tziEvent, stUTC);
  2497. ptrEvent->SetLastModificationTime(dtTmp);
  2499. // ------- Custom Properties -------
  2500. CXTPCalendarCustomProperties* pProps = ptrEvent->GetCustomProperties();
  2501. if (pProps)
  2502. {
  2503. strTmp = _getPropVal_str(pMessage, xtpMAPIpropEvent_CustomProperties);
  2504. pProps->LoadFromXML(strTmp);
  2506. _SetEventRuntimeProps(pProps, pMessage);
  2507. }
  2509. // nIsRecurrence
  2510. if (nIsRecurrence)
  2511. {
  2512. ULONG ulPropTag = m_MapiHelper.GetPropTagByID(pMessage, xtpMAPIpropEvent_RecurrenceState);
  2513. CByteArray arRecData;
  2514. HRESULT hr = _getPropVal(pMessage, ulPropTag, arRecData);
  2515. ASSERT(SUCCEEDED(hr));
  2517. VERIFY(ptrEvent->MakeEventAsRecurrence());
  2518. ImportRecurrence(ptrEvent, arRecData);
  2519. }
  2520. // -------
  2522. return ptrEvent;
  2523. }
  2525. int CXTPCalendarMAPIDataProvider::GetEventGlobalPropVal_int(LPCTSTR pcszPropName, int nDefault)
  2526. {
  2527. CXTPCalendarCustomProperties* pProps = GetCustomProperties();
  2529. ASSERT(pProps);
  2530. if (!pProps)
  2531. return nDefault;
  2533. COleVariant varValue;
  2534. BOOL bRes = pProps->GetProperty(pcszPropName, varValue);
  2535. if (!bRes)
  2536. return nDefault;
  2538. if (varValue.vt != VT_I4)
  2539. {
  2540. if (FAILED(::VariantChangeType(&varValue, &varValue, 0, VT_I4)))
  2541. return nDefault;
  2542. }
  2543. return V_I4(&varValue);
  2544. }
  2546. CString CXTPCalendarMAPIDataProvider::GetEventGlobalPropVal_str(LPCTSTR pcszPropName, LPCTSTR pcszDefault)
  2547. {
  2548. CXTPCalendarCustomProperties* pProps = GetCustomProperties();
  2550. ASSERT(pProps);
  2551. if (!pProps)
  2552. return pcszDefault;
  2554. COleVariant varValue;
  2555. BOOL bRes = pProps->GetProperty(pcszPropName, varValue);
  2556. if (!bRes)
  2557. return pcszDefault;
  2559. if (varValue.vt != VT_BSTR)
  2560. {
  2561. if (FAILED(::VariantChangeType(&varValue, &varValue, 0, VT_BSTR)))
  2562. return pcszDefault;
  2563. }
  2565. return CString(V_BSTR(&varValue));
  2566. }
  2568. void CXTPCalendarMAPIDataProvider::_SetMAPIEventGlobalPropsIfNeed(LPMESSAGE pMessage,
  2569.    CXTPCalendarEvent* pEvent)
  2570. {
  2571. if (!pMessage || !pEvent)
  2572. {
  2573. ASSERT(FALSE);
  2574. return;
  2575. }
  2577. //-----------------------------------------------------------------------
  2578. int nPropTag;
  2580. //**** Common customizable properties
  2581. int nRState = pEvent->GetRecurrenceState();
  2582. int nApptIcon = (nRState == xtpCalendarRecurrenceMaster) ? cnMAPIpropVal_AppointmentIconRecurr :
  2583. cnMAPIpropVal_AppointmentIcon;
  2585. VERIFY(_setPropTagVal_int(pMessage, XTP_PR_MAPI_EVENT_ICON_INDEX, nApptIcon));
  2587. //---------------------------------------
  2588. CString strMsgClass = GetEventGlobalPropVal_str(cszMAPIpropName_AppointmentMessageClass,
  2589. cszMAPIpropVal_AppointmentMessageClass);
  2590. VERIFY(_setPropTagVal_str(pMessage, PR_MESSAGE_CLASS_A, strMsgClass));
  2592. //---------------------------------------
  2593. nPropTag = m_MapiHelper.GetPropTagByID(pMessage, xtpMAPIpropCommon_OutlookInternalVersion);
  2595. int nOutlookVer = _getPropVal_int(pMessage, nPropTag);
  2596. if (nOutlookVer == 0)
  2597. {
  2598. nOutlookVer = GetEventGlobalPropVal_int(cszMAPIpropName_OutlookInternalVersion,
  2599. cnMAPIpropVal_OutlookInternalVersionDef);
  2600. VERIFY(_setPropTagVal_int(pMessage, nPropTag, nOutlookVer));
  2601. }
  2603. //---------------------------------------
  2604. nPropTag = m_MapiHelper.GetPropTagByID(pMessage, xtpMAPIpropCommon_OutlookVersion);
  2605. CString strOutlookVer = _getPropVal_str(pMessage, nPropTag);
  2606. if (strOutlookVer.IsEmpty())
  2607. {
  2608. strOutlookVer = GetEventGlobalPropVal_str(cszMAPIpropName_OutlookVersion,
  2609. cszMAPIpropVal_OutlookVersionDef);
  2610. VERIFY(_setPropTagVal_str(pMessage, nPropTag, strOutlookVer));
  2611. }
  2612. }
  2614. BOOL CXTPCalendarMAPIDataProvider::UpdateMAPIEvent(LPMESSAGE pMessage,
  2615.    CXTPCalendarEvent* pEvent)
  2616. {
  2617. if (!pMessage || !pEvent)
  2618. {
  2619. ASSERT(FALSE);
  2620. return FALSE;
  2621. }
  2623. //-----------------------------------------------------------------------
  2624. // ------- Is Recurrence --------
  2625. int nRState = pEvent->GetRecurrenceState();
  2627. int nIsRecurrence = (nRState == xtpCalendarRecurrenceMaster);
  2629. if (nRState != xtpCalendarRecurrenceNotRecurring &&
  2630. nRState != xtpCalendarRecurrenceMaster)
  2631. {
  2632. ASSERT(FALSE);
  2633. return TRUE;
  2634. }
  2636. // get TimeZone
  2637. //  TIME_ZONE_INFORMATION tziEvent;
  2638. //  GetTimeZoneInformation(&tziEvent);
  2640. int nPropTag;
  2641. //-------------------
  2643. //**** Common customizable properties
  2644. _SetMAPIEventGlobalPropsIfNeed(pMessage, pEvent);
  2645. //****
  2647. // ------- Subject --------
  2648. CString strTmp = pEvent->GetSubject();
  2649. VERIFY(_setPropTagVal_str(pMessage, PR_SUBJECT_A, strTmp));
  2651. // ------- Body --------
  2652. strTmp = pEvent->GetBody();
  2653. VERIFY(_setPropTagVal_str(pMessage, PR_BODY_A, strTmp));
  2655. // ------- StartTime --------
  2656. COleDateTime dtTmp = pEvent->GetStartTime();
  2657. SYSTEMTIME stUTCstart = xtp_TimeToUtc(dtTmp);
  2658. ASSERT(stUTCstart.wYear);
  2659. nPropTag = m_MapiHelper.GetPropTagByID(pMessage, xtpMAPIpropEvent_StartTime);
  2660. VERIFY(_setPropTagVal_UtcTime(pMessage, nPropTag, stUTCstart));
  2662. // ------- EndTime --------
  2663. dtTmp = pEvent->GetEndTime();
  2664. SYSTEMTIME stUTCend = xtp_TimeToUtc(dtTmp);
  2665. ASSERT(stUTCend.wYear);
  2666. nPropTag = m_MapiHelper.GetPropTagByID(pMessage, xtpMAPIpropEvent_EndTime);
  2667. VERIFY(_setPropTagVal_UtcTime(pMessage, nPropTag, stUTCend));
  2669. // ------- LOCATION --------
  2670. strTmp = pEvent->GetLocation();
  2671. nPropTag = m_MapiHelper.GetPropTagByID(pMessage, xtpMAPIpropEvent_Location);
  2672. VERIFY(_setPropTagVal_str(pMessage, nPropTag, strTmp));
  2674. // ------- AllDayEvent --------
  2675. int nTmp = pEvent->IsAllDayEvent();
  2676. nPropTag = m_MapiHelper.GetPropTagByID(pMessage, xtpMAPIpropEvent_AllDay);
  2677. VERIFY(_setPropTagVal_int(pMessage, nPropTag, nTmp));
  2679. // ------- IsReminder --------
  2680. nTmp = pEvent->IsReminder();
  2681. nPropTag = m_MapiHelper.GetPropTagByID(pMessage, xtpMAPIpropCommon_ReminderSet);
  2682. VERIFY(_setPropTagVal_int(pMessage, nPropTag, nTmp));
  2684. // ------- ReminderMinutesBeforeStart --------
  2685. nTmp = pEvent->GetReminderMinutesBeforeStart();
  2686. nPropTag = m_MapiHelper.GetPropTagByID(pMessage, xtpMAPIpropCommon_ReminderMinutesBefore);
  2687. VERIFY(_setPropTagVal_int(pMessage, nPropTag, nTmp));
  2689. // ------- ReminderDate --------
  2690. ULONG nPTagRmdDate = m_MapiHelper.GetPropTagByID(pMessage, xtpMAPIpropCommon_ReminderDate);
  2692. if (pEvent->IsReminder())
  2693. {
  2694. VERIFY(_setPropTagVal_UtcTime(pMessage, nPTagRmdDate, stUTCstart)); // always equal to start time
  2695. }
  2696. else
  2697. {
  2698. _deletePropTag(pMessage, nPTagRmdDate);
  2699. }
  2701. // ------- BusyStatus --------
  2702. nTmp = pEvent->GetBusyStatus();
  2703. nPropTag = m_MapiHelper.GetPropTagByID(pMessage, xtpMAPIpropEvent_BusyStatus);
  2704. VERIFY(_setPropTagVal_int(pMessage, nPropTag, nTmp));
  2706. // ------- Importance --------
  2707. nTmp = pEvent->GetImportance();
  2708. VERIFY(_setPropTagVal_int(pMessage, PR_IMPORTANCE, nTmp));
  2710. // ------- Label --------
  2711. nTmp = pEvent->GetLabelID();
  2712. nPropTag = m_MapiHelper.GetPropTagByID(pMessage, xtpMAPIpropEvent_Color);
  2713. VERIFY(_setPropTagVal_int(pMessage, nPropTag, nTmp));
  2715. // ------- Meeting --------
  2716. nTmp = pEvent->IsMeeting();
  2717. nPropTag = m_MapiHelper.GetPropTagByID(pMessage, xtpMAPIpropEvent_MeetingStatus);
  2718. VERIFY(_setPropTagVal_int(pMessage, nPropTag, nTmp));
  2720. // ------- Private --------
  2721. nTmp = pEvent->IsPrivate();
  2722. nPropTag = m_MapiHelper.GetPropTagByID(pMessage, xtpMAPIpropCommon_IsPrivate);
  2723. VERIFY(_setPropTagVal_int(pMessage, nPropTag, nTmp));
  2724. VERIFY(_setPropTagVal_int(pMessage, PR_SENSITIVITY, nTmp ? SENSITIVITY_PRIVATE : SENSITIVITY_NONE));
  2726. // ------- CreationTime --------
  2727. dtTmp = pEvent->GetCreationTime();
  2728. SYSTEMTIME stUTC = xtp_TimeToUtc(dtTmp);
  2729. ASSERT(stUTC.wYear);
  2730. VERIFY(_setPropTagVal_UtcTime(pMessage, PR_CREATION_TIME, stUTC));
  2732. // ------- LastModificationTime --------
  2733. dtTmp = pEvent->GetLastModificationTime();
  2734. stUTC = xtp_TimeToUtc(dtTmp);
  2735. ASSERT(stUTC.wYear);
  2736. VERIFY(_setPropTagVal_UtcTime(pMessage, PR_LAST_MODIFICATION_TIME, stUTC));
  2738. // -------- Custom Properties -------
  2739. CXTPCalendarCustomProperties* pProps = pEvent->GetCustomProperties();
  2740. if (pProps)
  2741. {
  2742. CXTPCalendarCustomProperties tmpStorage;
  2743. _MoveMAPIEventRuntimeProps(&tmpStorage, pProps);
  2745. pProps->SaveToXML(strTmp);
  2747. nPropTag = m_MapiHelper.GetPropTagByID(pMessage, xtpMAPIpropEvent_CustomProperties);
  2748. VERIFY(_setPropTagVal_str(pMessage, nPropTag, strTmp));
  2750. _MoveMAPIEventRuntimeProps(pProps, &tmpStorage);
  2751. }
  2753. // nIsRecurrence
  2754. nPropTag = m_MapiHelper.GetPropTagByID(pMessage, xtpMAPIpropEvent_IsRecuring);
  2755. VERIFY(_setPropTagVal_int(pMessage, nPropTag, nIsRecurrence));
  2757. if (nIsRecurrence)
  2758. {
  2759. CByteArray arRecData;
  2760. CXTPCalendarMAPI_Recurrence::CXTPRcData RCData;
  2761. CXTPCalendarRecurrencePatternPtr ptrPattern = pEvent->GetRecurrencePattern();
  2763. BOOL bRes = CXTPCalendarMAPI_Recurrence::FillRCData(RCData, ptrPattern, pEvent);
  2764. ASSERT(bRes);
  2765. if (bRes)
  2766. {
  2767. bRes = CXTPCalendarMAPI_Recurrence::RCDataToBin(RCData, arRecData);
  2768. ASSERT(bRes);
  2769. if (bRes)
  2770. {
  2771. nPropTag = m_MapiHelper.GetPropTagByID(pMessage, xtpMAPIpropEvent_RecurrenceState);
  2772. VERIFY(_setPropTagVal_bin(pMessage, nPropTag, arRecData));
  2773. }
  2774. }
  2776. //---------------------------------------------------------------------
  2777. TIME_ZONE_INFORMATION tziEvent;
  2778. GetTimeZoneInformation(&tziEvent);
  2780. CByteArray arTZIData;
  2781. xtp_GetMapiTZInfo(&tziEvent, arTZIData);
  2783. ULONG ulTZTag = m_MapiHelper.GetPropTagByID(pMessage, xtpMAPIpropEvent_TimeZone);
  2784. VERIFY(_setPropTagVal_bin(pMessage, ulTZTag, arTZIData));
  2786. //- recurrence Start/end ----------------------------------------------
  2787. nPropTag = m_MapiHelper.GetPropTagByID(pMessage, xtpMAPIpropEvent_RecurrenceStart);
  2788. VERIFY(_setPropTagVal_UtcTime(pMessage, nPropTag, stUTCstart));
  2790. nPropTag = m_MapiHelper.GetPropTagByID(pMessage, xtpMAPIpropEvent_RecurrenceEnd);
  2791. VERIFY(_setPropTagVal_UtcTime(pMessage, nPropTag, stUTCend));
  2793. if (ptrPattern->GetUseEndMethod() == xtpCalendarPatternEndNoDate)
  2794. {
  2795. // the end date set above was for 1 Jan 9999, which is fine for Outlook
  2796. // but at least some versions of exchange server don't like it. Outlook
  2797. // sets the end date to the end date/time of the first instance of the
  2798. // pattern in this case.
  2800. // ------- Fixed EndTime --------
  2801. int nDuration = RCData.dwOccEndTime - RCData.dwOccStartTime;
  2803. dtTmp = pEvent->GetStartTime() + CXTPCalendarUtils::Minutes2Span(nDuration);
  2804. stUTCend = xtp_TimeToUtc(dtTmp);
  2805. ASSERT(stUTCend.wYear);
  2807. nPropTag = m_MapiHelper.GetPropTagByID(pMessage, xtpMAPIpropEvent_EndTime);
  2808. VERIFY(_setPropTagVal_UtcTime(pMessage, nPropTag, stUTCend));
  2809. }
  2810. }
  2811. else
  2812. {
  2813. CUIntArray arPropsTags;
  2814. arPropsTags.Add( (ULONG)m_MapiHelper.GetPropTagByID(pMessage, xtpMAPIpropEvent_RecurrenceState));
  2815. arPropsTags.Add( (ULONG)m_MapiHelper.GetPropTagByID(pMessage, xtpMAPIpropEvent_RecurrenceStart));
  2816. arPropsTags.Add( (ULONG)m_MapiHelper.GetPropTagByID(pMessage, xtpMAPIpropEvent_RecurrenceEnd));
  2817. arPropsTags.Add( (ULONG)m_MapiHelper.GetPropTagByID(pMessage, xtpMAPIpropEvent_TimeZone));
  2819. _deletePropsTags(pMessage, arPropsTags);
  2820. }
  2822. // -------
  2824. return TRUE;
  2825. }
  2827. UINT CXTPCalendarMAPIDataProvider::_getStreamSize(IStream* pStream)
  2828. {
  2829. ASSERT(pStream);
  2830. if (!pStream)
  2831. {
  2832. return 0;
  2833. }
  2835. ULARGE_INTEGER  uliSize = {0, 0};
  2836. LARGE_INTEGER   liZero = {0, 0};
  2838. HRESULT hr = pStream->Seek(liZero, STREAM_SEEK_END, &uliSize);
  2839. if (FAILED(hr))
  2840. return 0;
  2842. hr = pStream->Seek(liZero, STREAM_SEEK_SET, NULL);
  2843. if (FAILED(hr))
  2844. {
  2845. return 0;
  2846. }
  2847. return uliSize.u.LowPart;
  2848. }
  2850. int CXTPCalendarMAPIDataProvider::_getSimpleMAPITypeSize(int nType)
  2851. {
  2852. switch(nType)
  2853. {
  2854. case PT_I2:     return 2;       /* Signed 16-bit value */
  2855. case PT_LONG:   return 4;       /* Signed 32-bit value */
  2856. case PT_R4:     return 4;       /* 4-byte floating point */
  2857. case PT_DOUBLE:     return 8;   /* Floating point double */
  2858. case PT_CURRENCY:   return 8;   /* Signed 64-bit int (decimal w/    4 digits right of decimal pt) */
  2859. case PT_APPTIME:    return sizeof(double);  /* Application time */
  2860. case PT_ERROR:      return 4;   /* 32-bit error value */
  2861. case PT_BOOLEAN:    return 2;   /* 16-bit boolean (non-zero true) */
  2862. case PT_I8:         return 8;   /* 8-byte signed integer */
  2863. case PT_SYSTIME:    return sizeof(FILETIME);    /* FILETIME 64-bit int w/ number of 100ns periods since Jan 1,1601 */
  2864. case PT_CLSID:      return sizeof(GUID);        /* OLE GUID */
  2866. case PT_OBJECT:     /* Embedded object in a property */
  2868. case PT_STRING8:    /* Null terminated 8-bit character string */
  2869. case PT_UNICODE:    /* Null terminated Unicode string */
  2870. case PT_BINARY:     /* Uninterpreted (counted byte array) */
  2871. return 0;
  2872. default:
  2873. ASSERT(FALSE);
  2874. }
  2875. return 0;
  2876. }
  2878. BOOL CXTPCalendarMAPIDataProvider::_setPropTagVal_int(LPMESSAGE pMessage,
  2879.   ULONG ulPropTag, int nValue)
  2880. {
  2881. int nType = PROP_TYPE(ulPropTag);
  2882. int nTypeSize = _getSimpleMAPITypeSize(nType);
  2884. if (nTypeSize <= 0 || nTypeSize > 4)
  2885. {
  2886. ASSERT(FALSE);
  2887. return FALSE;
  2888. }
  2890. SPropValue PropVal;
  2891. ZeroMemory(&PropVal, sizeof(PropVal));
  2893. PropVal.ulPropTag = ulPropTag;
  2895. switch(nType)
  2896. {
  2897. case PT_I2:
  2898. PropVal.Value.i = (short int)nValue;
  2899. break;
  2900. case PT_LONG:           /* Signed 32-bit value */
  2901. PropVal.Value.l = (long)nValue;
  2902. break;
  2903. case PT_ERROR:      /* 32-bit error value */
  2904. PropVal.Value.err = (SCODE)nValue;
  2905. break;
  2906. case PT_BOOLEAN:        /* 16-bit boolean (non-zero true) */
  2907. PropVal.Value.b = (unsigned short int)nValue;
  2908. break;
  2910. //  case PT_R4:     return 4;       /* 4-byte floating point */
  2911. //  case PT_DOUBLE:     return 8;   /* Floating point double */
  2912. //  case PT_CURRENCY:   return 8;   /* Signed 64-bit int (decimal w/    4 digits right of decimal pt) */
  2913. //  case PT_APPTIME:    return sizeof(double);  /* Application time */
  2915. //  case PT_I8:         return 8;   /* 8-byte signed integer */
  2916. //  case PT_SYSTIME:    return sizeof(FILETIME);    /* FILETIME 64-bit int w/ number of 100ns periods since Jan 1,1601 */
  2917. //  case PT_CLSID:      return sizeof(GUID);        /* OLE GUID */
  2919. //  case PT_OBJECT:     /* Embedded object in a property */
  2921. //  case PT_STRING8:    /* Null terminated 8-bit character string */
  2922. //  case PT_UNICODE:    /* Null terminated Unicode string */
  2923. //  case PT_BINARY:     /* Uninterpreted (counted byte array) */
  2924. //      return 0;
  2925. default:
  2926. ASSERT(FALSE);
  2927. return FALSE;
  2928. }
  2930. HRESULT hRes = this->HrSetOneProp(pMessage, &PropVal);
  2931. return SUCCEEDED(hRes);
  2932. }
  2934. BOOL CXTPCalendarMAPIDataProvider::_setPropTagVal_str(LPMESSAGE pMessage,
  2935.   ULONG ulPropTag, LPCTSTR pcszValue)
  2936. {
  2937. int nType = PROP_TYPE(ulPropTag);
  2939. LPSPropValue pPropVal = NULL;
  2941. if (nType == PT_STRING8) /* Null terminated 8-bit character string */
  2942. {
  2943. int nStrBuffSize = (int)_tcslen(pcszValue) * sizeof(TCHAR) + 2;
  2944. int nBufSize = sizeof(SPropValue) + nStrBuffSize + 4;
  2946. SCODE sc = this->MAPIAllocateBuffer(nBufSize, (void**)&pPropVal);
  2947. if (sc != S_OK || !pPropVal)
  2948. {
  2949. return FALSE;
  2950. }
  2951. ZeroMemory(pPropVal, nBufSize);
  2952. pPropVal->ulPropTag = ulPropTag;
  2953. pPropVal->Value.lpszA = (LPSTR)(pPropVal+1);
  2955. WCSTOMBS_S(pPropVal->Value.lpszA, pcszValue, nStrBuffSize);
  2956. }
  2957. else if (nType == PT_UNICODE) /* Null terminated Unicode string */
  2958. {
  2959. ASSERT(FALSE); //not implemented
  2960. return FALSE;
  2961. }
  2962. else
  2963. {
  2964. ASSERT(FALSE);
  2965. return FALSE;
  2966. }
  2968. HRESULT hRes = this->HrSetOneProp(pMessage, pPropVal);
  2970. MAPI_FREEBUFFER(this, pPropVal);
  2972. return SUCCEEDED(hRes);
  2973. }
  2975. BOOL CXTPCalendarMAPIDataProvider::_setPropTagVal_UtcTime(LPMESSAGE pMessage,
  2976.   ULONG ulPropTag, const SYSTEMTIME& stTime)
  2977. {
  2978. int nType = PROP_TYPE(ulPropTag);
  2980. SPropValue PropVal;
  2981. ZeroMemory(&PropVal, sizeof(SPropValue));
  2983. if (nType == PT_SYSTIME) // FILETIME
  2984. {
  2985. PropVal.ulPropTag = ulPropTag;
  2987. FILETIME ft;
  2988. ZeroMemory(&ft, sizeof(ft));
  2990. if (!SystemTimeToFileTime(&stTime, &ft))
  2991. {
  2992. ASSERT(FALSE);
  2993. return FALSE;
  2994. }
  2995. PropVal.Value.ft = ft;
  2996. }
  2997. else
  2998. {
  2999. ASSERT(FALSE);
  3000. return FALSE;
  3001. }
  3003. HRESULT hRes = this->HrSetOneProp(pMessage, &PropVal);
  3004. return SUCCEEDED(hRes);
  3005. }
  3007. BOOL CXTPCalendarMAPIDataProvider::_setPropTagVal_bin(LPMESSAGE pMessage,
  3008. ULONG ulPropTag, const CByteArray& arData)
  3009. {
  3010. int nType = PROP_TYPE(ulPropTag);
  3012. SPropValue PropVal;
  3013. ZeroMemory(&PropVal, sizeof(SPropValue));
  3015. if (nType == PT_BINARY)
  3016. {
  3017. PropVal.ulPropTag = ulPropTag;
  3018. PropVal.Value.bin.cb = (ULONG)arData.GetSize();
  3019. PropVal.Value.bin.lpb = (BYTE*)arData.GetData();
  3020. }
  3021. else
  3022. {
  3023. ASSERT(FALSE);
  3024. return FALSE;
  3025. }
  3027. HRESULT hRes = this->HrSetOneProp(pMessage, &PropVal);
  3029. return SUCCEEDED(hRes);
  3030. }
  3032. HRESULT CXTPCalendarMAPIDataProvider::_getPropVal(LPMESSAGE pMessage,
  3033.   ULONG ulPropTag, CByteArray& rData)
  3034. {
  3035. rData.RemoveAll();
  3037. LPSTREAM pStream = NULL;
  3038. LPSPropValue pProp = NULL;
  3040. HRESULT hRes = this->HrGetOneProp(pMessage, ulPropTag, &pProp);
  3042. if (hRes == MAPI_E_NOT_ENOUGH_MEMORY)
  3043. {
  3044. hRes = pMessage->OpenProperty(ulPropTag, &IID_IStream, STGM_READ,
  3045. NULL, (LPUNKNOWN*)&pStream);
  3047. if (FAILED(hRes) || !pStream)
  3048. {
  3049. hRes = FAILED(hRes) ? hRes : E_FAIL;
  3050. }
  3051. else
  3052. {
  3053. UINT nDataSize = _getStreamSize(pStream);
  3054. if (!nDataSize)
  3055. {
  3056. hRes = E_FAIL;
  3057. }
  3058. else
  3059. {
  3060. rData.SetSize((int)nDataSize);
  3062. ULONG nDataSize2 = 0;
  3063. hRes = pStream->Read(rData.GetData(), nDataSize, &nDataSize2);
  3065. ASSERT(nDataSize == nDataSize2);
  3066. rData.SetSize((int)nDataSize2);
  3067. }
  3068. pStream->Release();
  3069. }
  3071. }
  3072. else if (SUCCEEDED(hRes))
  3073. {
  3074. int nType = PROP_TYPE(pProp->ulPropTag);
  3075. int nTypeSize = _getSimpleMAPITypeSize(nType);
  3077. void* pData_src = NULL;
  3078. if (nTypeSize > 0)
  3079. {
  3080. pData_src = (void*)&pProp->Value;
  3081. }
  3082. else
  3083. {
  3084. if (nType == PT_STRING8) /* Null terminated 8-bit character string */
  3085. {
  3086. pData_src = (void*)pProp->Value.lpszA;
  3087. nTypeSize = (int)strlen(pProp->Value.lpszA) + 1;
  3088. }
  3089. else if (nType == PT_UNICODE) /* Null terminated Unicode string */
  3090. {
  3091. pData_src = (void*)pProp->Value.lpszW;
  3092. nTypeSize = (int)wcslen(pProp->Value.lpszW) * 2 + 2;
  3093. }
  3094. else if (nType == PT_BINARY) /* Uninterpreted (counted byte array) */
  3095. {
  3096. pData_src = (void*)pProp->Value.bin.lpb;
  3097. nTypeSize = pProp->Value.bin.cb;
  3098. }
  3099. }
  3101. rData.SetSize(nTypeSize);
  3102. MEMCPY_S(rData.GetData(), pData_src, nTypeSize);
  3103. }
  3105. MAPI_FREEBUFFER(this, pProp);
  3107. return hRes;
  3108. }
  3110. CString CXTPCalendarMAPIDataProvider::_getPropVal_str(LPMESSAGE pMessage,
  3111.   ULONG ulPropTag)
  3112. {
  3113. CString str;
  3114. CByteArray arData;
  3116. int nType = PROP_TYPE(ulPropTag);
  3117. ASSERT(nType == PT_STRING8 || nType == PT_UNICODE);
  3119. HRESULT hr = _getPropVal(pMessage, ulPropTag, arData);
  3121. if (FAILED(hr) || arData.GetSize() == 0)
  3122. {
  3123. return str;
  3124. }
  3126. if (nType == PT_STRING8) /* Null terminated 8-bit character string */
  3127. {
  3128. str = (LPCSTR)arData.GetData();
  3129. }
  3130. else if (nType == PT_UNICODE) /* Null terminated Unicode string */
  3131. {
  3132. str = (LPCWSTR)arData.GetData();
  3133. }
  3134. return str;
  3135. }
  3137. int CXTPCalendarMAPIDataProvider::_getPropVal_int(LPMESSAGE pMessage, ULONG ulPropTag)
  3138. {
  3139. CByteArray arData;
  3141. int nType = PROP_TYPE(ulPropTag);
  3142. ASSERT( nType == PT_I2 ||       nType == PT_LONG ||
  3143. nType == PT_ERROR ||    nType == PT_BOOLEAN ||
  3144. nType == PT_I8);
  3146. HRESULT hr = _getPropVal(pMessage, ulPropTag, arData);
  3148. if (FAILED(hr) || arData.GetSize() == 0)
  3149. {
  3150. return 0;
  3151. }
  3153. int nSize = (int)arData.GetSize();
  3154. int nValue = 0;
  3156. ASSERT(sizeof(ULONGLONG) == 8);
  3158. if (nSize == 1)
  3159. {
  3160. nValue = (int)arData[0];
  3161. }
  3162. else if (nSize == 2)
  3163. {
  3164. nValue = (int)*((WORD*)arData.GetData());
  3165. }
  3166. else if (nSize == 3)
  3167. {
  3168. nValue = (int)RGB(arData[0], arData[1], arData[2]);
  3169. }
  3170. else if (nSize == 4)
  3171. {
  3172. nValue = (int)*((DWORD*)arData.GetData());
  3173. }
  3174. else if (nSize == 8)
  3175. {
  3176. nValue = (int)*((ULONGLONG*)arData.GetData());
  3177. }
  3178. else
  3179. {
  3180. ASSERT(FALSE);
  3181. }
  3183. return nValue;
  3184. }
  3186. SYSTEMTIME CXTPCalendarMAPIDataProvider::_getPropVal_UtcTime(LPMESSAGE pMessage,
  3187.    ULONG ulPropTag)
  3188. {
  3189. SYSTEMTIME stUTCTime, stUTCTime0;
  3190. ZeroMemory(&stUTCTime, sizeof(stUTCTime));
  3191. ZeroMemory(&stUTCTime0, sizeof(stUTCTime0));
  3193. if (ulPropTag == 0)
  3194. {
  3195. return stUTCTime0;
  3196. }
  3198. int nType = PROP_TYPE(ulPropTag);
  3200. if (nType != PT_SYSTIME)
  3201. {
  3202. ASSERT(FALSE);
  3203. return stUTCTime0;
  3204. }
  3206. CByteArray arData;
  3207. HRESULT hr = _getPropVal(pMessage, ulPropTag, arData);
  3209. if (FAILED(hr) || arData.GetSize() == 0)
  3210. {
  3211. return stUTCTime0;
  3212. }
  3213. ASSERT(arData.GetSize() == sizeof(FILETIME));
  3215. FILETIME* pUTCTime = ((FILETIME*)arData.GetData());
  3217. if (FileTimeToSystemTime(pUTCTime, &stUTCTime))
  3218. {
  3219. return stUTCTime;
  3220. }
  3222. return stUTCTime0;
  3223. }
  3225. CString CXTPCalendarMAPIDataProvider::_getPropVal_str(LPMESSAGE pMessage,
  3226. const XTP_MAPI_PROP_NAME& propNameEx)
  3227. {
  3228. ULONG ulPropTag = m_MapiHelper.GetPropTagByID(pMessage, propNameEx);
  3230. return _getPropVal_str(pMessage, ulPropTag);
  3231. }
  3233. int CXTPCalendarMAPIDataProvider::_getPropVal_int(LPMESSAGE pMessage,
  3234. const XTP_MAPI_PROP_NAME& propNameEx)
  3235. {
  3236. ULONG ulPropTag = m_MapiHelper.GetPropTagByID(pMessage, propNameEx);
  3238. return _getPropVal_int(pMessage, ulPropTag);
  3239. }
  3241. SYSTEMTIME CXTPCalendarMAPIDataProvider::_getPropVal_UtcTime(LPMESSAGE pMessage,
  3242. const XTP_MAPI_PROP_NAME& propNameEx)
  3243. {
  3244. ULONG ulPropTag = m_MapiHelper.GetPropTagByID(pMessage, propNameEx);
  3246. return _getPropVal_UtcTime(pMessage, ulPropTag);
  3247. }
  3249. HRESULT CXTPCalendarMAPIDataProvider::_deletePropTag(LPMESSAGE pMessage, ULONG ulPropTag)
  3250. {
  3251. CUIntArray arPropsTags;
  3252. arPropsTags.Add(ulPropTag);
  3254. return _deletePropsTags(pMessage, arPropsTags);
  3255. }
  3257. HRESULT CXTPCalendarMAPIDataProvider::_deletePropsTags(LPMESSAGE pMessage, CUIntArray& arPropsTags)
  3258. {
  3259. if (!pMessage || arPropsTags.GetSize() == 0)
  3260. {
  3261. ASSERT(FALSE);
  3262. return E_INVALIDARG;
  3263. }
  3265. int nTagsCount = (int)arPropsTags.GetSize();
  3266. SPropTagArray* pPorpTagsArray = NULL;
  3268. int nBufSize = sizeof(SPropTagArray) + nTagsCount * sizeof(ULONG) + 4;
  3269. SCODE sc = this->MAPIAllocateBuffer(nBufSize, (void**)&pPorpTagsArray);
  3270. if (sc != S_OK || !pPorpTagsArray)
  3271. {
  3272. return E_OUTOFMEMORY;
  3273. }
  3275. //---------------------------------------------
  3276. pPorpTagsArray->cValues = nTagsCount;
  3277. for (int i = 0; i < nTagsCount; i++)
  3278. {
  3279. pPorpTagsArray->aulPropTag[i] = (ULONG)arPropsTags[i];
  3280. }
  3282. HRESULT hrDelete = pMessage->DeleteProps(pPorpTagsArray, NULL);
  3284. //---------------------------------------------
  3285. MAPI_FREEBUFFER(this, pPorpTagsArray);
  3287. return hrDelete;
  3288. }
  3290. void CXTPCalendarMAPIDataProvider::ImportRecurrence(CXTPCalendarEvent* pMasterEvent,
  3291. const CByteArray& arRCData)
  3292. {
  3293. ASSERT(pMasterEvent->GetRecurrenceState() == xtpCalendarRecurrenceMaster);
  3295. CXTPCalendarRecurrencePatternPtr ptrPattern = pMasterEvent->GetRecurrencePattern();
  3296. ASSERT(ptrPattern);
  3297. if (!ptrPattern)
  3298. {
  3299. return;
  3300. }
  3302. CXTPCalendarMAPI_Recurrence::CXTPRcData RCData;
  3304. BOOL bRead = CXTPCalendarMAPI_Recurrence::ReadRCData(RCData, arRCData);
  3305. ASSERT(bRead);
  3307. if (!bRead)
  3308. {
  3309. return;
  3310. }
  3311. ASSERT((RCData.wType - xtpMAPIRcType_Daily) >= 0 && (RCData.wType - xtpMAPIRcType_Daily) <= 3);
  3313. CXTPCalendarMAPI_Recurrence::SetRecurrenceOptions(ptrPattern, RCData);
  3315. CXTPCalendarMAPI_Recurrence::SetRecurrenceExceptions(pMasterEvent, ptrPattern, RCData);
  3317. VERIFY( pMasterEvent->UpdateRecurrence(ptrPattern) );
  3318. }
  3320. CXTPCalendarEventsPtr CXTPCalendarMAPIDataProvider::ImportAllEvents(LPSRestriction lpRestriction)
  3321. {
  3322. HRESULT hRes = S_OK;
  3323. LPMAPITABLE lpContentsTable = NULL;
  3324. LPSRowSet pRows = NULL;
  3325. ULONG i;
  3326. CXTPCalendarEventsPtr ptrEvents = new CXTPCalendarEvents();
  3328. static SizedSPropTagArray(1, sptCols) = {1, {PR_ENTRYID} };
  3330. hRes = m_lpCalendarFolder->GetContentsTable(0, &lpContentsTable);
  3332. if (SUCCEEDED(hRes))
  3333. {
  3334. hRes = this->HrQueryAllRows(lpContentsTable, (LPSPropTagArray) &sptCols,
  3335.   lpRestriction, //restriction...current day
  3336.   NULL,//sort order...we're not using this parameter
  3337.   0, &pRows);
  3339. if (SUCCEEDED(hRes))
  3340. {
  3341. for (i = 0; i < pRows->cRows; i++)
  3342. {
  3343. CXTPCalendarEventPtr ptrNextEvent = ImportEvent(&pRows->aRow[i]);
  3344. ASSERT(ptrNextEvent);
  3345. if (ptrNextEvent)
  3346. {
  3347. ptrEvents->Add(ptrNextEvent);
  3348. }
  3349. }
  3350. }
  3351. }
  3353. //-------------------------------------------------------------------------
  3354. if (pRows)
  3355. {
  3356. this->FreeProws(pRows);
  3357. }
  3359. MAPI_RELEASE(this, lpContentsTable);
  3361. return ptrEvents;
  3362. }
  3364. BOOL CXTPCalendarMAPIDataProvider::ImportNewEvents()
  3365. {
  3366. ASSERT(m_pMemDP);
  3367. if (!m_pMemDP)
  3368. {
  3369. return FALSE;
  3370. }
  3372. BOOL bChanged = FALSE;
  3374. HRESULT hRes = S_OK;
  3375. LPMAPITABLE lpContentsTable = NULL;
  3376. LPSRowSet pRows = NULL;
  3377. ULONG i;
  3378. CMap_EventIDs mapExistingEntries;
  3379. CMap_EventIDs mapMissedEntries;
  3381. // Retrieve EntryID's of all items from the MAPI Calendar folder
  3382. static SizedSPropTagArray(2, sptCols) = {2, {PR_ENTRYID, PR_SEARCH_KEY} };
  3384. hRes = m_lpCalendarFolder->GetContentsTable(0, &lpContentsTable);
  3386. if (SUCCEEDED(hRes))
  3387. {
  3388. hRes = this->HrQueryAllRows(lpContentsTable, (LPSPropTagArray) &sptCols,
  3389. NULL, //lpRestriction, //restriction...current day??
  3390. NULL,//sort order...we're not using this parameter
  3391. 0, &pRows);
  3393. if (SUCCEEDED(hRes))
  3394. {
  3395. // Iterate all appointment items read from data source
  3396. for (i = 0; i < pRows->cRows; i++)
  3397. {
  3398. // ------- SEARCH_KEY --------
  3399. if (PR_SEARCH_KEY != pRows->aRow[i].lpProps[1].ulPropTag)
  3400. {
  3401. ASSERT(FALSE);
  3402. continue;
  3403. }
  3404. // trying to find this eventID
  3405. DWORD dwEventID = GetEventID(pRows->aRow[i].lpProps[1].Value.bin.cb,
  3406. (LPENTRYID)pRows->aRow[i].lpProps[1].Value.bin.lpb);
  3408. // if not found - import
  3409. if (XTP_CALENDAR_UNKNOWN_EVENT_ID == dwEventID)
  3410. {
  3411. CXTPCalendarEventPtr ptrNextEvent = ImportEvent(&pRows->aRow[i]);
  3412. ASSERT(ptrNextEvent);
  3413. if (ptrNextEvent)
  3414. {
  3415. bChanged = TRUE;
  3416. VERIFY(m_pMemDP->AddEvent(ptrNextEvent));
  3417. }
  3418. }
  3419. else
  3420. {
  3421. // if event found - add its ID into a map
  3422. mapExistingEntries.SetAt(dwEventID, TRUE);
  3423. }
  3424. }
  3426. // Delete all items which exists in internal data storage, but
  3427. // were not just found in the contents table of the external folder.
  3428. m_mapID.FindMissing(mapExistingEntries, mapMissedEntries);
  3429. POSITION pos = mapMissedEntries.GetStartPosition();
  3430. DWORD dwKey;
  3431. BOOL bValue = FALSE;
  3432. while (pos != NULL)
  3433. {
  3434. bChanged = TRUE;
  3435. mapMissedEntries.GetNextAssoc(pos, dwKey, bValue);
  3437. CXTPCalendarEventPtr ptrEventToDel = m_pMemDP->GetEvent(dwKey);
  3438. // ASSERT(ptrEventToDel); // could be NULL if processing a few notifications in a row
  3439. if (ptrEventToDel)
  3440. {
  3441. VERIFY(m_pMemDP->DeleteEvent(ptrEventToDel));
  3442. }
  3443. }
  3444. }
  3445. }
  3447. // Cleanup
  3448. if (pRows)
  3449. {
  3450. this->FreeProws(pRows);
  3451. }
  3452. MAPI_RELEASE(this, lpContentsTable);
  3454. return bChanged;
  3455. }
  3457. LONG STDAPICALLTYPE CXTPCalendarMAPIDataProvider::MAPICallBack_OnNotify(
  3458. LPVOID          lpvContext,
  3459. ULONG           cNotif,
  3460. LPNOTIFICATION  lpNotif)
  3461. {
  3462. BOOL bProcessed = FALSE;
  3463. // get current MAPI data provider
  3464. CXTPCalendarMAPIDataProvider* pThis = (CXTPCalendarMAPIDataProvider*)lpvContext;
  3465. ASSERT(pThis);
  3466. if (!pThis)
  3467. return MAPI_E_INVALID_PARAMETER;
  3469. CXTPCalendarData* pMemDP = pThis->m_pMemDP;
  3471. if (!pMemDP)
  3472. {
  3473. return S_OK;
  3474. }
  3476. //***********************
  3477. SAFE_MANAGE_STATE(pThis->m_pModuleState);
  3478. //***********************
  3480. XTP_TRACE_MAPI_NF(_T("n MAPICallBack_OnNotify [%s] (notifications count = %d)n"),
  3481.   COleDateTime::GetCurrentTime().Format(), (int)cNotif);
  3483. for (int i = 0; i < (int)cNotif; i++)
  3484. {
  3485. ULONG ulNfSender = lpNotif[i].info.obj.ulObjType;
  3486. ULONG ulNfType = lpNotif[i].ulEventType;
  3488. XTP_TRACE_MAPI_NF(_T("    NfSender = %d (%s)n"), (int)ulNfSender,
  3489. ulNfSender == MAPI_FOLDER ? _T("MAPI_FOLDER") : (ulNfSender == MAPI_MESSAGE ? _T("MAPI_MESSAGE") : _T("")) );
  3491. // Check is notification related to active calendar folder ----------
  3492. CString str_dbg_CalRel;
  3493. CXTPMAPIBinary eidObj;
  3494. if (ulNfSender == MAPI_FOLDER)
  3495. {
  3496. eidObj.Set(lpNotif[i].info.obj.cbEntryID, (LPBYTE)lpNotif[i].info.obj.lpEntryID);
  3497. str_dbg_CalRel = _T("this");
  3498. }
  3499. else if (ulNfSender == MAPI_MESSAGE)
  3500. {
  3501. eidObj.Set(lpNotif[i].info.obj.cbParentID, (LPBYTE)lpNotif[i].info.obj.lpParentID);
  3502. str_dbg_CalRel = _T("Parent folder");
  3503. }
  3505. if (!pThis->Equal(eidObj, pThis->m_eidCalendarFolder))
  3506. {
  3507. if (ulNfSender == MAPI_MESSAGE)
  3508. {
  3509. eidObj.Set(lpNotif[i].info.obj.cbOldParentID, (LPBYTE)lpNotif[i].info.obj.lpOldParentID);
  3510. if (!pThis->Equal(eidObj, pThis->m_eidCalendarFolder))
  3511. {
  3512. XTP_TRACE_MAPI_NF(_T("    Calendar is: not related! SKIP. n"));
  3513. continue;
  3514. }
  3515. else
  3516. {
  3517. str_dbg_CalRel = _T("OLD Parent folder");
  3518. pThis->ImportNewEvents();
  3519. bProcessed = TRUE;
  3520. }
  3521. }
  3522. else
  3523. {
  3524. XTP_TRACE_MAPI_NF(_T("    Calendar is: not related! SKIP. n"));
  3525. continue;
  3526. }
  3527. }
  3529. XTP_TRACE_MAPI_NF(_T("    Calendar is: %sn"), str_dbg_CalRel);
  3531. CString str_dbg_NF;
  3532. str_dbg_NF += (ulNfType & fnevObjectCreated) ? _T(" | Created") : _T("");
  3533. str_dbg_NF += (ulNfType & fnevObjectDeleted) ? _T(" | Deleted") : _T("");
  3534. str_dbg_NF += (ulNfType & fnevObjectModified) ?_T(" | Modified") : _T("");
  3535. str_dbg_NF += (ulNfType & fnevObjectMoved)   ? _T(" | Moved") : _T("");
  3536. str_dbg_NF += (ulNfType & fnevObjectCopied)  ? _T(" | Copied") : _T("");
  3538. XTP_TRACE_MAPI_NF(_T("    fnevObject =%s n"), str_dbg_NF);
  3540. if (bProcessed)
  3541. {
  3542. return SUCCESS_SUCCESS;
  3543. }
  3544. //-------------------------------------------------------------------
  3545. CXTPMAPIBinary keyID = pThis->GetSearchKey(lpNotif[i].info.obj.cbEntryID, lpNotif[i].info.obj.lpEntryID);
  3546. DWORD dwEventID = pThis->GetEventID(keyID.GetBinarySize(), (LPENTRYID)keyID.GetBinaryData());
  3547. CXTPCalendarEventPtr ptrEvent = pMemDP->GetEvent(dwEventID);
  3549. XTP_TRACE_MAPI_NF(_T("    event ID = %d (%s)n"), dwEventID,
  3550. (LPCTSTR)(ptrEvent ? _T("exists") : _T("non-exists")) );
  3552. // look what type of change was performed
  3553. if (ulNfType & fnevObjectDeleted)
  3554. {
  3555. // Delete the event
  3556. // Note that this message will never be received for deleted item for Exchange 5.5 and 2000.
  3557. // More info at MS KB261172
  3558. if (ptrEvent)
  3559. {
  3560. VERIFY( pMemDP->DeleteEvent(ptrEvent) );
  3561. XTP_TRACE_MAPI_NF(_T("    Action = DELETEn"));
  3563. //#pragma NOTE("Advice to DP notification and resend")
  3564. //pThis->m_pConnect->SendEvent(XTP_NC_CALENDAREVENTWASDELETED, (WPARAM)dwEventID, (LPARAM)(CXTPCalendarEvent*)ptrEvent);
  3565. }
  3566. continue;
  3567. }
  3569. if ((ulNfType & fnevObjectCreated) && ulNfSender == MAPI_MESSAGE)
  3570. {
  3571. if (dwEventID != XTP_CALENDAR_UNKNOWN_EVENT_ID)
  3572. {
  3573. //ASSERT(FALSE);
  3574. XTP_TRACE_MAPI_NF(_T("    Action = skipn"));
  3575. return SUCCESS_SUCCESS;
  3576. }
  3578. // Add a new event
  3579. CXTPCalendarEventPtr ptrEvent2 = pThis->ImportEvent(
  3580. lpNotif[i].info.obj.cbEntryID,
  3581. lpNotif[i].info.obj.lpEntryID);
  3583. if (ptrEvent && ptrEvent2)
  3584. {
  3585. //Event already exists
  3586. VERIFY( pMemDP->ChangeEvent(ptrEvent2) );
  3587. XTP_TRACE_MAPI_NF(_T("    Action = CHANGEn"));
  3588. }
  3589. else if (ptrEvent2)
  3590. {
  3591. VERIFY( pMemDP->AddEvent(ptrEvent2) );
  3592. XTP_TRACE_MAPI_NF(_T("    Action = ADDn"));
  3593. }
  3595. continue;
  3596. }
  3598. if ((ulNfType & fnevObjectMoved) && ulNfSender == MAPI_MESSAGE)
  3599. {
  3600. CXTPCalendarEventPtr ptrEvent2 = pThis->ImportEvent_FromCalendarFolderOnly(
  3601. lpNotif[i].info.obj.cbEntryID,
  3602. lpNotif[i].info.obj.lpEntryID);
  3604. if (ptrEvent && ptrEvent2)
  3605. {
  3606. //Event was moved inside Calendar folder
  3607. VERIFY( pMemDP->ChangeEvent(ptrEvent2) );
  3608. XTP_TRACE_MAPI_NF(_T("    Action = CHANGEn"));
  3609. }
  3610. else if (ptrEvent)
  3611. {
  3612. //Event was moved Out of Calendar folder (to "Deleted Items" folder)
  3613. VERIFY( pMemDP->DeleteEvent(ptrEvent) );
  3614. XTP_TRACE_MAPI_NF(_T("    Action = DELETE (moved to other folder)n"));
  3615. }
  3617. continue;
  3618. }
  3620. if ((ulNfType & fnevObjectModified) && ulNfSender == MAPI_MESSAGE)
  3621. {
  3622. // is Our event changed
  3623. if (ptrEvent)
  3624. {
  3625. // Read new event data
  3626. CXTPCalendarEventPtr ptrEvent2 = pThis->ImportEvent(
  3627. lpNotif[i].info.obj.cbEntryID,
  3628. lpNotif[i].info.obj.lpEntryID);
  3629. ASSERT(ptrEvent2);
  3631. // Update event properties in the cache
  3632. if (ptrEvent2)
  3633. {
  3634. ASSERT(ptrEvent->GetEventID() == ptrEvent2->GetEventID());
  3636. DWORD dwPatternID = ptrEvent->GetRecurrencePatternID();
  3638. if (dwPatternID != XTP_CALENDAR_UNKNOWN_RECURRENCE_PATTERN_ID)
  3639. {
  3640. ptrEvent2->SetRecurrencePatternID(dwPatternID);
  3641. }
  3643. pMemDP->ChangeEvent(ptrEvent2);
  3644. XTP_TRACE_MAPI_NF(_T("    Action = CHANGE.2n"));
  3645. }
  3646. }
  3647. continue;
  3648. }
  3649. }
  3651. return SUCCESS_SUCCESS;
  3652. }
  3654. DWORD CXTPCalendarMAPIDataProvider::GetNextUniqueEventID(DWORD dwEventID)
  3655. {
  3656. if (XTP_CALENDAR_UNKNOWN_EVENT_ID == dwEventID)
  3657. dwEventID = GetNextFreeTempID();
  3659. CXTPMAPIBinary eKeyTmp;
  3660. while (m_mapID.Lookup(dwEventID, eKeyTmp))
  3661. {
  3662. dwEventID = GetNextFreeTempID();
  3663. }
  3664. ASSERT(m_mapID.Lookup(dwEventID, eKeyTmp) == FALSE);
  3665. return dwEventID;
  3666. }
  3668. CXTPMAPIBinary CXTPCalendarMAPIDataProvider::GetSearchKey(ULONG cbEntryID, LPENTRYID lpEntryID)
  3669. {
  3670. CXTPMAPIBinary keySearch;
  3672. if (cbEntryID == 0 || !lpEntryID || !m_lpCalendarFolder)
  3673. {
  3674. ASSERT(FALSE);
  3675. return keySearch;
  3676. }
  3678. LPMESSAGE pMessage = NULL;
  3679. ULONG ulObjType = NULL;
  3681. // open event from Calendar Folder storage
  3682. m_lpCalendarFolder->OpenEntry(cbEntryID, lpEntryID,
  3683. NULL,//default interface
  3684. MAPI_BEST_ACCESS,
  3685. &ulObjType,
  3686. (LPUNKNOWN*)&pMessage);
  3688. //ASSERT(ulObjType == 5);
  3689. //ASSERT(pMessage); // CHECK
  3690. if (!pMessage)
  3691. {
  3692. return keySearch;
  3693. }
  3695. // Get SearchKey
  3696. CByteArray arSearchKey;
  3697. HRESULT hrID = _getPropVal(pMessage, PR_SEARCH_KEY, arSearchKey);
  3698. if (SUCCEEDED(hrID))
  3699. {
  3700. keySearch.Set((int)arSearchKey.GetSize(), arSearchKey.GetData());
  3701. }
  3703. MAPI_RELEASE(this, pMessage);
  3705. return keySearch;
  3706. }
  3708. CXTPMAPIBinary CXTPCalendarMAPIDataProvider::GetEntryID(CXTPMAPIBinary& eSearchKey)
  3709. {
  3710. if (eSearchKey.GetBinarySize() == 0 || !eSearchKey.GetBinaryData() || !m_lpCalendarFolder)
  3711. {
  3712. ASSERT(FALSE);
  3713. return eSearchKey;
  3714. }
  3716. HRESULT hRes = S_OK;
  3717. LPMAPITABLE lpContentsTable = NULL;
  3718. LPSRowSet pRows = NULL;
  3719. CXTPMAPIBinary eid;
  3721. LPSRestriction pRestriction = BuildBinaryRestriction(eSearchKey.GetBinarySize(), eSearchKey.GetBinaryData(), PR_SEARCH_KEY);
  3723. static SizedSPropTagArray(1, sptCols) = {1, {PR_ENTRYID} };
  3725. hRes = m_lpCalendarFolder->GetContentsTable(0, &lpContentsTable);
  3727. if (SUCCEEDED(hRes))
  3728. {
  3729. hRes = this->HrQueryAllRows(lpContentsTable, (LPSPropTagArray) &sptCols,
  3730. pRestriction, //restriction...
  3731. NULL,//sort order...we're not using this parameter
  3732. 0, &pRows);
  3734. if (SUCCEEDED(hRes) && pRows->cRows > 0)
  3735. {
  3736. // ASSERT(pRows->cRows == 1); // we can get only one item by its Search Key
  3737. ASSERT(PR_ENTRYID == pRows->aRow[0].lpProps[0].ulPropTag); // we asked only for EntryID
  3738. eid.Set(pRows->aRow[0].lpProps[0].Value.bin.cb,
  3739. pRows->aRow[0].lpProps[0].Value.bin.lpb);
  3740. }
  3741. }
  3743. // cleanup
  3744. if (pRows)
  3745. {
  3746. this->FreeProws(pRows);
  3747. }
  3748. MAPI_RELEASE(this, lpContentsTable);
  3750. return eid;
  3751. }
  3753. DWORD CXTPCalendarMAPIDataProvider::GetEventID(
  3754. ULONG cbSearchKey, LPENTRYID lpSearchKey, BOOL bAddNew)
  3755. {
  3756. CXTPMAPIBinary eKey(cbSearchKey, lpSearchKey);
  3758. DWORD dwNextID = XTP_CALENDAR_UNKNOWN_EVENT_ID;
  3760. // lookup a map.
  3761. if (m_mapID.Lookup(eKey, dwNextID))
  3762. return dwNextID;
  3764. // ID not found - add new one if necessary
  3765. if (!bAddNew)
  3766. return XTP_CALENDAR_UNKNOWN_EVENT_ID;
  3768. dwNextID = GetNextUniqueEventID();
  3769. m_mapID.Add(dwNextID, eKey);
  3771. return dwNextID;
  3772. }
  3774. BOOL CXTPCalendarMAPIDataProvider::Equal(const CXTPMAPIBinary& eid1, const CXTPMAPIBinary& eid2)
  3775. {
  3776. BOOL bRes = FALSE;
  3778. // 1st check using simple byte-to-byte comparison
  3779. bRes = CXTPMAPIBinary::IsBinaryEqual(eid1, eid2);
  3780. if (bRes)
  3781. return bRes;
  3783. // 2nd check using CompareEntryIDs method.
  3784. // This is required because EntryID versions can change (i.e. A single
  3785. // provider can support more than one form of entry id) and it is up to
  3786. // a specific provider to decide if two EntryID's compare. The way of
  3787. // doing this is calling the CompareEntryIDs method on the on the
  3788. // appropriate object.
  3789. if (!m_lpMAPISession)
  3790. return bRes;
  3792. ULONG ulRes;
  3793. if (SUCCEEDED(m_lpMAPISession->CompareEntryIDs(
  3794. eid1.m_cb, (LPENTRYID)eid1.GetBinaryData(),
  3795. eid2.m_cb, (LPENTRYID)eid2.GetBinaryData(),
  3796. 0, &ulRes)))
  3797. {
  3798. bRes = (BOOL)ulRes;
  3799. }
  3801. return bRes;
  3802. }
  3804. BOOL CXTPCalendarMAPIDataProvider::OnTimeZoneChanged()
  3805. {
  3806. if (IsOpen())
  3807. {
  3808. // Re-Read all events to the cache data provider
  3809. if (m_pMemDP)
  3810. {
  3811. CXTPAutoResetValue<BOOL> autoReset(m_bDisableNotificationsSending, FALSE);
  3812. m_bDisableNotificationsSending = TRUE;
  3814. m_pMemDP->RemoveAllEvents();
  3816. m_pMemDP->AddEvents(ImportAllEvents());
  3817. }
  3819. return TRUE;
  3820. }
  3822. return FALSE;
  3823. };
  3824. /////////////////////////////////////////////////////////////////////////////
  3825. //
  3826. // CXTPMAPIBinary
  3827. //
  3829. CXTPMAPIBinary::CXTPMAPIBinary()
  3830. {
  3831. m_cb = 0;
  3832. }
  3834. CXTPMAPIBinary::CXTPMAPIBinary(ULONG cbEntryID, LPENTRYID lpEntryID)
  3835. {
  3836. Set(cbEntryID, (LPBYTE)lpEntryID);
  3837. }
  3839. CXTPMAPIBinary::CXTPMAPIBinary(const CXTPMAPIBinary& eid)
  3840. {
  3841. m_cb = eid.m_cb;
  3842. m_arBytes.RemoveAll();
  3843. m_arBytes.Append(eid.m_arBytes);
  3844. }
  3846. CXTPMAPIBinary::~CXTPMAPIBinary()
  3847. {
  3848. }
  3850. CXTPMAPIBinary& CXTPMAPIBinary::operator=(const CXTPMAPIBinary& eid)
  3851. {
  3852. m_cb = eid.m_cb;
  3853. m_arBytes.SetSize(m_cb);
  3854. MEMCPY_S(m_arBytes.GetData(), eid.GetBinaryData(), m_cb);
  3856. return *this;
  3857. }
  3859. ULONG CXTPMAPIBinary::GetBinarySize() const
  3860. {
  3861. return m_cb;
  3862. }
  3864. LPBYTE CXTPMAPIBinary::GetBinaryData() const
  3865. {
  3866. return (BYTE*)m_arBytes.GetData();
  3867. }
  3869. void CXTPMAPIBinary::Set(ULONG cbSize, LPBYTE lpData)
  3870. {
  3871. m_cb = cbSize;
  3873. m_arBytes.SetSize(m_cb);
  3874. MEMCPY_S(m_arBytes.GetData(), lpData, m_cb);
  3875. }
  3877. void CXTPMAPIBinary::Set(LPSPropValue pPropEntryID)
  3878. {
  3879. if (!pPropEntryID || pPropEntryID->ulPropTag != PR_ENTRYID)
  3880. {
  3881. ASSERT(FALSE);
  3882. Set(0, NULL);
  3883. return;
  3884. }
  3886. Set(pPropEntryID->Value.bin.cb, pPropEntryID->Value.bin.lpb);
  3887. }
  3889. BOOL CXTPMAPIBinary::IsBinaryEqual(
  3890. const CXTPMAPIBinary& eid1, const CXTPMAPIBinary& eid2)
  3891. {
  3892. if ((eid1.m_cb != eid2.m_cb) ||
  3893.  (eid1.m_arBytes.GetSize() != eid2.m_arBytes.GetSize()) )
  3894. return FALSE;
  3896. return 0 == memcmp(
  3897. eid1.m_arBytes.GetData(),
  3898. eid2.m_arBytes.GetData(),
  3899. eid1.m_arBytes.GetSize() );
  3900. }
  3902. #ifdef _DEBUG
  3903. void CXTPMAPIBinary::DebugPrint()
  3904. {
  3905. TRACE(_T("Bin size:%dt"), m_cb);
  3906. for (int i = 0; i < m_arBytes.GetSize(); i++)
  3907. {
  3908. TRACE(_T("%d "), m_arBytes.GetAt(i));
  3909. }
  3910. TRACE(_T("n"));
  3911. }
  3912. #endif
  3914. /////////////////////////////////////////////////////////////////////////////
  3915. //
  3916. // CXTP_ID_Collection
  3917. //
  3919. CXTP_ID_Collection::CXTP_ID_Collection()
  3920. {
  3921. m_mapEventID.InitHashTable(XTP_OBJECT_CACHE_HASH_TABLE_SIZE, FALSE);
  3922. m_mapEntryID.InitHashTable(XTP_OBJECT_CACHE_HASH_TABLE_SIZE, FALSE);
  3923. }
  3925. BOOL CXTP_ID_Collection::Lookup(
  3926. const DWORD dwEventID, CXTPMAPIBinary& obEntryID)
  3927. {
  3928. return m_mapEventID.Lookup(dwEventID, obEntryID);
  3929. }
  3931. BOOL CXTP_ID_Collection::Lookup(
  3932. CXTPMAPIBinary& obEntryID, DWORD& dwEventID)
  3933. {
  3934. return m_mapEntryID.Lookup(obEntryID, dwEventID);
  3935. }
  3937. BOOL CXTP_ID_Collection::Add(
  3938. const DWORD dwEventID, CXTPMAPIBinary& obEntryID)
  3939. {
  3940. m_mapEventID.SetAt(dwEventID, obEntryID);
  3941. m_mapEntryID.SetAt(obEntryID, dwEventID);
  3943. return TRUE;
  3944. }
  3946. void CXTP_ID_Collection::FindMissing(CMap_EventIDs& mapExisting, CMap_EventIDs& mapMissed)
  3947. {
  3948. POSITION pos = m_mapEventID.GetStartPosition();
  3949. DWORD dwKey;
  3950. CXTPMAPIBinary eID;
  3951. BOOL bValue = FALSE;
  3952. while (pos != NULL)
  3953. {
  3954. m_mapEventID.GetNextAssoc(pos, dwKey, eID);
  3956. BOOL bFound = mapExisting.Lookup(dwKey, bValue);
  3957. if (!bFound)
  3958. {
  3959. mapMissed.SetAt(dwKey, TRUE);
  3960. }
  3961. }
  3962. }
  3963. /////////////////////////////////////////////////////////////////////////////
  3964. //
  3965. // CMAPIPropIDMap
  3966. //
  3968. CXTPCalendarMAPIDataProvider::CMAPIPropIDMap::CMAPIPropIDMap()
  3969. : m_pProvider(NULL)
  3970. {
  3971. m_mapPropID2Tag.InitHashTable(199, FALSE);
  3972. m_mapPropTag2ID.InitHashTable(199, FALSE);
  3973. }
  3975. void CXTPCalendarMAPIDataProvider::CMAPIPropIDMap::_UpdateMaps(LPMESSAGE pMessage)
  3976. {
  3977. ASSERT(pMessage);
  3978. if (!pMessage)
  3979. return;
  3981. ULONG ulPropNames = 0;
  3982. LPMAPINAMEID* ppArPropNames = NULL;
  3983. LPSPropTagArray pPropTags = NULL;
  3985. HRESULT hRes = pMessage->GetPropList(0, &pPropTags);
  3987. if (SUCCEEDED(hRes) && pPropTags)
  3988. {
  3989. hRes = pMessage->GetNamesFromIDs(&pPropTags, NULL, MAPI_NO_STRINGS,
  3990.  &ulPropNames, &ppArPropNames);
  3992. if (SUCCEEDED(hRes) && ppArPropNames && ulPropNames)
  3993. {
  3994. ASSERT(pPropTags->cValues == ulPropNames);
  3995. XTP_TRACE_READ_IDS(_T("Prop ID -> Tag (%d)n"), ulPropNames);
  3997. for (int i = 0; i < (int)ulPropNames; i++)
  3998. {
  3999. if (!ppArPropNames[i])
  4000. {
  4001. continue;
  4002. }
  4003. if (ppArPropNames[i]->ulKind == MNID_ID)
  4004. {
  4005. ULONG ulID = (ULONG)ppArPropNames[i]->Kind.lID;
  4006. ULONG ulTag = pPropTags->aulPropTag[i];
  4008. m_mapPropID2Tag[ulID] = ulTag;
  4009. m_mapPropTag2ID[ulTag] = ulID;
  4011. //if (ulID >= 0x8000)
  4012. {
  4013. XTP_TRACE_READ_IDS(_T("Prop ID -> Tag (%x -> %x)n"), ulID, ulTag);
  4014. }
  4015. }
  4016. }
  4017. }
  4018. }
  4020. MAPI_FREEBUFFER(m_pProvider, ppArPropNames);
  4021. MAPI_FREEBUFFER(m_pProvider, pPropTags);
  4022. }
  4024. ULONG CXTPCalendarMAPIDataProvider::CMAPIPropIDMap::_GetPropTagFromID_ex(LPMESSAGE pMessage,
  4025. const XTP_MAPI_PROP_NAME& propNameEx)
  4026. {
  4027. ASSERT(pMessage);
  4028. if (!pMessage || !m_pProvider)
  4029. return 0;
  4031. ULONG ulPropTag = 0;
  4033. LPMAPINAMEID pPropName = NULL;
  4034. LPSPropTagArray pPropTag = NULL;
  4036. HRESULT hRes = m_pProvider->MAPIAllocateBuffer(sizeof(MAPINAMEID), (void**)&pPropName);
  4038. if (SUCCEEDED(hRes) && pPropName)
  4039. {
  4040. ZeroMemory(pPropName, sizeof(MAPINAMEID));
  4041. pPropName->lpguid = (LPGUID)&propNameEx.m_GuidPS;
  4042. pPropName->ulKind = MNID_ID;
  4043. pPropName->Kind.lID = propNameEx.m_ulID;
  4045. hRes = pMessage->GetIDsFromNames(1, &pPropName, MAPI_CREATE, &pPropTag);
  4046. if (SUCCEEDED(hRes) && pPropTag && pPropTag->cValues)
  4047. {
  4048. ulPropTag = pPropTag->aulPropTag[0];
  4050. // validate prop type
  4051. ulPropTag = CHANGE_PROP_TYPE(ulPropTag, propNameEx.m_ulType);
  4052. }
  4053. }
  4054. MAPI_FREEBUFFER(m_pProvider, pPropName);
  4055. MAPI_FREEBUFFER(m_pProvider, pPropTag);
  4057. return ulPropTag;
  4058. }
  4060. ULONG CXTPCalendarMAPIDataProvider::CMAPIPropIDMap::GetPropTagByID(
  4061. LPMESSAGE pMessage, const XTP_MAPI_PROP_NAME& propNameEx)
  4062. {
  4063. ULONG ulTag = 0;
  4065. if (!m_mapPropID2Tag.Lookup(propNameEx.m_ulID, ulTag))
  4066. {
  4067. _UpdateMaps(pMessage);
  4069. if (!m_mapPropID2Tag.Lookup(propNameEx.m_ulID, ulTag))
  4070. {
  4071. ulTag = _GetPropTagFromID_ex(pMessage, propNameEx);
  4072. ASSERT(ulTag); // WARNING!
  4073. if (ulTag)
  4074. {
  4075. m_mapPropID2Tag[propNameEx.m_ulID] = ulTag;
  4076. m_mapPropTag2ID[ulTag] = propNameEx.m_ulID;
  4078. return ulTag;
  4079. }
  4080. }
  4081. }
  4083. return ulTag;
  4084. }
  4086. ULONG CXTPCalendarMAPIDataProvider::CMAPIPropIDMap::GetPropIDByTag(LPMESSAGE pMessage,
  4087.  ULONG ulPropTag)
  4088. {
  4089. ULONG ulID = 0;
  4091. if (!m_mapPropTag2ID.Lookup(ulPropTag, ulID))
  4092. {
  4093. _UpdateMaps(pMessage);
  4094. }
  4095. if (!m_mapPropTag2ID.Lookup(ulPropTag, ulID))
  4096. {
  4097. ulID = 0;
  4098. }
  4099. return ulID;
  4100. }