image.cpp

虚拟打印机

/*
 *
 * image.cpp
 *
 *
   Copyright (C) 2006 Michael H. Overlin

   This program is free software; you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
   the Free Software Foundation; either version 2 of the License, or
   (at your option) any later version.

   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.

   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
   
   Contact at [e-mail]
 */

#include "image.h"

#include "coordtrans.h"
#include "dib.h"
#include "gdiutils.h"
#include "mathutils.h"
#include "utils.h"

// ****************************************************************************************************
// **  class Image  ***********************************************************************************
// ****************************************************************************************************

// OPTIONAL INTERFACE (DEFAULT IMPLEMENTS USING CLIPPING AND SETTING VIEW, WINDOW
BOOL Image::Draw(HDC hdcDest, IN const RECT& rDest, IN const RECTD& rdSrcSelection) const {
	// SYNTAX ?? WONT ACCEPT FIRST
	//::CoordTrans trans();
	::CoordTrans trans;

	POINT ptDest = { rDest.left, rDest.top };
	SIZE szDest = { RW(rDest), RH(rDest) };
	POINTD ptdSrc = { rdSrcSelection.left, rdSrcSelection.top };
	trans.Reset(ptdSrc, ptDest, 1.0, rdSrcSelection, rDest);

	// rDestSrcSelection SHOULD COME OUT SAME AS rDest, BUT TRANSFORM IN CASE OF SLIGHT ROUNDING DIFFERENCES
	RECT rDestSrcSelection;
	trans.DoTrans(rdSrcSelection, rDestSrcSelection);
	SIZE szDestSrcSelection = { RW(rDestSrcSelection), RH(rDestSrcSelection) };
	RECT rDestSrcFrame;
	RECTD rdFrame = this->GetFrame();
	trans.DoTrans(rdFrame, rDestSrcFrame);
	//SIZE szDestFrame = { RW(rDestFrame), RH(rDestFrame) };

	int iSave = ::SaveDC(hdcDest);

	::SetMapMode(hdcDest, MM_ANISOTROPIC);
	::SetViewport(hdcDest, rDest);
	//::SetViewportOrgEx(hdcDest, rDest.left, rDest.top, NULL);
	//::SetViewportExtEx(hdcDest, szDest.cx, szDest.cy, NULL);
	//::SetWindowOrgEx(hdcDest, rDestFrame.left, rDestFrame.top, NULL);
	//::SetWindowExtEx(hdcDest, szDestFrame.cx, szDestFrame.cy, NULL);
	//::SetWindowOrgEx(hdcDest, rDestSrcSelection.left, rDestSrcSelection.top, NULL);
	//::SetWindowExtEx(hdcDest, szDestSrcSelection.cx, szDestSrcSelection.cy, NULL);
	::SetWindow(hdcDest, rDestSrcSelection);
	::SelectClipRgn(hdcDest, NULL);
	::IntersectClipRect(hdcDest, rDestSrcSelection);
	//::IntersectClipRect(hdcDest, rDestSrcSelection.left, rDestSrcSelec

	//BOOL bRetValue = ::PlayEnhMetaFile(hdcDest, m_hMeta, &rDestSrcFrame);
	BOOL bRetValue = this->Draw(hdcDest, rDestSrcFrame);

	::RestoreDC(hdcDest, iSave);

	return bRetValue;

	//trans.Reset(
}

// ***********************************************************************************************
// **  class ImageFromDib  ***********************************************************************
// ***********************************************************************************************

ImageFromBitmap::ImageFromBitmap(HBITMAP hbmp, BOOL bOwnsBmp, const RECTD* prdFrame) {
	ASSERT(hbmp != NULL);
	m_hbmp = hbmp;
	m_bOwnsBmp = bOwnsBmp;

	{
		::BITMAP bm;
		::GetObject(m_hbmp, sizeof(bm), &bm);
		m_szBmp.cx = bm.bmWidth;
		m_szBmp.cy = bm.bmHeight;
	}

	if (prdFrame != NULL) {
		m_rdFrame = *prdFrame;
	} else {
		m_rdFrame.left = m_rdFrame.top = 0;
		m_rdFrame.right = m_szBmp.cx;
		m_rdFrame.bottom = m_szBmp.cy;
	}
}

ImageFromBitmap::~ImageFromBitmap() {
	if (m_bOwnsBmp) {
		::DeleteObject(m_hbmp);
	}
}

const RECTD& ImageFromBitmap::GetFrame(void) const  {
	return m_rdFrame;
}

BOOL ImageFromBitmap::Draw(HDC hdcDest, IN const RECT& rDest) const {
	BOOL bRetValue = FALSE;
	HDC hdcMem = ::CreateCompatibleDC(hdcDest);
	if (hdcMem != NULL) {
		HBITMAP hbmpOld = (HBITMAP) ::SelectObject(hdcMem, m_hbmp);
		if (hbmpOld != NULL) {
			try {
				SIZE szDest = { RW(rDest), RH(rDest) };
				bRetValue = ::StretchBlt(hdcDest, rDest.left, rDest.top, szDest.cx, szDest.cy, hdcMem, 0, 0, m_szBmp.cx, m_szBmp.cy, SRCCOPY);
			} catch(...) {
			}
			::SelectObject(hdcMem, hbmpOld);
		}
		::DeleteDC(hdcMem);
	}
	return bRetValue;
}

