www.pudn.com > VisSDK.rar > ExMFCOpenSaveView.cpp

// ExMFCOpenSaveView.cpp : implementation of the CExMFCOpenSaveView class 
// 
// Copyright © 1997-2000 Microsoft Corporation, All Rights Reserved 
 
 
// LATER:  Zooming, initial image POINT offsets (when StartPoint() != (0, 0)), 
// and titles when printing. 
 
 
#include "stdafx.h" 
#include "VisCore.h" 
#include "ExMFCOpenSave.h" 
 
#include "ExMFCOpenSaveDoc.h" 
#include "ExMFCOpenSaveView.h" 
 
#include "MainFrm.h" 
 
#ifdef _DEBUG 
#define new DEBUG_NEW 
#undef THIS_FILE 
static char THIS_FILE[] = __FILE__; 
#endif 
 
///////////////////////////////////////////////////////////////////////////// 
// CExMFCOpenSaveView 
 
IMPLEMENT_DYNCREATE(CExMFCOpenSaveView, CScrollView) 
 
BEGIN_MESSAGE_MAP(CExMFCOpenSaveView, CScrollView) 
	//{{AFX_MSG_MAP(CExMFCOpenSaveView) 
	ON_WM_ERASEBKGND() 
	ON_WM_MOUSEMOVE() 
	//}}AFX_MSG_MAP 
	// Standard printing commands 
	ON_COMMAND(ID_FILE_PRINT, CView::OnFilePrint) 
	ON_COMMAND(ID_FILE_PRINT_DIRECT, CView::OnFilePrint) 
	ON_COMMAND(ID_FILE_PRINT_PREVIEW, CView::OnFilePrintPreview) 
END_MESSAGE_MAP() 
 
///////////////////////////////////////////////////////////////////////////// 
// CExMFCOpenSaveView construction/destruction 
 
CExMFCOpenSaveView::CExMFCOpenSaveView() 
{ 
} 
 
CExMFCOpenSaveView::~CExMFCOpenSaveView() 
{ 
} 
 
///////////////////////////////////////////////////////////////////////////// 
// CExMFCOpenSaveView drawing 
 
void CExMFCOpenSaveView::OnDraw(CDC* pDC) 
{ 
	CExMFCOpenSaveDoc* pDoc = GetDocument(); 
	ASSERT_VALID(pDoc); 
 
	CVisImageBase& refimage = pDoc->Image(); 
	 
	assert(refimage.IsValid()); 
 
	refimage.DisplayInHdc(*pDC); 
} 
 
///////////////////////////////////////////////////////////////////////////// 
// CExMFCOpenSaveView printing 
 
BOOL CExMFCOpenSaveView::OnPreparePrinting(CPrintInfo* pInfo) 
{ 
	// default preparation 
	return DoPreparePrinting(pInfo); 
} 
 
void CExMFCOpenSaveView::OnBeginPrinting(CDC* /*pDC*/, CPrintInfo* /*pInfo*/) 
{ 
	// TODO: add extra initialization before printing 
} 
 
void CExMFCOpenSaveView::OnEndPrinting(CDC* /*pDC*/, CPrintInfo* /*pInfo*/) 
{ 
	// TODO: add cleanup after printing 
} 
 
///////////////////////////////////////////////////////////////////////////// 
// CExMFCOpenSaveView diagnostics 
 
#ifdef _DEBUG 
void CExMFCOpenSaveView::AssertValid() const 
{ 
	CScrollView::AssertValid(); 
} 
 
void CExMFCOpenSaveView::Dump(CDumpContext& dc) const 
{ 
	CScrollView::Dump(dc); 
} 
 
CExMFCOpenSaveDoc* CExMFCOpenSaveView::GetDocument() // non-debug version is inline 
{ 
	ASSERT(m_pDocument->IsKindOf(RUNTIME_CLASS(CExMFCOpenSaveDoc))); 
	return (CExMFCOpenSaveDoc*)m_pDocument; 
} 
#endif //_DEBUG 
 
///////////////////////////////////////////////////////////////////////////// 
// CExMFCOpenSaveView message handlers 
 
