/*++
Copyright (c) 1996 Microsoft Corporation
Module Name:
enable.c
Abstract:
Implementation of device and surface related DDI entry points:
DrvEnableDriver
DrvDisableDriver
DrvEnablePDEV
DrvResetPDEV
DrvCompletePDEV
DrvDisablePDEV
DrvEnableSurface
DrvDisableSurface
DrvBitBlt
DrvStretchBlt
DrvDitherColor
DrvEscape
Environment:
Fax driver, kernel mode
Revision History:
01/09/96 -davidx-
Created it.
mm/dd/yy -author-
description
--*/
#include "faxdrv.h"
#include "forms.h"
//
// Our DRVFN table which tells the engine where to find the routines we support.
//
static DRVFN FaxDriverFuncs[] =
{
{ INDEX_DrvEnablePDEV, (PFN) DrvEnablePDEV },
{ INDEX_DrvResetPDEV, (PFN) DrvResetPDEV },
{ INDEX_DrvCompletePDEV, (PFN) DrvCompletePDEV },
{ INDEX_DrvDisablePDEV, (PFN) DrvDisablePDEV },
{ INDEX_DrvEnableSurface, (PFN) DrvEnableSurface },
{ INDEX_DrvDisableSurface, (PFN) DrvDisableSurface },
{ INDEX_DrvStartDoc, (PFN) DrvStartDoc },
{ INDEX_DrvEndDoc, (PFN) DrvEndDoc },
{ INDEX_DrvStartPage, (PFN) DrvStartPage },
{ INDEX_DrvSendPage, (PFN) DrvSendPage },
{ INDEX_DrvBitBlt, (PFN) DrvBitBlt },
{ INDEX_DrvStretchBlt, (PFN) DrvStretchBlt },
{ INDEX_DrvCopyBits, (PFN) DrvCopyBits },
{ INDEX_DrvDitherColor, (PFN) DrvDitherColor },
{ INDEX_DrvEscape, (PFN) DrvEscape },
};
//
// Forward declaration of local functions
//
VOID SelectPrinterForm(PDEVDATA);
BOOL FillDevInfo(PDEVDATA, ULONG, PVOID);
BOOL FillGdiInfo(PDEVDATA, ULONG, PVOID);
VOID FreeDevData(PDEVDATA);
HINSTANCE ghInstance;
BOOL
DllEntryPoint(
HANDLE hModule,
ULONG ulReason,
PCONTEXT pContext
)
/*++
Routine Description:
DLL initialization procedure.
Arguments:
hModule - DLL instance handle
ulReason - Reason for the call
pContext - Pointer to context (not used by us)
Return Value:
TRUE if DLL is initialized successfully, FALSE otherwise.
--*/
{
switch (ulReason)
{
case DLL_PROCESS_ATTACH:
ghInstance = hModule;
break;
case DLL_PROCESS_DETACH:
break;
}
return TRUE;
}
BOOL
DrvQueryDriverInfo(
DWORD dwMode,
PVOID pBuffer,
DWORD cbBuf,
PDWORD pcbNeeded
)
/*++
Routine Description:
Query driver information
Arguments:
dwMode - Specify the information being queried
pBuffer - Points to output buffer
cbBuf - Size of output buffer in bytes
pcbNeeded - Return the expected size of output buffer
Return Value:
TRUE if successful, FALSE if there is an error
--*/
{
switch (dwMode)
{
case DRVQUERY_USERMODE:
Assert(pcbNeeded != NULL);
*pcbNeeded = sizeof(DWORD);
if (pBuffer == NULL || cbBuf < sizeof(DWORD))
{
SetLastError(ERROR_INSUFFICIENT_BUFFER);
return FALSE;
}
*((PDWORD) pBuffer) = TRUE;
return TRUE;
default:
Error(("Unknown dwMode in DrvQueryDriverInfo: %d\n", dwMode));
SetLastError(ERROR_INVALID_PARAMETER);
return FALSE;
}
}
BOOL
DrvEnableDriver(
ULONG iEngineVersion,
ULONG cb,
PDRVENABLEDATA pDrvEnableData
)
/*++
Routine Description:
Implementation of DDI entry point DrvEnableDriver.
Please refer to DDK documentation for more details.
Arguments:
iEngineVersion - Specifies the DDI version number that GDI is written for
cb - Size of the buffer pointed to by pDrvEnableData
pDrvEnableData - Points to an DRVENABLEDATA structure
Return Value:
TRUE if successful, FALSE if there is an error
--*/
{
Verbose(("Entering DrvEnableDriver...\n"));
//
// Make sure we have a valid engine version and
// we're given enough room for the DRVENABLEDATA.
//
if (iEngineVersion < DDI_DRIVER_VERSION || cb < sizeof(DRVENABLEDATA)) {
Error(("DrvEnableDriver failed\n"));
SetLastError(ERROR_BAD_DRIVER_LEVEL);
return FALSE;
}
//
// Fill in the DRVENABLEDATA structure for the engine.
//
pDrvEnableData->iDriverVersion = DDI_DRIVER_VERSION;
pDrvEnableData->c = sizeof(FaxDriverFuncs) / sizeof(DRVFN);
pDrvEnableData->pdrvfn = FaxDriverFuncs;
return TRUE;
}
DHPDEV
DrvEnablePDEV(
PDEVMODE pdm,
PWSTR pLogAddress,
ULONG cPatterns,
HSURF *phsurfPatterns,
ULONG cjGdiInfo,
ULONG *pGdiInfo,
ULONG cjDevInfo,
DEVINFO *pDevInfo,
HDEV hdev,
PWSTR pDeviceName,
HANDLE hPrinter
)
/*++
Routine Description:
Implementation of DDI entry point DrvEnablePDEV.
Please refer to DDK documentation for more details.
Arguments:
pdm - Points to a DEVMODE structure that contains driver data
pLogAddress - Points to the logical address string
cPatterns - Specifies the number of standard patterns
phsurfPatterns - Buffer to hold surface handles to standard patterns
cjGdiInfo - Size of GDIINFO buffer
pGdiInfo - Points to a GDIINFO structure
cjDevInfo - Size of DEVINFO buffer
pDevInfo - Points to a DEVINFO structure
hdev - GDI device handle
pDeviceName - Points to device name string
hPrinter - Spooler printer handle
Return Value:
Driver device handle, NULL if there is an error
--*/
{
PDEVDATA pdev;
Verbose(("Entering DrvEnablePDEV...\n"));
//
// Allocate memory for our DEVDATA structure and initialize it
//
if (! (pdev = MemAllocZ(sizeof(DEVDATA)))) {
Error(("Memory allocation failed\n"));
return NULL;
}
pdev->hPrinter = hPrinter;
pdev->startDevData = pdev;
pdev->endDevData = pdev;
//
// Save and validate DEVMODE information
// start with the driver default
// then merge with the system default
// finally merge with the input devmode
//
if (CurrentVersionDevmode(pdm)) {
memcpy(&pdev->dm, pdm, sizeof(DRVDEVMODE));
//
// NOTE: We now use dmPrintQuality and dmYResolution fields
// to store the resolution measured in dots-per-inch. Add
// the following check as a safety precaution in case older
// DEVMODE is passed to us.
//
if (pdev->dm.dmPublic.dmPrintQuality <= 0 ||
pdev->dm.dmPublic.dmYResolution <= 0)
{
pdev->dm.dmPublic.dmPrintQuality = FAXRES_HORIZONTAL;
pdev->dm.dmPublic.dmYResolution = FAXRES_VERTICAL;
}
} else {
Error(("Bad DEVMODE passed to DrvEnablePDEV\n"));
DriverDefaultDevmode(&pdev->dm, NULL, hPrinter);
}
//
// Calculate the paper size information
//
SelectPrinterForm(pdev);
//
// Fill out GDIINFO and DEVINFO structure
//
if (! FillGdiInfo(pdev, cjGdiInfo, pGdiInfo) ||
! FillDevInfo(pdev, cjDevInfo, pDevInfo))
{
FreeDevData(pdev);
return NULL;
}
//
// Zero out the array of HSURF's so that the engine will
// automatically simulate the standard patterns for us
//
memset(phsurfPatterns, 0, sizeof(HSURF) * cPatterns);
//
// Return a pointer to our DEVDATA structure
//
return (DHPDEV) pdev;
}
BOOL
DrvResetPDEV(
DHPDEV dhpdevOld,
DHPDEV dhpdevNew
)
/*++
Routine Description:
Implementation of DDI entry point DrvResetPDEV.
Please refer to DDK documentation for more details.
Arguments:
phpdevOld - Driver handle to the old device
phpdevNew - Driver handle to the new device
Return Value:
TRUE if successful, FALSE if there is an error
--*/
{
PDEVDATA pdevOld, pdevNew;
Verbose(("Entering DrvResetPDEV...\n"));
//
// Validate both old and new device
//
pdevOld = (PDEVDATA) dhpdevOld;
pdevNew = (PDEVDATA) dhpdevNew;
if (! ValidDevData(pdevOld) || ! ValidDevData(pdevNew)) {
Error(("ValidDevData failed\n"));
SetLastError(ERROR_INVALID_PARAMETER);
return FALSE;
}
Verbose(("Entering DrvResetPDEV...\n"));
//
// Transfer information from old device to new device
//
if (pdevOld->pageCount != 0) {
pdevNew->pageCount = pdevOld->pageCount;
pdevNew->flags |= PDEV_RESETPDEV;
pdevNew->fileOffset = pdevOld->fileOffset;
if (pdevOld->pFaxIFD) {
pdevNew->pFaxIFD = pdevOld->pFaxIFD;
pdevOld->pFaxIFD = NULL;
}
}
//
// Carry over relevant flag bits
//
pdevNew->flags |= pdevOld->flags & PDEV_CANCELLED;
return TRUE;
}
VOID
DrvCompletePDEV(
DHPDEV dhpdev,
HDEV hdev
)
/*++
Routine Description:
Implementation of DDI entry point DrvCompletePDEV.
Please refer to DDK documentation for more details.
Arguments:
dhpdev - Driver device handle
hdev - GDI device handle
Return Value:
NONE
--*/
{
PDEVDATA pdev = (PDEVDATA) dhpdev;
Verbose(("Entering DrvCompletePDEV...\n"));
if (! ValidDevData(pdev)) {
Assert(FALSE);
return;
}
//
// Remember the engine's handle to the physical device
//
pdev->hdev = hdev;
}
HSURF
DrvEnableSurface(
DHPDEV dhpdev
)
/*++
Routine Description:
Implementation of DDI entry point DrvEnableSurface.
Please refer to DDK documentation for more details.
Arguments:
dhpdev - Driver device handle
Return Value:
Handle to newly created surface, NULL if there is an error
--*/
{
PDEVDATA pdev = (PDEVDATA) dhpdev;
FLONG flHooks;
Verbose(("Entering DrvEnableSurface...\n"));
//
// Validate the pointer to our DEVDATA structure
//
if (! ValidDevData(pdev)) {
Error(("ValidDevData failed\n"));
SetLastError(ERROR_INVALID_PARAMETER);
return NULL;
}
//
// Adjust the bitmap size so that we always end up with 1728 pixels per scanline
//
Assert(MAX_WIDTH_PIXELS % DWORDBITS == 0);
if (IsLandscapeMode(pdev)) {
Assert(pdev->imageSize.cy <= MAX_WIDTH_PIXELS);
pdev->imageSize.cy = MAX_WIDTH_PIXELS;
pdev->imageSize.cx = ((pdev->imageSize.cx + (BYTEBITS - 1)) / BYTEBITS) * BYTEBITS;
} else {
Assert(pdev->imageSize.cx <= MAX_WIDTH_PIXELS);
pdev->imageSize.cx = MAX_WIDTH_PIXELS;
}
pdev->lineOffset = PadBitsToBytes(pdev->imageSize.cx, sizeof(DWORD));
//
// Call the engine to create a standard bitmap surface for us
//
pdev->hbitmap = (HSURF) EngCreateBitmap(pdev->imageSize,
pdev->lineOffset,
BMF_1BPP,
BMF_TOPDOWN | BMF_NOZEROINIT | BMF_USERMEM,
NULL);
if (pdev->hbitmap == NULL) {
Error(("EngCreateBitmap failed\n"));
return NULL;
}
//
// Associate the surface with the device and inform the
// engine which functions we have hooked out
//
if (pdev->dm.dmPrivate.flags & FAXDM_NO_HALFTONE)
flHooks = 0;
else
flHooks = (HOOK_STRETCHBLT | HOOK_BITBLT | HOOK_COPYBITS);
EngAssociateSurface(pdev->hbitmap, pdev->hdev, flHooks);
//
// Return the surface handle to the engine
//
return pdev->hbitmap;
}
VOID
DrvDisableSurface(
DHPDEV dhpdev
)
/*++
Routine Description:
Implementation of DDI entry point DrvDisableSurface.
Please refer to DDK documentation for more details.
Arguments:
dhpdev - Driver device handle
Return Value:
NONE
--*/
{
PDEVDATA pdev = (PDEVDATA) dhpdev;
Verbose(("Entering DrvDisableSurface...\n"));
if (! ValidDevData(pdev)) {
Assert(FALSE);
return;
}
//
// Call the engine to delete the surface handle
//
if (pdev->hbitmap != NULL) {
EngDeleteSurface(pdev->hbitmap);
pdev->hbitmap = NULL;
}
}
VOID
DrvDisablePDEV(
DHPDEV dhpdev
)
/*++
Routine Description:
Implementation of DDI entry point DrvDisablePDEV.
Please refer to DDK documentation for more details.
Arguments:
dhpdev - Driver device handle
Return Value:
NONE
--*/
{
PDEVDATA pdev = (PDEVDATA) dhpdev;
Verbose(("Entering DrvDisablePDEV...\n"));
if (! ValidDevData(pdev)) {
Assert(FALSE);
return;
}
//
// Free up memory allocated for the current PDEV
//
FreeDevData(pdev);
}
VOID
DrvDisableDriver(
VOID
)
/*++
Routine Description:
Implementation of DDI entry point DrvDisableDriver.
Please refer to DDK documentation for more details.
Arguments:
NONE
Return Value:
NONE
--*/
{
Verbose(("Entering DrvDisableDriver...\n"));
}
BOOL
IsCompatibleSurface(
SURFOBJ *psoDst,
SURFOBJ *psoSrc,
XLATEOBJ *pxlo
)
/*++
Routine Description:
Check if the source surface is compatible with the destination surface
i.e. we can bitblt without halftonig
Arguments:
psoDst - Specifies the destination surface
psoSrc - Specifies the source surface
pxlo - How to transform colors between the source surface and the destination surface
Return Value:
TRUE if the source surface is compatible with the destination surface
FALSE otherwise
--*/
{
BOOL result;
//
// We know our destination surface is always 1bpp
//
Assert(psoDst->iBitmapFormat == BMF_1BPP);
//
// Check whether the transformation is trivial
//
if (!pxlo || (pxlo->flXlate & XO_TRIVIAL)) {
result = (psoSrc->iBitmapFormat == psoDst->iBitmapFormat);
} else if ((pxlo->flXlate & XO_TABLE) && pxlo->cEntries <= 2) {
ULONG srcPalette[2];
srcPalette[0] = srcPalette[1] = RGB_BLACK;
XLATEOBJ_cGetPalette(pxlo, XO_SRCPALETTE, pxlo->cEntries, srcPalette);
result = (srcPalette[0] == RGB_BLACK || srcPalette[0] == RGB_WHITE) &&
(srcPalette[1] == RGB_BLACK || srcPalette[1] == RGB_WHITE);
} else
result = FALSE;
return result;
}
BOOL
DrvCopyBits(
SURFOBJ *psoTrg,
SURFOBJ *psoSrc,
CLIPOBJ *pco,
XLATEOBJ *pxlo,
RECTL *prclDst,
POINTL *pptlSrc
)
/*++
Routine Description:
Implementation of DDI entry point DrvCopyBits.
We need to hook out this function. Otherwise bitmaps won't be halftoned.
Arguments:
Please refer to DDK documentation for more details.
Return Value:
TRUE if successful, FALSE otherwise
--*/
{
Verbose(("Entering DrvCopyBits ...\n"));
//
// Check if halftoning is necessary
// If not, let the engine handle it
//
if ((psoSrc->iType != STYPE_BITMAP) ||
(psoTrg->iType != STYPE_BITMAP) ||
IsCompatibleSurface(psoTrg, psoSrc, pxlo))
{
return EngCopyBits(psoTrg, psoSrc, pco, pxlo, prclDst, pptlSrc);
}
else
{
POINTL ptlBrushOrg;
RECTL rclDst, rclSrc;
ptlBrushOrg.x = ptlBrushOrg.y = 0;
rclDst = *prclDst;
rclSrc.left = pptlSrc->x;
rclSrc.top = pptlSrc->y;
rclSrc.right = rclSrc.left + (rclDst.right - rclDst.left);
rclSrc.bottom = rclSrc.top + (rclDst.bottom - rclDst.top);
if ((rclSrc.right > psoSrc->sizlBitmap.cx) ||
(rclSrc.bottom > psoSrc->sizlBitmap.cy))
{
rclSrc.right = psoSrc->sizlBitmap.cx;
rclSrc.bottom = psoSrc->sizlBitmap.cy;
rclDst.right = rclDst.left + (rclSrc.right - rclSrc.left);
rclDst.bottom = rclDst.top + (rclSrc.bottom - rclSrc.top);
}
return EngStretchBlt(psoTrg,
psoSrc,
NULL,
pco,
pxlo,
&DefHTClrAdj,
&ptlBrushOrg,
&rclDst,
&rclSrc,
NULL,
HALFTONE);
}
}
BOOL
DrvBitBlt(
SURFOBJ *psoTrg,
SURFOBJ *psoSrc,
SURFOBJ *psoMask,
CLIPOBJ *pco,
XLATEOBJ *pxlo,
RECTL *prclTrg,
POINTL *pptlSrc,
POINTL *pptlMask,
BRUSHOBJ *pbo,
POINTL *pptlBrush,
ROP4 rop4
)
/*++
Routine Description:
Implementation of DDI entry point DrvBitBlt.
We need to hook out this function. Otherwise bitmaps won't be halftoned.
Arguments:
Please refer to DDK documentation for more details.
Return Value:
TRUE if successful, FALSE otherwise
--*/
{
COLORADJUSTMENT *pca;
PDEVDATA pdev;
DWORD rop3Foreground, rop3Background;
SURFOBJ *psoNewSrc;
HBITMAP hbmpNewSrc;
POINTL brushOrg;
BOOL result;
Verbose(("Entering DrvBitBlt...\n"));
//
// Validate input parameters
//
Assert(psoTrg != NULL);
pdev = (PDEVDATA) psoTrg->dhpdev;
if (! ValidDevData(pdev)) {
Error(("ValidDevData failed\n"));
SetLastError(ERROR_INVALID_PARAMETER);
return FALSE;
}
//
// Use the system default color adjustment information
//
pca = &DefHTClrAdj;
//
// Figure out the foreground and background ROP3
//
psoNewSrc = NULL;
hbmpNewSrc = NULL;
rop3Foreground = GetForegroundRop3(rop4);
rop3Background = GetBackgroundRop3(rop4);
if ((Rop3NeedPattern(rop3Foreground) || Rop3NeedPattern(rop3Background)) && pptlBrush) {
brushOrg = *pptlBrush;
} else {
brushOrg.x = brushOrg.y = 0;
}
//
// If a source bitmap is involved in the raster operation and
// the source is not compatible with the destination surface,
// then we'll halftone the source bitmap into a new bitmap and
// bitblt the new bitmap onto the destination surface.
//
if ((Rop3NeedSource(rop3Foreground) || Rop3NeedSource(rop3Background)) &&
!IsCompatibleSurface(psoTrg, psoSrc, pxlo))
{
RECTL rclNewSrc, rclOldSrc;
SIZEL bmpSize;
LONG lDelta;
rclNewSrc.left = rclNewSrc.top = 0;
rclNewSrc.right = prclTrg->right - prclTrg->left;
rclNewSrc.bottom = prclTrg->bottom - prclTrg->top;
rclOldSrc.left = pptlSrc->x;
rclOldSrc.top = pptlSrc->y;
rclOldSrc.right = rclOldSrc.left + rclNewSrc.right;
rclOldSrc.bottom = rclOldSrc.top + rclNewSrc.bottom;
//
// Express path for the most common case: SRCCOPY
//
if (rop4 == 0xcccc) {
return EngStretchBlt(psoTrg,
psoSrc,
psoMask,
pco,
pxlo,
pca,
&brushOrg,
prclTrg,
&rclOldSrc,
pptlMask,
HALFTONE);
}
//
// Modify the brush origin, because when we blt to the clipped bitmap
// the origin is at bitmap's (0, 0) minus the original location
//
brushOrg.x -= prclTrg->left;
brushOrg.y -= prclTrg->top;
//
// Create a temporary bitmap surface
// Halftone the source bitmap into the temporary bitmap
//
Assert(psoTrg->iBitmapFormat == BMF_1BPP);
bmpSize.cx = rclNewSrc.right;
bmpSize.cy = rclNewSrc.bottom;
lDelta = PadBitsToBytes(bmpSize.cx, sizeof(DWORD));
if (! (hbmpNewSrc = EngCreateBitmap(bmpSize,
lDelta,
BMF_1BPP,
BMF_TOPDOWN | BMF_NOZEROINIT,
NULL)) ||
! EngAssociateSurface((HSURF) hbmpNewSrc, pdev->hdev, 0) ||
! (psoNewSrc = EngLockSurface((HSURF) hbmpNewSrc)) ||
! EngStretchBlt(psoNewSrc,
psoSrc,
NULL,
NULL,
pxlo,
pca,
&brushOrg,
&rclNewSrc,
&rclOldSrc,
NULL,
HALFTONE))
{
if (psoNewSrc)
EngUnlockSurface(psoNewSrc);
if (hbmpNewSrc)
EngDeleteSurface((HSURF) hbmpNewSrc);
return FALSE;
}
//
// Proceed to bitblt from the temporary bitmap to the destination
//
psoSrc = psoNewSrc;
pptlSrc = (PPOINTL) &rclNewSrc.left;
pxlo = NULL;
brushOrg.x = brushOrg.y = 0;
}
//
// Let engine do the work
//
result = EngBitBlt(psoTrg,
psoSrc,
psoMask,
pco,
pxlo,
prclTrg,
pptlSrc,
pptlMask,
pbo,
&brushOrg,
rop4);
//
// Clean up properly before returning
//
if (psoNewSrc)
EngUnlockSurface(psoNewSrc);
if (hbmpNewSrc)
EngDeleteSurface((HSURF) hbmpNewSrc);
return result;
}
BOOL
DrvStretchBlt(
SURFOBJ *psoDest,
SURFOBJ *psoSrc,
SURFOBJ *psoMask,
CLIPOBJ *pco,
XLATEOBJ *pxlo,
COLORADJUSTMENT *pca,
POINTL *pptlBrushOrg,
RECTL *prclDest,
RECTL *prclSrc,
POINTL *pptlMask,
ULONG iMode
)
/*++
Routine Description:
Implementation of DDI entry point DrvDisableDriver.
We need to hook out this function. Otherwise bitmaps won't be halftoned.
Arguments:
Please refer to DDK documentation for more details.
Return Value:
TRUE if successful, FALSE if there is an error
--*/
{
Verbose(("Entering DrvStretchBlt...\n"));
//
// If no color adjustment information is provided, use the system default
//
if (pca == NULL)
pca = &DefHTClrAdj;
//
// Let engine do the work; make sure halftone is enabled
//
return EngStretchBlt(psoDest,
psoSrc,
psoMask,
pco,
pxlo,
pca,
pptlBrushOrg,
prclDest,
prclSrc,
pptlMask,
HALFTONE);
}
ULONG
DrvDitherColor(
DHPDEV dhpdev,
ULONG iMode,
ULONG rgb,
ULONG *pul
)
/*++
Routine Description:
Implementation of DDI entry point DrvDisableDriver.
Please refer to DDK documentation for more details.
Arguments:
dhpdev - Driver device handle
iMode - Determines the palette to dither against
rgb - Specifies the RGB color that is to be dithered
pul - Points to a memory location in which the dithering information is to be recorded
Return Value:
DCR_HALFTONE to indicate that the engine should create a halftone
approximation for the driver.
--*/
{
return DCR_HALFTONE;
}
BOOL
FillDevInfo(
PDEVDATA pdev,
ULONG cb,
PVOID pdevinfo
)
/*++
Routine Description:
Fill in the DEVINFO structure pointed to by pdevinfo.
Arguments:
pdev - Pointer to our DEVDATA structure
cb - Size of structure pointed to by pdevinfo
pdevinfo - Pointer to DEVINFO structure
[Notes:]
Since we have to worry about not writing out more than cb bytes to
pdevinfo, we will first fill in a local buffer, then copy cb bytes
to pdevinfo.
Return Value:
TRUE if successful. FALSE otherwise.
--*/
{
static ULONG paletteColors[2] = {
RGB_BLACK,
RGB_WHITE,
};
DEVINFO devinfo;
memset(&devinfo, 0, sizeof(devinfo));
//
// Fill in the graphics capabilities flags: we let the engine
// do almost everything. Also, we have to tell the engine not
// to do metafile spooling because we hook out DrvDocumentEvent.
//
devinfo.flGraphicsCaps = GCAPS_HALFTONE |
GCAPS_MONO_DITHER |
GCAPS_COLOR_DITHER |
GCAPS_DONTJOURNAL;
//
// No device fonts
//
devinfo.cFonts = 0;
//
// Black and white palette: entry 0 is black and entry 1 is white
//
if (! (pdev->hpal = EngCreatePalette(PAL_INDEXED, 2, paletteColors, 0, 0, 0))) {
Error(("EngCreatePalette failed\n"));
return FALSE;
}
devinfo.hpalDefault = pdev->hpal;
devinfo.iDitherFormat = BMF_1BPP;
devinfo.cxDither = devinfo.cyDither = 4;
//
// Copy cb bytes from devinfo structure into the caller-provided buffer
//
if (cb > sizeof(devinfo))
{
memset(pdevinfo, 0, cb);
memcpy(pdevinfo, &devinfo, sizeof(devinfo));
}
else
memcpy(pdevinfo, &devinfo, cb);
return TRUE;
}
BOOL
FillGdiInfo(
PDEVDATA pdev,
ULONG cb,
PVOID pgdiinfo
)
/*++
Routine Description:
Fill in the device capabilities information for the engine.
Arguments:
pdev - Pointer to DEVDATA structure
cb - Size of buffer pointed to by pgdiinfo
pgdiinfo - Pointer to a GDIINFO buffer
Return Value:
NONE
--*/
{
GDIINFO gdiinfo;
LONG maxRes;
memset(&gdiinfo, 0, sizeof(gdiinfo));
//
// This field doesn't seem to have any effect for printer drivers.
// Put our driver version number in there anyway.
//
gdiinfo.ulVersion = DRIVER_VERSION;
//
// We're raster printers
//
gdiinfo.ulTechnology = DT_RASPRINTER;
//
// Width and height of the imageable area measured in microns.
// Remember to turn on the sign bit.
//
gdiinfo.ulHorzSize = - (pdev->imageArea.right - pdev->imageArea.left);
gdiinfo.ulVertSize = - (pdev->imageArea.bottom - pdev->imageArea.top);
//
// Convert paper size and imageable area from microns to pixels
//
pdev->paperSize.cx = MicronToPixel(pdev->paperSize.cx, pdev->xres);
pdev->paperSize.cy = MicronToPixel(pdev->paperSize.cy, pdev->yres);
pdev->imageArea.left = MicronToPixel(pdev->imageArea.left, pdev->xres);
pdev->imageArea.right = MicronToPixel(pdev->imageArea.right, pdev->xres);
pdev->imageArea.top = MicronToPixel(pdev->imageArea.top, pdev->yres);
pdev->imageArea.bottom = MicronToPixel(pdev->imageArea.bottom, pdev->yres);
pdev->imageSize.cx = pdev->imageArea.right - pdev->imageArea.left;
pdev->imageSize.cy = pdev->imageArea.bottom - pdev->imageArea.top;
//
// Width and height of the imageable area measured in device pixels
//
gdiinfo.ulHorzRes = pdev->imageSize.cx;
gdiinfo.ulVertRes = pdev->imageSize.cy;
//
// Color depth information
//
gdiinfo.cBitsPixel = 1;
gdiinfo.cPlanes = 1;
gdiinfo.ulNumColors = 2;
//
// Resolution information
//
gdiinfo.ulLogPixelsX = pdev->xres;
gdiinfo.ulLogPixelsY = pdev->yres;
//
// Win31 compatible text capability flags. Are they still used by anyone?
//
gdiinfo.flTextCaps = 0;
//
// Device pixel aspect ratio
//
gdiinfo.ulAspectX = pdev->yres;
gdiinfo.ulAspectY = pdev->xres;
gdiinfo.ulAspectXY = CalcHypot(pdev->xres, pdev->yres);
//
// Dotted line appears to be approximately 25dpi
// We assume either xres is a multiple of yres or yres is a multiple of xres
//
maxRes = max(pdev->xres, pdev->yres);
Assert((maxRes % pdev->xres) == 0 && (maxRes % pdev->yres == 0));
gdiinfo.xStyleStep = maxRes / pdev->xres;
gdiinfo.yStyleStep = maxRes / pdev->yres;
gdiinfo.denStyleStep = maxRes / 25;
//
// Size and margins of physical surface measured in device pixels
//
gdiinfo.szlPhysSize.cx = pdev->paperSize.cx;
gdiinfo.szlPhysSize.cy = pdev->paperSize.cy;
gdiinfo.ptlPhysOffset.x = pdev->imageArea.left;
gdiinfo.ptlPhysOffset.y = pdev->imageArea.top;
//
// Use default halftone information
//
gdiinfo.ciDevice = DefDevHTInfo.ColorInfo;
gdiinfo.ulDevicePelsDPI = max(pdev->xres, pdev->yres);
gdiinfo.ulPrimaryOrder = PRIMARY_ORDER_CBA;
gdiinfo.ulHTOutputFormat = HT_FORMAT_1BPP;
gdiinfo.flHTFlags = HT_FLAG_HAS_BLACK_DYE;
gdiinfo.ulHTPatternSize = HT_PATSIZE_4x4_M;
//
// Copy cb byte from gdiinfo structure into the caller-provided buffer
//
if (cb > sizeof(gdiinfo))
{
memset(pgdiinfo, 0, cb);
memcpy(pgdiinfo, &gdiinfo, sizeof(gdiinfo));
}
else
memcpy(pgdiinfo, &gdiinfo, cb);
return TRUE;
}
VOID
FreeDevData(
PDEVDATA pdev
)
/*++
Routine Description:
Free up all memory associated with the specified PDEV
Arguments:
pdev Pointer to our DEVDATA structure
Return Value:
NONE
--*/
{
if (pdev->hpal)
EngDeletePalette(pdev->hpal);
MemFree(pdev->pFaxIFD);
MemFree(pdev);
}
VOID
SelectPrinterForm(
PDEVDATA pdev
)
/*++
Routine Description:
Store printer paper size information in our DEVDATA structure
Arguments:
pdev - Pointer to our DEVDATA structure
Return Value:
NONE
--*/
{
FORM_INFO_1 formInfo;
//
// Validate devmode form specification; use default form if it's invalid.
//
if (! ValidDevmodeForm(pdev->hPrinter, &pdev->dm.dmPublic, &formInfo)) {
memset(&formInfo, 0, sizeof(formInfo));
//
// Default to A4 paper
//
formInfo.Size.cx = formInfo.ImageableArea.right = A4_WIDTH;
formInfo.Size.cy = formInfo.ImageableArea.bottom = A4_HEIGHT;
}
Assert(formInfo.Size.cx > 0 && formInfo.Size.cy > 0);
Assert(formInfo.ImageableArea.left >= 0 &&
formInfo.ImageableArea.top >= 0 &&
formInfo.ImageableArea.left < formInfo.ImageableArea.right &&
formInfo.ImageableArea.top < formInfo.ImageableArea.bottom &&
formInfo.ImageableArea.right <= formInfo.Size.cx &&
formInfo.ImageableArea.bottom <= formInfo.Size.cy);
//
// Take landscape into consideration
//
if (IsLandscapeMode(pdev)) {
LONG width, height;
//
// Swap the width and height
//
pdev->paperSize.cy = width = formInfo.Size.cx;
pdev->paperSize.cx = height = formInfo.Size.cy;
//
// Rotate the coordinate system 90 degrees counterclockwise
//
pdev->imageArea.left = height - formInfo.ImageableArea.bottom;
pdev->imageArea.top = formInfo.ImageableArea.left;
pdev->imageArea.right = height - formInfo.ImageableArea.top;
pdev->imageArea.bottom = formInfo.ImageableArea.right;
//
// Swap x and y resolution
//
pdev->xres = pdev->dm.dmPublic.dmYResolution;
pdev->yres = pdev->dm.dmPublic.dmPrintQuality;
} else {
pdev->paperSize = formInfo.Size;
pdev->imageArea = formInfo.ImageableArea;
pdev->xres = pdev->dm.dmPublic.dmPrintQuality;
pdev->yres = pdev->dm.dmPublic.dmYResolution;
}
}
LONG
CalcHypot(
LONG x,
LONG y
)
/*++
Routine Description:
Returns the length of the hypotenouse of a right triangle
Arguments:
x, y - Edges of the right triangle
Return Value:
Hypotenouse of the right triangle
--*/
{
LONG hypo, delta, target;
//
// Take care of negative inputs
//
if (x < 0)
x = -x;
if (y < 0)
y = -y;
//
// use sq(x) + sq(y) = sq(hypo);
// start with MAX(x, y),
// use sq(x + 1) = sq(x) + 2x + 1 to incrementally get to the target hypotenouse.
//
hypo = max(x, y);
target = min(x, y);
target *= target;
for(delta = 0; delta < target; hypo++)
delta += (hypo << 1) + 1;
return hypo;
}