extdevmode.cpp

虚拟打印机

			} else {
				::ZeroMemory(pdmOut->privdm.abAppLocalTargetPrinterDevmodeBuffer, sizeof(pdmOut->privdm.abAppLocalTargetPrinterDevmodeBuffer));
			}
		}
	
		if (pdmTargetIn != _pdmTargetIn) {
			::EXTDM_ReleaseTargetPrinterDevMode(pdmOut, pdmTargetIn);
		}
	} else {
		::ZeroMemory(pdmOut->privdm.abAppLocalTargetPrinterDevmodeBuffer, sizeof(pdmOut->privdm.abAppLocalTargetPrinterDevmodeBuffer));
		EXTDM_SetPublicDMFromTargetDM(pdmOut, &g_dmFallback);
	}
}

void EXTDM_SetToDefault(OUT PEXTDEVMODE pextdm, IN LPCTSTR lptstrPrinterName) {
	::ZeroMemory(pextdm, sizeof(*pextdm));

	//DM_Copy( (PDEVMODE) &gextdmStatic, (LPBYTE) pextdm );
	::EXTDM_SetPublicDMFromTargetDM(pextdm, &g_dmFallback);

	StringCchCopy(
		pextdm->dm.dmDeviceName,
		ARRCOUNT(pextdm->dm.dmDeviceName),
		lptstrPrinterName
		);
	LPTSTR lptstrTargetPrinter = ChooseTargetPrinterNameWithoutUserInput();
	// 6/25 CHANGED SO IT INTERPRETS A NULL NAME AS STRING OF ZERO LENGTH
	EXTDM_SetTargetPrinterName(pextdm, lptstrTargetPrinter);
	if (lptstrTargetPrinter != NULL) {
		free(lptstrTargetPrinter);
	}
}

size_t EXTDM_Sizeof(void) {
	return sizeof(EXTDEVMODE);
}

// **** 
// **** private:  EXTDEVMODE
// **** 

static PCPRIVDEVMODE EXTDM_GetPrivDM(PCEXTDEVMODE pdm) {
	PCPRIVDEVMODE pprivdm;

	ASSERT(EXTDM_IsAnExtDevMode( (PCDEVMODE) pdm));
	
	pprivdm = (PPRIVDEVMODE) ( (PCBYTE) pdm + pdm->dm.dmSize );
	return pprivdm;
}

static PDEVMODE EXTDM_GetTargetPrinterDevMode_Internal(IN PEXTDEVMODE pextdm) {
	ASSERT( ::EXTDM_IsAnExtDevMode( (PCDEVMODE) pextdm) );
	PDEVMODE pdmRetValue = 
		GetPrinterDevMode(pextdm->privdm.atstrTargetPrinterName, pextdm->privdm.abAppLocalTargetPrinterDevmodeBuffer);
	// DIDN'T WORK
	//// 6/11 NEW CODE:
	//::EXTDM_SetTargetDMFromPublicDM(pdmRetValue, pextdm);
	//::DoDocumentProperties(NULL, ::EXTDM_GetTargetPrinterName(pextdm), pdmRetValue, DM_IN_BUFFER | DM_OUT_BUFFER);
	//::EXTDM_SetPublicDMFromTargetDM(pextdm, pdmRetValue);

	return pdmRetValue;
}

