www.pudn.com > ntshell.rar > filemgr.cpp

// filemgrview.cpp: implementation of the CFileMgr class. 
// 
////////////////////////////////////////////////////////////////////// 
 
#include "stdafx.h" 
#include "resource.h" 
#include "common.h" 
 
#include "ntshell.h" 
#include "sockmgr1.h" 
#include "inputdlg.h" 
#include "filemgr.h" 
 
////////////////////////////////////////////////////////////////////// 
// Construction/Destruction 
////////////////////////////////////////////////////////////////////// 
 
CFileMgr::CFileMgr() : m_path(this, 1) 
{ 
	strcpy(szCurPath, "C:\\"); 
} 
 
CFileMgr::~CFileMgr() 
{ 
 
} 
 
LRESULT CFileMgr::OnInitDialog(UINT /*uMsg*/, WPARAM /*wParam*/, LPARAM lParam, BOOL& /*bHandled*/) 
{ 
	pwip = (PWND_INIT_PARAM)lParam; 
	connwait = false; 
	slave_sock = INVALID_SOCKET; 
	filelist = NULL; 
	SortColumn = 0; 
	ClipboardOperation = 0; 
	SizeSortOrder[0] = 0; 
	SizeSortOrder[1] = 1; 
	SizeSortOrder[2] = 2; 
	SizeSortOrder[3] = 3; 
	SizeSortOrder[4] = 4; 
	SizeSortOrder[5] = 5; 
 
	TBBUTTON tbButtons[] = { 
		{0, 0, TBSTATE_ENABLED, TBSTYLE_SEP, 0L, -1}, 
		{0, ID_FILEMGR_BACK, TBSTATE_ENABLED, TBSTYLE_BUTTON, 0L, 0}, 
		{1, ID_FILEMGR_FORWARD, TBSTATE_ENABLED, TBSTYLE_BUTTON, 0L, 0}, 
		{2, ID_FILEMGR_TOP, TBSTATE_ENABLED, TBSTYLE_BUTTON, 0L, 0}, 
		{0, 0, TBSTATE_ENABLED, TBSTYLE_SEP, 0L, -1}, 
		{3, ID_FILEMGR_RELOAD, TBSTATE_ENABLED, TBSTYLE_BUTTON, 0L, 0}, 
		{0, 0, TBSTATE_ENABLED, TBSTYLE_SEP, 0L, -1}, 
	}; 
 
	CBitmap bmp; 
	CImageList m_ImageList; 
 
	bmp.LoadBitmap(IDB_BITMAP1); 
	m_ImageList.Create(22, 22, ILC_COLOR24 | ILC_MASK, 4, 0); 
	m_ImageList.Add(bmp, RGB(192, 192, 192)); 
	bmp.DeleteObject(); 
 
	m_hToolBar.Attach(GetDlgItem(IDC_FILETOOLBAR)); 
	m_hToolBar.SetButtonStructSize(); 
	//m_hToolBar.AddBitmap(sizeof(tbButtons) / sizeof(TBBUTTON), IDB_BITMAP1); 
	m_hToolBar.SetImageList(m_ImageList); 
	m_hToolBar.AddButtons(sizeof(tbButtons) / sizeof(TBBUTTON), tbButtons); 
	m_hToolBar.SetStyle(m_hToolBar.GetStyle() | TBSTYLE_TRANSPARENT | TBSTYLE_FLAT | CCS_NODIVIDER | CCS_NORESIZE); 
 
	m_hPathList.Attach(GetDlgItem(IDC_PATHLIST)); 
	m_hPathList.ModifyStyle(0, CBS_OWNERDRAWFIXED | CBS_AUTOHSCROLL); 
	m_path.SubclassWindow(FindWindowEx(GetDlgItem(IDC_PATHLIST), NULL, "Edit", NULL)); 
 
	m_hFileList.Attach(GetDlgItem(IDC_FILELIST)); 
	m_hFileList.InsertColumn(0, "名称", LVCFMT_LEFT, 200, 0); 
	m_hFileList.InsertColumn(1, "大小", LVCFMT_LEFT, 150, 0); 
	m_hFileList.InsertColumn(2, "属性", LVCFMT_LEFT, 50, 0); 
	m_hFileList.InsertColumn(3, "修改时间", LVCFMT_LEFT, 150, 0); 
 
	SHFILEINFO sfi; 
	ITEMIDLIST *m_pidlDesk; 
	HIMAGELIST hImageList; 
 
	SHGetSpecialFolderLocation(NULL, CSIDL_DESKTOP, &m_pidlDesk); 
 
	hImageList = (HIMAGELIST)SHGetFileInfo((LPCTSTR)m_pidlDesk, 0, &sfi, sizeof(SHFILEINFO), SHGFI_PIDL | SHGFI_SYSICONINDEX | SHGFI_ICON); 
	hImageList = m_hFileList.SetImageList(hImageList, LVSIL_NORMAL); 
	ImageList_Destroy(hImageList); 
 
	hImageList = (HIMAGELIST)SHGetFileInfo((LPCTSTR)m_pidlDesk, 0, &sfi, sizeof(SHFILEINFO), SHGFI_PIDL | SHGFI_SYSICONINDEX | SHGFI_SMALLICON); 
	hImageList = m_hFileList.SetImageList(hImageList, LVSIL_SMALL); 
	ImageList_Destroy(hImageList); 
 
	RECT rect; 
	REBARBANDINFO rbbi; 
 
	m_hToolBar.GetWindowRect(&rect); 
	rbbi.cbSize = sizeof(REBARBANDINFO); 
	rbbi.fMask = RBBIM_CHILD | RBBIM_CHILDSIZE | RBBIM_STYLE | RBBS_BREAK; 
	rbbi.fStyle = RBBS_NOVERT | RBBS_CHILDEDGE; 
	rbbi.hwndChild = m_hToolBar; 
	rbbi.cxMinChild = 200; 
	rbbi.cyMinChild = rect.bottom - rect.top + 2; 
 
	m_ReBar.Attach(GetDlgItem(IDC_FILEREBAR)); 
	m_ReBar.ModifyStyle(0, CCS_NODIVIDER | CCS_NOPARENTALIGN | RBS_VARHEIGHT | RBS_BANDBORDERS); 
	m_ReBar.InsertBand(-1, &rbbi); 
 
	m_hPathList.GetWindowRect(&rect); 
	rbbi.hwndChild = m_hPathList; 
	rbbi.cxMinChild = rect.right - rect.left; 
	rbbi.cyMinChild = 15; 
 
	m_ReBar.InsertBand(-1, &rbbi); 
 
//	DWORD dwStyle = m_hFileList.GetExtendedListViewStyle(); 
//	dwStyle |= LVS_EX_FULLROWSELECT | LVS_EX_GRIDLINES | LVS_EX_HEADERDRAGDROP; 
//	m_hFileList.SetExtendedListViewStyle(dwStyle); 
 
	::ShowWindow(GetDlgItem(IDC_GOTO), SW_HIDE); 
 
	return TRUE; 
} 
 