//private:
//	HBITMAP m_hbmp;
//	RECTD m_rdFrame;
//};

// ***********************************************************************************************
// **  class ImageFromDib  ***********************************************************************
// ***********************************************************************************************

ImageFromDib::ImageFromDib(const DibFromMemory& dib) : m_dib(dib) {
	SIZE sz = m_dib.GetSize_Pixels();
	m_rdFrame.left = m_rdFrame.top = 0;
	m_rdFrame.right = sz.cx;
	m_rdFrame.bottom = sz.cy;
}

ImageFromDib::~ImageFromDib() {
	// NOTHING TO DELETE
}


const RECTD& ImageFromDib::GetFrame(void) const {
	return m_rdFrame;
}

BOOL ImageFromDib::Draw(HDC hdcDest, IN const RECT& rDest) const {
	SIZE sz = m_dib.GetSize_Pixels();
	RECT rSrc = { 0, 0, sz.cx, sz.cy };
	int iCode = m_dib.StretchDIBits(hdcDest, rDest, rSrc, SRCCOPY);
	//m_dib.StretchDIBits();
	BOOL bRetValue = (iCode != GDI_ERROR);
	return bRetValue;
}

// ****************************************************************************************************
// **  class ImageFromEnhMetafile  ********************************************************************
// ****************************************************************************************************

ImageFromEnhMetafile::ImageFromEnhMetafile(
	HENHMETAFILE hMeta, BOOL bOwnsMeta, 
	const RECTD& rdFrame,
	BOOL bBkgClr,
	COLORREF clrBkg
) {
	ASSERT(hMeta != NULL);
	m_hMeta = hMeta;
	m_bOwnsMeta = bOwnsMeta;
	m_rdFrame = rdFrame;
	m_bBkgClr = bBkgClr;
	m_clrBkg = clrBkg;
}

ImageFromEnhMetafile::~ImageFromEnhMetafile() {
	if (m_bOwnsMeta) {
		::DeleteEnhMetaFile(m_hMeta);
	}
}

const RECTD& ImageFromEnhMetafile::GetFrame(void) const {
	return m_rdFrame;
}

#if 0
BOOL ImageFromEnhMetafile::Draw(HDC hdcDest, IN const RECT& rDest, IN const RECTD& rdSrcSelection) const {
	// SYNTAX ?? WONT ACCEPT FIRST
	//::CoordTrans trans();
	::CoordTrans trans;

	POINT ptDest = { rDest.left, rDest.top };
	SIZE szDest = { RW(rDest), RH(rDest) };
	POINTD ptdSrc = { rdSrcSelection.left, rdSrcSelection.top };
	trans.Reset(ptdSrc, ptDest, 1.0, rdSrcSelection, rDest);

	// rDestSrcSelection SHOULD COME OUT SAME AS rDest, BUT TRANSFORM IN CASE OF SLIGHT ROUNDING DIFFERENCES
	RECT rDestSrcSelection;
	trans.DoTrans(rdSrcSelection, rDestSrcSelection);
	SIZE szDestSrcSelection = { RW(rDestSrcSelection), RH(rDestSrcSelection) };
	RECT rDestSrcFrame;
	trans.DoTrans(m_rdFrame, rDestSrcFrame);
	//SIZE szDestFrame = { RW(rDestFrame), RH(rDestFrame) };

	int iSave = ::SaveDC(hdcDest);

	::SetMapMode(hdcDest, MM_ANISOTROPIC);
	::SetViewport(hdcDest, rDest);
	//::SetViewportOrgEx(hdcDest, rDest.left, rDest.top, NULL);
	//::SetViewportExtEx(hdcDest, szDest.cx, szDest.cy, NULL);
	//::SetWindowOrgEx(hdcDest, rDestFrame.left, rDestFrame.top, NULL);
	//::SetWindowExtEx(hdcDest, szDestFrame.cx, szDestFrame.cy, NULL);
	//::SetWindowOrgEx(hdcDest, rDestSrcSelection.left, rDestSrcSelection.top, NULL);
	//::SetWindowExtEx(hdcDest, szDestSrcSelection.cx, szDestSrcSelection.cy, NULL);
	::SetWindow(hdcDest, rDestSrcSelection);
	::SelectClipRgn(hdcDest, NULL);
	::IntersectClipRect(hdcDest, rDestSrcSelection);
	//::IntersectClipRect(hdcDest, rDestSrcSelection.left, rDestSrcSelec

	BOOL bRetValue = ::PlayEnhMetaFile(hdcDest, m_hMeta, &rDestSrcFrame);

	::RestoreDC(hdcDest, iSave);

	return bRetValue;

	//trans.Reset(
}
#endif

BOOL ImageFromEnhMetafile::Draw(HDC hdcDest, IN const RECT& rDest) const {
	BOOL bRetValue = FALSE;
	BOOL bContinue = TRUE;
	if (m_bBkgClr) {
		bContinue = ::FillSolidColor(hdcDest, rDest, m_clrBkg);
	}
	if (bContinue) {
		bRetValue = ::PlayEnhMetaFile(hdcDest, m_hMeta, &rDest);
	}
	return bRetValue;
}