extdevmode.cpp

虚拟打印机

/*
 * 
 * extDevMode.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]
 */

#define EXTDEVMODE_C

#include "extDevMode.h"

//#include "devModeV351.h"
#include "devModeV400.h"
//#include "devModeV401.h"
#include "devmode.h"
#include "fallback.h"
#include "mathutils.h"
#include "printResizerCommon.h"
#include "prutils.h"
#include "spoolutils.h"
#include "utils.h"
#include "winstdforms.h"

#include <windows.h>
#include <winspool.h>
#include <tchar.h>
#include <strsafe.h>

#include <vector>

#include <malloc.h>


PDEVMODE GetPrinterDevMode(IN LPCTSTR lptstrPrinterName, PBYTE pBuff) ;

// **********************************************************************************
// **  EXTDEVMODE  ******************************************************************
// **********************************************************************************

struct PRIVDEVMODE {
	//DWORD dwMagic; 
	//DWORD dwVersion;
	TCHAR atstrTargetPrinterName[TARGETPRINTERNAME_MAX];
	
	// IF TARGET PRINTER DEVMODE IS TOO BIG TO FIT, WE USE THE SPOOLER'S VERSION
	// AND IT CAN'T BE CONFIGURED FROM OUR DOCUMENTPROPERTIES
	BYTE abAppLocalTargetPrinterDevmodeBuffer[PRINTRESIZER_MAX_TARGETPRINTER_DEVMODE_SIZE];
} ;

typedef PRIVDEVMODE *PPRIVDEVMODE;
typedef const PRIVDEVMODE* PCPRIVDEVMODE;

struct EXTDEVMODE {
	DEVMODE dm;
	PRIVDEVMODE privdm;
} ;

//typedef EXTDEVMODE *PEXTDEVMODE;
//typedef const EXTDEVMODE *PCEXTDEVMODE;

// CURRENTLY NOT BEING USED
#define EXTDEVMODE_MAGIC					0xae972ae3

void EXTDM_Init(PEXTDEVMODE pextdm);
PCPRIVDEVMODE EXTDM_GetPrivDM(PCEXTDEVMODE pextdm) ;
PDEVMODE EXTDM_GetTargetPrinterDevMode_Internal(IN PEXTDEVMODE pextdm) ;
BOOL EXTDM_IsCircular_Internal(
	OUT BOOL& bCircular, 
	IN PCEXTDEVMODE pextdm, 
	IN OUT std::vector<PCEXTDEVMODE>& vextdm
) ;
void EXTDM_Merge(OUT PEXTDEVMODE pextdmOut, IN PCDEVMODE pdmIn, PCDEVMODE pdmTargetIn = NULL) ;
void EXTDM_SetPublicDMFromTargetDM(OUT PEXTDEVMODE pdmOut, IN PCDEVMODE pdmIn) ;
void EXTDM_SetPrivateDM(OUT PEXTDEVMODE pdmOut, IN PCPRIVDEVMODE pprivdmIn, PCDEVMODE pdmTargetIn = NULL) ;
static void EXTDM_SetTargetDMFromPublicDM(OUT PDEVMODE pdmOut, IN PCEXTDEVMODE pextdmIn) ;

// **** 
// **** public:  EXTDEVMODE
// **** 

BOOL EXTDM_CanConfigureTargetPrinterDevMode(IN PCEXTDEVMODE pextdm) {
	BOOL bRetValue = FALSE;
	PCDEVMODE pdmTarget = ::EXTDM_GetTargetPrinterDevMode(pextdm);
	if (pdmTarget != NULL) {
		if ( (PCDEVMODE) pextdm->privdm.abAppLocalTargetPrinterDevmodeBuffer == pdmTarget ) {
			bRetValue = TRUE;
		}
		::EXTDM_ReleaseTargetPrinterDevMode(pextdm, pdmTarget);
	}
	return bRetValue;
}

void EXTDM_Delete(PEXTDEVMODE pextdm) {
	if (pextdm != NULL) {
		free(pextdm);
	}
}