LRESULT CFileMgr::OnSocketRead(UINT /*uMsg*/, WPARAM /*wParam*/, LPARAM /*lParam*/, BOOL& /*bHandled*/) 
{ 
	int ret = RecvPack(); 
 
	if (ret == SOCKMGR_PENDING) 
		return 0; 
 
	if (ret == SOCKMGR_SOCK_FAILED) 
	{ 
		char *p = GetErrorString(); 
		MessageBox(p, "", MB_ICONERROR); 
		LocalFree(p); 
	} 
 
	if (ret == SOCKMGR_SUCCESS) 
	{ 
		ULONG nDataSize = GetBufferDataSize(); 
		PBYTE pData = (PBYTE)HeapAlloc(GetProcessHeap(), 0, nDataSize); 
 
		if (pData != NULL) 
		{ 
			ReadBuffer((char *)pData, nDataSize); 
			ParseDataPack(pData, nDataSize); 
			HeapFree(GetProcessHeap(), 0, pData); 
		} 
	} 
 
	return 0; 
} 
 
LRESULT CFileMgr::OnSocketWrite(UINT /*uMsg*/, WPARAM /*wParam*/, LPARAM /*lParam*/, BOOL& /*bHandled*/) 
{ 
	int ret = SendPack(); 
 
	if (ret == SOCKMGR_SOCK_FAILED) 
	{ 
		char *p = GetErrorString(); 
		MessageBox(p, "", MB_ICONERROR); 
		LocalFree(p); 
	} 
 
	return 0; 
} 
 
LRESULT CFileMgr::OnConnOk(UINT /*uMsg*/, WPARAM /*wParam*/, LPARAM /*lParam*/, BOOL& /*bHandled*/) 
{ 
	connwait = false; 
 
	return 0; 
} 
 
LRESULT CFileMgr::OnConnTimeOut(UINT /*uMsg*/, WPARAM /*wParam*/, LPARAM /*lParam*/, BOOL& /*bHandled*/) 
{ 
	connwait = false; 
	MessageBox("连接失败", "FileMgr", MB_ICONERROR); 
 
	return 0; 
} 
 
LRESULT CFileMgr::OnConnectCreated(UINT /*uMsg*/, WPARAM wParam, LPARAM /*lParam*/, BOOL& bHandled) 
{ 
	SetSocket((SOCKET)wParam); 
	NTSHELL_REQUEST req; 
	req.ClientVersion = 1; 
	req.Reserved = 0; 
	req.RequestClass = FILEMGR_LISTDRIVE; 
	WriteBuffer((char *)&req, sizeof(NTSHELL_REQUEST)); 
	FlushBuffer(); 
 
	return 0; 
} 
 
LRESULT CFileMgr::OnConnectClosed(UINT /*uMsg*/, WPARAM /*wParam*/, LPARAM /*lParam*/, BOOL& bHandled) 
{ 
	SetSocket(INVALID_SOCKET); 
 
	return 0; 
} 
 
LRESULT CFileMgr::OnSize(UINT /*uMsg*/, WPARAM /*wParam*/, LPARAM lParam, BOOL& /*bHandled*/) 
{/* 
	RECT rcRB, rcDL; 
 
	m_ReBar.SendMessage(WM_SIZE); 
	m_ReBar.GetWindowRect(&rcRB); 
	m_ReBar.MoveWindow(0, 0, LOWORD(lParam), rcRB.bottom - rcRB.top); 
 
	m_hPathList.SendMessage(WM_SIZE); 
	m_hPathList.GetWindowRect(&rcDL); 
	m_hPathList.MoveWindow(7, 7 + rcRB.bottom - rcRB.top, LOWORD(lParam) - 14, 180); 
 
	int y = rcRB.bottom - rcRB.top + rcDL.bottom - rcDL.top; 
	m_hFileList.MoveWindow(7, 14 + y, LOWORD(lParam) - 14, HIWORD(lParam) - 21 - y);//*/ 
 
	m_ReBar.MoveWindow(0, 0, LOWORD(lParam), HIWORD(lParam)); 
	int y = m_ReBar.GetBarHeight() + m_ReBar.GetBandCount(); 
	m_hFileList.MoveWindow(7, 7 + y, LOWORD(lParam) - 14, HIWORD(lParam) - 14 - y); 
 
	return TRUE; 
} 
 
