FileManager

最新推荐文章于 2021-08-10 11:38:56 发布

狂奔之林

最新推荐文章于 2021-08-10 11:38:56 发布

阅读量711

点赞数

分类专栏： C++

本文链接：https://blog.csdn.net/nodeman/article/details/42082029

版权

C++ 专栏收录该内容

35 篇文章 5 订阅

订阅专栏

"FileManager.h"

#include <list>

#define FILE_PATH_LEN (1024)
#define FILE_LINE_LEN (1024)

#define PARAMETER_ERROR (0)
#define ENFORCE_SUCCESSED (1)
#define ENFORCE_FAILED (2)

enum OPERATION_TYPE
{
MATCH_FILE=1,
DELITE_FILE,
DELETE_BY_EXTENSION,
DELETE_BY_PARTNAME,
FIND_FILE,
REPLACE_FILE,
INSERT_FRONT,
INSERT_BACK
};

class CFileHelperDlg;

class CFileManager
{
public:
CFileManager(char* pcMathLine, char* m_pcOperateLine);
~CFileManager(void);

private:

char* m_pcMatchLine;
char* m_pcOperateLine;

public:

int insertFileBack(char* pcFilePath);
int insertFileFront(char* pcFilePath);
int replaceFile(char* pcFilePath);
int deleteFile(char* pcFilePath);
int findFile(char* pcFilePath, std::list<int> &pnLine);
int matchFile(char* pcFilePath, std::list<int> &pnLine);
int TraverseFolder(char* pcFilePath, int flag, CFileHelperDlg* dlg);
};