LONG EXTDM_DoTargetPrinterDocumentProperties(PEXTDEVMODE pextdm, HWND hWnd) {
	LPCTSTR lptstrTargetPrinterName = ::EXTDM_GetTargetPrinterName(pextdm);
	LONG lRetValue = ::DoDocumentProperties(
		hWnd,
		lptstrTargetPrinterName,
		(PDEVMODE) pextdm->privdm.abAppLocalTargetPrinterDevmodeBuffer,
		DM_IN_BUFFER | DM_OUT_BUFFER | DM_PROMPT
		);
	::EXTDM_SetPublicDMFromTargetDM(pextdm, (PDEVMODE) pextdm->privdm.abAppLocalTargetPrinterDevmodeBuffer);
	return lRetValue;
}

DWORD EXTDM_Get_dmDriverExtra(void) {
	return sizeof(PRIVDEVMODE);
}

DWORD EXTDM_Get_dmSize(void) {
	return sizeof(DEVMODE);
}

DWORD EXTDM_Get_dmSpecVersion(void) {
	return DM_SPECVERSION;
}

PCDEVMODE EXTDM_GetTargetPrinterDevMode(IN PCEXTDEVMODE pextdm, BOOL bValidateUnsaved) {
	PDEVMODE pdm = ::EXTDM_GetTargetPrinterDevMode_Internal( const_cast<PEXTDEVMODE>(pextdm));

	//6/11 CHANGE
	if (bValidateUnsaved) {
		if (pdm != (PCDEVMODE) pextdm->privdm.abAppLocalTargetPrinterDevmodeBuffer) {
			// 6/23
			BOOL bCircular;
			if ( ::EXTDM_IsCircular(bCircular, pextdm) ) { // DEBUG / FIX -- THE //SERVER/NAME AND NAME ARE CONSID. DIFF!
				// 6/23
				// I THINK IF IT'S CIRCULAR THEN THE PUBLIC PORTIION IS ALL WE ARE DEALING WITH
				// AND THERE IS NO REASON TO TRY TO VALIDATE IT THRU ANYTHING (OR PROCESS) HERE
				// VALIDATION/MERGE OCCURS ELSEWHERE
				if (!bCircular) {
					::EXTDM_SetTargetDMFromPublicDM(pdm, pextdm);
					::DoDocumentProperties(NULL, ::EXTDM_GetTargetPrinterName(pextdm), pdm, DM_IN_BUFFER | DM_OUT_BUFFER);
				} else {
					// DEBUG - FIX - HERE ISWHY LANDSCAPSE ISN'T WORKING, IF CIRCULAR WE NEED 
					//TO EITHER MERGE OR SETAPPDEVMODE ON THE RETURN USEING OUR INPUT pextdm 
					// DO FALLBACK MERGE
					::Fallback_Merge(pdm, &pextdm->dm);
				}
			} else {
				// ERROR -- WE COULDN'T CHECK IF TARGET REFERENCE IS ULTIMATELY CIRCULAR
				if (pdm != NULL) {
					::EXTDM_ReleaseTargetPrinterDevMode(pextdm, pdm);
					pdm = NULL;
				}
			}
		}
	}

	return pdm;
}

LPCTSTR EXTDM_GetTargetPrinterName(IN PCEXTDEVMODE pextdm) {
	return pextdm->privdm.atstrTargetPrinterName;
}

BOOL EXTDM_IsAnExtDevMode(IN PCDEVMODE pdm) {
	if (pdm != NULL && pdm->dmDriverExtra == sizeof(PRIVDEVMODE)) {
		return TRUE;
	}
	return FALSE;
}

// 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.
BOOL EXTDM_IsCircular(OUT BOOL& bCircular, IN PCEXTDEVMODE pextdm) {
	std::vector<PCEXTDEVMODE> vextdm;
	BOOL bRetValue = EXTDM_IsCircular_Internal(bCircular, pextdm, vextdm); 
	return bRetValue;
}