LRESULT CFileMgr::OnDestroy(UINT /*uMsg*/, WPARAM /*wParam*/, LPARAM /*lParam*/, BOOL& /*bHandled*/) 
{ 
	m_hFileList.SetImageList(NULL, LVSIL_NORMAL); 
	m_hFileList.SetImageList(NULL, LVSIL_SMALL); 
	ImageList_Destroy(m_hToolBar.SetImageList(NULL)); 
	m_ReBar.Detach(); 
	m_hToolBar.Detach(); 
	m_hPathList.Detach(); 
	m_hFileList.Detach(); 
 
	if (slave_sock != INVALID_SOCKET) 
	{ 
		closesocket(slave_sock); 
		slave_sock = INVALID_SOCKET; 
	} 
 
	while (filelist != NULL) 
	{ 
		PFILE_LIST p = filelist; 
		filelist = filelist->next; 
		delete []p; 
	} 
 
	return TRUE; 
} 
 
LRESULT CFileMgr::OnToolBarTop(int /*code*/, int /*id*/, HWND /*hWnd*/, BOOL& /*bHandled*/) 
{ 
	SetCurrentPath(".."); 
 
	return 0; 
} 
 
LRESULT CFileMgr::OnToolBarReload(int /*code*/, int /*id*/, HWND /*hWnd*/, BOOL& /*bHandled*/) 
{ 
	SetCurrentPath(szCurPath); 
 
	return 0; 
} 
 
LRESULT CFileMgr::OnPathSelect(int code, int /*id*/, HWND /*hWnd*/, BOOL& /*bHandled*/) 
{ 
	char szRootPath[] = "C:\\"; 
 
	switch (code) 
	{ 
	case CBN_SELCHANGE: 
		szRootPath[0] = (char)m_hPathList.GetItemData(m_hPathList.GetCurSel()); 
		m_hPathList.SetWindowText(szRootPath); 
		SetCurrentPath(szRootPath); 
		break; 
	} 
 
	return 0; 
} 
 
LRESULT CFileMgr::OnFileSelect(int wParam, LPNMHDR pNMHDR, BOOL& /*bHandled*/) 
{ 
	NMLISTVIEW *pNMListView = (NMLISTVIEW *)pNMHDR; 
	int nItem = pNMListView->iItem; 
	char szFilePath[MAX_PATH]; 
	HMENU hMenu, hPopupMenu; 
	POINT point; 
 
	switch (pNMHDR->code) 
	{ 
	case LVN_COLUMNCLICK: 
		SortColumn = pNMListView->iSubItem; 
		SizeSortOrder[SortColumn] = ~SizeSortOrder[SortColumn]; 
		m_hFileList.SortItems(CompareFunc, (LPARAM)SizeSortOrder[SortColumn]); 
		break; 
 
	case NM_DBLCLK: 
		if (nItem >= 0 && nItem < m_hFileList.GetItemCount()) 
		{ 
			PFILE_LIST pfl = (PFILE_LIST)m_hFileList.GetItemData(nItem); 
 
			if (pfl->fileinfo.FileAttributes & FILE_ATTRIBUTE_DIRECTORY) 
			{ 
				SetCurrentPath(pfl->fileinfo.FileName); 
			} 
			else 
			{ 
				wsprintf(szFilePath, "%s\\%s", szCurPath, pfl->fileinfo.FileName); 
				SendCommand(FILEMGR_SIMPLYREADFILE, szFilePath); 
			} 
		} 
		break; 
 
	case NM_RCLICK: 
		hMenu = LoadMenu(GetModuleHandle(NULL), (LPCTSTR)IDR_SUBMENU); 
 
		if (nItem == -1) 
		{ 
			hPopupMenu = GetSubMenu(hMenu, 3); 
		} 
		else 
		{ 
			PFILE_LIST pfl = (PFILE_LIST)m_hFileList.GetItemData(nItem); 
 
			if (pfl->fileinfo.FileAttributes & FILE_ATTRIBUTE_DIRECTORY) 
			{ 
				hPopupMenu = GetSubMenu(hMenu, 4); 
			} 
			else 
			{ 
				hPopupMenu = GetSubMenu(hMenu, 2); 
 
				if (ClipboardOperation == 0) 
					EnableMenuItem(hPopupMenu, IDM_FILE_PASTE, MF_GRAYED); 
			} 
		} 
 
		GetCursorPos(&point); 
		TrackPopupMenu(hPopupMenu, TPM_LEFTALIGN, point.x, point.y, 0, m_hWnd, NULL); 
 
		DestroyMenu(hMenu); 
		break; 
	} 
 
	return 0; 
} 
 