/*********************************************************************************************

#include "stdafx.h"
#include <stdio.h>
#include <stdlib.h>
#include "FileManager.h"
#include "Resource.h"
#include "FileHelperDlg.h"

using namespace std;

CFileManager::CFileManager(char* pcMathLine, char* pcOperateLine)
{
m_pcMatchLine = pcMathLine;
m_pcOperateLine = pcOperateLine;
}

CFileManager::~CFileManager(void)
{

}

int CFileManager::insertFileBack(char* pcFilePath)
{
if(0 == strcmp(pcFilePath, "") || 0 == pcFilePath)
{
return PARAMETER_ERROR;
}

FILE *pFile = 0;
CString strLine;
BOOL bIsInserted=FALSE;
CStdioFile file;
file.Open(pcFilePath, CFile::modeRead);

if(0 == file.m_pStream )
{
return PARAMETER_ERROR;
}

char *pcNewPath = (char*)malloc(FILE_PATH_LEN);
if(0 == pcNewPath)
{
return PARAMETER_ERROR;
}
memset(pcNewPath, 0, FILE_PATH_LEN);
sprintf_s(pcNewPath, FILE_PATH_LEN, "%s_new", pcFilePath);

fopen_s(&pFile, pcNewPath, "w");
if(0 == pFile)
{
free(pcNewPath);
return PARAMETER_ERROR;
}

while(file.ReadString(strLine))
{
char *pcLine = strLine.GetBuffer(0);
int nRes = strcmp(pcLine, m_pcMatchLine);

fprintf(pFile, "%s\n", pcLine);

if(0 == nRes)
{
fprintf(pFile, "%s\n", m_pcOperateLine);
bIsInserted=TRUE;
}
}

file.Close();
fclose(pFile);

//rename and delete
BOOL bRes = DeleteFile(pcFilePath);
if(bRes)
{
rename(pcNewPath, pcFilePath);
}

free(pcNewPath);

if(bIsInserted)
{
return ENFORCE_SUCCESSED;
}
else
{
return ENFORCE_FAILED;
}
}

int CFileManager::insertFileFront(char* pcFilePath)
{
if(0 == strcmp(pcFilePath, "") || 0 == pcFilePath)
{
return PARAMETER_ERROR;
}

FILE *pFile = 0;
CString strLine;
BOOL bIsInserted=FALSE;
CStdioFile file;
file.Open(pcFilePath, CFile::modeRead);

if(0 == file.m_pStream)
{
return PARAMETER_ERROR;
}

char *pcNewPath = (char*)malloc(FILE_PATH_LEN);
if(0 == pcNewPath)
{
return PARAMETER_ERROR;
}
memset(pcNewPath, 0, FILE_PATH_LEN);
sprintf_s(pcNewPath, FILE_PATH_LEN, "%s_new", pcFilePath);

fopen_s(&pFile, pcNewPath, "w");
if(0 == pFile)
{
free(pcNewPath);
return PARAMETER_ERROR;
}

while(file.ReadString(strLine))
{
char *pcLine = strLine.GetBuffer(0);
int nRes = strcmp(pcLine, m_pcMatchLine);

if(nRes == 0)
{
fprintf(pFile, "%s\n", m_pcOperateLine);
bIsInserted=TRUE;
}

fprintf(pFile, "%s\n", pcLine);
}

file.Close();
fclose(pFile);

//rename and delete
BOOL bRes = DeleteFile(pcFilePath);
if(bRes)
{
rename(pcNewPath, pcFilePath);
}

free(pcNewPath);
if(bIsInserted)
{
return ENFORCE_SUCCESSED;
}
else
{
return ENFORCE_FAILED;
}
}

int CFileManager::replaceFile(char* pcFilePath)
{
if(0 == strcmp(pcFilePath, "") || 0 == pcFilePath)
{
return PARAMETER_ERROR;
}

FILE *pFile = 0;
CString strLine;
BOOL bIsReplaceed=FALSE;
CStdioFile file;
file.Open(pcFilePath, CFile::modeRead);

if(0 == file.m_pStream )
{
return PARAMETER_ERROR;
}

char *pcNewPath = (char*)malloc(FILE_PATH_LEN);

if(0 == pcNewPath)
{
return PARAMETER_ERROR;
}

memset(pcNewPath, 0, FILE_PATH_LEN);
sprintf_s(pcNewPath, FILE_PATH_LEN, "%s_new", pcFilePath);
fopen_s(&pFile, pcNewPath, "w");

if(0 == pFile)
{
free(pcNewPath);
return PARAMETER_ERROR;
}

while(file.ReadString(strLine))
{
char *pcLine = strLine.GetBuffer(0);
int nRes = strcmp(pcLine, m_pcMatchLine);

if(0 == nRes)
{
fprintf(pFile, "%s\n", m_pcOperateLine);
bIsReplaceed=TRUE;
}
else
{
fprintf(pFile, "%s\n", pcLine);
}
}

file.Close();
fclose(pFile);

//rename and delete
BOOL bRes = DeleteFile(pcFilePath);
if(bRes)
{
rename(pcNewPath, pcFilePath);
}

free(pcNewPath);

if(bIsReplaceed)
{
return ENFORCE_SUCCESSED;
}
else
{
return ENFORCE_FAILED;
}

}

int CFileManager::deleteFile(char* pcFilePath)
{

if(0 == pcFilePath || 0 == strcmp(pcFilePath, ""))
{
return PARAMETER_ERROR;
}
FILE *pFile = 0;
CString strLine;
BOOL IsDeleted=FALSE;
CStdioFile file;
file.Open(pcFilePath, CFile::modeRead);

if(0 == file.m_pStream )
{
return PARAMETER_ERROR;
}

char *pcNewPath = (char*)malloc(FILE_PATH_LEN);
if(0 == pcNewPath)
{
return PARAMETER_ERROR;
}
memset(pcNewPath, 0, FILE_PATH_LEN);
sprintf_s(pcNewPath, FILE_PATH_LEN, "%s_new", pcFilePath);

fopen_s(&pFile, pcNewPath, "w");
if(0 == pFile)
{
free(pcNewPath);
return PARAMETER_ERROR;
}

while(file.ReadString(strLine))
{
char *pcLine = strLine.GetBuffer(0);
int nRes = strcmp(pcLine, m_pcMatchLine);

if(0 == nRes)
{
IsDeleted=TRUE;
continue;
}

fprintf(pFile, "%s\n", pcLine);
}

file.Close();
fclose(pFile);

//rename and delete
BOOL bRes = DeleteFile(pcFilePath);
if(bRes)
{
rename(pcNewPath, pcFilePath);
}

free(pcNewPath);

if(IsDeleted)
{
return ENFORCE_SUCCESSED;
}
else
{
return ENFORCE_FAILED;
}
}

int CFileManager::findFile(char* pcFilePath, list<int> &pnLine)
{
if(0 == pcFilePath || 0 == strcmp(pcFilePath, ""))
{
return PARAMETER_ERROR;
}

CString strLine=_T("");
UINT nLine = 0;
BOOL bIsMatch=FALSE;//new

CStdioFile file;
file.Open(pcFilePath, CFile::modeRead);

if(0 == file.m_pStream )
{
return PARAMETER_ERROR;
}

while(file.ReadString(strLine))
{
nLine++;
char *pcLine = strLine.GetBuffer(0);

if(strstr(pcLine, m_pcMatchLine))
{
pnLine.push_back(nLine);
bIsMatch=TRUE;
}
strLine=_T("");
}

file.Close();
if(bIsMatch)//new
{
return ENFORCE_SUCCESSED;
}
else
{
return ENFORCE_FAILED;
}

}

int CFileManager::matchFile(char* pcFilePath, list<int> &pnLine)
{
if(0 == pcFilePath || 0 == strcmp(pcFilePath, ""))
{
return PARAMETER_ERROR;
}

CString strLine;
UINT nLine = 0;
BOOL bIsMatch=FALSE;//new

CStdioFile file;
file.Open(pcFilePath, CFile::modeRead);

if( 0 ==file.m_pStream )
{
return PARAMETER_ERROR;
}

while(file.ReadString(strLine))
{
nLine++;
char *pcLine = strLine.GetBuffer(0);

if(strcmp(pcLine, m_pcMatchLine) == 0)
{
pnLine.push_back(nLine);
bIsMatch=TRUE;
}
strLine=_T("");
}
file.Close();

if(bIsMatch)//new
{
return ENFORCE_SUCCESSED;
}
else
{
return ENFORCE_FAILED;
}

}

int CFileManager::TraverseFolder(char* pcPath, int flag, CFileHelperDlg* dlg)
{
if(0 == dlg)
{
return PARAMETER_ERROR;
}

switch(flag)
{
case FIND_FILE:
case MATCH_FILE:
case DELITE_FILE:
case DELETE_BY_PARTNAME:
case DELETE_BY_EXTENSION:
if(0 == pcPath || 0 == strcmp(pcPath, "") || 0 == strcmp(m_pcMatchLine, ""))
{
return ENFORCE_FAILED;
}
break;
case INSERT_BACK:
case REPLACE_FILE:
case INSERT_FRONT:
if(0 == pcPath || 0 == strcmp(pcPath, "") || 0 == strcmp(m_pcMatchLine, "") || 0 == strcmp(m_pcOperateLine, ""))
{
return ENFORCE_FAILED;
}
break;
default:
break;
}

WIN32_FIND_DATA FindData;
HANDLE hError = 0;
int FileCount = 0;
char FilePathName[FILE_PATH_LEN] = {0};
int nExtLen = strlen(m_pcMatchLine);
// 构造路径
char FullPathName[FILE_PATH_LEN] = {0};
strcpy_s(FilePathName, pcPath);
strcat_s(FilePathName, "\\*.*");
hError = FindFirstFile(FilePathName, &FindData);
if (INVALID_HANDLE_VALUE == hError )
{
return PARAMETER_ERROR;
}

while(::FindNextFile(hError, &FindData))
{
// 过虑.和..
if (strcmp(FindData.cFileName, ".") == 0
|| strcmp(FindData.cFileName, "..") == 0 )
{ continue; }

// 构造完整路径
sprintf_s(FullPathName, "%s\\%s", pcPath, FindData.cFileName);
FileCount++;

//file operation
if (FindData.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY)
{
// 输出本级的文件
CString strDir(FullPathName);
strDir += L"******<dir>";
dlg->showInformation(strDir.GetBuffer(0));
TraverseFolder(FullPathName,flag, dlg);
}
else
{
UINT nLine = 0;
char pcLine[10] = {0};
list<int> nArrLine;
list<int>::iterator iter;
switch (flag)
{
case MATCH_FILE:
{
int nRet = matchFile(FullPathName, nArrLine);
char arrTemp[FILE_PATH_LEN] = {0};
int nCount = 0;
switch(nRet)
{
case PARAMETER_ERROR:
strcat_s(FullPathName, "---error");
break;
case ENFORCE_SUCCESSED:

for(iter = nArrLine.begin(); iter != nArrLine.end(); iter++)
{
nCount++;
if(nCount>1)
{
strcpy_s(arrTemp,"---match in line: ");
_itoa_s((int)*iter, pcLine, 10);
strcat_s(arrTemp, pcLine);

}
else
{
strcat_s(FullPathName, "---match in line: ");
_itoa_s((int)*iter, pcLine, 10);
strcat_s(FullPathName, pcLine);

}
memset(arrTemp,0,1024);
}

break;

case ENFORCE_FAILED:
strcat_s(FullPathName, "---can not match");
if(!(dlg->m_bIsDisplayed))
{
continue;
}
break;
default:
strcat_s(FullPathName, "---unknown error");
break;
}
break;
}

case FIND_FILE:
{
int nRet = findFile(FullPathName,nArrLine);

char arrTemp[FILE_PATH_LEN]={0};
int nCount=0;
switch(nRet)
{
case PARAMETER_ERROR:
strcat_s(FullPathName, "---error");
break;
case ENFORCE_SUCCESSED:
for(iter = nArrLine.begin(); iter != nArrLine.end(); iter++)
{
nCount++;
if(nCount>1)
{
strcpy_s(arrTemp,"---find in line: ");
_itoa_s(*iter, pcLine, 10);
strcat_s(arrTemp, pcLine);
}
else
{
strcat_s(FullPathName, "---find in line: ");
_itoa_s(*iter, pcLine, 10);
strcat_s(FullPathName, pcLine);
}
memset(arrTemp,0,1024);
}
break;
case ENFORCE_FAILED:
strcat_s(FullPathName, "---can not find!");
if(!(dlg->m_bIsDisplayed))
{
continue;
}
break;
default:
strcat_s(FullPathName, "---unknown error");
break;
}
break;
}

case DELITE_FILE:
{
int nRet = deleteFile(FullPathName);
switch(nRet)
{
case PARAMETER_ERROR:
strcat_s(FullPathName, "---error");
break;
case ENFORCE_SUCCESSED:
strcat_s(FullPathName, "---delete successfully!");
break;
case ENFORCE_FAILED:
strcat_s(FullPathName, "---fail,not match!");
if(!(dlg->m_bIsDisplayed))
{
continue;
}
break;
default:
strcat_s(FullPathName, "---unknown error");
break;
}
break;
}

case DELETE_BY_EXTENSION:
{
int nPathLen = strlen(FullPathName);
if(strcmp((FullPathName + nPathLen - nExtLen), m_pcMatchLine) == 0)
{
BOOL bRes = DeleteFile(FullPathName);

if(bRes)
{
strcat_s(FullPathName, "---deleted by extension!");
}

}
else
{
strcat_s(FullPathName, "---faile,not match!");
if(!(dlg->m_bIsDisplayed))
{
continue;
}
}
break;
}

case DELETE_BY_PARTNAME:
{
if(strstr(FullPathName, m_pcMatchLine))
{
BOOL bRes = DeleteFile(FullPathName);

if(bRes)
{
strcat_s(FullPathName, "---deleted by part_name!");
}
}
else
{
strcat_s(FullPathName, "---faile,not match!");
if(!(dlg->m_bIsDisplayed))
{
continue;
}
}
break;
}

case REPLACE_FILE:
{
int nRet = replaceFile(FullPathName);
switch(nRet)
{
case PARAMETER_ERROR:
strcat_s(FullPathName, "---error");
break;
case ENFORCE_SUCCESSED:
strcat_s(FullPathName, "---replace successfully!");
break;
case ENFORCE_FAILED:
strcat_s(FullPathName, "---replace failly!,not match");
if(!(dlg->m_bIsDisplayed))
{
continue;
}
break;
default:
strcat_s(FullPathName, "---unknown error");
break;
}
break;
}

case INSERT_FRONT:
{
int nRet = insertFileFront(FullPathName);
switch(nRet)
{
case PARAMETER_ERROR:
strcat_s(FullPathName, "---error");
break;
case ENFORCE_SUCCESSED:
strcat_s(FullPathName, "---insert successfully!");
break;
case ENFORCE_FAILED:
strcat_s(FullPathName, "---insert failly!");
if(!(dlg->m_bIsDisplayed))
{
continue;
}
break;
default:
strcat_s(FullPathName, "---unknow error");
break;
}
break;
}

case INSERT_BACK:
{
int nRet = insertFileBack(FullPathName);
switch(nRet)
{
case PARAMETER_ERROR:
strcat_s(FullPathName, "---error");
break;
case ENFORCE_SUCCESSED:
strcat_s(FullPathName, "---insert successfully!");
break;
case ENFORCE_FAILED:
strcat_s(FullPathName, "---insert failly!");
if(!(dlg->m_bIsDisplayed))
{
continue;
}
break;
default:
strcat_s(FullPathName, "---unknow error");
break;
}
break;
}
default:
break;
}
dlg->showInformation(FullPathName);
nArrLine.clear();
}
}
return ENFORCE_SUCCESSED;
}

// FileHelperDlg.cpp : implementation file
//

#include "stdafx.h"
#include "FileHelper.h"
#include "FileHelperDlg.h"
#include "afxdialogex.h"

#include "FileManager.h"
#ifdef _DEBUG
#define new DEBUG_NEW
#endif

// CAboutDlg dialog used for App About

class CAboutDlg : public CDialogEx
{
public:
CAboutDlg();

// Dialog Data
enum { IDD = IDD_ABOUTBOX };

protected:
virtual void DoDataExchange(CDataExchange* pDX); // DDX/DDV support

// Implementation
protected:
DECLARE_MESSAGE_MAP()
};

CAboutDlg::CAboutDlg() : CDialogEx(CAboutDlg::IDD)
{
}

void CAboutDlg::DoDataExchange(CDataExchange* pDX)
{
CDialogEx::DoDataExchange(pDX);
}

BEGIN_MESSAGE_MAP(CAboutDlg, CDialogEx)
END_MESSAGE_MAP()

// CFileHelperDlg dialog

CFileHelperDlg::CFileHelperDlg(CWnd* pParent /*=NULL*/)
: CDialogEx(CFileHelperDlg::IDD, pParent)
, m_bIsDisplayed(FALSE)
{
m_hIcon = AfxGetApp()->LoadIcon(IDR_MAINFRAME);
m_strFilePath=(_T(""));
m_strOperteLine=(_T(""));
m_strMatchLine=(_T(""));

}

