leftview.cpp

visual c++ 实例编程

// LeftView.cpp : implementation of the CLeftView class
//

#include "stdafx.h"
#include "DiskUtil.h"

#include "DiskUtilDoc.h"
#include "LeftView.h"
#include "General.h"
#include "MainFrm.h"
#include <winsock2.h>

#ifdef _DEBUG
#define new DEBUG_NEW
#undef THIS_FILE
static char THIS_FILE[] = __FILE__;
#endif

extern DWORD BytesToFill, NumFloppiesNet, NumHardsNet, Int13ExtNet;
extern void DisplayPartTable(WORD Drive, WORD Cylinder, WORD Head, WORD Sector, WORD NumSectors, DRIVEPACKET *DrivePacket, DWORD, BOOL);
extern void DisplayBootRecord(WORD Drive, WORD Cylinder, WORD Head, WORD Sector, WORD NumSectors, DRIVEPACKET *DrivePacket, DWORD, BOOL);
extern void DisplayFAT16(DRIVEPACKET *DrivePacket);
extern void DisplayFAT12(DRIVEPACKET *DrivePacket);
extern void DisplayFAT32(DRIVEPACKET *DrivePacket);
extern void DisplayRootDir(DRIVEPACKET *DrivePacket);
extern void EnumTreeRoot(void);
extern WORD FormLongFileName(DIRECTORY *Directory, char *LfnBuff);
extern BOOL LoadSectors(DRIVEPACKET *DrivePacket, CYLHEADSECT *CylHeadSect, LPBYTE pBuffer);
extern DWORD CountFatEntries(DWORD StartCluster, WORD FatType, LPBYTE pBuffer);
extern void StoreFatEntries(DWORD StartCluster, WORD FatType, LPDWORD FatEntries, DWORD NumFatEntries, LPBYTE pBuffer);
extern BOOL ReadDirBuffer(LPDWORD, DRIVEPACKET *, DWORD, LPBYTE);
extern void DisplayFilesFolders(DRIVEPACKET *DrivePacket);
extern void DisplayFile(DRIVEPACKET *DrivePacket);
extern int gCurrentIndex;
extern BOOL CheckCopyProt(void);
extern HANDLE hDisk[];
extern bool ItsFile;
extern HTREEITEM hPrevHD;
extern SOCKET SocketNum;
extern BOOL BufferRead;

extern LPBYTE BufferNet;
extern DWORD BytesToFill;
extern DWORD NetEvent;

extern SECTOR_FUNC NetCall;
extern void CallNet();
CTreeCtrl	*DiskTree;
DWORD PrevRelSector=0, MainPrevRelSector = 0;
HANDLE      hVxD;
DWORD       cbBytesReturned;
DWORD       dwErrorCode;
DWORD       RetInfo[1];
DWORD       ErrorCode;
DWORD			NumFloppies;
TV_INSERTSTRUCT TvIns;
TV_ITEM TvI;
char TmpStr[MAX_PATH];
DLLFUNC	*DllThunk32, *DllThunk32Write;
DLLCHECK *DllCheckInt13Extension;
HMODULE hLib;
DRIVEPACKET *DrivePacket, ParentDrivePacket;
DRIVEPACKET *Packets;
HLOCAL hMemDrivePacket, hMemPackets, hMemBufferDir;
HTREEITEM hPrev;
LPBYTE Buffer, BufferDir;
HLOCAL hMemBuffer=0;
extern CYLHEADSECT CylHeadSect;
extern HLOCAL hMemFilePacket;
extern BOOL gbNextSector, gbPrevSector;
BOOL Refreshing=FALSE, gOSWin95;
extern HMENU Menu;
extern BOOL MenuThere;
extern CStatusBarCtrl  *m_wndStatusBarCtrl;
extern DRIVEPACKET gDrivePacket;

/////////////////////////////////////////////////////////////////////////////
// CLeftView

IMPLEMENT_DYNCREATE(CLeftView, CTreeView)

BEGIN_MESSAGE_MAP(CLeftView, CTreeView)
	//{{AFX_MSG_MAP(CLeftView)
	ON_NOTIFY_REFLECT(TVN_SELCHANGED, OnSelchanged)
	ON_NOTIFY_REFLECT(TVN_ITEMEXPANDING, OnItemexpanding)
	ON_NOTIFY_REFLECT(TVN_GETDISPINFO, OnGetdispinfo)
	//}}AFX_MSG_MAP
END_MESSAGE_MAP()

/////////////////////////////////////////////////////////////////////////////
// CLeftView construction/destruction