LRESULT CFileMgr::OnComboChar(UINT /*uMsg*/, WPARAM wParam, LPARAM /*lParam*/, BOOL& bHandled) 
{ 
	TCHAR chCharCode = (TCHAR)wParam; 
 
	if (chCharCode >= 'a' && chCharCode <= 'z') 
	{ 
		bHandled = FALSE; 
		return 0; 
	} 
 
	if (chCharCode >= 'A' && chCharCode <= 'Z') 
	{ 
		bHandled = FALSE; 
		return 0; 
	} 
 
	if (chCharCode >= '0' && chCharCode <= '9') 
	{ 
		bHandled = FALSE; 
		return 0; 
	} 
 
	if (chCharCode == ':' || chCharCode == '\\') 
	{ 
		bHandled = FALSE; 
		return 0; 
	} 
 
	bHandled = TRUE; 
	CString msg; 
	msg.Format("无效路径字符'%c'", chCharCode); 
	MessageBox(msg, "错误", MB_ICONERROR); 
 
	return 0; 
} 
 
LRESULT CFileMgr::OnFileOpen(WORD /*wNotifyCode*/, WORD /*wID*/, HWND /*hWndCtl*/, BOOL& /*bHandled*/) 
{ 
	if (m_hFileList.GetSelectedCount() != 1) 
	{ 
		MessageBox("一次只能打开一个文件！", "错误", MB_ICONERROR); 
		return 0; 
	} 
 
	int nItem = m_hFileList.GetSelectedIndex(); 
 
	if (nItem == -1) 
		return 0; 
 
	PFILE_LIST pfl = (PFILE_LIST)m_hFileList.GetItemData(nItem); 
 
	if (pfl->fileinfo.FileAttributes & FILE_ATTRIBUTE_DIRECTORY) 
		return 0; 
 
	char szFilePath[MAX_PATH]; 
	sprintf(szFilePath, "%s\\%s", szCurPath, pfl->fileinfo.FileName); 
	SendCommand(FILEMGR_SIMPLYREADFILE, szFilePath); 
 
	return 0; 
} 
 
LRESULT CFileMgr::OnFileExecute(WORD /*wNotifyCode*/, WORD /*wID*/, HWND /*hWndCtl*/, BOOL& /*bHandled*/) 
{ 
	if (m_hFileList.GetSelectedCount() != 1) 
	{ 
		MessageBox("一次执行下载一个文件！", "错误", MB_ICONERROR); 
		return 0; 
	} 
 
	int nItem = m_hFileList.GetSelectedIndex(); 
 
	if (nItem == -1) 
		return 0; 
 
	PFILE_LIST pfl = (PFILE_LIST)m_hFileList.GetItemData(nItem); 
 
	if (pfl->fileinfo.FileAttributes & FILE_ATTRIBUTE_DIRECTORY) 
		return 0; 
 
	char szFilePath[MAX_PATH]; 
	sprintf(szFilePath, "%s\\%s", szCurPath, pfl->fileinfo.FileName); 
	SendCommand(FILEMGR_EXECUTEFILE, szFilePath); 
 
	return 0; 
} 
 
LRESULT CFileMgr::OnFileCut(WORD /*wNotifyCode*/, WORD /*wID*/, HWND /*hWndCtl*/, BOOL& /*bHandled*/) 
{ 
	if (GetSelectedFileName(ClipboardData, true)) 
		ClipboardOperation = 1; 
 
	return 0; 
} 
 
LRESULT CFileMgr::OnFileCopy(WORD /*wNotifyCode*/, WORD /*wID*/, HWND /*hWndCtl*/, BOOL& /*bHandled*/) 
{ 
	if (GetSelectedFileName(ClipboardData, true)) 
		ClipboardOperation = 2; 
 
	return 0; 
} 
 
LRESULT CFileMgr::OnFilePaste(WORD /*wNotifyCode*/, WORD /*wID*/, HWND /*hWndCtl*/, BOOL& /*bHandled*/) 
{ 
	FILEMGR_FILENAME2 fn; 
 
	if (ClipboardOperation == 1) 
	{ 
		if (MessageBox("确定要移动文件？", "提示", MB_ICONQUESTION | MB_YESNO) == IDNO) 
			return 0; 
	} 
 
	int b = 0, f = 0; 
 
	for (;;) 
	{ 
		f = ClipboardData.Find('|', b); 
 
		if (f == -1) 
			break; 
 
		CString newFile = szCurPath; 
		CString fileName = ClipboardData.Mid(b, f - b); 
 
		newFile += "\\"; 
		int i = fileName.ReverseFind('\\'); 
		newFile += fileName.Mid(i, fileName.GetLength() - i); 
		strcpy(fn.FileName1, fileName); 
		strcpy(fn.FileName2, newFile); 
 
		switch (ClipboardOperation) 
		{ 
		case 1: 
			SendCommandEx(FILEMGR_MOVEFILE, &fn, sizeof(FILEMGR_FILENAME2)); 
			break; 
		case 2: 
			SendCommandEx(FILEMGR_COPYFILE, &fn, sizeof(FILEMGR_FILENAME2)); 
			break; 
		} 
 
		b = f + 1; 
	} 
 
	SetCurrentPath(szCurPath); 
 
	return 0; 
} 
 
LRESULT CFileMgr::OnFileDownload(WORD /*wNotifyCode*/, WORD /*wID*/, HWND /*hWndCtl*/, BOOL& /*bHandled*/) 
{ 
	if (m_hFileList.GetSelectedCount() != 1) 
	{ 
		MessageBox("一次只能下载一个文件！", "错误", MB_ICONERROR); 
		return 0; 
	} 
 
	return 0; 
} 
 
