idediskinfoview.cpp

获取IDE硬盘详细信息的代码

// IdeDiskInfoView.cpp : implementation of the CIdeDiskInfoView class
//

#include "stdafx.h"
#include "IdeDiskInfo.h"

#include "IdeDiskInfoDoc.h"
#include "IdeDiskInfoView.h"

#include "GetIdeDiskInfo.h"

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

/////////////////////////////////////////////////////////////////////////////
// CIdeDiskInfoView

IMPLEMENT_DYNCREATE(CIdeDiskInfoView, CEditView)

BEGIN_MESSAGE_MAP(CIdeDiskInfoView, CEditView)
	//{{AFX_MSG_MAP(CIdeDiskInfoView)
	ON_COMMAND(ID_METHOD1, OnMethod1)
	ON_COMMAND(ID_METHOD2, OnMethod2)
	//}}AFX_MSG_MAP
	// Standard printing commands
	ON_COMMAND(ID_FILE_PRINT, CEditView::OnFilePrint)
	ON_COMMAND(ID_FILE_PRINT_DIRECT, CEditView::OnFilePrint)
	ON_COMMAND(ID_FILE_PRINT_PREVIEW, CEditView::OnFilePrintPreview)
END_MESSAGE_MAP()

/////////////////////////////////////////////////////////////////////////////
// CIdeDiskInfoView construction/destruction

CIdeDiskInfoView::CIdeDiskInfoView()
{
	// TODO: add construction code here
	TRACE("%d\n",sizeof(IDINFO)/2);

}

CIdeDiskInfoView::~CIdeDiskInfoView()
{
}

BOOL CIdeDiskInfoView::PreCreateWindow(CREATESTRUCT& cs)
{
	// TODO: Modify the Window class or styles here by modifying
	//  the CREATESTRUCT cs

	BOOL bPreCreated = CEditView::PreCreateWindow(cs);
	cs.style &= ~(ES_AUTOHSCROLL|WS_HSCROLL);	// Enable word-wrapping

	return bPreCreated;
}

/////////////////////////////////////////////////////////////////////////////
// CIdeDiskInfoView drawing

void CIdeDiskInfoView::OnDraw(CDC* pDC)
{
	CIdeDiskInfoDoc* pDoc = GetDocument();
	ASSERT_VALID(pDoc);
	// TODO: add draw code for native data here
}

/////////////////////////////////////////////////////////////////////////////
// CIdeDiskInfoView printing

BOOL CIdeDiskInfoView::OnPreparePrinting(CPrintInfo* pInfo)
{
	// default CEditView preparation
	return CEditView::OnPreparePrinting(pInfo);
}

void CIdeDiskInfoView::OnBeginPrinting(CDC* pDC, CPrintInfo* pInfo)
{
	// Default CEditView begin printing.
	CEditView::OnBeginPrinting(pDC, pInfo);
}

void CIdeDiskInfoView::OnEndPrinting(CDC* pDC, CPrintInfo* pInfo)
{
	// Default CEditView end printing
	CEditView::OnEndPrinting(pDC, pInfo);
}

/////////////////////////////////////////////////////////////////////////////
// CIdeDiskInfoView diagnostics

#ifdef _DEBUG
void CIdeDiskInfoView::AssertValid() const
{
	CEditView::AssertValid();
}

void CIdeDiskInfoView::Dump(CDumpContext& dc) const
{
	CEditView::Dump(dc);
}

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


