uidriverentrypoints.cpp

虚拟打印机

/*
 * 
 * UIDriverEntryPoints.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 UIDRIVERENTRYPOINTS_C

#include "UIDriverEntryPoints.h"

#include "..\lib\debug.h"
#include "..\lib\extDevMode.h"
#include "..\lib\prcommandline.h"
#include "..\lib\prspoolerdatafile.h"
#include "..\lib\printResizerCommon.h"
#include "..\lib\prutils.h"
#include "..\lib\utils.h"
#include "..\lib\spoolutils.h"

#include <windows.h>
#include <wingdi.h>
#include <winspool.h>
#include <shellapi.h>
#include <prsht.h>
#include <winddi.h>
#include <winddiui.h>

#include <malloc.h>
#include <stdio.h>
#include <stdlib.h>
#include <tchar.h>
#include <strsafe.h>

#define PREVIEWAPP_STARTUPTIME_MAX			( (DWORD) 5 * 60 * 1000 )


// PUBLIC GLOBALS

HMODULE ghinstDLL;

// PROTOTYPES FOR MODULE'S PRIVATE UTILITIES
static BOOL CALLBACK EnumThreadWndProc(HWND hwnd, LPARAM lParam);

// PUBLIC ROUTINES

BOOL WINAPI DllMain(
  HINSTANCE hinstDLL,
  DWORD dwReason,
  LPVOID lpvReserved
  ) {

	if (dwReason == DLL_PROCESS_ATTACH) {
		ghinstDLL = hinstDLL;
	}
	return TRUE;
}

BOOL DevQueryPrintEx(
	PDEVQUERYPRINT_INFO  pDQPInfo
	) {
	// DEBUG/FIX -- supposed to check that print is possible given settings

	return TRUE;
}


// HERE IS APPARENTLY WHERE WE RESPOND TO INITIALIZATION
BOOL DrvPrinterEvent(
	LPWSTR  lpwstrPrinterName,
	INT  iEvent,
	DWORD  dwFlags,
	LPARAM  lParam
	) {
	BOOL bRetValue = TRUE;

    switch(iEvent) {

	case PRINTER_EVENT_INITIALIZE: {
		int k = 0;
		++k;
	} break;

	default:
		break;
	}

	return bRetValue;
}

/*
DrvDocumentEvent - printmirror uses this to grap the emf file
DrvDriverEvent 
*/

// 6/21 ADDED TO SEE IF THIS WILL CAUSE SPOOLER TO REPLACE
// DRIVER DLL'S WHEN NEWER (IN TERMS OF TIMESTAMP) ARE INSTALLED
BOOL
  DrvDriverEvent(
    DWORD  dwDriverEvent,
    DWORD  dwLevel,
    LPBYTE  pDriverInfo,
    LPARAM  lParam
	) {
	BOOL bRetValue = TRUE;
	switch(dwDriverEvent) {
	case DRIVER_EVENT_DELETE:
		bRetValue = TRUE;
		break;
	case DRIVER_EVENT_INITIALIZE:
		bRetValue = TRUE;
		break;
	default:
		break;
	}
	return bRetValue;
}


