731 lines
22 KiB
C
731 lines
22 KiB
C
//-----------------------------------------------------------------------------
|
|
// This files contains the module name for this mini driver. Each mini driver
|
|
// must have a unique module name. The module name is used to obtain the
|
|
// module handle of this Mini Driver. The module handle is used by the
|
|
// generic library to load in tables from the Mini Driver.
|
|
//-----------------------------------------------------------------------------
|
|
|
|
/*++
|
|
|
|
Copyright (c) 1996-1999 Microsoft Corporation
|
|
|
|
Module Name:
|
|
|
|
cmdcb.c
|
|
|
|
Abstract:
|
|
|
|
Implementation of GPD command callback for "test.gpd":
|
|
OEMCommandCallback
|
|
|
|
Environment:
|
|
|
|
Windows NT Unidrv driver
|
|
|
|
Revision History:
|
|
|
|
04/07/97 -zhanw-
|
|
Created it.
|
|
|
|
--*/
|
|
|
|
#include "pdev.h"
|
|
|
|
//////////////////////////////////////////////////////////////////////////
|
|
// Function: BInitOEMExtraData
|
|
//
|
|
// Description: Initializes OEM Extra data.
|
|
//
|
|
//
|
|
// Parameters:
|
|
//
|
|
// pOEMExtra Pointer to a OEM Extra data.
|
|
//
|
|
// dwSize Size of OEM extra data.
|
|
//
|
|
//
|
|
// Returns: TRUE if successful; FALSE otherwise.
|
|
//
|
|
//
|
|
// Comments:
|
|
//
|
|
//
|
|
// History:
|
|
// 02/11/97 APresley Created.
|
|
//
|
|
//////////////////////////////////////////////////////////////////////////
|
|
|
|
BOOL BInitOEMExtraData(POEM_EXTRADATA pOEMExtra)
|
|
{
|
|
// Initialize OEM Extra data.
|
|
pOEMExtra->dmExtraHdr.dwSize = sizeof(OEM_EXTRADATA);
|
|
pOEMExtra->dmExtraHdr.dwSignature = OEM_SIGNATURE;
|
|
pOEMExtra->dmExtraHdr.dwVersion = OEM_VERSION;
|
|
|
|
// Initialize private data
|
|
pOEMExtra->wCopyCount = 1;
|
|
pOEMExtra->wTray = CMD_ID_TRAY_1;
|
|
pOEMExtra->wPaper = CMD_ID_PAPER_A4;
|
|
pOEMExtra->wRes = 400;
|
|
pOEMExtra->fVert = FALSE;
|
|
pOEMExtra->wFont = 0;
|
|
pOEMExtra->wBlockHeight = 0;
|
|
pOEMExtra->wBlockWidth = 0;
|
|
|
|
return TRUE;
|
|
}
|
|
|
|
//////////////////////////////////////////////////////////////////////////
|
|
// Function: BMergeOEMExtraData
|
|
//
|
|
// Description: Validates and merges OEM Extra data.
|
|
//
|
|
//
|
|
// Parameters:
|
|
//
|
|
// pdmIn pointer to an input OEM private devmode containing the settings
|
|
// to be validated and merged. Its size is current.
|
|
//
|
|
// pdmOut pointer to the output OEM private devmode containing the
|
|
// default settings.
|
|
//
|
|
//
|
|
// Returns: TRUE if valid; FALSE otherwise.
|
|
//
|
|
//
|
|
// Comments:
|
|
//
|
|
//
|
|
// History:
|
|
// 02/11/97 APresley Created.
|
|
// 04/08/97 ZhanW Modified the interface
|
|
//
|
|
//////////////////////////////////////////////////////////////////////////
|
|
|
|
BOOL BMergeOEMExtraData(
|
|
POEM_EXTRADATA pdmIn,
|
|
POEM_EXTRADATA pdmOut
|
|
)
|
|
{
|
|
if(pdmIn) {
|
|
//
|
|
// copy over the private fields, if they are valid
|
|
//
|
|
// Copy private data
|
|
pdmOut->wCopyCount = pdmIn->wCopyCount;
|
|
pdmOut->wTray = pdmIn->wTray;
|
|
pdmOut->wPaper = pdmIn->wPaper;
|
|
pdmOut->wRes = pdmIn->wRes;
|
|
pdmOut->fVert = pdmIn->fVert;
|
|
pdmOut->wFont = pdmIn->wFont;
|
|
pdmOut->wBlockHeight = pdmIn->wBlockHeight;
|
|
pdmOut->wBlockWidth = pdmIn->wBlockWidth;
|
|
}
|
|
return TRUE;
|
|
}
|
|
|
|
// #######
|
|
|
|
#include <stdio.h>
|
|
#ifdef wsprintf
|
|
#undef wsprintf
|
|
#endif // wsprintf
|
|
#define wsprintf sprintf
|
|
|
|
#define WRITESPOOLBUF(p, s, n) \
|
|
((p)->pDrvProcs->DrvWriteSpoolBuf(p, s, n))
|
|
|
|
#define PARAM(p,n) \
|
|
(*((p)+(n)))
|
|
|
|
BYTE ESC_VERT_ON[] = "\x1B\x74";
|
|
BYTE ESC_VERT_OFF[] = "\x1B\x4B";
|
|
BYTE ESC_FONT_SELECT_MINCHO[] = "\x1B\x40\x43\x30";
|
|
BYTE ESC_FONT_SELECT_GOTHIC[] = "\x1B\x40\x43\x31";
|
|
BYTE ESC_FONT_PITCH[] = "\x1B\x2D\x00";
|
|
BYTE ESC_FONT_SIZE[] = "\x1B\x75\x33\x00\x00\x00\x00";
|
|
BYTE ESC_SET_COPYCOUNT[] = "\x1B\x3C\x31\x00\x00";
|
|
BYTE ESC_SET_RES240[] = "\x1B\x5B\x31\x00\x06\x3D\x33\x30\x32\x34\x30";
|
|
BYTE ESC_SET_RES400[] = "\x1B\x5B\x31\x00\x06\x3D\x33\x30\x34\x30\x30";
|
|
BYTE ESC_XY_ABS[] = "\x1B\x5C\x39\x00\x00\x00\x00";
|
|
BYTE ESC_XY_REL[] = "\x1B\x5C\x30\x00\x00\x00\x00";
|
|
BYTE ESC_SEND_BLOCK[] = "\x1B\x77\x00\x00\x00\x00";
|
|
|
|
|
|
BOOL APIENTRY OEMFilterGraphics(
|
|
PDEVOBJ pdevobj, // Points to private data required by the Unidriver.dll
|
|
PBYTE pBuf, // points to buffer of graphics data
|
|
DWORD dwLen) // length of buffer in bytes
|
|
{
|
|
POEM_EXTRADATA pOEM;
|
|
WORD wSent;
|
|
WORD wlen;
|
|
|
|
pOEM = (POEM_EXTRADATA)pdevobj->pOEMDM;
|
|
wSent = (WORD)dwLen;
|
|
|
|
while(wSent)
|
|
{
|
|
if(wSent > MAXBUFLEN)
|
|
wlen = MAXBUFLEN;
|
|
else
|
|
wlen = wSent;
|
|
|
|
WRITESPOOLBUF(pdevobj, pBuf, wlen);
|
|
|
|
wSent -= wlen;
|
|
pBuf += MAXBUFLEN;
|
|
}
|
|
return TRUE;
|
|
}
|
|
|
|
//---------------------------*OEMSendFontCmd*----------------------------------
|
|
// Action: send Pages-style font selection command.
|
|
//-----------------------------------------------------------------------------
|
|
VOID APIENTRY OEMSendFontCmd(
|
|
PDEVOBJ pdevobj,
|
|
PUNIFONTOBJ pUFObj, // offset to the command heap
|
|
PFINVOCATION pFInv)
|
|
{
|
|
POEM_EXTRADATA pOEM;
|
|
PGETINFO_STDVAR pSV;
|
|
DWORD dwStdVariable[2 + 2 * 2];
|
|
BYTE pbCmd[256];
|
|
WORD wCmdLen = 0;
|
|
WORD wFontWidth;
|
|
WORD wFontHeight;
|
|
WORD wScale;
|
|
|
|
if(!pUFObj || !pFInv)
|
|
{
|
|
ERR(("Parameter is invalid.\n"));
|
|
return;
|
|
}
|
|
|
|
pOEM = (POEM_EXTRADATA)pdevobj->pOEMDM;
|
|
|
|
// Get font size from STDVARIABLE
|
|
pSV = (PGETINFO_STDVAR)dwStdVariable;
|
|
pSV->dwSize = sizeof(GETINFO_STDVAR) + 2 * sizeof(DWORD) * (2 - 1);
|
|
pSV->dwNumOfVariable = 2;
|
|
pSV->StdVar[0].dwStdVarID = FNT_INFO_FONTHEIGHT;
|
|
pSV->StdVar[1].dwStdVarID = FNT_INFO_FONTWIDTH;
|
|
if (!pUFObj->pfnGetInfo(pUFObj, UFO_GETINFO_STDVARIABLE, pSV, pSV->dwSize, NULL))
|
|
{
|
|
ERR(("UFO_GETINFO_STDVARIABLE failed.\n"));
|
|
return;
|
|
}
|
|
wFontHeight = (WORD)pSV->StdVar[0].lStdVariable;
|
|
wFontWidth = (WORD)(pSV->StdVar[1].lStdVariable * 2);
|
|
|
|
// Scaling to current res unit
|
|
wScale = (WORD)(1200 / (pOEM->wRes == CMD_ID_RES240 ? 240 : 400));
|
|
wFontHeight /= wScale;
|
|
wFontWidth /= wScale;
|
|
|
|
// Build Command for Scalable font
|
|
switch(pUFObj->ulFontID)
|
|
{
|
|
case FONT_ID_MIN:
|
|
if(pOEM->fVert)
|
|
{
|
|
wCmdLen = (WORD)wsprintf((PBYTE)&pbCmd, ESC_VERT_OFF);
|
|
pOEM->fVert = FALSE;
|
|
}
|
|
if(pOEM->wFont != FONT_MINCHO)
|
|
{
|
|
wCmdLen += (WORD)wsprintf((PBYTE)&pbCmd[wCmdLen], ESC_FONT_SELECT_MINCHO);
|
|
pOEM->wFont = FONT_MINCHO;
|
|
}
|
|
break;
|
|
|
|
case FONT_ID_GOT: // These fonts are for horizontal
|
|
if(pOEM->fVert)
|
|
{
|
|
wCmdLen = (WORD)wsprintf((PBYTE)&pbCmd, ESC_VERT_OFF);
|
|
pOEM->fVert = FALSE;
|
|
}
|
|
if(pOEM->wFont != FONT_GOTHIC)
|
|
{
|
|
wCmdLen += (WORD)wsprintf((PBYTE)&pbCmd[wCmdLen],
|
|
ESC_FONT_SELECT_MINCHO);
|
|
pOEM->wFont = FONT_GOTHIC;
|
|
}
|
|
break;
|
|
|
|
case FONT_ID_MIN_V:
|
|
if(!pOEM->fVert)
|
|
{
|
|
wCmdLen = (WORD)wsprintf((PBYTE)&pbCmd, ESC_VERT_ON);
|
|
pOEM->fVert = TRUE;
|
|
}
|
|
if(pOEM->wFont != FONT_MINCHO)
|
|
{
|
|
wCmdLen += (WORD)wsprintf((PBYTE)&pbCmd[wCmdLen],
|
|
ESC_FONT_SELECT_MINCHO);
|
|
pOEM->wFont = FONT_MINCHO;
|
|
}
|
|
break;
|
|
|
|
case FONT_ID_GOT_V: // These fonts are for vertical
|
|
if(!pOEM->fVert)
|
|
{
|
|
wCmdLen = (WORD)wsprintf((PBYTE)&pbCmd, ESC_VERT_ON);
|
|
pOEM->fVert = TRUE;
|
|
}
|
|
if(pOEM->wFont != FONT_GOTHIC)
|
|
{
|
|
wCmdLen += (WORD)wsprintf((PBYTE)&pbCmd[wCmdLen],
|
|
ESC_FONT_SELECT_MINCHO);
|
|
pOEM->wFont = FONT_GOTHIC;
|
|
}
|
|
break;
|
|
|
|
default:
|
|
ERR(("Device Font ID is invalid.\n"));
|
|
return;
|
|
}
|
|
|
|
// Font pitch command
|
|
ESC_FONT_PITCH[2] = (BYTE)wFontWidth;
|
|
wCmdLen += (WORD)wsprintf((PBYTE)&pbCmd[wCmdLen], ESC_FONT_PITCH);
|
|
|
|
// Font size command
|
|
ESC_FONT_SIZE[3] = HIBYTE(wFontWidth);
|
|
ESC_FONT_SIZE[4] = LOBYTE(wFontWidth);
|
|
ESC_FONT_SIZE[5] = HIBYTE(wFontHeight);
|
|
ESC_FONT_SIZE[6] = LOBYTE(wFontHeight);
|
|
memcpy((PBYTE)&pbCmd[wCmdLen], ESC_FONT_SIZE, 7);
|
|
wCmdLen += 7;
|
|
|
|
// Send build command for spooler
|
|
WRITESPOOLBUF(pdevobj, (PBYTE)&pbCmd, wCmdLen);
|
|
return;
|
|
}
|
|
|
|
VOID APIENTRY OEMOutputCharStr(
|
|
PDEVOBJ pdevobj,
|
|
PUNIFONTOBJ pUFObj,
|
|
DWORD dwType,
|
|
DWORD dwCount,
|
|
PVOID pGlyph)
|
|
{
|
|
POEM_EXTRADATA pOEM;
|
|
GETINFO_GLYPHSTRING GStr;
|
|
PBYTE tempBuf;
|
|
PTRANSDATA pTrans;
|
|
DWORD i;
|
|
BYTE pbStr[MAXBUFLEN];
|
|
WORD wStrLen;
|
|
|
|
BYTE *pTemp;
|
|
WORD wLen;
|
|
|
|
VERBOSE(("OEMOutputCharStr() entry.\n"));
|
|
ASSERT(VALID_PDEVOBJ(pdevobj));
|
|
|
|
if(!pUFObj || !pGlyph)
|
|
{
|
|
ERR(("Parameter is invalid.\n"));
|
|
return ;
|
|
}
|
|
|
|
pOEM = (POEM_EXTRADATA)pdevobj->pOEMDM;
|
|
|
|
GStr.dwSize = sizeof(GETINFO_GLYPHSTRING);
|
|
GStr.dwCount = dwCount;
|
|
GStr.dwTypeIn = TYPE_GLYPHHANDLE;
|
|
GStr.pGlyphIn = pGlyph;
|
|
GStr.dwTypeOut = TYPE_TRANSDATA;
|
|
GStr.pGlyphOut = NULL;
|
|
GStr.dwGlyphOutSize = 0;
|
|
|
|
/* Get TRANSDATA buffer size */
|
|
if (FALSE != pUFObj->pfnGetInfo(pUFObj,
|
|
UFO_GETINFO_GLYPHSTRING, &GStr, 0, NULL)
|
|
|| 0 == GStr.dwGlyphOutSize )
|
|
{
|
|
ERR(("get TRANSDATA buffer size error\n"));
|
|
return ;
|
|
}
|
|
|
|
/* Alloc TRANSDATA buffer size */
|
|
if(!(tempBuf = (PBYTE)MemAllocZ(GStr.dwGlyphOutSize)))
|
|
{
|
|
ERR(("Memory alloc failed.\n"));
|
|
return ;
|
|
}
|
|
|
|
/* Get actual TRANSDATA */
|
|
GStr.pGlyphOut = tempBuf;
|
|
if (FALSE == pUFObj->pfnGetInfo(pUFObj,
|
|
UFO_GETINFO_GLYPHSTRING, &GStr, 0, NULL))
|
|
{
|
|
ERR(("GetInfo failed.\n"));
|
|
return;
|
|
}
|
|
|
|
pTrans = GStr.pGlyphOut;
|
|
|
|
for(i = 0, wStrLen = 0; i < dwCount; i++, pTrans++)
|
|
{
|
|
switch(pTrans->ubType & MTYPE_FORMAT_MASK)
|
|
{
|
|
case MTYPE_DIRECT: // SBCS character
|
|
pbStr[wStrLen++] = pTrans->uCode.ubCode;
|
|
break;
|
|
|
|
case MTYPE_PAIRED: // DBCS character
|
|
pbStr[wStrLen++] = pTrans->uCode.ubPairs[0];
|
|
pbStr[wStrLen++] = pTrans->uCode.ubPairs[1];
|
|
break;
|
|
case MTYPE_COMPOSE:
|
|
pTemp = (BYTE *)(GStr.pGlyphOut) + pTrans->uCode.sCode;
|
|
|
|
// first two bytes are the length of the string
|
|
wLen = *pTemp + (*(pTemp + 1) << 8);
|
|
pTemp += 2;
|
|
|
|
while (wLen--)
|
|
{
|
|
pbStr[ wStrLen++ ] = *pTemp++;
|
|
}
|
|
}
|
|
}
|
|
|
|
if(wStrLen)
|
|
WRITESPOOLBUF(pdevobj, pbStr, wStrLen);
|
|
|
|
MemFree(tempBuf);
|
|
return ;
|
|
}
|
|
|
|
/*****************************************************************************/
|
|
/* */
|
|
/* INT APIENTRY OEMCommandCallback( */
|
|
/* PDEVOBJ pdevobj */
|
|
/* DWORD dwCmdCbId */
|
|
/* DWORD dwCount */
|
|
/* PDWORD pdwParams */
|
|
/* */
|
|
/*****************************************************************************/
|
|
INT APIENTRY
|
|
OEMCommandCallback(
|
|
PDEVOBJ pdevobj, // Points to private data required by the Unidriver.dll
|
|
DWORD dwCmdCbId, // Callback ID
|
|
DWORD dwCount, // Counts of command parameter
|
|
PDWORD pdwParams) // points to values of command params
|
|
{
|
|
POEM_EXTRADATA pOEM;
|
|
WORD wCmdLen;
|
|
BYTE pbCmd[MAXBUFLEN];
|
|
|
|
VERBOSE(("OEMCommandCallback() entry.\n"));
|
|
ASSERT(VALID_PDEVOBJ(pdevobj));
|
|
|
|
pOEM = (POEM_EXTRADATA)pdevobj->pOEMDM;
|
|
wCmdLen = 0;
|
|
|
|
switch(dwCmdCbId)
|
|
{
|
|
case CMD_ID_TRAY_1:
|
|
case CMD_ID_TRAY_2:
|
|
case CMD_ID_TRAY_MANUAL:
|
|
case CMD_ID_TRAY_AUTO:
|
|
pOEM->wTray = (WORD)dwCmdCbId;
|
|
break;
|
|
|
|
case CMD_ID_PAPER_A3:
|
|
case CMD_ID_PAPER_B4:
|
|
case CMD_ID_PAPER_A4:
|
|
case CMD_ID_PAPER_B5:
|
|
case CMD_ID_PAPER_A5:
|
|
case CMD_ID_PAPER_HAGAKI:
|
|
case CMD_ID_PAPER_LETTER:
|
|
case CMD_ID_PAPER_LEGAL:
|
|
pOEM->wPaper = (WORD)dwCmdCbId;
|
|
SetTrayPaper(pdevobj);
|
|
return 0;
|
|
|
|
case CMD_ID_COPYCOUNT:
|
|
{
|
|
WORD wCopies;
|
|
|
|
if(!pdwParams)
|
|
return 0;
|
|
|
|
if(*pdwParams < 1)
|
|
wCopies = 1;
|
|
else if(*pdwParams > 99)
|
|
wCopies = 99;
|
|
else
|
|
wCopies = (WORD)*pdwParams;
|
|
|
|
ESC_SET_COPYCOUNT[3] = ((BYTE)wCopies / 10) + 0x30;
|
|
ESC_SET_COPYCOUNT[4] = ((BYTE)wCopies % 10) + 0x30;
|
|
memcpy((PBYTE)&pbCmd[wCmdLen], ESC_SET_COPYCOUNT, 5);
|
|
wCmdLen += 5;
|
|
break;
|
|
}
|
|
|
|
case CMD_ID_RES240:
|
|
case CMD_ID_RES400:
|
|
pOEM->wRes = (WORD)dwCmdCbId;
|
|
if(pOEM->wRes == CMD_ID_RES240)
|
|
{
|
|
memcpy((PBYTE)&pbCmd[wCmdLen], ESC_SET_RES240, 11);
|
|
wCmdLen += 11;
|
|
} else {
|
|
memcpy((PBYTE)&pbCmd[wCmdLen], ESC_SET_RES400, 11);
|
|
wCmdLen += 11;
|
|
}
|
|
memcpy((PBYTE)&pbCmd[wCmdLen], "\x1B\x5C\x35\x38", 4);
|
|
wCmdLen += 4;
|
|
memcpy((PBYTE)&pbCmd[wCmdLen],
|
|
"\x1B\x5B\x31\x00\x03\x46\x34\x00", 8);
|
|
wCmdLen += 8;
|
|
memcpy((PBYTE)&pbCmd[wCmdLen],
|
|
"\x1B\x5B\x31\x00\x03\x46\x35\x09", 8);
|
|
wCmdLen += 8;
|
|
memcpy((PBYTE)&pbCmd[wCmdLen],
|
|
"\x1B\x5B\x31\x00\x03\x46\x31\x03", 8);
|
|
wCmdLen += 8;
|
|
break;
|
|
|
|
case CMD_ID_BEGIN_PAGE:
|
|
pOEM->wFont = 0;
|
|
|
|
ESC_XY_ABS[3] = 0x00 | 0x80;
|
|
ESC_XY_ABS[4] = 0x00;
|
|
ESC_XY_ABS[5] = 0x00;
|
|
ESC_XY_ABS[6] = 0x00;
|
|
|
|
wCmdLen += (WORD)wsprintf((PBYTE)&pbCmd[wCmdLen], ESC_VERT_OFF);
|
|
|
|
memcpy(&pbCmd[wCmdLen], ESC_XY_ABS, 7);
|
|
wCmdLen += 7;
|
|
break;
|
|
|
|
case CMD_ID_XM_ABS:
|
|
case CMD_ID_YM_ABS:
|
|
{
|
|
WORD wX, wY;
|
|
|
|
wX = (WORD)PARAM(pdwParams, 0);
|
|
wY = (WORD)PARAM(pdwParams, 1);
|
|
|
|
wX /= (pOEM->wRes == CMD_ID_RES240 ? 5 : 3);
|
|
wY /= (pOEM->wRes == CMD_ID_RES240 ? 5 : 3);
|
|
|
|
ESC_XY_ABS[3] = HIBYTE(wX) | 0x80;
|
|
ESC_XY_ABS[4] = LOBYTE(wX);
|
|
ESC_XY_ABS[5] = HIBYTE(wY);
|
|
ESC_XY_ABS[6] = LOBYTE(wY);
|
|
WRITESPOOLBUF(pdevobj, ESC_XY_ABS, 7);
|
|
return (INT)(dwCmdCbId == CMD_ID_XM_ABS ? wX : wY);
|
|
}
|
|
|
|
case CMD_ID_X_REL_RIGHT:
|
|
case CMD_ID_X_REL_LEFT:
|
|
case CMD_ID_Y_REL_DOWN:
|
|
case CMD_ID_Y_REL_UP:
|
|
{
|
|
WORD wX, wY;
|
|
|
|
wX = (WORD)PARAM(pdwParams, 0);
|
|
wY = (WORD)PARAM(pdwParams, 1);
|
|
|
|
wX /= (pOEM->wRes == CMD_ID_RES240 ? 5 : 3);
|
|
wY /= (pOEM->wRes == CMD_ID_RES240 ? 5 : 3);
|
|
|
|
ESC_XY_REL[3] = HIBYTE(wX) | 0x80;
|
|
ESC_XY_REL[4] = LOBYTE(wX);
|
|
ESC_XY_REL[5] = HIBYTE(wY);
|
|
ESC_XY_REL[6] = LOBYTE(wY);
|
|
WRITESPOOLBUF(pdevobj, ESC_XY_REL, 7);
|
|
return (INT)((dwCmdCbId == CMD_ID_X_REL_RIGHT
|
|
|| dwCmdCbId == CMD_ID_X_REL_LEFT) ? wX : wY);
|
|
}
|
|
|
|
case CMD_ID_SEND_BLOCK240:
|
|
case CMD_ID_SEND_BLOCK400:
|
|
if(pOEM->fVert)
|
|
{
|
|
wCmdLen += (WORD)wsprintf((PBYTE)&pbCmd[wCmdLen], ESC_VERT_OFF);
|
|
pOEM->fVert = FALSE;
|
|
}
|
|
|
|
pOEM->wBlockHeight = (WORD)PARAM(pdwParams, 1);
|
|
pOEM->wBlockWidth = (WORD)(PARAM(pdwParams, 2) * 8);
|
|
|
|
ESC_SEND_BLOCK[2] = HIBYTE(pOEM->wBlockWidth);
|
|
ESC_SEND_BLOCK[3] = LOBYTE(pOEM->wBlockWidth);
|
|
ESC_SEND_BLOCK[4] = HIBYTE(pOEM->wBlockHeight);
|
|
ESC_SEND_BLOCK[5] = LOBYTE(pOEM->wBlockHeight);
|
|
memcpy((PBYTE)&pbCmd[wCmdLen], ESC_SEND_BLOCK, 6);
|
|
wCmdLen += 6;
|
|
break;
|
|
|
|
case CMD_ID_END_BLOCK:
|
|
{
|
|
WORD wHeight;
|
|
|
|
if(!pOEM->wBlockHeight)
|
|
break;
|
|
|
|
wHeight = pOEM->wBlockHeight - 1;
|
|
if(wHeight)
|
|
{
|
|
wHeight *= (pOEM->wRes == CMD_ID_RES240 ? 5 : 3);
|
|
|
|
ESC_XY_REL[3] = 0x00 | 0x80;
|
|
ESC_XY_REL[4] = 0x00;
|
|
ESC_XY_REL[5] = HIBYTE(wHeight);
|
|
ESC_XY_REL[6] = LOBYTE(wHeight);
|
|
memcpy(&pbCmd[wCmdLen], ESC_XY_REL, 7);
|
|
wCmdLen += 7;
|
|
}
|
|
break;
|
|
}
|
|
|
|
default:
|
|
break;
|
|
}
|
|
|
|
if(wCmdLen)
|
|
WRITESPOOLBUF(pdevobj, (PBYTE)&pbCmd, wCmdLen);
|
|
|
|
return 0;
|
|
}
|
|
|
|
/*
|
|
* Set tray and paper
|
|
*/
|
|
VOID SetTrayPaper(PDEVOBJ pdevobj)
|
|
{
|
|
POEM_EXTRADATA pOEM;
|
|
WORD wLen;
|
|
BYTE pbCmdBuf[MAXBUFLEN];
|
|
|
|
pOEM = (POEM_EXTRADATA)pdevobj->pOEMDM;
|
|
wLen = 0;
|
|
|
|
switch (pOEM->wTray)
|
|
{
|
|
case CMD_ID_TRAY_1:
|
|
memcpy((PBYTE)&pbCmdBuf[wLen], "\x1B\x40\x29\x30", 4);
|
|
wLen += 4;
|
|
break;
|
|
|
|
case CMD_ID_TRAY_2:
|
|
memcpy((PBYTE)&pbCmdBuf[wLen], "\x1B\x40\x29\x31", 4);
|
|
wLen += 4;
|
|
break;
|
|
|
|
case CMD_ID_TRAY_MANUAL:
|
|
memcpy((PBYTE)&pbCmdBuf[wLen], "\x1B\x40\x29\x32", 4);
|
|
wLen += 4;
|
|
|
|
switch (pOEM->wPaper)
|
|
{
|
|
case CMD_ID_PAPER_A3:
|
|
memcpy((PBYTE)&pbCmdBuf[wLen],
|
|
"\x1B\x5B\x31\x00\x03\x40\x31\x30", 8);
|
|
wLen += 8;
|
|
break;
|
|
|
|
case CMD_ID_PAPER_B4:
|
|
memcpy((PBYTE)&pbCmdBuf[wLen],
|
|
"\x1B\x5B\x31\x00\x03\x40\x31\x31", 8);
|
|
wLen += 8;
|
|
break;
|
|
|
|
case CMD_ID_PAPER_A4:
|
|
memcpy((PBYTE)&pbCmdBuf[wLen],
|
|
"\x1B\x5B\x31\x00\x03\x40\x31\x33", 8);
|
|
wLen += 8;
|
|
break;
|
|
|
|
case CMD_ID_PAPER_B5:
|
|
memcpy((PBYTE)&pbCmdBuf[wLen],
|
|
"\x1B\x5B\x31\x00\x03\x40\x31\x34", 8);
|
|
wLen += 8;
|
|
break;
|
|
|
|
case CMD_ID_PAPER_A5:
|
|
memcpy((PBYTE)&pbCmdBuf[wLen],
|
|
"\x1B\x5B\x31\x00\x03\x40\x31\x36", 8);
|
|
wLen += 8;
|
|
break;
|
|
|
|
case CMD_ID_PAPER_HAGAKI:
|
|
memcpy((PBYTE)&pbCmdBuf[wLen],
|
|
"\x1B\x5B\x31\x00\x03\x40\x31\x3D", 8);
|
|
wLen += 8;
|
|
break;
|
|
|
|
case CMD_ID_PAPER_LETTER:
|
|
memcpy((PBYTE)&pbCmdBuf[wLen],
|
|
"\x1B\x5B\x31\x00\x03\x40\x31\x39", 8);
|
|
wLen += 8;
|
|
break;
|
|
|
|
case CMD_ID_PAPER_LEGAL:
|
|
memcpy((PBYTE)&pbCmdBuf[wLen],
|
|
"\x1B\x5B\x31\x00\x03\x40\x31\x3B", 8);
|
|
wLen += 8;
|
|
break;
|
|
|
|
default:
|
|
break;
|
|
}
|
|
break;
|
|
|
|
case CMD_ID_TRAY_AUTO:
|
|
switch (pOEM->wPaper)
|
|
{
|
|
case CMD_ID_PAPER_A3:
|
|
memcpy((PBYTE)&pbCmdBuf[wLen], "\x1B\x40\x29\x38", 4);
|
|
wLen += 4;
|
|
break;
|
|
|
|
case CMD_ID_PAPER_B4:
|
|
memcpy((PBYTE)&pbCmdBuf[wLen], "\x1B\x40\x29\x34", 4);
|
|
wLen += 4;
|
|
break;
|
|
|
|
case CMD_ID_PAPER_A4:
|
|
memcpy((PBYTE)&pbCmdBuf[wLen], "\x1B\x40\x29\x35", 4);
|
|
wLen += 4;
|
|
break;
|
|
|
|
case CMD_ID_PAPER_B5:
|
|
memcpy((PBYTE)&pbCmdBuf[wLen], "\x1B\x40\x29\x36", 4);
|
|
wLen += 4;
|
|
break;
|
|
|
|
case CMD_ID_PAPER_A5:
|
|
memcpy((PBYTE)&pbCmdBuf[wLen], "\x1B\x40\x29\x3B", 4);
|
|
wLen += 4;
|
|
break;
|
|
|
|
case CMD_ID_PAPER_HAGAKI:
|
|
memcpy((PBYTE)&pbCmdBuf[wLen], "\x1B\x40\x29\x3C", 4);
|
|
wLen += 4;
|
|
break;
|
|
|
|
default:
|
|
break;
|
|
}
|
|
break;
|
|
|
|
default:
|
|
break;
|
|
}
|
|
if(wLen)
|
|
WRITESPOOLBUF(pdevobj, (PBYTE)pbCmdBuf, wLen);
|
|
|
|
return ;
|
|
}
|
|
|