void CFileHelperDlg::DoDataExchange(CDataExchange* pDX)
{
CDialogEx::DoDataExchange(pDX);
DDX_Text(pDX, IDC_EDIT_MATCH, m_strMatchLine);
DDX_Text(pDX, IDC_EDIT_OPERATE, m_strOperteLine);
DDX_Text(pDX, IDC_EDIT_FILE_PATH, m_strFilePath);
DDX_Control(pDX, IDC_LIST_INFO, m_listBox);
DDX_Control(pDX, IDC_STATIC_STATE, m_state);
DDX_Check(pDX, IDC_CHECK_DISPLAY, m_bIsDisplayed);
}

BEGIN_MESSAGE_MAP(CFileHelperDlg, CDialogEx)
ON_WM_SYSCOMMAND()
ON_WM_PAINT()
ON_WM_QUERYDRAGICON()
ON_WM_DROPFILES()
ON_BN_CLICKED(IDC_BUTTON_BROWSE, &CFileHelperDlg::OnBnClickedButtonBrowse)
ON_BN_CLICKED(IDC_BUTTON_MATCH, &CFileHelperDlg::OnBnClickedButtonMatch)
ON_BN_CLICKED(IDC_BUTTON_FIND, &CFileHelperDlg::OnBnClickedButtonFind)
ON_BN_CLICKED(IDC_BUTTON_DELETE, &CFileHelperDlg::OnBnClickedButtonDelete)
ON_BN_CLICKED(IDC_BUTTON_REPLACE, &CFileHelperDlg::OnBnClickedButtonReplace)
ON_BN_CLICKED(IDC_BUTTON_DELETE_BY_FILENAME, &CFileHelperDlg::OnBnClickedButtonDeleteFileByName)
ON_BN_CLICKED(IDC_BUTTON_DELETE_BY_EXT, &CFileHelperDlg::OnBnClickedButtonDeleteFileByExtension)
ON_BN_CLICKED(IDC_BUTTON_INSERT_IN_FRONT, &CFileHelperDlg::OnBnClickedButtonInsertInFront)
ON_BN_CLICKED(IDC_BUTTON_INSERT_IN_BACK, &CFileHelperDlg::OnBnClickedButtonInsertInBack)
ON_WM_CTLCOLOR()
ON_BN_CLICKED(IDC_CHECK_DISPLAY, &CFileHelperDlg::OnBnClickedCheckDisplay)
END_MESSAGE_MAP()