INT DrvDocumentEvent(
	HANDLE  hPrinter,
	HDC  hdc,
	int  iEsc,
	ULONG  ulcIn,
	PULONG  pulIn,
	ULONG  ulcOut,
	PULONG  pulOut
	) {
	INT retValue = DOCUMENTEVENT_SUCCESS;

	switch(iEsc) {
	case DOCUMENTEVENT_RESETDCPOST: 
	case DOCUMENTEVENT_CREATEDCPOST: {
		int k = 0;
		++k;
	} break;
	case DOCUMENTEVENT_RESETDCPRE: {
		int k = 0;
		++k;
	} break;
	case DOCUMENTEVENT_CREATEDCPRE: {
		int k = 0;
		++k;
	} break;
	case DOCUMENTEVENT_STARTPAGE: {
		int k = 0;
		++k;
	} break;
	case DOCUMENTEVENT_ENDPAGE: {
		int k = 0;
		++k;
	} break;
	case DOCUMENTEVENT_ENDDOC: {
		int k = 0;
		++k;
	} break;
	case DOCUMENTEVENT_DELETEDC: {
		int k = 0;
		++k;
	} break;
	case DOCUMENTEVENT_STARTDOC: {
		int k = 0;
		++k;
	} break;
	case DOCUMENTEVENT_STARTDOCPOST: {
		retValue = DOCUMENTEVENT_FAILURE;

		// DEBUG / FIX
		static BOOL bBreak = STATICBOOLBREAK;
		ASSERT(!bBreak);

		::PrintProcessorParameter ppp;
		::ZeroMemory(&ppp, sizeof(ppp));
		LPTSTR lptstrFullAppFileName = ::GetPreviewAppFullNameAndFullTempFileName(hPrinter,
			ppp.atstrFullTempFileName, ARRCOUNT(ppp.atstrFullTempFileName));

		if (lptstrFullAppFileName != NULL) {
			tstring tstrCommandLine;
			::MakeCommandLine(lptstrFullAppFileName, ::PrintPreviewDataSources::ePrintSpoolerDataFile,
				ppp.atstrFullTempFileName, tstrCommandLine);

			PROCESS_INFORMATION pi;
			STARTUPINFO si;
			ZeroMemory(&si, sizeof(si));
			si.cb = sizeof(si);
			ZeroMemory(&pi, sizeof(pi));

			BOOL bCreated = CreateProcess(
				lptstrFullAppFileName,
				const_cast<LPTSTR> (tstrCommandLine.c_str()),
				NULL,
				NULL,
				FALSE,
				0,
				NULL,
				NULL,
				&si,
				&pi
				);

			if (bCreated) {
				WaitForInputIdle(pi.hProcess, PREVIEWAPP_STARTUPTIME_MAX);
				EnumThreadWindows(pi.dwThreadId, EnumThreadWndProc, (LPARAM) &ppp.hwndPreviewApp);
				if (ppp.hwndPreviewApp != NULL) {
					TCHAR atstrParameter[PRINTPROCESSOR_PARAMTER_MAX_CCH+1];
					if (::WritePrintProcessorParameter(atstrParameter, ARRCOUNT(atstrParameter), ppp) != 0) {
						DWORD dwJobID = (DWORD) ((PLONG) pulIn)[0];
						DWORD dwcJobInfo = 0;
						PJOB_INFO_2 pji = GetJobInfo2(hPrinter, dwJobID, &dwcJobInfo); 
						if (pji != NULL) {
							size_t szParameter = ::StringBufferSize(atstrParameter);
							DWORD dwcNewJobInfo = dwcJobInfo + szParameter;
							PJOB_INFO_2 pjiNew = (PJOB_INFO_2) malloc(dwcNewJobInfo);
							if (pjiNew != NULL) {
								CopyMemory(pjiNew, pji, dwcJobInfo);
								CopyMemory( (LPBYTE) pjiNew + dwcJobInfo, atstrParameter, szParameter );

								pjiNew->pParameters = (LPTSTR) ( (LPBYTE) pjiNew + dwcJobInfo );
								pjiNew->Position = JOB_POSITION_UNSPECIFIED;
								if (SetJob(hPrinter, dwJobID, 2, (LPBYTE) pjiNew, 0)) {
									PEXTDEVMODE pextdm = (PEXTDEVMODE) pjiNew->pDevMode;
									LPTSTR lptstrPrinterName = ::GetPrinterName(hPrinter);
									if (lptstrPrinterName != NULL) {
										if (PRSpoolerDataFile::WriteUserInterfaceData(ppp.atstrFullTempFileName, 
																						lptstrPrinterName, pextdm)
										) {
											retValue = DOCUMENTEVENT_SUCCESS;
										}
										free(lptstrPrinterName);
									}
								} 
								free(pjiNew);
							} // if (pjiNew != NULL)
							free(pji);
						} // if (pji != NULL)
					}
				}
				// DEBUG/FIX - SHOUDL WE SetLastError ??
				if (retValue != DOCUMENTEVENT_SUCCESS) {
					if (ppp.hwndPreviewApp != NULL) {
						::PostMessage(ppp.hwndPreviewApp, WM_ABORTPRINTING, 0, 0);
					} else {
						::TerminateProcess(pi.hProcess, 0);
					}
				}
			} // if (bCreated)
			free(lptstrFullAppFileName);
		} // if (lptstrFullAppFileName != NULL)
	} break;
	case DOCUMENTEVENT_ENDDOCPOST: {
		int k = 0;
		++k;
	} break;
	default: {
		int k = 0;
		++k;
	} break;
	} // switch(iEsc)

	return retValue;
}


// DrvDriverEvent
#if 0
 DrvDocumentEvent
 DrvPrinterEvent
#endif


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

 static BOOL CALLBACK EnumThreadWndProc(          
	HWND hwnd,
    LPARAM lParam
	) {
	HWND *phwnd = (HWND *) lParam;
	*phwnd = hwnd;
	return FALSE;
 }