CString CIdeDiskInfoView::MakeIdeInfo(int nDrive, int nType, IDINFO *pIdInfo)
{
	CString strInfo;
	CString strTmp;

	if(nType == 0)	// Use ATA/ATAPI directly
	{
		strInfo.Format("Physical drive %d ----\r\n", nDrive);
	}
	else	// Use SCSI driver instead of IDE driver
	{
		if(nType/2 == 0) strInfo = "Primary ";
		else strInfo = "Secondary ";
		
		if(nType%2 == 0) strInfo = " master drive ----\r\n";
		else strInfo += " master drive ---- \r\n";
	}

	strTmp = pIdInfo->sModelNumber;
	strInfo += "    Model number:  " + strTmp.Left(40) + "\r\n";

	strTmp = pIdInfo->sSerialNumber;
	strInfo += "    Serial number:  " + strTmp.Left(20) + "\r\n";

	strTmp = pIdInfo->sFirmwareRev;
	strInfo += "    Firmware reversion:  " + strTmp.Left(8) + "\r\n";

	if(*(WORD*)&pIdInfo->wMajorVersion != 0 && *(WORD*)&pIdInfo->wMajorVersion != 0xffff)
	{
		strTmp.Empty();

		if(pIdInfo->wMajorVersion.ATA1)
		{
			strTmp += "ATA-1";
		}

		if(pIdInfo->wMajorVersion.ATA2)
		{
			strTmp += ", ATA-2";
		}

		if(pIdInfo->wMajorVersion.ATA3)
		{
			strTmp += ", ATA-3";
		}

		if(pIdInfo->wMajorVersion.ATA4)
		{
			strTmp += ", ATA/ATAPI-4";
		}

		if(pIdInfo->wMajorVersion.ATA5)
		{
			strTmp += ", ATA/ATAPI-5";
		}

		if(pIdInfo->wMajorVersion.ATA6)
		{
			strTmp += ", ATA/ATAPI-6";
		}

		strInfo += "    ATA/ATAPI versions supported:  " + strTmp + "\r\n";
	}

	strTmp.Format("%u", pIdInfo->wBufferSize * 512);
	strInfo += "    Buffer size on drive:  " + strTmp + " bytes\r\n";

	strTmp.Format("%u", pIdInfo->wNumCyls);
	strInfo += "    Cylinders:  " + strTmp + "\r\n";

	strTmp.Format("%u", pIdInfo->wNumHeads);
	strInfo += "    Heads:  " + strTmp + "\r\n";

	strTmp.Format("%u", pIdInfo->wNumSectorsPerTrack);
	strInfo += "    Sectors per track:  " + strTmp + "\r\n";

	strTmp.Format("%u", pIdInfo->dwTotalSectors);
	strInfo += "    Total sectors:  " + strTmp + "\r\n";

	strTmp.Format("%I64d", (ULONGLONG)pIdInfo->dwTotalSectors * 512);
	strInfo += "    Total size:  " + strTmp + " bytes\r\n";

	if(pIdInfo->wFieldValidity.CHSNumber)
	{
		strTmp.Format("%u", pIdInfo->wNumCurCyls);
		strInfo += "    Addressable cylinders in CHS translation:  " + strTmp + "\r\n";

		strTmp.Format("%u", pIdInfo->wNumCurHeads);
		strInfo += "    Addressable heads in CHS translation:  " + strTmp + "\r\n";

		strTmp.Format("%u", pIdInfo->wNumCurSectorsPerTrack);
		strInfo += "    Addressable sectors per track in CHS translation:  " + strTmp + "\r\n";

		strTmp.Format("%u", pIdInfo->wCurSectorsLow + pIdInfo->wCurSectorsHigh * 65536);
		strInfo += "    Addressable sectors in CHS translation:  " + strTmp + "\r\n";

		strTmp.Format("%I64d", (ULONGLONG)(pIdInfo->wCurSectorsLow + pIdInfo->wCurSectorsHigh * 65536) * 512);
		strInfo += "    Addressable size in CHS translation:  " + strTmp + " bytes\r\n";
	}

	strTmp.Format("%d", pIdInfo->wPIOCapacity.AdvPOIModes);
	strInfo += "    Advanced PIO modes supported:  " + strTmp + "\r\n";


	strTmp = pIdInfo->wCapabilities.DMA ? "Yes" : "No";
	strInfo += "    DMA supported:  " + strTmp + "\r\n";

	strTmp = pIdInfo->wCapabilities.LBA ? "Yes" : "No";
	strInfo += "    LBA supported:  " + strTmp + "\r\n";

	strTmp = pIdInfo->wCapabilities.IORDY ? "Yes" : "No";
	strInfo += "    IORDY supported:  " + strTmp + "\r\n";

	strTmp = pIdInfo->wCapabilities.DisIORDY ? "Yes" : "No";
	strInfo += "    IORDY may be disabled:  " + strTmp + "\r\n";

	strTmp = pIdInfo->wCapabilities.Overlap ? "Yes" : "No";
	strInfo += "    Overlap operation supported:  " + strTmp + "\r\n";

	strTmp = pIdInfo->wCapabilities.Queue ? "Yes" : "No";
	strInfo += "    Command queuing supported:  " + strTmp + "\r\n";

	strTmp = pIdInfo->wCapabilities.InlDMA ? "Yes" : "No";
	strInfo += "    Interleaved DMA supported:  " + strTmp + "\r\n";

	if(pIdInfo->wFieldValidity.UnltraDMA)
	{
		strTmp = pIdInfo->wUltraDMA.Mode0 ? "Yes" : "No";
		strInfo += "    Ultra DMA mode 0 (16.7Mb/s) supported:  " + strTmp + "\r\n";

		strTmp = pIdInfo->wUltraDMA.Mode1 ? "Yes" : "No";
		strInfo += "    Ultra DMA mode 1 (25Mb/s) supported:  " + strTmp + "\r\n";

		strTmp = pIdInfo->wUltraDMA.Mode2 ? "Yes" : "No";
		strInfo += "    Ultra DMA mode 2 (33Mb/s) supported:  " + strTmp + "\r\n";

		strTmp = pIdInfo->wUltraDMA.Mode3 ? "Yes" : "No";
		strInfo += "    Ultra DMA mode 3 (44Mb/s) supported:  " + strTmp + "\r\n";

		strTmp = pIdInfo->wUltraDMA.Mode4 ? "Yes" : "No";
		strInfo += "    Ultra DMA mode 4 (66Mb/s) supported:  " + strTmp + "\r\n";

		strTmp = pIdInfo->wUltraDMA.Mode5 ? "Yes" : "No";
		strInfo += "    Ultra DMA mode 5 (100Mb/s) supported:  " + strTmp + "\r\n";

		strTmp = pIdInfo->wUltraDMA.Mode6 ? "Yes" : "No";
		strInfo += "    Ultra DMA mode 6 (133Mb/s) supported:  " + strTmp + "\r\n";

		strTmp = pIdInfo->wUltraDMA.Mode7 ? "Yes" : "No";
		strInfo += "    Ultra DMA mode 7 (166Mb/s) supported:  " + strTmp + "\r\n";

		if(pIdInfo->wUltraDMA.Mode0Sel)
		{
			strInfo += "    Ultra DMA mode currently selected:  0\r\n";
		}

		if(pIdInfo->wUltraDMA.Mode1Sel)
		{
			strInfo += "    Ultra DMA mode currently selected:  1\r\n";
		}

		if(pIdInfo->wUltraDMA.Mode2Sel)
		{
			strInfo += "    Ultra DMA mode currently selected:  2\r\n";
		}

		if(pIdInfo->wUltraDMA.Mode3Sel)
		{
			strInfo += "    Ultra DMA mode currently selected:  3\r\n";
		}

		if(pIdInfo->wUltraDMA.Mode4Sel)
		{
			strInfo += "    Ultra DMA mode currently selected:  4\r\n";
		}

		if(pIdInfo->wUltraDMA.Mode5Sel)
		{
			strInfo += "    Ultra DMA mode currently selected:  5\r\n";
		}

		if(pIdInfo->wUltraDMA.Mode6Sel)
		{
			strInfo += "    Ultra DMA mode currently selected:  6\r\n";
		}

		if(pIdInfo->wUltraDMA.Mode7Sel)
		{
			strInfo += "    Ultra DMA mode currently selected:  7\r\n";
		}

	}

	return strInfo;
}


/////////////////////////////////////////////////////////////////////////////
// CIdeDiskInfoView message handlers

void CIdeDiskInfoView::OnMethod1() 
{
	// TODO: Add your command handler code here
	CString strInfo;
	IDINFO IdInfo;

	for(int i=0; i<4; i++)
	{
		if(::GetPhysicalDriveInfoInNT(i, &IdInfo))
		{
			strInfo += "\r\n" + MakeIdeInfo(i, 0, &IdInfo);
		}
	}
	
	CEdit& Edit = GetEditCtrl();

	Edit.SetWindowText(strInfo);
}

void CIdeDiskInfoView::OnMethod2() 
{
	// TODO: Add your command handler code here
	CString strInfo;
	IDINFO IdInfo;

	for(int i=0; i<4; i++)
	{
		if(::GetIdeDriveAsScsiInfoInNT(i, &IdInfo))
		{
			strInfo += "\r\n" + MakeIdeInfo(i, 1, &IdInfo);
		}
	}
	
	CEdit& Edit = GetEditCtrl();

	Edit.SetWindowText(strInfo);	
}