// CFileHelperDlg message handlers

BOOL CFileHelperDlg::OnInitDialog()
{
CDialogEx::OnInitDialog();

// Add "About..." menu item to system menu.

// IDM_ABOUTBOX must be in the system command range.
ASSERT((IDM_ABOUTBOX & 0xFFF0) == IDM_ABOUTBOX);
ASSERT(IDM_ABOUTBOX < 0xF000);

CMenu* pSysMenu = GetSystemMenu(FALSE);
if (pSysMenu != NULL)
{
BOOL bNameValid;
CString strAboutMenu;
bNameValid = strAboutMenu.LoadString(IDS_ABOUTBOX);
ASSERT(bNameValid);
if (!strAboutMenu.IsEmpty())
{
pSysMenu->AppendMenu(MF_SEPARATOR);
pSysMenu->AppendMenu(MF_STRING, IDM_ABOUTBOX, strAboutMenu);
}
}

// Set the icon for this dialog. The framework does this automatically
// when the application's main window is not a dialog
SetIcon(m_hIcon, TRUE); // Set big icon
SetIcon(m_hIcon, FALSE); // Set small icon

// TODO: Add extra initialization here
SendDlgItemMessage(IDC_LIST_INFO, LB_SETHORIZONTALEXTENT, 1000, 0);

return TRUE; // return TRUE unless you set the focus to a control
}

