vc10view.cpp

Visual C++ 6.0编程基础与范例

// VC10View.cpp : implementation of the CVC10View class
//

#include "stdafx.h"
#include "VC10.h"

#include "VC10Doc.h"
#include "VC10View.h"

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

/////////////////////////////////////////////////////////////////////////////
// CVC10View

IMPLEMENT_DYNCREATE(CVC10View, CScrollView)

BEGIN_MESSAGE_MAP(CVC10View, CScrollView)
	//{{AFX_MSG_MAP(CVC10View)
	ON_COMMAND(ID_FILE_OPEN, OnFileOpen)
	ON_COMMAND(ID_ZoomOut, OnZoomOut)
	ON_COMMAND(ID_ZoomIn, OnZoomIn)
	//}}AFX_MSG_MAP
	// Standard printing commands
	ON_COMMAND(ID_FILE_PRINT, CScrollView::OnFilePrint)
	ON_COMMAND(ID_FILE_PRINT_DIRECT, CScrollView::OnFilePrint)
	ON_COMMAND(ID_FILE_PRINT_PREVIEW, CScrollView::OnFilePrintPreview)
END_MESSAGE_MAP()

/////////////////////////////////////////////////////////////////////////////
// CVC10View construction/destruction

CVC10View::CVC10View()
{
	// TODO: add construction code here
 	Clear();
}

CVC10View::~CVC10View()
{
	Clear();
}

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

	return CScrollView::PreCreateWindow(cs);
}

/////////////////////////////////////////////////////////////////////////////
// CVC10View drawing

void CVC10View::OnDraw(CDC* pDC)
{
	// TODO: add draw code for native data here

	BeginWaitCursor();
    CSize DibSize = GetDibSize();
    DibSize.cx *= m_x;
    DibSize.cy *= -m_x;
    DibToDC(pDC, DibSize);
    EndWaitCursor();
}

void CVC10View::OnInitialUpdate()
{
	CScrollView::OnInitialUpdate();

	// TODO: calculate the total size of this view

	m_x=25;	
	CSize MaxSize(24000, 32000);
    CSize MinSize = CSize(MaxSize.cx / 100, MaxSize.cy / 100);
    SetScrollSizes(MM_HIMETRIC, MaxSize, MaxSize, MinSize);

    LPVOID BMPResource = (LPVOID) ::LoadResource(NULL,
              ::FindResource(NULL, MAKEINTRESOURCE(IDB_BITMAP1),
              RT_BITMAP));
    MemToDib(BMPResource); 
}

/////////////////////////////////////////////////////////////////////////////
// CVC10View printing

BOOL CVC10View::OnPreparePrinting(CPrintInfo* pInfo)
{
	// default preparation
	return DoPreparePrinting(pInfo);
}

void CVC10View::OnBeginPrinting(CDC* /*pDC*/, CPrintInfo* /*pInfo*/)
{
	// TODO: add extra initialization before printing
}

void CVC10View::OnEndPrinting(CDC* /*pDC*/, CPrintInfo* /*pInfo*/)
{
	// TODO: add cleanup after printing
}

/////////////////////////////////////////////////////////////////////////////
// CVC10View diagnostics

#ifdef _DEBUG
void CVC10View::AssertValid() const
{
	CScrollView::AssertValid();
}

void CVC10View::Dump(CDumpContext& dc) const
{
	CScrollView::Dump(dc);
}

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

/////////////////////////////////////////////////////////////////////////////
// CVC10View message handlers

CSize CVC10View::GetDibSize()
{	
	if(m_DibHead == NULL) return CSize(0, 0);
	return CSize((int) m_DibHead->biWidth, (int) m_DibHead->biHeight);
}


BOOL CVC10View::MemToDib(LPVOID lMem)
{
	Clear();

	m_DibHead = (LPBITMAPINFOHEADER) lMem;
	PaletteSize(m_DibHead->biBitCount);
	m_Image = (LPBYTE) m_ColorList + sizeof(RGBQUAD) * m_nPalette;
	GetPalette();

	return TRUE;
}

BOOL CVC10View::DibToDC(CDC* pDC, CSize size)
{
	if(m_DibHead == NULL) return FALSE;
	if(m_hPalette != NULL) {
		HDC hdc = pDC->GetSafeHdc();
		::SelectPalette(hdc, m_hPalette, TRUE);
	}
	pDC->SetStretchBltMode(COLORONCOLOR);
	::StretchDIBits(pDC->GetSafeHdc(), 0, 0, size.cx, size.cy,
		0, 0, m_DibHead->biWidth, m_DibHead->biHeight,
		m_Image, (LPBITMAPINFO) m_DibHead, DIB_RGB_COLORS, SRCCOPY);
	return TRUE;
}


BOOL CVC10View::GetPalette()
{
	if(m_nPalette == 0) return FALSE;

	if(m_hPalette != NULL) ::DeleteObject(m_hPalette);

	LPLOGPALETTE pTempPalette = (LPLOGPALETTE) new char[2 * 
		sizeof(WORD) + m_nPalette * sizeof(PALETTEENTRY)];

	pTempPalette->palVersion = 0x300;
	pTempPalette->palNumEntries = m_nPalette;

	LPRGBQUAD pRGBQuad = (LPRGBQUAD) m_ColorList;
	for(int i = 0; i < m_nPalette; i++) {
		pTempPalette->palPalEntry[i].peRed = pRGBQuad->rgbRed;
		pTempPalette->palPalEntry[i].peGreen = pRGBQuad->rgbGreen;
		pTempPalette->palPalEntry[i].peBlue = pRGBQuad->rgbBlue;
		pTempPalette->palPalEntry[i].peFlags = 0;
		pRGBQuad++;
	}
	m_hPalette = ::CreatePalette(pTempPalette);

	delete pTempPalette;
	return TRUE;
}	