CLeftView::CLeftView()
{
	// TODO: add construction code here

}

CLeftView::~CLeftView()
{
}

BOOL CLeftView::PreCreateWindow(CREATESTRUCT& cs)
{
	// TODO: Modify the Window class or styles here by modifying
	//  the CREATESTRUCT cs
	cs.style |= TVS_HASBUTTONS | TVS_LINESATROOT | TVS_HASLINES | TVS_SHOWSELALWAYS | TVS_DISABLEDRAGDROP |
                                  WS_VISIBLE | WS_CHILD | WS_BORDER;
	return CTreeView::PreCreateWindow(cs);
}

/////////////////////////////////////////////////////////////////////////////
// CLeftView drawing

void CLeftView::OnDraw(CDC* pDC)
{
	CDiskUtilDoc* pDoc = GetDocument();
	ASSERT_VALID(pDoc);

	// TODO: add draw code for native data here
}

#define DISK_DETECT 1
#define HARDDISK_DETECT 2

void CLeftView::OnInitialUpdate()
{
	char TmpStr1[1000];
	CTreeView::OnInitialUpdate();

	// TODO: You may populate your TreeView with items by directly accessing
	//  its tree control through a call to GetTreeCtrl().
	hMemDrivePacket = LocalAlloc(LMEM_MOVEABLE|LMEM_DISCARDABLE|LMEM_ZEROINIT, 100*sizeof(DRIVEPACKET));
	if(hMemDrivePacket == NULL){
		AfxMessageBox("Drive Packet memory not enough");
		return;
	}
	hMemPackets = LocalAlloc(LMEM_MOVEABLE|LMEM_DISCARDABLE|LMEM_ZEROINIT, 1024*1024*2);
	if(hMemPackets == NULL){
		AfxMessageBox("Packets memory not enough");
		LocalFree(hMemDrivePacket);
		return;
	}
	CTreeCtrl &Ctr=GetTreeCtrl();
	DiskTree = &Ctr;
	
	gOSWin95 = ((int) GetVersion() < 0);
	if(gOSWin95){
		hLib = LoadLibrary("Disk32.DLL");
		int ab = GetLastError();
		if(hLib == NULL){
			AfxMessageBox("Disk32.DLL not found");
			return;
		}
		DllThunk32 = (DLLFUNC *) GetProcAddress(hLib, "ReadDisk32");
		if(DllThunk32 == NULL){
			AfxMessageBox("ReadDisk32 Function not accessible!");
			return;
		}
		DllThunk32Write = (DLLFUNC *) GetProcAddress(hLib, "WriteDisk32");
		if(DllThunk32Write == NULL){
			AfxMessageBox("WriteDisk32 Function not accessible!");
			return;
		}
		DllCheckInt13Extension = (DLLCHECK *) GetProcAddress(hLib, "CheckInt13Extension32");
		if(DllCheckInt13Extension == NULL){
			AfxMessageBox("DllCheckInt13Extension Function not accessible!");
			return;
		}
		hVxD = CreateFile("\\\\.\\DISK.VXD", 0,0,0,
			CREATE_NEW, FILE_FLAG_DELETE_ON_CLOSE, 0);
		
		if ( hVxD == INVALID_HANDLE_VALUE )
		{
				AfxMessageBox("Unable to open DISK.VXD");
				MenuThere = TRUE;
				NumFloppies = 0;
				EnumTreeRoot();
				return;
			dwErrorCode = GetLastError();
			if ( dwErrorCode == ERROR_NOT_SUPPORTED ){
				AfxMessageBox("Unable to open DISK.VXD.\nDevice does not support DeviceIOCTL\n");
				return;
			}
			else{
				AfxMessageBox("Unable to open DISK.VXD");
			}
			return;
		}
		else
		{
			DeviceIoControl(hVxD, DISK_DETECT,
				(LPVOID)NULL, 0,
				(LPVOID)RetInfo, sizeof(RetInfo),
				&cbBytesReturned, NULL);
			NumFloppies = RetInfo[0];
			MenuThere = TRUE;
			CloseHandle(hVxD);
			EnumTreeRoot();
		}
	}
	else{
		char TmpStr[]="A:\\";
		NumFloppies = 0;
		for(int i=0; i<26; i++){
			TmpStr[0] = 'A'+i;
			if(GetDriveType(TmpStr)==DRIVE_REMOVABLE)
				NumFloppies++;
		}
		MenuThere = TRUE;
		EnumTreeRoot();
	}
}

/////////////////////////////////////////////////////////////////////////////
// CLeftView diagnostics