void CFileHelperDlg::OnSysCommand(UINT nID, LPARAM lParam)
{
if ((nID & 0xFFF0) == IDM_ABOUTBOX)
{
CAboutDlg dlgAbout;
dlgAbout.DoModal();
}
else
{
CDialogEx::OnSysCommand(nID, lParam);
}
}

// If you add a minimize button to your dialog, you will need the code below
// to draw the icon. For MFC applications using the document/view model,
// this is automatically done for you by the framework.

void CFileHelperDlg::OnPaint()
{
if (IsIconic())
{
CPaintDC dc(this); // device context for painting

SendMessage(WM_ICONERASEBKGND, reinterpret_cast<WPARAM>(dc.GetSafeHdc()), 0);

// Center icon in client rectangle
int cxIcon = GetSystemMetrics(SM_CXICON);
int cyIcon = GetSystemMetrics(SM_CYICON);
CRect rect;
GetClientRect(&rect);
int x = (rect.Width() - cxIcon + 1) / 2;
int y = (rect.Height() - cyIcon + 1) / 2;

// Draw the icon
dc.DrawIcon(x, y, m_hIcon);
}
else
{
CDialogEx::OnPaint();
}
}

// The system calls this function to obtain the cursor to display while the user drags
// the minimized window.
HCURSOR CFileHelperDlg::OnQueryDragIcon()
{
return static_cast<HCURSOR>(m_hIcon);
}

