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

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

对话框与窗口

开发平台：

Visual C++

XTPCalendarUtils.cpp：源码内容
  1. // XTPCalendarUtils.cpp: implementation of the CXTPCalendarUtils class.
  2. //
  3. // This file is a part of the XTREME CALENDAR MFC class library.
  4. // (c)1998-2008 Codejock Software, All Rights Reserved.
  5. //
  6. // THIS SOURCE FILE IS THE PROPERTY OF CODEJOCK SOFTWARE AND IS NOT TO BE
  7. // RE-DISTRIBUTED BY ANY MEANS WHATSOEVER WITHOUT THE EXPRESSED WRITTEN
  8. // CONSENT OF CODEJOCK SOFTWARE.
  9. //
  10. // THIS SOURCE CODE CAN ONLY BE USED UNDER THE TERMS AND CONDITIONS OUTLINED
  11. // IN THE XTREME TOOLKIT PRO LICENSE AGREEMENT. CODEJOCK SOFTWARE GRANTS TO
  12. // YOU (ONE SOFTWARE DEVELOPER) THE LIMITED RIGHT TO USE THIS SOFTWARE ON A
  13. // SINGLE COMPUTER.
  14. //
  15. // CONTACT INFORMATION:
  16. // support@codejock.com
  17. // http://www.codejock.com
  18. //
  19. /////////////////////////////////////////////////////////////////////////////
  21. #include "stdafx.h"
  22. #include "resource.h"
  23. #include <math.h>
  25. #include "Common/XTPResourceManager.h"
  26. #include "Common/XTPVC50Helpers.h"
  27. #include "Common/XTPDrawHelpers.h"
  28. #include "Common/XTPSystemHelpers.h"
  30. #include "XTPCalendarRecurrencePattern.h"
  31. #include "XTPCalendarData.h"
  32. #include "XTPCalendarUtils.h"
  38. #ifdef _DEBUG
  39. #undef THIS_FILE
  40. static char THIS_FILE[] = __FILE__;
  41. #define new DEBUG_NEW
  42. #endif
  44. ////////////////////////////////////////////////////////////////////////////
  45. BOOL CXTPCalendarUtils::s_bUseResourceFileLocale = FALSE;
  47. BOOL CXTPCalendarUtils::IsUseResourceFileLocale()
  48. {
  49. return s_bUseResourceFileLocale;
  50. }
  52. void CXTPCalendarUtils::SetUseResourceFileLocale(BOOL bUseResourceFileLocale)
  53. {
  54. s_bUseResourceFileLocale = bUseResourceFileLocale;
  55. }
  57. LCID CXTPCalendarUtils::GetActiveLCID()
  58. {
  59. LCID lcidCurr = LOCALE_USER_DEFAULT;
  61. if (s_bUseResourceFileLocale)
  62. lcidCurr = MAKELCID(XTPResourceManager()->GetResourcesLangID(), SORT_DEFAULT);
  64. return lcidCurr;
  65. }
  67. ////////////////////////////////////////////////////////////////////////////
  68. CXTPCalendarUtils::CXTPCalendarUtils()
  69. {
  70. }
  72. int CXTPCalendarUtils::GetLocaleLong(LCTYPE LCType)
  73. {
  74. TCHAR szResult[5];
  76. int nResult = ::GetLocaleInfo(GetActiveLCID(), LCType , szResult, 4);
  77. ASSERT(nResult == 2);
  78. return _ttoi(szResult);
  79. }
  81. CString CXTPCalendarUtils::GetLocaleString(LCTYPE LCType, int nMaxLength)
  82. {
  83. CString strResult;
  85. int nResult = ::GetLocaleInfo(GetActiveLCID(), LCType , strResult.GetBufferSetLength(nMaxLength), nMaxLength);
  86. strResult.ReleaseBuffer();
  87. ASSERT(strResult.GetLength() == nResult - 1);
  89. return strResult;
  90. }
  92. CString CXTPCalendarUtils::GetDateFormat(CONST SYSTEMTIME* lpDate, LPCTSTR lpFormat)
  93. {
  94. CString strResult;
  96. int nResult = ::GetDateFormat(GetActiveLCID(), 0, lpDate, lpFormat, strResult.GetBufferSetLength(255), 255);
  97. strResult.ReleaseBuffer();
  98. ASSERT(strResult.GetLength() == nResult - 1 || strResult.GetLength() == 0);
  100. return strResult;
  101. }
  103. CString CXTPCalendarUtils::GetTimeFormat(CONST SYSTEMTIME* lpTime, LPCTSTR lpFormat)
  104. {
  105. CString strResult;
  107. int nResult = ::GetTimeFormat(GetActiveLCID(), 0, lpTime, lpFormat, strResult.GetBufferSetLength(255), 255);
  108. strResult.ReleaseBuffer();
  109. ASSERT(strResult.GetLength() == nResult - 1);
  111. return strResult;
  112. }
  114. CString CXTPCalendarUtils::GetDateFormat(CONST COleDateTime& dtDate, LPCTSTR lpFormat)
  115. {
  116. SYSTEMTIME stDate;
  117. GETASSYSTEMTIME_DT(dtDate, stDate);
  118. return GetDateFormat(&stDate, lpFormat);
  119. }
  121. CString CXTPCalendarUtils::GetTimeFormat(CONST COleDateTime& dtTime, LPCTSTR lpFormat)
  122. {
  123. SYSTEMTIME stTime;
  124. GETASSYSTEMTIME_DT(dtTime, stTime);
  125. return GetTimeFormat(&stTime, lpFormat);
  126. }
  128. CString CXTPCalendarUtils::GetTimeFormat(int nHour, int nMinutes, LPCTSTR lpFormat)
  129. {
  130. SYSTEMTIME stTime;
  131. ::ZeroMemory(&stTime, sizeof(stTime));
  133. stTime.wHour = (WORD)nHour;
  134. stTime.wMinute = (WORD)nMinutes;
  136. return GetTimeFormat(&stTime, lpFormat);
  137. }
  139. ///***
  141. COleDateTime CXTPCalendarUtils::RetriveEventEndDate(const CXTPCalendarEvent* pEvent)
  142. {
  143. if (!pEvent)
  144. {
  145. ASSERT(FALSE);
  146. return COleDateTime((DATE)0);
  147. }
  149. COleDateTime dtStartDay = ResetTime(pEvent->GetStartTime());
  150. COleDateTime dtEndDay = ResetTime(pEvent->GetEndTime());
  152. if (IsZeroTime(pEvent->GetEndTime()) && dtStartDay < dtEndDay)
  153. {
  154. dtEndDay -= COleDateTimeSpan(1, 0, 0, 0);
  155. }
  156. return dtEndDay;
  157. }
  159. BOOL CXTPCalendarUtils::CalcDayOfMonth(COleDateTime& rdtDate, int nWhichDay, int nWhichDayMask)
  160. {
  161. ASSERT(nWhichDay >= xtpCalendarWeekFirst && nWhichDay <= xtpCalendarWeekLast);
  162. ASSERT((nWhichDayMask & (~xtpCalendarDayAllWeek)) == 0);
  164. COleDateTime dtYMD;
  165. dtYMD.SetDate(rdtDate.GetYear(), rdtDate.GetMonth(), 1);
  167. COleDateTimeSpan spStep(nWhichDay == xtpCalendarWeekLast ? -1 : 1, 0, 0, 0);
  169. if (nWhichDay == xtpCalendarWeekLast)
  170. {
  171. CXTPCalendarUtils::ShiftDate_Month(dtYMD, 1);
  172. COleDateTimeSpan spInitStep(-1, 0, 0, 0);
  173. dtYMD += spInitStep;
  174. }
  176. int nFCount = nWhichDay == xtpCalendarWeekLast ? xtpCalendarWeekLast-1 : xtpCalendarWeekFirst-1;
  178. for (int i = 0; i < 31; i++)
  179. {
  180. int nWD = dtYMD.GetDayOfWeek();
  181. int nWDMask = CXTPCalendarUtils::GetDayOfWeekMask(nWD);
  183. if (nWhichDayMask & nWDMask)
  184. {
  185. nFCount++;
  187. if (nFCount == nWhichDay)
  188. {
  189. rdtDate = dtYMD;
  190. return TRUE;
  191. }
  192. }
  193. dtYMD += spStep;
  194. }
  196. ASSERT(FALSE);
  197. return FALSE;
  198. }
  200. int CXTPCalendarUtils::GetWeekOfYear(COleDateTime dtDate, int nFirstDayOfWeekIndex)
  201. {
  202. COleDateTime dtFirst(dtDate.GetYear(), 1, 1, 0, 0, 0);
  203. COleDateTime dtFirstWeekDate = ShiftDateToWeekBegin(dtFirst, nFirstDayOfWeekIndex);
  205. COleDateTimeSpan spDiff = dtDate - dtFirstWeekDate;
  207. int nDayOfYear = (int)spDiff.GetTotalDays();
  208. int nWeek = nDayOfYear/7 + 1;
  210. return nWeek;
  211. }
  213. BOOL CXTPCalendarUtils::IsWin9x()
  214. {
  215. return XTPSystemVersion()->IsWin9x();
  216. }
  218. BOOL CXTPCalendarUtils::SystemTimeToTzSpecificLocalTime(
  219. const TIME_ZONE_INFORMATION* pTZI,
  220. const SYSTEMTIME* pUTime, SYSTEMTIME* pTzTime)
  221. {
  222. if (!pTZI || !pUTime || !pTzTime)
  223. {
  224. ASSERT(FALSE);
  225. return FALSE;
  226. }
  228. if (!CXTPCalendarUtils::IsWin9x())
  229. {
  230. return ::SystemTimeToTzSpecificLocalTime((TIME_ZONE_INFORMATION*)pTZI,
  231.  (SYSTEMTIME*)pUTime, pTzTime);
  232. }
  234. //---------------------------------------------------------------------------
  235. COleDateTime dtUTime(*pUTime);
  236. COleDateTime dtTzTime = dtUTime;
  238. int nBias_min = pTZI->Bias;
  240. if (pTZI->StandardDate.wMonth)
  241. {
  242. nBias_min += pTZI->StandardBias;
  243. }
  245. BOOL bDayLight = FALSE;
  246. int nDLBias_min = 0;
  247. if (pTZI->DaylightDate.wMonth != 0 && pTZI->DaylightBias != 0)
  248. {
  249. bDayLight = TRUE;
  250. nDLBias_min = (pTZI->DaylightBias - pTZI->StandardBias);
  251. }
  253. dtTzTime = dtUTime - Minutes2Span(nBias_min);
  255. if (bDayLight && IsInDst(pTZI, dtTzTime))
  256. {
  257. dtTzTime -= Minutes2Span(nDLBias_min);
  258. }
  260. return GETASSYSTEMTIME_DT(dtTzTime, *pTzTime);
  261. }
  263. BOOL CXTPCalendarUtils::IsInDst(const TIME_ZONE_INFORMATION* pTZI,
  264. COleDateTime dtTime)
  265. {
  266. if (pTZI->StandardDate.wMonth == 0 ||
  267. pTZI->DaylightDate.wMonth == 0 || pTZI->DaylightBias == 0)
  268. {
  269. return FALSE;
  270. }
  272. COleDateTime dtStandard(dtTime.GetYear(), pTZI->StandardDate.wMonth, 1,
  273. pTZI->StandardDate.wHour, pTZI->StandardDate.wMinute,
  274. pTZI->StandardDate.wSecond);
  276. COleDateTime dtDaylight(dtTime.GetYear(), pTZI->DaylightDate.wMonth, 1,
  277. pTZI->DaylightDate.wHour, pTZI->DaylightDate.wMinute,
  278. pTZI->DaylightDate.wSecond);
  280. BOOL bRes1 = CalcDayOfMonth(dtStandard, pTZI->StandardDate.wDay,
  281. GetDayOfWeekMask(pTZI->StandardDate.wDayOfWeek + 1));
  283. BOOL bRes2 = CalcDayOfMonth(dtDaylight, pTZI->DaylightDate.wDay,
  284. GetDayOfWeekMask(pTZI->DaylightDate.wDayOfWeek + 1));
  286. if (!bRes1 || !bRes2)
  287. {
  288. ASSERT(FALSE);
  289. return FALSE;
  290. }
  291. //  TRACE(_T("dtStandard = %d-%d-%d || "), dtStandard.GetYear(), dtStandard.GetMonth(), dtStandard.GetDay());
  292. //  TRACE(_T("dtDaylight = %d-%d-%d n"), dtDaylight.GetYear(), dtDaylight.GetMonth(), dtDaylight.GetDay());
  293. //  TRACE(_T("dtTime = %d-%d-%d n"), dtTime.GetYear(), dtTime.GetMonth(), dtTime.GetDay());
  295. if (dtStandard < dtDaylight)
  296. {
  297. if (dtTime >= dtDaylight || dtTime < dtStandard)
  298. {
  299. return TRUE;
  300. }
  301. }
  302. else
  303. {
  304. if (dtTime >= dtDaylight && dtTime < dtStandard)
  305. {
  306. return TRUE;
  307. }
  308. }
  310. return FALSE;
  311. }
  313. COleDateTime CXTPCalendarUtils::GetCurrentTime()
  314. {
  315. SYSTEMTIME st;
  316. ::ZeroMemory(&st, sizeof(st));
  318. ::GetLocalTime(&st);
  320. COleDateTime dtNow(st);
  322. return dtNow;
  323. }
  325. CString CXTPCalendarUtils::GetTimeFormatString_HrMin()
  326. {
  327. ////////////////////////////////////////////////////////////////////////////
  328. //  LOCALE_STIME    // time separator
  329. //
  330. //  LOCALE_ITLZERO  //leading zeros in time field
  331. //      0 No leading zeros for hours.
  332. //      1 Leading zeros for hours.
  333. //
  334. //  LOCALE_ITIME    // time format specifier
  335. //      0 AM / PM 12-hour format.
  336. //      1 24-hour format.
  337. //
  338. //  LOCALE_ITIMEMARKPOSN    // time marker position
  339. //      0 Use as suffix.
  340. //      1 Use as prefix.
  341. //
  342. //  LOCALE_S1159    // AM designator
  343. //  LOCALE_S2359    // PM designator
  344. ////////////////////////////////////////////////////////////////////////////
  346. CString strTmp;
  348. CString strTimeSeparator = CXTPCalendarUtils::GetLocaleString(LOCALE_STIME, 16);
  350. strTmp = CXTPCalendarUtils::GetLocaleString(LOCALE_ITIME, 16);
  351. BOOL b24_HFormat = _ttoi(strTmp) == 1;
  353. strTmp = CXTPCalendarUtils::GetLocaleString(LOCALE_ITLZERO, 16);
  354. BOOL bH_LZero = _ttoi(strTmp) == 1;
  356. strTmp = CXTPCalendarUtils::GetLocaleString(LOCALE_ITIMEMARKPOSN, 16);
  357. BOOL bAM_PM_Prefix = _ttoi(strTmp) == 1;
  359. //---------------------------------------------------------------------------
  360. CString strTimeFormat;
  361. strTimeFormat += strTimeSeparator;
  362. strTimeFormat += _T("mm");
  364. if (b24_HFormat)
  365. {
  366. strTmp = bH_LZero ? _T("HH") : _T("H");
  367. strTimeFormat = strTmp + strTimeFormat;
  368. }
  369. else //12 AM/PM Format
  370. {
  371. strTmp = bH_LZero ? _T("hh") : _T("h");
  372. strTimeFormat = strTmp + strTimeFormat;
  374. if (bAM_PM_Prefix)
  375. {
  376. strTimeFormat = _T("tt ") + strTimeFormat;
  377. }
  378. else
  379. {
  380. strTimeFormat = strTimeFormat + _T(" tt");
  381. }
  382. }
  383. //---------------------------------------------------------------------------
  385. return strTimeFormat;
  386. }
  388. int CXTPCalendarUtils::ParceTimeString_min(LPCTSTR pcszTime_HrMin)
  389. {
  390. CString strTime = pcszTime_HrMin;
  391. strTime.TrimLeft(); strTime.TrimRight();
  393. CString strPM = CXTPCalendarUtils::GetLocaleString(LOCALE_S2359, 20);
  394. strPM.MakeUpper();
  395. strTime.MakeUpper();
  397. // By default Am, or 24 hr format.
  398. BOOL bPM = !strPM.IsEmpty() && strTime.Find(strPM) >= 0;
  400. // remove prefixed AmPm and other non-digits in the beginning
  401. CString strTmp;
  402. strTmp = strTime.SpanExcluding(_T("0123456789"));
  403. int nTmpLen = strTmp.GetLength();
  404. if (nTmpLen)
  405. {
  406. DELETE_S(strTime, 0, nTmpLen);
  407. }
  409. //-------------------------------------------------
  410. CString strHr, strMin;
  411. strHr = strTime.SpanIncluding(_T("0123456789"));
  412. int nHrLen = strHr.GetLength();
  413. if (!nHrLen)
  414. {
  415. return -1;
  416. }
  417. DELETE_S(strTime, 0, nHrLen);
  419. CString strTimeSeparator = CXTPCalendarUtils::GetLocaleString(LOCALE_STIME, 16);
  420. TCHAR ctTimeSep = strTimeSeparator.GetLength() ? (TCHAR)strTimeSeparator[0] : (TCHAR)0;
  422. if (strTime.IsEmpty() || (strTime[0] != ctTimeSep && strTime[0] != _T(':')))
  423. {
  424. return -1;
  425. }
  426. DELETE_S(strTime, 0);
  428. strMin = strTime.SpanIncluding(_T("0123456789"));
  429. TCHAR* pChar1 = NULL, *pChar2 = NULL;
  430. int nHr = _tcstol(strHr, &pChar1, 10);
  431. int nMin = _tcstol(strMin, &pChar2, 10);
  433. int nResult_min = nHr * 60 + nMin;
  435. if (bPM && nResult_min <= 12 * 60)
  436. nResult_min += 12 * 60;
  438. if (nResult_min > 24 * 60)
  439. nResult_min = nResult_min % (24 * 60);
  441. return nResult_min;
  442. }
  444. CFont* CXTPCalendarUtils::GetMaxHeightFont(CArray<CFont*, CFont*>& arFonts, CDC* pDC,
  445.    int* pnMaxHeight)
  446. {
  447. CFont* pFontMax = NULL;
  449. int nMaxHeight = 0;
  450. int nCount = (int)arFonts.GetSize();
  451. for (int i = 0; i < nCount; i++)
  452. {
  453. CFont* pFont = arFonts[i];
  454. if (pFont && pFont->m_hObject)
  455. {
  456. if (pDC)
  457. {
  458. CXTPFontDC autoFont(pDC, pFont);
  459. CSize szFi = pDC->GetTextExtent(_T("Aq"), 2);
  461. if (szFi.cy > nMaxHeight)
  462. {
  463. pFontMax = pFont;
  464. nMaxHeight = szFi.cy;
  465. }
  466. }
  467. else
  468. {
  469. LOGFONT lf;
  470. int nRes = pFont->GetLogFont(&lf);
  471. ASSERT(nRes);
  472. if (nRes)
  473. {
  474. int nHeight = abs(lf.lfHeight) + (lf.lfWeight < FW_BOLD ? 0 : 1);
  475. if (nHeight > nMaxHeight)
  476. {
  477. pFontMax = pFont;
  478. nMaxHeight = nHeight;
  479. }
  480. }
  481. }
  482. }
  483. }
  485. if (pnMaxHeight)
  486. {
  487. *pnMaxHeight = nMaxHeight;
  488. }
  489. return pFontMax;
  490. }
  492. CXTPCalendarUtils::CXTPTimesResourceIDs::CXTPTimesResourceIDs()
  493. {
  494. s_mapMinutes.SetAt(0, XTP_IDS_CALENDAR_MINUTES_0);
  495. s_mapMinutes.SetAt(1, XTP_IDS_CALENDAR_MINUTES_1);
  496. s_mapMinutes.SetAt(5, XTP_IDS_CALENDAR_MINUTES_5);
  497. s_mapMinutes.SetAt(10, XTP_IDS_CALENDAR_MINUTES_10);
  498. s_mapMinutes.SetAt(15, XTP_IDS_CALENDAR_MINUTES_15);
  499. s_mapMinutes.SetAt(30, XTP_IDS_CALENDAR_MINUTES_30);
  501. s_mapHours.SetAt(1, XTP_IDS_CALENDAR_HOURS_1);
  502. s_mapHours.SetAt(2, XTP_IDS_CALENDAR_HOURS_2);
  503. s_mapHours.SetAt(3, XTP_IDS_CALENDAR_HOURS_3);
  504. s_mapHours.SetAt(4, XTP_IDS_CALENDAR_HOURS_4);
  505. s_mapHours.SetAt(5, XTP_IDS_CALENDAR_HOURS_5);
  506. s_mapHours.SetAt(6, XTP_IDS_CALENDAR_HOURS_6);
  507. s_mapHours.SetAt(7, XTP_IDS_CALENDAR_HOURS_7);
  508. s_mapHours.SetAt(8, XTP_IDS_CALENDAR_HOURS_8);
  509. s_mapHours.SetAt(9, XTP_IDS_CALENDAR_HOURS_9);
  510. s_mapHours.SetAt(10, XTP_IDS_CALENDAR_HOURS_10);
  511. s_mapHours.SetAt(11, XTP_IDS_CALENDAR_HOURS_11);
  512. s_mapHours.SetAt(12, XTP_IDS_CALENDAR_DAYS_0_5);
  513. s_mapHours.SetAt(18, XTP_IDS_CALENDAR_HOURS_18);
  515. s_mapDays.SetAt(1, XTP_IDS_CALENDAR_DAYS_1);
  516. s_mapDays.SetAt(2, XTP_IDS_CALENDAR_DAYS_2);
  517. s_mapDays.SetAt(3, XTP_IDS_CALENDAR_DAYS_3);
  519. s_mapWeeks.SetAt(1, XTP_IDS_CALENDAR_WEEKS_1);
  520. s_mapWeeks.SetAt(2, XTP_IDS_CALENDAR_WEEKS_2);
  521. }
  523. CString CXTPCalendarUtils::LoadString(UINT nIDResource)
  524. {
  525. CString str;
  526. VERIFY(XTPResourceManager()->LoadString(&str, nIDResource));
  527. return str;
  528. }
  530. BOOL CXTPCalendarUtils::LoadString2(CString& rstrString, UINT nIDResource)
  531. {
  532. CString str;
  533. BOOL bFind = XTPResourceManager()->LoadString(&str, nIDResource);
  534. if (bFind)
  535. {
  536. rstrString = str;
  537. }
  538. return bFind;
  539. }
  541. CString CXTPCalendarUtils::FormatTimeDuration(int nMinutes, BOOL bRoundly)
  542. {
  543. static CXTPTimesResourceIDs s_RCData;
  545. int nWeeks = nMinutes / (7*24*60);
  546. int nWeeks_r = nMinutes % (7*24*60);
  548. int nDays = nMinutes / (24*60);
  549. int nDays_r = nMinutes % (24*60);
  551. int nHours = nMinutes / 60;
  552. int nHours_r = nMinutes % 60;
  554. CString strDuration;
  555. UINT nStrID = 0;
  557. if ((bRoundly || nWeeks_r == 0) && nWeeks)
  558. {
  559. if (s_RCData.s_mapWeeks.Lookup(nWeeks, nStrID) && nStrID)
  560. strDuration = LoadString(nStrID);
  561. else
  562. strDuration.Format(_T("%d %s"), nWeeks, (LPCTSTR)LoadString(XTP_IDS_CALENDAR_WEEKS));
  563. }
  564. else if ((bRoundly  || nDays_r == 0) && nDays)
  565. {
  566. if (s_RCData.s_mapDays.Lookup(nDays, nStrID) && nStrID)
  567. strDuration = LoadString(nStrID);
  568. else
  569. strDuration.Format(_T("%d %s"), nDays, (LPCTSTR)LoadString(XTP_IDS_CALENDAR_DAYS));
  570. }
  571. else if ((bRoundly || nHours_r == 0) && nHours)
  572. {
  573. if (s_RCData.s_mapHours.Lookup(nHours, nStrID) && nStrID)
  574. strDuration = LoadString(nStrID);
  575. else
  576. strDuration.Format(_T("%d %s"), nHours, (LPCTSTR)LoadString(XTP_IDS_CALENDAR_HOURS));
  577. }
  578. else
  579. {
  580. if (s_RCData.s_mapMinutes.Lookup(nMinutes, nStrID) && nStrID)
  581. strDuration = LoadString(nStrID);
  582. else
  583. strDuration.Format(_T("%d %s"), nMinutes, (LPCTSTR)LoadString(XTP_IDS_CALENDAR_MINUTES));
  584. }
  586. return strDuration;
  587. }
  589. int CXTPCalendarUtils::ParceTimeDuration_min(LPCTSTR pcszTime)
  590. {
  591. CString strTime = pcszTime;
  593. strTime.TrimLeft(); strTime.TrimRight();
  595. CString strValue, strScale;
  596. strValue = strTime.SpanIncluding(_T("-+0123456789,."));
  597. int nValueLen = strValue.GetLength();
  598. if (!nValueLen)
  599. {
  600. return INT_MIN;
  601. }
  602. DELETE_S(strTime, 0, nValueLen);
  604. strScale = strTime;
  605. strScale.TrimLeft();
  607. TCHAR* pChar = NULL;
  608. REPLACE_S(strValue, _T(","), _T("."));
  609. double dValue = _tcstod(strValue, &pChar);
  611. CStringArray arSIname;
  612. CStringArray arSIname2;
  613. CUIntArray   arSIvalue;
  615. arSIname.Add(LoadString(XTP_IDS_CALENDAR_TIME_PREFIX_MINUTES));
  616. arSIname2.Add(_T("min"));
  617. arSIvalue.Add(1);
  619. arSIname.Add(LoadString(XTP_IDS_CALENDAR_TIME_PREFIX_HOURS));
  620. arSIname2.Add(_T("h"));
  621. arSIvalue.Add(60);
  623. arSIname.Add(LoadString(XTP_IDS_CALENDAR_TIME_PREFIX_DAYS));
  624. arSIname2.Add(_T("d"));
  625. arSIvalue.Add(24*60);
  627. arSIname.Add(LoadString(XTP_IDS_CALENDAR_TIME_PREFIX_WEEKS));
  628. arSIname2.Add(_T("w"));
  629. arSIvalue.Add(7*24*60);
  631. int nCount = (int)arSIname.GetSize();
  632. for (int i = 0; i < nCount; i++)
  633. {
  634. if (_tcsnicmp(strScale, arSIname[i], arSIname[i].GetLength()) == 0 ||
  635. _tcsnicmp(strScale, arSIname2[i], arSIname2[i].GetLength()) == 0)
  636. {
  637. return (int)(dValue * arSIvalue[i]);
  638. }
  639. }
  641. return (int)dValue; // minutes
  642. }