renderpages.cpp

虚拟打印机

	}

	// SOME NOTES FOR MYSELF ON CALCULATION
	// mT is total margin, m0 is fixed edges margin, mE is extra cut-guide and overlap margin
	// c is the mosiac page count (for the dimension)
	// szP is the printable page size -- so sz is the free printable page size, and sz0 is the printable mosaic size
	//mT = m0 + (c-1) mE
	//sz = sz0 - mT
	//sz0 = szP * c
	//and require sz >= szG (image * zoom)
	//
	//szG <= szP * c - mT = szP * c - m0 - (c-1) mE
	//= c (szP - mE) - m0 + mE
	//so c >= (szG + m0 - mE) / (szP - mE)  ---- and c >= 1
}

//void CalculateMosaicSizeFromZoomWithRotation(
//	OUT SIZE& szMosaic, 
//	OUT BOOL& bRotated,
//	IN double dZoom,
//	IN const RenderSpec& rs, 
//	IN const PageSpec& ps, 
//	IN const SourceSpec &ss
//) {
//	SIZE sz1;
//	::CalculateMosaicSizeFromZoom(sz1, dZoom, rs, ps, ss);
//	::PageSpec psTemp;
//	//::ReflectPageSpec(psTemp, ps);
//	::LandscapeRotatePageSpec(psTemp, ps);
//	
//	SIZE sz2;
//	::CalculateMosaicSizeFromZoom(sz2, dZoom, rs, psTemp, ss);
//	if (AREA(sz1) <= AREA(sz2)) {
//		szMosaic = sz1;
//		bRotated = FALSE;
//	} else {
//		szMosaic = sz2;
//		bRotated = TRUE;
//	}
//}
void CalculateMosaicSizeFromZoomWithRotation(
	OUT SIZE& szMosaic, 
	OUT BOOL& bRotated,
	IN double dZoom,
	IN const RenderSpec& rs, 
	IN const PageSpec& ps, 
	IN const SourceSpec &ss
) {
	SIZE sz1;
	::CalculateMosaicSizeFromZoom(sz1, dZoom, rs, ps, ss);
	::RenderSpec::MosaicFullDimension fd;
	double dZoom1 = ::CalculateZoomFromMosaicSize(sz1, rs, ps, ss, fd);

	::PageSpec psTemp;
	::LandscapeRotatePageSpec(psTemp, ps);
	SIZE sz2;
	::CalculateMosaicSizeFromZoom(sz2, dZoom, rs, psTemp, ss);
	double dZoom2 = ::CalculateZoomFromMosaicSize(sz2, rs, psTemp, ss, fd);

	if (dZoom2 <= dZoom1) {
		szMosaic = sz2;
		bRotated = TRUE;
	} else {
		szMosaic = sz1;
		bRotated = FALSE;
	}

}

void CalculatePageLogPix(OUT POINTD& ptdLogPix, IN const PageSpec& ps) {
	ptdLogPix.x = ps.szlPhysicalPage.cx / ps.szdPhysicalPage_Inches.cx;
	ptdLogPix.y = ps.szlPhysicalPage.cy / ps.szdPhysicalPage_Inches.cy;
}

void CalculateReneredImageBoundsRelPrintable(
	OUT RECTD& rdRenderedImageBounds_Inches, 
	IN const POINT& ptPage,
	IN const ::RenderSpec& rs,
	IN const ::PageSpec& ps,
	IN const ::SourceSpec& ss
	) {
	::RenderMosaicPage_Internal(NULL, NULL, ptPage, rs, ps, NULL, ss, &rdRenderedImageBounds_Inches);
}