// bCircular IS CALCULATED ALWAYS FOR THE PRINTER AT RECURSION LEVEL 0.
// THAT IS, AS WE GO DOWN IN TARGET PRINTERS, WE MAY COME ACROSS A CIRCLE, BUT THAT DOES NOT
// MAKE THE PRINTER AT RECURSION LEVEL 0 CIRCULAR UNLESS THE CIRCLE REFERS BACK TO IT.
// SO WE CAN HAVE ONE OF OUR PRINTERS HAVE A CIRCULAR SET OF PRINTERS AS A TARGET, BUT NOT
// BE CONSIDERED CIRCULAR ITSELF.  THE CIRCULAR SET OF PRINTERS WON'T USE GDI TO CALCULATE THEIR
// GDIINFO OR DEVCAPS, BUT ONE OF OUR PRINTERS THAT HAS THEM AS A TARGET WILL -- AND THIS WON'T
// RESULT IN INFINITE RECURSION IN THE GRAPHICS OR UI DLL'S.
static BOOL EXTDM_IsCircular_Internal(
	OUT BOOL& bCircular, 
	IN PCEXTDEVMODE pextdm, 
	IN OUT std::vector<PCEXTDEVMODE>& vextdm
) {
	BOOL bRetValue = FALSE;
	PCDEVMODE pdmTarget = EXTDM_GetTargetPrinterDevMode(pextdm, FALSE);
	if (pdmTarget != NULL) {
		if ( ::EXTDM_IsAnExtDevMode(pdmTarget) ) {
			BOOL bFound = FALSE;
			uint k;
			for(k = 0; k < vextdm.size(); ++k) {
				PCEXTDEVMODE pdmIter = vextdm[k];
				if ( ::lstrcmp(pdmIter->dm.dmDeviceName, pextdm->dm.dmDeviceName) == 0 &&
					 ::lstrcmp(EXTDM_GetTargetPrinterName(pdmIter), ::EXTDM_GetTargetPrinterName(pextdm)) == 0
				) {
					bFound = TRUE;
					break;
				}
			}
			if (bFound) {
				bCircular = (k == 0);
				bRetValue = TRUE;
			} else {
				// NOTE -- I DON'T KNOW HOW TO ERROR CHECK THIS FOR MEMORY FAILURE  DEBUG / FIX
				vextdm.push_back(pextdm);

				PCEXTDEVMODE pextdmTarget = (PCEXTDEVMODE) pdmTarget;
				bRetValue = ::EXTDM_IsCircular_Internal(bCircular, pextdmTarget, vextdm);
			}
		} else {
			bCircular = FALSE;
			bRetValue = TRUE;
		}
		::EXTDM_ReleaseTargetPrinterDevMode(pextdm, pdmTarget);
	}
	return bRetValue;
}

static void EXTDM_Merge(OUT PEXTDEVMODE pextdmOut, IN PCDEVMODE pdmIn, PCDEVMODE pdmTargetIn) {
	if (EXTDM_IsAnExtDevMode(pdmIn)) {
		PCPRIVDEVMODE pprivdmIn = EXTDM_GetPrivDM( (PCEXTDEVMODE) pdmIn);
		EXTDM_SetPrivateDM(pextdmOut, pprivdmIn, pdmTargetIn);
	}

	//// DEBUG - FIX NEED TO GET RID OF THIS
	//// WITH NORMAL TARGET, EVERYTHING IS DETERMINED BY THE TARGET

	//// NOTE -- WE SHOULD DEAL WITH THE CASE THAT pdmIn
	//// IS A DIFFERENT VERSION OF DEVMODE
	//// BUT THERE IS NOTHING TO DEAL WITH SO FAR
	//if (pdmIn->dmFields & DM_COPIES) {
	//	pextdmOut->dm.dmCopies = pdmIn->dmCopies;
	//	pextdmOut->dm.dmFields |= DM_COPIES;
	//}
}

