ShellFileOp.cpp
上传用户:tjfeida
上传日期:2013-03-10
资源大小:1917k
文件大小:8k
源码类别:

Ftp客户端

开发平台:

Visual C++

  1. // ShellFileOp.cpp: implementation of the CShellFileOp class.
  2. //
  3. // Tim Johnson timj@progsoc.uts.edu.au
  4. // Written : July 1998
  5. //
  6. // Copyright 1998
  7. //
  8. //////////////////////////////////////////////////////////////////////
  9. #include "stdafx.h"
  10. #include "ShellFileOp.h"
  11. #ifdef _DEBUG
  12. #undef THIS_FILE
  13. static char THIS_FILE[]=__FILE__;
  14. #define new DEBUG_NEW
  15. #endif
  16. //////////////////////////////////////////////////////////////////////
  17. // Construction/Destruction
  18. //////////////////////////////////////////////////////////////////////
  19. //
  20. // CShellFileOp ()
  21. //
  22. // Basic constructor
  23. //
  24. CShellFileOp::CShellFileOp()
  25. {
  26. m_lMaxSrcCount = 0;
  27. m_lMaxDestCount = 0;
  28. m_lCurSrcCount = 0;
  29. m_lCurDestCount = 0;
  30. m_pSrc = NULL;
  31. m_pDest = NULL;
  32. m_pTo = NULL;
  33. m_pFrom = NULL;
  34. m_pTitle = NULL;
  35. m_FileOp.hwnd = NULL; 
  36.     m_FileOp.wFunc = 0; 
  37.     m_FileOp.pFrom = NULL; 
  38.     m_FileOp.pTo = NULL; 
  39.     m_FileOp.fFlags = 0; 
  40.     m_FileOp.fAnyOperationsAborted = FALSE; 
  41.     m_FileOp.hNameMappings = NULL; 
  42.     m_FileOp.lpszProgressTitle = NULL; 
  43. }
  44. //
  45. // CShellFileOp
  46. //
  47. // Complex constructor - performs the operation straight away
  48. //
  49. CShellFileOp::CShellFileOp( const HWND phWnd, 
  50.    const UINT wFunc,
  51.    const CString sFrom,
  52.    const CString sTo,
  53.    const FILEOP_FLAGS fFlags,
  54.    const CString sProgressTitle)
  55. {
  56. m_lMaxSrcCount = 0;
  57. m_lMaxDestCount = 0;
  58. m_lCurSrcCount = 0;
  59. m_lCurDestCount = 0;
  60. m_pSrc = NULL;
  61. m_pDest = NULL;
  62. m_pTo = NULL;
  63. m_pFrom = NULL;
  64. m_pTitle = NULL;
  65. m_FileOp.hwnd = NULL; 
  66.     m_FileOp.wFunc = 0; 
  67.     m_FileOp.pFrom = NULL; 
  68.     m_FileOp.pTo = NULL; 
  69.     m_FileOp.fFlags = 0; 
  70.     m_FileOp.fAnyOperationsAborted = FALSE; 
  71.     m_FileOp.hNameMappings = NULL; 
  72.     m_FileOp.lpszProgressTitle = NULL; 
  73. SetParent(phWnd);
  74. AddFile(SH_SRC_FILE, sFrom);
  75. AddFile(SH_DEST_FILE, sTo);
  76. SetFlags(fFlags);
  77. SetTitle(sProgressTitle);
  78. switch (wFunc)
  79. {
  80. case FO_COPY:
  81. CopyFiles();
  82. break;
  83. case FO_DELETE:
  84. DeleteFiles();
  85. break;
  86. case FO_MOVE:
  87. MoveFiles();
  88. break;
  89. case FO_RENAME:
  90. RenameFiles();
  91. break;
  92. default:
  93. break;
  94. }
  95. }
  96. //
  97. // ~CShellFileOp()
  98. //
  99. // deconstructor - kill all memory before object destruction
  100. //
  101. CShellFileOp::~CShellFileOp()
  102. {
  103. //free all malloc'd blocks
  104.     if (m_pTo) 
  105. free ((void *)m_pTo );
  106.     if (m_pFrom) 
  107. free ((void *)m_pFrom);
  108.     if (m_pTitle) 
  109. free ((void *)m_pTitle);
  110. }
  111. //
  112. // long CopyFiles ( )
  113. //
  114. // Function to perform copy operation
  115. //
  116. long CShellFileOp::CopyFiles()
  117. {
  118. m_FileOp.fAnyOperationsAborted = FALSE; 
  119. m_FileOp.wFunc = FO_COPY;
  120. return SHFileOperation(&m_FileOp);
  121. }
  122. //
  123. // long DeleteFiles ( )
  124. //
  125. // Function to perform delete operation
  126. //
  127. long CShellFileOp::DeleteFiles()
  128. {
  129. m_FileOp.fAnyOperationsAborted = FALSE; 
  130. m_FileOp.wFunc = FO_DELETE;
  131. return SHFileOperation(&m_FileOp);
  132. }
  133. //
  134. // long MoveFiles ( )
  135. //
  136. // Function to perform move operation
  137. //
  138. long CShellFileOp::MoveFiles()
  139. {
  140. m_FileOp.fAnyOperationsAborted = FALSE; 
  141. m_FileOp.wFunc = FO_MOVE;
  142. return SHFileOperation(&m_FileOp);
  143. }
  144. //
  145. // long RenameFiles ( )
  146. //
  147. // Function to perform rename operation
  148. //
  149. long CShellFileOp::RenameFiles()
  150. {
  151. m_FileOp.fAnyOperationsAborted = FALSE; 
  152. m_FileOp.wFunc = FO_RENAME;
  153. return SHFileOperation(&m_FileOp);
  154. }
  155. //
  156. // void ClearFiles ( const int iSrcDest )
  157. //
  158. // Clears a list of files
  159. //
  160. void CShellFileOp::ClearFiles(const int iSrcDest)
  161. {
  162. if (iSrcDest == SH_SRC_FILE)
  163. {
  164. if (m_pFrom) 
  165. {
  166. free ((void *)m_pFrom);
  167. m_pFrom = NULL;
  168. m_FileOp.pFrom = m_pFrom;
  169. m_lMaxSrcCount = 0;
  170. m_lCurSrcCount = 0;
  171. }
  172. }
  173. else
  174. {
  175. if (m_pTo) 
  176. {
  177. free ((void *)m_pTo );
  178. m_pTo = NULL;
  179. m_FileOp.pTo = m_pTo;
  180. m_lMaxDestCount = 0;
  181. m_lCurDestCount = 0;
  182. }
  183. }
  184. }
  185. //
  186. // void AddFile ( const int iSrcDest, CString sFile )
  187. //
  188. // Adds another filename to the end of the current string
  189. //
  190. void CShellFileOp::AddFile(const int iSrcDest, const CString sFile)
  191. {
  192. int iLength = sFile.GetLength() + 1; //+1 for the null
  193. if (iSrcDest == SH_SRC_FILE)
  194. {
  195. //check enough allocated space...
  196. if ((m_lCurSrcCount + iLength + 1)> m_lMaxSrcCount) //+1 for the double null termination...
  197. {
  198. //have to get more mem.
  199. GrabMem(iSrcDest, (m_lCurSrcCount + iLength + 1));
  200. }
  201. //now theres enough memory!  yay.
  202. //now copy the filename in
  203. strcpy(m_pSrc, (LPCTSTR)sFile);
  204. //go to end of this files null term.
  205. m_pSrc += iLength;
  206. m_lCurSrcCount += iLength;
  207. //always keep it double null terminated, but don't
  208. // increment past it incase we want to add more files
  209. m_pSrc[0] = 0;
  210. }
  211. else
  212. {
  213. //check enough allocated space...
  214. if ((m_lCurDestCount + iLength + 1)> m_lMaxDestCount) //+1 for the double null termination...
  215. {
  216. //have to get more mem.
  217. GrabMem(iSrcDest, (m_lCurDestCount + iLength + 1));
  218. }
  219. //now theres enough memory!  yay.
  220. //now copy the filename in
  221. strcpy(m_pDest, (LPCTSTR)sFile);
  222. //go to end of this files null term.
  223. m_pDest += iLength;
  224. m_lCurDestCount += iLength;
  225. //always keep it double null terminated, but don't
  226. // increment past it incase we want to add more files
  227. m_pDest[0] = 0;
  228. }
  229. }
  230. //
  231. // SetMaxCount( const int iSrcDest, long lMax )
  232. //
  233. // Function to pre-allocate string memory to prevent 
  234. //  lots of re-allocations
  235. //
  236. void CShellFileOp::SetMaxCount(const int iSrcDest, const long lMax)
  237. {
  238. if (iSrcDest == SH_SRC_FILE)
  239. {
  240. m_lMaxSrcCount = lMax + 1; //+1 for double null term.
  241. GrabMem(iSrcDest, m_lMaxSrcCount);
  242. } else {
  243. m_lMaxDestCount = lMax + 1; //+1 for double null term.
  244. GrabMem(iSrcDest, m_lMaxDestCount);
  245. }
  246. }
  247. //
  248. // SetTitle ( CString sTitle )
  249. //
  250. // Function to set the dialog title from a string
  251. //
  252. void CShellFileOp::SetTitle(CString sTitle)
  253. {
  254. int iLength;
  255. char * pBuf;
  256. //free mem of current title
  257. if (m_pTitle)
  258. {
  259. free ((void *)m_pTitle);
  260. m_pTitle = NULL;
  261. m_FileOp.lpszProgressTitle = NULL;
  262. }
  263. iLength = sTitle.GetLength()+1;
  264. if (iLength > 1)
  265. {
  266. //grab more mem
  267. m_pTitle = (char *)malloc(iLength);
  268. //copy the title
  269. pBuf = sTitle.GetBuffer(iLength);
  270. strcpy(m_pTitle, pBuf);
  271. //now point the struct to the title
  272. m_FileOp.lpszProgressTitle = m_pTitle;
  273. }
  274. }
  275. //
  276. // SetTitle ( const int nTitle )
  277. //
  278. // Function to set the dialog title from a resource identifier
  279. //
  280. void CShellFileOp::SetTitle( const int nTitle )
  281. {
  282. CString sTitle;
  283. sTitle.LoadString(nTitle);
  284. SetTitle(sTitle);
  285. }
  286. //
  287. // SetParent ( const HWND phWnd )
  288. //
  289. // Function to set the parent dialog
  290. //
  291. void CShellFileOp::SetParent(const HWND phWnd)
  292. {
  293. m_FileOp.hwnd = phWnd;
  294. }
  295. //
  296. // BOOL AnyOperationsAborted ( ) const
  297. //
  298. // Function to get Abort flag
  299. //
  300. BOOL CShellFileOp::AnyOperationsAborted() const
  301. {
  302. return m_FileOp.fAnyOperationsAborted;
  303. }
  304. //
  305. // FILEOP_FLAGS GetFlags() const
  306. //
  307. // Function to return the operation flags
  308. //
  309. FILEOP_FLAGS CShellFileOp::GetFlags() const
  310. {
  311. return m_FileOp.fFlags;
  312. }
  313. //
  314. // SetFlags ( const FILEOP_FLAGS fNewFlags )
  315. //
  316. // Function to set the operation flags
  317. //
  318. void CShellFileOp::SetFlags(const FILEOP_FLAGS fNewFlags)
  319. {
  320. m_FileOp.fFlags = fNewFlags;
  321. }
  322. //
  323. // GrabMem( const int iSrcDest, const long lNum )
  324. //
  325. // function to grab some string space memory
  326. //
  327. void CShellFileOp::GrabMem(const int iSrcDest, const long lNum)
  328. {
  329. char * pMem;
  330. long lOffset;
  331. //get current ptr
  332. if (iSrcDest == SH_SRC_FILE) {
  333. pMem = m_pFrom;
  334. } else {
  335. pMem = m_pTo;
  336. }
  337. if (pMem) //some mem is already allocated!
  338. {
  339. //have to make sure our offset ptrs dont get screwed up...
  340. if (iSrcDest == SH_SRC_FILE) {
  341. lOffset = (m_pSrc - pMem);
  342. } else {
  343. lOffset = (m_pDest - pMem);
  344. }
  345. //get more!
  346. pMem = (char *)realloc((void *)pMem, lNum);
  347. //reassign offset ptr, and max counts
  348. if (iSrcDest == SH_SRC_FILE) {
  349. m_pSrc = pMem + lOffset;
  350. m_lMaxSrcCount = lNum;
  351. } else {
  352. m_pDest = pMem + lOffset;
  353. m_lMaxDestCount = lNum;
  354. }
  355. }
  356. else
  357. {
  358. //get first block
  359. pMem = (char *)malloc(lNum);
  360. //assign offset ptr to start of block, and max counts
  361. if (iSrcDest == SH_SRC_FILE) {
  362. m_pSrc = pMem;
  363. m_lMaxSrcCount = lNum;
  364. } else {
  365. m_pDest = pMem;
  366. m_lMaxDestCount = lNum;
  367. }
  368. pMem[0] = 0; //ensure null terminated
  369. }
  370. //assign ptrs in sh structure.
  371. if (iSrcDest == SH_SRC_FILE) {
  372. m_pFrom = pMem;
  373. m_FileOp.pFrom = m_pFrom;
  374. } else {
  375. m_pTo = pMem;
  376. m_FileOp.pTo = m_pTo;
  377. }
  378. }