BOOL CVC10View::SetPalette()
{
	if(m_nPalette != 0) return FALSE;
	CClientDC dc(this);
	CDC* pDC=&dc;
	m_hPalette = ::CreateHalftonePalette(pDC->GetSafeHdc());
	return TRUE;
}

BOOL CVC10View::ReadFile(CFile* pFile)
{
	int nCount, nSize;
	BITMAPFILEHEADER bmfh;
	Clear();
	try {
		nCount = pFile->Read((LPVOID) &bmfh, sizeof(BITMAPFILEHEADER));
		if(nCount != sizeof(BITMAPFILEHEADER)) {
			throw new CException;
		}
		if(bmfh.bfType != 0x4d42) {
			throw new CException;
		}
		nSize = bmfh.bfOffBits - sizeof(BITMAPFILEHEADER);
		m_DibHead = (LPBITMAPINFOHEADER) new char[nSize];
		m_nBmpallocate = m_nImageallocate = crtallocate;
		nCount = pFile->Read(m_DibHead, nSize); 
		PaletteSize(m_DibHead->biBitCount);
		GetPalette();
		m_Image = (LPBYTE) new char[m_ImageSize];
		nCount = pFile->Read(m_Image, m_ImageSize); 
	}
	catch(CException* tmpc) {
		AfxMessageBox("文件读取错误");
		tmpc->Delete();
		return FALSE;
	}
	return TRUE;
}


void CVC10View::PaletteSize(int nBitCount)
{
	if(m_DibHead->biSize != sizeof(BITMAPINFOHEADER)) {
		throw new CException;
	}
	m_ImageSize = m_DibHead->biSizeImage;
	if(m_ImageSize == 0) {
		DWORD dwBytes = ((DWORD) m_DibHead->biWidth * 
			m_DibHead->biBitCount) / 32;
		if(((DWORD) m_DibHead->biWidth * m_DibHead->biBitCount) % 32)
		{
			dwBytes++;
		}
		dwBytes *= 4;
		m_ImageSize = dwBytes * m_DibHead->biHeight; 
	}
	m_ColorList = (LPBYTE) m_DibHead + sizeof(BITMAPINFOHEADER);

	if((m_DibHead == NULL) || (m_DibHead->biClrUsed == 0)) {
		switch(nBitCount) {
			case 1:
				m_nPalette = 2;
				break;
			case 4:
				m_nPalette = 16;
				break;
			case 8:
				m_nPalette = 256;
				break;
			case 16:
			case 24:
			case 32:
				m_nPalette = 0;
				break;
			default:
				ASSERT(FALSE);
		}
	}
	else {
		m_nPalette = m_DibHead->biClrUsed;
	}
	ASSERT((m_nPalette >= 0) && (m_nPalette <= 256)); 
}

void CVC10View::Clear()
{
	if(m_hFile == NULL) return;
	::UnmapViewOfFile(m_lpvFile);
	::CloseHandle(m_hMap);
	::CloseHandle(m_hFile);
	m_hFile = NULL;

	if(m_nBmpallocate == crtallocate) {
		delete [] m_DibHead;
	}
	else if(m_nBmpallocate == heapallocate) {
		::GlobalUnlock(m_hGlob);
		::GlobalFree(m_hGlob);
	}
	if(m_nImageallocate == crtallocate) delete [] m_Image;
	if(m_hPalette != NULL) ::DeleteObject(m_hPalette);
	if(m_Bmp != NULL) ::DeleteObject(m_Bmp);
	m_nBmpallocate = m_nImageallocate = None;
	m_hGlob = NULL;
	m_DibHead = NULL;
	m_Image = NULL;
	m_ColorList = NULL;
	m_nPalette = 0;
	m_ImageSize = 0;
	m_lpvFile = NULL;
	m_hMap = NULL;
	m_hFile = NULL;
	m_Bmp = NULL;
	m_hPalette = NULL;
}


void CVC10View::OnFileOpen() 
{
	// TODO: Add your command handler code here

	CFileDialog dlg(TRUE, "bmp", "*.bmp");
    if (dlg.DoModal() != IDOK) 
	{
        return;
    }
    CFile file;
    file.Open(dlg.GetPathName(), CFile::modeRead);
    if (ReadFile(&file) == TRUE) {
        Invalidate();
    }
    SetPalette();
}


void CVC10View::OnZoomOut() 
{
	// TODO: Add your command handler code here

	CSize Dibsize = GetDibSize();
	if ((Dibsize.cx * m_x * 1.2) < 24000)
	{
		if ((Dibsize.cy * m_x * 1.2) < 32000)
		{
		m_x = m_x * 1.2;
		Invalidate();
		}
	}
}

void CVC10View::OnZoomIn() 
{
	// TODO: Add your command handler code here

	if (m_x > 2)
	{
		m_x = m_x / 1.2;
		Invalidate();
	}
}