static void EXTDM_SetPublicDMFromTargetDM(OUT PEXTDEVMODE pextdmOut, IN PCDEVMODE pdmIn) {
	// 6/23 THIS MADE NO SENSE, dmDeviceName IS A (TRUNCATED) PRINTER NAME, NOT A DRIVER NAME
	//StringCchCopy(
	//	pextdmOut->dm.dmDeviceName, 
	//	ARRCOUNT(pextdmOut->dm.dmDeviceName), 
	//	PRINTRESIZER_DRIVERNAME);

	pextdmOut->dm.dmSpecVersion = DM_SPECVERSION;
	// 6/21
	//pextdmOut->dm.dmDriverVersion = 0x100;
	pextdmOut->dm.dmDriverVersion = PRINTRESIZER_VERSION;
	pextdmOut->dm.dmSize = sizeof(pextdmOut->dm);
	pextdmOut->dm.dmDriverExtra = sizeof(PRIVDEVMODE);

	pextdmOut->dm.dmFields = pdmIn->dmFields;
	pextdmOut->dm.dmOrientation = pdmIn->dmOrientation;
	pextdmOut->dm.dmPaperSize = pdmIn->dmPaperSize;
	pextdmOut->dm.dmPaperLength = pdmIn->dmPaperLength;
	pextdmOut->dm.dmPaperWidth = pdmIn->dmPaperWidth;
	pextdmOut->dm.dmScale = pdmIn->dmScale;
	pextdmOut->dm.dmCopies = pdmIn->dmCopies;
	pextdmOut->dm.dmDefaultSource = pdmIn->dmDefaultSource;
	pextdmOut->dm.dmPrintQuality = pdmIn->dmPrintQuality;
	pextdmOut->dm.dmColor = pdmIn->dmColor;
	pextdmOut->dm.dmDuplex = pdmIn->dmDuplex;
	pextdmOut->dm.dmYResolution = pdmIn->dmYResolution;
	pextdmOut->dm.dmTTOption = pdmIn->dmTTOption;
	pextdmOut->dm.dmCollate = pdmIn->dmCollate;
	CopyMemory(pextdmOut->dm.dmFormName, pdmIn->dmFormName, sizeof(pextdmOut->dm.dmFormName));
	pextdmOut->dm.dmLogPixels = pdmIn->dmLogPixels;
	pextdmOut->dm.dmBitsPerPel = pdmIn->dmBitsPerPel;
	pextdmOut->dm.dmPelsWidth = pdmIn->dmPelsWidth;
	pextdmOut->dm.dmPelsHeight = pdmIn->dmPanningHeight;
	pextdmOut->dm.dmNup = pdmIn->dmNup;
	pextdmOut->dm.dmDisplayFrequency = 0;
	if (pdmIn->dmSize >= (WORD) GetDevModeV400Size()) {
		pextdmOut->dm.dmICMMethod = pdmIn->dmICMMethod;
		pextdmOut->dm.dmICMIntent = pdmIn->dmICMIntent;
		pextdmOut->dm.dmMediaType = pdmIn->dmMediaType;
		pextdmOut->dm.dmDitherType = pdmIn->dmDitherType;
	} else {
		pextdmOut->dm.dmICMMethod = 0;
		pextdmOut->dm.dmICMIntent = 0;
		pextdmOut->dm.dmMediaType = 0;
		pextdmOut->dm.dmDitherType = 0;
	}
	pextdmOut->dm.dmPanningWidth = 0;
	pextdmOut->dm.dmPanningHeight = 0;
}

static void EXTDM_SetPrivateDM(OUT PEXTDEVMODE pdmOut, IN PCPRIVDEVMODE pprivdmIn, PCDEVMODE pdmTargetIn) {
	::CopyMemory(pdmOut->privdm.abAppLocalTargetPrinterDevmodeBuffer,
		pprivdmIn->abAppLocalTargetPrinterDevmodeBuffer,
		sizeof(pdmOut->privdm.abAppLocalTargetPrinterDevmodeBuffer)
		);
	EXTDM_SetTargetPrinterName(pdmOut, pprivdmIn->atstrTargetPrinterName, pdmTargetIn);
}