// THIS CODEIS PULLED FROM TOP OF RenderMosaicPage
double CalculateZoomFromMosaicSize(
	IN const SIZE& szMosaic,
	IN const RenderSpec& rs, 
	IN const PageSpec& ps, 
	IN const SourceSpec &ss,
	OUT RenderSpec::MosaicFullDimension& fulldim
) {
	// IS ALL PHYSICAL PAGE HEIGHT AVAILABLE FOR PRINTING?
	// THIS TYPICALLY MEANS PAGE IS TRACTOR-FEAD
	BOOL bAllHeight = (ps.szlPhysicalPage.cy == ps.szlPrintable.cy);
	
	// IS ALL PHYSICAL PAGE WIDTH AVAILABLE FOR PRINTING?
	BOOL bAllWidth = (ps.szlPhysicalPage.cx == ps.szlPrintable.cx);

	// PIXELS PER INCH "LOGPIXELS"
	POINTD ptdPageLogPixels = { 
		ps.szlPhysicalPage.cx / ps.szdPhysicalPage_Inches.cx,
		ps.szlPhysicalPage.cy / ps.szdPhysicalPage_Inches.cy
	};

	// TOTAL SIZE OF MOSAIC OF PAGES
	SIZED szdPhysicalMosaic_Inches = {
		ps.szdPhysicalPage_Inches.cx * szMosaic.cx,
		ps.szdPhysicalPage_Inches.cy * szMosaic.cy
	};

	// OFFSET INTO PHYSICAL PAGE OF PRINTABLE AREA, IN INCHES
	POINTD ptdOffsetPrintable_Inches = {
		ps.ptlOffsetPrintable.x / ptdPageLogPixels.x,
		ps.ptlOffsetPrintable.y / ptdPageLogPixels.y
	};

	// PAGE PRINTABLE SIZE IN INCHES
	SIZED szdPrintablePage_Inches = {
		ps.szlPrintable.cx / ptdPageLogPixels.x,
		ps.szlPrintable.cy / ptdPageLogPixels.y
	};

	// TOTAL PRINTABLE MOSAIC SIZE IN INCHES
	SIZED szdPrintableMosaic_Inches = { 
		szdPrintablePage_Inches.cx * szMosaic.cx,
		szdPrintablePage_Inches.cy * szMosaic.cy
	};

	// OFFSET OF IMAGE SELECTION WITHIN TOTAL IMAGE
	POINTD ptdImageSelectionOffsetIntoTotal_Inches = {
		ss.rdSelection_Inches.left - ss.rdTotalImage_Inches.left,
		ss.rdSelection_Inches.top - ss.rdTotalImage_Inches.top
	};

	// TOTAL FREE PRINTABLE MOSAIC SIZE IN INCHES -- SPACE AVAILABLE FOR THE IMAGE ITSELF
	// APART FROM OVERLAPPING MARGINS, CUTTING GUIDES, AND EDGE MARGINS
	SIZED szdMargins_Inches;
	szdMargins_Inches.cy = ps.ms.rdEdgeMargins_Inches.top + ps.ms.rdEdgeMargins_Inches.bottom - 
		(ps.szdPhysicalPage_Inches.cy - szdPrintablePage_Inches.cy);
	if (!bAllHeight) {
		szdMargins_Inches.cy += 
			(szMosaic.cy - 1) * (ps.ms.dOverlapMargin_Inches + (rs.bCutGuides ? ps.ms.dCutGuideMargin_Inches : 0));
	}
	szdMargins_Inches.cx = ps.ms.rdEdgeMargins_Inches.left + ps.ms.rdEdgeMargins_Inches.right - 
		(ps.szdPhysicalPage_Inches.cx - szdPrintablePage_Inches.cx);
	if (!bAllWidth) {
		szdMargins_Inches.cx += 
			(szMosaic.cx - 1) * (ps.ms.dOverlapMargin_Inches + (rs.bCutGuides ? ps.ms.dCutGuideMargin_Inches : 0));
	}

	SIZED szdFreePrintableMosaic_Inches = {
		szdPrintableMosaic_Inches.cx - szdMargins_Inches.cx,
		szdPrintableMosaic_Inches.cy - szdMargins_Inches.cy
	};

	// IMAGE SELECTION SIZE IN INCHES
	SIZED szdImageSelection_Inches = { RW(ss.rdSelection_Inches), RH(ss.rdSelection_Inches) };

	// ZOOMED SELECTED IMAGE TOTAL SIZE IN INCHES
	double dZoom;
	if (szdImageSelection_Inches.cx * szdFreePrintableMosaic_Inches.cy <
		szdImageSelection_Inches.cy * szdFreePrintableMosaic_Inches.cx) {

		dZoom = szdFreePrintableMosaic_Inches.cy / szdImageSelection_Inches.cy;
		fulldim = RenderSpec::eY;
	} else {
		dZoom = szdFreePrintableMosaic_Inches.cx / szdImageSelection_Inches.cx;
		fulldim = RenderSpec::eX;
	}
	return dZoom;
}