LRESULT CFileMgr::OnFileUpload(WORD /*wNotifyCode*/, WORD /*wID*/, HWND /*hWndCtl*/, BOOL& /*bHandled*/) 
{ 
	return 0; 
} 
 
LRESULT CFileMgr::OnFileDelete(WORD /*wNotifyCode*/, WORD /*wID*/, HWND /*hWndCtl*/, BOOL& /*bHandled*/) 
{ 
	CString fileList; 
 
	if (!GetSelectedFileName(fileList, true)) 
		return 0; 
 
	if (MessageBox("确定要删除文件？", "提示", MB_ICONQUESTION | MB_YESNO) == IDNO) 
		return 0; 
 
	int b = 0, f = 0; 
 
	for (;;) 
	{ 
		f = fileList.Find('|', b); 
 
		if (f == -1) 
			break; 
 
		SendCommand(FILEMGR_DELETEFILE, fileList.Mid(b, f - b)); 
		b = f + 1; 
	} 
 
	SetCurrentPath(szCurPath); 
 
	return 0; 
} 
 
LRESULT CFileMgr::OnDirectoryCreate(WORD /*wNotifyCode*/, WORD /*wID*/, HWND /*hWndCtl*/, BOOL& /*bHandled*/) 
{ 
	CInputDlg dlg; 
	char szDirectoryName[INPUT_BUFFER_SIZE] = ""; 
 
	if (dlg.DoModal(m_hWnd, (LPARAM)szDirectoryName) == FALSE) 
		return 0; 
 
	CString path = szCurPath; 
	path += "\\"; 
	path += szDirectoryName; 
	SendCommand(FILEMGR_CREATEDIRECTORY, path); 
 
	SetCurrentPath(szCurPath); 
 
	return 0; 
} 
 
LRESULT CFileMgr::OnDirectoryRemove(WORD /*wNotifyCode*/, WORD /*wID*/, HWND /*hWndCtl*/, BOOL& /*bHandled*/) 
{ 
	if (m_hFileList.GetSelectedCount() != 1) 
	{ 
		MessageBox("一次只能删除一个目录！", "错误", MB_ICONERROR); 
		return 0; 
	} 
 
	int nItem = m_hFileList.SendMessage(LVM_GETNEXTITEM, (WPARAM)-1, MAKELPARAM(LVNI_ALL | LVNI_SELECTED, 0)); 
 
	PFILE_LIST p = (PFILE_LIST)m_hFileList.GetItemData(nItem); 
 
	if (!(p->fileinfo.FileAttributes & FILE_ATTRIBUTE_DIRECTORY)) 
		return 0; 
 
	if (MessageBox("确定要删除目录？", "提示", MB_ICONQUESTION | MB_YESNO) == IDNO) 
		return 0; 
 
	CString path = szCurPath; 
	path += "\\"; 
	path += p->fileinfo.FileName; 
	SendCommand(FILEMGR_REMOVEDIRECTORY, path); 
 
	SetCurrentPath(szCurPath); 
 
	return 0; 
} 
 
LRESULT CFileMgr::OnGoto(int /*code*/, int /*id*/, HWND /*hWnd*/, BOOL& /*bHandled*/) 
{ 
	m_hPathList.GetWindowText(szCurPath, MAX_PATH); 
	SetCurrentPath(szCurPath); 
 
	return 0; 
} 
 