static void EXTDM_SetTargetDMFromPublicDM(OUT PDEVMODE pdmOut, IN PCEXTDEVMODE pextdmIn) {
	pdmOut->dmFields = pextdmIn->dm.dmFields;
	pdmOut->dmOrientation = pextdmIn->dm.dmOrientation;
	pdmOut->dmPaperSize = pextdmIn->dm.dmPaperSize;
	pdmOut->dmPaperLength = pextdmIn->dm.dmPaperLength;
	pdmOut->dmPaperWidth = pextdmIn->dm.dmPaperWidth;
	pdmOut->dmScale = pextdmIn->dm.dmScale;
	pdmOut->dmCopies = pextdmIn->dm.dmCopies;
	pdmOut->dmDefaultSource = pextdmIn->dm.dmDefaultSource;
	pdmOut->dmPrintQuality = pextdmIn->dm.dmPrintQuality;
	pdmOut->dmColor = pextdmIn->dm.dmColor;
	pdmOut->dmDuplex = pextdmIn->dm.dmDuplex;
	pdmOut->dmYResolution = pextdmIn->dm.dmYResolution;
	pdmOut->dmTTOption = pextdmIn->dm.dmTTOption;
	pdmOut->dmCollate = pextdmIn->dm.dmCollate;
	CopyMemory(pdmOut->dmFormName, pextdmIn->dm.dmFormName, sizeof(pdmOut->dmFormName));
	pdmOut->dmLogPixels = pextdmIn->dm.dmLogPixels;
	pdmOut->dmBitsPerPel = pextdmIn->dm.dmBitsPerPel;
	pdmOut->dmPelsWidth = pextdmIn->dm.dmPelsWidth;
	pdmOut->dmPelsHeight = pextdmIn->dm.dmPanningHeight;
	pdmOut->dmNup = pextdmIn->dm.dmNup;
	pdmOut->dmDisplayFrequency = 0;
	if (pextdmIn->dm.dmSize >= (WORD) GetDevModeV400Size()) {
		pdmOut->dmICMMethod = pextdmIn->dm.dmICMMethod;
		pdmOut->dmICMIntent = pextdmIn->dm.dmICMIntent;
		pdmOut->dmMediaType = pextdmIn->dm.dmMediaType;
		pdmOut->dmDitherType = pextdmIn->dm.dmDitherType;
	} else {
		pdmOut->dmICMMethod = 0;
		pdmOut->dmICMIntent = 0;
		pdmOut->dmMediaType = 0;
		pdmOut->dmDitherType = 0;
	}
	pdmOut->dmPanningWidth = 0;
	pdmOut->dmPanningHeight = 0;
}


#if 0
void GetSpoolerTargetPrinterName(
	OUT LPTSTR lptstrTargetPrinterName,
	IN LPCTSTR lptstrPrinterName
	) {
	PDEVMODE pdm = GetPrinterDevMode(lptstrPrinterName);
	lptstrTargetPrinterName[0] = 0;
	if (pdm != NULL) {
		if (EXTDM_IsAnExtDevMode(pdm)) {
			PEXTDEVMODE pextdm = (PEXTDEVMODE) pdm;
			StringCchCopy(
				lptstrTargetPrinterName, 
				TARGETPRINTERNAME_MAX,
				::EXTDM_GetTargetPrinterName(pextdm)
				);
		}
		free(pdm);
	}
}
#endif

// **********************************************************************************
// **  PRIVATE ROUTINES  ************************************************************
// **********************************************************************************

static PDEVMODE GetPrinterDevMode(IN LPCTSTR lptstrPrinterName, PBYTE pBuff) {
	PDEVMODE pdmRetValue = NULL;
	PDEVMODE pdmCandidate = (PDEVMODE) pBuff;
	// 6/23
	// THIS SHOULD PROBABLY BE A TRUNCATED COMPARE (AT LEAST TO WORK IN MOST CASES)
	if (::wcsncmp(lptstrPrinterName, pdmCandidate->dmDeviceName, ARRCOUNT(pdmCandidate->dmDeviceName)-1) == 0) {
	//if (::_tcsncmp(lptstrPrinterName, pdmCandidate->dmDeviceName, ARRCOUNT(pdmCandidate->dmDeviceName)-1) == 0) {
	// if (::lstrcmp(lptstrPrinterName, pdmCandidate->dmDeviceName) == 0) {
		pdmRetValue = pdmCandidate;
	} else {
		pdmRetValue = ::GetPrinterDevMode(lptstrPrinterName);
	}
	return pdmRetValue;
}