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

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

对话框与窗口

开发平台：

Visual C++

XTPCalendarRemindersManager.cpp：源码内容
  1. // XTPCalendarRemindersManager.cpp: implementation of the
  2. // CXTPCalendarRemindersManager class.
  3. //
  4. // This file is a part of the XTREME CALENDAR MFC class library.
  5. // (c)1998-2008 Codejock Software, All Rights Reserved.
  6. //
  7. // THIS SOURCE FILE IS THE PROPERTY OF CODEJOCK SOFTWARE AND IS NOT TO BE
  8. // RE-DISTRIBUTED BY ANY MEANS WHATSOEVER WITHOUT THE EXPRESSED WRITTEN
  9. // CONSENT OF CODEJOCK SOFTWARE.
  10. //
  11. // THIS SOURCE CODE CAN ONLY BE USED UNDER THE TERMS AND CONDITIONS OUTLINED
  12. // IN THE XTREME TOOLKIT PRO LICENSE AGREEMENT. CODEJOCK SOFTWARE GRANTS TO
  13. // YOU (ONE SOFTWARE DEVELOPER) THE LIMITED RIGHT TO USE THIS SOFTWARE ON A
  14. // SINGLE COMPUTER.
  15. //
  16. // CONTACT INFORMATION:
  17. // support@codejock.com
  18. // http://www.codejock.com
  19. //
  20. /////////////////////////////////////////////////////////////////////////////
  22. #include "stdafx.h"
  24. #include "Common/XTPVC50Helpers.h"
  25. #include "Common/XTPPropExchange.h"
  27. #include "XTPCalendarRemindersManager.h"
  28. #include "XTPCalendarData.h"
  29. #include "XTPCalendarNotifications.h"
  30. #include "XTPCalendarCustomProperties.h"
  31. #include "XTPCalendarResource.h"
  33. #ifdef _DEBUG
  34. #define new DEBUG_NEW
  35. #undef THIS_FILE
  36. static char THIS_FILE[] = __FILE__;
  37. #endif
  39. #ifdef _DEBUG
  40. //  #define DBG_REMINDERS_TRACE TRACE
  41. #endif
  43. #ifndef DBG_REMINDERS_TRACE
  44. #define DBG_REMINDERS_TRACE
  45. #endif
  47. #define TIMERID_RMD_REFRESH 1
  48. #define XTP_CALENDAR_RMD_REFRESH_TIMEOUT 3*1000
  50. #define TIMERID_RMD_NOTIFY_CHANGED 2
  51. #define XTP_CALENDAR_RMD_NOTIFY_CHANGED_TIMEOUT 500
  53. static LPCTSTR XTP_CALENDAR_REMINDERS_MANAGER_WND_NAME = _T("XTPCalendarRemindersManagerWnd");
  55. ////////////////////////////////////////////////////////////////////////////
  56. IMPLEMENT_DYNAMIC(CXTPCalendarReminder, CCmdTarget)
  57. IMPLEMENT_DYNAMIC(CXTPCalendarRemindersManager, CCmdTarget)
  59. CXTPCalendarReminder::CXTPCalendarReminder(CXTPCalendarRemindersManager* pOwnerMan)
  60. {
  61. m_pOwnerMan = pOwnerMan;
  62. m_pEventDataProvider = NULL;
  64. m_dtEventStartTime = (DATE)0;
  65. m_dtNextReminderTime = (DATE)0;
  66. m_nMinutesBeforeStart = 0;
  68. m_eEventType = evtNormal;
  69. ::ZeroMemory(&m_RecurrenceEventInfo, sizeof(m_RecurrenceEventInfo));
  70. m_dwNormalEventID = XTP_CALENDAR_UNKNOWN_EVENT_ID;
  72. }
  74. CXTPCalendarReminder::~CXTPCalendarReminder()
  75. {
  76. CMDTARGET_RELEASE(m_pEventDataProvider);
  77. }
  79. CXTPCalendarEventPtr CXTPCalendarReminder::GetEvent()
  80. {
  81. if (!m_pOwnerMan || !m_pEventDataProvider)
  82. {
  83. ASSERT(FALSE);
  84. return NULL;
  85. }
  87. if (m_eEventType == evtNormal)
  88. {
  89. return m_pEventDataProvider->GetEvent(m_dwNormalEventID);
  90. }
  91. if (m_eEventType != evtRecurrence)
  92. {
  93. ASSERT(FALSE);
  94. return NULL;
  95. }
  97. CXTPCalendarEventPtr ptrMaster = m_pEventDataProvider->GetEvent(m_RecurrenceEventInfo.m_dwMasterEventID);
  98. CXTPCalendarRecurrencePatternPtr ptrPattern = ptrMaster ? ptrMaster->GetRecurrencePattern() : NULL;
  100. if (!ptrMaster || !ptrPattern)
  101. {
  102. ASSERT(FALSE);
  103. return NULL;
  104. }
  106. CXTPCalendarEvent* pExc = ptrPattern->FindException(m_RecurrenceEventInfo.m_dtOccurrenceStartTime,
  107. m_RecurrenceEventInfo.m_dtOccurrenceEndTime);
  108. if (pExc)
  109. {
  110. return pExc->CloneEvent();
  111. }
  113. return ptrMaster->CloneForOccurrence(m_RecurrenceEventInfo.m_dtOccurrenceStartTime,
  114.  m_RecurrenceEventInfo.m_dtOccurrenceEndTime);
  115. }
  117. void CXTPCalendarReminder::SetEvent(CXTPCalendarEvent* pEvent)
  118. {
  119. if (!pEvent || !pEvent->GetDataProvider())
  120. {
  121. ASSERT(FALSE);
  122. return;
  123. }
  125. // data provider
  126. CMDTARGET_RELEASE(m_pEventDataProvider);
  128. m_pEventDataProvider = pEvent->GetDataProvider();
  129. CMDTARGET_ADDREF(m_pEventDataProvider);
  131. //-----
  132. m_dtEventStartTime = pEvent->GetStartTime();
  134. int nRState = pEvent->GetRecurrenceState();
  135. if (nRState == xtpCalendarRecurrenceNotRecurring)
  136. {
  137. m_eEventType = evtNormal;
  138. m_dwNormalEventID = pEvent->GetEventID();
  139. return;
  140. }
  142. CXTPCalendarRecurrencePatternPtr ptrPattern = pEvent->GetRecurrencePattern();
  144. if (nRState != xtpCalendarRecurrenceOccurrence &&
  145. nRState != xtpCalendarRecurrenceException || !ptrPattern)
  146. {
  147. ASSERT(FALSE);
  148. return;
  149. }
  151. m_eEventType = evtRecurrence;
  152. m_RecurrenceEventInfo.m_dwMasterEventID = ptrPattern->GetMasterEventID();
  154. if (nRState == xtpCalendarRecurrenceOccurrence)
  155. {
  156. m_RecurrenceEventInfo.m_dtOccurrenceStartTime = pEvent->GetStartTime();
  157. m_RecurrenceEventInfo.m_dtOccurrenceEndTime = pEvent->GetEndTime();
  158. }
  159. else if (nRState == xtpCalendarRecurrenceException)
  160. {
  161. m_RecurrenceEventInfo.m_dtOccurrenceStartTime = pEvent->GetRException_StartTimeOrig();
  162. m_RecurrenceEventInfo.m_dtOccurrenceEndTime = pEvent->GetRException_EndTimeOrig();
  163. }
  164. else
  165. {
  166. ASSERT(FALSE);
  167. }
  168. }
  170. BOOL CXTPCalendarReminder::IsEqualID(const CXTPCalendarReminder* pR2) const
  171. {
  172. ASSERT(pR2);
  173. if (!pR2)
  174. {
  175. return FALSE;
  176. }
  178. if (m_pEventDataProvider != pR2->m_pEventDataProvider)
  179. {
  180. return FALSE;
  181. }
  182. if (m_eEventType != pR2->m_eEventType)
  183. {
  184. return FALSE;
  185. }
  186. if (m_eEventType == evtNormal)
  187. {
  188. return m_dwNormalEventID == pR2->m_dwNormalEventID;
  189. }
  190. if (m_eEventType != evtRecurrence)
  191. {
  192. ASSERT(FALSE);
  193. return FALSE;
  194. }
  195. if (m_RecurrenceEventInfo.m_dwMasterEventID != pR2->m_RecurrenceEventInfo.m_dwMasterEventID)
  196. {
  197. return FALSE;
  198. }
  199. if (!CXTPCalendarUtils::IsEqual(m_RecurrenceEventInfo.m_dtOccurrenceStartTime,
  200. pR2->m_RecurrenceEventInfo.m_dtOccurrenceStartTime) )
  201. {
  202. return FALSE;
  203. }
  205. if (!CXTPCalendarUtils::IsEqual(m_RecurrenceEventInfo.m_dtOccurrenceEndTime,
  206. pR2->m_RecurrenceEventInfo.m_dtOccurrenceEndTime) )
  207. {
  208. return FALSE;
  209. }
  210. return TRUE;
  211. }
  213. ////////////////////////////////////////////////////////////////////////////
  214. int CXTPCalendarReminders::Find(const CXTPCalendarReminder* pReminder) const
  215. {
  216. if (!pReminder)
  217. {
  218. ASSERT(FALSE);
  219. return -1;
  220. }
  222. int nCount = GetCount();
  223. for (int i = 0; i < nCount; i++)
  224. {
  225. CXTPCalendarReminder* pRmdI = GetAt(i, FALSE);
  226. ASSERT(pRmdI);
  228. if (pRmdI && pRmdI->IsEqualID(pReminder))
  229. {
  230. return i;
  231. }
  232. }
  233. return -1;
  234. }
  236. int CXTPCalendarReminders::Find(CXTPCalendarEvent* pEvent) const
  237. {
  238. if (!pEvent)
  239. {
  240. ASSERT(FALSE);
  241. return -1;
  242. }
  244. CXTPCalendarReminder eventRmd;
  245. eventRmd.SetEvent(pEvent);
  247. int nCount = GetCount();
  248. for (int i = 0; i < nCount; i++)
  249. {
  250. CXTPCalendarReminder* pRmdI = GetAt(i, FALSE);
  251. ASSERT(pRmdI);
  253. if (pRmdI && eventRmd.IsEqualID(pRmdI))
  254. {
  255. return i;
  256. }
  257. }
  258. return -1;
  259. }
  261. int CXTPCalendarReminders::Find(DWORD dwEventID, CXTPCalendarData* pDP) const
  262. {
  263. // DEBUG
  264. // ASSERT(pDP);
  266. int nCount = GetCount();
  267. for (int i = 0; i < nCount; i++)
  268. {
  269. CXTPCalendarReminder* pRmdI = GetAt(i, FALSE);
  270. ASSERT(pRmdI);
  271. if (!pRmdI)
  272. {
  273. continue;
  274. }
  276. if (pDP && pDP != pRmdI->m_pEventDataProvider)
  277. continue;
  279. if (pRmdI->m_eEventType == CXTPCalendarReminder::evtNormal &&
  280. pRmdI->m_dwNormalEventID == dwEventID
  281. ||
  282. pRmdI->m_eEventType == CXTPCalendarReminder::evtRecurrence &&
  283. pRmdI->m_RecurrenceEventInfo.m_dwMasterEventID == dwEventID)
  284. {
  285. return i;
  286. }
  287. }
  288. return -1;
  289. }
  291. BOOL CXTPCalendarReminders::RemoveDataForEvent(CXTPCalendarEvent* pEvent)
  292. {
  293. ASSERT(pEvent);
  294. if (!pEvent)
  295. {
  296. ASSERT(FALSE);
  297. return FALSE;
  298. }
  299. BOOL bChanged = FALSE;
  301. if (pEvent->GetRecurrenceState() == xtpCalendarRecurrenceMaster)
  302. {
  303. bChanged = _RemoveDataForMasterEvent(pEvent);
  304. }
  305. else
  306. {
  307. int nFIdx = Find(pEvent);
  308. if (nFIdx >= 0)
  309. {
  310. RemoveAt(nFIdx);
  311. bChanged = TRUE;
  313. ASSERT(Find(pEvent) < 0);
  314. }
  315. }
  317. //---------------------------------
  318. int nFIdx = Find(pEvent->GetEventID(), pEvent->GetDataProvider());
  319. if (nFIdx >= 0)
  320. {
  321. RemoveAt(nFIdx);
  322. bChanged = TRUE;
  323. }
  324. return bChanged;
  325. }
  327. void CXTPCalendarReminders::Sort()
  328. {
  329. int nCount = GetCount();
  330. for (int i = 0; i < nCount; i++)
  331. {
  332. for (int j = i+1; j < nCount; j++)
  333. {
  334. TObjectPtr ptrE1 = GetAt(i, TRUE);
  335. TObjectPtr ptrE2 = GetAt(j, TRUE);
  337. if (ptrE1->m_dtEventStartTime > ptrE2->m_dtEventStartTime)
  338. {
  339. SetAt(j, ptrE1.Detach());
  340. SetAt(i, ptrE2.Detach());
  341. }
  342. }
  343. }
  344. }
  346. BOOL CXTPCalendarReminders::_RemoveDataForMasterEvent(CXTPCalendarEvent* pEvent)
  347. {
  348. if (!pEvent || pEvent->GetRecurrenceState() != xtpCalendarRecurrenceMaster)
  349. {
  350. ASSERT(FALSE);
  351. return FALSE;
  352. }
  353. BOOL bChanged = FALSE;
  355. DWORD dwMasterEventID = pEvent->GetEventID();
  356. CXTPCalendarData* pEvDP = pEvent->GetDataProvider();
  358. int nCount = GetCount();
  359. for (int i = nCount-1; i >= 0 ; i--)
  360. {
  361. CXTPCalendarReminder* pRmdI = GetAt(i, FALSE);
  362. ASSERT(pRmdI);
  363. if (!pRmdI)
  364. {
  365. continue;
  366. }
  368. if (pRmdI->m_eEventType == CXTPCalendarReminder::evtRecurrence &&
  369. pRmdI->m_RecurrenceEventInfo.m_dwMasterEventID == dwMasterEventID &&
  370. pRmdI->m_pEventDataProvider == pEvDP)
  371. {
  372. RemoveAt(i);
  373. bChanged = TRUE;
  374. }
  375. }
  376. return bChanged;
  377. }
  379. ////////////////////////////////////////////////////////////////////////////
  380. CXTPCalendarRemindersManager::CXTPCalendarRemindersManager()
  381. {
  382. m_dtLastUpdateTime = (DATE)0;
  384. m_pConnection = new CXTPNotifyConnection();
  385. m_pResourcesNf = new CXTPCalendarResourcesNf();
  387. m_bSkipOnEventChanged = FALSE;
  388. m_bMonitoringRunning = FALSE;
  390. }
  392. CXTPCalendarRemindersManager::~CXTPCalendarRemindersManager()
  393. {
  394. //RemoveAll();
  396. CMDTARGET_RELEASE(m_pConnection);
  397. CMDTARGET_RELEASE(m_pResourcesNf);
  398. }
  400. BEGIN_MESSAGE_MAP(CXTPCalendarRemindersManager, CWnd)
  401. ON_WM_TIMER()
  402. ON_WM_TIMECHANGE()
  403. END_MESSAGE_MAP()
  405. void CXTPCalendarRemindersManager::OnFinalRelease()
  406. {
  407. StopMonitoring();
  409. CWnd::OnFinalRelease();
  410. CCmdTarget::OnFinalRelease();
  411. }
  413. BOOL CXTPCalendarRemindersManager::_CreateWnd()
  414. {
  415. LPCTSTR pcszSimpleWndClass = AfxRegisterWndClass(0);
  416. CRect rcEmpty(0,0,0,0);
  418. BOOL bCreated = CreateEx(0, pcszSimpleWndClass,
  419. XTP_CALENDAR_REMINDERS_MANAGER_WND_NAME,
  420. WS_POPUP, rcEmpty, NULL, 0);
  422. return bCreated;
  423. }
  425. BOOL CXTPCalendarRemindersManager::StartMonitoring(CXTPCalendarResources* pResources,
  426.    COleDateTimeSpan spPeriod2Cache)
  427. {
  428. if (!GetSafeHwnd())
  429. {
  430. if (!_CreateWnd())
  431. {
  432. ASSERT(FALSE);
  433. return FALSE;
  434. }
  435. }
  437. //***********************************
  438. if (IsMonitoringRunning())
  439. {
  440. StopMonitoring();
  441. }
  443. //***********************************
  444. RemoveAll();
  445. XTP_SAFE_CALL1(m_pResourcesNf, RemoveAll());
  446. m_Sink.UnadviseAll();
  448. //-----------------------------------
  449. ASSERT(pResources);
  450. ASSERT(GETTOTAL_SECONDS_DTS(spPeriod2Cache) > 0);
  452. if (!pResources || !m_pResourcesNf)
  453. {
  454. return FALSE;
  455. }
  457. DBG_REMINDERS_TRACE(_T("%s - CXTPCalendarRemindersManager::StartMonitoring(). period = %d min n"),
  458. (LPCTSTR)CXTPCalendarUtils::GetCurrentTime().Format(),
  459. (int)spPeriod2Cache.GetTotalMinutes());
  461. m_pResourcesNf->Append(pResources);
  462. m_spPeriod2Cache = spPeriod2Cache;
  464. //------------------------------------
  465. // Advise to Data Provider notifications
  466. CXTPNotifyConnection* pConnRC = m_pResourcesNf->GetConnection();
  467. ASSERT(pConnRC);
  469. if (pConnRC)
  470. {
  471. m_Sink.Advise(pConnRC, XTP_NC_CALENDAREVENTWASADDED, &CXTPCalendarRemindersManager::OnEventChanged);
  472. m_Sink.Advise(pConnRC, XTP_NC_CALENDAREVENTWASDELETED, &CXTPCalendarRemindersManager::OnEventChanged);
  473. m_Sink.Advise(pConnRC, XTP_NC_CALENDAREVENTWASCHANGED, &CXTPCalendarRemindersManager::OnEventChanged);
  474. }
  475. m_pResourcesNf->ReBuildInternalData();
  477. //------------------------------------
  478. COleDateTime dtNow = CXTPCalendarUtils::GetCurrentTime();
  479. UpdateDataFromDP(dtNow, m_spPeriod2Cache);
  481. SetTimer(TIMERID_RMD_REFRESH, XTP_CALENDAR_RMD_REFRESH_TIMEOUT, NULL);
  483. //--------------------------------------------------------
  484. m_bMonitoringRunning = TRUE;
  485. NotifyReminders(xtpCalendarRemindersMonitoringStarted);
  487. return TRUE;
  488. }
  490. BOOL CXTPCalendarRemindersManager::StopMonitoring()
  491. {
  492. if (IsWindow(m_hWnd))
  493. {
  494. KillTimer(TIMERID_RMD_REFRESH);
  495. }
  497. m_Sink.UnadviseAll();
  499. RemoveAll();
  501. m_bMonitoringRunning = FALSE;
  502. NotifyReminders(xtpCalendarRemindersMonitoringStopped);
  504. DBG_REMINDERS_TRACE(_T("%s - CXTPCalendarRemindersManager::STOP Monitoring().  n"),
  505. CXTPCalendarUtils::GetCurrentTime().Format());
  507. return TRUE;
  508. }
  510. void CXTPCalendarRemindersManager::RemoveAll()
  511. {
  512. m_arWaitingReminders.RemoveAll();
  513. m_arActiveReminders.RemoveAll();
  514. }
  516. BOOL CXTPCalendarRemindersManager::UpdateDataFromDP(COleDateTime dtFrom,
  517. COleDateTimeSpan spPeriod)
  518. {
  519. ASSERT(m_pResourcesNf);
  520. if (!m_pResourcesNf || 0 == m_pResourcesNf->GetCount())
  521. {
  522. m_dtLastUpdateTime = (DATE)0;
  523. return FALSE;
  524. }
  526. DWORD dwTime0 = ::GetTickCount();
  527. DBG_REMINDERS_TRACE(_T("%s - CXTPCalendarRemindersManager::start retrieve UpcomingEvents().  n"),
  528. CXTPCalendarUtils::GetCurrentTime().Format());
  530. CWaitCursor _WC;
  532. int nWaitingCount = m_arWaitingReminders.GetCount();
  533. int nActiveCount = m_arActiveReminders.GetCount();
  534. // ???
  535. m_arWaitingReminders.RemoveAll();
  536. m_arActiveReminders.RemoveAll();
  538. CXTPCalendarEventsPtr ptrEvents;
  539. BOOL bDataAvailable = GetUpcomingEventsAll(dtFrom, spPeriod, ptrEvents);
  541. if (bDataAvailable)
  542. {
  543. int nCount = ptrEvents ? ptrEvents->GetCount() : 0;
  544. for (int i = 0; i < nCount; i++)
  545. {
  546. CXTPCalendarEvent* pEvent = ptrEvents->GetAt(i, FALSE);
  547. ASSERT(pEvent);
  549. ProcessNewEvent(pEvent, dtFrom, spPeriod);
  550. }
  551. m_arActiveReminders.Sort();
  553. m_dtLastUpdateTime = dtFrom;
  555. int nWaitingCount2 = m_arWaitingReminders.GetCount();
  557. //------------------------------------
  558. DWORD dwTime1 = ::GetTickCount();
  559. DBG_REMINDERS_TRACE(_T("%s - CXTPCalendarRemindersManager::STOP retrieve UpcomingEvents(). time=%d ms, count = %d n"),
  560. CXTPCalendarUtils::GetCurrentTime().Format(), (dwTime1 - dwTime0), nWaitingCount2);
  562. //------------------------------------------------------------
  563. return (nWaitingCount != 0 || nWaitingCount2 != 0 || nActiveCount != 0);
  564. }
  566. //===================================================
  567. DBG_REMINDERS_TRACE(_T("%s - CXTPCalendarRemindersManager::SKIP  retrieve UpcomingEvents(). *** Some Data Closed. *** n"),
  568. CXTPCalendarUtils::GetCurrentTime().Format());
  570. m_dtLastUpdateTime = (DATE)0;
  571. return FALSE;
  572. }
  574. void CXTPCalendarRemindersManager::OnEventChanged(XTP_NOTIFY_CODE Event,
  575.   WPARAM /*wParam*/, LPARAM lParam)
  576. {
  577. if (m_bSkipOnEventChanged)
  578. {
  579. return;
  580. }
  582. CXTPCalendarEvent* pEvent = (CXTPCalendarEvent*)lParam;
  584. if (!m_pResourcesNf || 0 == m_pResourcesNf->GetCount() || !pEvent)
  585. {
  586. ASSERT(FALSE);
  587. return;
  588. }
  590. if (lParam && (Event == XTP_NC_CALENDAREVENTWASADDED || 
  591. Event == XTP_NC_CALENDAREVENTWASDELETED || Event == XTP_NC_CALENDAREVENTWASCHANGED))
  592. {
  593. CXTPCalendarResource* pRC = m_pResourcesNf->FindByDataProvider(pEvent->GetDataProvider());
  594. ASSERT(pRC);
  595. if (!pRC)
  596. return;
  598. UINT uScheduleIDEvent = pEvent->GetScheduleID();
  599. if (!pRC->ExistsScheduleID(uScheduleIDEvent, TRUE))
  600. return;
  601. }
  603. COleDateTime dtNow = CXTPCalendarUtils::GetCurrentTime();
  604. BOOL bChanged = FALSE;
  605. BOOL bChanged2 = FALSE;
  606. if (Event == XTP_NC_CALENDAREVENTWASADDED)
  607. {
  608. //CXTPCalendarEvent* pEvent = (CXTPCalendarEvent*)lParam;
  609. ProcessNewEvent(pEvent, m_dtLastUpdateTime, m_spPeriod2Cache);
  611. bChanged = ProcessActiveReminders(dtNow);
  612. }
  613. else if (Event == XTP_NC_CALENDAREVENTWASDELETED)
  614. {
  615. //CXTPCalendarEvent* pEvent = (CXTPCalendarEvent*)lParam;
  617. m_arWaitingReminders.RemoveDataForEvent(pEvent);
  619. bChanged = m_arActiveReminders.RemoveDataForEvent(pEvent);
  620. }
  621. else if (Event == XTP_NC_CALENDAREVENTWASCHANGED)
  622. {
  623. //CXTPCalendarEvent* pEvent = (CXTPCalendarEvent*)lParam;
  624. bChanged = ProcessChangedEvent(pEvent);
  626. bChanged2 = ProcessActiveReminders(dtNow);
  627. }
  628. else
  629. {
  630. ASSERT(FALSE);
  631. }
  633. if (bChanged || bChanged2)
  634. {
  635. PostNotify_RemindersFire();
  637. DBG_REMINDERS_TRACE(_T("%s - CXTPCalendarRemindersManager::OnEventChanged(). data updated. n"),
  638. CXTPCalendarUtils::GetCurrentTime().Format());
  640. }
  641. }
  643. BOOL CXTPCalendarRemindersManager::ProcessNewEvent(CXTPCalendarEvent* pEvent,
  644.    COleDateTime dtFrom, COleDateTimeSpan spPeriod)
  645. {
  646. if (!pEvent)
  647. {
  648. ASSERT(FALSE);
  649. return FALSE;
  650. }
  651. if (pEvent->GetRecurrenceState() == xtpCalendarRecurrenceMaster)
  652. {
  653. return _ProcessNewMasterEvent(pEvent, dtFrom, spPeriod);
  654. }
  655. return _ProcessNewSingleEvent(pEvent, dtFrom, spPeriod);
  656. }
  658. BOOL CXTPCalendarRemindersManager::_ProcessNewSingleEvent(CXTPCalendarEvent* pEvent,
  659.   COleDateTime dtFrom, COleDateTimeSpan spPeriod)
  660. {
  662. if (pEvent->GetRecurrenceState() == xtpCalendarRecurrenceMaster)
  663. {
  664. ASSERT(FALSE);
  665. return FALSE;
  666. }
  668. if (!pEvent->IsReminder())
  669. {
  670. return FALSE;
  671. }
  673. int nMinBeforeStart = pEvent->GetReminderMinutesBeforeStart();
  674. COleDateTimeSpan spRem = CXTPCalendarUtils::Minutes2Span(nMinBeforeStart);
  675. COleDateTime dtNextReminderTime = pEvent->GetStartTime() - spRem;
  677. //---------------------------------
  678. COleVariant varNextReminderTime_Snoozed;
  679. BOOL bSnoozed = pEvent->GetCustomProperties()->GetProperty(
  680. cszEventCustProp_NextReminderTime_Snoozed, varNextReminderTime_Snoozed);
  682. if (bSnoozed)
  683. {
  684. dtNextReminderTime = (DATE)_variant_t(varNextReminderTime_Snoozed);
  685. }
  687. //---------------------------------
  688. COleDateTime dtEndMonitoringPeriod = dtFrom + spPeriod;
  690. if (dtNextReminderTime > dtEndMonitoringPeriod)
  691. {
  692. return FALSE;
  693. }
  695. //=======================================================================
  696. CXTPCalendarReminder* pRmdData = new CXTPCalendarReminder(this);
  697. if (!pRmdData)
  698. {
  699. return FALSE;
  700. }
  702. pRmdData->SetEvent(pEvent);
  704. pRmdData->m_nMinutesBeforeStart = nMinBeforeStart;
  705. pRmdData->m_dtNextReminderTime = dtNextReminderTime;
  707. m_arWaitingReminders.Add(pRmdData, FALSE);
  709. return TRUE;
  710. }
  712. BOOL CXTPCalendarRemindersManager::ProcessChangedEvent(CXTPCalendarEvent* pEvent)
  713. {
  714. ASSERT(pEvent);
  715. if (!pEvent)
  716. {
  717. return FALSE;
  718. }
  720. m_arWaitingReminders.RemoveDataForEvent(pEvent);
  722. BOOL bActiveChanged = m_arActiveReminders.RemoveDataForEvent(pEvent);
  724. ////BOOL bChanged2 =
  725. ProcessNewEvent(pEvent, m_dtLastUpdateTime, m_spPeriod2Cache);
  727. return bActiveChanged;// || bChanged2;
  728. }
  730. BOOL CXTPCalendarRemindersManager::_ProcessNewMasterEvent(CXTPCalendarEvent* pEvent,
  731.  COleDateTime dtFrom,
  732.  COleDateTimeSpan spPeriod)
  733. {
  734. if (!pEvent || !pEvent->GetCustomProperties())
  735. {
  736. ASSERT(FALSE);
  737. return FALSE;
  738. }
  740. if (pEvent->GetRecurrenceState() != xtpCalendarRecurrenceMaster)
  741. {
  742. ASSERT(FALSE);
  743. return FALSE;
  744. }
  746. CXTPCalendarEvents arOccurrences;
  748. CXTPCalendarRecurrencePatternPtr ptrPattern = pEvent->GetRecurrencePattern();
  749. if (!ptrPattern)
  750. {
  751. ASSERT(FALSE);
  752. return FALSE;
  753. }
  755. int nMaxMinutesBefore = 0;
  756. BOOL bReminderExists = _GetMaxExceptionReminder(ptrPattern, nMaxMinutesBefore);
  758. if (pEvent->IsReminder())
  759. {
  760. nMaxMinutesBefore = max(nMaxMinutesBefore, pEvent->GetReminderMinutesBeforeStart());
  761. bReminderExists = TRUE;
  762. }
  764. if (!bReminderExists)
  765. {
  766. return FALSE;
  767. }
  769. COleDateTimeSpan spMaxBeforePeriod = CXTPCalendarUtils::Minutes2Span(nMaxMinutesBefore);
  771. COleDateTime dtOccFrom = ptrPattern->GetPatternStartDate();
  772. COleDateTime dtOccTo = dtFrom + spPeriod + spMaxBeforePeriod;
  773. ptrPattern->GetOccurrences(&arOccurrences, dtOccFrom, dtOccTo, pEvent);
  775. int nCount = arOccurrences.GetCount();
  776. for (int i = 0; i < nCount; i++)
  777. {
  778. CXTPCalendarEvent* pOccExc = arOccurrences.GetAt(i, FALSE);
  779. _ProcessNewSingleEvent(pOccExc, dtFrom, spPeriod);
  780. }
  781. return TRUE;
  782. }
  784. BOOL CXTPCalendarRemindersManager::_GetMaxExceptionReminder(
  785. CXTPCalendarRecurrencePattern* pPattern,
  786. int& rnMinutes)
  787. {
  788. ASSERT(pPattern);
  789. if (!pPattern)
  790. {
  791. return FALSE;
  792. }
  794. CXTPCalendarEventsPtr ptrExcAr = pPattern->GetExceptions();
  795. if (!ptrExcAr)
  796. {
  797. return FALSE;
  798. }
  800. BOOL bExists = FALSE;
  801. rnMinutes = 0;
  803. int nCount = ptrExcAr->GetCount();
  804. for (int i = 0; i < nCount; i++)
  805. {
  806. CXTPCalendarEvent* pExc = ptrExcAr->GetAt(i, FALSE);
  807. if (pExc && pExc->IsReminder())
  808. {
  809. rnMinutes = max(rnMinutes, pExc->GetReminderMinutesBeforeStart());
  810. bExists = TRUE;
  811. }
  812. }
  813. return bExists;
  814. }
  816. void CXTPCalendarRemindersManager::OnTimer(UINT_PTR uTimerID)
  817. {
  818. if (!m_pResourcesNf || 0 == m_pResourcesNf->GetCount())
  819. {
  820. ASSERT(FALSE);
  821. return;
  822. }
  824. if (uTimerID == TIMERID_RMD_NOTIFY_CHANGED)
  825. {
  826. KillTimer(TIMERID_RMD_NOTIFY_CHANGED);
  828. NotifyReminders(xtpCalendarRemindersFire);
  830. DBG_REMINDERS_TRACE(_T("%s - CXTPCalendarRemindersManager::POST NotifyReminders(fier). n"),
  831. CXTPCalendarUtils::GetCurrentTime().Format());
  832. return;
  833. }
  836. //===========================================================================
  837. if (uTimerID != TIMERID_RMD_REFRESH)
  838. {
  839. ASSERT(FALSE);
  840. return;
  841. }
  842. //===========================================================================
  843. COleDateTime dtNow = CXTPCalendarUtils::GetCurrentTime();
  845. //-(1) Update cached data if need
  846. COleDateTime dtNextUpdateTime = m_dtLastUpdateTime + m_spPeriod2Cache;
  848. BOOL bUpdated = FALSE;
  849. if (dtNextUpdateTime <= dtNow || 0 == (DATE)m_dtLastUpdateTime)
  850. {
  851. DBG_REMINDERS_TRACE(_T("%s - CXTPCalendarRemindersManager::Update from timer ==>>. n"),
  852. CXTPCalendarUtils::GetCurrentTime().Format());
  854. bUpdated = UpdateDataFromDP(dtNow, m_spPeriod2Cache);
  855. }
  857. //---------------------------------------------------------------------------
  858. //-(2) Notify reminders
  859. BOOL bUpdated2 = ProcessActiveReminders(dtNow);
  860. if (bUpdated || bUpdated2)
  861. {
  862. DBG_REMINDERS_TRACE(_T("%s - CXTPCalendarRemindersManager::NotifyReminders(fier). n"),
  863. CXTPCalendarUtils::GetCurrentTime().Format());
  865. NotifyReminders(xtpCalendarRemindersFire);
  866. }
  867. //---------------------------------------------------------------------------
  868. }
  870. void CXTPCalendarRemindersManager::OnTimeChange()
  871. {
  872. DBG_REMINDERS_TRACE(_T("%s - CXTPCalendarRemindersManager::OnTimeChange(update will soon). n"),
  873. CXTPCalendarUtils::GetCurrentTime().Format());
  875. m_dtLastUpdateTime = (DATE)0;
  877. SetTimer(TIMERID_RMD_REFRESH, XTP_CALENDAR_RMD_REFRESH_TIMEOUT, NULL);
  878. }
  880. BOOL CXTPCalendarRemindersManager::ProcessActiveReminders(COleDateTime dtTime)
  881. {
  882. CXTPAutoResetValue<BOOL> autoReset(m_bSkipOnEventChanged, FALSE);
  883. m_bSkipOnEventChanged = TRUE;
  885. BOOL bChanged = FALSE;
  886. int nCount = m_arWaitingReminders.GetCount();
  887. for (int i = nCount-1; i >= 0 ; i--)
  888. {
  889. CXTPCalendarReminder* pRmdI = m_arWaitingReminders.GetAt(i, FALSE);
  891. if (pRmdI->m_dtNextReminderTime <= dtTime)
  892. {
  893. m_arActiveReminders.Add(pRmdI, TRUE);
  894. m_arWaitingReminders.RemoveAt(i);
  896. bChanged = TRUE;
  898. _RemoveSnoozeData(pRmdI);
  899. }
  900. }
  901. if (bChanged)
  902. m_arActiveReminders.Sort();
  904. return bChanged;
  905. }
  908. BOOL CXTPCalendarRemindersManager::_RemoveSnoozeData(CXTPCalendarReminder* pRmd)
  909. {
  910. CXTPCalendarEventPtr ptrEvent = pRmd->GetEvent();
  911. if (ptrEvent && ptrEvent->GetCustomProperties())
  912. {
  913. COleVariant varTmp;
  915. BOOL bSnoozed = ptrEvent->GetCustomProperties()->GetProperty(
  916. cszEventCustProp_NextReminderTime_Snoozed, varTmp);
  917. if (bSnoozed)
  918. {
  919. if (ptrEvent->GetRecurrenceState() == xtpCalendarRecurrenceOccurrence)
  920. {
  921. CXTPCalendarRecurrencePatternPtr ptrPattern = ptrEvent->GetRecurrencePattern();
  922. CXTPCalendarEventPtr ptrMaster = ptrPattern ? ptrPattern->GetMasterEvent() : NULL;
  923. if (ptrMaster)
  924. {
  925. ptrPattern->SetOccReminder(ptrEvent, xtpCalendarRmdPrm_Default, (DATE)xtpCalendarRmdPrm_Default);
  927. VERIFY( ptrMaster->UpdateRecurrence(ptrPattern) );
  928. VERIFY( XTP_SAFE_GET1(ptrMaster->GetDataProvider(), ChangeEvent(ptrMaster), FALSE) );
  929. }
  930. }
  931. else
  932. {
  933. ptrEvent->GetCustomProperties()->RemoveProperty(cszEventCustProp_NextReminderTime_Snoozed);
  934. VERIFY( XTP_SAFE_GET1(ptrEvent->GetDataProvider(), ChangeEvent(ptrEvent), FALSE) );
  935. }
  937. return TRUE;
  938. }
  939. }
  940. return FALSE;
  941. }
  943. void CXTPCalendarRemindersManager::NotifyReminders(int eAction, LPARAM lParam)
  944. {
  945. if (m_pConnection)
  946. {
  947. m_pConnection->SendEvent(XTP_NC_CALENDAR_ON_REMINDERS, (WPARAM)eAction, lParam);
  948. }
  949. }
  951. void CXTPCalendarRemindersManager::PostNotify_RemindersFire()
  952. {
  953. SetTimer(TIMERID_RMD_NOTIFY_CHANGED, XTP_CALENDAR_RMD_NOTIFY_CHANGED_TIMEOUT, NULL);
  954. }
  956. int CXTPCalendarRemindersManager::GetActiveRemindersCount()
  957. {
  958. return m_arActiveReminders.GetCount();
  959. }
  961. void CXTPCalendarRemindersManager::GetActiveReminders(CXTPCalendarReminders& rarActiveReminders)
  962. {
  963. rarActiveReminders.RemoveAll();
  964. rarActiveReminders.Append(&m_arActiveReminders);
  965. }
  967. BOOL CXTPCalendarRemindersManager::Snooze(CXTPCalendarReminder* pReminder,
  968.   int nMinutesAfterNow)
  969. {
  970. const int cnMaxSnoozeMinutes = (60*24*365) * 1000; // 1000 years
  972. // WARNING. no sense to snooze before now.
  973. ASSERT(nMinutesAfterNow >= 1);
  975. // WARNING. do you really need to snooze so far.
  976. ASSERT(nMinutesAfterNow <= cnMaxSnoozeMinutes);
  978. nMinutesAfterNow = max(1, min(nMinutesAfterNow, cnMaxSnoozeMinutes));
  980. CXTPCalendarEventPtr ptrEvent = pReminder ? pReminder->GetEvent() : NULL;
  982. if (!pReminder || !ptrEvent)
  983. {
  984. ASSERT(FALSE);
  985. return FALSE;
  986. }
  988. pReminder->m_dtNextReminderTime = CXTPCalendarUtils::GetCurrentTime();
  989. pReminder->m_dtNextReminderTime += CXTPCalendarUtils::Minutes2Span(nMinutesAfterNow);
  991. m_arWaitingReminders.Add(pReminder, TRUE);
  993. int nIdx = m_arActiveReminders.Find(pReminder);
  994. if (nIdx >= 0)
  995. {
  996. m_arActiveReminders.RemoveAt(nIdx);
  997. }
  999. CXTPAutoResetValue<BOOL> autoReset(m_bSkipOnEventChanged, FALSE);
  1000. m_bSkipOnEventChanged = TRUE;
  1002. if (ptrEvent->GetRecurrenceState() == xtpCalendarRecurrenceOccurrence)
  1003. {
  1004. CXTPCalendarRecurrencePatternPtr ptrPattern = ptrEvent->GetRecurrencePattern();
  1005. CXTPCalendarEventPtr ptrMaster = ptrPattern ? ptrPattern->GetMasterEvent() : NULL;
  1006. if (ptrMaster)
  1007. {
  1008. ptrPattern->SetOccReminder(ptrEvent, xtpCalendarRmdPrm_DontChange,
  1009. (DATE)pReminder->m_dtNextReminderTime);
  1011. VERIFY( ptrMaster->UpdateRecurrence(ptrPattern) );
  1012. VERIFY( XTP_SAFE_GET1(ptrMaster->GetDataProvider(), ChangeEvent(ptrMaster), FALSE) );
  1013. }
  1014. }
  1015. else
  1016. {
  1017. VERIFY( ptrEvent->GetCustomProperties()->SetProperty(
  1018. cszEventCustProp_NextReminderTime_Snoozed,
  1019. (DATE)pReminder->m_dtNextReminderTime) );
  1021. VERIFY( XTP_SAFE_GET1(ptrEvent->GetDataProvider(), ChangeEvent(ptrEvent), FALSE) );
  1022. }
  1024. NotifyReminders(xtpCalendarReminderSnoozed, (LPARAM)pReminder);
  1026. return TRUE;
  1027. }
  1029. BOOL CXTPCalendarRemindersManager::Dismiss(CXTPCalendarReminder* pReminder)
  1030. {
  1031. if (!pReminder)
  1032. {
  1033. ASSERT(FALSE);
  1034. return FALSE;
  1035. }
  1037. int nIdx = m_arActiveReminders.Find(pReminder);
  1038. if (nIdx >= 0)
  1039. {
  1040. m_arActiveReminders.RemoveAt(nIdx);
  1041. }
  1043. BOOL bRes = _Dismiss(pReminder);
  1045. if (bRes)
  1046. {
  1047. NotifyReminders(xtpCalendarReminderDismissed, (LPARAM)pReminder);
  1048. }
  1050. return bRes;
  1051. }
  1053. BOOL CXTPCalendarRemindersManager::DismissAll()
  1054. {
  1055. int nCount = m_arActiveReminders.GetCount();
  1056. for (int i = 0; i < nCount; i++)
  1057. {
  1058. CXTPCalendarReminder* pReminder = m_arActiveReminders.GetAt(i, FALSE);
  1059. ASSERT(pReminder);
  1060. if (pReminder)
  1061. {
  1062. _Dismiss(pReminder);
  1063. }
  1064. }
  1065. m_arActiveReminders.RemoveAll();
  1067. if (nCount)
  1068. {
  1069. NotifyReminders(xtpCalendarReminderDismissedAll);
  1070. }
  1072. return nCount > 0;
  1073. }
  1075. BOOL CXTPCalendarRemindersManager::_Dismiss(CXTPCalendarReminder* pReminder)
  1076. {
  1077. CXTPCalendarEventPtr ptrEvent = pReminder ? pReminder->GetEvent() : NULL;
  1079. if (!pReminder || !ptrEvent)
  1080. {
  1081. ASSERT(FALSE);
  1082. return FALSE;
  1083. }
  1085. CXTPAutoResetValue<BOOL> autoReset(m_bSkipOnEventChanged, FALSE);
  1086. m_bSkipOnEventChanged = TRUE;
  1088. if (ptrEvent->GetRecurrenceState() == xtpCalendarRecurrenceOccurrence)
  1089. {
  1090. CXTPCalendarRecurrencePatternPtr ptrPattern = ptrEvent->GetRecurrencePattern();
  1091. CXTPCalendarEventPtr ptrMaster = ptrPattern ? ptrPattern->GetMasterEvent() : NULL;
  1092. if (ptrMaster)
  1093. {
  1094. ptrPattern->SetOccReminder(ptrEvent, FALSE);
  1096. VERIFY( ptrMaster->UpdateRecurrence(ptrPattern) );
  1097. VERIFY( XTP_SAFE_GET1(ptrMaster->GetDataProvider(), ChangeEvent(ptrMaster), FALSE) );
  1098. }
  1099. }
  1100. else
  1101. {
  1102. ptrEvent->SetReminder(FALSE);
  1103. //ptrEvent->GetCustomProperties()->RemoveProperty(cszEventCustProp_NextReminderTime_Snoozed);
  1105. VERIFY( XTP_SAFE_GET1(ptrEvent->GetDataProvider(), ChangeEvent(ptrEvent), FALSE) );
  1106. }
  1108. return TRUE;
  1109. }
  1111. BOOL CXTPCalendarRemindersManager::GetUpcomingEventsAll(COleDateTime dtFrom,
  1112. COleDateTimeSpan spPeriod, CXTPCalendarEventsPtr& rptrEvents)
  1113. {
  1114. rptrEvents = NULL;
  1116. if (!m_pResourcesNf || !m_pResourcesNf->GetResourcesGroupedByDP())
  1117. {
  1118. ASSERT(FALSE);
  1119. return FALSE;
  1120. }
  1122. CXTPCalendarResources* pRCgroups = m_pResourcesNf->GetResourcesGroupedByDP();
  1124. int i;
  1125. int nCount = pRCgroups->GetCount();
  1127. //-- check is all data providers opened -------------
  1128. for (i = 0; i < nCount; i++)
  1129. {
  1130. CXTPCalendarResource* pRC = pRCgroups->GetAt(i);
  1131. ASSERT(pRC);
  1132. CXTPCalendarData* pData = pRC ? pRC->GetDataProvider() : NULL;
  1133. ASSERT(pData);
  1135. if (!pData || !pData->IsOpen())
  1136. {
  1137. return FALSE;
  1138. }
  1139. }
  1141. //-- read data ----------------
  1142. for (i = 0; i < nCount; i++)
  1143. {
  1144. CXTPCalendarResource* pRC = pRCgroups->GetAt(i);
  1145. ASSERT(pRC);
  1146. CXTPCalendarData* pData = pRC ? pRC->GetDataProvider() : NULL;
  1148. if (!pData || !pData->IsOpen())
  1149. {
  1150. ASSERT(FALSE);
  1151. continue;
  1152. }
  1154. CXTPCalendarEventsPtr ptrEv = pData->GetUpcomingEvents(dtFrom, spPeriod);
  1156. if (rptrEvents)
  1157. {
  1158. rptrEvents->Append(ptrEv);
  1159. }
  1160. else
  1161. {
  1162. rptrEvents = ptrEv;
  1163. }
  1165. pRC->FilterEventsByScheduleID(rptrEvents);
  1166. }
  1167. return TRUE;
  1168. }
  1171. /////////////////////////////////////////////////////////////////////////////