int CALLBACK CFileMgr::CompareFunc(LPARAM lParam1, LPARAM lParam2, LPARAM lParamSort) 
{ 
	PFILE_LIST pfile1 = (PFILE_LIST)lParam1; 
	PFILE_LIST pfile2 = (PFILE_LIST)lParam2; 
	int nResult, nSortColumn = lParamSort < 0 ? ~lParamSort : lParamSort; 
 
	if ((pfile1->fileinfo.FileAttributes & FILE_ATTRIBUTE_DIRECTORY) != (pfile2->fileinfo.FileAttributes & FILE_ATTRIBUTE_DIRECTORY)) 
	{ 
		nResult = (pfile1->fileinfo.FileAttributes & FILE_ATTRIBUTE_DIRECTORY) - (pfile2->fileinfo.FileAttributes & FILE_ATTRIBUTE_DIRECTORY); 
		return lParamSort < 0 ? nResult : -nResult; 
	} 
 
	switch (nSortColumn) 
	{ 
	case 0: 
		nResult = stricmp(pfile1->fileinfo.FileName, pfile2->fileinfo.FileName); 
		break; 
 
	case 1: 
		if (pfile1->fileinfo.FileSizeHigh != pfile2->fileinfo.FileSizeHigh) 
		{ 
			nResult = pfile1->fileinfo.FileSizeHigh - pfile2->fileinfo.FileSizeHigh; 
			break; 
		} 
		if (pfile1->fileinfo.FileSizeLow != pfile2->fileinfo.FileSizeLow) 
		{ 
			nResult = pfile1->fileinfo.FileSizeLow - pfile2->fileinfo.FileSizeLow; 
			break; 
		} 
		nResult = stricmp(pfile1->fileinfo.FileName, pfile2->fileinfo.FileName); 
		break; 
 
	case 2: 
		if ((pfile1->fileinfo.FileAttributes & FILE_ATTRIBUTE_READONLY) != (pfile2->fileinfo.FileAttributes & FILE_ATTRIBUTE_READONLY)) 
		{ 
			nResult = (pfile1->fileinfo.FileAttributes & FILE_ATTRIBUTE_READONLY) - (pfile2->fileinfo.FileAttributes & FILE_ATTRIBUTE_READONLY); 
			break; 
		} 
		if ((pfile1->fileinfo.FileAttributes & FILE_ATTRIBUTE_HIDDEN) != (pfile2->fileinfo.FileAttributes & FILE_ATTRIBUTE_HIDDEN)) 
		{ 
			nResult = (pfile1->fileinfo.FileAttributes & FILE_ATTRIBUTE_HIDDEN) - (pfile2->fileinfo.FileAttributes & FILE_ATTRIBUTE_HIDDEN); 
			break; 
		} 
		if ((pfile1->fileinfo.FileAttributes & FILE_ATTRIBUTE_SYSTEM) != (pfile2->fileinfo.FileAttributes & FILE_ATTRIBUTE_SYSTEM)) 
		{ 
			nResult = (pfile1->fileinfo.FileAttributes & FILE_ATTRIBUTE_SYSTEM) - (pfile2->fileinfo.FileAttributes & FILE_ATTRIBUTE_SYSTEM); 
			break; 
		} 
		if ((pfile1->fileinfo.FileAttributes & FILE_ATTRIBUTE_ARCHIVE) != (pfile2->fileinfo.FileAttributes & FILE_ATTRIBUTE_ARCHIVE)) 
		{ 
			nResult = (pfile1->fileinfo.FileAttributes & FILE_ATTRIBUTE_ARCHIVE) - (pfile2->fileinfo.FileAttributes & FILE_ATTRIBUTE_ARCHIVE); 
			break; 
		} 
		if ((pfile1->fileinfo.FileAttributes & FILE_ATTRIBUTE_ENCRYPTED) != (pfile2->fileinfo.FileAttributes & FILE_ATTRIBUTE_ENCRYPTED)) 
		{ 
			nResult = (pfile1->fileinfo.FileAttributes & FILE_ATTRIBUTE_ENCRYPTED) - (pfile2->fileinfo.FileAttributes & FILE_ATTRIBUTE_ENCRYPTED); 
			break; 
		} 
		if ((pfile1->fileinfo.FileAttributes & FILE_ATTRIBUTE_COMPRESSED) != (pfile2->fileinfo.FileAttributes & FILE_ATTRIBUTE_COMPRESSED)) 
		{ 
			nResult = (pfile1->fileinfo.FileAttributes & FILE_ATTRIBUTE_COMPRESSED) - (pfile2->fileinfo.FileAttributes & FILE_ATTRIBUTE_COMPRESSED); 
			break; 
		} 
		nResult = stricmp(pfile1->fileinfo.FileName, pfile2->fileinfo.FileName); 
		break; 
 
	case 3: 
		if (pfile1->fileinfo.LastWriteTime.dwHighDateTime != pfile2->fileinfo.LastWriteTime.dwHighDateTime) 
		{ 
			nResult = pfile1->fileinfo.LastWriteTime.dwHighDateTime - pfile2->fileinfo.LastWriteTime.dwHighDateTime; 
			break; 
		} 
		if (pfile1->fileinfo.LastWriteTime.dwLowDateTime != pfile2->fileinfo.LastWriteTime.dwLowDateTime) 
		{ 
			nResult = pfile1->fileinfo.LastWriteTime.dwLowDateTime - pfile2->fileinfo.LastWriteTime.dwLowDateTime; 
			break; 
		} 
		nResult = stricmp(pfile1->fileinfo.FileName, pfile2->fileinfo.FileName); 
		break; 
	} 
 
	return lParamSort < 0 ? -nResult : nResult; 
} 
 