void CFileHelperDlg::OnDropFiles(HDROP hDropInfo)
{
// TODO: Add your message handler code here and/or call default
UINT count;
TCHAR arrfilePath[200];
count = DragQueryFile(hDropInfo, 0xFFFFFFFF, NULL, 0);
if(count)
{
for(UINT i=0;i<count;i++)
{
int pathLen=DragQueryFile(hDropInfo,i,arrfilePath,sizeof(arrfilePath));
m_strFilePath=arrfilePath;
}
}
DragFinish(hDropInfo);
UpdateData(FALSE);
CDialogEx::OnDropFiles(hDropInfo);
}

void CFileHelperDlg::OnBnClickedButtonBrowse()
{
// TODO: Add your control notification handler code here
CString fileSrc; //将选择的文件夹路径保存在此变量中
TCHAR Buffer[MAX_PATH];
BROWSEINFO bi;
ZeroMemory(&bi, sizeof(BROWSEINFO));
bi.hwndOwner = NULL;
bi.ulFlags = BIF_RETURNONLYFSDIRS; //要求返回文件系统的目录
bi.pszDisplayName = Buffer; //此参数如为NULL则不能显示对话框
bi.lpszTitle = _T("Please choose directory...");
bi.lpfn = NULL;
bi.iImage=IDR_MAINFRAME;
LPITEMIDLIST pIDList = SHBrowseForFolder(&bi);//调用显示选择对话框

if(pIDList)
{
SHGetPathFromIDList(pIDList, Buffer);
//取得文件夹路径到Buffer里
fileSrc = Buffer;//将文件夹路径保存在一个CString对象里
}

LPMALLOC lpMalloc;
if(FAILED(SHGetMalloc(&lpMalloc)))
{
return ;
}

//释放内存
lpMalloc->Free(pIDList);
lpMalloc->Release();

//show
SetDlgItemText(IDC_EDIT_FILE_PATH, fileSrc);
UpdateData();
}