void CExMFCOpenSaveView::OnInitialUpdate()  
{ 
	// Need to set the document size. 
	// MFC Example says that MM_LOENGLISH is better than MM_TEXT for 
	// printing. 
	// Note:  We could also add page and line sizes to SetScrollSize. 
	CExMFCOpenSaveDoc* pDoc = GetDocument(); 
	ASSERT_VALID(pDoc); 
 
	CVisImageBase& refimage = pDoc->Image(); 
	 
	if (refimage.IsValid()) 
	{ 
		CSize size(refimage.Size()); 
		SetScrollSizes(MM_TEXT, size); 
		ResizeParentToFit(false); 
 
		// May need to reduce the view's frame window size to make 
		// it fit in its parent's client area. 
		CFrameWnd* pFrame = GetParentFrame(); 
		if (pFrame != NULL) 
		{ 
			CRect rectSized; 
			pFrame->GetWindowRect(&rectSized); 
 
			CWnd *pParent = pFrame->GetParent(); 
			if (pParent != 0) 
			{ 
				// May need to adjust rect so that it fits in parent. 
				bool fResized = false; 
 
				pParent->ScreenToClient(rectSized); 
 
				CRect rectParent; 
				pParent->GetClientRect(&rectParent); 
 
				assert(rectParent.left <= rectSized.left); 
				assert(rectParent.top <= rectSized.top); 
 
				if (rectParent.right < rectSized.right) 
				{ 
					rectSized.right = rectParent.right; 
					rectSized.bottom += GetSystemMetrics(SM_CYVSCROLL) + 1; 
					fResized = true; 
				} 
 
				if (rectParent.bottom < rectSized.bottom) 
				{ 
					rectSized.bottom = rectParent.bottom; 
					rectSized.right += GetSystemMetrics(SM_CXHSCROLL) + 1; 
					if (rectParent.right < rectSized.right) 
						rectSized.right = rectParent.right; 
					fResized = true; 
				} 
 
				if (fResized) 
					pFrame->MoveWindow(&rectSized); 
			} 
		} 
	} 
 
	CScrollView::OnInitialUpdate(); 
} 
 
BOOL CExMFCOpenSaveView::OnEraseBkgnd(CDC* pDC)  
{ 
    // This probably isn't needed if the windows are sized correctly, 
	// but it might improve performance a little. 
	CBrush br( GetSysColor( COLOR_WINDOW ) );  
    FillOutsideRect( pDC, &br ); 
	 
	return CScrollView::OnEraseBkgnd(pDC); 
} 
 
void CExMFCOpenSaveView::OnMouseMove(UINT nFlags, CPoint point)  
{ 
	CRect rect; 
	GetClientRect(&rect); 
	if (rect.PtInRect(point)) 
	{ 
		CExMFCOpenSaveDoc* pDoc = GetDocument(); 
		ASSERT_VALID(pDoc); 
 
		CVisImageBase& refimage = pDoc->Image(); 
 
		CPoint pointImage = point + GetDeviceScrollPosition(); 
 
		if (refimage.Rect().PtInRect(pointImage)) 
		{ 
			CMainFrame *pMainFrame = ((CMainFrame *) AfxGetApp()->m_pMainWnd); 
 
			char szValue[256]; 
			refimage.GetPixelValueString(pointImage, szValue, sizeof(szValue)); 
	 
			CString text; 
			text.Format("(%3d, %3d)  -> [%s]", 
					pointImage.x, pointImage.y, szValue); 
 
			pMainFrame->SetMessageText(text); 
		} 
	} 
	 
	CScrollView::OnMouseMove(nFlags, point); 
} 
 
void CExMFCOpenSaveView::OnPrint(CDC* pDC, CPrintInfo* pInfo)  
{ 
	CExMFCOpenSaveApp *pApp = (CExMFCOpenSaveApp *) AfxGetApp(); 
	ASSERT_VALID(pApp); 
	CExMFCOpenSaveDoc* pDoc = GetDocument(); 
	ASSERT_VALID(pDoc); 
 
	CVisImageBase& refimage = pDoc->Image(); 
	 
	if (refimage.IsValid()) 
	{ 
		assert(pDC != 0); 
		assert(pInfo != 0); 
 
		int w = GetDeviceCaps(*pDC, RASTERCAPS); 
		if (((RC_STRETCHDIB & w) != 0) 
				&& (pApp->FScaleWhenPrinting())) 
		{ 
			// Scale the image when printing. 
			CSize sizeImage(refimage.Size()); 
			CSize sizePage(pInfo->m_rectDraw.Size()); 
			CRect rectDest(pInfo->m_rectDraw); 
 
			if (sizeImage.cy * sizePage.cx < sizeImage.cx * sizePage.cy) 
			{ 
				// X-dimensions determine scale 
				rectDest.bottom = rectDest.top 
						+ sizeImage.cy * sizePage.cx / sizeImage.cx; 
			} 
			else 
			{ 
				// Y-dimensions determine scale 
				rectDest.right = rectDest.left 
						+ sizeImage.cx * sizePage.cy / sizeImage.cy; 
			} 
 
			rectDest.right = rectDest.left + rectDest.Width() 
					* pApp->PercentPrintPage() / 100; 
			rectDest.bottom = rectDest.top + rectDest.Height() 
					* pApp->PercentPrintPage() / 100; 
			 
			refimage.DisplayInHdc(*pDC, refimage.Rect(), rectDest); 
		} 
		else 
		{ 
			// Don't scale when printing. 
			refimage.DisplayInHdc(*pDC); 
		} 
	} 
}