void CFileMgr::ParseDataPack(LPBYTE pData, ULONG nDataSize) 
{ 
	PNTSHELL_RESULTSET rs = (PNTSHELL_RESULTSET)pData; 
	CString str; 
	PBYTE p = pData + sizeof(NTSHELL_RESULTSET); 
	ULONG l = nDataSize - sizeof(NTSHELL_RESULTSET); 
 
	if (rs->ErrorCode != ERROR_SUCCESS) 
	{ 
		LPVOID lpMsgBuf; 
 
		FormatMessage(	FORMAT_MESSAGE_ALLOCATE_BUFFER | 
						FORMAT_MESSAGE_FROM_SYSTEM | 
						FORMAT_MESSAGE_IGNORE_INSERTS, 
						NULL, 
						rs->ErrorCode, 
						0, 
						(LPTSTR)&lpMsgBuf, 
						0, 
						NULL 
						); 
 
		MessageBox((LPTSTR)lpMsgBuf, "", MB_ICONERROR); 
		LocalFree(lpMsgBuf); 
		return; 
	} 
 
	if (rs->ResultClass == FILEMGR_LISTDRIVE) 
	{ 
		int count = 0; 
		PFILEMGR_DRIVEINFO pdi; 
 
		m_hPathList.ResetContent(); 
 
		for (int i = 0; i < (int)rs->NumberOfResults; i++) 
		{ 
			pdi = ((PFILEMGR_DRIVEINFO)p) + i; 
 
			str.Format("%s (%c:)", pdi->VolumeName, pdi->RootPathName[0]); 
			m_hPathList.InsertString(i, str); 
			m_hPathList.SetItemData(i, pdi->RootPathName[0]); 
		} 
 
		char szRootPath[] = "C:\\"; 
		m_hPathList.SetCurSel(0); 
		szRootPath[0] = (char)m_hPathList.GetItemData(0); 
		m_hPathList.SetWindowText(szRootPath); 
		SetCurrentPath(szRootPath); 
	} 
	else if (rs->ResultClass == FILEMGR_LISTFILE) 
	{ 
		int count = 0; 
		PFILEMGR_FILEINFO pfi; 
 
		for (ULONG i = 0; i < l && count < (int)rs->NumberOfResults; count++) 
		{ 
			pfi = (PFILEMGR_FILEINFO)(p + i); 
 
			PFILE_LIST p = (PFILE_LIST)new BYTE[sizeof(FILE_LIST) + strlen(pfi->FileName) + 1]; 
			p->fileinfo = *pfi; 
			strcpy(p->fileinfo.FileName, pfi->FileName); 
			p->next = filelist; 
			filelist = p; 
 
			char *pExtName = strrchr(p->fileinfo.FileName, '.'); 
			int nImage = GetIconIndex(pExtName, TRUE, p->fileinfo.FileAttributes); 
			m_hFileList.InsertItem(LVIF_TEXT | LVIF_IMAGE | LVIF_PARAM, count, pfi->FileName, 0, 0, nImage, (LPARAM)p); 
 
			if (!(pfi->FileAttributes & FILE_ATTRIBUTE_DIRECTORY)) 
			{ 
				char buf[20]; 
				ULONG fsh = pfi->FileSizeHigh >> 10; 
				ULONG fsl = (pfi->FileSizeLow >> 10) | (pfi->FileSizeHigh << 22); 
				if (pfi->FileSizeLow % 1024) {fsl += 1; if (fsl == 0) fsh += 1;} 
				NumGrouping(buf, fsh, fsl, 14); 
				str = buf; 
				str += " KB"; 
				m_hFileList.SetItemText(count, 1, str); 
			} 
 
			str = ""; 
			if (pfi->FileAttributes & FILE_ATTRIBUTE_READONLY) 
				str += 'R'; 
			if (pfi->FileAttributes & FILE_ATTRIBUTE_HIDDEN) 
				str += 'H'; 
			if (pfi->FileAttributes & FILE_ATTRIBUTE_SYSTEM) 
				str += 'S'; 
			if (pfi->FileAttributes & FILE_ATTRIBUTE_ARCHIVE) 
				str += 'A'; 
			if (pfi->FileAttributes & FILE_ATTRIBUTE_ENCRYPTED) 
				str += 'E'; 
			if (pfi->FileAttributes & FILE_ATTRIBUTE_COMPRESSED) 
				str += 'C'; 
			m_hFileList.SetItemText(count, 2, str); 
 
			SYSTEMTIME stime; 
			FILETIME ftime; 
			FileTimeToLocalFileTime(&pfi->LastWriteTime, &ftime); 
			FileTimeToSystemTime(&ftime, &stime); 
			str.Format("%d-%02d-%02d %02d:%02d", stime.wYear, stime.wMonth, stime.wDay, stime.wHour, stime.wMinute); 
			m_hFileList.SetItemText(count, 3, str); 
			i += sizeof(FILEMGR_FILEINFO) + strlen(pfi->FileName) + 1; 
		} 
 
		m_hFileList.SortItems(CompareFunc, (LPARAM)SizeSortOrder[SortColumn]); 
	} 
	else if (rs->ResultClass == FILEMGR_SIMPLYREADFILE) 
	{ 
		PFILEMGR_FILEREAD pfr = (PFILEMGR_FILEREAD)p; 
		char szTempFile[MAX_PATH]; 
 
		GetTempPath(MAX_PATH, szTempFile); 
		strcat(szTempFile, pfr->FileName); 
 
		HANDLE hFile = CreateFile(szTempFile, GENERIC_WRITE, 0, NULL, CREATE_ALWAYS, 0, NULL); 
 
		if (hFile != INVALID_HANDLE_VALUE) 
		{ 
			for (ULONG i = 0; i < pfr->FileSize;) 
			{ 
				ULONG nWriteBytes; 
				if (!WriteFile(hFile, pfr->FileData + i, pfr->FileSize - i, &nWriteBytes, NULL)) 
					break; 
				i += nWriteBytes; 
			} 
 
			CloseHandle(hFile); 
 
//			STARTUPINFO si = {0}; 
//			PROCESS_INFORMATION pi; 
 
//			si.cb			= sizeof(STARTUPINFO); 
//			si.lpDesktop	= "WinSta0\\Default"; 
//			si.dwY			= 1; 
//			si.dwXSize		= 100; 
//			si.dwYSize		= 100; 
//			si.wShowWindow	= SW_SHOWNORMAL; 
 
//			if (!CreateProcess(szTempFile, pfr->cFileName, NULL, NULL, TRUE, 0, NULL, NULL, &si, &pi)) 
//			{ 
				if (!ShellExecute(NULL, "open", szTempFile, NULL, NULL, SW_SHOWNORMAL)) 
					MessageBox("文件已传送完成，但无法打开"); 
//			} 
//			else 
//			{ 
//				CloseHandle(pi.hProcess); 
//				CloseHandle(pi.hThread); 
//			} 
		} 
	} 
} 
 
