You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
857 lines
42 KiB
857 lines
42 KiB
/*****************************************************************************/
|
|
/* CODE.C */
|
|
/* */
|
|
/* The FE minidriver with Win95 style callbacks negotiates with the */
|
|
/* Unidriver using a data block MINIDRVENABLEDATA. Minidriver exports a */
|
|
/* callback function MiniDrvEnableDriver() to be recognized by the Unidriver */
|
|
/* (so that it can know the minidriver has Win95 style callbacks in it). */
|
|
/* */
|
|
/* Following files are used by only NT4.0 FE minidriver when driver use */
|
|
/* callback function. */
|
|
/* */
|
|
/* gdidefs.inc mdevice.h print.h mindrvrc.h */
|
|
/* minidriv.h unidrv.h udmdi.h version.h */
|
|
/* uniutil.c */
|
|
/* */
|
|
/* Copyright (C) 1997- Advanced Peripherals Technologies, Inc. */
|
|
/* */
|
|
/* <HISTORY> */
|
|
/* */
|
|
/*****************************************************************************/
|
|
//+---------------------------------------------------------------------------+
|
|
//| I N C L U D E F I L E |
|
|
//+---------------------------------------------------------------------------+
|
|
char *rgchModuleName = "APTiE840";
|
|
#include <print.h>
|
|
#include "mdevice.h"
|
|
#include "gdidefs.inc"
|
|
|
|
#include "mindrvrc.h"
|
|
#include "minidriv.h"
|
|
#include "unidrv.h"
|
|
|
|
#include "code.h"
|
|
|
|
#include <windows.h>
|
|
#include <windowsx.h>
|
|
/*****************************************************************************/
|
|
/* */
|
|
/* Module: MiniDrvEnableDriver */
|
|
/* */
|
|
/* Function: */
|
|
/* */
|
|
/* Syntax: BOOL MiniDrvEnableDriver(MINIDRVENABLEDATA) */
|
|
/* */
|
|
/* Input: *pEnableData */
|
|
/* */
|
|
/* Output: BOOL */
|
|
/* */
|
|
/* Notice: This callback routine is "for NT4.0 FE minidriver only". */
|
|
/* */
|
|
/* History: 1997. 06.03 initial */
|
|
/* */
|
|
/*****************************************************************************/
|
|
BOOL MiniDrvEnableDriver(MINIDRVENABLEDATA *pEnableData)
|
|
{
|
|
if (pEnableData == NULL)
|
|
return FALSE;
|
|
|
|
if (pEnableData->cbSize == 0) {
|
|
pEnableData->cbSize = sizeof(MINIDRVENABLEDATA);
|
|
return TRUE;
|
|
}
|
|
|
|
if ((pEnableData->cbSize < sizeof(MINIDRVENABLEDATA))
|
|
|| (HIBYTE(pEnableData->DriverVersion) < HIBYTE(MDI_DRIVER_VERSION)))
|
|
return FALSE; // Wrong size and/or version mismatch.
|
|
|
|
// Load address of Unidriver provided function
|
|
if (!bLoadUniDrvCallBack(pEnableData,INDEX_UniDrvWriteSpoolBuf,(PFN *)&WriteSpoolBuf)
|
|
||!bLoadUniDrvCallBack(pEnableData,INDEX_UniDrvAllocMem,(PFN *)&AllocMem)
|
|
||!bLoadUniDrvCallBack(pEnableData,INDEX_UniDrvFreeMem,(PFN *)&FreeMem))
|
|
{
|
|
// Failed to get Unidriver callback function address.
|
|
return FALSE;
|
|
}
|
|
// Set minidriver's function table to MINIDRVENABLEDATA
|
|
pEnableData->cMiniDrvFn = sizeof(MiniDrvFnTab)/sizeof(MiniDrvFnTab[0]);
|
|
pEnableData->pMinDrvFn = MiniDrvFnTab;
|
|
|
|
return TRUE; // Now we are done.
|
|
}
|
|
/*****************************************************************************/
|
|
/* */
|
|
/* Module: MiniDrvEnablePDEV */
|
|
/* */
|
|
/* Function: */
|
|
/* */
|
|
/* Syntax: BOOL PASCAL MiniDrvEnablePDEV(LPDV, PGDIINFO) */
|
|
/* */
|
|
/* Input: lpdv */
|
|
/* pdevcaps */
|
|
/* */
|
|
/* Output: BOOL */
|
|
/* */
|
|
/* Notice: This callback routine is "for NT4.0 FE minidriver only". */
|
|
/* */
|
|
/* History: 1997. 06.03 initial */
|
|
/* */
|
|
/*****************************************************************************/
|
|
BOOL PASCAL MiniDrvEnablePDEV(LPDV lpdv, PGDIINFO pdevcaps)
|
|
{
|
|
LPAPDL lpApdl;
|
|
|
|
lpdv->fMdv = FALSE;
|
|
|
|
/* allocate memory for A/PDL structure */
|
|
if (!(lpApdl = lpdv->lpMdv = AllocMem(sizeof(APDL))))
|
|
return FALSE;
|
|
|
|
/* allocate buffer for image compression */
|
|
if (!(lpApdl->lpCompBuf = AllocMem(MAXIMGSIZE)))
|
|
return FALSE;
|
|
|
|
/* allocate buffer for image compression */
|
|
if (!(lpApdl->lpTempBuf = AllocMem(MAXIMGSIZE)))
|
|
return FALSE;
|
|
|
|
/* save current resolution */
|
|
lpApdl->ulHorzRes = pdevcaps->ulAspectX;
|
|
lpApdl->ulVertRes = pdevcaps->ulAspectY;
|
|
|
|
/* save physical offset of the unwriteable margin */
|
|
lpApdl->ptlPhysOffset.x = pdevcaps->ptlPhysOffset.x;
|
|
lpApdl->ptlPhysOffset.y = pdevcaps->ptlPhysOffset.y;
|
|
|
|
/* save physical Size of the entire surface, including unwriteable margin */
|
|
lpApdl->szlPhysSize.cx = pdevcaps->szlPhysSize.cx;
|
|
lpApdl->szlPhysSize.cy = pdevcaps->szlPhysSize.cy;
|
|
|
|
lpdv->fMdv = TRUE;
|
|
|
|
return TRUE;
|
|
}
|
|
/*****************************************************************************/
|
|
/* */
|
|
/* Module: MiniDrvDisablePDEV */
|
|
/* */
|
|
/* Function: */
|
|
/* */
|
|
/* Syntax: BOOL PASCAL MiniDrvDisablePDEV(LPDV) */
|
|
/* */
|
|
/* Input: lpdv */
|
|
/* */
|
|
/* Output: BOOL */
|
|
/* */
|
|
/* Notice: This callback routine is "for NT4.0 FE minidriver only". */
|
|
/* */
|
|
/* History: 1997. 06.03 initial */
|
|
/* */
|
|
/*****************************************************************************/
|
|
BOOL PASCAL MiniDrvDisablePDEV(LPDV lpdv)
|
|
{
|
|
if (lpdv->fMdv){
|
|
FreeMem(((LPAPDL)(lpdv->lpMdv))->lpCompBuf);
|
|
FreeMem(((LPAPDL)(lpdv->lpMdv))->lpTempBuf);
|
|
FreeMem(lpdv->lpMdv);
|
|
lpdv->fMdv = FALSE;
|
|
}
|
|
|
|
return TRUE;
|
|
}
|
|
/*****************************************************************************/
|
|
/* */
|
|
/* Module: CBFilterGraphics */
|
|
/* */
|
|
/* Function: */
|
|
/* */
|
|
/* Syntax: WORD PASCAL CBFilterGraphics(LPDV, LPSTR, WORD) */
|
|
/* */
|
|
/* Input: lpdv address of PDEVICE structure */
|
|
/* lpBuf points to buffer of graphics data */
|
|
/* wLen length of buffer in bytes */
|
|
/* */
|
|
/* Output: WORD */
|
|
/* */
|
|
/* Notice: nFunction and Escape numbers are the same */
|
|
/* */
|
|
/*****************************************************************************/
|
|
WORD PASCAL CBFilterGraphics (LPDV lpdv, LPSTR lpBuf, WORD wLen)
|
|
{
|
|
LPAPDL lpApdl = lpdv->lpMdv;
|
|
ULONG ulHorzPixel;
|
|
WORD wCompLen;
|
|
|
|
LPSTR lpSrcImage;
|
|
LPSTR lpCompImage;
|
|
LPSTR lpTempImage;
|
|
|
|
/*_ LPDVに保管したｲﾒｰｼﾞﾊﾞｯﾌｧのﾎﾟｲﾝﾀをｾｯﾄ */
|
|
lpSrcImage = lpBuf;
|
|
lpCompImage = lpApdl->lpCompBuf;
|
|
lpTempImage = lpApdl->lpTempBuf;
|
|
|
|
wCompLen = BRL_ECmd((LPBYTE)lpSrcImage,
|
|
(LPBYTE)lpCompImage,
|
|
(LPBYTE)lpTempImage,
|
|
wLen);
|
|
|
|
// Set the LEN of the DrawBlockImage command
|
|
CmdDrawImgCurrent[4] = (BYTE)((wCompLen + 9) >>8 & 0x00ff);
|
|
CmdDrawImgCurrent[5] = (BYTE)((wCompLen + 9) & 0x00ff);
|
|
|
|
// Set the WIDTH parameter of the DrawBlockImage command
|
|
ulHorzPixel = (ULONG)((wLen / LINE_PER_BAND) * 8); // in bits
|
|
CmdDrawImgCurrent[7] = (BYTE)(ulHorzPixel >> 8 & 0x000000ffL);
|
|
CmdDrawImgCurrent[8] = (BYTE)(ulHorzPixel & 0x000000ffL);
|
|
|
|
// Set the LEN of uncompressed data
|
|
CmdDrawImgCurrent[13] = (BYTE)(wLen >> 8 & 0x000000ff);
|
|
CmdDrawImgCurrent[14] = (BYTE)(wLen & 0x000000ff);
|
|
|
|
// Draw Block Image at Current Position
|
|
WriteSpoolBuf((LPDV)lpdv, (LPSTR)CmdDrawImgCurrent, sizeof(CmdDrawImgCurrent));
|
|
WriteSpoolBuf((LPDV)lpdv, lpCompImage, wCompLen);
|
|
|
|
return wLen;
|
|
}
|
|
/*****************************************************************************/
|
|
/* */
|
|
/* Module: OEMOutputCmd */
|
|
/* */
|
|
/* Function: */
|
|
/* */
|
|
/* Syntax: VOID PASCAL OEMOutputCmd(LPDV, WORD, LPDWORD) */
|
|
/* */
|
|
/* Input: lpdv */
|
|
/* wCmdCbId */
|
|
/* lpdwParams */
|
|
/* */
|
|
/* Output: VOID */
|
|
/* */
|
|
/* Notice: */
|
|
/* */
|
|
/*****************************************************************************/
|
|
// @Aug/31/98 ->
|
|
#define MAX_COPIES_VALUE 255
|
|
// @Aug/31/98 <-
|
|
VOID PASCAL OEMOutputCmd(LPDV lpdv, WORD wCmdCbId, LPDWORD lpdwParams)
|
|
{
|
|
LPAPDL lpApdl = lpdv->lpMdv;
|
|
WORD wTemp;
|
|
WORD wPhysWidth;
|
|
WORD wPhysHeight;
|
|
DWORD dwXval;
|
|
DWORD dwYval;
|
|
|
|
switch(wCmdCbId)
|
|
{
|
|
/*------------------------------------------------------*/
|
|
/* A/PDL start now */
|
|
/*------------------------------------------------------*/
|
|
case PAGECONTROL_BEGIN_DOC:
|
|
/* reset flag of sent Set Physical Paper command */
|
|
lpApdl->fSendSetPhysPaper = FALSE;
|
|
/* initialize flag */
|
|
lpApdl->fBold = FALSE;
|
|
lpApdl->fItalic = FALSE;
|
|
lpApdl->fDuplex = FALSE;
|
|
CmdSetPhysPage[10] = 0x00;
|
|
|
|
/* Send Change Data Stream Command for Enter A/PDL mode */
|
|
WriteSpoolBuf((LPDV)lpdv, (LPSTR)CmdInAPDLMode, 6);
|
|
/* Send A/PLDL start Command */
|
|
WriteSpoolBuf((LPDV)lpdv, (LPSTR)CmdAPDLStart, 2);
|
|
break;
|
|
/*------------------------------------------------------*/
|
|
/* send Page Description command */
|
|
/*------------------------------------------------------*/
|
|
case PAGECONTROL_BEGIN_PAGE:
|
|
if(!lpApdl->fSendSetPhysPaper){ // if command has not sent yet
|
|
|
|
/* reset duplex mode if fDuplex is FALSE */
|
|
if(!lpApdl->fDuplex)
|
|
CmdSetPhysPaper[8] = 0x00; // Duplex OFF
|
|
|
|
/* send Set Physical Paper command */
|
|
WriteSpoolBuf((LPDV)lpdv,
|
|
(LPSTR)CmdSetPhysPaper, sizeof(CmdSetPhysPaper));
|
|
|
|
if(lpApdl->ulHorzRes == 600) { // set unit base
|
|
CmdSetPhysPage[6] = 0x17;
|
|
CmdSetPhysPage[7] = 0x70;
|
|
} else {
|
|
CmdSetPhysPage[6] = 0x0B;
|
|
CmdSetPhysPage[7] = 0xB8;
|
|
}
|
|
|
|
lpApdl->fSendSetPhysPaper = TRUE; // already sent
|
|
}
|
|
|
|
// send Set Physical Page command
|
|
WriteSpoolBuf((LPDV)lpdv,
|
|
(LPSTR)CmdSetPhysPage, sizeof(CmdSetPhysPage));
|
|
// send Begin Physical Page command
|
|
WriteSpoolBuf((LPDV)lpdv,
|
|
(LPSTR)CmdBeginPhysPage, sizeof(CmdBeginPhysPage));
|
|
// send Begin Logical Page command
|
|
WriteSpoolBuf((LPDV)lpdv,
|
|
(LPSTR)CmdBeginLogPage, sizeof(CmdBeginLogPage));
|
|
// send Define Drawing Area command
|
|
WriteSpoolBuf((LPDV)lpdv,
|
|
(LPSTR)CmdDefDrawArea, sizeof(CmdDefDrawArea));
|
|
break;
|
|
case PAGECONTROL_END_PAGE:
|
|
// send End Logical Page command
|
|
WriteSpoolBuf ((LPDV)lpdv,(LPSTR)CmdEndLogPage, sizeof(CmdEndLogPage));
|
|
// send End Physical Page command
|
|
WriteSpoolBuf ((LPDV)lpdv,(LPSTR)CmdEndPhysPage, sizeof(CmdEndPhysPage));
|
|
break;
|
|
|
|
case PAGECONTROL_ABORT_DOC:
|
|
case PAGECONTROL_END_DOC:
|
|
// send A/PDL End command
|
|
WriteSpoolBuf((LPDV)lpdv, (LPSTR)CmdAPDLEnd, sizeof(CmdAPDLEnd));
|
|
break;
|
|
/*------------------------------------------------------*/
|
|
/* save print direction */
|
|
/*------------------------------------------------------*/
|
|
case PAGECONTROL_POTRAIT: // 36
|
|
lpApdl->fOrientation = TRUE;
|
|
break;
|
|
case PAGECONTROL_LANDSCAPE: // 37
|
|
lpApdl->fOrientation = FALSE;
|
|
break;
|
|
/*------------------------------------------------------*/
|
|
/* set Drawing Area into SetPhysPaperDesc command */
|
|
/*------------------------------------------------------*/
|
|
case PHYS_PAPER_A3: // 50
|
|
case PHYS_PAPER_A4: // 51
|
|
case PHYS_PAPER_B4: // 54
|
|
case PHYS_PAPER_LETTER: // 57
|
|
case PHYS_PAPER_LEGAL: // 58
|
|
CmdSetPhysPaper[5] = SetDrawArea(lpdv, wCmdCbId);
|
|
break;
|
|
|
|
case PHYS_PAPER_B5: // 55
|
|
case PHYS_PAPER_A5: // 52
|
|
CmdSetPhysPaper[5] = SetDrawArea(lpdv, wCmdCbId);
|
|
/* even if Duplex is selected, it cancel */
|
|
lpApdl->fDuplex = FALSE;
|
|
CmdSetPhysPaper[8] = 0x00; // Duplex is off
|
|
break;
|
|
|
|
case PHYS_PAPER_POSTCARD: // 59
|
|
CmdSetPhysPaper[5] = SetDrawArea(lpdv, wCmdCbId);
|
|
/* if paper is Postcard, papersource is always Front Tray */
|
|
CmdSetPhysPaper[6] = 0x00; // select Front Tray
|
|
CmdSetPhysPaper[7] = 0x00; // Auto Tray Select is OFF
|
|
|
|
/* even if Duplex is selected, it cancel */
|
|
lpApdl->fDuplex = FALSE;
|
|
CmdSetPhysPaper[8] = 0x00; // Duplex is off
|
|
break;
|
|
|
|
case PHYS_PAPER_UNFIXED: // 60
|
|
/* if paper is Unfixed, papersource is always Front Tray */
|
|
CmdSetPhysPaper[6] = 0x00; // Select Front Tray
|
|
CmdSetPhysPaper[7] = 0x00; // Auto Tray Select is OFF
|
|
|
|
/* even if Duplex is selected, it cancel */
|
|
lpApdl->fDuplex = FALSE;
|
|
CmdSetPhysPaper[8] = 0x00; // Duplex is off
|
|
|
|
CmdSetPhysPaper[5] = SetDrawArea(lpdv, wCmdCbId);
|
|
CmdSetPhysPaper[12] = 0x00; // UnitBase : 10 inch
|
|
|
|
if(lpApdl->ulHorzRes == 600) { // set logical unit
|
|
CmdSetPhysPaper[13] = 0x17;
|
|
CmdSetPhysPaper[14] = 0x70;
|
|
} else {
|
|
CmdSetPhysPaper[13] = 0x0B;
|
|
CmdSetPhysPaper[14] = 0xB8;
|
|
}
|
|
|
|
if(lpApdl->fOrientation){ // portrait
|
|
wPhysWidth = (WORD)lpApdl->szlPhysSize.cx;
|
|
wPhysHeight = (WORD)lpApdl->szlPhysSize.cy;
|
|
} else { // landscape
|
|
wPhysWidth = (WORD)lpApdl->szlPhysSize.cy;
|
|
wPhysHeight = (WORD)lpApdl->szlPhysSize.cx;
|
|
}
|
|
|
|
CmdSetPhysPaper[15] = (BYTE)(wPhysWidth >> 8 & 0x00ff);
|
|
CmdSetPhysPaper[16] = (BYTE)(wPhysWidth & 0x00ff);
|
|
CmdSetPhysPaper[17] = (BYTE)(wPhysHeight >> 8 & 0x00ff);
|
|
CmdSetPhysPaper[18] = (BYTE)(wPhysHeight & 0x00ff);
|
|
|
|
break;
|
|
/*------------------------------------------------------*/
|
|
/* set Paper Tray into SetPhysPaperDesc command */
|
|
/*------------------------------------------------------*/
|
|
case PAPER_SRC_FTRAY:
|
|
CmdSetPhysPaper[6] = 0x00; // Select Front Tray
|
|
CmdSetPhysPaper[7] = 0x00; // Auto Tray Select is OFF
|
|
break;
|
|
case PAPER_SRC_CAS1:
|
|
CmdSetPhysPaper[6] = 0x01; // Select Cassette 1
|
|
CmdSetPhysPaper[7] = 0x00; // Auto Tray Select is OFF
|
|
break;
|
|
case PAPER_SRC_CAS2:
|
|
CmdSetPhysPaper[6] = 0x02; // Select Cassette 2
|
|
CmdSetPhysPaper[7] = 0x00; // Auto Tray Select is OFF
|
|
break;
|
|
case PAPER_SRC_CAS3:
|
|
CmdSetPhysPaper[6] = 0x03; // Select Cassette 3
|
|
CmdSetPhysPaper[7] = 0x00; // Auto Tray Select is OFF
|
|
break;
|
|
/*------------------------------------------------------*/
|
|
/* set Auto Tray Mode into SetPhysPaperDesc command */
|
|
/*------------------------------------------------------*/
|
|
case PAPER_DEST_SCALETOFIT_ON: // 25
|
|
lpApdl->fScaleToFit = TRUE;
|
|
CmdSetPhysPaper[7] = 0x02;
|
|
break;
|
|
case PAPER_DEST_SCALETOFIT_OFF: // 26
|
|
lpApdl->fScaleToFit = FALSE;
|
|
CmdSetPhysPaper[7] = 0x00;
|
|
break;
|
|
/*------------------------------------------------------*/
|
|
/* set Duplex Mode into SetPhysPaperDesc command */
|
|
/*------------------------------------------------------*/
|
|
case PAGECONTROL_DUPLEX_UPDOWN:
|
|
lpApdl->fDuplex = TRUE;
|
|
CmdSetPhysPaper[8] = 0x01; // Up Side Down
|
|
break;
|
|
case PAGECONTROL_DUPLEX_RIGHTUP:
|
|
lpApdl->fDuplex = TRUE;
|
|
CmdSetPhysPaper[8] = 0x02; // Right Side Up
|
|
break;
|
|
case PAGECONTROL_DUPLEX_OFF:
|
|
lpApdl->fDuplex = FALSE;
|
|
break;
|
|
/*------------------------------------------------------*/
|
|
/* set Toner Save into SetPhysPage command */
|
|
/*------------------------------------------------------*/
|
|
case TONER_SAVE_OFF: // 100
|
|
CmdSetPhysPage[10] = 0x00; // off
|
|
break;
|
|
case TONER_SAVE_DARK: // 101
|
|
CmdSetPhysPage[10] = 0x02; // dark
|
|
break;
|
|
case TONER_SAVE_LIGHT: // 102
|
|
CmdSetPhysPage[10] = 0x01; // right
|
|
break;
|
|
/*------------------------------------------------------*/
|
|
/* set Copy Count to SetPhysPaperDesc command */
|
|
/*------------------------------------------------------*/
|
|
case PAGECONTROL_MULTI_COPIES:
|
|
// @Aug/31/98 ->
|
|
if(MAX_COPIES_VALUE < *lpdwParams)
|
|
CmdSetPhysPaper[9] = MAX_COPIES_VALUE;
|
|
else if(1 > *lpdwParams)
|
|
CmdSetPhysPaper[9] = 1;
|
|
else
|
|
CmdSetPhysPaper[9] = (BYTE)*lpdwParams;
|
|
// @Aug/31/98 <-
|
|
break;
|
|
/*------------------------------------------------------*/
|
|
/* send Set Character Attribute with ornament */
|
|
/*------------------------------------------------------*/
|
|
case BOLD_ON:
|
|
if (!lpApdl->fItalic) // bold only
|
|
WriteSpoolBuf(lpdv, CmdBoldOn, sizeof(CmdBoldOn));
|
|
else // bold and italic
|
|
WriteSpoolBuf(lpdv, CmdBoldItalicOn, sizeof(CmdBoldItalicOn));
|
|
|
|
lpApdl->fBold = TRUE;
|
|
break;
|
|
case ITALIC_ON:
|
|
if (!lpApdl->fBold) // italic only
|
|
WriteSpoolBuf(lpdv, CmdItalicOn, sizeof(CmdItalicOn));
|
|
else // italic and bold
|
|
WriteSpoolBuf(lpdv, CmdBoldItalicOn, sizeof(CmdBoldItalicOn));
|
|
|
|
lpApdl->fItalic = TRUE;
|
|
break;
|
|
case BOLD_OFF:
|
|
case ITALIC_OFF:
|
|
lpApdl->fItalic = lpApdl->fBold = FALSE;
|
|
WriteSpoolBuf(lpdv, CmdBoldItalicOff, sizeof(CmdBoldItalicOff));
|
|
break;
|
|
/*------------------------------------------------------*/
|
|
/* */
|
|
/*------------------------------------------------------*/
|
|
case X_ABS_MOVE:
|
|
wTemp = (WORD)*lpdwParams / (MASTER_UNIT / (WORD)lpApdl->ulHorzRes);
|
|
CmdGivenHoriPos[2] = (BYTE) (wTemp >> 8 & 0x00ff);
|
|
CmdGivenHoriPos[3] = (BYTE) (wTemp & 0x00ff);
|
|
/* Send SetGivenHorizontalPosition Command */
|
|
WriteSpoolBuf(lpdv, CmdGivenHoriPos, sizeof(CmdGivenHoriPos));
|
|
break;
|
|
case Y_ABS_MOVE:
|
|
wTemp = (WORD)*lpdwParams;
|
|
CmdGivenVerPos[2] = (BYTE) (wTemp >> 8 & 0x00ff);
|
|
CmdGivenVerPos[3] = (BYTE) (wTemp & 0x00ff);
|
|
/* Send SetGivenVerticalPosition Command */
|
|
WriteSpoolBuf(lpdv, CmdGivenVerPos, sizeof(CmdGivenVerPos));
|
|
break;
|
|
case CR_EMULATION:
|
|
CmdGivenVerPos[2] = 0x00;
|
|
CmdGivenVerPos[3] = 0x00;
|
|
/* Send SetGivenVerticalPosition Command */
|
|
WriteSpoolBuf(lpdv, CmdGivenVerPos, sizeof(CmdGivenVerPos));
|
|
break;
|
|
case XY_ABS_MOVE:
|
|
if(lpApdl->ulHorzRes == 300) {
|
|
dwXval = (DWORD) lpdwParams[0] / 2;
|
|
dwYval = (DWORD) lpdwParams[1] / 2;
|
|
} else {
|
|
dwXval = (DWORD) lpdwParams[0];
|
|
dwYval = (DWORD) lpdwParams[1];
|
|
} /* endif */
|
|
CmdSetGivenPos[2] = (BYTE)(dwXval >> 8 & 0x00ff);
|
|
CmdSetGivenPos[3] = (BYTE)(dwXval & 0x00ff);
|
|
CmdSetGivenPos[4] = (BYTE)(dwYval >> 8 & 0x00ff);
|
|
CmdSetGivenPos[5] = (BYTE)(dwYval & 0x00ff);
|
|
WriteSpoolBuf(lpdv, CmdSetGivenPos, sizeof(CmdSetGivenPos));
|
|
break;
|
|
}
|
|
}
|
|
/*****************************************************************************/
|
|
/* */
|
|
/* Module: OEMOutputChar */
|
|
/* */
|
|
/* Function: */
|
|
/* */
|
|
/* Syntax: VOID PASCAL OEMOutputChar(LPDV, LPSTR, WORD, SHORT) */
|
|
/* */
|
|
/* Input: lpdv address of PDEVICE structure */
|
|
/* lpstr */
|
|
/* len */
|
|
/* rcID */
|
|
/* */
|
|
/* Output: short */
|
|
/* */
|
|
/* Notice: */
|
|
/* */
|
|
/*****************************************************************************/
|
|
VOID PASCAL OEMOutputChar(LPDV lpdv, LPSTR lpstr, WORD len, SHORT rcID)
|
|
{
|
|
LPAPDL lpApdl = lpdv->lpMdv;
|
|
|
|
if (rcID){ // "rc != 0" means font is device font.
|
|
CmdPrnStrCurrent[2] = (BYTE)((len+1) >> 8 & 0x00ff);
|
|
CmdPrnStrCurrent[3] = (BYTE)((len+1) & 0x00ff);
|
|
|
|
/* send Print Character String at Current Position command */
|
|
WriteSpoolBuf(lpdv, (LPSTR)CmdPrnStrCurrent, sizeof(CmdPrnStrCurrent));
|
|
WriteSpoolBuf(lpdv, lpstr, len);
|
|
|
|
if(len <= 2) {
|
|
/* send Move Position Horizontally command */
|
|
CmdMoveHoriPos[2] = (BYTE)((lpApdl->wWidths * len) >> 8 & 0x00ff);
|
|
CmdMoveHoriPos[3] = (BYTE)((lpApdl->wWidths * len) & 0x00ff);
|
|
WriteSpoolBuf(lpdv, (LPSTR)CmdMoveHoriPos, sizeof(CmdMoveHoriPos));
|
|
}
|
|
}
|
|
}
|
|
/*****************************************************************************/
|
|
/* */
|
|
/* Module: OEMSendScalableFontCmd */
|
|
/* */
|
|
/* Function: send A/PDL-style font selection command. */
|
|
/* */
|
|
/* Syntax: VOID PASCAL OEMSendScalableFontCmd(LPDV, LPCD, LPFONTINFO) */
|
|
/* */
|
|
/* Input: lpdv address of PDEVICE structure */
|
|
/* lpcd offset to the command heap */
|
|
/* lpFont deveice font information */
|
|
/* */
|
|
/* Output: VOID */
|
|
/* */
|
|
/* Notice: */
|
|
/* */
|
|
/*****************************************************************************/
|
|
VOID PASCAL OEMSendScalableFontCmd(LPDV lpdv, LPCD lpcd, LPFONTINFO lpFont)
|
|
{
|
|
LPSTR lpcmd;
|
|
short ocmd;
|
|
WORD wCount;
|
|
BYTE rgcmd[CCHMAXCMDLEN]; // build command here
|
|
LPAPDL lpApdl = lpdv->lpMdv;
|
|
WORD wHeight;
|
|
WORD wWidth;
|
|
|
|
if (!lpcd || !lpFont)
|
|
return;
|
|
|
|
// be careful about integer overflow.
|
|
lpcmd = (LPSTR)(lpcd+1);
|
|
ocmd = 0;
|
|
|
|
for (wCount = 0; wCount < lpcd->wLength && ocmd < CCHMAXCMDLEN; )
|
|
if (lpcmd[wCount] == '#' && lpcmd[wCount + 1] == 'H'){ // height
|
|
wHeight = (lpFont->dfPixHeight - lpFont->dfInternalLeading);
|
|
rgcmd[ocmd++] = HIBYTE(wHeight);
|
|
rgcmd[ocmd++] = LOBYTE(wHeight);
|
|
wCount += 2;
|
|
}
|
|
else {
|
|
if (lpcmd[wCount] == '#' && lpcmd[wCount + 1] == 'W'){ // width
|
|
if (lpFont->dfPixWidth > 0){
|
|
wWidth = lpFont->dfMaxWidth;
|
|
rgcmd[ocmd++] = HIBYTE(wWidth);
|
|
rgcmd[ocmd++] = LOBYTE(wWidth);
|
|
|
|
// move current position for device font in OEMOutputCHar
|
|
lpApdl->wWidths = lpFont->dfAvgWidth;
|
|
}
|
|
wCount += 2;
|
|
}
|
|
else
|
|
rgcmd[ocmd++] = lpcmd[wCount++];
|
|
}
|
|
|
|
WriteSpoolBuf(lpdv, (LPSTR) rgcmd, ocmd);
|
|
}
|
|
/*****************************************************************************/
|
|
/* */
|
|
/* Module: OEMScaleWidth */
|
|
/* */
|
|
/* Function: return the scaled width which is calcualted based on the */
|
|
/* assumption that APDL assumes 72 points in one 1 inch. */
|
|
/* */
|
|
/* Syntax: SHORT PASCAL OEMScaleWidth(SHORT, SHORT, SHORT, SHORT, SHORT) */
|
|
/* */
|
|
/* Input: width in units specified by 'masterUnits' */
|
|
/* masterUnits */
|
|
/* newHeight in units specified by 'vRes' */
|
|
/* vRes height device units */
|
|
/* hRes width device units */
|
|
/* */
|
|
/* Output: short */
|
|
/* */
|
|
/* Notice: <extent> : <font units> = <base Width> : <hRes> */
|
|
/* <base width> : <etmMasterHeight> = <newWidth> : <newHeight> */
|
|
/* <etmMasterUnits> : <etmMasterHeight> = <font units> : <vRes> */
|
|
/* <newWidth> = (<extent> * <hRes> * <newHeight>) / */
|
|
/* (<etmMasterUnits> * <vRes>) */
|
|
/* */
|
|
/*****************************************************************************/
|
|
SHORT PASCAL OEMScaleWidth(SHORT width,
|
|
SHORT masterUnits, SHORT newHeight, SHORT vRes, SHORT hRes)
|
|
{
|
|
DWORD newWidth10;
|
|
short newWidth;
|
|
|
|
// assert that hRes == vRes to avoid overflow problem.
|
|
if (vRes != hRes)
|
|
return 0;
|
|
|
|
newWidth10 = (DWORD)width * (DWORD)newHeight * 10;
|
|
newWidth10 /= (DWORD)masterUnits;
|
|
|
|
// we multiplied 10 first in order to maintain the precision of
|
|
// the width calcution. Now convert it back and round to the
|
|
// nearest integer.
|
|
newWidth = (short)((newWidth10 + 5) / 10);
|
|
|
|
return newWidth;
|
|
}
|
|
/*****************************************************************************/
|
|
/* */
|
|
/* Module: SetDrawArea */
|
|
/* */
|
|
/* Function: */
|
|
/* */
|
|
/* Syntax: BYTE PASCAL SetDrawArea(LPDV, WORD) */
|
|
/* */
|
|
/* Input: lpdv */
|
|
/* wCmdCbId */
|
|
/* */
|
|
/* Output: BYTE */
|
|
/* */
|
|
/* Notice: */
|
|
/* */
|
|
/*****************************************************************************/
|
|
BYTE PASCAL SetDrawArea(LPDV lpdv, WORD wCmdCbId)
|
|
{
|
|
LPAPDL lpApdl = lpdv->lpMdv;
|
|
WORD wWidth;
|
|
WORD wHeight;
|
|
BYTE bIndex;
|
|
|
|
if(wCmdCbId != PHYS_PAPER_UNFIXED){
|
|
bIndex = (BYTE)(wCmdCbId - PAPERSIZE_MAGIC);
|
|
wWidth = phySize[bIndex].wWidth / (MASTER_UNIT / (WORD)lpApdl->ulHorzRes);
|
|
wHeight= phySize[bIndex].wHeight / (MASTER_UNIT / (WORD)lpApdl->ulHorzRes);
|
|
} else {
|
|
bIndex = 0x7f;
|
|
if(lpApdl->ulHorzRes == 600){
|
|
if(lpApdl->fOrientation){ // portrait
|
|
wWidth = (WORD)lpApdl->szlPhysSize.cx - (0x5e * 2);
|
|
wHeight= (WORD)lpApdl->szlPhysSize.cy - (0x5e * 2);
|
|
} else { // landscape
|
|
wWidth = (WORD)lpApdl->szlPhysSize.cy - (0x5e * 2);
|
|
wHeight= (WORD)lpApdl->szlPhysSize.cx - (0x5e * 2);
|
|
}
|
|
} else {
|
|
if(lpApdl->fOrientation){ // portrait
|
|
wWidth = (WORD)lpApdl->szlPhysSize.cx - (0x2f * 2);
|
|
wHeight= (WORD)lpApdl->szlPhysSize.cy - (0x2f * 2);
|
|
} else { // landscape
|
|
wWidth = (WORD)lpApdl->szlPhysSize.cy - (0x2f * 2);
|
|
wHeight= (WORD)lpApdl->szlPhysSize.cx - (0x2f * 2);
|
|
}
|
|
}
|
|
}
|
|
|
|
/* set value of width, height into DefineDrawingArea command */
|
|
CmdDefDrawArea[9] = (BYTE)(wWidth >> 8 & 0x00ff);
|
|
CmdDefDrawArea[10] = (BYTE)(wWidth & 0x00ff);
|
|
CmdDefDrawArea[11] = (BYTE)(wHeight >> 8 & 0x00ff);
|
|
CmdDefDrawArea[12] = (BYTE)(wHeight & 0x00ff);
|
|
|
|
/* set value of Origin-X, Y into DefineDrawingArea command */
|
|
if(lpApdl->ulHorzRes == 600){
|
|
CmdDefDrawArea[5] = CmdDefDrawArea[7] = 0x00;
|
|
CmdDefDrawArea[6] = CmdDefDrawArea[8] = 0x5e;
|
|
} else {
|
|
CmdDefDrawArea[5] = CmdDefDrawArea[7] = 0x00;
|
|
CmdDefDrawArea[6] = CmdDefDrawArea[8] = 0x2f;
|
|
}
|
|
|
|
/* set Media Origin into DefineDrawingArea command */
|
|
if(lpApdl->fOrientation) // portrait
|
|
CmdDefDrawArea[15] = 0x00;
|
|
else { // landscape
|
|
if( wCmdCbId==50 || wCmdCbId==54 || wCmdCbId==61)
|
|
CmdDefDrawArea[15] = 0x01; // A3 or B4 or Unfixed
|
|
else
|
|
CmdDefDrawArea[15] = 0x03;
|
|
}
|
|
|
|
return bIndex;
|
|
}
|
|
/*****************************************************************************/
|
|
/* */
|
|
/* Module: BRL_Ecmd */
|
|
/* */
|
|
/* Function: ByteRunLength(HBP) Compression Routine */
|
|
/* */
|
|
/* Syntax: WORD PASCAL BRL_Ecmd(LPBYTE, LPBYTE, LPBYTE, WORD) */
|
|
/* */
|
|
/* Input: lpbSrc */
|
|
/* lpbTgt */
|
|
/* lpbTmp */
|
|
/* len */
|
|
/* */
|
|
/* Output: WORD */
|
|
/* */
|
|
/* Notice: */
|
|
/* */
|
|
/*****************************************************************************/
|
|
WORD PASCAL BRL_ECmd(LPBYTE lpbSrc, LPBYTE lpbTgt, LPBYTE lpbTmp, WORD len)
|
|
{
|
|
|
|
BYTE bRCnt = 1; // repeating byte counter
|
|
BYTE bNRCnt = 0; // non-repeating byte counter
|
|
BYTE bSaveRCnt;
|
|
WORD i = 0, j = 0, k = 0, l = 0; // movement trackers
|
|
char Go4LastByte = TRUE; // flag to get last byte
|
|
|
|
/* initialize data */
|
|
_fmemcpy(lpbTmp,(LPBYTE)lpbSrc,len);
|
|
|
|
/* start compression routine - ByteRunLength Encoding */
|
|
do {
|
|
if(lpbSrc[i] != (lpbSrc[i+1])) { // non-repeating data?
|
|
while(((lpbTmp[i] != (lpbTmp[i+1]))
|
|
&& ((i+1) < len)) && (bNRCnt < NRPEAK)) {
|
|
bNRCnt++; // if so, how many?
|
|
i++;
|
|
}
|
|
|
|
/* if at last element but less than NRPEAK value */
|
|
if(((i+1)==len) && (bNRCnt<NRPEAK)) {
|
|
bNRCnt++; // inc count for last element
|
|
Go4LastByte = FALSE; // no need to go back
|
|
} else
|
|
/* if at last BYTE, but before that, NRPEAK value has been reached */
|
|
if(((i+1)==len) && ((bNRCnt)==NRPEAK))
|
|
Go4LastByte = TRUE; // get the last BYTE
|
|
|
|
/* assign the value for Number of Non-repeating bytes */
|
|
lpbTgt[j] = bNRCnt-1; // subtract one for WinP's case
|
|
j++; // update tracker
|
|
|
|
/* afterwards...write the Raw Data */
|
|
for (l=0; l<bNRCnt;l++) {
|
|
lpbTgt[j] = lpbSrc[k];
|
|
k++;
|
|
j++;
|
|
}
|
|
|
|
/* reset counter */
|
|
bNRCnt = 0;
|
|
} else { // end of Non-repeating data
|
|
// data is repeating
|
|
while(((lpbTmp[i]==(lpbTmp[i+1])) && ((i+1)<len)) && (bRCnt<RPEAK)) {
|
|
bRCnt++;
|
|
i++;
|
|
}
|
|
|
|
/* Convert to Two's Complement */
|
|
bSaveRCnt = bRCnt; // save original value
|
|
bRCnt = (BYTE) 0 - bRCnt;
|
|
|
|
/* Write the Number of Repeating Data */
|
|
lpbTgt[j] = bRCnt + 1; // add one for WinP's case
|
|
j++; // go to next element
|
|
|
|
/* afterwards...write the Repeating data */
|
|
lpbTgt[j] = lpbSrc[k];
|
|
j++;
|
|
|
|
/* update counters */
|
|
k += bSaveRCnt;
|
|
bRCnt = 1;
|
|
i += 1;
|
|
|
|
/* check if last element has been reached */
|
|
if (i==len)
|
|
Go4LastByte=FALSE; // if so, no need to go back
|
|
} // end of Repeating data
|
|
} while (Go4LastByte); // end of Compression
|
|
|
|
return ( j );
|
|
}
|
|
|
|
/*****************************************************************************/
|
|
/* */
|
|
/* Module: fnOEMGetFontCmd */
|
|
/* */
|
|
/* Function: */
|
|
/* */
|
|
/* Syntax: BOOL fnOEMGetFontCmd(LPDV, WORD, PVOID, BOOL, PBYTE, PWORD) */
|
|
/* */
|
|
/* Input： lpdv */
|
|
/* wCmdCbId */
|
|
/* lpFont */
|
|
/* fSelect */
|
|
/* lpBuf */
|
|
/* lpwSize */
|
|
/* */
|
|
/* Output： */
|
|
/* */
|
|
/* Notice： */
|
|
/* */
|
|
/* History： 1996.05.20 Ver 1.00 */
|
|
/* */
|
|
/*****************************************************************************/
|
|
BOOL PASCAL OEMGetFontCmd(LPDV lpdv, WORD wCmdCbId, PVOID lpFont,
|
|
BOOL fSelect, PBYTE lpBuf, PWORD lpwSize)
|
|
{
|
|
return (TRUE);
|
|
}
|