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

源码开发语言/平台
当前位置：首页 > 源码/资料 > Windows编程 > 进程与线程 > 查看源码
PublicFunction.cpp
资源名称：NetDownMTR.rar　[点击查看]
上传用户：oadesign
上传日期：2013-12-25
资源大小：265k
文件大小：36k
源码类别：

进程与线程

开发平台：

Visual C++

PublicFunction.cpp：源码内容
  1. // PublicFunction.cpp: implementation of the CPublicFunction class.
  2. //
  3. //////////////////////////////////////////////////////////////////////
  5. #include "stdafx.h"
  6. #include "NetDownMTR.h"
  7. #include "PublicFunction.h"
  8. #include <Afxmt.h>
  9. #include  <io.h>
  10. #include <direct.h>
  11. // for function StrTrim()
  12. #include "Shlwapi.h"
  13. #pragma comment ( lib, "Shlwapi.lib" )
  15. #ifdef _DEBUG
  16. #undef THIS_FILE
  17. static char THIS_FILE[]=__FILE__;
  18. #define new DEBUG_NEW
  19. #endif
  21. const char f_seps[]   = ";";
  23. void DeleteStrAry(CStringArray **ppStrAry)
  24. {
  25. if ( ppStrAry && (*ppStrAry) )
  26. {
  27. (*ppStrAry)->RemoveAll();
  28. (*ppStrAry)->FreeExtra();
  29. delete (*ppStrAry);
  30. (*ppStrAry) = NULL;
  31. }
  32. }
  33. int PartStringAndAddToStrAry ( char *pStr, CStringArray &StrAry, char *seps/*="trn"*/ )
  34. {
  35. StrAry.RemoveAll();
  36. char *token;
  37. token = strtok( pStr, seps );
  38. while( token != NULL )
  39. {
  40. /* While there are tokens in "string" */
  41. StrAry.Add ( token );
  42. /* Get next token: */
  43. token = strtok( NULL, seps );
  44. }
  45. return StrAry.GetSize();
  46. }
  48. int PartStringAndAddToStrAry ( char *pStr, CStringArray &StrAry, char nPartFlag )
  49. {
  50. char *pStart = pStr;
  51. char *pFind = NULL;
  52. char szTempBuf[10240] = {0};
  53. LPCTSTR pszTrimChars = "rnt";
  54. while ( pFind = strchr ( pStart, nPartFlag ) )
  55. {
  56. int nLen = pFind - pStart;
  57. if ( nLen > 0 )
  58. {
  59. if ( nLen > sizeof(szTempBuf)-2 )
  60. nLen = sizeof(szTempBuf)-2;
  61. memcpy ( szTempBuf, pStart, nLen );
  62. szTempBuf [ nLen ] = '';
  63. StrTrim ( szTempBuf, pszTrimChars );
  64. StrAry.Add ( szTempBuf );
  65. }
  66. else
  67. {
  68. StrAry.Add ( "" );
  69. }
  71. pStart = pFind + 1;
  72. }
  73. if ( (int)( pStart - pStr ) < (int)strlen ( pStr ) )
  74. StrAry.Add ( pStart );
  76. return StrAry.GetSize();
  77. }
  79. int PartStringAndAddToStrAry ( LPCTSTR lpszStr, CStringArray &StrAry, char nFirstFlag, char nSecondFlag )
  80. {
  81. StrAry.RemoveAll();
  82. int nStartPos = 0, nEndPos = 0;
  83. CString csBigString = GET_SAFE_STRING ( lpszStr );
  84. BOOL bSentence = FALSE;
  85. for ( ;; )
  86. {
  87. char cFindChar = ( bSentence ? nSecondFlag : nFirstFlag );
  88. int nFindPos = csBigString.Find ( cFindChar, nEndPos );
  89. if ( nFindPos < 0 )
  90. {
  91. if ( bSentence )
  92. {
  93. CString csTemp = csBigString.Mid ( nStartPos+1 );
  94. if ( csTemp.GetLength() > 0 )
  95. StrAry.Add ( csTemp );
  96. }
  97. break;
  98. }
  99. if ( !bSentence )
  100. {
  101. nStartPos = nFindPos;
  102. bSentence = TRUE;
  103. }
  104. else
  105. {
  106. nEndPos = nFindPos;
  107. CString csTemp = csBigString.Mid ( nStartPos+1, nEndPos-nStartPos-1 );
  108. StrAry.Add ( csTemp );
  109. bSentence = FALSE;
  110. }
  111. nEndPos = nFindPos + 1;
  112. }
  114. return StrAry.GetSize();
  115. }
  117. //////////////////////////////////////////////////////////////////////
  118. // Construction/Destruction
  119. //////////////////////////////////////////////////////////////////////
  120. CHwDir::CHwDir(
  121. LPCTSTR lpszBasePathOrFile,
  122. BOOL bSerachSubDir/* = TRUE*/, // 搜索子目录
  123. BOOL bAbsolutePath /*=TRUE*/, // 是绝对路径
  124. CHwDir **ppHwDir/*=NULL*/ // 将这个类的指针传出去给调用者
  125. )
  126. {
  127. m_bCancel = FALSE;
  128. if ( ppHwDir ) *ppHwDir = this;
  129. m_pStrAryResFile = new CStringArray;
  130. if ( !m_pStrAryResFile ) return;
  131. m_pStrArySubDirectory_Private = new CStringArray;
  132. if ( !m_pStrArySubDirectory_Private ) return;
  133. m_pStrArySubDirectory = new CStringArray;
  134. if ( !m_pStrArySubDirectory ) return;
  136. //初始化变量
  137. char buf[MAX_PATH];
  138. m_bSerachSubDir = bSerachSubDir;
  139. m_bAbsolutePath = bAbsolutePath;
  140. m_pStrAryResFile->FreeExtra();
  141. m_pStrArySubDirectory_Private->FreeExtra();
  142. m_pStrArySubDirectory->FreeExtra();
  143. m_dwRelativePathStartPos = 0;
  144. ZeroMemory(m_szBasePathFile,sizeof(m_szBasePathFile));
  145. int iLen = 0;
  146. char *p = NULL;
  147. ZeroMemory(m_strFilter,sizeof(m_strFilter));
  148. m_AmountBytes = 0;
  149. iLen = hwSnprintf((char*)m_szBasePathFile,sizeof(m_szBasePathFile)-2,"%s",lpszBasePathOrFile);
  152. //查找的是目录还是文件，取得目录名和过滤字符（*.*、*.exe、??.cpp等都是过滤条件)
  153. char TempBuf[MAX_PATH];
  154. ZeroMemory(TempBuf,sizeof(TempBuf));
  155. DWORD dwFileAttrib = GetFileAttributes(m_szBasePathFile);
  156. if((dwFileAttrib & FILE_ATTRIBUTE_DIRECTORY) && dwFileAttrib != 0xffffffff) //指定搜索一个目录，没有过滤条件
  157. {
  158. strcpy(m_strFilter,"*.*");
  159. if(m_szBasePathFile[iLen - 1] != '\')
  160. m_szBasePathFile[iLen] = '\';
  161. }
  162. else //指定了过滤条件
  163. {
  164. PartFileAndPathByFullPath(m_szBasePathFile,m_strFilter,sizeof(m_strFilter),TempBuf,sizeof(TempBuf));
  165. STRNCPY_SZ( m_szBasePathFile, TempBuf );
  166. }
  167. //找相对路径的位置
  168. if ( !bAbsolutePath )
  169. {
  170. strcpy((char*)buf,(const char*)m_szBasePathFile);
  171. if ( strchr((const char*)buf,':') && strlen((const char*)buf) == 3 ) //是诸如“E:”、“d:”的路径
  172. {
  173. m_dwRelativePathStartPos = 3;
  174. }
  175. else if ( strlen((const char*)buf) == 1 && buf[0] == '\') //是“”，表示搜索当前盘的根目录
  176. {
  177. m_dwRelativePathStartPos = 1;
  178. }
  179. else //一般目录（绝对路径、相对路径）
  180. {
  181. iLen = (int)strlen((const char*)buf);
  182. buf[iLen - 1] = '';
  183. p = strrchr((const char*)buf,'\');
  184. if(p)
  185. {
  186. m_dwRelativePathStartPos = (DWORD)(p - buf + 1);
  187. }
  188. }
  189. }
  190. Dir();
  191. }
  193. CHwDir::~CHwDir()
  194. {
  195. DeleteStrAry ( &m_pStrAryResFile );
  196. DeleteStrAry ( &m_pStrArySubDirectory_Private );
  197. DeleteStrAry ( &m_pStrArySubDirectory );
  198. }
  199. /********************************************************************************
  200. * Function Type : private
  201. * Parameter : None
  202. * Return Value : 获得的文件总数
  203. * Description : 将目录m_szBasePathFile下的所有文件列举出来
  204. *********************************************************************************/
  205. DWORD CHwDir::Dir()
  206. {
  207. char strDirectory[MAX_PATH*4];
  208. DWORD dwLine = 0;
  209. FindDirAndFile(m_szBasePathFile);
  210. while(1)
  211. {
  212. dwLine = (DWORD)m_pStrArySubDirectory_Private->GetSize();
  213. if(dwLine < 1) break;
  214. //处理m_StrArySubDirectory中最后一个子目录
  215. hwSnprintf((char*)strDirectory,sizeof(strDirectory) - 1,"%s",m_pStrArySubDirectory_Private->GetAt(dwLine - 1));
  216. m_pStrArySubDirectory_Private->RemoveAt(dwLine - 1);
  217. FindDirAndFile(strDirectory);
  218. if ( m_bCancel ) break;
  219. }
  220. return m_pStrAryResFile->GetSize();
  221. }
  222. /********************************************************************************
  223. * Function Type : private
  224. * Parameter : lpszDirectory - 要搜索的纯目录
  225. * Return Value : 获得的文件总数
  226. * Description : 所有一个目录下的所有目录和符合过滤条件的文件
  227. *********************************************************************************/
  228. DWORD CHwDir::FindDirAndFile(LPCTSTR lpszDirectory)
  229. {
  230. DWORD dwRet = 0;
  231. char strDirFile[MAX_PATH*2];
  232. hwSnprintf((char*)strDirFile,sizeof(strDirFile) - 1,"%s*.*",lpszDirectory); //先搜索出子目录
  233. dwRet += FindAllFileUnderOneDir((LPCTSTR)strDirFile,lpszDirectory,TRUE);
  234. hwSnprintf((char*)strDirFile,sizeof(strDirFile) - 1,"%s%s",lpszDirectory,m_strFilter); //再按过滤条件搜索
  235. dwRet += FindAllFileUnderOneDir(strDirFile,lpszDirectory,FALSE);
  236. return dwRet;
  237. }
  238. /********************************************************************************
  239. * Function Type : private
  240. * Parameter : lpszFileName - 要处理的文件（这里把目录也视为文件）
  241. * lpszDirectory - 纯目录（不需要再找目录了，减少计算量）
  242. * bFindDir - 是否只搜索目录，不理会文件
  243. * Return Value : 获得的文件总数
  244. * Description : 查找lpszFileName指定的所有文件或所有目录
  245. *********************************************************************************/
  246. DWORD CHwDir::FindAllFileUnderOneDir(LPCTSTR lpszFileName,LPCTSTR lpszDirectory,BOOL bFindDir)
  247. {
  248. DWORD dwFileNum = 0, dwDirNum = 0;
  249. WIN32_FIND_DATA FindData;
  250. HANDLE hFileHandle = FindFirstFile(lpszFileName,&FindData);
  251. if(hFileHandle == INVALID_HANDLE_VALUE)
  252. return dwFileNum;
  253. int iRet = HandleOneFile ( lpszDirectory, &FindData, bFindDir );
  254. if(iRet == 1) //是文件
  255. dwFileNum ++;
  256. else if(iRet == 2) //是目录
  257. dwDirNum ++;
  258. while ( FindNextFile ( hFileHandle, &FindData ) )
  259. {
  260. iRet = HandleOneFile ( lpszDirectory, &FindData, bFindDir );
  261. if(iRet == 1) //是文件
  262. dwFileNum ++;
  263. else if(iRet == 2) //是目录
  264. dwDirNum ++;
  265. if ( m_bCancel ) break;
  266. }
  267. FindClose(hFileHandle);
  268. return dwFileNum;
  269. }
  270. /********************************************************************************
  271. * Function Type : private
  272. * Parameter : lpszDirectory - 纯路径（不包含文件名）
  273. * pFindData - 文件信息
  274. * bFindDir - TRUE  : 只搜索目录，不理会文件
  275. * FALSE : 只搜索文件，不理会目录
  276. * Return Value : 1 - 是一个有效的文件
  277. * 2 - 是一个有效的目录
  278. * -1 _ - 不是想要的文件或目录
  279. * Description : 处理一个找到的文件（这里把目录也视为文件）
  280. *********************************************************************************/
  281. int CHwDir::HandleOneFile(LPCTSTR lpszDirectory, WIN32_FIND_DATA* pFindData,BOOL bFindDir)
  282. {
  283. char ResBuf[3*MAX_PATH];
  284. ULONGLONG FileSize;
  285. LPDWORD pDword = (LPDWORD)&FileSize;
  286. pDword[0] = pFindData->nFileSizeLow;
  287. pDword[1] = pFindData->nFileSizeHigh;
  288. ZeroMemory(ResBuf,sizeof(ResBuf));
  289. if(stricmp((const char*)pFindData->cFileName,"..")== 0 || pFindData->cFileName[0] == '.')
  290. return -1;
  291. if((pFindData->dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY) && 
  292. pFindData->dwFileAttributes != 0xffffffff)
  293. {
  294. if(bFindDir)
  295. {
  296. if(m_bSerachSubDir)
  297. {
  298. hwSnprintf((char*)ResBuf,sizeof(ResBuf) - 1,"%s%s\",lpszDirectory,pFindData->cFileName);
  299. m_pStrArySubDirectory_Private->Add((LPCTSTR)ResBuf);
  300. m_pStrArySubDirectory->Add((LPCTSTR)ResBuf);
  301. return 2;
  302. }
  303. }
  304. }
  305. else if(!bFindDir)
  306. {
  307. hwSnprintf((char*)ResBuf, sizeof(ResBuf) - 1,
  308. "%s%s", lpszDirectory+m_dwRelativePathStartPos, pFindData->cFileName );
  309. m_pStrAryResFile->Add((LPCTSTR)ResBuf);
  310. m_AmountBytes += FileSize;
  311. #ifdef _DEBUG
  312. printf("NO.%04d : %stt%dt字节n",m_pStrAryResFile->GetSize(),ResBuf,FileSize);
  313. #endif
  314. return 1;
  315. }
  316. return -1;
  317. }
  319. /********************************************************************************
  320. * Function Type : public
  321. * Parameter : None
  322. * Return Value : None
  323. * Description : 取字节总数
  324. *********************************************************************************/
  325. ULONGLONG CHwDir::GetAmountBytes()
  326. {
  327. return m_AmountBytes;
  328. }
  330. void CHwDir::Cancel()
  331. {
  332. m_bCancel = TRUE;
  333. }
  335. //////////////////////////////////////////////////////////////////////
  336. // CHwDirEx Class
  337. //////////////////////////////////////////////////////////////////////
  339. //////////////////////////////////////////////////////////////////////
  340. // Construction/Destruction
  341. //////////////////////////////////////////////////////////////////////
  343. CHwDirEx::CHwDirEx(
  344. LPCTSTR lpszMultiFindPath, // 要搜索的多路径，如“E:\winnt\;d:temp\;”
  345. LPCTSTR lpszMultiFindFilter, // 要搜索的过滤条件，如“*.bmp;*.exe;”
  346. LPCTSTR lpszMultiExcludeFilter/*=NULL*/, // 要排除的过滤条件，如“*.bmp;*.exe;”
  347. BOOL bSerachSubDir/* = TRUE*/, // 搜索子目录
  348. BOOL bAbsolutePath /*=TRUE*/, // 是绝对路径
  349. CHwDirEx **ppHwDirEx/*=NULL*/ // 将这个类的指针传出去给调用者
  350. )
  351. : m_AmountBytes ( 0 )
  352. , m_bCancel ( FALSE )
  353. , m_pHwDir ( NULL )
  354. {
  355. ASSERT ( lpszMultiFindPath && strlen(lpszMultiFindPath) > 0 );
  356. ASSERT ( lpszMultiFindFilter && strlen(lpszMultiFindFilter) > 0 );
  357. if ( ppHwDirEx ) *ppHwDirEx = this;
  359. m_pStrAryResFile = new CStringArray;
  360. if ( !m_pStrAryResFile ) return;
  361. m_pStrArySubDirectory = new CStringArray;
  362. if ( !m_pStrArySubDirectory ) return;
  364. CStringArray StrAryMultiFindPath;
  365. PartStringAndAddToStrAry ( (char*)lpszMultiFindPath, StrAryMultiFindPath, (char)f_seps[0] );
  366. for ( int i=0; i<StrAryMultiFindPath.GetSize(); i++ )
  367. {
  368. CString csFindPath = StrAryMultiFindPath.GetAt(i);
  369. DirAll ( csFindPath, lpszMultiFindFilter, lpszMultiExcludeFilter, bSerachSubDir, bAbsolutePath );
  370. if ( m_bCancel ) break;
  371. }
  372. }
  374. CHwDirEx::~CHwDirEx()
  375. {
  376. DeleteStrAry ( &m_pStrAryResFile );
  377. DeleteStrAry ( &m_pStrArySubDirectory );
  378. }
  380. ULONGLONG CHwDirEx::GetAmountBytes()
  381. {
  382. return m_AmountBytes;
  383. }
  385. void CHwDirEx::DirAll(
  386. LPCTSTR lpszFindPath, // 要搜索的路径，如“E:\winnt\”
  387. LPCTSTR lpszMultiFindFilter, // 要搜索的过滤条件，如“*.bmp;*.exe;”
  388. LPCTSTR lpszMultiExcludeFilter/*=NULL*/, // 要排除的过滤条件，如“*.bmp;*.exe;”
  389. BOOL bSerachSubDir/* = TRUE*/, // 搜索子目录
  390. BOOL bAbsolutePath /*=TRUE*/ // 是绝对路径
  391. )
  392. {
  393. ASSERT ( lpszFindPath && strlen(lpszFindPath) > 0 );
  395. CStringArray StrAryResFile_Find, StrAryResFile_Exclude,
  396. StrArySubDirectory_Find, StrArySubDirectory_Exclude;
  397. DWORD dwAmountBytes_Find = 0, dwAmountBytes_Exclude = 0;
  399. // 先搜索符合指定过滤条件的文件
  400. Dir ( lpszFindPath, lpszMultiFindFilter, StrAryResFile_Find, StrArySubDirectory_Find,
  401. dwAmountBytes_Find, bSerachSubDir, bAbsolutePath );
  403. // 再搜索需要排除的文件
  404. if ( lpszMultiExcludeFilter && strlen ( lpszMultiExcludeFilter ) > 0 )
  405. {
  406. ASSERT ( lpszMultiExcludeFilter && strlen(lpszMultiExcludeFilter) > 0 );
  407. Dir ( lpszFindPath, lpszMultiExcludeFilter, StrAryResFile_Exclude, StrArySubDirectory_Exclude,
  408. dwAmountBytes_Exclude, bSerachSubDir, bAbsolutePath );
  409. // 然后从 StrAryResFile_Find 中删除掉需要排除的文件
  410. for ( int i=0; i<StrAryResFile_Exclude.GetSize(); i++ )
  411. {
  412. CString csResFile = StrAryResFile_Exclude.GetAt(i);
  413. int nFindPos = FindFromArray ( StrAryResFile_Find, csResFile );
  414. if ( nFindPos >= 0 ) StrAryResFile_Find.RemoveAt ( nFindPos );
  415. if ( m_bCancel ) break;
  416. }
  417. }
  419. // 最后将搜索结果保存到成员变量中，并清理临时变量
  420. m_pStrAryResFile->Append ( StrAryResFile_Find );
  421. m_pStrArySubDirectory->Append ( StrArySubDirectory_Find );
  422. m_AmountBytes += (dwAmountBytes_Find - dwAmountBytes_Exclude);
  423. StrAryResFile_Find.RemoveAll();
  424. StrAryResFile_Exclude.RemoveAll();
  425. StrArySubDirectory_Find.RemoveAll();
  426. StrArySubDirectory_Exclude.RemoveAll();
  427. }
  429. void CHwDirEx::Dir(
  430. LPCTSTR lpszFindPath, // 要搜索的路径，如“E:\winnt\”
  431. LPCTSTR lpszMultiFindFilter, // 要搜索的过滤条件，如“*.bmp;*.exe;”
  432. CStringArray &StrAryResFile, // 搜索的文件保存到此
  433. CStringArray &StrArySubDirectory, // 搜索的子目录保存到此
  434. DWORD &dwAmountBytes, // 总字节数保存到此
  435. BOOL bSerachSubDir/* = TRUE*/, // 搜索子目录
  436. BOOL bAbsolutePath /*=TRUE*/ // 是绝对路径
  437. )
  438. {
  439. ASSERT ( lpszFindPath && strlen(lpszFindPath) > 0 );
  440. dwAmountBytes = 0;
  441. StrAryResFile.RemoveAll();
  442. StrArySubDirectory.RemoveAll();
  444. char szFindPath[MAX_PATH] = {0}, szMultiFindFilter[1024]={0}, szMultiExcludeFilter[1024]={0};
  445. STRNCPY_SZ ( szFindPath, lpszFindPath );
  446. STRNCPY_SZ ( szMultiFindFilter, lpszMultiFindFilter );
  447. StandardizationPathBuffer ( szFindPath, sizeof(szFindPath), '\' );
  449. char *token = strtok( szMultiFindFilter, f_seps );
  450. while( token != NULL )
  451. {
  452. /* While there are tokens in "string" */
  453. char szFindFile[MAX_PATH] = {0};
  454. hwSnprintf ( szFindFile, sizeof(szFindFile)-1, "%s%s", szFindPath, token );
  455. CHwDir dir ( szFindFile, bSerachSubDir, bAbsolutePath, &m_pHwDir );
  456. if ( dir.m_pStrAryResFile && dir.m_pStrArySubDirectory )
  457. {
  458. StrAryResFile.Append ( *(dir.m_pStrAryResFile) );
  459. StrArySubDirectory.Append ( *(dir.m_pStrArySubDirectory) );
  460. dwAmountBytes += (DWORD)dir.GetAmountBytes();
  461. }
  462. /* Get next token: */
  463. token = strtok( NULL, f_seps );
  464. if ( m_bCancel ) break;
  465. m_pHwDir = NULL;
  466. }
  467. }
  469. void CHwDirEx::Cancel()
  470. {
  471. m_bCancel = TRUE;
  472. if ( m_pHwDir )
  473. m_pHwDir->Cancel ();
  474. }
  476. CString GetOneLine(CString &str)
  477. {
  478. int nPos = str.Find ( "rn", 0 );
  479. if ( nPos < 0 ) return "";
  480. CString csOneLine = str.Left ( nPos );
  481. str = str.Mid ( nPos + 2 );
  482. return csOneLine;
  483. }
  485. int CalcCharCount ( LPCTSTR lpszText, char chCalc )
  486. {
  487. int nLen = STRLEN_SZ(lpszText);
  488. int nCount = 0;
  489. for ( int i=0; i<nLen; i++ )
  490. {
  491. if ( (BYTE)lpszText[i] == (BYTE)chCalc )
  492. nCount ++;
  493. }
  494. return nCount;
  495. }
  497. #define  TIME_START_YEAR  1900
  498. BOOL CopyBuffer_Date ( int *data, SYSTEMTIME &SysTime )
  499. {
  500. const int nMinDateDigitCount = 3;
  501. ASSERT_ADDRESS ( data, nMinDateDigitCount * sizeof(int) );
  503. /********年(1000 ~ 9999)********/
  504. if ( data[0] < 1000 || data[0] >= 9999 )
  505. return FALSE;
  506. SysTime.wYear = data[0];
  508. /********月(1--12)********/
  509. if ( data[1] < 1 || data[1] > 12 )
  510. return FALSE;
  511. SysTime.wMonth = data[1];
  513. /********日(1--31)********/
  514. if ( data[2] < 1 && data[2] > 31 )
  515. return FALSE;
  516. SysTime.wDay = data[2];
  518. return TRUE;
  519. }
  521. BOOL CopyBuffer_Time ( int *data, SYSTEMTIME &SysTime )
  522. {
  523. const int nMinDateDigitCount = 3;
  524. ASSERT_ADDRESS ( data, nMinDateDigitCount * sizeof(int) );
  526. /********时(0--23)********/
  527. if ( data[0] <0 || data[0] > 23 )
  528. return FALSE;
  529. SysTime.wHour = data[0];
  531. /********分(0--59)********/
  532. if ( data[1] < 0 || data[1] > 59 )
  533. return FALSE;
  534. SysTime.wMinute = data[1];
  536. /********秒********/
  537. if ( data[2] < 0 || data[2] > 59 )
  538. return FALSE;
  539. SysTime.wSecond = data[2];
  541. return TRUE;
  542. }
  544. //
  545. // ConvertStrToCTime() 将一个表示日期的字符串（按年、月、日、时、分、秒的顺序，
  546. // 如"2001-08-09 18:03:30"）转成 CTime 格式.
  547. // return : ------------------------------------------------------------
  548. // 0 - 错误
  549. // 1 - 是时期时间
  550. // 2 - 是日期
  551. // 3 - 是时间
  552. //
  553. int ConvertStrToCTime(char *chtime, CTime &cTime )
  554. {
  555. int  i, j, k;
  556. char tmpbuf[8] = {0};
  557. int  value[6] = {0};
  558. SYSTEMTIME SysTime = {0};
  560. if ((!chtime) ) return FALSE; /* invalid parameter */
  562. memset((void *)value, 0, sizeof(value));
  563. for (i=0, j=0, k=0;  ; i++)
  564. {
  565. if (chtime[i]<'0' || chtime[i]>'9') /* 非数字字符 */
  566. {
  567. tmpbuf[j] = '';
  568. if ( j > 0 )
  569. {
  570. value[k++] = atoi(tmpbuf);
  571. j = 0;
  572. if ( k >= 6 ) break;
  573. }
  574. if ( chtime[i] == '' ) break;
  575. }
  576. else if (j < 7) tmpbuf[j++] = chtime[i];
  577. }
  578. if ( k < 3 ) return 0;
  579. if (
  580. CalcCharCount ( chtime, '-' ) < 2
  581. &&
  582. CalcCharCount ( chtime, '/' ) < 2
  583. &&
  584. CalcCharCount ( chtime, ':' ) < 2
  585. )
  586. return 0;
  588. int nRet = 0;
  589. // 是日期时间
  590. if (
  591. ( k>=6 )
  592. &&
  593. CopyBuffer_Date ( value, SysTime )
  594. &&
  595. CopyBuffer_Time ( &value[3], SysTime )
  596. )
  597. {
  598. nRet = 1;
  599. }
  600. // 是日期
  601. else if (
  602. (k>=3)
  603. &&
  604. CopyBuffer_Date ( value, SysTime )
  605. )
  606. {
  607. nRet = 2;
  608. }
  610. // 是时间
  611. if (
  612. (k>=3)
  613. &&
  614. CopyBuffer_Time ( value, SysTime )
  615. )
  616. {
  617. nRet = 3;
  618. }
  620. if ( SysTime.wYear < 1971 )
  621. SysTime.wYear = 1971;
  622. if ( SysTime.wMonth < 1 )
  623. SysTime.wMonth = 1;
  624. if ( SysTime.wDay < 1 )
  625. SysTime.wDay = 1;
  627. CTime tTemp ( SysTime );
  628. cTime = tTemp;
  630. return nRet;
  631. }
  633. void Log ( UINT nLevel, LPCTSTR lpszFormat, ... )
  634. {
  635. // 格式化
  636. char szLogBuf[1024] = {0};
  637. va_list  va;
  638. va_start (va, lpszFormat);
  639. _vsnprintf ( szLogBuf, sizeof(szLogBuf)-1, (const char*)lpszFormat, va);
  640. va_end(va);
  641. UINT nType = MB_ICONWARNING;
  642. nLevel &= 0x0f;
  643. if ( nLevel == L_VERBOSE || nLevel == L_NORMAL )
  644. nType = MB_ICONINFORMATION;
  645. else if ( nLevel == L_ERROR )
  646. nType = MB_ICONERROR;
  648. AfxMessageBox ( szLogBuf, nType );
  649. }
  650. /********************************************************************************
  651. * Function Type : public
  652. * Parameter : buf - 输出缓冲
  653. * Return Value : 字符个数
  654. * Description : 获取当前时间的字符串,如：2003-10-01 12:00:00
  655. *********************************************************************************/
  656. DWORD GetCurTimeString ( char *buf, time_t tNow/*=0*/ )
  657. {
  658. ASSERT_ADDRESS ( buf, DATETIME_TYPE_LENGTH );
  659. if ( tNow == 0 ) tNow = time(NULL);
  660. CTime cTime ( tNow );
  661. CString csNow = cTime.Format ( "%Y-%m-%d %H:%M:%S" );
  662. return (DWORD)hwSnprintf ( buf, DATETIME_TYPE_LENGTH, "%s", csNow );
  663. }
  665. CCriticalSection f_CSFor_DbgLog;
  666. void DbgLog ( LPCTSTR lpszFormat, ... )
  667. {
  668. // 格式化
  669. f_CSFor_DbgLog.Lock ();
  670. char szLogBuf[1024*4] = {0};
  671. char *p = szLogBuf;
  672. *p = '[';
  673. p ++;
  674. char szTime[32] = {0};
  675. int nLen = (int)GetCurTimeString ( szTime, sizeof(szTime) );
  676. strcpy ( p, szTime );
  677. p += nLen;
  678. *p = ']';
  679. p ++;
  680. *p = ' ';
  681. p ++;
  683. va_list  va;
  684. va_start (va, lpszFormat);
  685. _vsnprintf ( p, sizeof(szLogBuf)-1-(int)(p-szLogBuf), (const char*)lpszFormat, va);
  686. va_end(va);
  687. WriteDataToFile ( "c:\debug.txt", szLogBuf, strlen(szLogBuf), "ab+" );
  688. f_CSFor_DbgLog.Unlock ();
  689. }
  691. int GetMouthByShortStr ( LPCTSTR lpszShortMonth )
  692. {
  693. const char* szConstMonth[] =
  694. {
  695. "jan", "feb", "mar", "apr", "may", "jun", "jul", "aug", "sep", "oct", "nov", "dec", ""
  696. };
  698. CString csShortMonth = GET_SAFE_STRING ( lpszShortMonth );
  699. for ( int i=0; i<sizeof(szConstMonth)/sizeof(szConstMonth[0]); i++ )
  700. {
  701. if ( csShortMonth.CompareNoCase ( szConstMonth[i] ) == 0 )
  702. {
  703. return ( i+1 );
  704. }
  705. }
  707. return -1;
  708. };
  710. CString hwFormatMessage ( DWORD dwErrorCode )
  711. {
  712. CString csError;
  713. LPVOID pv;
  714.     FormatMessage (
  715. FORMAT_MESSAGE_ALLOCATE_BUFFER | FORMAT_MESSAGE_FROM_SYSTEM,
  716. NULL,
  717. dwErrorCode,
  718. MAKELANGID(LANG_NEUTRAL,SUBLANG_DEFAULT),
  719. (LPTSTR)&pv,
  720. 0,
  721. NULL);
  722. if(pv)
  723. {
  724. csError = (char*)pv;
  725. LocalFree ( pv );
  726. }
  728. return csError;
  729. }
  731. /********************************************************************************
  732. * Function Type : Global
  733. * Parameter : filename - 文件名
  734. * data - 要保存的数据
  735. * mode - 文件打开的模式
  736. * size - 数据大小
  737. * nStartPos - 文件开始位置
  738. * Return Value : >=0 - 写入文件的大小
  739. * -1 - 写操作失败
  740. * Description : 保存数据到文件
  741. *********************************************************************************/
  742. int WriteDataToFile(LPCTSTR filename,char* data,long size,LPCTSTR mode, int nStartPos/*=-1*/ )
  743. {
  744. ASSERT ( filename && strlen(filename) > 0 );
  745. FILE *fp;
  746. long retval;
  747. fp=fopen((const char*)filename,(const char*)mode);
  748. if ( fp!=NULL)
  749. {
  750. if ( nStartPos >= 0 )
  751. {
  752. if ( fseek ( fp, nStartPos, SEEK_SET ) != 0 )
  753. return -1;
  754. }
  755. retval = (long)fwrite(data,sizeof(UCHAR),size,fp);
  756. fclose(fp);
  757. if(retval != size)
  758. {
  759. return -1;
  760. }
  761. else  return retval;
  762. }
  763. else
  764. {
  765. return -1;
  766. }
  767. }
  768. /********************************************************************************
  769. * Function Type : Global
  770. * Parameter : filename - 文件名
  771. * data - 读到的数据存于此缓冲
  772. * size - 缓冲大小
  773. * nStartPos - 文件开始位置
  774. * Return Value : >=0 - 读到数据的大小
  775. * -1 - 操作失败
  776. * Description : 从文件中读取数据
  777. *********************************************************************************/
  778. int ReadDataFromFile(LPCTSTR filename,char* data,long size, int nStartPos/*=-1*/)
  779. {
  780. FILE *fp;
  781. long retval;
  782. fp=fopen((const char*)filename,"rb");
  783. if ( fp!=NULL)
  784. {
  785. if ( nStartPos >= 0 )
  786. {
  787. if ( fseek ( fp, nStartPos, SEEK_SET ) != 0 )
  788. return -1;
  789. }
  790. retval = (long)fread(data,sizeof(char), size, fp);
  791. fclose(fp);
  792. if ( retval >= 0 ) return retval;
  793. }
  794. return -1;
  795. }
  797. CString Data2HexString ( int nOffset, char *data, int size )
  798. {
  799. CString csHexString, csTemp, csOffset;
  800. if ( nOffset >= 0 )
  801. {
  802. csOffset.Format ( "%08xh: ", nOffset );
  803. csHexString += csOffset;
  804. }
  805. for ( int i=0; i<size; i++ )
  806. {
  807. csTemp.Format ( "%02X ", (BYTE)data[i] );
  808. csHexString += csTemp;
  809. if ( (i+1) % 16 == 0 )
  810. {
  811. csHexString += "rn";
  812. if ( nOffset >= 0 )
  813. {
  814. nOffset += 16;
  815. csOffset.Format ( "%08xh: ", nOffset );
  816. csHexString += csOffset;
  817. }
  818. }
  819. }
  820. return csHexString;
  821. }
  823. //
  824. // 为了方便 strchr() 或 strrchr() 函数正确查找字符，将字符串中的中文字符串用指定的字符替换掉
  825. //
  826. void ReplaceChineseStrToEnglish ( char *szBuf, char cReplace )
  827. {
  828. if ( !szBuf ) return;
  829. for ( int i=0; szBuf[i] != ''; i++ )
  830. {
  831. if ( szBuf[i] < 0 && szBuf[i+1] != '' )
  832. {
  833. szBuf[i] = cReplace;
  834. szBuf[i+1] = cReplace;
  835. i ++;
  836. }
  837. }
  838. }
  840. /********************************************************************************
  841. * Function Type : Global
  842. * Parameter : lpszDirName - [in] 目录名
  843. * Return Value : 没有路径的文件名
  844. * Description : 确保路径存在，如果目录不存在就创建目录,可以创建多层次的目录
  845. *********************************************************************************/
  846. char* MakeSureDirectory(LPCTSTR lpszDirName)
  847. {
  848. char tempbuf[255];
  849. char *p1 = NULL, *p2 = (char*)lpszDirName;
  850. int len;
  851. while(1)
  852. {
  853. p1 = hwStrChr((const char*)p2,'\');
  854. if( p1 )
  855. {
  856. ZeroMemory(tempbuf,sizeof(tempbuf));
  857. len = (int)((p1 - lpszDirName > sizeof(tempbuf)) ? sizeof(tempbuf) : (p1 - lpszDirName));
  858. if(len < 1) //如：“123456”目录，第一个就是“”
  859. {
  860. p2 = p1 + 1;
  861. continue;
  862. }
  863. strncpy((char*)tempbuf,(const char*)lpszDirName, len);
  864. if(_access((const char*)tempbuf,0) == -1) //Not exist
  865. {
  866. if(_mkdir((const char*)tempbuf) != 0)
  867. return FALSE;
  868. }
  869. p2 = p1 + 1;
  870. }
  871. else break;
  872. }
  874. return p2;
  875. }
  877. int hwSnprintf ( char *buffer, int count, const char *format, ... )
  878. {
  879. if ( count < 1 ) return 0;
  880. ASSERT_ADDRESS ( buffer, count );
  881. memset ( buffer, 0, count );
  882. // 格式化
  883. va_list  va;
  884. va_start (va, format);
  885. int nRet = _vsnprintf ( buffer, count, (const char*)format, va);
  886. va_end(va);
  887. buffer [count-1] = '';
  889. int nLen = nRet;
  890. if ( nLen < 0 ) nLen = strlen(buffer);
  891. if ( nLen > count ) nLen = count;
  893. return nLen;
  894. }
  896. //
  897. //
  898. // 从一个完整的全路径名(包含文件名)中分离出路径（没有文件名）和
  899. // 文件名，如：从“E:0102.exe”中分得“E:01”，结果存入到
  900. // lsOnlyPath中，“002.exe”存入szOnlyFileName中
  901. //
  902. BOOL PartFileAndPathByFullPath (
  903. IN LPCTSTR lpszFilePath, // 全路径名(包含文件名)
  904. OUT char *szOnlyFileName, // 光文件名（没有路径）
  905. int nFileNameSize,
  906. OUT char *szOnlyPath /*=NULL*/, // 光路径（没有文件名）
  907. int nPathSize/*=0*/
  908. )
  909. {
  910. ASSERT ( lpszFilePath );
  911. char chDirPart = '\';
  912. if ( hwStrChr ( lpszFilePath, '/' ) )
  913. chDirPart = '/';
  915. if ( szOnlyFileName )
  916. {
  917. memset ( szOnlyFileName, 0, nFileNameSize );
  918. }
  919. if ( szOnlyPath )
  920. {
  921. memset ( szOnlyPath, 0, nPathSize );
  922. }
  924. WIN32_FILE_ATTRIBUTE_DATA FileAttrData;
  925. if ( GetFileAttributesEx ( lpszFilePath, GetFileExInfoStandard, (LPVOID)&FileAttrData ) &&
  926. ( FileAttrData.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY ) == FILE_ATTRIBUTE_DIRECTORY
  927. && FileAttrData.dwFileAttributes != 0xffffffff ) // 本身就是目录
  928. {
  929. if ( szOnlyPath )
  930. {
  931. STRNCPY ( szOnlyPath, lpszFilePath, nPathSize );
  932. StandardizationPathBuffer ( szOnlyPath, nPathSize, chDirPart );
  933. }
  934. return TRUE;
  935. }
  937. char *p = hwStrrChr ( lpszFilePath, chDirPart );
  938. if ( !p )
  939. {
  940. STRNCPY ( szOnlyFileName, lpszFilePath, nFileNameSize );
  941. return TRUE;
  942. }
  944. if ( szOnlyFileName )
  945. STRNCPY ( szOnlyFileName, p+1, nFileNameSize );
  946. if ( szOnlyPath )
  947. {
  948. STRNCPY ( szOnlyPath, lpszFilePath, nPathSize );
  949. int nLen = p-lpszFilePath+1;
  950. if ( nPathSize-1 < nLen ) return FALSE;
  951. szOnlyPath [ nLen ] = '';
  952. }
  953. return TRUE;
  954. }
  956. BOOL PartPathAndFileAndExtensionName (
  957. IN LPCTSTR lpszFilePath, // 全路径名(包含文件名)
  958. OUT CString *pcsOnlyPath, // 输出光路径（没有文件名）
  959. OUT CString *pcsOnlyFileName, // 输出光文件名（没有路径）
  960. OUT CString *pcsExtensionName // 输出扩展名
  961. )
  962. {
  963. char szOnlyPath[MAX_PATH] = {0};
  964. char szOnlyFileName[MAX_PATH] = {0};
  965. char szExtensionName[MAX_PATH] = {0};
  966. if ( !PartFileAndPathByFullPath ( lpszFilePath, szOnlyFileName, MAX_PATH, szOnlyPath, MAX_PATH ) )
  967. return FALSE;
  968. if ( !PartFileAndExtensionName ( szOnlyFileName, szOnlyFileName, MAX_PATH, szExtensionName, MAX_PATH ) )
  969. return FALSE;
  971. if ( pcsOnlyPath ) *pcsOnlyPath = szOnlyPath;
  972. if ( pcsOnlyFileName ) *pcsOnlyFileName = szOnlyFileName;
  973. if ( pcsExtensionName ) *pcsExtensionName = szExtensionName;
  975. return TRUE;
  976. }
  978. char *hwStrrChr ( const char *string, int c )
  979. {
  980. if ( !string ) return NULL;
  981. CString csString = string;
  982. ReplaceChineseStrToEnglish ( csString.GetBuffer(0), (c>=127) ? (c-1) : (c+1) );
  983. csString.ReleaseBuffer ();
  984. int nPos = csString.ReverseFind ( c );
  985. if ( nPos < 0 ) return NULL;
  986. return ( (char*)string + nPos );
  987. }
  989. char *hwStrChr ( const char *string, int c )
  990. {
  991. if ( !string ) return NULL;
  992. CString csString = string;
  993. ReplaceChineseStrToEnglish ( csString.GetBuffer(0), (c>=127) ? (c-1) : (c+1) );
  994. csString.ReleaseBuffer ();
  995. int nPos = csString.Find ( c );
  996. if ( nPos < 0 ) return NULL;
  997. return ( (char*)string + nPos );
  998. }
  1000. //
  1001. // 根据文件名来找它的文件名和扩展名，如：完整路径为“E:123456.bmp”，那么 szFileName 等于“E:123456”
  1002. // szExtensionName 等于“bmp”
  1003. //
  1004. BOOL PartFileAndExtensionName (
  1005. IN LPCTSTR lpszFileName,
  1006. OUT char *szFileName,
  1007. IN int nFileNameSize,
  1008. OUT char *szExtensionName/*=NULL*/,
  1009. IN int nExtensionNameSize/*=0*/ )
  1010. {
  1011. ASSERT ( lpszFileName );
  1012. char chDirPart = '\';
  1013. if ( hwStrChr ( lpszFileName, '/' ) )
  1014. chDirPart = '/';
  1016. if ( szFileName )
  1017. {
  1018. STRNCPY ( szFileName, lpszFileName, nFileNameSize );
  1019. }
  1020. if ( szExtensionName )
  1021. {
  1022. memset ( szExtensionName, 0, nExtensionNameSize );
  1023. }
  1025. char *p_Dot = hwStrrChr ( lpszFileName, '.' );
  1026. if ( !p_Dot )
  1027. {
  1028. return TRUE;
  1029. }
  1030. char *p_Slash = hwStrrChr ( lpszFileName, chDirPart );
  1031. if ( szFileName )
  1032. {
  1033. if ( p_Dot-lpszFileName >= nFileNameSize )
  1034. return FALSE;
  1035. // TRACE ( "%d, %dn", p_Dot-lpszFileName, strlen(lpszFileName) );
  1036. if ( int(p_Dot-lpszFileName) < (int)strlen(lpszFileName)-1 )
  1037. szFileName [p_Dot-lpszFileName] = '';
  1038. }
  1039. if ( p_Slash > p_Dot )
  1040. {
  1041. return TRUE;
  1042. }
  1044. if ( szExtensionName )
  1045. {
  1046. STRNCPY ( szExtensionName, p_Dot+1, nExtensionNameSize );
  1047. }
  1048. return TRUE;
  1049. }
  1051. //
  1052. // 删除一个文件夹，不管里面有没有文件，都会被删除
  1053. //
  1054. BOOL hwDeleteFolder ( LPCTSTR lpszFolder )
  1055. {
  1056. BOOL bRet = FALSE;
  1057. CHwDir dir ( lpszFolder, TRUE, TRUE );
  1058. if ( !dir.m_pStrAryResFile || !dir.m_pStrArySubDirectory )
  1059. return FALSE;
  1060. for ( int i=0; i<dir.m_pStrAryResFile->GetSize(); i++ )
  1061. {
  1062. CString csFileName = dir.m_pStrAryResFile->GetAt ( i );
  1063. bRet = ::SetFileAttributes ( csFileName, FILE_ATTRIBUTE_NORMAL );
  1064. bRet = ::DeleteFile ( csFileName );
  1065. if ( !bRet )
  1066. {
  1067. DWORD dwLastError = ::GetLastError ();
  1068. }
  1069. }
  1071. for ( i=dir.m_pStrArySubDirectory->GetSize()-1; i>=0; i-- )
  1072. {
  1073. CString csDirName = dir.m_pStrArySubDirectory->GetAt ( i );
  1074. TRACE ( "Delete dir : %sn", csDirName );
  1075. bRet = ::SetFileAttributes ( csDirName, FILE_ATTRIBUTE_NORMAL );
  1076. bRet = RemoveDirectory ( csDirName );
  1077. }
  1079. return RemoveDirectory ( lpszFolder );
  1080. }
  1082. //
  1083. // 将一个文件追加拷贝到另一个文件末尾
  1084. //
  1085. BOOL CopyFileAppend ( LPCTSTR lpszFileName_Src, LPCTSTR lpszFileName_Dst, int nOffset )
  1086. {
  1087. if ( !lpszFileName_Src || !lpszFileName_Dst ) return FALSE;
  1088. CFileStatus fileStatus;
  1089. if ( !CFile::GetStatus(lpszFileName_Src,fileStatus) || fileStatus.m_size < 1 )
  1090. {
  1091. return TRUE;
  1092. }
  1094. const int nBufSize = 1024*1024;
  1095. char *pTempBuf = new char[nBufSize];
  1096. if ( !pTempBuf ) return FALSE;
  1097. BOOL bRet = FALSE;
  1098. CFile file_Src, file_Dst;
  1099. TRY
  1100. {
  1101. if ( file_Src.Open ( lpszFileName_Src, CFile::modeRead|CFile::typeBinary ) &&
  1102. file_Dst.Open ( lpszFileName_Dst, CFile::modeCreate|CFile::modeNoTruncate|CFile::modeWrite|CFile::typeBinary ) )
  1103. {
  1104. if ( nOffset >= 0 )
  1105. {
  1106. file_Dst.Seek ( nOffset, CFile::begin );
  1107. }
  1108. else
  1109. {
  1110. file_Dst.SeekToEnd ();
  1111. }
  1112. int nReadSize = 0;
  1113. while ( (nReadSize = file_Src.ReadHuge ( pTempBuf, nBufSize )) > 0 )
  1114. {
  1115. file_Dst.WriteHuge ( pTempBuf, nReadSize );
  1116. }
  1117. bRet = TRUE;
  1118. }
  1119. }
  1120. CATCH( CFileException, e )
  1121. {
  1122. e->Delete ();
  1123. bRet = FALSE;
  1124. }
  1125. END_CATCH
  1127. if ( pTempBuf ) delete[] pTempBuf;
  1128. if ( HANDLE_IS_VALID(file_Src.m_hFile) )
  1129. file_Src.Close ();
  1130. if ( HANDLE_IS_VALID(file_Dst.m_hFile) )
  1131. file_Dst.Close ();
  1133. return bRet;
  1135. }
  1137. //
  1138. // 创建一个空文件
  1139. //
  1140. BOOL CreateNullFile ( LPCTSTR lpszFileName, int nFileSize )
  1141. {
  1142. if ( !lpszFileName ) return FALSE;
  1143. DeleteFile ( lpszFileName );
  1144. CFile file;
  1145. BOOL bRet = TRUE;
  1146. TRY
  1147. {
  1148. bRet = file.Open ( lpszFileName, CFile::modeCreate|CFile::modeWrite|CFile::typeBinary );
  1149. if ( bRet && nFileSize > 0 )
  1150. file.SetLength ( nFileSize );
  1151. }
  1152. CATCH( CFileException, e )
  1153. {
  1154. e->Delete ();
  1155. bRet = FALSE;
  1156. }
  1157. END_CATCH
  1158. if ( !bRet )
  1159. {
  1160. Log ( L_WARNING, "Create file [%s] failed. %s", lpszFileName, hwFormatMessage ( GetLastError() ) );
  1161. }
  1162. if ( HANDLE_IS_VALID(file.m_hFile) )
  1163. file.Close ();
  1165. return bRet;
  1166. }
  1168. //
  1169. // 等待线程退出
  1170. //
  1171. BOOL WaitForThreadEnd ( HANDLE hThread, DWORD dwWaitTime /*=5000*/ )
  1172. {
  1173. BOOL bRet = TRUE;
  1174. if ( !HANDLE_IS_VALID(hThread) ) return TRUE;
  1175. if ( ::WaitForSingleObject ( hThread, dwWaitTime ) == WAIT_TIMEOUT )
  1176. {
  1177. bRet = FALSE;
  1178. ::TerminateThread ( hThread, 0 );
  1179. }
  1180. return bRet;
  1181. }
  1183. /********************************************************************************
  1184. * Function Type : Global
  1185. * Parameter : lpszPathName - [out] 选择的路径名
  1186. * Return Value : 路径字符数
  1187. * Description : 从通用对话框中选择路径
  1188. * Note : 缓冲lpszPathName申请时建议大小为“MAX_PATH”
  1189. *********************************************************************************/
  1190. DWORD SelectPathByCommonDlg(LPSTR lpszPathName,HWND hwndOwner/*=NULL*/)
  1191. {
  1192. ASSERT_ADDRESS ( lpszPathName, MAX_PATH );
  1193. DWORD dwLength = 0;
  1194. LPMALLOC pMalloc; //利用shell的扩展功能
  1195. BROWSEINFO bi;
  1196. if ( !SUCCEEDED(SHGetMalloc(&pMalloc)) ) //为生成目录选择对话框分配内存
  1197. return 0;
  1198. ZeroMemory( (char*)&bi, sizeof(bi) );
  1199. LPITEMIDLIST pidl;
  1200. bi.hwndOwner = hwndOwner;
  1201. bi.pidlRoot = NULL;
  1202. bi.pszDisplayName = (LPSTR)lpszPathName;
  1203. bi.lpszTitle = _T("Select Directory");
  1204. bi.ulFlags = BIF_RETURNFSANCESTORS | BIF_RETURNONLYFSDIRS;
  1205. bi.lpfn = NULL;
  1206. bi.lParam = 0;
  1207. if ( (pidl = ::SHBrowseForFolder(&bi)) != NULL)//调用选择目录对话框
  1208. {
  1209. // 获得所选择的目录
  1210. if ( ::SHGetPathFromIDList(pidl, (LPSTR)lpszPathName) )
  1211. {
  1212. dwLength = (DWORD)strlen((const char*)lpszPathName);
  1213. if(lpszPathName[dwLength-1] != '\')
  1214. {
  1215. strcat((char*)lpszPathName,"\");
  1216. dwLength ++;
  1217. }
  1218. }
  1219. pMalloc->Free(pidl);//释放分配的资源
  1220. }
  1221. pMalloc->Release();
  1222. return dwLength;
  1223. }
  1225. BOOL SelectPathByCommonDlg ( CWnd *pDlg, UINT nEditID )
  1226. {
  1227. if ( !pDlg || nEditID < 1 ) return FALSE;
  1228. char szPath[MAX_PATH] = {0};
  1229. if ( SelectPathByCommonDlg ( szPath, pDlg->GetSafeHwnd() ) > 0 )
  1230. {
  1231. pDlg->SetDlgItemText ( nEditID, szPath );
  1232. return TRUE;
  1233. }
  1234. return FALSE;
  1235. }
  1237. //
  1238. // 标准化路径缓冲，如果不是以“”结尾，将自动加上
  1239. //
  1240. void StandardizationPathBuffer ( char *szPath, int nSize, char cFlagChar/*='\'*/ )
  1241. {
  1242. int nLen = strlen(szPath);
  1243. if ( nLen < 1 ) return;
  1244. ASSERT_ADDRESS ( szPath, nLen+1 );
  1245. char szTemp[4] = {0};
  1246. szTemp[0] = cFlagChar;
  1247. if ( szPath[nLen-1] != cFlagChar )
  1248. strncat ( szPath, szTemp, nSize );
  1250. CString csPath = StandardizationFileForPathName ( szPath, FALSE );
  1251. strncpy ( szPath, csPath, nSize );
  1252. }
  1254. //
  1255. // 标准化路径或文件名，把不符合文件名命名规则的字符替换成指定的字符。//u 在 StandardizationPathBuffer() 中
  1256. // 加上该函数
  1257. //
  1258. CString StandardizationFileForPathName ( LPCTSTR lpszFileOrPathName, BOOL bIsFileName, char cReplaceChar/*='_'*/ )
  1259. {
  1260. CString csFileOrPathName = GET_SAFE_STRING(lpszFileOrPathName);
  1261. CString csHead, csTail;
  1262. // 路径名中最后一个'\'是正常的。另外类似“c:\”的字符也是正常的。所以先提取出来不参与后面的替换，等替换完以后再补回来
  1263. if ( !bIsFileName )
  1264. {
  1265. if ( csFileOrPathName.GetLength() >= 1 && (csFileOrPathName[csFileOrPathName.GetLength()-1] == '\' || csFileOrPathName[csFileOrPathName.GetLength()-1] == '/') )
  1266. {
  1267. csTail += csFileOrPathName[csFileOrPathName.GetLength()-1];
  1268. csFileOrPathName = csFileOrPathName.Left ( csFileOrPathName.GetLength()-1 );
  1269. }
  1271. if ( csFileOrPathName.GetLength() >= 2 && isalpha(csFileOrPathName[0]) && csFileOrPathName[1]==':' )
  1272. {
  1273. csHead = csFileOrPathName.Left(2);
  1274. csFileOrPathName = csFileOrPathName.Mid(2);
  1275. }
  1276. if ( csFileOrPathName.GetLength() >= 1 && (csFileOrPathName[0]=='\' || csFileOrPathName[0]=='/') )
  1277. {
  1278. csHead += csFileOrPathName[0];
  1279. csFileOrPathName = csFileOrPathName.Mid(1);
  1280. }
  1281. }
  1282. csFileOrPathName.Replace ( "\", "_" );
  1283. csFileOrPathName.Replace ( "/", "_" );
  1284. csFileOrPathName.Replace ( ":", "_" );
  1285. csFileOrPathName.Replace ( "*", "_" );
  1286. csFileOrPathName.Replace ( "?", "_" );
  1287. csFileOrPathName.Replace ( """, "_" );
  1288. csFileOrPathName.Replace ( "<", "_" );
  1289. csFileOrPathName.Replace ( ">", "_" );
  1290. csFileOrPathName.Replace ( "|", "_" );
  1291. csFileOrPathName.Insert ( 0, csHead );
  1292. csFileOrPathName += csTail;
  1294. return csFileOrPathName;
  1295. }