void CFileHelperDlg::showInformation(CString strInfo)
{
m_listBox.AddString(strInfo);
UpdateData();
}

void CFileHelperDlg::OnBnClickedButtonMatch()
{
// TODO: Add your control notification handler code here
TraverseFolder(MATCH_FILE);
}

void CFileHelperDlg::OnBnClickedButtonFind()
{
// TODO: Add your control notification handler code here
TraverseFolder(FIND_FILE);
}

void CFileHelperDlg::OnBnClickedButtonDelete()
{
// TODO: Add your control notification handler code here
TraverseFolder(DELITE_FILE);
}

void CFileHelperDlg::OnBnClickedButtonReplace()
{
// TODO: Add your control notification handler code here
TraverseFolder(REPLACE_FILE);
}

void CFileHelperDlg::OnBnClickedButtonDeleteFileByName()
{
// TODO: Add your control notification handler code here
TraverseFolder(DELETE_BY_PARTNAME);
}

void CFileHelperDlg::OnBnClickedButtonDeleteFileByExtension()
{
// TODO: Add your control notification handler code here
TraverseFolder(DELETE_BY_EXTENSION);
}

void CFileHelperDlg::OnBnClickedButtonInsertInFront()
{
// TODO: Add your control notification handler code here
TraverseFolder(INSERT_FRONT);
}

void CFileHelperDlg::OnBnClickedButtonInsertInBack()
{
// TODO: Add your control notification handler code here
TraverseFolder(INSERT_BACK);
}

HBRUSH CFileHelperDlg::OnCtlColor(CDC* pDC, CWnd* pWnd, UINT nCtlColor)
{
HBRUSH hbr = CDialogEx::OnCtlColor(pDC, pWnd, nCtlColor);

// TODO: Change any attributes of the DC here
if(pDC->GetWindow() == GetDlgItem(IDC_LIST_INFO))
{
pDC->SetTextColor(RGB(255, 0, 0));
}
return hbr;
}

void CFileHelperDlg::OnBnClickedCheckDisplay()
{
// TODO: Add your control notification handler code here
UpdateData();
}

int CFileHelperDlg::TraverseFolder(int flag)
{
m_listBox.ResetContent();
UpdateData();
m_strOperteLine.Replace("\r", "");
CFileManager *pManager = new CFileManager(m_strMatchLine.GetBuffer(0), m_strOperteLine.GetBuffer(0));
int nRet = pManager->TraverseFolder(m_strFilePath.GetBuffer(0), flag, this);
delete pManager;

switch(nRet)
{
case ENFORCE_SUCCESSED:
m_state.SetWindowText("finished!");
break;
case ENFORCE_FAILED:
m_state.SetWindowText("path can not be empty!");
break;
case PARAMETER_ERROR:
m_state.SetWindowText("failed!");
break;
default:
break;
}
return ENFORCE_SUCCESSED;
}