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

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

对话框与窗口

开发平台：

Visual C++

XTPCalendarRemindersDialog.cpp：源码内容
  1. // XTPCalendarRemindersDialog.cpp :
  3. #include "stdafx.h"
  4. #include "Common/XTPResourceManager.h"
  5. #include "Common/XTPVC50Helpers.h"
  7. #include "XTPCalendarRemindersDialog.h"
  8. #include "XTPCalendarEventPropertiesDlg.h"
  9. #include "XTPCalendarEvent.h"
  10. #include "XTPCalendarNotifications.h"
  11. #include "XTPCalendarControl.h"
  13. #ifdef _DEBUG
  14. #define new DEBUG_NEW
  15. #undef THIS_FILE
  16. static char THIS_FILE[] = __FILE__;
  17. #endif
  19. #define XTP_CALENDAR_RMD_REFRESH_TIMERID 1
  20. #define XTP_CALENDAR_RMD_REFRESH_TIMEOUT 60*1000 // 1 minute
  22. #define XTP_CALENDAR_RMD_REFRESH_ITEM_TIMERID 2
  23. #define XTP_CALENDAR_RMD_REFRESH_ITEM_TIMEOUT 70 // 70 ms
  25. /////////////////////////////////////////////////////////////////////////////
  26. // CXTPCalendarRemindersDialog dialog
  28. CXTPCalendarRemindersDialog::CXTPCalendarRemindersDialog(CWnd* pParent, UINT nIDTemplate)
  29. {
  30. InitModalIndirect(XTPResourceManager()->LoadDialogTemplate(nIDTemplate), pParent);
  32. m_pRemindersMan = NULL;
  33. m_pCalendar = NULL;
  34. m_nNextRefreshIndex = -1;
  36. m_bAutoPopup = TRUE;
  37. m_bShowInTaskBar = TRUE;
  38. }
  40. CXTPCalendarRemindersDialog::~CXTPCalendarRemindersDialog()
  41. {
  42. DestroyWindow();
  44. m_Sink.UnadviseAll();
  46. CMDTARGET_RELEASE(m_pRemindersMan);
  47. CMDTARGET_RELEASE(m_pCalendar);
  48. }
  50. BOOL CXTPCalendarRemindersDialog::Create(CWnd* pParent)
  51. {
  52. BOOL bCreated = CDialog::CreateIndirect(XTPResourceManager()->LoadDialogTemplate(IDD), pParent);
  53. if (bCreated)
  54. {
  55. if (m_bShowInTaskBar)
  56. {
  57. ModifyStyleEx(0, WS_EX_APPWINDOW);
  58. }
  59. }
  61. return bCreated;
  62. }
  64. BOOL CXTPCalendarRemindersDialog::IsShowInTaskBar()
  65. {
  66. return m_bShowInTaskBar;
  67. }
  69. void CXTPCalendarRemindersDialog::SetShowInTaskBar(BOOL bShow)
  70. {
  71. BOOL bChanged = m_bShowInTaskBar != bShow;
  72. m_bShowInTaskBar = bShow;
  73. if (m_hWnd)
  74. {
  75. BOOL bVisible = IsWindowVisible();
  76. if (bChanged)
  77. ShowWindow(SW_HIDE);
  79. ModifyStyleEx(m_bShowInTaskBar ? 0 : WS_EX_APPWINDOW, m_bShowInTaskBar ? WS_EX_APPWINDOW : 0);
  81. if (bChanged && bVisible)
  82. ShowWindow(SW_SHOWNORMAL);
  83. }
  84. }
  86. void CXTPCalendarRemindersDialog::DoDataExchange(CDataExchange* pDX)
  87. {
  88. CDialog::DoDataExchange(pDX);
  90. DDX_Control(pDX, XTP_IDC_RMD_SNOZE_TIME_CB, m_ctrlSnoozeTimeCB);
  91. DDX_Control(pDX, XTP_IDC_RMD_SNOOZE, m_ctrlSnoozeBtn);
  92. DDX_Control(pDX, XTP_IDC_RMD_REMINDERS_LIST, m_ctrlRemindersList);
  93. DDX_Control(pDX, XTP_IDC_RMD_DIMISS_ALL, m_ctrlDismissAllBtn);
  94. DDX_Control(pDX, XTP_IDC_RMD_DIMISS, m_ctrlDismissBtn);
  95. DDX_Control(pDX, XTP_IDC_RMD_OPEN_ITEM, m_ctrlOpenItemBtn);
  96. DDX_Control(pDX, XTP_IDC_RMD_DESCRIPTION, m_ctrlDescription);
  98. }
  100. BEGIN_MESSAGE_MAP(CXTPCalendarRemindersDialog, CDialog)
  102. ON_BN_CLICKED(XTP_IDC_RMD_DIMISS, OnDismiss)
  103. ON_BN_CLICKED(XTP_IDC_RMD_DIMISS_ALL, OnDismissAll)
  104. ON_BN_CLICKED(XTP_IDC_RMD_OPEN_ITEM, OnOpenItem)
  105. ON_BN_CLICKED(XTP_IDC_RMD_SNOOZE, OnSnooze)
  106. ON_NOTIFY(LVN_ITEMCHANGED, XTP_IDC_RMD_REMINDERS_LIST, OnRemindersList_ItemChanged)
  107. ON_NOTIFY(NM_DBLCLK, XTP_IDC_RMD_REMINDERS_LIST, OnRemindersList_DblClick)
  108. ON_WM_TIMER()
  110. END_MESSAGE_MAP()
  112. /////////////////////////////////////////////////////////////////////////////
  113. // CXTPCalendarRemindersDialog message handlers
  115. BOOL CXTPCalendarRemindersDialog::OnInitDialog()
  116. {
  117. CDialog::OnInitDialog();
  119. CRect rcList(0,0,0,0);
  120. m_ctrlRemindersList.GetClientRect(&rcList);
  122. int nColWith0 = rcList.Width()*60/100;
  123. int nColWith1 = rcList.Width()*30/100;
  125. m_ctrlRemindersList.InsertColumn(0, CXTPCalendarUtils::LoadString(XTP_IDS_CALENDAR_SUBJECT),
  126.  LVCFMT_LEFT, nColWith0, 0);
  128. m_ctrlRemindersList.InsertColumn(1, CXTPCalendarUtils::LoadString(XTP_IDS_CALENDAR_DUEIN),
  129.  LVCFMT_LEFT, nColWith1, 1);
  131. ListView_SetExtendedListViewStyleEx(m_ctrlRemindersList.m_hWnd, LVS_EX_FULLROWSELECT, LVS_EX_FULLROWSELECT);
  133. InitSnoozeComboBox();
  135. UpdateFromManager();
  137. UpdateControlsBySelection();
  139. return TRUE;  // return TRUE unless you set the focus to a control
  140.               // EXCEPTION: OCX Property Pages should return FALSE
  141. }
  143. void CXTPCalendarRemindersDialog::InitSnoozeComboBox()
  144. {
  145. m_ctrlSnoozeTimeCB.ResetContent();
  147. m_ctrlSnoozeTimeCB.AddString(CXTPCalendarUtils::LoadString(XTP_IDS_CALENDAR_MINUTES_1));
  148. m_ctrlSnoozeTimeCB.AddString(CXTPCalendarUtils::LoadString(XTP_IDS_CALENDAR_MINUTES_5));
  149. m_ctrlSnoozeTimeCB.AddString(CXTPCalendarUtils::LoadString(XTP_IDS_CALENDAR_MINUTES_10));
  150. m_ctrlSnoozeTimeCB.AddString(CXTPCalendarUtils::LoadString(XTP_IDS_CALENDAR_MINUTES_15));
  152. m_ctrlSnoozeTimeCB.AddString(CXTPCalendarUtils::LoadString(XTP_IDS_CALENDAR_HOURS_1));
  153. m_ctrlSnoozeTimeCB.AddString(CXTPCalendarUtils::LoadString(XTP_IDS_CALENDAR_HOURS_2));
  154. m_ctrlSnoozeTimeCB.AddString(CXTPCalendarUtils::LoadString(XTP_IDS_CALENDAR_HOURS_4));
  155. m_ctrlSnoozeTimeCB.AddString(CXTPCalendarUtils::LoadString(XTP_IDS_CALENDAR_HOURS_8));
  157. m_ctrlSnoozeTimeCB.AddString(CXTPCalendarUtils::LoadString(XTP_IDS_CALENDAR_DAYS_0_5));
  158. m_ctrlSnoozeTimeCB.AddString(CXTPCalendarUtils::LoadString(XTP_IDS_CALENDAR_DAYS_1));
  159. m_ctrlSnoozeTimeCB.AddString(CXTPCalendarUtils::LoadString(XTP_IDS_CALENDAR_DAYS_2));
  160. m_ctrlSnoozeTimeCB.AddString(CXTPCalendarUtils::LoadString(XTP_IDS_CALENDAR_DAYS_3));
  162. m_ctrlSnoozeTimeCB.AddString(CXTPCalendarUtils::LoadString(XTP_IDS_CALENDAR_WEEKS_1));
  163. m_ctrlSnoozeTimeCB.AddString(CXTPCalendarUtils::LoadString(XTP_IDS_CALENDAR_WEEKS_2));
  164. }
  166. void CXTPCalendarRemindersDialog::OnDismissAll()
  167. {
  168. CWaitCursor _WC;
  170. ASSERT(m_pRemindersMan);
  171. if (m_pRemindersMan)
  172. {
  173. VERIFY(m_pRemindersMan->DismissAll());
  174. }
  175. }
  177. BOOL CXTPCalendarRemindersDialog::_RemoveReminderInfo(CXTPCalendarReminder* pReminder)
  178. {
  179. int nRmdIdx = m_arActiveReminders.Find(pReminder);
  181. if (nRmdIdx >= 0 && nRmdIdx < m_ctrlRemindersList.GetItemCount())
  182. {
  183. m_ctrlRemindersList.DeleteItem(nRmdIdx);
  184. m_arActiveReminders.RemoveAt(nRmdIdx);
  186. UpdateControlsBySelection();
  188. SelectItem(nRmdIdx);
  189. UpdateTitle();
  191. return TRUE;
  192. }
  194. return FALSE;
  195. }
  197. void CXTPCalendarRemindersDialog::OnDismiss()
  198. {
  199. int nSelIdx = m_ctrlRemindersList.GetNextItem(-1, LVNI_FOCUSED|LVNI_SELECTED);
  200. if (nSelIdx >= 0)
  201. {
  202. CXTPCalendarReminder* pReminder = m_arActiveReminders.GetAt(nSelIdx, FALSE);
  203. ASSERT(pReminder);
  204. if (pReminder)
  205. {
  206. VERIFY(pReminder->Dismiss());
  207. }
  208. }
  209. }
  211. void CXTPCalendarRemindersDialog::OnSnooze()
  212. {
  213. int nSelIdx = m_ctrlRemindersList.GetNextItem(-1, LVNI_FOCUSED|LVNI_SELECTED);
  214. if (nSelIdx >= 0)
  215. {
  216. CXTPCalendarReminder* pReminder = m_arActiveReminders.GetAt(nSelIdx, FALSE);
  217. ASSERT(pReminder);
  218. if (pReminder)
  219. {
  220. CString strSnooze;
  221. m_ctrlSnoozeTimeCB.GetWindowText(strSnooze);
  222. int nSnoozeTime = CXTPCalendarUtils::ParceTimeDuration_min(strSnooze);
  224. if (nSnoozeTime == INT_MIN || nSnoozeTime < 1)
  225. {
  226. m_ctrlSnoozeTimeCB.SetFocus();
  227. XTPResourceManager()->ShowMessageBox(XTP_IDS_CALENDAR_WRONG_VALUE);
  228. return;
  229. }
  231. VERIFY(pReminder->Snooze(nSnoozeTime));
  232. }
  233. }
  234. }
  236. void CXTPCalendarRemindersDialog::OnOpenItem()
  237. {
  238. ASSERT(m_pCalendar);
  239. if (!m_pCalendar) {
  240. return;
  241. }
  243. int nSelIdx = m_ctrlRemindersList.GetNextItem(-1, LVNI_FOCUSED|LVNI_SELECTED);
  244. if (nSelIdx >= 0)
  245. {
  246. CXTPCalendarReminder* pReminder = m_arActiveReminders.GetAt(nSelIdx, FALSE);
  247. ASSERT(pReminder);
  248. if (pReminder)
  249. {
  250. CXTPCalendarEventPtr ptrEvent = pReminder->GetEvent();
  252. CXTPCalendarEventPropertiesDlg dlg(m_pCalendar, FALSE, this, ptrEvent);
  253. dlg.DoModal();
  254. }
  255. }
  256. }
  259. void CXTPCalendarRemindersDialog::OnRemindersList_ItemChanged(NMHDR* pNMHDR, LRESULT* pResult)
  260. {
  261. UNREFERENCED_PARAMETER(pNMHDR);
  262. //NM_LISTVIEW* pNMListView = (NM_LISTVIEW*)pNMHDR;
  264. *pResult = 0;
  266. UpdateControlsBySelection();
  267. }
  269. void CXTPCalendarRemindersDialog::OnRemindersList_DblClick(NMHDR* , LRESULT* )
  270. {
  271. if (m_pCalendar) {
  272. OnOpenItem();
  273. }
  274. }
  276. void CXTPCalendarRemindersDialog::UpdateControlsBySelection()
  277. {
  278. CString strDescription;
  279. BOOL bEnableControls = FALSE;
  281. int nSelIdx = m_ctrlRemindersList.GetNextItem(-1, LVNI_FOCUSED|LVNI_SELECTED);
  282. if (nSelIdx < 0)
  283. {
  284. if (m_ctrlRemindersList.GetItemCount())
  285. {
  286. strDescription = CXTPCalendarUtils::LoadString(XTP_IDS_CALENDAR_SEL_0_RMD);
  287. }
  288. else
  289. {
  290. strDescription = CXTPCalendarUtils::LoadString(XTP_IDS_CALENDAR_NO_REMINDERS);
  291. }
  292. }
  293. else
  294. {
  295. CXTPCalendarReminder* pReminder = m_arActiveReminders.GetAt(nSelIdx, FALSE);
  296. CXTPCalendarEventPtr ptrEvent = pReminder ? pReminder->GetEvent() : NULL;
  298. ASSERT(ptrEvent);
  299. if (ptrEvent)
  300. {
  301. bEnableControls = TRUE;
  303. CString strSubject = ptrEvent->GetSubject();
  304. SYSTEMTIME stStart;
  305. GETASSYSTEMTIME_DT(ptrEvent->GetStartTime(), stStart);
  307. CString strFormatDate = CXTPCalendarUtils::GetLocaleString(LOCALE_SLONGDATE, 81);
  308. CString strFormatTime = CXTPCalendarUtils::GetTimeFormatString_HrMin();
  310. CString strDate = CXTPCalendarUtils::GetDateFormat(&stStart, strFormatDate);
  311. CString strTime = CXTPCalendarUtils::GetTimeFormat(&stStart, strFormatTime);
  313. strDescription.Format(_T("%s nn%s: %s %s"), (LPCTSTR)strSubject,
  314. (LPCTSTR)CXTPCalendarUtils::LoadString(XTP_IDS_CALENDAR_START_TIME),
  315. (LPCTSTR)strDate, (LPCTSTR)strTime);
  316. }
  317. }
  319. //===================================================================
  320. m_ctrlDescription.SetWindowText(strDescription);
  322. CString strSnooze = CXTPCalendarUtils::FormatTimeDuration(15, FALSE);
  323. m_ctrlSnoozeTimeCB.SetWindowText(strSnooze);
  325. m_ctrlSnoozeTimeCB.EnableWindow(bEnableControls);
  326. m_ctrlSnoozeBtn.EnableWindow(bEnableControls);
  327. m_ctrlDismissBtn.EnableWindow(bEnableControls);
  329. int nItemsCount = m_ctrlRemindersList.GetItemCount();
  330. m_ctrlDismissAllBtn.EnableWindow(nItemsCount > 0);
  332. m_ctrlOpenItemBtn.EnableWindow(bEnableControls && m_pCalendar != NULL);
  333. }
  335. void CXTPCalendarRemindersDialog::SetRemindersManager(CXTPCalendarControl* pCalendar)
  336. {
  337. m_Sink.UnadviseAll();
  338. m_ctrlRemindersList.DeleteAllItems();
  340. CMDTARGET_ADDREF(pCalendar);
  341. CMDTARGET_RELEASE(m_pCalendar);
  342. m_pCalendar = pCalendar;
  344. CMDTARGET_RELEASE(m_pRemindersMan);
  346. if (!m_pCalendar)
  347. {
  348. return;
  349. }
  351. CXTPNotifyConnection* pConn = m_pCalendar->GetConnection();
  352. ASSERT(pConn);
  353. if (pConn)
  354. {
  355. m_Sink.Advise(pConn, XTP_NC_CALENDAR_ON_REMINDERS, &CXTPCalendarRemindersDialog::OnReminders);
  356. }
  358. m_pRemindersMan = m_pCalendar->GetRemindersManager();
  359. CMDTARGET_ADDREF(m_pRemindersMan);
  361. UpdateFromManager();
  362. }
  364. void CXTPCalendarRemindersDialog::UpdateFromManager()
  365. {
  366. CWaitCursor _WC;
  368. if (!m_pRemindersMan || !m_ctrlRemindersList.m_hWnd) {
  369. return;
  370. }
  372. m_pRemindersMan->GetActiveReminders(m_arActiveReminders);
  373. COleDateTime dtNow = CXTPCalendarUtils::GetCurrentTime();
  375. int nSelIdx = m_ctrlRemindersList.GetNextItem(-1, LVNI_FOCUSED|LVNI_SELECTED);
  376. m_ctrlRemindersList.DeleteAllItems();
  378. int nCount = m_arActiveReminders.GetCount();
  379. for (int i = 0; i < nCount; i++)
  380. {
  381. CXTPCalendarReminder* pReminder = m_arActiveReminders.GetAt(i, FALSE);
  382. CXTPCalendarEventPtr ptrEvent = pReminder ? pReminder->GetEvent() : NULL;
  384. if (!ptrEvent) {
  385. ASSERT(FALSE);
  386. continue;
  387. }
  388. CString strText = ptrEvent->GetSubject();
  390. m_ctrlRemindersList.InsertItem(i, strText);
  392. //-----------------------------------------
  393. COleDateTimeSpan spDueIn = ptrEvent->GetStartTime() - dtNow;
  395. int nMunutes = GETTOTAL_MINUTES_DTS(spDueIn);
  396. strText = CXTPCalendarUtils::FormatTimeDuration(labs(nMunutes), TRUE);
  398. if (nMunutes < 0) {
  399. strText += _T(" ") + CXTPCalendarUtils::LoadString(XTP_IDS_CALENDAR_OVERDUE);
  400. }
  402. m_ctrlRemindersList.SetItem(i, 1, LVIF_TEXT, strText, 0, 0, 0, 0);
  403. }
  405. SelectItem(nSelIdx);
  407. UpdateControlsBySelection();
  408. UpdateTitle();
  410. KillTimer(XTP_CALENDAR_RMD_REFRESH_ITEM_TIMERID);
  411. m_nNextRefreshIndex = -1;
  412. SetTimer(XTP_CALENDAR_RMD_REFRESH_TIMERID, XTP_CALENDAR_RMD_REFRESH_TIMEOUT, NULL);
  413. }
  415. void CXTPCalendarRemindersDialog::UpdateTitle()
  416. {
  417. int nItemsCount = m_ctrlRemindersList.GetItemCount();
  419. CString strTitle;
  420. strTitle.Format((LPCTSTR)CXTPCalendarUtils::LoadString(XTP_IDS_CALENDAR_REMINDERS), nItemsCount);
  421. SetWindowText(strTitle);
  422. }
  424. void CXTPCalendarRemindersDialog::SelectItem(int nSelItemIndex)
  425. {
  426. int nItemsCount = m_ctrlRemindersList.GetItemCount();
  427. if (nSelItemIndex >= 0 && nItemsCount)
  428. {
  429. if (nSelItemIndex >= nItemsCount) {
  430. nSelItemIndex = nItemsCount - 1;
  431. }
  432. UINT uState = LVNI_FOCUSED|LVNI_SELECTED;
  433. m_ctrlRemindersList.SetItemState(nSelItemIndex, uState, uState);
  435. m_ctrlRemindersList.EnsureVisible(nSelItemIndex, FALSE);
  436. }
  437. }
  439. void CXTPCalendarRemindersDialog::OnReminders(XTP_NOTIFY_CODE Event, WPARAM wParam , LPARAM lParam)
  440. {
  441. if (Event != XTP_NC_CALENDAR_ON_REMINDERS)
  442. {
  443. ASSERT(FALSE);
  444. return;
  445. }
  447. int eAction = (int)wParam;
  449. if (eAction == xtpCalendarRemindersFire ||
  450. eAction == xtpCalendarReminderDismissedAll)
  451. {
  452. UpdateFromManager();
  454. if (m_bAutoPopup && m_pRemindersMan && m_pRemindersMan->GetActiveRemindersCount())
  455. {
  456. ShowWindow(SW_SHOWNORMAL);
  457. }
  458. }
  459. else if (eAction == xtpCalendarReminderSnoozed ||
  460.  eAction == xtpCalendarReminderDismissed)
  461. {
  462. CXTPCalendarReminder* pReminder = (CXTPCalendarReminder*)lParam;
  463. ASSERT(pReminder);
  465. if (!_RemoveReminderInfo(pReminder))
  466. {
  467. ASSERT(FALSE);
  468. UpdateFromManager();
  469. }
  470. }
  471. else if (eAction == xtpCalendarRemindersMonitoringStarted)
  472. {
  473. ASSERT(!m_pRemindersMan);
  474. ASSERT(m_pCalendar);
  476. CMDTARGET_RELEASE(m_pRemindersMan);
  477. m_pRemindersMan = m_pCalendar ? m_pCalendar->GetRemindersManager() : NULL;
  478. CMDTARGET_ADDREF(m_pRemindersMan);
  480. UpdateFromManager();
  481. }
  482. else if (eAction == xtpCalendarRemindersMonitoringStopped)
  483. {
  484. m_ctrlRemindersList.DeleteAllItems();
  485. m_arActiveReminders.RemoveAll();
  487. UpdateControlsBySelection();
  489. KillTimer(XTP_CALENDAR_RMD_REFRESH_TIMERID);
  490. KillTimer(XTP_CALENDAR_RMD_REFRESH_ITEM_TIMERID);
  492. CMDTARGET_RELEASE(m_pRemindersMan);
  493. }
  495. if (!m_arActiveReminders.GetCount())
  496. {
  497. ShowWindow(SW_HIDE);
  498. }
  499. }
  501. void CXTPCalendarRemindersDialog::OnOK()
  502. {
  503. OnSnooze();
  504. }
  506. void CXTPCalendarRemindersDialog::OnTimer(UINT_PTR nIDEvent)
  507. {
  508. CDialog::OnTimer(nIDEvent);
  510. if (nIDEvent == XTP_CALENDAR_RMD_REFRESH_TIMERID)
  511. {
  512. if (m_nNextRefreshIndex < 0)
  513. {
  514. m_nNextRefreshIndex = 0;
  515. SetTimer(XTP_CALENDAR_RMD_REFRESH_ITEM_TIMERID, XTP_CALENDAR_RMD_REFRESH_ITEM_TIMEOUT, NULL);
  516. }
  517. return;
  518. }
  520. //=======================================================================
  521. if (nIDEvent != XTP_CALENDAR_RMD_REFRESH_ITEM_TIMERID)
  522. {
  523. return;
  524. }
  526. if (!m_pRemindersMan || !m_ctrlRemindersList.m_hWnd)
  527. {
  528. ASSERT(FALSE);
  529. return;
  530. }
  532. m_pRemindersMan->GetActiveReminders(m_arActiveReminders);
  533. COleDateTime dtNow = CXTPCalendarUtils::GetCurrentTime();
  535. int nCount = m_arActiveReminders.GetCount();
  536. if (m_nNextRefreshIndex < nCount)
  537. {
  538. int nIndex = m_nNextRefreshIndex;
  539. m_nNextRefreshIndex++;
  541. CXTPCalendarReminder* pReminder = m_arActiveReminders.GetAt(nIndex, FALSE);
  542. CXTPCalendarEventPtr ptrEvent = pReminder ? pReminder->GetEvent() : NULL;
  544. if (!ptrEvent) {
  545. ASSERT(FALSE);
  546. return;
  547. }
  549. //-----------------------------------------
  550. COleDateTimeSpan spDueIn = ptrEvent->GetStartTime() - dtNow;
  551. int nMunutes = GETTOTAL_MINUTES_DTS(spDueIn);
  552. CString strText = CXTPCalendarUtils::FormatTimeDuration(labs(nMunutes), TRUE);
  553. if (nMunutes < 0)
  554. {
  555. strText += _T(" ") + CXTPCalendarUtils::LoadString(XTP_IDS_CALENDAR_OVERDUE);
  556. }
  558. m_ctrlRemindersList.SetItem(nIndex, 1, LVIF_TEXT, strText, 0, 0, 0, 0);
  559. }
  560. else
  561. {
  562. m_nNextRefreshIndex = -1;
  563. KillTimer(XTP_CALENDAR_RMD_REFRESH_ITEM_TIMERID);
  564. }
  565. }