void CFileMgr::NumGrouping(char *buf, unsigned int hival, unsigned int loval, int width) 
{ 
	unsigned int c, d, i, temp; 
	char *p; 
 
	p = buf + width; 
	*p = '\0'; 
	goto mod; 
	do 
	{ 
		if (i++ == 2) 
		{ 
			*--p = ','; 
mod: 
			i = 0; 
		} 
 
		if (hival) 
		{ 
			c = hival % 10; 
			hival /= 10; 
			c = (c << 16) + (loval >> 16); 
			d = c / 10; 
			c %= 10; 
			c = (c << 16) + (loval & 0xffff); 
			temp = c % 10; 
			loval = (d << 16) + c / 10; 
		} 
		else 
		{ 
			temp = (unsigned int)loval % 10; 
			loval /= 10; 
		} 
		*--p = temp + '0'; 
	} while (loval || hival); 
 
	while (p > buf) 
		*--p = ' '; 
} 
 
void CFileMgr::CleanupFileList() 
{ 
	m_hFileList.DeleteAllItems(); 
 
	while (filelist != NULL) 
	{ 
		PFILE_LIST p = filelist; 
		filelist = filelist->next; 
		delete []p; 
	} 
} 
 
int CFileMgr::GetIconIndex(const char *lpExtName, BOOL bSmallIcon, DWORD dwFileAttributes) 
{ 
	SHFILEINFO shfi; 
	int nImage; 
 
	DWORD dwFlags = SHGFI_USEFILEATTRIBUTES | SHGFI_ICON | SHGFI_SYSICONINDEX | SHGFI_USEFILEATTRIBUTES; 
	dwFlags |= bSmallIcon ? SHGFI_SMALLICON : SHGFI_LARGEICON; 
 
	nImage = SHGetFileInfo(lpExtName, dwFileAttributes, &shfi, sizeof(SHFILEINFO), dwFlags); 
 
	return shfi.iIcon; 
} 
 
void CFileMgr::SetCurrentPath(const char *lpPath) 
{ 
	char szFilePath[280]; 
 
	if (lpPath[1] == ':') 
	{ 
		strcpy(szCurPath, lpPath); 
	} 
	else if (lpPath[0] == '.' && lpPath[1] == '.') 
	{ 
		char *p = strrchr(szCurPath, '\\'); 
 
		if (p - szCurPath > 3) 
			p[0] = '\0'; 
		else 
			p[1] = '\0'; 
	} 
	else 
	{ 
		if (strlen(szCurPath) > 3) 
			strcat(szCurPath, "\\"); 
		strcat(szCurPath, lpPath); 
	} 
 
	CleanupFileList(); 
 
	strcpy(szFilePath, szCurPath); 
 
	if (szCurPath[strlen(szCurPath) - 1] == '\\') 
		strcat(szFilePath, "*.*"); 
	else 
		strcat(szFilePath, "\\*.*"); 
 
	SendCommand(FILEMGR_LISTFILE, szFilePath); 
	m_hPathList.SetWindowText(szCurPath); 
} 
 
int CFileMgr::SendCommand(DWORD dwCommand, const char *lpPath) 
{ 
	NTSHELL_REQUEST req; 
 
	req.ClientVersion = 1; 
	req.Reserved = 0; 
	req.RequestClass = (WORD)dwCommand; 
	req.Reserved2 = 0; 
 
	WriteBuffer((char *)&req, sizeof(NTSHELL_REQUEST)); 
	WriteBuffer(lpPath, strlen(lpPath) + 1); 
 
	FlushBuffer(); 
 
	int ret = SendPack(); 
 
	if (ret == SOCKMGR_SOCK_FAILED) 
		MessageBox("连接不可用", "错误", MB_ICONERROR); 
 
	return ret; 
} 
 
int CFileMgr::SendCommandEx(DWORD dwCommand, const void *lpData, int cbData) 
{ 
	NTSHELL_REQUEST req; 
 
	req.ClientVersion = 1; 
	req.Reserved = 0; 
	req.RequestClass = (WORD)dwCommand; 
	req.Reserved2 = 0; 
 
	WriteBuffer((char *)&req, sizeof(NTSHELL_REQUEST)); 
	WriteBuffer((char *)lpData, cbData); 
 
	FlushBuffer(); 
 
	int ret = SendPack(); 
 
	if (ret == SOCKMGR_SOCK_FAILED) 
		MessageBox("连接不可用", "错误", MB_ICONERROR); 
 
	return ret; 
} 
 
bool CFileMgr::GetSelectedFileName(CString &str, bool bIncludePath) 
{ 
	int nItem = -1; 
 
	str = ""; 
 
	for (;;) 
	{ 
		nItem = m_hFileList.SendMessage(LVM_GETNEXTITEM, (WPARAM)nItem, MAKELPARAM(LVNI_ALL | LVNI_SELECTED, 0)); 
 
		if (nItem == -1) 
			break; 
 
		PFILE_LIST p = (PFILE_LIST)m_hFileList.GetItemData(nItem); 
 
		if (p->fileinfo.FileAttributes & FILE_ATTRIBUTE_DIRECTORY) 
			continue; 
 
		if (bIncludePath) 
		{ 
			str += szCurPath; 
			str += "\\"; 
		} 
 
		str += p->fileinfo.FileName; 
		str += "|"; 
	} 
 
	return true; 
}