prbitmapdatafile.cpp

虚拟打印机

/*
 *
 * prbitmapdatafile.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 "prbitmapdatafile.h"

#include "..\lib\printResizerCommon.h"
#include "..\lib\gdiutils.h"
#include "..\lib\image.h"
//#include "..\lib\mathutils.h"
#include "..\lib\renderpages.h"
#include "..\lib\utils.h"

//double GetMaxIsoScale(const SIZED &szdFrame, const SIZED& szdImage) ;


PRBitmapDataFile::PRBitmapDataFile() {
	// NOTHING TO DO
}

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

BOOL PRBitmapDataFile::Open(const tstring& tstrFileName) {
	BOOL bRetValue = FALSE;
	
	if (m_dib.Open(tstrFileName)) {
		LPTSTR lptstrTemp = ::GetFileNameAndExt(tstrFileName.c_str());
		if (lptstrTemp != NULL) {
			m_tstrJobName = lptstrTemp;
			free(lptstrTemp);
		}
		bRetValue = TRUE;
	}

	return bRetValue;
}

void PRBitmapDataFile::Close(void) {
	ASSERT(this->IsOpen());
	m_dib.Close();
	m_tstrJobName.erase();
}

BOOL PRBitmapDataFile::IsOpen(void) const {
	BOOL bRetValue = m_dib.IsOpen();
	return bRetValue;
}

const tstring & PRBitmapDataFile::GetJobName(void) const {
	ASSERT(this->IsOpen());
	return m_tstrJobName;
}

uint PRBitmapDataFile::GetPageCount(void) const {
	ASSERT(this->IsOpen());
	return 1;
}

//HENHMETAFILE PRBitmapDataFile::GetPageEMF(uint uiPage) const {
//	ASSERT(this->IsOpen()); 
//	ASSERT(uiPage < this->GetPageCount());
//
//	HENHMETAFILE hMeta = NULL;
//
//	HDC hdcRef = ::GetDC(NULL);
//	if (hdcRef != NULL) {
//		try {
//			SIZE szRefDC_Pixels = { ::GetDeviceCaps(hdcRef, HORZRES), ::GetDeviceCaps(hdcRef, VERTRES) };
//			SIZE szRefDC_HM = { ::GetDeviceCaps(hdcRef, HORZSIZE) * 100, ::GetDeviceCaps(hdcRef, VERTSIZE) * 100 };
//			POINTD ptdRef_HM_Per_Pixel = { (double) szRefDC_HM.cx / szRefDC_Pixels.cx, (double) szRefDC_HM.cy / szRefDC_Pixels.cy };
//			SIZE szDib_Pixels = m_dib.GetSize_Pixels();
//			RECT rSrc_Pixels = { 0, 0, szDib_Pixels.cx, szDib_Pixels.cy };
//
//			// IM NOT SURE HOW METAFILE RESOLUTION AND SCALING WORKS
//			// SO I DRAW THE IMAGE IN THE METAFILE ISOMETRICALLY SCALED AS LARGE AS POSSIBLE
//			// TO FIT WITHIN THE REFERENCE DC RESOLUTION (I DO KNOW METFAILES CLIP OUTSIDE OF THAT)
//			// THIS SEEMS TO FIX THE "PHYSICAL" OF THE METAFILE IMAGE -- THE METFILE KNOWS THE DPI OF THE REFERENCE DC,
//			// AND CONSIDERS THE ULTIMATE DEVICE PIXEL OUTPUT TO BE AT THAT DPI
//			// NOT SURE HOW TO DO OTHERWISE AND AVOID SACRIFICING ACCURACY 
//			// (MAYBE THE ACCURACY IS DETERMINED BY THE WINDOW EXT INSTEAD?)
//
//			double dScale = 1;
//			{
//				SIZED szdFrameTemp = { szRefDC_Pixels.cx, szRefDC_Pixels.cy };
//				SIZED szdImageTemp = { szDib_Pixels.cx, szDib_Pixels.cy };
//				dScale = ::GetMaxIsoScale(szdFrameTemp, szdImageTemp);
//			}
//
//			SIZE szDest_Pixels = { RoundToLong(szDib_Pixels.cx * dScale), RoundToLong(szDib_Pixels.cy * dScale) };
//			//SIZE szFrame = { RoundToLong( sz
//			SIZE szFrame_HM = { 
//				RoundToLong( szDib_Pixels.cx * dScale * ptdRef_HM_Per_Pixel.x), 
//				RoundToLong( szDib_Pixels.cy * dScale * ptdRef_HM_Per_Pixel.y)
//			};
//			RECT rFrame_HM = { 0, 0, szFrame_HM.cx, szFrame_HM.cy };
//
//			LPTSTR lptstrDescription = ::MyCatStringsString(TRUE, PRINTRESIZER_APP_NAME, m_tstrJobName.c_str(), NULL);
//			if (lptstrDescription != NULL) {
//				HDC hdcMeta = ::CreateEnhMetaFileW(hdcRef, NULL, &rFrame_HM, lptstrDescription);
//				if (hdcMeta != NULL) {
//					::SetMapMode(hdcMeta, MM_ANISOTROPIC);
//					::SetViewportOrgEx(hdcMeta, 0, 0, NULL);
//					::SetViewportExtEx(hdcMeta, szDest_Pixels.cx, szDest_Pixels.cy, NULL);
//					::SetWindowOrgEx(hdcMeta, 0, 0, NULL);
//					::SetWindowExtEx(hdcMeta, szFrame_HM.cx, szFrame_HM.cy, NULL);
//
//					m_dib.StretchDIBits(hdcMeta, rFrame_HM, rSrc_Pixels, SRCCOPY);
//
//					hMeta = ::CloseEnhMetaFile(hdcMeta);
//				}
//				free(lptstrDescription);
//			}
//
//			if (hdcRef != NULL) {
//				::ReleaseDC(NULL, hdcRef);
//			}
//		} catch(...) {
//			if (hdcRef != NULL) {
//				::ReleaseDC(NULL, hdcRef);
//			}
//		}
//	}
//
//	return hMeta;
//}
HENHMETAFILE PRBitmapDataFile::GetPageEMF(uint uiPage) const {
	ASSERT(this->IsOpen()); 
	ASSERT(uiPage < this->GetPageCount());

	HENHMETAFILE hMeta = NULL;

	HDC hdcRef = ::GetDC(NULL);
	if (hdcRef != NULL) {
		try {
			LPTSTR lptstrDescription = ::MyCatStringsString(TRUE, PRINTRESIZER_APP_NAME, m_tstrJobName.c_str(), NULL);
			if (lptstrDescription != NULL) {
				ImageFromDib img(m_dib);
				RECTD rdFrame = img.GetFrame();
				SIZE szPixels;
				hMeta = ::ExtractSelectionToEnhMetafile(
					img,
					rdFrame,
					hdcRef,
					NULL,
					lptstrDescription,
					szPixels
					);
				free(lptstrDescription);
			}

			if (hdcRef != NULL) {
				::ReleaseDC(NULL, hdcRef);
			}
		} catch(...) {
			if (hdcRef != NULL) {
				::ReleaseDC(NULL, hdcRef);
			}
		}
	}

	return hMeta;
}

BOOL PRBitmapDataFile::GetSourcePageSpec(IN uint uiPage, OUT ::PageSpec& ps) const {
	ASSERT(this->IsOpen());
	ASSERT(uiPage < this->GetPageCount());
	::ZeroMemory(&ps, sizeof(ps));
	ps.rotDir = ::LandscapeRot::e90;
	// DEBUG / FIX
	// NOTE WE DON'T SET UP THE METAFILE WITH THIS FRAME SIZE CURRENTLY
	// SO WE HAVE TO WATCH FOR PROBLEMS -- THINK THAT CODE TO EXTRACT A SELECTION NEEDS TO BE FIXED
	ps.szlPhysicalPage = m_dib.GetSize_Pixels();
	ps.szlPrintable = ps.szlPhysicalPage;
	ps.szdPhysicalPage_Inches = m_dib.GetSize_Inches();
	return TRUE;
}

PDEVMODE PRBitmapDataFile::GetTargetPrinter(IN uint uiPage, OUT tstring& tstrTargetPrinterName) const {
	ASSERT(this->IsOpen());
	ASSERT(uiPage < this->GetPageCount());
	// BITMAP FILE HAS NO SUCH DATA IN IT
	return NULL;
}

BOOL PRBitmapDataFile::GetResizedRenderSpec(IN uint uiPage, OUT ::RenderSpec& rs) const {
	ASSERT(this->IsOpen());
	ASSERT(uiPage < this->GetPageCount());
	// BITMAP FILE HAS NO SUCH DATA IN IT
	return FALSE;
}
//
//BOOL PRBitmapDataFile::GetSourceSelection(IN uint uiPage, OUT ::RECTD& rdSourceSelection_Inches) const {
//	// BITMAP FILE HAS NO SUCH DATA IN IT
//	return FALSE;
//}
//
BOOL PRBitmapDataFile::GetResizedSourceSpec(IN uint uiPage, OUT ::SourceSpec& ssResized) const {
	ASSERT(this->IsOpen());
	ASSERT(uiPage < this->GetPageCount());
	//ssResized.rdSelection_Inches ps.szdPhysicalPage_Inches = m_dib.GetSize_Inches();
	SIZED szd_Inches = m_dib.GetSize_Inches();
	ssResized.rdTotalImage_Inches.left = ssResized.rdTotalImage_Inches.top = 0;
	ssResized.rdTotalImage_Inches.right = szd_Inches.cx;
	ssResized.rdTotalImage_Inches.bottom = szd_Inches.cy;
	ssResized.rdSelection_Inches = ssResized.rdTotalImage_Inches;
	return TRUE;
}

// 7/3
// IN MATHUTILS 
//double GetMaxIsoScale(const SIZED &szdFrame, const SIZED& szdImage) {
//	double dRetValue = 1;
//	if (szdImage.cx * szdFrame.cy < szdImage.cy * szdFrame.cx) {
//		dRetValue = szdFrame.cy / szdImage.cy;
//	} else {
//		dRetValue = szdFrame.cx / szdImage.cx;
//	}
//	return dRetValue;
//}