#ifdef _DEBUG
void CLeftView::AssertValid() const
{
	CTreeView::AssertValid();
}

void CLeftView::Dump(CDumpContext& dc) const
{
	CTreeView::Dump(dc);
}

CDiskUtilDoc* CLeftView::GetDocument() // non-debug version is inline
{
	ASSERT(m_pDocument->IsKindOf(RUNTIME_CLASS(CDiskUtilDoc)));
	return (CDiskUtilDoc*)m_pDocument;
}
#endif //_DEBUG

/////////////////////////////////////////////////////////////////////////////
// CLeftView message handlers

void CLeftView::OnSelchanged(NMHDR* pNMHDR, LRESULT* pResult) 
{
	NM_TREEVIEW* pNMTreeView = (NM_TREEVIEW*)pNMHDR;
	// TODO: Add your control notification handler code here
	*pResult = 0;
	ItsFile = false;
	if(Refreshing)
		return;
	m_wndStatusBarCtrl->SetText("", 0, 0);
	gCurrentIndex = 0;
	DRIVEPACKET *DrivePacket=(DRIVEPACKET *)pNMTreeView->itemNew.lParam;
	if(DrivePacket->Net && (DrivePacket->Type == NET))
		return;
	memcpy(&gDrivePacket, DrivePacket, sizeof(DRIVEPACKET));
	memcpy(&ParentDrivePacket, DrivePacket, sizeof(DRIVEPACKET));
	DRIVEPACKET TmpDrivePacket;
	memcpy(&TmpDrivePacket, DrivePacket, sizeof(DRIVEPACKET));

	if(DrivePacket->NumSectors){
		if(hMemBuffer){
			LocalUnlock(hMemBuffer);
			LocalFree(hMemBuffer);
		}
		hMemBuffer = LocalAlloc(LMEM_MOVEABLE|LMEM_DISCARDABLE|LMEM_ZEROINIT, DrivePacket->NumSectors * 512);
		if(hMemBuffer == NULL){
			AfxMessageBox("Fatal Error!  Not able to allocate a buffer of memory!");
			return;
		}
		Buffer = (LPBYTE) LocalLock(hMemBuffer);
	}
	gbNextSector = gbPrevSector = FALSE;
	switch(DrivePacket->Type){
		case EXTENDED_PART:
		case PART_TABLE:
			DisplayPartTable(DrivePacket->Drive, DrivePacket->Cylinder, DrivePacket->Head, DrivePacket->Sector, DrivePacket->NumSectors, DrivePacket, DrivePacket->NTRelativeSector, DrivePacket->Flag);
			break;
		case UNKNOWN:
		case BOOT_RECORD:
			DisplayBootRecord(DrivePacket->Drive, DrivePacket->Cylinder, DrivePacket->Head, DrivePacket->Sector, DrivePacket->NumSectors, DrivePacket, DrivePacket->NTRelativeSector, DrivePacket->Flag);
			break;
		case FAT32:
			DisplayFAT32(DrivePacket);
			break;
		case FAT16:
			DisplayFAT16(DrivePacket);
			break;
		case FAT12:
			DisplayFAT12(DrivePacket);
			break;
		case ROOT_DIR:
			if(hMemFilePacket){
				LocalUnlock(hMemFilePacket);
				LocalFree(hMemFilePacket);
			}
			DisplayRootDir(DrivePacket);
			break;
		case FILES_FOLDERS:
			if(hMemBuffer){
				LocalUnlock(hMemBuffer);
				LocalFree(hMemBuffer);
			}
			hMemBuffer = LocalAlloc(LMEM_MOVEABLE|LMEM_DISCARDABLE|LMEM_ZEROINIT, DrivePacket->NumFatSectors * 512);
			if(hMemBuffer == NULL){
				AfxMessageBox("Fatal Error!  Not able to allocate a buffer!");
				return;
			}
			Buffer = (LPBYTE) LocalLock(hMemBuffer);
			if(hMemFilePacket){
				LocalUnlock(hMemFilePacket);
				LocalFree(hMemFilePacket);
			}
			if(DrivePacket->Attributes & ATTR_SUBDIR)
				DisplayFilesFolders(DrivePacket);
			else
				DisplayFile(DrivePacket);
			break;
	}
	m_wndStatusBarCtrl->SetText("", 0, 0);
}

void CLeftView::OnItemexpanding(NMHDR* pNMHDR, LRESULT* pResult) 
{
	PARTITION *PartitionTable;
	BOOL UnknownPart=FALSE;
	int i;