643 lines
18 KiB
C
643 lines
18 KiB
C
/*++
|
||
|
||
Copyright (c) 1996 Microsoft Corporation
|
||
|
||
Module Name:
|
||
|
||
custsize.c
|
||
|
||
Abstract:
|
||
|
||
Parser functions for handling custom page size feature
|
||
|
||
Environment:
|
||
|
||
Windows NT PostScript driver
|
||
|
||
Revision History:
|
||
|
||
03/20/97 -davidx-
|
||
Created it.
|
||
|
||
--*/
|
||
|
||
#include "lib.h"
|
||
#include "ppd.h"
|
||
|
||
|
||
BOOL
|
||
BFixupCustomSizeDataFeedDirection(
|
||
PUIINFO pUIInfo,
|
||
PPPDDATA pPpdData,
|
||
PCUSTOMSIZEDATA pCSData
|
||
)
|
||
|
||
/*++
|
||
|
||
Routine Description:
|
||
|
||
Validate the requested paper feed direction parameter
|
||
Fix up any inconsistency if necessary
|
||
|
||
Arguments:
|
||
|
||
pPpdData - Points to PPDDATA structure
|
||
pCSData - Specifies custom page size parameters
|
||
|
||
Return Value:
|
||
|
||
TRUE if we can find a feeding direction to fit the custom page size.
|
||
FALSE otherwise.
|
||
|
||
Note:
|
||
|
||
See Figure 3 on page 109 of PPD 4.3 spec for more details.
|
||
|
||
--*/
|
||
|
||
#define ORIENTATION_AVAILABLE(iOrient) (dwFlags & (1 << (iOrient)))
|
||
#define FIXUP_FEEDDIRECTION(iMainOrient, iAltOrient, wAltFeedDirection) \
|
||
{ \
|
||
if (! ORIENTATION_AVAILABLE(iMainOrient)) \
|
||
{ \
|
||
pCSData->wFeedDirection = \
|
||
ORIENTATION_AVAILABLE(iAltOrient) ? \
|
||
(wAltFeedDirection) : \
|
||
MAX_FEEDDIRECTION; \
|
||
} \
|
||
}
|
||
|
||
{
|
||
static const DWORD adwMasks[4] = { 0x1, 0x3, 0x7, 0xf };
|
||
DWORD dwFlags;
|
||
BOOL bXGreaterThanY;
|
||
BOOL bShortEdgeFirst;
|
||
LONG lVal;
|
||
WORD wFeedDirectionSave;
|
||
|
||
//
|
||
// Figure out which custom page size orientations are supported
|
||
// dwFlags is DWORD value whose lower-order 4 bits are interpreted as flags:
|
||
// If orientation N is supported, then bit 1 << N will be set
|
||
//
|
||
|
||
dwFlags = 0xf;
|
||
|
||
if ((lVal = MINCUSTOMPARAM_ORIENTATION(pPpdData)) > 3)
|
||
dwFlags = 0;
|
||
else if (lVal > 0)
|
||
dwFlags &= ~adwMasks[lVal - 1];
|
||
|
||
if ((lVal = MAXCUSTOMPARAM_ORIENTATION(pPpdData)) < 3)
|
||
dwFlags &= adwMasks[lVal];
|
||
|
||
wFeedDirectionSave = pCSData->wFeedDirection;
|
||
bXGreaterThanY = (pCSData->dwX > pCSData->dwY);
|
||
|
||
//
|
||
// First try to fit within the current feeding direction.
|
||
//
|
||
|
||
switch (pCSData->wFeedDirection)
|
||
{
|
||
case SHORTEDGEFIRST:
|
||
|
||
if (bXGreaterThanY)
|
||
{
|
||
// orientation 0 (or 2)
|
||
FIXUP_FEEDDIRECTION(0, 2, SHORTEDGEFIRST_FLIPPED);
|
||
}
|
||
else
|
||
{
|
||
// orientation 1 (or 3)
|
||
FIXUP_FEEDDIRECTION(1, 3, SHORTEDGEFIRST_FLIPPED);
|
||
}
|
||
break;
|
||
|
||
case SHORTEDGEFIRST_FLIPPED:
|
||
|
||
if (bXGreaterThanY)
|
||
{
|
||
// orientation 2 (or 0)
|
||
FIXUP_FEEDDIRECTION(2, 0, SHORTEDGEFIRST);
|
||
}
|
||
else
|
||
{
|
||
// orientation 3 (or 1)
|
||
FIXUP_FEEDDIRECTION(3, 1, SHORTEDGEFIRST);
|
||
}
|
||
break;
|
||
|
||
case LONGEDGEFIRST:
|
||
|
||
if (bXGreaterThanY)
|
||
{
|
||
// orientation 1 (or 3)
|
||
FIXUP_FEEDDIRECTION(1, 3, LONGEDGEFIRST_FLIPPED);
|
||
}
|
||
else
|
||
{
|
||
// orientation 0 (or 2)
|
||
FIXUP_FEEDDIRECTION(0, 2, LONGEDGEFIRST_FLIPPED);
|
||
}
|
||
break;
|
||
|
||
case LONGEDGEFIRST_FLIPPED:
|
||
|
||
if (bXGreaterThanY)
|
||
{
|
||
// orientation 3 (or 1)
|
||
FIXUP_FEEDDIRECTION(3, 1, LONGEDGEFIRST);
|
||
}
|
||
else
|
||
{
|
||
// orientation 2 (or 0)
|
||
FIXUP_FEEDDIRECTION(2, 0, LONGEDGEFIRST);
|
||
}
|
||
break;
|
||
}
|
||
|
||
//
|
||
// If the paper feed direction is not valid, we'll automatically
|
||
// pick one here (default to long-edge-first if possible). This
|
||
// should always change Long to Short, or Short to Long.
|
||
//
|
||
|
||
if (pCSData->wFeedDirection >= MAX_FEEDDIRECTION)
|
||
{
|
||
if (bXGreaterThanY)
|
||
{
|
||
if (ORIENTATION_AVAILABLE(1))
|
||
pCSData->wFeedDirection = LONGEDGEFIRST;
|
||
else if (ORIENTATION_AVAILABLE(3))
|
||
pCSData->wFeedDirection = LONGEDGEFIRST_FLIPPED;
|
||
else if (ORIENTATION_AVAILABLE(0))
|
||
pCSData->wFeedDirection = SHORTEDGEFIRST;
|
||
else // (ORIENTATION_AVAILABLE(2))
|
||
pCSData->wFeedDirection = SHORTEDGEFIRST_FLIPPED;
|
||
}
|
||
else
|
||
{
|
||
if (ORIENTATION_AVAILABLE(0))
|
||
pCSData->wFeedDirection = LONGEDGEFIRST;
|
||
else if (ORIENTATION_AVAILABLE(2))
|
||
pCSData->wFeedDirection = LONGEDGEFIRST_FLIPPED;
|
||
else if (ORIENTATION_AVAILABLE(1))
|
||
pCSData->wFeedDirection = SHORTEDGEFIRST;
|
||
else // (ORIENTATION_AVAILABLE(3))
|
||
pCSData->wFeedDirection = SHORTEDGEFIRST_FLIPPED;
|
||
}
|
||
}
|
||
|
||
bShortEdgeFirst =
|
||
(pCSData->wFeedDirection == SHORTEDGEFIRST ||
|
||
pCSData->wFeedDirection == SHORTEDGEFIRST_FLIPPED);
|
||
|
||
if ( (!bShortEdgeFirst && !LONGEDGEFIRST_SUPPORTED(pUIInfo, pPpdData)) ||
|
||
(bShortEdgeFirst && !SHORTEDGEFIRST_SUPPORTED(pUIInfo, pPpdData)))
|
||
{
|
||
//
|
||
// The other feeding direction we picked doesn't fit either, so we
|
||
// have to stick with the original feeding direction.
|
||
//
|
||
|
||
pCSData->wFeedDirection = wFeedDirectionSave;
|
||
|
||
//
|
||
// Check the availability of orientations and flip the feed direction if necessary
|
||
//
|
||
|
||
if ((pCSData->wFeedDirection == LONGEDGEFIRST || pCSData->wFeedDirection == SHORTEDGEFIRST) &&
|
||
!(ORIENTATION_AVAILABLE(0) || ORIENTATION_AVAILABLE(1)))
|
||
{
|
||
pCSData->wFeedDirection = (pCSData->wFeedDirection == LONGEDGEFIRST) ?
|
||
LONGEDGEFIRST_FLIPPED : SHORTEDGEFIRST_FLIPPED;
|
||
}
|
||
else if ((pCSData->wFeedDirection == LONGEDGEFIRST_FLIPPED || pCSData->wFeedDirection == SHORTEDGEFIRST_FLIPPED) &&
|
||
!(ORIENTATION_AVAILABLE(2) || ORIENTATION_AVAILABLE(3)))
|
||
{
|
||
pCSData->wFeedDirection = (pCSData->wFeedDirection == LONGEDGEFIRST_FLIPPED) ?
|
||
LONGEDGEFIRST : SHORTEDGEFIRST;
|
||
}
|
||
|
||
return FALSE;
|
||
}
|
||
else
|
||
return TRUE;
|
||
}
|
||
|
||
|
||
|
||
BOOL
|
||
BValidateCustomPageSizeData(
|
||
IN PRAWBINARYDATA pRawData,
|
||
IN OUT PCUSTOMSIZEDATA pCSData
|
||
)
|
||
|
||
/*++
|
||
|
||
Routine Description:
|
||
|
||
Validate the specified custom page size parameters, and
|
||
Fix up any inconsistencies found.
|
||
|
||
Arguments:
|
||
|
||
pRawData - Points to raw binary printer description data
|
||
pCSData - Specifies the custom page size parameters to be validate
|
||
|
||
Return Value:
|
||
|
||
TRUE if the custom page size parameters are valid, FALSE otherwise.
|
||
If FALSE is returned, custom page size parameters have been
|
||
fixed up to a consistent state.
|
||
|
||
--*/
|
||
|
||
{
|
||
PUIINFO pUIInfo;
|
||
PPPDDATA pPpdData;
|
||
PPAGESIZE pPageSize;
|
||
CUSTOMSIZEDATA csdata;
|
||
PDWORD pdwWidth, pdwHeight;
|
||
DWORD dwTemp;
|
||
BOOL bShortEdgeFirst, bXGreaterThanY;
|
||
BOOL bFit;
|
||
|
||
pUIInfo = GET_UIINFO_FROM_INFOHEADER((PINFOHEADER) pRawData);
|
||
pPpdData = GET_DRIVER_INFO_FROM_INFOHEADER((PINFOHEADER) pRawData);
|
||
|
||
ASSERT(pUIInfo != NULL && pPpdData != NULL);
|
||
|
||
if ((pPageSize = PGetCustomPageSizeOption(pUIInfo)) == NULL)
|
||
{
|
||
RIP(("Custom page size not supported\n"));
|
||
return TRUE;
|
||
}
|
||
|
||
csdata = *pCSData;
|
||
|
||
//
|
||
// Width and height offset parameters are straightforward to verify
|
||
//
|
||
|
||
if ((LONG) csdata.dwWidthOffset < MINCUSTOMPARAM_WIDTHOFFSET(pPpdData))
|
||
csdata.dwWidthOffset = MINCUSTOMPARAM_WIDTHOFFSET(pPpdData);
|
||
else if ((LONG) csdata.dwWidthOffset > MAXCUSTOMPARAM_WIDTHOFFSET(pPpdData))
|
||
csdata.dwWidthOffset = MAXCUSTOMPARAM_WIDTHOFFSET(pPpdData);
|
||
|
||
if ((LONG) csdata.dwHeightOffset < MINCUSTOMPARAM_HEIGHTOFFSET(pPpdData))
|
||
csdata.dwHeightOffset = MINCUSTOMPARAM_HEIGHTOFFSET(pPpdData);
|
||
else if ((LONG) csdata.dwHeightOffset > MAXCUSTOMPARAM_HEIGHTOFFSET(pPpdData))
|
||
csdata.dwHeightOffset = MAXCUSTOMPARAM_HEIGHTOFFSET(pPpdData);
|
||
|
||
//
|
||
// Validate cut-sheet vs. roll-fed selection
|
||
//
|
||
|
||
if (csdata.wCutSheet && !(pPpdData->dwCustomSizeFlags & CUSTOMSIZE_CUTSHEET))
|
||
csdata.wCutSheet = FALSE;
|
||
else if (!csdata.wCutSheet && !(pPpdData->dwCustomSizeFlags & CUSTOMSIZE_ROLLFED))
|
||
csdata.wCutSheet = TRUE;
|
||
|
||
//
|
||
// Check if the specified paper feed direction can be satisfied
|
||
//
|
||
|
||
bFit = BFixupCustomSizeDataFeedDirection(pUIInfo, pPpdData, &csdata);
|
||
|
||
//
|
||
// If we haven't been able to fit the custom paper size in
|
||
// correct feeding direction and orientation, then we have
|
||
// to swap width and height here, because they will be opposite
|
||
// of what PPD spec 4.3 page 109 Figure 3 specifies.
|
||
//
|
||
|
||
if (!bFit)
|
||
{
|
||
dwTemp = csdata.dwX;
|
||
csdata.dwX = csdata.dwY;
|
||
csdata.dwY = dwTemp;
|
||
}
|
||
|
||
//
|
||
// Verify width and height parameters
|
||
//
|
||
|
||
bShortEdgeFirst =
|
||
(csdata.wFeedDirection == SHORTEDGEFIRST ||
|
||
csdata.wFeedDirection == SHORTEDGEFIRST_FLIPPED);
|
||
|
||
bXGreaterThanY = (csdata.dwX > csdata.dwY);
|
||
|
||
if ((bShortEdgeFirst && bXGreaterThanY) ||
|
||
(!bShortEdgeFirst && !bXGreaterThanY))
|
||
{
|
||
// In this case: x <=> height, y <=> width
|
||
|
||
pdwHeight = &csdata.dwX;
|
||
pdwWidth = &csdata.dwY;
|
||
}
|
||
else
|
||
{
|
||
// In this case: x <=> width, y <=> height
|
||
|
||
pdwWidth = &csdata.dwX;
|
||
pdwHeight = &csdata.dwY;
|
||
}
|
||
|
||
if ((LONG) (*pdwWidth + csdata.dwWidthOffset) > pPageSize->szPaperSize.cx)
|
||
{
|
||
*pdwWidth = pPageSize->szPaperSize.cx - csdata.dwWidthOffset;
|
||
|
||
if ((LONG) *pdwWidth < MINCUSTOMPARAM_WIDTH(pPpdData))
|
||
{
|
||
*pdwWidth = MINCUSTOMPARAM_WIDTH(pPpdData);
|
||
csdata.dwWidthOffset = pPageSize->szPaperSize.cx - *pdwWidth;
|
||
}
|
||
}
|
||
else if ((LONG) *pdwWidth < MINCUSTOMPARAM_WIDTH(pPpdData))
|
||
{
|
||
*pdwWidth = MINCUSTOMPARAM_WIDTH(pPpdData);
|
||
}
|
||
|
||
if ((LONG) (*pdwHeight + csdata.dwHeightOffset) > pPageSize->szPaperSize.cy)
|
||
{
|
||
*pdwHeight = pPageSize->szPaperSize.cy - csdata.dwHeightOffset;
|
||
|
||
if ((LONG) *pdwHeight < MINCUSTOMPARAM_HEIGHT(pPpdData))
|
||
{
|
||
*pdwHeight = MINCUSTOMPARAM_HEIGHT(pPpdData);
|
||
csdata.dwHeightOffset = pPageSize->szPaperSize.cy - *pdwHeight;
|
||
}
|
||
}
|
||
else if ((LONG) *pdwHeight < MINCUSTOMPARAM_HEIGHT(pPpdData))
|
||
{
|
||
*pdwHeight = MINCUSTOMPARAM_HEIGHT(pPpdData);
|
||
}
|
||
|
||
//
|
||
// Check if anything has changed and
|
||
// return appropriate result value
|
||
//
|
||
|
||
if (memcmp(pCSData, &csdata, sizeof(csdata)) == 0)
|
||
return TRUE;
|
||
|
||
*pCSData = csdata;
|
||
return FALSE;
|
||
}
|
||
|
||
|
||
|
||
VOID
|
||
VFillDefaultCustomPageSizeData(
|
||
IN PRAWBINARYDATA pRawData,
|
||
OUT PCUSTOMSIZEDATA pCSData,
|
||
IN BOOL bMetric
|
||
)
|
||
|
||
/*++
|
||
|
||
Routine Description:
|
||
|
||
Initialize the custom page size parameters to their default values
|
||
|
||
Arguments:
|
||
|
||
pRawData - Points to raw printer description data
|
||
pCSData - Buffer for storing default custom page size parameters
|
||
bMetric - Whether we're on a metric system
|
||
|
||
Return Value:
|
||
|
||
NONE
|
||
|
||
--*/
|
||
|
||
{
|
||
PPPDDATA pPpdData;
|
||
|
||
pPpdData = GET_DRIVER_INFO_FROM_INFOHEADER((PINFOHEADER) pRawData);
|
||
|
||
ASSERT(pPpdData != NULL);
|
||
|
||
//
|
||
// Default to Letter or A4 depending on whether
|
||
// we're on metric system or not
|
||
//
|
||
|
||
if (bMetric)
|
||
{
|
||
pCSData->dwX = 210000; // 210mm
|
||
pCSData->dwY = 297000; // 297mm
|
||
}
|
||
else
|
||
{
|
||
pCSData->dwX = 215900; // 8.5"
|
||
pCSData->dwY = 279400; // 11"
|
||
}
|
||
|
||
//
|
||
// Get default offsets and feed direction
|
||
//
|
||
|
||
pCSData->dwWidthOffset = MINCUSTOMPARAM_WIDTHOFFSET(pPpdData);
|
||
pCSData->dwHeightOffset = MINCUSTOMPARAM_HEIGHTOFFSET(pPpdData);
|
||
|
||
pCSData->wFeedDirection =
|
||
(pPpdData->dwCustomSizeFlags & CUSTOMSIZE_SHORTEDGEFEED) ?
|
||
SHORTEDGEFIRST : LONGEDGEFIRST;
|
||
|
||
//
|
||
// Make sure the default custom page size parameters are consistent
|
||
//
|
||
|
||
(VOID) BValidateCustomPageSizeData(pRawData, pCSData);
|
||
}
|
||
|
||
|
||
|
||
VOID
|
||
VGetCustomSizeParamRange(
|
||
IN PRAWBINARYDATA pRawData,
|
||
IN PCUSTOMSIZEDATA pCSData,
|
||
OUT PCUSTOMSIZERANGE pCSRange
|
||
)
|
||
|
||
/*++
|
||
|
||
Routine Description:
|
||
|
||
Return the valid ranges for custom page size width, height,
|
||
and offset parameters based on their current values
|
||
|
||
Arguments:
|
||
|
||
pRawData - Points to raw printer description data
|
||
pCSData - Specifies the current custom page size parameter values
|
||
pCSRange - Output buffer for returning custom page size parameter ranges
|
||
It should point to an array of 4 CUSTOMSIZERANGE structures:
|
||
0 (CUSTOMPARAM_WIDTH)
|
||
1 (CUSTOMPARAM_HEIGHT)
|
||
2 (CUSTOMPARAM_WIDTHOFFSET)
|
||
3 (CUSTOMPARAM_HEIGHTOFFSET)
|
||
|
||
Return Value:
|
||
|
||
NONE
|
||
|
||
--*/
|
||
|
||
{
|
||
PUIINFO pUIInfo;
|
||
PPPDDATA pPpdData;
|
||
BOOL bShortEdgeFirst, bXGreaterThanY;
|
||
PPAGESIZE pPageSize;
|
||
CUSTOMSIZEDATA csdata;
|
||
PCUSTOMSIZERANGE pWidthRange, pHeightRange, pTempRange;
|
||
BOOL bFit;
|
||
|
||
pUIInfo = GET_UIINFO_FROM_INFOHEADER((PINFOHEADER) pRawData);
|
||
pPpdData = GET_DRIVER_INFO_FROM_INFOHEADER((PINFOHEADER) pRawData);
|
||
|
||
ASSERT(pUIInfo != NULL && pPpdData != NULL);
|
||
|
||
pPageSize = PGetCustomPageSizeOption(pUIInfo);
|
||
|
||
ASSERT(pPageSize != NULL);
|
||
|
||
//
|
||
// The range for width and height offsets are predictable
|
||
//
|
||
|
||
pCSRange[CUSTOMPARAM_WIDTHOFFSET].dwMin = MINCUSTOMPARAM_WIDTHOFFSET(pPpdData);
|
||
pCSRange[CUSTOMPARAM_WIDTHOFFSET].dwMax = MAXCUSTOMPARAM_WIDTHOFFSET(pPpdData);
|
||
pCSRange[CUSTOMPARAM_HEIGHTOFFSET].dwMin = MINCUSTOMPARAM_HEIGHTOFFSET(pPpdData);
|
||
pCSRange[CUSTOMPARAM_HEIGHTOFFSET].dwMax = MAXCUSTOMPARAM_HEIGHTOFFSET(pPpdData);
|
||
|
||
//
|
||
// The range for width and height are affected by the selected paper feed direction
|
||
//
|
||
|
||
csdata = *pCSData;
|
||
bFit = BFixupCustomSizeDataFeedDirection(pUIInfo, pPpdData, &csdata);
|
||
|
||
bShortEdgeFirst =
|
||
(csdata.wFeedDirection == SHORTEDGEFIRST ||
|
||
csdata.wFeedDirection == SHORTEDGEFIRST_FLIPPED);
|
||
|
||
bXGreaterThanY = (csdata.dwX > csdata.dwY);
|
||
|
||
if ((bShortEdgeFirst && bXGreaterThanY) ||
|
||
(!bShortEdgeFirst && !bXGreaterThanY))
|
||
{
|
||
//
|
||
// Here user's logical x/y and custom page
|
||
// size width/height are swapped
|
||
//
|
||
|
||
pWidthRange = pCSRange + CUSTOMPARAM_HEIGHT;
|
||
pHeightRange = pCSRange + CUSTOMPARAM_WIDTH;
|
||
}
|
||
else
|
||
{
|
||
//
|
||
// Here user's logical x/y correspond to
|
||
// custom page size width/height
|
||
//
|
||
|
||
pWidthRange = pCSRange + CUSTOMPARAM_WIDTH;
|
||
pHeightRange = pCSRange + CUSTOMPARAM_HEIGHT;
|
||
}
|
||
|
||
//
|
||
// If we haven't been able to fit the custom paper size in
|
||
// correct feeding direction and orientation, then we have
|
||
// to swap width and height here, because they will be opposite
|
||
// of what PPD spec 4.3 page 109 Figure 3 specifies.
|
||
//
|
||
|
||
if (!bFit)
|
||
{
|
||
pTempRange = pWidthRange;
|
||
pWidthRange = pHeightRange;
|
||
pHeightRange = pTempRange;
|
||
}
|
||
|
||
pWidthRange->dwMin = MINCUSTOMPARAM_WIDTH(pPpdData);
|
||
pWidthRange->dwMax = MAXCUSTOMPARAM_WIDTH(pPpdData);
|
||
pHeightRange->dwMin = MINCUSTOMPARAM_HEIGHT(pPpdData);
|
||
pHeightRange->dwMax = MAXCUSTOMPARAM_HEIGHT(pPpdData);
|
||
|
||
if (pWidthRange->dwMax > pPageSize->szPaperSize.cx - csdata.dwWidthOffset)
|
||
pWidthRange->dwMax = pPageSize->szPaperSize.cx - csdata.dwWidthOffset;
|
||
|
||
if (pHeightRange->dwMax > pPageSize->szPaperSize.cy - csdata.dwHeightOffset)
|
||
pHeightRange->dwMax = pPageSize->szPaperSize.cy - csdata.dwHeightOffset;
|
||
}
|
||
|
||
|
||
|
||
BOOL
|
||
BFormSupportedThruCustomSize(
|
||
PRAWBINARYDATA pRawData,
|
||
DWORD dwX,
|
||
DWORD dwY,
|
||
PWORD pwFeedDirection
|
||
)
|
||
|
||
/*++
|
||
|
||
Routine Description:
|
||
|
||
Determine whether a form can be supported through custom page size
|
||
|
||
Arguments:
|
||
|
||
pRawData - Points to raw printer description data
|
||
dwX, dwY - Form width and height (in microns)
|
||
pwFeedDirection - if not NULL, will be set to the selected feed direction
|
||
|
||
Return Value:
|
||
|
||
TRUE if the form can be supported through custom page size
|
||
FALSE if not. In that case, pwFeedDirection will be LONGEDGEFIRST.
|
||
|
||
--*/
|
||
{
|
||
PPPDDATA pPpdData = GET_DRIVER_INFO_FROM_INFOHEADER((PINFOHEADER) pRawData);
|
||
static WORD awPrefFeedDir[] = {
|
||
LONGEDGEFIRST,
|
||
SHORTEDGEFIRST
|
||
};
|
||
CUSTOMSIZEDATA csdata;
|
||
DWORD i;
|
||
|
||
for (i = 0; i < (sizeof(awPrefFeedDir)/sizeof(WORD)); i++)
|
||
{
|
||
csdata.dwX = dwX;
|
||
csdata.dwY = dwY;
|
||
csdata.dwWidthOffset =
|
||
csdata.dwHeightOffset = 0;
|
||
csdata.wCutSheet = TRUE;
|
||
csdata.wFeedDirection = awPrefFeedDir[i];
|
||
|
||
(VOID) BValidateCustomPageSizeData(pRawData, &csdata);
|
||
|
||
if (dwX == csdata.dwX && dwY == csdata.dwY && csdata.wFeedDirection != MAX_FEEDDIRECTION)
|
||
{
|
||
if (pwFeedDirection != NULL)
|
||
*pwFeedDirection = csdata.wFeedDirection; // might be flipped
|
||
|
||
return TRUE;
|
||
}
|
||
}
|
||
|
||
if (pwFeedDirection != NULL)
|
||
*pwFeedDirection = LONGEDGEFIRST; // just set a safe default, the return value should be checked !
|
||
|
||
return FALSE;
|
||
}
|
||
|