PEXTDEVMODE EXTDM_New(void) {
	PEXTDEVMODE pextdm = (PEXTDEVMODE) malloc(sizeof(EXTDEVMODE));
	return pextdm;
}

void EXTDM_ReleaseTargetPrinterDevMode(IN PCEXTDEVMODE pextdm, IN PCDEVMODE pdmTargetPrinter) {
	if (pdmTargetPrinter != (PCDEVMODE) pextdm->privdm.abAppLocalTargetPrinterDevmodeBuffer) {
		free( const_cast<PDEVMODE>(pdmTargetPrinter));
	}
}

void EXTDM_SetAppDevMode(OUT PEXTDEVMODE pextdmOut, IN PCDEVMODE pdmIn, IN LPCTSTR lptstrPrinterName) {
	PDEVMODE pdmTemp = NULL;

	EXTDM_SetToDefault(pextdmOut, lptstrPrinterName);

	pdmTemp = GetPrinterDevMode(lptstrPrinterName);
	if (pdmTemp != NULL) {
		EXTDM_Merge(pextdmOut, pdmTemp);
		free(pdmTemp);	
	} 

	if (pdmIn != NULL) { 
		if (::EXTDM_IsAnExtDevMode(pdmIn)) {
			PEXTDEVMODE pextdmIn = (PEXTDEVMODE) pdmIn;
			BOOL bCircular;
			if (::EXTDM_IsCircular(bCircular, pextdmIn)) {
				if (!bCircular) {
					PDEVMODE pdmTargetIn = ::EXTDM_GetTargetPrinterDevMode_Internal(pextdmIn);
					if (pdmTargetIn != NULL) {
						::EXTDM_SetTargetDMFromPublicDM(pdmTargetIn, pextdmIn);
						::DoDocumentProperties(NULL, pextdmIn->privdm.atstrTargetPrinterName, 
							pdmTargetIn, DM_IN_BUFFER | DM_OUT_BUFFER);
					}
					EXTDM_Merge(pextdmOut, pdmIn, pdmTargetIn);

					if (pdmTargetIn != NULL) {
						::EXTDM_ReleaseTargetPrinterDevMode( (PEXTDEVMODE) pdmIn, pdmTargetIn );
					}
				} else {
					// DO FALLBACK MERGE
					::Fallback_Merge(& pextdmOut->dm, pdmIn);
				}
			}
		}
 
	}
}

void EXTDM_SetTargetPrinterName(OUT PEXTDEVMODE pdmOut, IN LPCTSTR lptstrTargetPrinterName, PCDEVMODE _pdmTargetIn) {
	StringCchCopy(
		pdmOut->privdm.atstrTargetPrinterName,
		ARRCOUNT(pdmOut->privdm.atstrTargetPrinterName),
		( lptstrTargetPrinterName != NULL ? lptstrTargetPrinterName : TEXT("") )
		);

	//PDEVMODE pdmTargetIn = GetPrinterDevMode(lptstrTargetPrinterName, pdmOut->privdm.abAppLocalTargetPrinterDevmodeBuffer);
	// 6/11 CHANGE (AND TO GETTARGETPRINTERDEVMODE)
	PCDEVMODE pdmTargetIn = (_pdmTargetIn == NULL) ? ::EXTDM_GetTargetPrinterDevMode(pdmOut, FALSE) : _pdmTargetIn ;

	if (pdmTargetIn != NULL) {
		EXTDM_SetPublicDMFromTargetDM(pdmOut, pdmTargetIn);

		if (pdmTargetIn != (PDEVMODE) pdmOut->privdm.abAppLocalTargetPrinterDevmodeBuffer) {
			DWORD dwCbTargetDevMode = ::DM_GetTotalSize(pdmTargetIn);
			if (dwCbTargetDevMode <= sizeof(pdmOut->privdm.abAppLocalTargetPrinterDevmodeBuffer)) {
				::CopyMemory( pdmOut->privdm.abAppLocalTargetPrinterDevmodeBuffer, pdmTargetIn, dwCbTargetDevMode );