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

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

对话框与窗口

开发平台：

Visual C++

XTPVC50Helpers.h：源码内容
  1. // XTPVC50Helpers.h : Visual C++ 5.0 helpers
  2. //
  3. // This file is a part of the XTREME TOOLKIT PRO 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. //{{AFX_CODEJOCK_PRIVATE
  22. #if !defined(__XTPVC50HELPERS_H__)
  23. #define __XTPVC50HELPERS_H__
  25. #if (_MSC_VER >= 1000)
  26. #pragma once
  27. #endif // _MSC_VER >= 1000
  29. class CXTPPushRoutingFrame
  30. {
  31. protected:
  32. CFrameWnd* pOldRoutingFrame;
  33. _AFX_THREAD_STATE* pThreadState;
  35. public:
  36. CXTPPushRoutingFrame(CFrameWnd* pNewRoutingFrame)
  37. {
  38. pThreadState = AfxGetThreadState();
  39. pOldRoutingFrame = pThreadState->m_pRoutingFrame;
  40. pThreadState->m_pRoutingFrame = pNewRoutingFrame;
  41. }
  42. ~CXTPPushRoutingFrame()
  43. {
  44. pThreadState->m_pRoutingFrame = pOldRoutingFrame;
  45. }
  46. };
  48. #if (_MSC_VER <= 1100)
  51. class CXTPStringHelper
  52. {
  53. class CXTPString : public CString {
  54. friend class CXTPStringHelper;
  55. };
  57. public:
  58. static int Remove(CString& strRemove, TCHAR chRemove)
  59. {
  60. CXTPString& str = (CXTPString&) strRemove;
  62. str.CopyBeforeWrite();
  64. LPTSTR pstrSource = str.m_pchData;
  65. LPTSTR pstrDest = str.m_pchData;
  66. LPTSTR pstrEnd = str.m_pchData + str.GetData()->nDataLength;
  68. while (pstrSource < pstrEnd)
  69. {
  70. if (*pstrSource != chRemove)
  71. {
  72. *pstrDest = *pstrSource;
  73. pstrDest = _tcsinc(pstrDest);
  74. }
  75. pstrSource = _tcsinc(pstrSource);
  76. }
  77. *pstrDest = '';
  78. int nCount = pstrSource - pstrDest;
  79. str.GetData()->nDataLength -= nCount;
  81. return nCount;
  82. }
  84. static int Find(const CString& strFind, LPCTSTR lpszSub, int nStart)
  85. {
  86. CXTPString& str = (CXTPString&) strFind;
  88. ASSERT(AfxIsValidString(lpszSub));
  90. int nLength = str.GetData()->nDataLength;
  91. if (nStart > nLength)
  92. return -1;
  94. // find first matching substring
  95. LPTSTR lpsz = _tcsstr(str.m_pchData + nStart, lpszSub);
  97. // return -1 for not found, distance from beginning otherwise
  98. return (lpsz == NULL) ? -1 : (int)(lpsz - str.m_pchData);
  99. }
  100. static int Find(const CString& strFind, TCHAR ch, int nStart)
  101. {
  102. CXTPString& str = (CXTPString&) strFind;
  104. int nLength = str.GetData()->nDataLength;
  105. if (nStart >= nLength)
  106. return -1;
  108. // find first single character
  109. LPTSTR lpsz = _tcschr(str.m_pchData + nStart, (_TUCHAR)ch);
  111. // return -1 if not found and index otherwise
  112. return (lpsz == NULL) ? -1 : (int)(lpsz - str.m_pchData);
  113. }
  115. static int Replace(CString& strReplace, TCHAR chOld, TCHAR chNew)
  116. {
  117. CXTPString& str = (CXTPString&) strReplace;
  118. int nCount = 0;
  120. // short-circuit the nop case
  121. if (chOld != chNew)
  122. {
  123. // otherwise modify each character that matches in the string
  124. str.CopyBeforeWrite();
  125. LPTSTR psz = str.m_pchData;
  126. LPTSTR pszEnd = psz + str.GetData()->nDataLength;
  127. while (psz < pszEnd)
  128. {
  129. // replace instances of the specified character only
  130. if (*psz == chOld)
  131. {
  132. *psz = chNew;
  133. nCount++;
  134. }
  135. psz = _tcsinc(psz);
  136. }
  137. }
  138. return nCount;
  139. }
  142. static int Replace(CString& strReplace, LPCTSTR lpszOld, LPCTSTR lpszNew)
  143. {
  144. CXTPString& str = (CXTPString&) strReplace;
  145. // can't have empty or NULL lpszOld
  147. int nSourceLen = str.SafeStrlen(lpszOld);
  148. if (nSourceLen == 0)
  149. return 0;
  150. int nReplacementLen = str.SafeStrlen(lpszNew);
  152. // loop once to figure out the size of the result string
  153. int nCount = 0;
  154. LPTSTR lpszStart = str.m_pchData;
  155. LPTSTR lpszEnd = str.m_pchData + str.GetData()->nDataLength;
  156. LPTSTR lpszTarget;
  157. while (lpszStart < lpszEnd)
  158. {
  159. while ((lpszTarget = _tcsstr(lpszStart, lpszOld)) != NULL)
  160. {
  161. nCount++;
  162. lpszStart = lpszTarget + nSourceLen;
  163. }
  164. lpszStart += lstrlen(lpszStart) + 1;
  165. }
  167. // if any changes were made, make them
  168. if (nCount > 0)
  169. {
  170. str.CopyBeforeWrite();
  172. // if the buffer is too small, just
  173. //   allocate a new buffer (slow but sure)
  174. int nOldLength = str.GetData()->nDataLength;
  175. int nNewLength =  nOldLength + (nReplacementLen-nSourceLen)*nCount;
  176. if (str.GetData()->nAllocLength < nNewLength || str.GetData()->nRefs > 1)
  177. {
  178. CStringData* pOldData = str.GetData();
  179. LPTSTR pstr = str.m_pchData;
  180. str.AllocBuffer(nNewLength);
  181. memcpy(str.m_pchData, pstr, pOldData->nDataLength*sizeof(TCHAR));
  182. CXTPString::Release(pOldData);
  183. }
  184. // else, we just do it in-place
  185. lpszStart = str.m_pchData;
  186. lpszEnd = str.m_pchData + str.GetData()->nDataLength;
  188. // loop again to actually do the work
  189. while (lpszStart < lpszEnd)
  190. {
  191. while ((lpszTarget = _tcsstr(lpszStart, lpszOld)) != NULL)
  192. {
  193. int nBalance = nOldLength - (lpszTarget - str.m_pchData + nSourceLen);
  194. memmove(lpszTarget + nReplacementLen, lpszTarget + nSourceLen,
  195. nBalance * sizeof(TCHAR));
  196. memcpy(lpszTarget, lpszNew, nReplacementLen*sizeof(TCHAR));
  197. lpszStart = lpszTarget + nReplacementLen;
  198. lpszStart[nBalance] = '';
  199. nOldLength += (nReplacementLen - nSourceLen);
  200. }
  201. lpszStart += lstrlen(lpszStart) + 1;
  202. }
  203. ASSERT(str.m_pchData[nNewLength] == '');
  204. str.GetData()->nDataLength = nNewLength;
  205. }
  207. return nCount;
  208. }
  210. static int Delete(CString& strSource, int nIndex, int nCount)
  211. {
  212. CXTPString& str = (CXTPString&) strSource;
  214. if (nIndex < 0)
  215. nIndex = 0;
  216. int nNewLength = str.GetData()->nDataLength;
  217. if (nCount > 0 && nIndex < nNewLength)
  218. {
  219. str.CopyBeforeWrite();
  220. int nBytesToCopy = nNewLength - (nIndex + nCount) + 1;
  222. memcpy(str.m_pchData + nIndex,
  223. str.m_pchData + nIndex + nCount, nBytesToCopy * sizeof(TCHAR));
  224. str.GetData()->nDataLength = nNewLength - nCount;
  225. }
  227. return nNewLength;
  228. }
  230. static int Insert(CString& strSource, int nIndex, LPCTSTR pstr)
  231. {
  232. if (nIndex < 0)
  233. nIndex = 0;
  235. CXTPString& str = (CXTPString&) strSource;
  237. int nInsertLength = str.SafeStrlen(pstr);
  238. int nNewLength = str.GetData()->nDataLength;
  239. if (nInsertLength > 0)
  240. {
  241. str.CopyBeforeWrite();
  242. if (nIndex > nNewLength)
  243. nIndex = nNewLength;
  244. nNewLength += nInsertLength;
  246. if (str.GetData()->nAllocLength < nNewLength)
  247. {
  248. CStringData* pOldData = str.GetData();
  249. LPTSTR pstr = str.m_pchData;
  250. str.AllocBuffer(nNewLength);
  251. memcpy(str.m_pchData, pstr, (pOldData->nDataLength+1)*sizeof(TCHAR));
  252. CXTPString::Release(pOldData);
  253. }
  255. // move existing bytes down
  256. memmove(str.m_pchData + nIndex + nInsertLength,
  257. str.m_pchData + nIndex,
  258. (nNewLength-nIndex-nInsertLength+1)*sizeof(TCHAR));
  259. memmove(str.m_pchData + nIndex,
  260. pstr, nInsertLength*sizeof(TCHAR));
  261. str.GetData()->nDataLength = nNewLength;
  262. }
  264. return nNewLength;
  265. }
  267. static void TrimRight(CString& strSource, LPCTSTR lpszTargetList)
  268. {
  269. // find beginning of trailing matches
  270. // by starting at beginning (DBCS aware)
  271. CXTPString& str = (CXTPString&) strSource;
  273. str.CopyBeforeWrite();
  274. LPTSTR lpsz = str.m_pchData;
  275. LPTSTR lpszLast = NULL;
  277. while (*lpsz != '')
  278. {
  279. if (_tcschr(lpszTargetList, *lpsz) != NULL)
  280. {
  281. if (lpszLast == NULL)
  282. lpszLast = lpsz;
  283. }
  284. else
  285. lpszLast = NULL;
  286. lpsz = _tcsinc(lpsz);
  287. }
  289. if (lpszLast != NULL)
  290. {
  291. // truncate at left-most matching character
  292. *lpszLast = '';
  293. str.GetData()->nDataLength = lpszLast - str.m_pchData;
  294. }
  295. }
  297. static void TrimLeft(CString& strSource, LPCTSTR lpszTargets)
  298. {
  299. CXTPString& str = (CXTPString&) strSource;
  301. // if we're not trimming anything, we're not doing any work
  302. if (!lpszTargets || lpszTargets[0] == 0)
  303. return;
  305. str.CopyBeforeWrite();
  306. LPCTSTR lpsz = str.m_pchData;
  308. while (*lpsz != '')
  309. {
  310. if (_tcschr(lpszTargets, *lpsz) == NULL)
  311. break;
  312. lpsz = _tcsinc(lpsz);
  313. }
  315. if (lpsz != str.m_pchData)
  316. {
  317. // fix up data and length
  318. int nDataLength = str.GetData()->nDataLength - (lpsz - str.m_pchData);
  319. memmove(str.m_pchData, lpsz, (nDataLength+1)*sizeof(TCHAR));
  320. str.GetData()->nDataLength = nDataLength;
  321. }
  322. }
  323. };
  325. #endif
  327. #define XTP_VC50_HALF_SECOND (1.0/172800.0)
  328. #include <math.h>
  330. class CXTPDateTimeHelper
  331. {
  332. public:
  333. #if (_MSC_VER <= 1200) // Using Visual C++ 5.0, 6.0
  334. static BOOL TmFromOleDate(DATE dtSrc, struct tm& tmDest)
  335. {
  336. const DATE MIN_DATE =               (-657434L);  // about year 100
  337. const DATE MAX_DATE =               2958465L;    // about year 9999
  339. static int nMonthDays[13] = {0, 31, 59, 90, 120, 151, 181, 212, 243, 273, 304, 334, 365};
  341. // The legal range does not actually span year 0 to 9999.
  342. if (dtSrc > MAX_DATE || dtSrc < MIN_DATE) // about year 100 to about 9999
  343. return FALSE;
  345. long nDays;             // Number of days since Dec. 30, 1899
  346. long nDaysAbsolute;     // Number of days since 1/1/0
  347. long nSecsInDay;        // Time in seconds since midnight
  348. long nMinutesInDay;     // Minutes in day
  349. long n400Years;         // Number of 400 year increments since 1/1/0
  350. long n400Century;       // Century within 400 year block (0, 1, 2 or 3)
  351. long n4Years;           // Number of 4 year increments since 1/1/0
  352. long n4Day;             // Day within 4 year block
  354. //  (0 is 1/1/yr1, 1460 is 12/31/yr4)
  355. long n4Yr;              // Year within 4 year block (0, 1, 2 or 3)
  356. BOOL bLeap4 = TRUE;     // TRUE if 4 year block includes leap year
  358. double dblDate = dtSrc; // temporary serial date
  360. // If a valid date, then this conversion should not overflow
  361. nDays = (long)dblDate;
  363. // Round to the second
  364. dblDate += ((dtSrc > 0.0) ? XTP_VC50_HALF_SECOND : -XTP_VC50_HALF_SECOND);
  366. nDaysAbsolute = (long)dblDate + 693959L; // Add days from 1/1/0 to 12/30/1899
  368. dblDate = fabs(dblDate);
  369. nSecsInDay = (long)((dblDate - floor(dblDate)) * 86400.);
  371. // Calculate the day of week (sun = 1, mon = 2...)
  372. // -1 because 1/1/0 is Sat. +1 because we want 1-based
  373. tmDest.tm_wday = (int)((nDaysAbsolute - 1) % 7L) + 1;
  375. // Leap years every 4 yrs except centuries not multiples of 400.
  376. n400Years = (long)(nDaysAbsolute / 146097L);
  378. // Set nDaysAbsolute to day within 400-year block
  379. nDaysAbsolute %= 146097L;
  381. // -1 because first century has extra day
  382. n400Century = (long)((nDaysAbsolute - 1) / 36524L);
  384. // Non-leap century
  385. if (n400Century != 0)
  386. {
  387. // Set nDaysAbsolute to day within century
  388. nDaysAbsolute = (nDaysAbsolute - 1) % 36524L;
  390. // +1 because 1st 4 year increment has 1460 days
  391. n4Years = (long)((nDaysAbsolute + 1) / 1461L);
  393. if (n4Years != 0)
  394. n4Day = (long)((nDaysAbsolute + 1) % 1461L);
  395. else
  396. {
  397. bLeap4 = FALSE;
  398. n4Day = (long)nDaysAbsolute;
  399. }
  400. }
  401. else
  402. {
  403. // Leap century - not special case!
  404. n4Years = (long)(nDaysAbsolute / 1461L);
  405. n4Day = (long)(nDaysAbsolute % 1461L);
  406. }
  408. if (bLeap4)
  409. {
  410. // -1 because first year has 366 days
  411. n4Yr = (n4Day - 1) / 365;
  413. if (n4Yr != 0)
  414. n4Day = (n4Day - 1) % 365;
  415. }
  416. else
  417. {
  418. n4Yr = n4Day / 365;
  419. n4Day %= 365;
  420. }
  422. // n4Day is now 0-based day of year. Save 1-based day of year, year number
  423. tmDest.tm_yday = (int)n4Day + 1;
  424. tmDest.tm_year = n400Years * 400 + n400Century * 100 + n4Years * 4 + n4Yr;
  426. // Handle leap year: before, on, and after Feb. 29.
  427. if (n4Yr == 0 && bLeap4)
  428. {
  429. // Leap Year
  430. if (n4Day == 59)
  431. {
  432. /* Feb. 29 */
  433. tmDest.tm_mon = 2;
  434. tmDest.tm_mday = 29;
  435. goto DoTime;
  436. }
  438. // Pretend it's not a leap year for month/day comp.
  439. if (n4Day >= 60)
  440. --n4Day;
  441. }
  443. // Make n4DaY a 1-based day of non-leap year and compute
  444. //  month/day for everything but Feb. 29.
  445. ++n4Day;
  447. // Month number always >= n/32, so save some loop time */
  448. for (tmDest.tm_mon = (n4Day >> 5) + 1;
  449. n4Day > nMonthDays[tmDest.tm_mon]; tmDest.tm_mon++);
  451. tmDest.tm_mday = (int)(n4Day - nMonthDays[tmDest.tm_mon-1]);
  453. DoTime:
  454. if (nSecsInDay == 0)
  455. tmDest.tm_hour = tmDest.tm_min = tmDest.tm_sec = 0;
  456. else
  457. {
  458. tmDest.tm_sec = (int)nSecsInDay % 60L;
  459. nMinutesInDay = nSecsInDay / 60L;
  460. tmDest.tm_min = (int)nMinutesInDay % 60;
  461. tmDest.tm_hour = (int)nMinutesInDay / 60;
  462. }
  464. return TRUE;
  465. }
  467. static BOOL GetAsSystemTime(const COleDateTime& dtTime, SYSTEMTIME& sysTime)
  468. {
  469. if (dtTime.GetStatus() != COleDateTime::valid)
  470. return FALSE;
  472. struct tm tmTemp;
  473. if (!TmFromOleDate(dtTime, tmTemp))
  474. return FALSE;
  476. sysTime.wYear = (WORD)tmTemp.tm_year;
  477. sysTime.wMonth = (WORD)tmTemp.tm_mon;
  478. sysTime.wDayOfWeek = (WORD)(tmTemp.tm_wday - 1);
  479. sysTime.wDay = (WORD)tmTemp.tm_mday;
  480. sysTime.wHour = (WORD)tmTemp.tm_hour;
  481. sysTime.wMinute = (WORD)tmTemp.tm_min;
  482. sysTime.wSecond = (WORD)tmTemp.tm_sec;
  483. sysTime.wMilliseconds = 0;
  485. return TRUE;
  486. };
  488. AFX_INLINE static LONG GetTotalDays(const COleDateTimeSpan& spSpan)
  489. {
  490. double dSpan = _RoundTime(spSpan);
  491. return  LONG(dSpan);
  492. };
  494. AFX_INLINE static LONG GetTotalHours(const COleDateTimeSpan& spSpan)
  495. {
  496. double dSpan = _RoundTime(spSpan);
  497. LONG nHours = LONG(dSpan * 24);
  498. return nHours;
  499. };
  501. static BOOL AFX_CDECL GetDateTimeCtrlTime(HWND hWnd, COleDateTime& timeDest)
  502. {
  503. SYSTEMTIME sysTime;
  504. BOOL bRetVal = TRUE;
  506. LRESULT result = ::SendMessage(hWnd, DTM_GETSYSTEMTIME, 0, (LPARAM) &sysTime);
  507. if (result == GDT_VALID)
  508. {
  509. timeDest = COleDateTime(sysTime);
  510. bRetVal = TRUE;
  511. ASSERT(timeDest.GetStatus() == COleDateTime::valid);
  512. }
  513. else if (result == GDT_NONE)
  514. {
  515. timeDest.SetStatus(COleDateTime::null);
  516. bRetVal = TRUE;
  517. }
  518. else
  519. timeDest.SetStatus(COleDateTime::invalid);
  520. return bRetVal;
  521. }
  523. static BOOL AFX_CDECL SetDateTimeCtrlTime(HWND hWnd, const COleDateTime& timeNew)
  524. {
  525. BOOL bRetVal = FALSE;
  527. // make sure the time isn't invalid
  528. ASSERT(timeNew.GetStatus() != COleDateTime::invalid);
  529. ASSERT(::IsWindow(hWnd));
  531. SYSTEMTIME sysTime;
  532. WPARAM wParam = GDT_NONE;
  533. if (timeNew.GetStatus() == COleDateTime::valid &&
  534. GetAsSystemTime(timeNew, sysTime))
  535. {
  536. wParam = GDT_VALID;
  537. }
  539. bRetVal = (BOOL) ::SendMessage(hWnd,
  540. DTM_SETSYSTEMTIME, wParam, (LPARAM) &sysTime);
  542. return bRetVal;
  543. }
  544. #endif
  546. AFX_INLINE static LONG GetTotalMinutes(const COleDateTimeSpan& spSpan)
  547. {
  548. double dSpan = _RoundTime(spSpan);
  549. double dMinutes = dSpan * 24 * 60;
  550. LONG nMinutes = _DoubleToLONG(dMinutes);
  551. return nMinutes;
  552. };
  554. AFX_INLINE static LONG GetTotalSeconds(const COleDateTimeSpan& spSpan)
  555. {
  556. double dSpan = _RoundTime(spSpan);
  557. double dSeconds= dSpan * 24 * 60 * 60;
  558. LONG nSeconds = _DoubleToLONG(dSeconds);
  559. return nSeconds;
  560. };
  561. protected:
  562. AFX_INLINE static double _RoundTime(double dTime)
  563. {
  564. dTime += dTime < 0 ? -XTP_VC50_HALF_SECOND : XTP_VC50_HALF_SECOND;
  565. return dTime;
  566. };
  567. AFX_INLINE static LONG _DoubleToLONG(double dValue)
  568. {
  569. return LONG(dValue > 0 ? min(dValue, double(LONG_MAX)) : max(dValue, double(LONG_MIN)) );
  570. };
  571. };
  573. AFX_INLINE CString CONSTRUCT_S(LPCSTR lpsz, int nLength) {
  574. #if (_MSC_VER <= 1100) && defined(_UNICODE) // Using Visual C++ 5.0
  575. CString str;
  576. if (nLength != 0)
  577. {
  578. LPTSTR lpzsData = str.GetBuffer(nLength);
  579. int n = ::MultiByteToWideChar(CP_ACP, 0, lpsz, nLength, lpzsData, nLength + 1);
  580. str.ReleaseBuffer(n >= 0 ? n : -1);
  581. }
  582. return str;
  583. #else
  584. return CString(lpsz, nLength);
  585. #endif
  586. }
  588. AFX_INLINE CString CONSTRUCT_S(LPCWSTR lpsz, int nLength) {
  589. #if (_MSC_VER <= 1100) && !defined(_UNICODE) // Using Visual C++ 5.0
  590. CString str;
  591. if (nLength != 0)
  592. {
  593. LPTSTR lpzsData = str.GetBuffer(nLength*2);
  594. int n = ::WideCharToMultiByte(CP_ACP, 0, lpsz, nLength, lpzsData,
  595. (nLength*2)+1, NULL, NULL);
  596. str.ReleaseBuffer(n >= 0 ? n : -1);
  597. }
  598. return str;
  599. #else
  600. return CString(lpsz, nLength);
  601. #endif
  602. }
  604. AFX_INLINE int REPLACE_S(CString& str, LPCTSTR lpszOld, LPCTSTR lpszNew) {
  605. #if (_MSC_VER <= 1100) // Using Visual C++ 5.0
  606. return CXTPStringHelper::Replace(str, lpszOld, lpszNew);
  607. #else
  608. return str.Replace(lpszOld, lpszNew);
  609. #endif
  610. }
  611. AFX_INLINE int REPLACE_S(CString& str, TCHAR chOld, TCHAR chNew) {
  612. #if (_MSC_VER <= 1100) // Using Visual C++ 5.0
  613. return CXTPStringHelper::Replace(str, chOld, chNew);
  614. #else
  615. return str.Replace(chOld, chNew);
  616. #endif
  617. }
  618. AFX_INLINE int FIND_S(const CString& str, LPCTSTR lpszSub, int nStart) {
  619. #if (_MSC_VER <= 1100) // Using Visual C++ 5.0
  620. return CXTPStringHelper::Find(str, lpszSub, nStart);
  621. #else
  622. return str.Find(lpszSub, nStart);
  623. #endif
  624. }
  625. AFX_INLINE int FIND_S(const CString& str, TCHAR ch, int nStart) {
  626. #if (_MSC_VER <= 1100) // Using Visual C++ 5.0
  627. return CXTPStringHelper::Find(str, ch, nStart);
  628. #else
  629. return str.Find(ch, nStart);
  630. #endif
  631. }
  632. AFX_INLINE int REMOVE_S(CString& str, TCHAR chRemove) {
  633. #if (_MSC_VER <= 1100) // Using Visual C++ 5.0
  634. return CXTPStringHelper::Remove(str, chRemove);
  635. #else
  636. return str.Remove(chRemove);
  637. #endif
  638. }
  639. AFX_INLINE int INSERT_S(CString& str, int nIndex, LPCTSTR pstr) {
  640. #if (_MSC_VER <= 1100) // Using Visual C++ 5.0
  641. return CXTPStringHelper::Insert(str, nIndex, pstr);
  642. #else
  643. return str.Insert(nIndex, pstr);
  644. #endif
  645. }
  646. AFX_INLINE int DELETE_S(CString& str, int nIndex, int nCount = 1) {
  647. #if (_MSC_VER <= 1100) // Using Visual C++ 5.0
  648. return CXTPStringHelper::Delete(str, nIndex, nCount);
  649. #else
  650. return str.Delete(nIndex, nCount);
  651. #endif
  652. }
  654. AFX_INLINE void TRIMRIGHT_S(CString& str, LPCTSTR lpszTargetList) {
  655. #if (_MSC_VER <= 1100) // Using Visual C++ 5.0
  656. CXTPStringHelper::TrimRight(str, lpszTargetList);
  657. #else
  658. str.TrimRight(lpszTargetList);
  659. #endif
  660. }
  662. AFX_INLINE void TRIMLEFT_S(CString& str, LPCTSTR lpszTargetList) {
  663. #if (_MSC_VER <= 1100) // Using Visual C++ 5.0
  664. CXTPStringHelper::TrimLeft(str, lpszTargetList);
  665. #else
  666. str.TrimLeft(lpszTargetList);
  667. #endif
  668. }
  671. AFX_INLINE BOOL GETASSYSTEMTIME_DT(const COleDateTime& dtTime, SYSTEMTIME& sysTime) {
  672. #if (_MSC_VER <= 1100) // Using Visual C++ 5.0
  673. return CXTPDateTimeHelper::GetAsSystemTime(dtTime, sysTime);
  674. #else
  675. ::ZeroMemory(&sysTime, sizeof(sysTime));
  676. return dtTime.GetAsSystemTime(sysTime);
  677. #endif
  678. }
  680. AFX_INLINE LONG GETTOTAL_DAYS_DTS(const COleDateTimeSpan& spSpan) {
  681. #if (_MSC_VER <= 1200) // Using Visual C++ 5.0, 6.0
  682. return CXTPDateTimeHelper::GetTotalDays(spSpan);
  683. #else
  684. return (LONG)spSpan.GetTotalDays();
  685. #endif
  686. }
  688. AFX_INLINE LONG GETTOTAL_HOURS_DTS(const COleDateTimeSpan& spSpan) {
  689. #if (_MSC_VER <= 1200) // Using Visual C++ 5.0, 6.0
  690. return CXTPDateTimeHelper::GetTotalHours(spSpan);
  691. #else
  692. return (LONG)spSpan.GetTotalHours();
  693. #endif
  694. }
  696. AFX_INLINE HRESULT VARCMP_S(LPVARIANT pvarLeft, LPVARIANT pvarRight, LCID lcid, ULONG dwFlags)
  697. {
  698. #if (_MSC_VER <= 1100) // Using Visual C++ 5.0
  699. HINSTANCE hModule = GetModuleHandle(_T("OLEAUT32.DLL"));
  700. if (!hModule)
  701. return E_FAIL;
  703. typedef HRESULT (STDAPICALLTYPE * PFNVARCMP)(LPVARIANT pvarLeft, LPVARIANT pvarRight, LCID lcid, ULONG dwFlags);
  704. PFNVARCMP pfnVarCmp = (PFNVARCMP)GetProcAddress(hModule, "VarCmp");
  705. if (!pfnVarCmp)
  706. return E_FAIL;
  708. return (*pfnVarCmp)(pvarLeft, pvarRight, lcid, dwFlags);
  709. #else
  710. return VarCmp(pvarLeft, pvarRight, lcid, dwFlags);
  711. #endif
  712. }
  714. AFX_INLINE LONG GETTOTAL_MINUTES_DTS(const COleDateTimeSpan& spSpan) {
  715. return CXTPDateTimeHelper::GetTotalMinutes(spSpan);
  716. }
  718. AFX_INLINE LONG GETTOTAL_SECONDS_DTS(const COleDateTimeSpan& spSpan) {
  719. return CXTPDateTimeHelper::GetTotalSeconds(spSpan);
  720. }
  722. #if (_MSC_VER <= 1100)
  724. AFX_INLINE LONG AFXAPI AfxDelRegTreeHelper(HKEY hParentKey, const CString& strKeyName)
  725. {
  726. TCHAR   szSubKeyName[256];
  727. HKEY    hCurrentKey;
  728. DWORD   dwResult;
  730. if ((dwResult = RegOpenKey(hParentKey, strKeyName, &hCurrentKey)) ==
  731. ERROR_SUCCESS)
  732. {
  733. // Remove all subkeys of the key to delete
  734. while ((dwResult = RegEnumKey(hCurrentKey, 0, szSubKeyName, 255)) ==
  735. ERROR_SUCCESS)
  736. {
  737. if ((dwResult = AfxDelRegTreeHelper(hCurrentKey, szSubKeyName)) != ERROR_SUCCESS)
  738. break;
  739. }
  741. // If all went well, we should now be able to delete the requested key
  742. if ((dwResult == ERROR_NO_MORE_ITEMS) || (dwResult == ERROR_BADKEY))
  743. {
  744. dwResult = RegDeleteKey(hParentKey, strKeyName);
  745. }
  746. }
  748. RegCloseKey(hCurrentKey);
  749. return dwResult;
  750. }
  752. #endif
  754. AFX_INLINE BOOL IMAGELISTDRAWINDIRECT_S(CImageList* pImageList, CDC* pDC, int nImage, POINT pt,
  755. SIZE sz, POINT ptOrigin = CPoint(0, 0), UINT fStyle = ILD_NORMAL,
  756. DWORD dwRop  = SRCCOPY, COLORREF rgbBack = CLR_DEFAULT,
  757. COLORREF rgbFore = CLR_DEFAULT)
  758. {
  759. #if (_MSC_VER <= 1100)
  760. ASSERT_POINTER(pDC, CDC);
  761. ASSERT(pDC->m_hDC != NULL);
  763. IMAGELISTDRAWPARAMS drawing;
  764. drawing.cbSize = sizeof(IMAGELISTDRAWPARAMS);
  765. drawing.himl = pImageList->m_hImageList;
  766. drawing.i = nImage;
  767. drawing.hdcDst = pDC->GetSafeHdc();
  768. drawing.x = pt.x;
  769. drawing.y = pt.y;
  770. drawing.cx = sz.cx;
  771. drawing.cy = sz.cy;
  772. drawing.xBitmap = ptOrigin.x;
  773. drawing.yBitmap = ptOrigin.y;
  774. drawing.rgbBk = rgbBack;
  775. drawing.rgbFg = rgbFore;
  776. drawing.fStyle = fStyle;
  777. drawing.dwRop = dwRop;
  779. return ImageList_DrawIndirect(&drawing);
  780. #else
  781. return pImageList->DrawIndirect(pDC, nImage, pt, sz, ptOrigin, fStyle, dwRop, rgbBack, rgbFore);
  782. #endif
  783. }
  785. //}}AFX_CODEJOCK_PRIVATE
  787. //////////////////////////////////////////////////////////////////////
  789. #endif // #if !defined(__XTPVC50HELPERS_H__)