BOOL GetPageSpec(
	OUT ::PageSpec &ps, 
	IN const ::MarginSpec& ms, 
	IN ::PCDEVMODE pdm, 
	LPCTSTR lptstrPrinterName, 
	IN BOOL bEvenMargins,
	IN BOOL bAllowNonStandardMargins 
) {
	BOOL bRetValue = FALSE;
	HDC hdc = ::CreateDC(pdm, TRUE);
	if (hdc != NULL) {
		POINT ptLogPix = { ::GetDeviceCaps(hdc, LOGPIXELSX), ::GetDeviceCaps(hdc, LOGPIXELSY) };

		ps.ptlOffsetPrintable.x = ::GetDeviceCaps(hdc, PHYSICALOFFSETX);
		ps.ptlOffsetPrintable.y = ::GetDeviceCaps(hdc, PHYSICALOFFSETY);
		ps.szlPhysicalPage.cx = ::GetDeviceCaps(hdc, PHYSICALWIDTH);
		ps.szlPhysicalPage.cy = ::GetDeviceCaps(hdc, PHYSICALHEIGHT);
		ps.szlPrintable.cx = ::GetDeviceCaps(hdc, HORZRES);
		ps.szlPrintable.cy = ::GetDeviceCaps(hdc, VERTRES);

		ps.szdPhysicalPage_Inches.cx = (double) ps.szlPhysicalPage.cx / ptLogPix.x;
		ps.szdPhysicalPage_Inches.cy = (double) ps.szlPhysicalPage.cy / ptLogPix.y;

		// 6/11
		DWORD dwLandscapeRot = ::DoDeviceCapabilites(lptstrPrinterName, pdm, DC_ORIENTATION, NULL);
		switch(dwLandscapeRot) {
		case 90:	ps.rotDir = ::LandscapeRot::e90;	break;
		case 270:	ps.rotDir = ::LandscapeRot::e270;	break;
		default:
			SHOULD(FALSE);
			// FALL THRU
		case 0:		ps.rotDir = ::LandscapeRot::eNone;	break;
		}
		// 6/4 ASSUMING FIELDS BIT INDICATES ABILITY TO SET THIS
		//ps.bReflected = (pdm->dmFields & DM_ORIENTATION) && (pdm->dmOrientation == DMORIENT_LANDSCAPE);
		ps.bLandscape = (ps.rotDir != ::LandscapeRot::eNone) &&
			(pdm->dmFields & DM_ORIENTATION) && (pdm->dmOrientation == DMORIENT_LANDSCAPE);

		// 6/4
		ps.ms = ms;
		// 7/1 MOVE OUT OF IF-BLOCK BELOW
		//RECTD& rd = ps.ms.rdEdgeMargins_Inches;
		if (ps.bLandscape) {
			::LandscapeRotate(ps.ms.rdEdgeMargins_Inches, ps.rotDir);
		}
		if (! bAllowNonStandardMargins) {
			::EnforceMinimumMargins(ps, bEvenMargins);
			// 7/1 MOVE INTO FN
			//RECTD rdMinEdgeMargins;
			//::GetMinimumPageMargins(rdMinEdgeMargins, ps);
	
			////if (ps.bReflected) {
			////	::Reflect(rd);
			////}
			//rd.left = max(rd.left, rdMinEdgeMargins.left);
			//rd.top = max(rd.top, rdMinEdgeMargins.top);
			//rd.right = max(rd.right, rdMinEdgeMargins.right);
			//rd.bottom = max(rd.bottom, rdMinEdgeMargins.bottom);
		}

		::DeleteDC(hdc);
		bRetValue = TRUE;
	}
	return bRetValue;
}

void EnforceMinimumMargins(IN OUT ::PageSpec &ps, IN BOOL bEvenMargins) {
	RECTD rdMinEdgeMargins;
	::GetMinimumPageMargins(rdMinEdgeMargins, ps);

	RECTD& rd = ps.ms.rdEdgeMargins_Inches;
	rd.left = max(rd.left, rdMinEdgeMargins.left);
	rd.top = max(rd.top, rdMinEdgeMargins.top);
	rd.right = max(rd.right, rdMinEdgeMargins.right);
	rd.bottom = max(rd.bottom, rdMinEdgeMargins.bottom);

	if (bEvenMargins) {
		rd.left = rd.right = max(rd.left, rd.right);
		rd.top = rd.bottom = max(rd.top, rd.bottom);
	}
}


double FindNextLargerMosaicSize(IN OUT SIZE& szMosaic, IN double dZoomCurrent,
							  IN const ::RenderSpec rs, IN const ::PageSpec& ps, IN const ::SourceSpec& ss) {
	double dZoomRetValue ;
	::RenderSpec::MosaicFullDimension fulldim;

	double dMosaicZoom = ::CalculateZoomFromMosaicSize(szMosaic, rs, ps, ss, fulldim);
	if (dMosaicZoom > dZoomCurrent) {
		dZoomRetValue = dMosaicZoom;
	} else {
		switch(fulldim) {
		case RenderSpec::eX: ++ szMosaic.cx; break;
		case RenderSpec::eY: ++ szMosaic.cy; break;
		default:
			ASSERTFAIL();
			break;
		}
		dZoomRetValue = ::CalculateZoomFromMosaicSize(szMosaic, rs, ps, ss, fulldim);
	}
	return dZoomRetValue;
}

double FindNextLargerMosaicSizeWithRotation(IN OUT SIZE& szMosaic, OUT BOOL& bRotate, IN double dZoomCurrent,
							  IN const ::RenderSpec rs, IN const ::PageSpec& ps, IN const ::SourceSpec& ss) {
	double dZoomRetValue;

	SIZE sz1 = szMosaic;
	double dZoom1 = ::FindNextLargerMosaicSize(sz1, dZoomCurrent, rs, ps, ss);

	::PageSpec psRot;
	//::ReflectPageSpec(psRot, ps);
	::LandscapeRotatePageSpec(psRot, ps);
	SIZE sz2 ;
	::CalculateMosaicSizeFromZoom(sz2, dZoomCurrent, rs, psRot, ss);
	double dZoom2 = ::FindNextLargerMosaicSize(sz2, dZoomCurrent, rs, psRot, ss);

	if (dZoom1 < dZoom2) {
		szMosaic = sz1;
		bRotate = FALSE;
		dZoomRetValue = dZoom1;
	} else {
		szMosaic = sz2;
		bRotate = TRUE;
		dZoomRetValue = dZoom2;
	}						
	return dZoomRetValue;
}

// 6/3 COMPLETELY CHANGED, SCREWED UP COMMENTING A BACKUP

double FindNextSmallerMosaicSize(OUT SIZE& szMosaic, 
								 IN const ::RenderSpec& rs, IN const ::PageSpec& ps, IN const ::SourceSpec& ss) {

	BOOL bX = FALSE;
	if (szMosaic.cx > 1) {
		SIZE szTemp = szMosaic;
		-- szTemp.cx;
		RenderSpec::MosaicFullDimension mfdTemp;
		double dZoomTemp = ::CalculateZoomFromMosaicSize(szTemp, rs, ps, ss, mfdTemp);
		SIZE szTemp2;
		::CalculateMosaicSizeFromZoom(szTemp2, dZoomTemp, rs, ps, ss);
		if (::EqualSz(szTemp, szTemp2)) {
			bX = (mfdTemp == RenderSpec::eX);
		}
	}

	BOOL bY = FALSE;
	if (szMosaic.cy > 1) {
		SIZE szTemp = szMosaic;
		-- szTemp.cy;
		RenderSpec::MosaicFullDimension mfdTemp;
		double dZoomTemp = ::CalculateZoomFromMosaicSize(szTemp, rs, ps, ss, mfdTemp);
		SIZE szTemp2;
		::CalculateMosaicSizeFromZoom(szTemp2, dZoomTemp, rs, ps, ss);
		if (::EqualSz(szTemp, szTemp2)) {
			bY = (mfdTemp == RenderSpec::eY);
		}
	}

	if (bX) {
		-- szMosaic.cx;
	} else if (bY) {
		-- szMosaic.cy;
	}

	RenderSpec::MosaicFullDimension mfd;
	double dZoomRetValue = ::CalculateZoomFromMosaicSize(szMosaic, rs, ps, ss, mfd);
	return dZoomRetValue;
}

double FindNextSmallerMosaicSizeWithRotation(IN OUT SIZE& szMosaic, OUT BOOL& bRotate, IN double dZoomCurrent,
							  IN const ::RenderSpec rs, IN const ::PageSpec& ps, IN const ::SourceSpec& ss) {
	double dZoomRetValue;

	SIZE sz1 = szMosaic;
	double dZoom1 = ::FindNextSmallerMosaicSize(sz1, rs, ps, ss);

	::PageSpec psRot;
	//::ReflectPageSpec(psRot, ps);
	::LandscapeRotatePageSpec(psRot, ps);
	SIZE sz2;
	// 6/1
	//::RenderSpec::MosaicFullDimension fulldim;
	//double dZoomTemp = ::CalculateZoomFromMosaicSize(szMosaic, rs, ps, ss, fulldim);
	double dZoomTemp = dZoomCurrent;
	::CalculateMosaicSizeFromZoom(sz2, dZoomTemp, rs, psRot, ss);
	double dZoom2 = ::FindNextSmallerMosaicSize(sz2, rs, psRot, ss);

	// 6/1 ADDED "|| dZoom2 >= dZoomCurrent) {"
	if (dZoom1 > dZoom2 && ! ::EqualSz(sz1, szMosaic) || dZoom2 >= dZoomCurrent) {
		szMosaic = sz1;
		bRotate = FALSE;
		dZoomRetValue = dZoom1;
	} else {
		szMosaic = sz2;
		bRotate = TRUE;
		dZoomRetValue = dZoom2;