archive
/
windows-server-2003
mirror of https://github.com/selfrender/Windows-Server-2003
2
0
Fork 0
Code Issues Projects Releases Wiki Activity
Leaked source code of windows server 2003
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.
4 Commits
1 Branch
0 Tags
1.5 GiB
 
 
 
 
 
 
Tree: 5c6fe3db62
Branches Tags
${ item.name }
Create tag ${ searchTerm }
Create branch ${ searchTerm }
from '5c6fe3db62'
${ noResults }
windows-server-2003/printscan/print/drivers/usermode/gpdres/rpdlres/rpdlres.c

5309 lines
223 KiB
Raw Blame History

/*++
Copyright (c) 1996-2002 Microsoft Corp. & Ricoh Co., Ltd. All rights reserved.
FILE: RPDLRES.C
Abstract: Main file for OEM rendering plugin module.
Functions: OEMCommandCallback
bOEMSendFontCmd
bOEMOutputCharStr
OEMDownloadFontHeader
OEMDownloadCharGlyph
OEMTTDownloadMethod
OEMCompression
Environment: Windows NT Unidrv5 driver
Revision History:
04/07/1997 -zhanw-
Created it.
08/11/1997 -Masatoshi Kubokura-
Began to modify for RPDL.
04/22/1999 -Masatoshi Kubokura-
Last modified for Windows2000.
08/30/1999 -Masatoshi Kubokura-
Began to modify for NT4SP6(Unidrv5.4).
09/27/1999 -Masatoshi Kubokura-
Last modified for NT4SP6.
02/17/2000 -Masatoshi Kubokura-
V.1.02 release
04/07/2000 -Masatoshi Kubokura-
Fix bug of SET_IBM_EXT_BLOCK with 1200dpi printer (RPDL bug)
05/22/2000 -Masatoshi Kubokura-
V.1.03 for NT4 release
06/30/2000 -Masatoshi Kubokura-
V.1.04 release
01/22/2001 -Masatoshi Kubokura-
V.1.05 release
02/05/2001 -Masatoshi Kubokura-
Add "Thick Paper"
03/15/2001 -Masatoshi Kubokura-
Fix RectangleFill bug
Last modified for XP(Whistler).
06/29/2001 -Masatoshi Kubokura-
V.1.07
Fix RPDL staple bug.(NX800,810,910,MF2230,2730,3530e,3570e,4570e).
Enable SET_PAPERDEST_FINISHER at GW model.
03/04/2002 -Masatoshi Kubokura-
Include strsafe.h.
Add FileNameBufSize as arg3 at RWFileData().
Use safe_sprintfA() instead of sprintf().
03/27/2002 -Masatoshi Kubokura-
Eliminate "#if 0".
04/02/2002 -Masatoshi Kubokura-
Check pdevobj NULL pointer before using at OEMCommandCallback().
11/20-22/2002 -yasuho & Kubokura-
Fix memory leak.
Last modified for .NET Server.
--*/
#include <stdio.h>
#include "pdev.h"
#ifndef WINNT_40
#include "strsafe.h" // @Mar/01/2002
#endif // !WINNT_40
#if DBG
//#define DBG_OUTPUTCHARSTR 1
//#define giDebugLevel DBG_VERBOSE // enable VERBOSE() in each file
#endif
//
// Misc definitions and declarations.
//
#define STDVAR_BUFSIZE(n) \
(sizeof (GETINFO_STDVAR) + sizeof(DWORD) * 2 * ((n) - 1)) // MSKK 1/24/98
#define MASTER_TO_SPACING_UNIT(p, n) \
((n) / (p)->nResoRatio)
#ifndef WINNT_40
//#define sprintf wsprintfA // @Sep/30/98
#define strcmp lstrcmpA // @Sep/30/98
#endif // WINNT_40
// External Functions' prototype
// @Mar/01/2002 ->
//extern BOOL RWFileData(PFILEDATA pFileData, LPWSTR pwszFileName, LONG type); // add pwszFileName @Aug/31/99
extern BOOL RWFileData(PFILEDATA pFileData, LPWSTR pwszFileName, LONG FileNameBufSize, LONG type);
extern INT safe_sprintfA(char* pszDest, size_t cchDest, const char* pszFormat, ...);
// @Mar/01/2002 <-
// Local Functions' prototype
static BYTE IsDBCSLeadByteRPDL(BYTE Ch);
static BYTE IsDifferentPRNFONT(BYTE Ch);
static VOID DrawTOMBO(PDEVOBJ pdevobj, SHORT action);
static VOID AssignIBMfont(PDEVOBJ pdevobj, SHORT rcID, SHORT action);
static VOID SendFaxNum(PDEVOBJ pdevobj);
#ifdef JISGTT
static VOID jis2sjis(BYTE jis[], BYTE sjis[]);
#endif // JISGTT
static INT DRCompression(PBYTE pInBuf, PBYTE pOutBuf, DWORD dwInLen, DWORD dwOutLen,
DWORD dwWidthByte, DWORD dwHeight);
//
// Static data to be used by this minidriver.
//
static BYTE ShiftJisRPDL[256] = {
// +0 +1 +2 +3 +4 +5 +6 +7 +8 +9 +A +B +C +D +E +F
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, //00
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, //10
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, //20
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, //30
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, //40
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, //50
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, //60
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, //70
0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, //80
1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, //90
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, //A0
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, //B0
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, //C0
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, //D0
1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, //E0
1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0 //F0
};
// Some vertical device font differ from TrueType font
static BYTE VerticalFontCheck[256] = {
// +0 +1 +2 +3 +4 +5 +6 +7 +8 +9 +A +B +C +D +E +F
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, //00
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, //10
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, //20
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, //30
0, 0, 0, 0, 0, 0, 1, 1, 0, 0, 1, 1, 0, 0, 0, 0, //40
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, //50
0, 0, 0, 0, 0, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, //60
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 0, 0, //70
1, 0, 1, 1, 1, 1, 1, 0, 0, 0, 0, 1, 1, 1, 0, 0, //80
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, //90
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, //A0
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, //B0
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, //C0
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, //D0
1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, //E0
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 //F0
};
static BYTE UpdateDate[] = "04/04/2002";
// OBSOLETE (described in GPD) @Feb/15/98 ->
// Emulation Mode after printing
//static BYTE *RPDLProgName[] = {
// "1@R98", "1@R16", "1@RPS", "1@R55", // 0- 3
// "1@RGL", "1@GL2", "1@R52", "1@R73", // 4- 7
// "1@R35", "1@R01", // 8- 9
// "0@P1", "0@P2", "0@P3", "0@P4", // 10-13
// "0@P5", "0@P6", "0@P7", "0@P8", // 14-17
// "0@P9", "0@P10", "0@P11", "0@P12", // 18-21
// "0@P13", "0@P14", "0@P15", "0@P16" // 22-25
//};
//static BYTE *RPDLProgName2[] = {
// "-1,1,1@R98", "-1,1,1@R16", "-1,1,1@RPS", "-1,1,1@R55", // 0- 3
// "-1,1,1@RGL", "-1,1,1@GL2", "-1,1,1@R52", "-1,1,1@R73", // 4- 7
// "-1,1,1@R35", "-1,1,1@R01", // 8- 9
// "0,1,2@P1", "0,1,2@P2", "0,1,2@P3", "0,1,2@P4", // 10-13
// "0,1,2@P5", "0,1,2@P6", "0,1,2@P7", "0,1,2@P8", // 14-17
// "0,1,2@P9", "0,1,2@P10", "0,1,2@P11", "0,1,2@P12", // 18-21
// "0,1,2@P13", "0,1,2@P14", "0,1,2@P15", "0,1,2@P16" // 22-25
//};
//#define PRG_RPGL 4
// @Feb/15/98 <-
// RPDL pagesize (unit:masterunit)
static POINT RPDLPageSize[] = {
{2688L*MASTERUNIT/240L, 3888L*MASTERUNIT/240L}, // A3
{1872L*MASTERUNIT/240L, 2720L*MASTERUNIT/240L}, // A4
{1280L*MASTERUNIT/240L, 1904L*MASTERUNIT/240L}, // A5
{ 880L*MASTERUNIT/240L, 1312L*MASTERUNIT/240L}, // A6
{2336L*MASTERUNIT/240L, 3352L*MASTERUNIT/240L}, // B4
{1600L*MASTERUNIT/240L, 2352L*MASTERUNIT/240L}, // B5
{1104L*MASTERUNIT/240L, 1640L*MASTERUNIT/240L}, // B6
{2528L*MASTERUNIT/240L, 4000L*MASTERUNIT/240L}, // Tabloid
{1920L*MASTERUNIT/240L, 3280L*MASTERUNIT/240L}, // Legal
{1920L*MASTERUNIT/240L, 2528L*MASTERUNIT/240L}, // Letter
{1200L*MASTERUNIT/240L, 1968L*MASTERUNIT/240L}, // Statement
{3969L*MASTERUNIT/240L, 5613L*MASTERUNIT/240L}, // A2->A3
{6480L*MASTERUNIT/400L, 8960L*MASTERUNIT/400L}, // A2
{6667L*MASTERUNIT/400L, 8448L*MASTERUNIT/400L}, // C
{5587L*MASTERUNIT/400L, 7792L*MASTERUNIT/400L}, // B3 @Jan/07/98
{2688L*MASTERUNIT/240L, 3888L*MASTERUNIT/240L}, // A3->A4 @Feb/04/98
{2336L*MASTERUNIT/240L, 3352L*MASTERUNIT/240L}, // B4->A4 @Feb/04/98
{6600L*MASTERUNIT/600L, 8160L*MASTERUNIT/600L}, // 11x15->A4 @Jan/27/2000
{ 880L*MASTERUNIT/240L, 1312L*MASTERUNIT/240L} // Postcard since NX700 @Feb/13/98
};
#define PAGESPACE_2IN1_100 12 // mm
static WORD PageSpace_2IN1_67[] = {
30, 23, 22, 18, // A3,A4,A5,A6
25, 23, 19, 56, // B4,B5,B6,Tabloid
6, 6, 35, 6, // Legal(disable),Letter,Statement,A2->A3(disable)
6, 6, 6, 6, // A2(disable),C(disable),B3(disable),A3->A4(disable)
6, 6, 6 // B4->A4(disable),11x15->A4(disable),Postcard(disable)
};
static POINT RPDLPageSizeE2E[] = {
{(2970000L/254L+5L)/10L*MASTERUNIT/100L, (4200000L/254L+5L)/10L*MASTERUNIT/100L}, // A3
{(2100000L/254L+5L)/10L*MASTERUNIT/100L, (2970000L/254L+5L)/10L*MASTERUNIT/100L}, // A4
{(1480000L/254L+5L)/10L*MASTERUNIT/100L, (2100000L/254L+5L)/10L*MASTERUNIT/100L}, // A5
{(1050000L/254L+5L)/10L*MASTERUNIT/100L, (1480000L/254L+5L)/10L*MASTERUNIT/100L}, // A6
{(2570000L/254L+5L)/10L*MASTERUNIT/100L, (3640000L/254L+5L)/10L*MASTERUNIT/100L}, // B4
{(1820000L/254L+5L)/10L*MASTERUNIT/100L, (2570000L/254L+5L)/10L*MASTERUNIT/100L}, // B5
{(1280000L/254L+5L)/10L*MASTERUNIT/100L, (1820000L/254L+5L)/10L*MASTERUNIT/100L}, // B6
{110L*MASTERUNIT/10L, 170L*MASTERUNIT/10L}, // Tabloid
{ 85L*MASTERUNIT/10L, 140L*MASTERUNIT/10L}, // Legal
{ 85L*MASTERUNIT/10L, 110L*MASTERUNIT/10L}, // Letter
{ 55L*MASTERUNIT/10L, 85L*MASTERUNIT/10L}, // Statement
{(4200000L/254L+5L)/10L*MASTERUNIT/100L, (5940000L/254L+5L)/10L*MASTERUNIT/100L}, // A2->A3
{(4200000L/254L+5L)/10L*MASTERUNIT/100L, (5940000L/254L+5L)/10L*MASTERUNIT/100L}, // A2
{170L*MASTERUNIT/10L, 220L*MASTERUNIT/10L}, // C
{(3640000L/254L+5L)/10L*MASTERUNIT/100L, (5140000L/254L+5L)/10L*MASTERUNIT/100L}, // B3
{(2970000L/254L+5L)/10L*MASTERUNIT/100L, (4200000L/254L+5L)/10L*MASTERUNIT/100L}, // A3->A4
{(2570000L/254L+5L)/10L*MASTERUNIT/100L, (3640000L/254L+5L)/10L*MASTERUNIT/100L}, // B4->A4
{110L*MASTERUNIT/10L, 150L*MASTERUNIT/10L}, // 11x15 -> A4 @Jan/27/2000
{(1000000L/254L+5L)/10L*MASTERUNIT/100L, (1480000L/254L+5L)/10L*MASTERUNIT/100L} // Postcard since NX700
};
#define PAGESPACE_2IN1_100E2E 0 // mm
static WORD PageSpace_2IN1_67E2E[] = {
18, 11, 10, 6, // A3,A4,A5,A6
15, 11, 9, 43, // B4,B5,B6,Tabloid
0, 0, 23, 0, // Legal(disable),Letter,Statement,A2->A3(disable)
0, 0, 0, 0, // A2(disable),C(disable),B3(disable),A3->A4(disable)
0, 0, 0 // B4->A4(disable),11x15->A4(disable),Postcard(disable)
};
#define RPDL_A3 0
#define RPDL_A4 1
#define RPDL_A5 2
#define RPDL_A6 3 // A6/Postcard
#define RPDL_B4 4
#define RPDL_B5 5
#define RPDL_B6 6
#define RPDL_TABD 7
#define RPDL_LEGL 8
#define RPDL_LETR 9
#define RPDL_STAT 10
#define RPDL_A2A3 11
#define RPDL_A2 12
#define RPDL_C 13
#define RPDL_B3 14
#define RPDL_A3A4 15
#define RPDL_B4A4 16
#define RPDL_11x15A4 17 // @Jan/27/2000
#define RPDL_POSTCARD 18 // Postcard since NX700
#define RPDL_CUSTOMSIZE 99
// RPDL command definition
static BYTE BS[] = "\x08";
static BYTE FF[] = "\x0C";
static BYTE CR[] = "\x0D";
static BYTE LF[] = "\x0A";
static BYTE DOUBLE_BS[] = "\x08\x08";
static BYTE DOUBLE_SPACE[] = "\x20\x20";
static BYTE BEGIN_SEND_BLOCK_C[] = "\x1B\x12G3,%d,%d,,2,,,%u@";
static BYTE BEGIN_SEND_BLOCK_NC[] = "\x1B\x12G3,%d,%d,,,@";
static BYTE BEGIN_SEND_BLOCK_DRC[] = "\x1B\x12G3,%d,%d,,5,,@";
static BYTE ESC_ROT0[] = "\x1B\x12\x46\x30\x20";
static BYTE ESC_ROT90[] = "\x1B\x12\x46\x39\x30\x20";
static BYTE ESC_VERT_ON[] = "\x1B\x12&2\x20";
static BYTE ESC_VERT_OFF[] = "\x1B\x12&1\x20";
static BYTE ESC_SHIFT_IN[] = "\x1B\x0F";
static BYTE ESC_SHIFT_OUT[] = "\x1B\x0E";
static BYTE ESC_CTRLCODE[] = "\x1B\x12K1\x20";
static BYTE ESC_HALFDOWN[] = "\x1B\x55";
static BYTE ESC_HALFUP[] = "\x1B\x44";
static BYTE ESC_DOWN[] = "\x1B\x55\x1B\x55";
static BYTE ESC_UP[] = "\x1B\x44\x1B\x44";
static BYTE ESC_BOLD_ON[] = "\x1BO";
static BYTE ESC_BOLD_OFF[] = "\x1B&";
static BYTE ESC_ITALIC_ON[] = "\x1B\x12I-16\x20";
static BYTE ESC_ITALIC_OFF[] = "\x1B\x12I0\x20";
static BYTE ESC_WHITETEXT_ON[] = "\x1B\x12W5,0\x20";
static BYTE ESC_WHITETEXT_OFF[] = "\x1B\x12W0,0\x20";
static BYTE ESC_XM_ABS[] = "\x1B\x12H%d\x20";
static BYTE ESC_XM_REL[] = "\x1B\x12\x20+%d\x20";
static BYTE ESC_XM_RELLEFT[] = "\x1B\x12\x20-%d\x20";
static BYTE ESC_YM_ABS[] = "\x1B\x12V%d\x20";
static BYTE ESC_YM_REL[] = "\x1B\x12\x0A+%d\x20";
static BYTE ESC_YM_RELUP[] = "\x1B\x12\x0A-%d\x20";
static BYTE ESC_CLIPPING[] = "\x1B\x12*%d,%d,%d,%d\x20";
static BYTE SELECT_PAPER_CUSTOM[] = "\x1B\x12\x3F\x35%ld,%ld\x1B\x20";
static BYTE SELECT_PAPER_CUSTOM2[]= "\x1B\x12\x3F\x35%ld,%ld,%d\x1B\x20"; // %ld<-%d @Sep/27/2000, %d<-%c @Oct/13/2000
static BYTE SELECT_TRAY_N[] = "\x1B\x19%d"; // %d<-%c @Oct/13/2000
static BYTE SELECT_PAPER_HEAD[] = "\x1B\x12\x35\x32@";
static BYTE SEL_TRAY_PAPER_HEAD[] = "\x1B\x12\x35@";
static BYTE SELECT_PAPER_HEAD_IP1[] = "\x1B\x12\x35\x33@";
static BYTE SELECT_PAPER_A1[] = "A1\x1B\x20";
static BYTE SELECT_PAPER_A2[] = "A2\x1B\x20";
static BYTE SELECT_PAPER_A3[] = "A3\x1B\x20";
static BYTE SELECT_PAPER_A4[] = "A4\x1B\x20"; // @May/25/98
static BYTE SELECT_PAPER_A4R[] = "A4R\x1B\x20";
static BYTE SELECT_PAPER_A4X[] = "A4X\x1B\x20";
static BYTE SELECT_PAPER_A4W[] = "A4R\x1B\x20\x1B\x12\x35@A4\x1B\x20";
static BYTE SELECT_PAPER_A5[] = "A5\x1B\x20"; // @May/25/98
static BYTE SELECT_PAPER_A5R[] = "A5R\x1B\x20";
static BYTE SELECT_PAPER_A5X[] = "A5X\x1B\x20";
static BYTE SELECT_PAPER_A5W[] = "A5R\x1B\x20\x1B\x12\x35@A5\x1B\x20";
static BYTE SELECT_PAPER_A6[] = "A6\x1B\x20";
static BYTE SELECT_PAPER_PC[] = "PC\x1B\x20"; // @May/25/98
static BYTE SELECT_PAPER_PCR[] = "PCR\x1B\x20"; // @Feb/13/98
static BYTE SELECT_PAPER_PCX[] = "PCX\x1B\x20"; // @Feb/13/98
static BYTE SELECT_PAPER_B3[] = "B3\x1B\x20"; // @Jan/07/98
static BYTE SELECT_PAPER_B4[] = "B4\x1B\x20";
static BYTE SELECT_PAPER_B5[] = "B5\x1B\x20"; // @May/25/98
static BYTE SELECT_PAPER_B5R[] = "B5R\x1B\x20";
static BYTE SELECT_PAPER_B5X[] = "B5X\x1B\x20";
static BYTE SELECT_PAPER_B5W[] = "B5R\x1B\x20\x1B\x12\x35@B5\x1B\x20";
static BYTE SELECT_PAPER_B6[] = "B6\x1B\x20";
static BYTE SELECT_PAPER_C[] = "FLT\x1B\x20";
static BYTE SELECT_PAPER_TABD[] = "DLT\x1B\x20";
static BYTE SELECT_PAPER_LEGL[] = "LG\x1B\x20";
static BYTE SELECT_PAPER_LETR[] = "LT\x1B\x20"; // @May/25/98
static BYTE SELECT_PAPER_LETRR[] = "LTR\x1B\x20";
static BYTE SELECT_PAPER_LETRX[] = "LTX\x1B\x20";
static BYTE SELECT_PAPER_LETRW[] = "LTR\x1B\x20\x1B\x12\x35@LT\x1B\x20";
static BYTE SELECT_PAPER_STAT[] = "HL\x1B\x20"; // @May/25/98
static BYTE SELECT_PAPER_STATR[] = "HLR\x1B\x20";
static BYTE SELECT_PAPER_STATX[] = "HLX\x1B\x20";
static BYTE SELECT_PAPER_STATW[] = "HLR\x1B\x20\x1B\x12\x35@HLT\x1B\x20";
static BYTE SET_LIMITLESS_SUPPLY[]= "\x1B\x12Z2\x20";
static BYTE RESET_LIMITLESS_SUPPLY[]= "\x1B\x12Z1\x20"; // @Sep/27/2000
static BYTE SELECT_MANUALFEED[] = "\x1B\x19T";
static BYTE SELECT_MULTIFEEDER[] = "\x1B\x19M";
static BYTE SELECT_ROLL1[] = "\x1B\x12Y1,2\x20";
static BYTE SELECT_ROLL2[] = "\x1B\x12Y1,4\x20";
//static BYTE SET_EMULATION[] = "\x1B\x12!%s\x1B\x20";
//static BYTE SET_EMULATION_GL_EX[] = "MS-1,6,11;";
static BYTE SET_PORTRAIT[] = "\x1B\x12\x44\x31\x20";
static BYTE SET_LANDSCAPE[] = "\x1B\x12\x44\x32\x20";
static BYTE SET_LEFTMARGIN[] = "\x1B\x12YK,%d\x20";
static BYTE SET_UPPERMARGIN[] = "\x1B\x12YL,%d\x20";
static BYTE SET_LEFTMARGIN_9II[] = "\x1B\x12?Y,K:%d\x1B\x20";
static BYTE SET_UPPERMARGIN_9II[] = "\x1B\x12?Y,L:%d\x1B\x20";
static BYTE SET_MULTI_COPY[] = "\x1B\x12N%d\x20";
// PRINTER SIDE ISSUE: MF3550 RPDL @Feb/22/99 ->
// Since 'backslash' can't be printed in Japanese region ('KUNIBETSU'),
// set 1st param to 1 for USA region.
//static BYTE SET_IBM_EXT_BLOCK[] = "\x1B\x12?@,,1\x1B\x20";
static BYTE SET_IBM_EXT_BLOCK[] = "\x1B\x12?@1,,1\x1B\x20";
// @Feb/22/99 <-
static BYTE SET_PAGEMAX_VALID[] = "\x1B\x12?+1\x1B\x20";
static BYTE DUPLEX_ON[] = "\x1B\x12\x36\x31,1\x20";
static BYTE DUPLEX_HORZ[] = "\x1B\x12YA3,1\x20";
static BYTE DUPLEX_VERT[] = "\x1B\x12YA3,2\x20";
static BYTE DUPLEX_VERT_R[] = "\x1B\x12YA3,3\x20";
//static BYTE IMAGE_2IN1[] = "\x1B\x12\x36\x32,\x20";
static BYTE IMAGE_OPT_OFF[] = "\x1B\x12\x36\x30,1,0\x20";
static BYTE IMAGE_SCALING_100[] = "\x1B\x12YM,1\x20";
static BYTE IMAGE_SCALING_88[] = "\x1B\x12YM,2\x20";
static BYTE IMAGE_SCALING_80[] = "\x1B\x12YM,3\x20";
static BYTE IMAGE_SCALING_75[] = "\x1B\x12YM,4\x20";
static BYTE IMAGE_SCALING_70[] = "\x1B\x12YM,5\x20";
static BYTE IMAGE_SCALING_67[] = "\x1B\x12YM,6\x20";
static BYTE IMAGE_SCALING_115[] = "\x1B\x12YM,7\x20";
static BYTE IMAGE_SCALING_122[] = "\x1B\x12YM,8\x20";
static BYTE IMAGE_SCALING_141[] = "\x1B\x12YM,9\x20";
static BYTE IMAGE_SCALING_200[] = "\x1B\x12YM,10\x20";
static BYTE IMAGE_SCALING_283[] = "\x1B\x12YM,11\x20";
static BYTE IMAGE_SCALING_400[] = "\x1B\x12YM,12\x20";
static BYTE IMAGE_SCALING_122V[] = "\x1B\x12?M122,1\x1B\x20"; // variable ratio
static BYTE IMAGE_SCALING_141V[] = "\x1B\x12?M141,1\x1B\x20";
static BYTE IMAGE_SCALING_200V[] = "\x1B\x12?M200,1\x1B\x20";
static BYTE IMAGE_SCALING_50V[] = "\x1B\x12?M50,1\x1B\x20";
static BYTE IMAGE_SCALING_VAR[] = "\x1B\x12?M%d,1\x1B\x20";
static BYTE SET_PAPERDEST_OUTTRAY[] = "\x1B\x12\x38\x33,2\x20";
static BYTE SET_PAPERDEST_FINISHER[] = "\x1B\x12\x38\x46,2,%d\x20"; // %d<-1 @Jun/25/2001
static BYTE SET_PAPERDEST_FINISHER_GW[] = "\x1B\x12\x38\x46,,%d\x20"; // @Jun/25/2001
static BYTE SET_PAPERDEST_1BINSHIFT[] = "\x1B\x12\x38\x49,,1\x20"; // @Oct/10/2000
// RPDL SPEC changed at NX900. @Jan/08/99 ->
//static BYTE SET_SORT_ON[] = "\x1B\x12\x36,,1\x20";
static BYTE SET_SORT_ON[] = "\x1B\x12\x36%d,,1\x20";
// @Jan/08/99 <-
static BYTE SET_STAPLE_ON[] = "\x1B\x12?O22,0,%d\x1B\x20";
static BYTE SET_STAPLE_CORNER_ON[] = "\x1B\x12?O22,1,%d\x1B\x20";
static BYTE SET_PUNCH_ON[] = "\x1B\x12?O32,%d\x1B\x20";
static BYTE SELECT_MEDIATYPE[] = "\x1B\x12?6%c,%d\x1B\x20"; // %d<-%c @Oct/13/2000
static BYTE COLLATE_DISABLE_ROT[] = "\x1B\x12?O11\x1B\x20"; // @May/27/98
static BYTE COLLATE_ENABLE_ROT[] = "\x1B\x12?O12\x1B\x20"; // @Jul/31/98
static BYTE SET_TEXTRECT_BLACK[] = "\x1B\x12P3,64\x20";
static BYTE SET_TEXTRECT_WHITE[] = "\x1B\x12W0,3\x20\x1B\x12P3,1\x20"; // @Aug/15/98
static BYTE SET_TEXTRECT_GRAY[] = "\x1B\x12P3,%d,1\x20"; // add ",1" @Aug/15/98
static BYTE DRAW_TEXTRECT[] = "\x1B\x12R%d,%d,%d,%d\x20";
static BYTE DRAW_TEXTRECT_R_P3[] = "\x1B\x12r%d,%d,%d\x20";
static BYTE DRAW_TEXTRECT_R_P4[] = "\x1B\x12r%d,%d,%d,%d\x20";
// @Jun/25/2001 ->
static BYTE BEGINDOC_TOP[] = "\x1B\x12!1@R00\x1B\x20";
static BYTE BEGINDOC_TOP_JOBDEF[] = "\x1B\x12!1@R00\x1B\x20\x1B\x12?JS@\x1B@\x1B@\x1B@\x1B@\x1B\x20";
static BYTE BEGINDOC1_2[] = "\x1B\x34\x1B\x12YJ,3\x20";
// @Jun/25/2001 <-
static BYTE BEGINDOC1[] = "\x1B\x12!1@R00\x1B\x20\x1B\x34\x1B\x12YJ,3\x20";
static BYTE BEGINDOC2_1[] = "\x1B\x12YP,1\x20\x1B\x12YQ,2\x20";
static BYTE BEGINDOC2_2[] = "\x1B\x12YQ,2\x20";
static BYTE BEGINDOC3[] = "\x1B\x12YA6,1\x20";
static BYTE SELECT_RES240_1[] = "\x1B\x12YI,6\x20";
static BYTE SELECT_RES240_2[] = "\x1B\x12YW,2\x20\x1B\x12YA4,2\x20\x1B\x12#3\x20";
static BYTE SELECT_RES400_1[] = "\x1B\x12\x36\x30,1,0\x20\x1B\x12YI,7\x20\x1B\x12YW,1\x20";
static BYTE SELECT_RES400_2[] = "\x1B\x12YA4,1\x20";
static BYTE SELECT_RES400_3[] = "\x1B\x12#2\x20";
static BYTE SELECT_RES600[] = "\x1B\x12\x36\x30,1,0\x20\x1B\x12YI,8\x20\x1B\x12YW,3\x20\x1B\x12YA4,3\x20\x1B\x12#4\x20";
static BYTE SELECT_RES1200[] = "\x1B\x12\x36\x30,1,0\x20\x1B\x12YI,9\x20\x1B\x12YW,4\x20\x1B\x12YA4,4\x20\x1B\x12#5\x20"; // @Mar/02/99
static BYTE SELECT_REGION_STD[] = "\x1B\x12YB,1\x20";
static BYTE SELECT_REGION_E2E[] = "\x1B\x12YB,2\x20";
static BYTE ENDDOC1[] = "\x1B\x12YB,1\x20\x1B\x12YI,1\x20\x1B\x12YJ,1\x20\x1B\x12YM,1\x20";
static BYTE ENDDOC2_240DPI[] = "\x1B\x12YW,2\x20\x1B\x12YA4,2\x20";
static BYTE ENDDOC2_SP9[] = "\x1B\x12YW,2\x20\x1B\x12YA4,1\x20";
static BYTE ENDDOC2_400DPI[] = "\x1B\x12YW,1\x20\x1B\x12YA4,1\x20";
static BYTE ENDDOC3[] = "\x1B\x12#0\x20";
static BYTE ENDDOC4[] = "\x1B\x12\x36\x30,0,0\x20";
static BYTE ENDDOC4_FINISHER[] = "\x1B\x12\x36\x30,0\x20";
static BYTE ENDDOC_JOBDEF_END[] = "\x1B\x12?JE@\x1B@\x1B@\x1B@\x1B@\x1B\x20"; // @Jan/08/99
static BYTE ENDDOC5[] = "\x1B\x1AI";
static BYTE SELECT_SMOOTHING2[] = "\x1B\x12YA2,2\x20";
// If you change FONT_NAME, see AssignIBMfont().
static BYTE SET_IBM_FONT_SCALE[] = "\x1B\x12\x43%d,M,%ld,%ld,4@I55\x20";
static BYTE SET_IBM_FONT_SCALE_H_ONLY[] = "\x1B\x12\x43%d,M,,%ld,4@I55\x20"; // @Jan/29/99
static BYTE *SET_IBM_FONT_NAME[] = {"CHUMINCYO\x1B\x20",
"MINCYO-BOLD\x1B\x20",
"MINCYO-E B\x1B\x20",
"GOTHIC\x1B\x20",
"GOTHIC-M\x1B\x20",
"GOTHIC-E B\x1B\x20",
"MARUGOTHIC\x1B\x20",
"MARUGOTHIC-M\x1B\x20",
"MARUGOTHIC-L\x1B\x20",
"GYOUSHO\x1B\x20",
"KAISHO\x1B\x20",
"KYOUKASHO\x1B\x20"};
static BYTE SET_JIS_FONT_SCALE[] = "\x1B\x12\x43\x5A,M,%ld,%ld@";
static BYTE SET_JIS_FONT_SCALE_H_ONLY[] = "\x1B\x12\x43\x5A,M,,%ld@"; // @Jan/29/99
static BYTE *SET_JIS_FONT_NAME[] = {"CHUMINCYO\x1B\x20",
"MINCYO-BOLD\x1B\x20",
"MINCYO-EXTRA BOLD\x1B\x20",
"GOTHIC\x1B\x20",
"GOTHIC-MEDIUM\x1B\x20",
"GOTHIC-EXTRA BOLD\x1B\x20",
"MARUGOTHIC\x1B\x20",
"MARUGOTHIC-MEDIUM\x1B\x20",
"MARUGOTHIC-LIGHT\x1B\x20",
"GYOUSHO\x1B\x20",
"KAISHO\x1B\x20",
"KYOUKASHO\x1B\x20"};
#ifdef DOWNLOADFONT
//static BYTE DLFONT_MALLOC[] = "\x1B\x12/128,8\x20";
static BYTE DLFONT_MALLOC[] = "\x1B\x12/%d,%d\x20";
static BYTE DLFONT_SEND_BLOCK[] = "\x1B\x12G7,%d,%d,%d,@";
static BYTE DLFONT_SEND_BLOCK_DRC[] = "\x1B\x12G7,%d,%d,%d,5,,,%d@";
static BYTE DLFONT_PRINT[] = "\x1B\x12g%d,,%d\x20";
#endif // DOWNLOADFONT
static BYTE ENTER_VECTOR[] = "\x1B\x33";
static BYTE EXIT_VECTOR[] = "\x1B\x34";
static BYTE TERMINATOR[] = ";";
static BYTE MOVE_ABSOLUTE[] = "MA%d,%d";
static BYTE BAR_CHECKDIGIT[] = "BC1";
static BYTE BAR_H_SET[] = "BH%d";
static BYTE BAR_W_SET_JAN[] = "JW%d";
static BYTE BAR_W_SET_2OF5[] = "TW";
static BYTE BAR_W_SET_C39[] = "CW";
static BYTE BAR_W_SET_NW7[] = "NW";
static BYTE BAR_W_PARAMS[] = "%d,%d,%d,%d,%d";
static BYTE BAR_ROT90[ ] = "RO90";
static BYTE BAR_ROT270[] = "RO270";
// @Dec/07/99 FK#50 ->
static BYTE BAR_W_SET_CUST[] = "CS";
// @Dec/07/99 FK#50 <-
static BYTE *BAR_TYPE[] = {"JL", // JAN(STANDARD)
"JS", // JAN(SHORT)
"TI%d,", // 2of5(INDUSTRIAL)
"TX%d,", // 2of5(MATRIX)
"TL%d,", // 2of5(ITF)
"CD%d,", // CODE39
"NB%d,", // NW-7
// @Dec/07/99 FK#50 ->
"CU%d,", // CUSTOMER
"CE%d", // CODE128(B)
"JU", // UPC(A)
"JE" // UPC(W)
// @Dec/07/99 FK#50 <-
};
static BYTE *BAR_NOFONT[] = {"FJ1,-1", // JAN(STANDARD)
"FJ1,-1", // JAN(SHORT)
"FT2,-1", // 2of5(INDUSTRIAL)
"FT2,-1", // 2of5(MATRIX)
"FT2,-1", // 2of5(ITF)
"FC2,-1", // CODE39
"FN2,-1", // NW-7
// @Dec/07/99 FK#50 ->
"", // CUSTOMER
"FC2,-1", // CODE128
"FJ1,-1", // UPC(A)
"FJ1,-1" // UPC(W)
// @Dec/07/99 FK#50 <-
};
static BYTE PEN_WIDTH[] = "LW%d"; // @Sep/14/98
static BYTE DRAW_TOMBO_POLYLINE[] = "MA%d,%dMRPD%d,%d,%d,%d"; // @Sep/14/98
// @Jun/25/2001 ->
//static BYTE BEGINFAX_HEAD[] = "\x1B\x12!1@R00\x1B\x20\x1B\x12?F1,%d,%d,%d,180,1,";
static BYTE BEGINFAX_HEAD[] = "\x1B\x12?F1,%d,%d,%d,180,1,";
// @Jun/25/2001 <-
static BYTE BEGINFAX_CH[] = "@%d:";
static BYTE BEGINFAX_EXTNUM[] = "%s-";
static BYTE BEGINFAX_TAIL[] = ",%08d,RPDLMINI,%d,1,2,1,1,,1,%d,%s,1,,1,,,1,\x1B\x20";
static BYTE ENDFAX[] = "\x1B\x12?F2,1\x1B\x20";
INT APIENTRY OEMCommandCallback(
PDEVOBJ pdevobj,
DWORD dwCmdCbID,
DWORD dwCount,
PDWORD pdwParams)
{
INT ocmd, iRet;
BYTE Cmd[256];
SHORT nTmp;
LPSTR lpcmd;
WORD fLandscape, fFinisherSR30Active, fDoFormFeed, fPaperX;
// @Apr/02/2002 ->
// POEMUD_EXTRADATA pOEMExtra = MINIPRIVATE_DM(pdevobj); // @Oct/06/98
// POEMPDEV pOEM = MINIDEV_DATA(pdevobj); // @Oct/06/98
POEMUD_EXTRADATA pOEMExtra;
POEMPDEV pOEM;
// @Apr/02/2002 <-
// VERBOSE(("OEMCommandCallback() entry.\n"));
//
// verify pdevobj okay
//
ASSERT(VALID_PDEVOBJ(pdevobj));
// @Apr/02/2002 ->
pOEMExtra = MINIPRIVATE_DM(pdevobj);
pOEM = MINIDEV_DATA(pdevobj);
// @Apr/02/2002 <-
//
// fill in printer commands
//
ocmd = 0;
iRet = 0;
// If TextMode RectangleFill or Move_X,Y are not called now &&
// Move_X,Y command is saved, then flush the command here.
if (dwCmdCbID != CMD_SET_TEXTRECT_W && dwCmdCbID != CMD_SET_TEXTRECT_H &&
dwCmdCbID != CMD_DRAW_TEXTRECT &&
dwCmdCbID != CMD_DRAW_TEXTRECT_REL && // @Dec/11/97
dwCmdCbID != CMD_DRAW_TEXTRECT_WHITE && // @Aug/14/98
dwCmdCbID != CMD_DRAW_TEXTRECT_WHITE_REL && // @Aug/14/98
!(dwCmdCbID >= CMD_XM_ABS && dwCmdCbID <= CMD_YM_RELUP)) // @Aug/28/98
{
if (BITTEST32(pOEM->fGeneral2, TEXTRECT_CONTINUE)) // @Dec/11/97
{
BITCLR32(pOEM->fGeneral2, TEXTRECT_CONTINUE);
// If white-rect has been done before, set raster drawmode to OR. @Jan/20/99
if (!pOEM->TextRectGray)
{
if (BITTEST32(pOEM->fGeneral1, FONT_WHITETEXT_ON))
WRITESPOOLBUF(pdevobj, ESC_WHITETEXT_ON, sizeof(ESC_WHITETEXT_ON)-1);
else
WRITESPOOLBUF(pdevobj, ESC_WHITETEXT_OFF, sizeof(ESC_WHITETEXT_OFF)-1);
}
}
if (dwCmdCbID == CMD_FF)
{
BITCLR32(pOEM->fGeneral1, YM_ABS_GONNAOUT);
BITCLR32(pOEM->fGeneral1, XM_ABS_GONNAOUT);
}
if (BITTEST32(pOEM->fGeneral1, YM_ABS_GONNAOUT))
{
BITCLR32(pOEM->fGeneral1, YM_ABS_GONNAOUT);
// Output Move_Y command here.
ocmd = safe_sprintfA(Cmd, sizeof(Cmd), ESC_YM_ABS, pOEM->TextCurPos.y);
WRITESPOOLBUF(pdevobj, Cmd, ocmd);
}
if (BITTEST32(pOEM->fGeneral1, XM_ABS_GONNAOUT))
{
BITCLR32(pOEM->fGeneral1, XM_ABS_GONNAOUT);
// Output Move_X command here.
ocmd = safe_sprintfA(Cmd, sizeof(Cmd), ESC_XM_ABS, pOEM->TextCurPos.x);
WRITESPOOLBUF(pdevobj, Cmd, ocmd);
}
}
switch (dwCmdCbID) {
case CMD_SET_TEXTRECT_W: // pdwParams:RectXSize
pOEM->TextRect.x = *pdwParams / pOEM->nResoRatio;
break;
case CMD_SET_TEXTRECT_H: // pdwParams:RectYSize
pOEM->TextRect.y = *pdwParams / pOEM->nResoRatio;
break;
case CMD_DRAW_TEXTRECT_WHITE: // @Aug/14/98, pdwParams:DestX,DestY @Aug/28/98
if (pOEM->TextRectGray || !BITTEST32(pOEM->fGeneral2, TEXTRECT_CONTINUE))
{
pOEM->TextRectGray = 0;
WRITESPOOLBUF(pdevobj, SET_TEXTRECT_WHITE, sizeof(SET_TEXTRECT_WHITE)-1);
}
goto _DRAW_RECT;
case CMD_DRAW_TEXTRECT: // pdwParams:DestX,DestY,GrayPercentage
// If white-rect has been done before, set raster drawmode to OR. @Jan/20/99
if (!pOEM->TextRectGray)
{
if (BITTEST32(pOEM->fGeneral1, FONT_WHITETEXT_ON))
WRITESPOOLBUF(pdevobj, ESC_WHITETEXT_ON, sizeof(ESC_WHITETEXT_ON)-1);
else
WRITESPOOLBUF(pdevobj, ESC_WHITETEXT_OFF, sizeof(ESC_WHITETEXT_OFF)-1);
}
if ((WORD)*(pdwParams+2) >= 1 && (WORD)*(pdwParams+2) <= 100 &&
(WORD)*(pdwParams+2) != pOEM->TextRectGray) // @Jan/08/98, 3rd param @Aug/28/98
{
if ((pOEM->TextRectGray = (WORD)*(pdwParams+2)) == 100) // @Aug/26/98
{
ocmd = safe_sprintfA(Cmd, sizeof(Cmd), SET_TEXTRECT_BLACK);
}
else
{
WORD gray;
if ((gray = pOEM->TextRectGray * RPDLGRAYMAX / 100) < RPDLGRAYMIN)
gray = RPDLGRAYMIN; // use RPDLGRAYMIN @Aug/15/98
ocmd = safe_sprintfA(Cmd, sizeof(Cmd), SET_TEXTRECT_GRAY, gray);
}
WRITESPOOLBUF(pdevobj, Cmd, ocmd);
}
_DRAW_RECT: // @Aug/14/98
// @Jan/13/99 ->
if (!BITTEST32(pOEM->fGeneral2, TEXTRECT_CONTINUE))
BITSET32(pOEM->fGeneral2, TEXTRECT_CONTINUE);
// @Jan/13/99 <-
{
LONG x = pOEM->TextCurPos.x;
LONG y = pOEM->TextCurPosRealY; // y without page_length adjustment
LONG w = pOEM->TextRect.x;
LONG h = pOEM->TextRect.y;
LONG dest_x = *pdwParams / pOEM->nResoRatio + pOEM->Offset.x;
// UNIDRV5 SIDE ISSUE
// We can rely on DestX, except when CmdCR is emitted.
// Following bugs are concerned.
// - RPDL117&124: Current x isn't updated by CMD_XM_ABS while device font
// direct(not-substituted) printing. -> DestX is reliable.
// - #236215: DestX doesn't become 0 after CmdCR when current y is 0.
// (SP8 WINPARTy printarea.exe) -> TextCurPos.x is reliable.
// - DestX doesn't become 0 after CmdCR, even though current y isn't 0.
// (NX720N WINPARTy printarea.exe at 1200dpi) -> TextCurPos.x is reliable.
// @Mar/15/2001 ->
// if (!(x != dest_x && x == pOEM->Offset.x && y == pOEM->Offset.y))
if (!(x != dest_x && x == pOEM->Offset.x))
// @Mar/15/2001 <-
pOEM->TextCurPos.x = x = dest_x;
// Convert unit from dot to 1/720inch_unit at OLD models
if (!(TEST_AFTER_SP10(pOEM->fModel) || BITTEST32(pOEM->fModel, GRP_MF150E)))
{
if (pOEM->nResoRatio == MASTERUNIT/240) // 240dpi printer
{
x *= 3; // 3 = 720/240
y *= 3;
w *= 3;
h *= 3;
}
else // MF530,150
{
x *= 18; // 18 = 720/400*10
w = (w * 18 + x % 10) / 10; // Adjust fractional part
x /= 10; // KIRISUTE
y *= 18;
h = (h * 18 + y % 10) / 10;
y /= 10;
}
}
ocmd = safe_sprintfA(Cmd, sizeof(Cmd), DRAW_TEXTRECT, x, y, w, h);
WRITESPOOLBUF(pdevobj, Cmd, ocmd);
}
break;
case CMD_DRAW_TEXTRECT_WHITE_REL: // @Aug/14/98, pdwParams:DestX,DestY @Aug/28/98
if (pOEM->TextRectGray || !BITTEST32(pOEM->fGeneral2, TEXTRECT_CONTINUE))
{
pOEM->TextRectGray = 0;
WRITESPOOLBUF(pdevobj, SET_TEXTRECT_WHITE, sizeof(SET_TEXTRECT_WHITE)-1);
}
goto _DRAW_RECT_REL;
// Relative-coordinate rectangle command since NX-510 @Dec/12/97
case CMD_DRAW_TEXTRECT_REL: // pdwParams:DestX,DestY,GrayPercentage
// If white-rect has been done before, set raster drawmode to OR. @Jan/20/99
if (!pOEM->TextRectGray)
{
if (BITTEST32(pOEM->fGeneral1, FONT_WHITETEXT_ON))
WRITESPOOLBUF(pdevobj, ESC_WHITETEXT_ON, sizeof(ESC_WHITETEXT_ON)-1);
else
WRITESPOOLBUF(pdevobj, ESC_WHITETEXT_OFF, sizeof(ESC_WHITETEXT_OFF)-1);
}
if ((WORD)*(pdwParams+2) >= 1 && (WORD)*(pdwParams+2) <= 100 &&
(WORD)*(pdwParams+2) != pOEM->TextRectGray) // @Jan/08/98, 3rd param @Aug/28/98
{
if ((pOEM->TextRectGray = (WORD)*(pdwParams+2)) == 100) // @Aug/26/98
{
ocmd = safe_sprintfA(Cmd, sizeof(Cmd), SET_TEXTRECT_BLACK);
}
else
{
WORD gray;
if ((gray = pOEM->TextRectGray * RPDLGRAYMAX / 100) < RPDLGRAYMIN)
gray = RPDLGRAYMIN; // use RPDLGRAYMIN @Aug/15/98
ocmd = safe_sprintfA(Cmd, sizeof(Cmd), SET_TEXTRECT_GRAY, gray);
}
WRITESPOOLBUF(pdevobj, Cmd, ocmd);
}
_DRAW_RECT_REL: // @Aug/14/98
{
LONG dest_x = *pdwParams / pOEM->nResoRatio + pOEM->Offset.x;
// UNIDRV5 SIDE ISSUE
// @Mar/15/2001 ->
// if (!(pOEM->TextCurPos.x != dest_x && pOEM->TextCurPos.x == pOEM->Offset.x &&
// pOEM->TextCurPosRealY == pOEM->Offset.y))
if (!(pOEM->TextCurPos.x != dest_x && pOEM->TextCurPos.x == pOEM->Offset.x))
// @Mar/15/2001 <-
{
pOEM->TextCurPos.x = dest_x;
}
}
if (!BITTEST32(pOEM->fGeneral2, TEXTRECT_CONTINUE))
{
BITSET32(pOEM->fGeneral2, TEXTRECT_CONTINUE);
ocmd = safe_sprintfA(Cmd, sizeof(Cmd), DRAW_TEXTRECT,
pOEM->TextCurPos.x, pOEM->TextCurPosRealY,
pOEM->TextRect.x, pOEM->TextRect.y);
}
else
{
LONG x = pOEM->TextCurPos.x - pOEM->TextRectPrevPos.x;
LONG y = pOEM->TextCurPosRealY - pOEM->TextRectPrevPos.y;
// If height is 1dot, this parameter can be omitted.
if (pOEM->TextRect.y != 1)
ocmd = safe_sprintfA(Cmd, sizeof(Cmd), DRAW_TEXTRECT_R_P4, x, y,
pOEM->TextRect.x, pOEM->TextRect.y);
else
ocmd = safe_sprintfA(Cmd, sizeof(Cmd), DRAW_TEXTRECT_R_P3, x, y,
pOEM->TextRect.x);
}
WRITESPOOLBUF(pdevobj, Cmd, ocmd);
pOEM->TextRectPrevPos.x = pOEM->TextCurPos.x;
pOEM->TextRectPrevPos.y = pOEM->TextCurPosRealY;
break;
case CMD_SET_SRCBMP_H: // @Jun/04/98
pOEM->dwSrcBmpHeight = *pdwParams;
break;
case CMD_SET_SRCBMP_W: // @Jun/04/98
pOEM->dwSrcBmpWidthByte = *pdwParams;
break;
case CMD_OEM_COMPRESS_ON: // @Jun/04/98
// VERBOSE(("** OEM_COMPRESS_ON **\n"));
BITSET32(pOEM->fGeneral2, OEM_COMPRESS_ON);
BITCLR32(pOEM->fGeneral1, RLE_COMPRESS_ON);
break;
case CMD_RLE_COMPRESS_ON:
// VERBOSE(("** RLE_COMPRESS_ON **\n"));
BITSET32(pOEM->fGeneral1, RLE_COMPRESS_ON);
BITCLR32(pOEM->fGeneral2, OEM_COMPRESS_ON); // @Jun/04/98
break;
case CMD_COMPRESS_OFF:
// VERBOSE(("** COMPRESS_OFF **\n"));
BITCLR32(pOEM->fGeneral1, RLE_COMPRESS_ON);
BITCLR32(pOEM->fGeneral2, OEM_COMPRESS_ON); // @Jun/04/98
break;
case CMD_SEND_BLOCK: // pdwParams:NumOfDataBytes,RasterDataH&W
// Do FE-DeltaRow compression @Jun/04/98
if (BITTEST32(pOEM->fGeneral2, OEM_COMPRESS_ON))
{
// VERBOSE(("** OEM_COMPRESS_SEND (%d) **\n", *pdwParams));
ocmd = safe_sprintfA(Cmd, sizeof(Cmd), BEGIN_SEND_BLOCK_DRC,
(WORD)*(pdwParams+2) * 8, // RasterDataWidthInBytes
(WORD)*(pdwParams+1)); // RasterDataHeightInPixels
WRITESPOOLBUF(pdevobj, Cmd, ocmd);
}
else
{
// Do FE-RunLength compression
if (BITTEST32(pOEM->fGeneral1, RLE_COMPRESS_ON))
{
// VERBOSE(("** RLE_COMPRESS_SEND (%d) **\n", *pdwParams));
ocmd = safe_sprintfA(Cmd, sizeof(Cmd), BEGIN_SEND_BLOCK_C,
(WORD)*(pdwParams+2) * 8, // RasterDataWidthInBytes
(WORD)*(pdwParams+1), // RasterDataHeightInPixels
(WORD)*pdwParams); // NumOfDataBytes
WRITESPOOLBUF(pdevobj, Cmd, ocmd);
}
// No compression
else
{
// VERBOSE(("** NO_COMPRESS_SEND (%d) **\n", *pdwParams));
{
ocmd = safe_sprintfA(Cmd, sizeof(Cmd), BEGIN_SEND_BLOCK_NC,
(WORD)*(pdwParams+2) * 8, // RasterDataWidthInBytes
(WORD)*(pdwParams+1)); // RasterDataHeightInPixels
WRITESPOOLBUF(pdevobj, Cmd, ocmd);
}
}
}
break;
case CMD_XM_ABS: // pdwParams:DestX
if (!BITTEST32(pOEM->fGeneral2, BARCODE_DATA_VALID))
{
#ifdef DOWNLOADFONT
pOEM->nCharPosMoveX = 0;
#endif // DOWNLOADFONT
iRet = pOEM->TextCurPos.x = *pdwParams / pOEM->nResoRatio; // @Aug/28/98
pOEM->TextCurPos.x += pOEM->Offset.x;
// Output Move_X command later.
BITSET32(pOEM->fGeneral1, XM_ABS_GONNAOUT);
// VERBOSE(("** CMD_XM_ABS iRet=%d **\n", iRet));
}
break;
case CMD_YM_ABS: // pdwParams:DestY
if (!BITTEST32(pOEM->fGeneral2, BARCODE_DATA_VALID))
{
iRet = pOEM->TextCurPos.y = *pdwParams / pOEM->nResoRatio; // @Aug/28/98
pOEM->TextCurPosRealY = pOEM->TextCurPos.y;
// PRINTER SIDE ISSUE: RPDL
// Because RPDL do formfeed when vertical position is around
// ymax-coordinate, we shift position upper 1mm.
if (pOEM->TextCurPos.y > pOEM->PageMaxMoveY)
pOEM->TextCurPos.y = pOEM->PageMaxMoveY;
pOEM->TextCurPos.y += pOEM->Offset.y;
pOEM->TextCurPosRealY += pOEM->Offset.y;
// Output Move_Y command later.
BITSET32(pOEM->fGeneral1, YM_ABS_GONNAOUT);
// VERBOSE(("** CMD_YM_ABS iRet=%d **\n", iRet));
}
break;
case CMD_XM_REL: // pdwParams:DestXRel
if (!BITTEST32(pOEM->fGeneral2, BARCODE_DATA_VALID))
{
iRet = *pdwParams / pOEM->nResoRatio; // @Aug/28/98
pOEM->TextCurPos.x += iRet;
// Output Move_X command later.
BITSET32(pOEM->fGeneral1, XM_ABS_GONNAOUT);
}
break;
case CMD_XM_RELLEFT: // pdwParams:DestXRel
if (!BITTEST32(pOEM->fGeneral2, BARCODE_DATA_VALID))
{
iRet = *pdwParams / pOEM->nResoRatio; // @Aug/28/98
pOEM->TextCurPos.x -= iRet;
// Output Move_X command later.
BITSET32(pOEM->fGeneral1, XM_ABS_GONNAOUT);
}
break;
case CMD_YM_REL: // pdwParams:DestYRel
if (!BITTEST32(pOEM->fGeneral2, BARCODE_DATA_VALID))
{
iRet = *pdwParams / pOEM->nResoRatio; // @Aug/28/98
pOEM->TextCurPos.y += iRet;
pOEM->TextCurPosRealY = pOEM->TextCurPos.y;
if (pOEM->TextCurPos.y > pOEM->PageMaxMoveY)
pOEM->TextCurPos.y = pOEM->PageMaxMoveY;
// Output Move_Y command later.
BITSET32(pOEM->fGeneral1, YM_ABS_GONNAOUT);
}
break;
case CMD_YM_RELUP: // pdwParams:DestYRel
if (!BITTEST32(pOEM->fGeneral2, BARCODE_DATA_VALID))
{
iRet = *pdwParams / pOEM->nResoRatio; // @Aug/28/98
pOEM->TextCurPos.y -= iRet;
pOEM->TextCurPosRealY = pOEM->TextCurPos.y;
// Output Move_Y command later.
BITSET32(pOEM->fGeneral1, YM_ABS_GONNAOUT);
}
break;
case CMD_CR:
#ifdef DOWNLOADFONT
pOEM->nCharPosMoveX = 0; // @Jan/19/98
#endif // DOWNLOADFONT
ocmd = safe_sprintfA(Cmd, sizeof(Cmd), CR);
if ((pOEM->TextCurPos.x = pOEM->Offset.x) != 0)
ocmd += safe_sprintfA(&Cmd[ocmd], sizeof(Cmd) - ocmd, ESC_XM_ABS, pOEM->TextCurPos.x);
WRITESPOOLBUF(pdevobj, Cmd, ocmd);
// VERBOSE(("** CMD_CR **\n"));
break;
case CMD_LF:
WRITESPOOLBUF(pdevobj, LF, sizeof(LF)-1);
break;
case CMD_BS:
WRITESPOOLBUF(pdevobj, BS, sizeof(BS)-1);
break;
case CMD_FF:
fDoFormFeed = FALSE;
// If 2in1
if (TEST_2IN1_MODE(pOEM->fGeneral1))
{
// If 2nd page finished
if (pOEM->Nin1RemainPage)
{
pOEM->Nin1RemainPage = 0;
// Initialize offset
pOEM->Offset.x = pOEM->BaseOffset.x;
pOEM->Offset.y = pOEM->BaseOffset.y;
// Output formfeed command later
fDoFormFeed = TRUE;
}
// If not 2nd page, disable formfeed and increase offset.
else
{
WORD PageSpace, wTmp;
pOEM->Nin1RemainPage++;
// space(dot) between 2pages of 2in1.
if (BITTEST32(pOEM->fGeneral2, EDGE2EDGE_PRINT)) // @Nov/27/97
{
wTmp = BITTEST32(pOEM->fGeneral1, IMGCTRL_2IN1_67)?
PageSpace_2IN1_67E2E[pOEM->DocPaperID] :
PAGESPACE_2IN1_100E2E;
}
else
{
wTmp = BITTEST32(pOEM->fGeneral1, IMGCTRL_2IN1_67)?
PageSpace_2IN1_67[pOEM->DocPaperID] :
PAGESPACE_2IN1_100;
}
PageSpace = ((WORD)(MASTERUNIT*10)/(WORD)254) * wTmp /
pOEM->nResoRatio;
if (BITTEST32(pOEM->fGeneral1, ORIENT_LANDSCAPE))
pOEM->Offset.y = pOEM->PageMax.y + pOEM->BaseOffset.y + PageSpace;
else
pOEM->Offset.x = pOEM->PageMax.x + pOEM->BaseOffset.x + PageSpace;
} // 'if (Nin1RemainPage) else' end
}
// If 4in1
else if (TEST_4IN1_MODE(pOEM->fGeneral1)) // OLD MF do not support this
{
switch (++pOEM->Nin1RemainPage) // bug fix @Jan/20/99
{
default: // If illegal, treat as 1st page finished.
pOEM->Nin1RemainPage = 1;
pOEM->Offset.y = pOEM->BaseOffset.y;
case 1:
pOEM->Offset.x = pOEM->PageMax.x + pOEM->BaseOffset.x;
break;
case 2:
pOEM->Offset.x = pOEM->BaseOffset.x;
pOEM->Offset.y = pOEM->PageMax.y + pOEM->BaseOffset.y;
break;
case 3:
pOEM->Offset.x = pOEM->PageMax.x + pOEM->BaseOffset.x;
break;
case 4: // 4th page finished
pOEM->Nin1RemainPage = 0;
// Initialize offset
pOEM->Offset.x = pOEM->BaseOffset.x;
pOEM->Offset.y = pOEM->BaseOffset.y;
// Output formfeed command later
fDoFormFeed = TRUE;
break;
}
}
// Usual case (non Nin1 mode)
else
{
// Output formfeed command later
fDoFormFeed = TRUE;
} // 'if (TEST_2IN1_MODE) else if (TEST_4IN1_MODE) else' end
BITCLR32(pOEM->fGeneral1, TEXT_CLIP_VALID);
if (fDoFormFeed)
{
if (BITTEST32(pOEMExtra->fUiOption, ENABLE_TOMBO)) // @Sep/14/98
DrawTOMBO(pdevobj, DRAW_TOMBO);
WRITESPOOLBUF(pdevobj, FF, sizeof(FF)-1); // moved here @Sep/14/98
// SPEC of RPDL
// Because RPDL's formfeed resets font status(vertical-text, bold, italic,
// white-text and TextMode clipping), we must output these commands again.
if (BITTEST32(pOEM->fGeneral1, FONT_VERTICAL_ON))
ocmd = safe_sprintfA(Cmd, sizeof(Cmd), ESC_VERT_ON);
if (BITTEST32(pOEM->fGeneral1, FONT_BOLD_ON))
ocmd += safe_sprintfA(&Cmd[ocmd], sizeof(Cmd) - ocmd, ESC_BOLD_ON);
if (BITTEST32(pOEM->fGeneral1, FONT_ITALIC_ON))
ocmd += safe_sprintfA(&Cmd[ocmd], sizeof(Cmd) - ocmd, ESC_ITALIC_ON);
if (BITTEST32(pOEM->fGeneral1, FONT_WHITETEXT_ON))
ocmd += safe_sprintfA(&Cmd[ocmd], sizeof(Cmd) - ocmd, ESC_WHITETEXT_ON);
} // 'if (fDoFormFeed)' end
// Reset coordinate x&y
pOEM->TextCurPos.x = pOEM->Offset.x;
pOEM->TextCurPos.y = pOEM->Offset.y;
// SPEC of Unidrv5 & RPDL @Aug/14/98
// Unidrv5 doesn't order to set coordinate x,y to 0 after returning iRet=0,
// and RPDL doesn't reset coordinate y of SEND_BLOCK after initializing
// printer.
ocmd += safe_sprintfA(&Cmd[ocmd], sizeof(Cmd) - ocmd, ESC_XM_ABS, pOEM->TextCurPos.x);
ocmd += safe_sprintfA(&Cmd[ocmd], sizeof(Cmd) - ocmd, ESC_YM_ABS, pOEM->TextCurPos.y);
// reset coordinate y without page_length adjustment, too.
pOEM->TextCurPosRealY = pOEM->TextCurPos.y;
WRITESPOOLBUF(pdevobj, Cmd, ocmd);
break;
case CMD_FONT_BOLD_ON:
if (!BITTEST32(pOEM->fGeneral1, FONT_BOLD_ON)) // add @Jan/28/99
{
BITSET32(pOEM->fGeneral1, FONT_BOLD_ON);
WRITESPOOLBUF(pdevobj, ESC_BOLD_ON, sizeof(ESC_BOLD_ON)-1);
}
break;
case CMD_FONT_BOLD_OFF:
if (BITTEST32(pOEM->fGeneral1, FONT_BOLD_ON)) // add @Jan/28/99
{
BITCLR32(pOEM->fGeneral1, FONT_BOLD_ON);
WRITESPOOLBUF(pdevobj, ESC_BOLD_OFF, sizeof(ESC_BOLD_OFF)-1);
}
break;
case CMD_FONT_ITALIC_ON:
if (!BITTEST32(pOEM->fGeneral1, FONT_ITALIC_ON)) // add @Jan/28/99
{
BITSET32(pOEM->fGeneral1, FONT_ITALIC_ON);
WRITESPOOLBUF(pdevobj, ESC_ITALIC_ON, sizeof(ESC_ITALIC_ON)-1);
}
break;
case CMD_FONT_ITALIC_OFF:
if (BITTEST32(pOEM->fGeneral1, FONT_ITALIC_ON)) // add @Jan/28/99
{
BITCLR32(pOEM->fGeneral1, FONT_ITALIC_ON);
WRITESPOOLBUF(pdevobj, ESC_ITALIC_OFF, sizeof(ESC_ITALIC_OFF)-1);
}
break;
case CMD_FONT_WHITETEXT_ON:
BITSET32(pOEM->fGeneral1, FONT_WHITETEXT_ON);
WRITESPOOLBUF(pdevobj, ESC_WHITETEXT_ON, sizeof(ESC_WHITETEXT_ON)-1);
break;
case CMD_FONT_WHITETEXT_OFF:
BITCLR32(pOEM->fGeneral1, FONT_WHITETEXT_ON);
WRITESPOOLBUF(pdevobj, ESC_WHITETEXT_OFF, sizeof(ESC_WHITETEXT_OFF)-1);
break;
#ifdef DOWNLOADFONT
case CMD_DL_SET_FONT_ID: // pdwParams:FontHeight
// OBSOLETE @Nov/20/98 ->
// pOEM->DLFontH_MU = (WORD)*pdwParams; // @Jun/30/98
// @Nov/20/98 <-
break;
case CMD_DL_SELECT_FONT_ID:
// OBSOLETE @Jun/30/98 ->
// pOEM->DLFontCurID = (WORD)*pdwParams; // CurrentFontID
// @Jun/30/98 <-
break;
case CMD_DL_SET_FONT_GLYPH: // pdwParams:NextGlyph
// VERBOSE(("[DL_SET_FONT_GLYPH] glyph=%d\n", (SHORT)*pdwParams));
pOEM->DLFontCurGlyph = (WORD)*pdwParams;
break;
//
// Following cases are called at the beginning of a print-job
//
case CMD_SET_MEM0KB: // JOB_SETUP.10 @Jan/14/98
pOEM->DLFontMaxMemKB = 0; // disabled
pOEM->pDLFontGlyphInfo = NULL; // @Sep/08/98
break;
case CMD_SET_MEM128KB:
pOEM->DLFontMaxMemKB = MEM128KB; // 128Kbytes
pOEM->DLFontMaxID = DLFONT_ID_4; // 2->4 @Oct/20/98
goto _SET_MEM_ENABLE;
case CMD_SET_MEM256KB:
pOEM->DLFontMaxMemKB = MEM256KB; // 256Kbytes
pOEM->DLFontMaxID = DLFONT_ID_8; // 4->8 @Oct/20/98
goto _SET_MEM_ENABLE;
case CMD_SET_MEM512KB:
pOEM->DLFontMaxMemKB = MEM512KB; // 512Kbytes
pOEM->DLFontMaxID = DLFONT_ID_16; // 8->16 @Oct/20/98
// goto _SET_MEM_ENABLE;
_SET_MEM_ENABLE: // @Sep/08/98
pOEM->DLFontMaxGlyph = DLFONT_GLYPH_TOTAL; // 116->70 @Oct/20/98
// allocate glyph info structure for TrueType download.
// fix memory leak @Nov/22/2002 ->
// if already allocated, exit
if(pOEM->pDLFontGlyphInfo)
break;
// @Nov/22/2002 <-
if(!(pOEM->pDLFontGlyphInfo = (FONTPOS*)MemAllocZ(pOEM->DLFontMaxID *
pOEM->DLFontMaxGlyph *
sizeof(FONTPOS))))
{
pOEM->DLFontMaxMemKB = 0; // disabled
}
break;
#endif // DOWNLOADFONT
case CMD_SELECT_STAPLE_NONE: // JOB_SETUP.20 @Dec/02/97
pOEM->StapleType = 0;
break;
case CMD_SELECT_STAPLE_1:
pOEM->StapleType = 1;
break;
case CMD_SELECT_STAPLE_2:
pOEM->StapleType = 2;
break;
case CMD_SELECT_STAPLE_MAX1: // @Mar/18/99
pOEM->StapleType = 3; // stapling with FinisherSR12(max 1staple)
break;
case CMD_SELECT_PUNCH_NONE: // JOB_SETUP.30 @Dec/02/97
pOEM->PunchType = 0;
break;
case CMD_SELECT_PUNCH_1:
pOEM->PunchType = 1;
break;
case CMD_BEGINDOC_SP4II: // SP4mkII,5
pOEM->fModel = 0;
BITSET32(pOEM->fModel, GRP_SP4II);
// Set Emulation:RPDL, Code:SJIS
ocmd = safe_sprintfA(Cmd, sizeof(Cmd), BEGINDOC1);
// Set Graphics:KAN-I G, Page-Length:max
ocmd += safe_sprintfA(&Cmd[ocmd], sizeof(Cmd) - ocmd, BEGINDOC2_1);
WRITESPOOLBUF(pdevobj, Cmd, ocmd);
goto _BEGINDOC_FINISH2; // @Sep/09/98;
case CMD_BEGINDOC_MF530: // MF530
pOEM->fModel = 0;
BITSET32(pOEM->fModel, GRP_MF530);
// Set Emulation:RPDL, Code:SJIS
ocmd = safe_sprintfA(Cmd, sizeof(Cmd), BEGINDOC1);
// Set Page-Length:max
ocmd += safe_sprintfA(&Cmd[ocmd], sizeof(Cmd) - ocmd, BEGINDOC2_2);
WRITESPOOLBUF(pdevobj, Cmd, ocmd);
goto _BEGINDOC_FINISH2; // @Sep/09/98;
case CMD_BEGINDOC_MF150: // MF150
pOEM->fModel = 0;
BITSET32(pOEM->fModel, GRP_MF150);
goto _BEGINDOC_FINISH1;
case CMD_BEGINDOC_MF150E: // MF150e,160
pOEM->fModel = 0;
BITSET32(pOEM->fModel, GRP_MF150E);
goto _BEGINDOC_FINISH1;
case CMD_BEGINDOC_SP8: // SP8(7),8(7)mkII,80
pOEM->fModel = 0;
BITSET32(pOEM->fModel, GRP_SP8);
goto _BEGINDOC_FINISH1;
case CMD_BEGINDOC_MFP250: // MF-P250,355,250(FAX),355(FAX),MF-FD355,MF-P250e,355e
pOEM->fModel = 0;
BITSET32(pOEM->fModel, GRP_MFP250);
goto _BEGINDOC_FINISH1;
case CMD_BEGINDOC_SP10: // SP10,10mkII
pOEM->fModel = 0;
BITSET32(pOEM->fModel, GRP_SP10);
goto _BEGINDOC_FINISH1;
case CMD_BEGINDOC_SP9: // SP9,10Pro
pOEM->fModel = 0;
BITSET32(pOEM->fModel, GRP_SP9);
goto _BEGINDOC_FINISH1;
case CMD_BEGINDOC_SP9II: // SP9II,10ProII,90
pOEM->fModel = 0;
BITSET32(pOEM->fModel, GRP_SP9II);
goto _BEGINDOC_FINISH1;
case CMD_BEGINDOC_MF200: // MF200,MF-p150,MF2200
pOEM->fModel = 0; // (separate BEGINDOC_SP9II @Sep/01/98)
BITSET32(pOEM->fModel, GRP_MF200);
goto _BEGINDOC_FINISH1;
case CMD_BEGINDOC_NX100: // NX-100
pOEM->fModel = 0;
// not support IBM extended character block
BITSET32(pOEM->fModel, GRP_NX100);
goto _BEGINDOC_FINISH1;
case CMD_BEGINDOC_NX500: // NX-500,1000,110,210,510,1100
pOEM->fModel = 0;
// TT font download capable
BITSET32(pOEM->fModel, GRP_NX500);
goto _BEGINDOC_FINISH1;
// OBSOLETE @Apr/15/99
// case CMD_BEGINDOC_MFP250E: // MF-P250e,355e
// pOEM->fModel = 0;
// BITSET32(pOEM->fModel, GRP_MFP250E);
// goto _BEGINDOC_FINISH1;
case CMD_BEGINDOC_MF250M: // MF250M
// staple capable
pOEM->fModel = 0;
BITSET32(pOEM->fModel, GRP_MF250M);
goto _BEGINDOC_FINISH1;
case CMD_BEGINDOC_MF3550: // MF2700,3500,3550,4550,5550,6550,3530,3570,4570,5550EX,6550EX,1530
// staple & punch & media type option
pOEM->fModel = 0;
BITSET32(pOEM->fModel, GRP_MF3550);
goto _BEGINDOC_FINISH1;
case CMD_BEGINDOC_MF3530E: // MF3530e,3570e,4570e,5570,7070,8570,105Pro @Jun/25/2001
// Job define command is needed for staple
pOEM->fModel = 0;
BITSET32(pOEM->fModel, GRP_MF3530E);
goto _BEGINDOC_FINISH1;
case CMD_BEGINDOC_MF3300: // MF3300W,3350W,3540W,3580W
pOEM->fModel = 0;
// A2 printer
BITSET32(pOEM->fModel, GRP_MF3300);
goto _BEGINDOC_FINISH1;
case CMD_BEGINDOC_IP1: // IP-1
pOEM->fModel = 0;
// A1 plotter
BITSET32(pOEM->fModel, GRP_IP1);
goto _BEGINDOC_FINISH1;
case CMD_BEGINDOC_NX70: // NX70,71 @Feb/04/98
pOEM->fModel = 0;
// A4 printer, FE-DeltaRow
BITSET32(pOEM->fModel, GRP_NX70); // BITSET->BITSET32 @Jun/01/98
goto _BEGINDOC_FINISH1;
case CMD_BEGINDOC_NX700: // NX700,600,FAX Printer,MF700 @Jun/12/98
pOEM->fModel = 0;
// FE-DeltaRow
BITSET32(pOEM->fModel, GRP_NX700);
goto _BEGINDOC_FINISH1;
case CMD_BEGINDOC_NX900: // NX900 @Jan/08/99
pOEM->fModel = 0;
// Job define command is needed for shifted collate
BITSET32(pOEM->fModel, GRP_NX900);
goto _BEGINDOC_FINISH1;
case CMD_BEGINDOC_NX800: // NX800,910,810,MF2230,2730 @Mar/03/99, remove MF1530 @Jun/25/2001
pOEM->fModel = 0;
// Job define command is needed for staple
BITSET32(pOEM->fModel, GRP_NX800);
goto _BEGINDOC_FINISH1;
case CMD_BEGINDOC_NX710: // NX710,610 @Jun/23/2000
pOEM->fModel = 0;
// FE-DeltaRow & media type option (& variable scaling bug)
BITSET32(pOEM->fModel, GRP_NX710);
goto _BEGINDOC_FINISH1;
case CMD_BEGINDOC_NX720: // NX620,620N,720N,Neo350,350D,450,220,270 @Sep/26/2000
pOEM->fModel = 0;
// FE-DeltaRow & media type option (GW model)
BITSET32(pOEM->fModel, GRP_NX720);
// goto _BEGINDOC_FINISH1;
_BEGINDOC_FINISH1:
// Jun/29/2001 ->
pOEM->FinisherTrayNum = 1;
// set Emulation:RPDL
if (TEST_NEED_JOBDEF_CMD(pOEM->fModel))
ocmd = safe_sprintfA(Cmd, sizeof(Cmd), BEGINDOC_TOP_JOBDEF); // with Job define command
else
ocmd = safe_sprintfA(Cmd, sizeof(Cmd), BEGINDOC_TOP); // without Job define command
WRITESPOOLBUF(pdevobj, Cmd, ocmd);
ocmd = 0;
// Jun/29/2001 <-
if (BITTEST32(pOEMExtra->fUiOption, FAX_MODEL))
SendFaxNum(pdevobj);
// Set Code:SJIS
ocmd = safe_sprintfA(Cmd, sizeof(Cmd), BEGINDOC1_2); // <-BEGINDOC1 @Jun/25/2001
// Set Graphics:KAN-I G, Page-Length:max
ocmd += safe_sprintfA(&Cmd[ocmd], sizeof(Cmd) - ocmd, BEGINDOC2_1);
// Set Duplex:off
ocmd += safe_sprintfA(&Cmd[ocmd], sizeof(Cmd) - ocmd, BEGINDOC3);
WRITESPOOLBUF(pdevobj, Cmd, ocmd);
#ifdef DOWNLOADFONT
pOEM->dwDLFontUsedMem = 0;
if (pOEM->DLFontMaxMemKB)
{
ocmd = safe_sprintfA(Cmd, sizeof(Cmd), DLFONT_MALLOC, pOEM->DLFontMaxMemKB, DLFONT_MIN_BLOCK_ID);
WRITESPOOLBUF(pdevobj, Cmd, ocmd);
}
#endif // DOWNLOADFONT
_BEGINDOC_FINISH2: // @Sep/09/98
// Allocate heap memory for bOEMOutputCharStr&OEMDownloadCharGlyph.
// fix memory leak @Nov/22/2002 ->
// if already allocated, exit
if(pOEM->pRPDLHeap2K)
break;
// @Nov/22/2002 <-
pOEM->pRPDLHeap2K = (PBYTE)MemAllocZ(HEAPSIZE2K);
break;
case CMD_SET_BASEOFFSETX_0: // @May/07/98
case CMD_SET_BASEOFFSETX_1:
case CMD_SET_BASEOFFSETX_2:
case CMD_SET_BASEOFFSETX_3:
case CMD_SET_BASEOFFSETX_4:
case CMD_SET_BASEOFFSETX_5:
pOEM->BaseOffset.x = (LONG)(dwCmdCbID - CMD_SET_BASEOFFSETX_0);
break;
case CMD_SET_BASEOFFSETY_0: // @May/07/98
case CMD_SET_BASEOFFSETY_1:
case CMD_SET_BASEOFFSETY_2:
case CMD_SET_BASEOFFSETY_3:
case CMD_SET_BASEOFFSETY_4:
case CMD_SET_BASEOFFSETY_5:
pOEM->BaseOffset.y = (LONG)(dwCmdCbID - CMD_SET_BASEOFFSETY_0);
break;
case CMD_RES240:
pOEM->fGeneral1 = pOEM->fGeneral2 = 0;
pOEM->nResoRatio = MASTERUNIT/240;
// Set Options[duplex/2in1:off,reversed_output:on,sort/stack:off]
if (!BITTEST32(pOEM->fModel, GRP_SP4II))
ocmd = safe_sprintfA(Cmd, sizeof(Cmd), IMAGE_OPT_OFF);
// Set Spacing_Unit:1/240inch
ocmd += safe_sprintfA(&Cmd[ocmd], sizeof(Cmd) - ocmd, SELECT_RES240_1);
if (TEST_AFTER_SP10(pOEM->fModel)) // SP10,9,etc
// Set Graphics_Unit & Coordinate_Unit:1/240inch,Engine_Resolution:240dpi
ocmd += safe_sprintfA(&Cmd[ocmd], sizeof(Cmd) - ocmd, SELECT_RES240_2);
WRITESPOOLBUF(pdevobj, Cmd, ocmd);
break;
case CMD_RES400:
pOEM->fGeneral1 = pOEM->fGeneral2 = 0;
pOEM->nResoRatio = MASTERUNIT/400;
// Set Spacing_Unit & Graphics_Unit:1/400inch
// & Options[duplex/2in1:off,reversed_output:on,sort/stack:off]
ocmd = safe_sprintfA(Cmd, sizeof(Cmd), SELECT_RES400_1);
if (!BITTEST32(pOEM->fModel, GRP_MF530))
{
// Set Engine_Resolution:400dpi
ocmd += safe_sprintfA(&Cmd[ocmd], sizeof(Cmd) - ocmd, SELECT_RES400_2);
if (TEST_AFTER_SP10(pOEM->fModel) ||
BITTEST32(pOEM->fModel, GRP_MF150E)) // MF150e,160
{
// Set Coordinate_Unit:1/400inch
ocmd += safe_sprintfA(&Cmd[ocmd], sizeof(Cmd) - ocmd, SELECT_RES400_3);
}
}
WRITESPOOLBUF(pdevobj, Cmd, ocmd);
break;
case CMD_RES600:
pOEM->fGeneral1 = pOEM->fGeneral2 = 0;
pOEM->nResoRatio = MASTERUNIT/600;
#ifdef DOWNLOADFONT
// If non-DRC&&600dpi then make it half. @Jun/15/98
if (!TEST_CAPABLE_DOWNLOADFONT_DRC(pOEM->fModel))
pOEM->DLFontMaxID /= 2;
#endif // DOWNLOADFONT
// Set Spacing_Unit & Graphics_Unit & Coordinate_Unit:1/600inch,
// Engine_Resolution:600dpi
// & Options[duplex/2in1:off,reversed_output:on,sort/stack:off]
WRITESPOOLBUF(pdevobj, SELECT_RES600, sizeof(SELECT_RES600)-1);
break;
case CMD_RES1200: // @Mar/02/99
pOEM->fGeneral1 = pOEM->fGeneral2 = 0;
pOEM->nResoRatio = MASTERUNIT/1200;
#ifdef DOWNLOADFONT
pOEM->DLFontMaxID /= 2;
#endif // DOWNLOADFONT
// Set Spacing_Unit & Graphics_Unit & Coordinate_Unit:1/1200inch,
// Engine_Resolution:1200dpi
// & Options[duplex/2in1:off,reversed_output:on,sort/stack:off]
WRITESPOOLBUF(pdevobj, SELECT_RES1200, sizeof(SELECT_RES1200)-1);
break;
case CMD_REGION_STANDARD: // @Nov/29/97
BITCLR32(pOEM->fGeneral2, EDGE2EDGE_PRINT);
if (BITTEST32(pOEMExtra->fUiOption, ENABLE_TOMBO)) // @Sep/15/98
WRITESPOOLBUF(pdevobj, SELECT_REGION_E2E, sizeof(SELECT_REGION_E2E)-1);
else
WRITESPOOLBUF(pdevobj, SELECT_REGION_STD, sizeof(SELECT_REGION_STD)-1);
break;
case CMD_REGION_EDGE2EDGE: // @Nov/29/97
BITSET32(pOEM->fGeneral2, EDGE2EDGE_PRINT);
WRITESPOOLBUF(pdevobj, SELECT_REGION_E2E, sizeof(SELECT_REGION_E2E)-1);
break;
case CMD_IMGCTRL_100:
if (pOEMExtra->UiScale != VAR_SCALING_DEFAULT) // @Feb/06/98
{
pOEM->Scale = pOEMExtra->UiScale; // @Mar/18/98
ocmd = safe_sprintfA(Cmd, sizeof(Cmd), IMAGE_SCALING_VAR, pOEM->Scale);
WRITESPOOLBUF(pdevobj, Cmd, ocmd);
BITSET32(pOEM->fGeneral1, VARIABLE_SCALING_VALID); // @Jan/27/2000
break;
}
pOEM->Scale = 100; // @Mar/18/98
WRITESPOOLBUF(pdevobj, IMAGE_SCALING_100, sizeof(IMAGE_SCALING_100)-1);
break;
case CMD_IMGCTRL_88:
pOEM->Scale = 88; // @Mar/18/98
WRITESPOOLBUF(pdevobj, IMAGE_SCALING_88, sizeof(IMAGE_SCALING_88)-1);
break;
case CMD_IMGCTRL_80:
pOEM->Scale = 80; // @Mar/18/98
WRITESPOOLBUF(pdevobj, IMAGE_SCALING_80, sizeof(IMAGE_SCALING_80)-1);
break;
case CMD_IMGCTRL_75:
pOEM->Scale = 75; // @Mar/18/98
WRITESPOOLBUF(pdevobj, IMAGE_SCALING_75, sizeof(IMAGE_SCALING_75)-1);
break;
case CMD_IMGCTRL_70:
pOEM->Scale = 70; // @Mar/18/98
WRITESPOOLBUF(pdevobj, IMAGE_SCALING_70, sizeof(IMAGE_SCALING_70)-1);
break;
case CMD_IMGCTRL_67:
pOEM->Scale = 67; // @Mar/18/98
WRITESPOOLBUF(pdevobj, IMAGE_SCALING_67, sizeof(IMAGE_SCALING_67)-1);
break;
case CMD_IMGCTRL_115:
pOEM->Scale = 115;
WRITESPOOLBUF(pdevobj, IMAGE_SCALING_115, sizeof(IMAGE_SCALING_115)-1);
break;
case CMD_IMGCTRL_122:
pOEM->Scale = 122; // @Mar/18/98
if (TEST_PLOTTERMODEL_SCALING(pOEM->fModel))
{
WRITESPOOLBUF(pdevobj, IMAGE_SCALING_122, sizeof(IMAGE_SCALING_122)-1);
}
else
{
WRITESPOOLBUF(pdevobj, IMAGE_SCALING_122V, sizeof(IMAGE_SCALING_122V)-1);
BITSET32(pOEM->fGeneral1, VARIABLE_SCALING_VALID); // @Jan/27/2000
}
break;
case CMD_IMGCTRL_141:
pOEM->Scale = 141; // @Mar/18/98
if (TEST_PLOTTERMODEL_SCALING(pOEM->fModel))
{
WRITESPOOLBUF(pdevobj, IMAGE_SCALING_141, sizeof(IMAGE_SCALING_141)-1);
}
else
{
WRITESPOOLBUF(pdevobj, IMAGE_SCALING_141V, sizeof(IMAGE_SCALING_141V)-1);
BITSET32(pOEM->fGeneral1, VARIABLE_SCALING_VALID); // @Jan/27/2000
}
break;
case CMD_IMGCTRL_200:
pOEM->Scale = 200; // @Mar/18/98
if (TEST_PLOTTERMODEL_SCALING(pOEM->fModel))
{
WRITESPOOLBUF(pdevobj, IMAGE_SCALING_200, sizeof(IMAGE_SCALING_200)-1);
}
else
{
WRITESPOOLBUF(pdevobj, IMAGE_SCALING_200V, sizeof(IMAGE_SCALING_200V)-1);
BITSET32(pOEM->fGeneral1, VARIABLE_SCALING_VALID); // @Jan/27/2000
}
break;
case CMD_IMGCTRL_50:
pOEM->Scale = 50; // @Mar/18/98
WRITESPOOLBUF(pdevobj, IMAGE_SCALING_50V, sizeof(IMAGE_SCALING_50V)-1);
BITSET32(pOEM->fGeneral1, VARIABLE_SCALING_VALID); // @Jan/27/2000
break;
case CMD_IMGCTRL_AA67: // A->A scaling(67%)
pOEM->Scale = 67; // @Mar/18/98
BITSET32(pOEM->fGeneral1, IMGCTRL_AA67);
WRITESPOOLBUF(pdevobj, IMAGE_SCALING_67, sizeof(IMAGE_SCALING_67)-1);
break;
case CMD_IMGCTRL_BA80: // B->A scaling(80%)
pOEM->Scale = 80; // @Mar/18/98
BITSET32(pOEM->fGeneral1, IMGCTRL_BA80);
WRITESPOOLBUF(pdevobj, IMAGE_SCALING_80, sizeof(IMAGE_SCALING_80)-1);
break;
case CMD_IMGCTRL_BA115: // B->A scaling(115%)
pOEM->Scale = 115; // @Mar/18/98
BITSET32(pOEM->fGeneral1, IMGCTRL_BA115);
WRITESPOOLBUF(pdevobj, IMAGE_SCALING_115, sizeof(IMAGE_SCALING_115)-1);
break;
case CMD_DRV_4IN1_50: // 4in1
pOEM->Scale = 50; // @Mar/18/98
BITSET32(pOEM->fGeneral1, IMGCTRL_4IN1_50);
pOEM->Nin1RemainPage = 0;
WRITESPOOLBUF(pdevobj, IMAGE_SCALING_50V, sizeof(IMAGE_SCALING_50V)-1);
BITSET32(pOEM->fGeneral1, VARIABLE_SCALING_VALID); // @Jan/27/2000
break;
case CMD_DRV_2IN1_67: // 2in1
pOEM->Scale = 67; // @Mar/18/98
BITSET32(pOEM->fGeneral1, IMGCTRL_2IN1_67);
pOEM->Nin1RemainPage = 0;
WRITESPOOLBUF(pdevobj, IMAGE_SCALING_67, sizeof(IMAGE_SCALING_67)-1);
break;
case CMD_DRV_2IN1_100: // 2in1
pOEM->Scale = 100; // @Mar/18/98
BITSET32(pOEM->fGeneral1, IMGCTRL_2IN1_100);
pOEM->Nin1RemainPage = 0;
WRITESPOOLBUF(pdevobj, IMAGE_SCALING_100, sizeof(IMAGE_SCALING_100)-1);
break;
case CMD_IMGCTRL_AA141: // IP-1,3300W,3350W:A->A scaling(141%)
pOEM->Scale = 141; // @Mar/18/98
BITSET32(pOEM->fGeneral1, IMGCTRL_AA141);
WRITESPOOLBUF(pdevobj, IMAGE_SCALING_141, sizeof(IMAGE_SCALING_141)-1);
break;
case CMD_IMGCTRL_AA200: // IP-1:A->A scaling(200%)
pOEM->Scale = 200; // @Mar/18/98
BITSET32(pOEM->fGeneral1, IMGCTRL_AA200);
WRITESPOOLBUF(pdevobj, IMAGE_SCALING_200, sizeof(IMAGE_SCALING_200)-1);
break;
case CMD_IMGCTRL_AA283: // IP-1:A->A scaling(283%)
BITSET32(pOEM->fGeneral1, IMGCTRL_AA283);
case CMD_IMGCTRL_283: // IP-1
pOEM->Scale = 283; // @Mar/18/98
WRITESPOOLBUF(pdevobj, IMAGE_SCALING_283, sizeof(IMAGE_SCALING_283)-1);
break;
case CMD_IMGCTRL_A1_400: // IP-1:400% with A1
BITSET32(pOEM->fGeneral1, IMGCTRL_A1_400);
case CMD_IMGCTRL_400: // IP-1
pOEM->Scale = 400; // @Mar/18/98
WRITESPOOLBUF(pdevobj, IMAGE_SCALING_400, sizeof(IMAGE_SCALING_400)-1);
break;
case CMD_SET_LANDSCAPE:
BITSET32(pOEM->fGeneral1, ORIENT_LANDSCAPE);
break;
case CMD_SET_PORTRAIT:
BITCLR32(pOEM->fGeneral1, ORIENT_LANDSCAPE);
break;
// OBSOLETE (actually obsoleted at converting GPC to GPD) @Jan/08/99 ->
// case CMD_DUPLEX_ON:
// BITSET32(pOEM->fGeneral1, DUPLEX_VALID);
// break;
// @Jan/08/99 <-
case CMD_DUPLEX_VERT:
BITSET32(pOEM->fGeneral1, DUPLEX_VALID); // @Jan/08/99
if (BITTEST32(pOEM->fGeneral1, ORIENT_LANDSCAPE))
{
if (!TEST_2IN1_MODE(pOEM->fGeneral1))
goto _DUP_H;
}
else
{
if (TEST_2IN1_MODE(pOEM->fGeneral1))
goto _DUP_H;
}
_DUP_V:
if (pOEMExtra->UiBindMargin)
{
BITSET32(pOEM->fGeneral1, DUPLEX_LEFTMARGIN_VALID);
// Convert mm to 5mm_unit(2=5mm,3=10mm,...,11=50mm)
nTmp = (pOEMExtra->UiBindMargin + 4) / 5 + 1;
ocmd = safe_sprintfA(Cmd, sizeof(Cmd), SET_LEFTMARGIN, nTmp);
// SP9II(except 1st lot),10ProII can set binding margin every 1 mm
if (TEST_AFTER_SP9II(pOEM->fModel))
ocmd += safe_sprintfA(&Cmd[ocmd], sizeof(Cmd) - ocmd, SET_LEFTMARGIN_9II, pOEMExtra->UiBindMargin);
}
if (BITTEST32(pOEMExtra->fUiOption, ENABLE_BIND_RIGHT))
{
pOEM->BindPoint = BIND_RIGHT;
ocmd += safe_sprintfA(&Cmd[ocmd], sizeof(Cmd) - ocmd, DUPLEX_VERT_R);
}
else
{
pOEM->BindPoint = BIND_LEFT;
ocmd += safe_sprintfA(&Cmd[ocmd], sizeof(Cmd) - ocmd, DUPLEX_VERT);
}
ocmd += safe_sprintfA(&Cmd[ocmd], sizeof(Cmd) - ocmd, DUPLEX_ON);
// DCR @Jan/27/2000 ->
// Emit IMAGE_SCALING_xxxV here, because DUPLEX_VERT resets IMAGE_SCALING_xxxV
if (BITTEST32(pOEM->fGeneral1, VARIABLE_SCALING_VALID));
ocmd += safe_sprintfA(&Cmd[ocmd], sizeof(Cmd) - ocmd, IMAGE_SCALING_VAR, pOEM->Scale);
// @Jan/27/2000 <-
WRITESPOOLBUF(pdevobj, Cmd, ocmd);
break;
case CMD_DUPLEX_HORZ:
BITSET32(pOEM->fGeneral1, DUPLEX_VALID); // @Jan/08/99
if (BITTEST32(pOEM->fGeneral1, ORIENT_LANDSCAPE))
{
if (!TEST_2IN1_MODE(pOEM->fGeneral1))
goto _DUP_V;
}
else
{
if (TEST_2IN1_MODE(pOEM->fGeneral1))
goto _DUP_V;
}
_DUP_H:
if (pOEMExtra->UiBindMargin)
{
BITSET32(pOEM->fGeneral1, DUPLEX_UPPERMARGIN_VALID);
nTmp = (pOEMExtra->UiBindMargin + 4) / 5 + 1;
ocmd = safe_sprintfA(Cmd, sizeof(Cmd), SET_UPPERMARGIN, nTmp);
if (TEST_AFTER_SP9II(pOEM->fModel))
{
ocmd += safe_sprintfA(&Cmd[ocmd], sizeof(Cmd) - ocmd, SET_UPPERMARGIN_9II, pOEMExtra->UiBindMargin);
}
}
pOEM->BindPoint = BIND_UPPER;
ocmd += safe_sprintfA(&Cmd[ocmd], sizeof(Cmd) - ocmd, DUPLEX_HORZ);
ocmd += safe_sprintfA(&Cmd[ocmd], sizeof(Cmd) - ocmd, DUPLEX_ON);
// DCR @Jan/27/2000 ->
// Emit IMAGE_SCALING_xxxV here, because DUPLEX_HORZ resets IMAGE_SCALING_xxxV
if (BITTEST32(pOEM->fGeneral1, VARIABLE_SCALING_VALID));
ocmd += safe_sprintfA(&Cmd[ocmd], sizeof(Cmd) - ocmd, IMAGE_SCALING_VAR, pOEM->Scale);
// @Jan/27/2000 <-
WRITESPOOLBUF(pdevobj, Cmd, ocmd);
break;
case CMD_MEDIATYPE_STANDARD:
pOEM->MediaType = MEDIATYPE_STD; // use pOEM->MediaType @Mar/03/99
break;
case CMD_MEDIATYPE_OHP:
pOEM->MediaType = MEDIATYPE_OHP;
break;
case CMD_MEDIATYPE_THICK:
pOEM->MediaType = MEDIATYPE_THICK;
break;
case CMD_MEDIATYPE_SPL: // since MF1530 @Mar/03/99
pOEM->MediaType = MEDIATYPE_SPL;
break;
case CMD_MEDIATYPE_TRACE: // since MF5570 @Feb/15/2000
pOEM->MediaType = MEDIATYPE_TRACE;
break;
case CMD_MEDIATYPE_LABEL: // since Neo450 @Oct/12/2000
pOEM->MediaType = MEDIATYPE_LABEL;
break;
case CMD_MEDIATYPE_THIN: // since Neo270 @Feb/05/2001
pOEM->MediaType = MEDIATYPE_THIN;
break;
case CMD_SELECT_PAPER_A2:
pOEM->DocPaperID = RPDL_A2;
// If A->A(67%), scale down papersize.
if (BITTEST32(pOEM->fGeneral1, IMGCTRL_AA67))
lpcmd = SELECT_PAPER_A3;
else
lpcmd = SELECT_PAPER_A2;
// Store papername to buffer
pOEM->RPDLHeapCount = (WORD)safe_sprintfA(pOEM->RPDLHeap64, sizeof(pOEM->RPDLHeap64), lpcmd);
// Because incapable, clear setting
if (TEST_NIN1_MODE(pOEM->fGeneral1) ||
BITTEST32(pOEM->fGeneral1, IMGCTRL_BA80) ||
BITTEST32(pOEM->fGeneral1, IMGCTRL_BA115) ||
BITTEST32(pOEM->fGeneral1, IMGCTRL_AA141) ||
BITTEST32(pOEM->fGeneral1, IMGCTRL_AA200) ||
BITTEST32(pOEM->fGeneral1, IMGCTRL_AA283) ||
BITTEST32(pOEM->fGeneral1, IMGCTRL_A1_400))
{
goto _IMGCTRL_OFF1;
}
break;
case CMD_SELECT_PAPER_A3:
pOEM->DocPaperID = RPDL_A3;
// If able to select tray with "papername+X" && no staple && no punch
fPaperX = (TEST_CAPABLE_PAPERX(pOEM->fModel) && !pOEM->StapleType &&
!pOEM->PunchType)? TRUE : FALSE;
// If TOMBO is enabled, scale up papersize. @Sep/14/98
if (BITTEST32(pOEMExtra->fUiOption, ENABLE_TOMBO) &&
TEST_CAPABLE_PAPER_A2(pOEM->fModel))
{
lpcmd = SELECT_PAPER_B3;
pOEM->RPDLHeapCount = (WORD)safe_sprintfA(pOEM->RPDLHeap64, sizeof(pOEM->RPDLHeap64), lpcmd);
goto _IMGCTRL_OFF1;
}
// If A->A(67%), scale down papersize.
if (BITTEST32(pOEM->fGeneral1, IMGCTRL_AA67))
lpcmd = (fPaperX)? SELECT_PAPER_A4X : SELECT_PAPER_A4W;
// If A->A(141%), scale up papersize.
else if (BITTEST32(pOEM->fGeneral1, IMGCTRL_AA141))
lpcmd = SELECT_PAPER_A2;
// If A->A(200%) || A1(400%), scale up papersize.
else if (BITTEST32(pOEM->fGeneral1, IMGCTRL_AA200) ||
BITTEST32(pOEM->fGeneral1, IMGCTRL_A1_400))
lpcmd = SELECT_PAPER_A1;
else
lpcmd = SELECT_PAPER_A3;
// Store papername to buffer
pOEM->RPDLHeapCount = (WORD)safe_sprintfA(pOEM->RPDLHeap64, sizeof(pOEM->RPDLHeap64), lpcmd);
// Because incapable, clear setting
if (BITTEST32(pOEM->fGeneral1, IMGCTRL_2IN1_100) ||
BITTEST32(pOEM->fGeneral1, IMGCTRL_BA80) ||
BITTEST32(pOEM->fGeneral1, IMGCTRL_BA115) ||
BITTEST32(pOEM->fGeneral1, IMGCTRL_AA283))
{
goto _IMGCTRL_OFF1;
}
break;
case CMD_SELECT_PAPER_A4:
pOEM->DocPaperID = RPDL_A4;
fPaperX = (TEST_CAPABLE_PAPERX(pOEM->fModel) && !pOEM->StapleType &&
!pOEM->PunchType)? TRUE : FALSE;
// If TOMBO is enabled, scale up papersize. @Sep/14/98
if (BITTEST32(pOEMExtra->fUiOption, ENABLE_TOMBO))
{
lpcmd = SELECT_PAPER_B4;
pOEM->RPDLHeapCount = (WORD)safe_sprintfA(pOEM->RPDLHeap64, sizeof(pOEM->RPDLHeap64), lpcmd);
goto _IMGCTRL_OFF1;
}
// If 2in1(100%), scale up papersize.
if (BITTEST32(pOEM->fGeneral1, IMGCTRL_2IN1_100) ||
BITTEST32(pOEM->fGeneral1, IMGCTRL_AA141))
lpcmd = SELECT_PAPER_A3;
// If A->A(67%), scale down papersize.
else if (BITTEST32(pOEM->fGeneral1, IMGCTRL_AA67))
lpcmd = (fPaperX)? SELECT_PAPER_A5X : SELECT_PAPER_A5W;
else if (BITTEST32(pOEM->fGeneral1, IMGCTRL_AA200))
lpcmd = SELECT_PAPER_A2;
else if (BITTEST32(pOEM->fGeneral1, IMGCTRL_AA283) ||
BITTEST32(pOEM->fGeneral1, IMGCTRL_A1_400))
lpcmd = SELECT_PAPER_A1;
else
lpcmd = (fPaperX)? SELECT_PAPER_A4X : SELECT_PAPER_A4W;
pOEM->RPDLHeapCount = (WORD)safe_sprintfA(pOEM->RPDLHeap64, sizeof(pOEM->RPDLHeap64), lpcmd);
if (BITTEST32(pOEM->fGeneral1, IMGCTRL_BA80) ||
BITTEST32(pOEM->fGeneral1, IMGCTRL_BA115))
{
goto _IMGCTRL_OFF1;
}
break;
case CMD_SELECT_PAPER_A5:
pOEM->DocPaperID = RPDL_A5;
fPaperX = (TEST_CAPABLE_PAPERX(pOEM->fModel) && !pOEM->StapleType &&
!pOEM->PunchType)? TRUE : FALSE;
// If TOMBO is enabled, scale up papersize. @Sep/14/98
if (BITTEST32(pOEMExtra->fUiOption, ENABLE_TOMBO))
{
lpcmd = (fPaperX)? SELECT_PAPER_A4X : SELECT_PAPER_A4W;
pOEM->RPDLHeapCount = (WORD)safe_sprintfA(pOEM->RPDLHeap64, sizeof(pOEM->RPDLHeap64), lpcmd);
goto _IMGCTRL_OFF1;
}
if (BITTEST32(pOEM->fGeneral1, IMGCTRL_2IN1_100) ||
BITTEST32(pOEM->fGeneral1, IMGCTRL_AA141))
lpcmd = (fPaperX)? SELECT_PAPER_A4X : SELECT_PAPER_A4W;
else if (BITTEST32(pOEM->fGeneral1, IMGCTRL_AA67))
lpcmd = SELECT_PAPER_A6;
else if (BITTEST32(pOEM->fGeneral1, IMGCTRL_AA200))
lpcmd = SELECT_PAPER_A3;
else if (BITTEST32(pOEM->fGeneral1, IMGCTRL_AA283))
lpcmd = SELECT_PAPER_A2;
else
lpcmd = (fPaperX)? SELECT_PAPER_A5X : SELECT_PAPER_A5W;
pOEM->RPDLHeapCount = (WORD)safe_sprintfA(pOEM->RPDLHeap64, sizeof(pOEM->RPDLHeap64), lpcmd);
if (BITTEST32(pOEM->fGeneral1, IMGCTRL_BA80) ||
BITTEST32(pOEM->fGeneral1, IMGCTRL_BA115) ||
BITTEST32(pOEM->fGeneral1, IMGCTRL_A1_400))
{
goto _IMGCTRL_OFF1;
}
break;
case CMD_SELECT_PAPER_A6:
pOEM->DocPaperID = RPDL_A6;
fPaperX = (TEST_CAPABLE_PAPERX(pOEM->fModel) && !pOEM->StapleType &&
!pOEM->PunchType)? TRUE : FALSE;
// If TOMBO is enabled, scale up papersize. @Sep/14/98
if (BITTEST32(pOEMExtra->fUiOption, ENABLE_TOMBO))
{
lpcmd = (fPaperX)? SELECT_PAPER_A4X : SELECT_PAPER_A4W;
pOEM->RPDLHeapCount = (WORD)safe_sprintfA(pOEM->RPDLHeap64, sizeof(pOEM->RPDLHeap64), lpcmd);
goto _IMGCTRL_OFF1;
}
if (BITTEST32(pOEM->fGeneral1, IMGCTRL_2IN1_100) ||
BITTEST32(pOEM->fGeneral1, IMGCTRL_AA141))
lpcmd = (fPaperX)? SELECT_PAPER_A5X : SELECT_PAPER_A5W;
else if (BITTEST32(pOEM->fGeneral1, IMGCTRL_AA200))
lpcmd = (fPaperX)? SELECT_PAPER_A4X : SELECT_PAPER_A4W;
else if (BITTEST32(pOEM->fGeneral1, IMGCTRL_AA283))
lpcmd = SELECT_PAPER_A3;
else
lpcmd = SELECT_PAPER_A6;
pOEM->RPDLHeapCount = (WORD)safe_sprintfA(pOEM->RPDLHeap64, sizeof(pOEM->RPDLHeap64), lpcmd);
if (BITTEST32(pOEM->fGeneral1, IMGCTRL_AA67) ||
BITTEST32(pOEM->fGeneral1, IMGCTRL_BA80) ||
BITTEST32(pOEM->fGeneral1, IMGCTRL_BA115) ||
BITTEST32(pOEM->fGeneral1, IMGCTRL_A1_400))
{
goto _IMGCTRL_OFF1;
}
break;
case CMD_SELECT_PAPER_POSTCARD: // since NX700 @Feb/13/98
pOEM->DocPaperID = RPDL_POSTCARD;
// If TOMBO is enabled, scale up papersize. @Sep/14/98
if (BITTEST32(pOEMExtra->fUiOption, ENABLE_TOMBO))
{
lpcmd = SELECT_PAPER_A4X;
pOEM->RPDLHeapCount = (WORD)safe_sprintfA(pOEM->RPDLHeap64, sizeof(pOEM->RPDLHeap64), lpcmd);
goto _IMGCTRL_OFF1;
}
lpcmd = SELECT_PAPER_PCX;
pOEM->RPDLHeapCount = (WORD)safe_sprintfA(pOEM->RPDLHeap64, sizeof(pOEM->RPDLHeap64), lpcmd);
if (TEST_NIN1_MODE(pOEM->fGeneral1) ||
TEST_SCALING_SEL_TRAY(pOEM->fGeneral1))
{
goto _IMGCTRL_OFF1;
}
break;
case CMD_SELECT_PAPER_B3: // @Jan/07/98
pOEM->DocPaperID = RPDL_B3;
if (BITTEST32(pOEM->fGeneral1, IMGCTRL_BA80))
lpcmd = SELECT_PAPER_A3;
else if (BITTEST32(pOEM->fGeneral1, IMGCTRL_BA115))
lpcmd = SELECT_PAPER_A2;
else
lpcmd = SELECT_PAPER_B3;
pOEM->RPDLHeapCount = (WORD)safe_sprintfA(pOEM->RPDLHeap64, sizeof(pOEM->RPDLHeap64), lpcmd);
if (TEST_NIN1_MODE(pOEM->fGeneral1) ||
BITTEST32(pOEM->fGeneral1, IMGCTRL_AA67) ||
BITTEST32(pOEM->fGeneral1, IMGCTRL_AA141) ||
BITTEST32(pOEM->fGeneral1, IMGCTRL_AA200) ||
BITTEST32(pOEM->fGeneral1, IMGCTRL_AA283) ||
BITTEST32(pOEM->fGeneral1, IMGCTRL_A1_400))
{
goto _IMGCTRL_OFF1;
}
break;
case CMD_SELECT_PAPER_B4:
pOEM->DocPaperID = RPDL_B4;
fPaperX = (TEST_CAPABLE_PAPERX(pOEM->fModel) && !pOEM->StapleType &&
!pOEM->PunchType)? TRUE : FALSE;
// If TOMBO is enabled, scale up papersize. @Sep/14/98
if (BITTEST32(pOEMExtra->fUiOption, ENABLE_TOMBO))
{
lpcmd = SELECT_PAPER_A3;
pOEM->RPDLHeapCount = (WORD)safe_sprintfA(pOEM->RPDLHeap64, sizeof(pOEM->RPDLHeap64), lpcmd);
goto _IMGCTRL_OFF1;
}
if (BITTEST32(pOEM->fGeneral1, IMGCTRL_BA80))
lpcmd = (fPaperX)? SELECT_PAPER_A4X : SELECT_PAPER_A4W;
else if (BITTEST32(pOEM->fGeneral1, IMGCTRL_BA115))
lpcmd = SELECT_PAPER_A3;
else
lpcmd = SELECT_PAPER_B4;
pOEM->RPDLHeapCount = (WORD)safe_sprintfA(pOEM->RPDLHeap64, sizeof(pOEM->RPDLHeap64), lpcmd);
if (BITTEST32(pOEM->fGeneral1, IMGCTRL_2IN1_100) ||
BITTEST32(pOEM->fGeneral1, IMGCTRL_AA67) ||
BITTEST32(pOEM->fGeneral1, IMGCTRL_AA141) ||
BITTEST32(pOEM->fGeneral1, IMGCTRL_AA200) ||
BITTEST32(pOEM->fGeneral1, IMGCTRL_AA283) ||
BITTEST32(pOEM->fGeneral1, IMGCTRL_A1_400))
{
goto _IMGCTRL_OFF1;
}
break;
case CMD_SELECT_PAPER_B5:
pOEM->DocPaperID = RPDL_B5;
fPaperX = (TEST_CAPABLE_PAPERX(pOEM->fModel) && !pOEM->StapleType &&
!pOEM->PunchType)? TRUE : FALSE;
// If TOMBO is enabled, scale up papersize. @Sep/14/98
if (BITTEST32(pOEMExtra->fUiOption, ENABLE_TOMBO))
{
lpcmd = (fPaperX)? SELECT_PAPER_A4X : SELECT_PAPER_A4W;
pOEM->RPDLHeapCount = (WORD)safe_sprintfA(pOEM->RPDLHeap64, sizeof(pOEM->RPDLHeap64), lpcmd);
goto _IMGCTRL_OFF1;
}
if (BITTEST32(pOEM->fGeneral1, IMGCTRL_2IN1_100))
lpcmd = SELECT_PAPER_B4;
else if (BITTEST32(pOEM->fGeneral1, IMGCTRL_BA80))
lpcmd = (fPaperX)? SELECT_PAPER_A5X : SELECT_PAPER_A5W;
else if (BITTEST32(pOEM->fGeneral1, IMGCTRL_BA115))
lpcmd = (fPaperX)? SELECT_PAPER_A4X : SELECT_PAPER_A4W;
else
lpcmd = (fPaperX)? SELECT_PAPER_B5X : SELECT_PAPER_B5W;
pOEM->RPDLHeapCount = (WORD)safe_sprintfA(pOEM->RPDLHeap64, sizeof(pOEM->RPDLHeap64), lpcmd);
if (BITTEST32(pOEM->fGeneral1, IMGCTRL_AA67) ||
BITTEST32(pOEM->fGeneral1, IMGCTRL_AA141) ||
BITTEST32(pOEM->fGeneral1, IMGCTRL_AA200) ||
BITTEST32(pOEM->fGeneral1, IMGCTRL_AA283) ||
BITTEST32(pOEM->fGeneral1, IMGCTRL_A1_400))
{
goto _IMGCTRL_OFF1;
}
break;
case CMD_SELECT_PAPER_B6:
pOEM->DocPaperID = RPDL_B6;
fPaperX = (TEST_CAPABLE_PAPERX(pOEM->fModel) && !pOEM->StapleType &&
!pOEM->PunchType)? TRUE : FALSE;
// If TOMBO is enabled, scale up papersize. @Sep/14/98
if (BITTEST32(pOEMExtra->fUiOption, ENABLE_TOMBO))
{
lpcmd = (fPaperX)? SELECT_PAPER_A4X : SELECT_PAPER_A4W;
pOEM->RPDLHeapCount = (WORD)safe_sprintfA(pOEM->RPDLHeap64, sizeof(pOEM->RPDLHeap64), lpcmd);
goto _IMGCTRL_OFF1;
}
if (BITTEST32(pOEM->fGeneral1, IMGCTRL_2IN1_100))
lpcmd = (fPaperX)? SELECT_PAPER_B5X : SELECT_PAPER_B5W;
else if (BITTEST32(pOEM->fGeneral1, IMGCTRL_BA80))
lpcmd = SELECT_PAPER_A6;
else if (BITTEST32(pOEM->fGeneral1, IMGCTRL_BA115))
lpcmd = (fPaperX)? SELECT_PAPER_A5X : SELECT_PAPER_A5W;
else
lpcmd = SELECT_PAPER_B6;
pOEM->RPDLHeapCount = (WORD)safe_sprintfA(pOEM->RPDLHeap64, sizeof(pOEM->RPDLHeap64), lpcmd);
if (BITTEST32(pOEM->fGeneral1, IMGCTRL_AA67) ||
BITTEST32(pOEM->fGeneral1, IMGCTRL_AA141) ||
BITTEST32(pOEM->fGeneral1, IMGCTRL_AA200) ||
BITTEST32(pOEM->fGeneral1, IMGCTRL_AA283) ||
BITTEST32(pOEM->fGeneral1, IMGCTRL_A1_400))
{
goto _IMGCTRL_OFF1;
}
break;
case CMD_SELECT_PAPER_C:
pOEM->DocPaperID = RPDL_C;
lpcmd = SELECT_PAPER_C;
pOEM->RPDLHeapCount = (WORD)safe_sprintfA(pOEM->RPDLHeap64, sizeof(pOEM->RPDLHeap64), lpcmd);
if (TEST_NIN1_MODE(pOEM->fGeneral1) ||
TEST_SCALING_SEL_TRAY(pOEM->fGeneral1))
{
goto _IMGCTRL_OFF1;
}
break;
case CMD_SELECT_PAPER_TABLOID:
pOEM->DocPaperID = RPDL_TABD;
if (BITTEST32(pOEM->fGeneral1, IMGCTRL_A1_400))
lpcmd = SELECT_PAPER_A1;
else
lpcmd = SELECT_PAPER_TABD;
pOEM->RPDLHeapCount = (WORD)safe_sprintfA(pOEM->RPDLHeap64, sizeof(pOEM->RPDLHeap64), lpcmd);
if (BITTEST32(pOEM->fGeneral1, IMGCTRL_2IN1_100) ||
BITTEST32(pOEM->fGeneral1, IMGCTRL_AA67) ||
BITTEST32(pOEM->fGeneral1, IMGCTRL_BA80) ||
BITTEST32(pOEM->fGeneral1, IMGCTRL_BA115) ||
BITTEST32(pOEM->fGeneral1, IMGCTRL_AA141) ||
BITTEST32(pOEM->fGeneral1, IMGCTRL_AA200) ||
BITTEST32(pOEM->fGeneral1, IMGCTRL_AA283))
{
goto _IMGCTRL_OFF1;
}
break;
case CMD_SELECT_PAPER_LEGAL:
pOEM->DocPaperID = RPDL_LEGL;
lpcmd = SELECT_PAPER_LEGL;
pOEM->RPDLHeapCount = (WORD)safe_sprintfA(pOEM->RPDLHeap64, sizeof(pOEM->RPDLHeap64), lpcmd);
if (TEST_NIN1_MODE(pOEM->fGeneral1) ||
TEST_SCALING_SEL_TRAY(pOEM->fGeneral1))
{
goto _IMGCTRL_OFF1;
}
break;
case CMD_SELECT_PAPER_LETTER:
pOEM->DocPaperID = RPDL_LETR;
fPaperX = (TEST_CAPABLE_PAPERX(pOEM->fModel) && !pOEM->StapleType &&
!pOEM->PunchType)? TRUE : FALSE;
if (BITTEST32(pOEM->fGeneral1, IMGCTRL_2IN1_100))
lpcmd = SELECT_PAPER_TABD;
else if (BITTEST32(pOEM->fGeneral1, IMGCTRL_A1_400))
lpcmd = SELECT_PAPER_A1;
else
lpcmd = (fPaperX)? SELECT_PAPER_LETRX : SELECT_PAPER_LETRW;
pOEM->RPDLHeapCount = (WORD)safe_sprintfA(pOEM->RPDLHeap64, sizeof(pOEM->RPDLHeap64), lpcmd);
if (BITTEST32(pOEM->fGeneral1, IMGCTRL_AA67) ||
BITTEST32(pOEM->fGeneral1, IMGCTRL_BA80) ||
BITTEST32(pOEM->fGeneral1, IMGCTRL_BA115) ||
BITTEST32(pOEM->fGeneral1, IMGCTRL_AA141) ||
BITTEST32(pOEM->fGeneral1, IMGCTRL_AA200) ||
BITTEST32(pOEM->fGeneral1, IMGCTRL_AA283))
{
goto _IMGCTRL_OFF1;
}
break;
case CMD_SELECT_PAPER_STATEMENT:
pOEM->DocPaperID = RPDL_STAT;
fPaperX = (TEST_CAPABLE_PAPERX(pOEM->fModel) && !pOEM->StapleType &&
!pOEM->PunchType)? TRUE : FALSE;
if (BITTEST32(pOEM->fGeneral1, IMGCTRL_2IN1_100))
lpcmd = (fPaperX)? SELECT_PAPER_LETRX : SELECT_PAPER_LETRW;
else
lpcmd = (fPaperX)? SELECT_PAPER_STATX : SELECT_PAPER_STATW;
pOEM->RPDLHeapCount = (WORD)safe_sprintfA(pOEM->RPDLHeap64, sizeof(pOEM->RPDLHeap64), lpcmd);
if (TEST_SCALING_SEL_TRAY(pOEM->fGeneral1))
goto _IMGCTRL_OFF1;
break;
case CMD_SELECT_PAPER_A2TOA3:
pOEM->DocPaperID = RPDL_A2A3;
WRITESPOOLBUF(pdevobj, IMAGE_SCALING_67, sizeof(IMAGE_SCALING_67)-1);
// DCR @Jan/27/2000 ->
// Emit DUPLEX_ON here, because IMAGE_SCALING_xxx resets DUPLEX_ON.
if (BITTEST32(pOEM->fGeneral1, DUPLEX_VALID))
WRITESPOOLBUF(pdevobj, DUPLEX_ON, sizeof(DUPLEX_ON)-1);
// @Jan/27/2000 <-
lpcmd = SELECT_PAPER_A3;
pOEM->RPDLHeapCount = (WORD)safe_sprintfA(pOEM->RPDLHeap64, sizeof(pOEM->RPDLHeap64), lpcmd);
if (TEST_NIN1_MODE(pOEM->fGeneral1) ||
TEST_SCALING_SEL_TRAY(pOEM->fGeneral1))
{
goto _IMGCTRL_OFF2;
}
break;
case CMD_SELECT_PAPER_A3TOA4: // for NX70 @Feb/04/98
pOEM->DocPaperID = RPDL_A3A4;
WRITESPOOLBUF(pdevobj, IMAGE_SCALING_67, sizeof(IMAGE_SCALING_67)-1);
// DCR @Jan/27/2000 ->
// Emit DUPLEX_ON here, because IMAGE_SCALING_xxx resets DUPLEX_ON.
if (BITTEST32(pOEM->fGeneral1, DUPLEX_VALID))
WRITESPOOLBUF(pdevobj, DUPLEX_ON, sizeof(DUPLEX_ON)-1);
// @Jan/27/2000 <-
lpcmd = SELECT_PAPER_A4X;
pOEM->RPDLHeapCount = (WORD)safe_sprintfA(pOEM->RPDLHeap64, sizeof(pOEM->RPDLHeap64), lpcmd);
if (TEST_NIN1_MODE(pOEM->fGeneral1) ||
TEST_SCALING_SEL_TRAY(pOEM->fGeneral1))
{
goto _IMGCTRL_OFF2;
}
break;
case CMD_SELECT_PAPER_B4TOA4: // for NX70 @Feb/04/98
pOEM->DocPaperID = RPDL_B4A4;
WRITESPOOLBUF(pdevobj, IMAGE_SCALING_80, sizeof(IMAGE_SCALING_80)-1);
// DCR @Jan/27/2000 ->
// Emit DUPLEX_ON here, because IMAGE_SCALING_xxx resets DUPLEX_ON.
if (BITTEST32(pOEM->fGeneral1, DUPLEX_VALID))
WRITESPOOLBUF(pdevobj, DUPLEX_ON, sizeof(DUPLEX_ON)-1);
// @Jan/27/2000 <-
lpcmd = SELECT_PAPER_A4X;
pOEM->RPDLHeapCount = (WORD)safe_sprintfA(pOEM->RPDLHeap64, sizeof(pOEM->RPDLHeap64), lpcmd);
if (TEST_NIN1_MODE(pOEM->fGeneral1) ||
TEST_SCALING_SEL_TRAY(pOEM->fGeneral1))
{
goto _IMGCTRL_OFF2;
}
break;
case CMD_SELECT_PAPER_11x15TOA4: // @Feb/07/2000
pOEM->DocPaperID = RPDL_11x15A4;
WRITESPOOLBUF(pdevobj, IMAGE_SCALING_67, sizeof(IMAGE_SCALING_67)-1);
if (BITTEST32(pOEM->fGeneral1, DUPLEX_VALID))
WRITESPOOLBUF(pdevobj, DUPLEX_ON, sizeof(DUPLEX_ON)-1);
fPaperX = (TEST_CAPABLE_PAPERX(pOEM->fModel) && !pOEM->StapleType &&
!pOEM->PunchType)? TRUE : FALSE;
lpcmd = (fPaperX)? SELECT_PAPER_A4X : SELECT_PAPER_A4W;
pOEM->RPDLHeapCount = (WORD)safe_sprintfA(pOEM->RPDLHeap64, sizeof(pOEM->RPDLHeap64), lpcmd);
// Emulate NEC MultiWriter 2200
if (BITTEST32(pOEM->fGeneral1, ORIENT_LANDSCAPE))
{
pOEM->BaseOffset.x = 37; // mm
pOEM->BaseOffset.y = 15;
}
else
{
pOEM->BaseOffset.x = 15;
pOEM->BaseOffset.y = 37;
}
if (TEST_NIN1_MODE(pOEM->fGeneral1) ||
TEST_SCALING_SEL_TRAY(pOEM->fGeneral1))
{
goto _IMGCTRL_OFF2;
}
break;
case CMD_SELECT_PAPER_DOUBLEPOSTCARD:
BITSET32(pOEM->fGeneral1, PAPER_DOUBLEPOSTCARD);
goto _SET_CUSTOMSIZE;
case CMD_SELECT_PAPER_CUSTOM: // pdwParams:PhysPaperWidth,Length
pOEM->PhysPaperWidth = (WORD)*pdwParams; // @Dec/26/97
pOEM->PhysPaperLength = (WORD)*(pdwParams+1);
BITSET32(pOEM->fGeneral1, PAPER_CUSTOMSIZE);
_SET_CUSTOMSIZE:
pOEM->DocPaperID = RPDL_CUSTOMSIZE;
pOEM->RPDLHeapCount = 0;
if (TEST_NIN1_MODE(pOEM->fGeneral1) ||
TEST_SCALING_SEL_TRAY(pOEM->fGeneral1))
{
goto _IMGCTRL_OFF1;
}
break;
_IMGCTRL_OFF1:
// Invalidate image controls
pOEM->Scale = 100; // @Mar/18/98
WRITESPOOLBUF(pdevobj, IMAGE_SCALING_100, sizeof(IMAGE_SCALING_100)-1);
// DCR @Jan/27/2000 ->
// Emit DUPLEX_ON here, because IMAGE_SCALING_xxx resets DUPLEX_ON.
if (BITTEST32(pOEM->fGeneral1, DUPLEX_VALID))
WRITESPOOLBUF(pdevobj, DUPLEX_ON, sizeof(DUPLEX_ON)-1);
// @Jan/27/2000 <-
_IMGCTRL_OFF2:
BITCLR_SCALING_SEL_TRAY(pOEM->fGeneral1);
BITCLR_NIN1_MODE(pOEM->fGeneral1);
break;
case CMD_SET_LONG_EDGE_FEED: // for Multi Tray @May/25/98
BITSET32(pOEM->fGeneral2, LONG_EDGE_FEED);
break;
case CMD_SET_SHORT_EDGE_FEED: // for Multi Tray @May/25/98
BITCLR32(pOEM->fGeneral2, LONG_EDGE_FEED);
break;
case CMD_SELECT_AUTOFEED:
// Set MediaType (modify @Mar/03/99, @Feb/15/2000, moved top@Sep/27/2000)
if (TEST_CAPABLE_MEDIATYPE(pOEM->fModel))
{
// @Oct/13/2000 ->
// ocmd = safe_sprintfA(Cmd, sizeof(Cmd), SELECT_MEDIATYPE, 'T', '0'+pOEM->MediaType);
ocmd = safe_sprintfA(Cmd, sizeof(Cmd), SELECT_MEDIATYPE, 'T', pOEM->MediaType);
// @Oct/13/2000 <-
WRITESPOOLBUF(pdevobj, Cmd, ocmd);
ocmd = 0;
}
if (BITTEST32(pOEM->fGeneral1, PAPER_CUSTOMSIZE) ||
BITTEST32(pOEM->fGeneral1, PAPER_DOUBLEPOSTCARD))
{
// Select ManualFeed
WRITESPOOLBUF(pdevobj, SELECT_MANUALFEED, sizeof(SELECT_MANUALFEED)-1);
goto _SELECTPAPER_CUSTOMSIZE;
}
// Output Set_Limitless_Paper_Supply_Mode
WRITESPOOLBUF(pdevobj, SET_LIMITLESS_SUPPLY, sizeof(SET_LIMITLESS_SUPPLY)-1);
// Output Select_Tray_By_Papersize command.
// if letter size, select A4 first in case of no letter paper.
if (!strcmp(pOEM->RPDLHeap64, SELECT_PAPER_LETRX))
{
WRITESPOOLBUF(pdevobj, SEL_TRAY_PAPER_HEAD, sizeof(SEL_TRAY_PAPER_HEAD)-1);
WRITESPOOLBUF(pdevobj, SELECT_PAPER_A4X, sizeof(SELECT_PAPER_A4X)-1);
}
else if (!strcmp(pOEM->RPDLHeap64, SELECT_PAPER_LETRW))
{
WRITESPOOLBUF(pdevobj, SEL_TRAY_PAPER_HEAD, sizeof(SEL_TRAY_PAPER_HEAD)-1);
WRITESPOOLBUF(pdevobj, SELECT_PAPER_A4W, sizeof(SELECT_PAPER_A4W)-1);
}
WRITESPOOLBUF(pdevobj, SEL_TRAY_PAPER_HEAD, sizeof(SEL_TRAY_PAPER_HEAD)-1);
WRITESPOOLBUF(pdevobj, pOEM->RPDLHeap64, pOEM->RPDLHeapCount);
break;
// @Dec/10/99 FK#49, add TRAY1,3,4,5 & reset limitless @Sep/27/2000 ->
case CMD_SELECT_TRAY1:
case CMD_SELECT_TRAY2:
case CMD_SELECT_TRAY3:
case CMD_SELECT_TRAY4:
case CMD_SELECT_TRAY5:
ocmd = safe_sprintfA(Cmd, sizeof(Cmd), SELECT_TRAY_N, dwCmdCbID - CMD_SELECT_TRAY1 + 2);
WRITESPOOLBUF(pdevobj, Cmd, ocmd);
if (TEST_GWMODEL(pOEM->fModel))
WRITESPOOLBUF(pdevobj, RESET_LIMITLESS_SUPPLY, sizeof(RESET_LIMITLESS_SUPPLY)-1);
if (BITTEST32(pOEM->fGeneral1, PAPER_CUSTOMSIZE) ||
BITTEST32(pOEM->fGeneral1, PAPER_DOUBLEPOSTCARD))
{
goto _SELECTPAPER_CUSTOMSIZE;
}
break;
// @Dec/10/99, @Sep/27/2000 <-
case CMD_SELECT_MANUALFEED:
case CMD_SELECT_MULTIFEEDER:
case CMD_SELECT_MULTITRAY: // NXs' MultiTray
// Moved forward, because NX710(MultiTray) support MediaType @Mar/11/99 ->
// Set MediaType (modify @Mar/03/99, @Feb/15/2000)
if (TEST_CAPABLE_MEDIATYPE(pOEM->fModel))
{
// @Oct/13/2000 ->
// ocmd = safe_sprintfA(Cmd, sizeof(Cmd), SELECT_MEDIATYPE, 'T', '0'+pOEM->MediaType);
ocmd = safe_sprintfA(Cmd, sizeof(Cmd), SELECT_MEDIATYPE, 'T', pOEM->MediaType);
// @Oct/13/2000 <-
WRITESPOOLBUF(pdevobj, Cmd, ocmd);
ocmd = 0;
}
// @Mar/11/99 <-
// Select Feeder
if (dwCmdCbID == CMD_SELECT_MANUALFEED)
{
// Select ManualFeed
WRITESPOOLBUF(pdevobj, SELECT_MANUALFEED, sizeof(SELECT_MANUALFEED)-1);
}
else
{
// Select MultiFeeder/MultTray
WRITESPOOLBUF(pdevobj, SELECT_MULTIFEEDER, sizeof(SELECT_MULTIFEEDER)-1);
//@Sep/27/2000 ->
if (TEST_GWMODEL(pOEM->fModel))
WRITESPOOLBUF(pdevobj, RESET_LIMITLESS_SUPPLY, sizeof(RESET_LIMITLESS_SUPPLY)-1);
//@Sep/27/2000 <-
}
// If CustomSize, jump.
if (BITTEST32(pOEM->fGeneral1, PAPER_CUSTOMSIZE) ||
BITTEST32(pOEM->fGeneral1, PAPER_DOUBLEPOSTCARD))
{
goto _SELECTPAPER_CUSTOMSIZE;
}
// Set papersize
// If papersize without transverse (A1,A2,A3,A6,B3,B4,B6,C,Tabloid,Legal)
if (!strcmp(pOEM->RPDLHeap64, SELECT_PAPER_A1) ||
!strcmp(pOEM->RPDLHeap64, SELECT_PAPER_A2) ||
!strcmp(pOEM->RPDLHeap64, SELECT_PAPER_A3) ||
!strcmp(pOEM->RPDLHeap64, SELECT_PAPER_A6) ||
!strcmp(pOEM->RPDLHeap64, SELECT_PAPER_B3) || // @Feb/05/98
!strcmp(pOEM->RPDLHeap64, SELECT_PAPER_B4) ||
!strcmp(pOEM->RPDLHeap64, SELECT_PAPER_B6) ||
!strcmp(pOEM->RPDLHeap64, SELECT_PAPER_C) ||
!strcmp(pOEM->RPDLHeap64, SELECT_PAPER_TABD) ||
!strcmp(pOEM->RPDLHeap64, SELECT_PAPER_LEGL))
{
// Output Select_Papersize command
WRITESPOOLBUF(pdevobj, SELECT_PAPER_HEAD, sizeof(SELECT_PAPER_HEAD)-1);
WRITESPOOLBUF(pdevobj, pOEM->RPDLHeap64, pOEM->RPDLHeapCount);
}
else
{
if (!strcmp(pOEM->RPDLHeap64, SELECT_PAPER_A4X) ||
!strcmp(pOEM->RPDLHeap64, SELECT_PAPER_A4W))
{
// If long edge feed is enabled, set transverse paper. @May/25/98
if (dwCmdCbID == CMD_SELECT_MULTITRAY &&
BITTEST32(pOEM->fGeneral2, LONG_EDGE_FEED))
{
lpcmd = SELECT_PAPER_A4;
}
else
{
lpcmd = SELECT_PAPER_A4R;
}
}
else if (!strcmp(pOEM->RPDLHeap64, SELECT_PAPER_A5X) ||
!strcmp(pOEM->RPDLHeap64, SELECT_PAPER_A5W))
{
if (dwCmdCbID == CMD_SELECT_MULTITRAY &&
BITTEST32(pOEM->fGeneral2, LONG_EDGE_FEED))
{
lpcmd = SELECT_PAPER_A5;
}
else
{
lpcmd = SELECT_PAPER_A5R;
}
}
else if (!strcmp(pOEM->RPDLHeap64, SELECT_PAPER_B5X) ||
!strcmp(pOEM->RPDLHeap64, SELECT_PAPER_B5W))
{
if (dwCmdCbID == CMD_SELECT_MULTITRAY &&
BITTEST32(pOEM->fGeneral2, LONG_EDGE_FEED))
{
lpcmd = SELECT_PAPER_B5;
}
else
{
lpcmd = SELECT_PAPER_B5R;
}
}
else if (!strcmp(pOEM->RPDLHeap64, SELECT_PAPER_LETRX) ||
!strcmp(pOEM->RPDLHeap64, SELECT_PAPER_LETRW))
{
if (dwCmdCbID == CMD_SELECT_MULTITRAY &&
BITTEST32(pOEM->fGeneral2, LONG_EDGE_FEED))
{
lpcmd = SELECT_PAPER_LETR;
}
else
{
lpcmd = SELECT_PAPER_LETRR;
}
}
else if (!strcmp(pOEM->RPDLHeap64, SELECT_PAPER_STATX) ||
!strcmp(pOEM->RPDLHeap64, SELECT_PAPER_STATW))
{
if (dwCmdCbID == CMD_SELECT_MULTITRAY &&
BITTEST32(pOEM->fGeneral2, LONG_EDGE_FEED))
{
lpcmd = SELECT_PAPER_STAT;
}
else
{
lpcmd = SELECT_PAPER_STATR;
}
}
else if (!strcmp(pOEM->RPDLHeap64, SELECT_PAPER_PCX)) // @Feb/13/98
{
if (dwCmdCbID == CMD_SELECT_MULTITRAY &&
BITTEST32(pOEM->fGeneral2, LONG_EDGE_FEED))
{
lpcmd = SELECT_PAPER_PC;
}
else
{
lpcmd = SELECT_PAPER_PCR;
}
}
else
break; // exit
// Output Select_Papersize command
ocmd = safe_sprintfA(Cmd, sizeof(Cmd), SELECT_PAPER_HEAD);
ocmd += safe_sprintfA(&Cmd[ocmd], sizeof(Cmd) - ocmd, lpcmd);
WRITESPOOLBUF(pdevobj, Cmd, ocmd);
} // 'if (A1,A2,A3,A6,B4,B6,C,TABLOID,LEGAL) else' end
// Reconfirm ManualFeed/AutoFeed.
if (dwCmdCbID == CMD_SELECT_MANUALFEED)
WRITESPOOLBUF(pdevobj, SELECT_MANUALFEED, sizeof(SELECT_MANUALFEED)-1);
else
WRITESPOOLBUF(pdevobj, SELECT_MULTIFEEDER, sizeof(SELECT_MULTIFEEDER)-1);
break;
_SELECTPAPER_CUSTOMSIZE:
{
DWORD dwWidth, dwHeight;
// If DoublePostcard
if (BITTEST32(pOEM->fGeneral1, PAPER_DOUBLEPOSTCARD))
{
if (BITTEST32(pOEM->fGeneral1, ORIENT_LANDSCAPE))
{
dwWidth = 148; // mm
dwHeight = 200;
}
else
{
dwWidth = 200;
dwHeight = 148;
}
// Set max pagesize (mm to dot with KIRISUTE)
pOEM->PageMax.x = (LONG)(dwWidth * (DWORD)(MASTERUNIT*10) /
(DWORD)254 / (DWORD)pOEM->nResoRatio);
pOEM->PageMax.y = (LONG)(dwHeight * (DWORD)(MASTERUNIT*10) /
(DWORD)254 / (DWORD)pOEM->nResoRatio);
}
// If CustomSize
else
{
if (BITTEST32(pOEM->fGeneral1, ORIENT_LANDSCAPE))
{
dwWidth = pOEM->PhysPaperLength; // masterunit
dwHeight = pOEM->PhysPaperWidth;
}
else
{
dwWidth = pOEM->PhysPaperWidth; // masterunit
dwHeight = pOEM->PhysPaperLength;
}
// Set max pagesize
pOEM->PageMax.x = (LONG)(dwWidth / pOEM->nResoRatio); // dot
pOEM->PageMax.y = (LONG)(dwHeight / pOEM->nResoRatio);
// masterunit to mm with SISHAGONYU
dwWidth = (dwWidth * (DWORD)254 + (DWORD)(MASTERUNIT*10/2)) /
(DWORD)(MASTERUNIT*10);
dwHeight = (dwHeight * (DWORD)254 + (DWORD)(MASTERUNIT*10/2)) /
(DWORD)(MASTERUNIT*10);
}
BITCLR32(pOEM->fGeneral1, CUSTOMSIZE_USE_LAND);
BITCLR32(pOEM->fGeneral1, CUSTOMSIZE_MAKE_LAND_PORT);
// Because app sometimes sets under-limit in landscape,
// we need to swap width and height. @Oct/21/98
if (dwHeight < USRD_H_MIN148) // < 148
{
DWORD dwTmp;
dwTmp = dwWidth;
dwWidth = dwHeight;
dwHeight = dwTmp;
}
else if (dwWidth >= dwHeight)
{
WORD fSwap = FALSE;
// Because app sometimes sets over-limit width in portrait,
// we need to swap width and height.
if (TEST_CAPABLE_PAPER_A2(pOEM->fModel))
{
if (dwWidth > USRD_W_A2) // > 432
fSwap = TRUE;
}
else if (TEST_CAPABLE_PAPER_A3_W297(pOEM->fModel))
{
if (dwWidth > USRD_W_A3) // > 297
fSwap = TRUE;
}
else if (TEST_CAPABLE_PAPER_A4MAX(pOEM->fModel))
{
if (dwWidth > USRD_W_A4) // > 216
fSwap = TRUE;
}
else
{
if (dwWidth > USRD_W_A3_OLD) // > 296
fSwap = TRUE;
}
if (fSwap)
{
DWORD dwTmp;
dwTmp = dwWidth;
dwWidth = dwHeight;
dwHeight = dwTmp;
}
// SPEC of RPDL
// If width is larger than length, we need to set landscape.
else
{
BITSET32(pOEM->fGeneral1, CUSTOMSIZE_USE_LAND);
}
}
else
{
BITSET32(pOEM->fGeneral1, CUSTOMSIZE_MAKE_LAND_PORT);
}
// @Dec/10/99 FK#49, add TRAY1-5 & eliminate TRAYA-D @Sep/27/2000 ->
// ocmd = safe_sprintfA(Cmd, sizeof(Cmd), SELECT_PAPER_CUSTOM, (WORD)dwWidth, (WORD)dwHeight);
// WRITESPOOLBUF(pdevobj, Cmd, ocmd);
if (dwCmdCbID >= CMD_SELECT_TRAY1 && dwCmdCbID <= CMD_SELECT_TRAY5)
{
ocmd = safe_sprintfA(Cmd, sizeof(Cmd), SELECT_PAPER_CUSTOM2, (WORD)dwWidth, (WORD)dwHeight,
dwCmdCbID - CMD_SELECT_TRAY1 + 2);
}
else // manual feed
{
ocmd = safe_sprintfA(Cmd, sizeof(Cmd), SELECT_PAPER_CUSTOM, (WORD)dwWidth, (WORD)dwHeight);
ocmd += safe_sprintfA(&Cmd[ocmd], sizeof(Cmd) - ocmd, SELECT_MANUALFEED, sizeof(SELECT_MANUALFEED)-1);
}
WRITESPOOLBUF(pdevobj, Cmd, ocmd);
// @Dec/10/99, @Sep/27/2000 <-
}
break;
case CMD_SELECT_ROLL1: // IP-1
case CMD_SELECT_ROLL2:
// Select roll (plotter)
if (dwCmdCbID == CMD_SELECT_ROLL1)
WRITESPOOLBUF(pdevobj, SELECT_ROLL1, sizeof(SELECT_ROLL1)-1);
else
WRITESPOOLBUF(pdevobj, SELECT_ROLL2, sizeof(SELECT_ROLL2)-1);
// Output Select_Papersize command ("papername+X" only)
WRITESPOOLBUF(pdevobj, SELECT_PAPER_HEAD_IP1, sizeof(SELECT_PAPER_HEAD_IP1)-1);
WRITESPOOLBUF(pdevobj, pOEM->RPDLHeap64, pOEM->RPDLHeapCount);
break;
case CMD_SELECT_FINISHER_TRAY2: // @Jun/25/2001
pOEM->FinisherTrayNum = 2;
ocmd = safe_sprintfA(Cmd, sizeof(Cmd), SET_PAPERDEST_FINISHER_GW, pOEM->FinisherTrayNum);
WRITESPOOLBUF(pdevobj, Cmd, ocmd);
break;
case CMD_SET_COLLATE_OFF: // @Jul/31/98
pOEM->CollateType = COLLATE_OFF; // COLLATE_OFF<-0 @Dec/02/98
break;
case CMD_SET_COLLATE_ON: // @Jul/31/98
pOEM->CollateType = COLLATE_ON; // COLLATE_ON<-1 @Dec/02/98
break;
case CMD_SELECT_COLLATE_UNIDIR: // @Aug/10/98
if (COLLATE_OFF != pOEM->CollateType)
pOEM->CollateType = COLLATE_UNIDIR; // COLLATE_UNIDIR<-2 @Dec/02/98
break;
case CMD_SELECT_COLLATE_ROTATED: // @Aug/10/98
if (COLLATE_OFF != pOEM->CollateType)
pOEM->CollateType = COLLATE_ROTATED; // COLLATE_ROTATED<-3 @Dec/02/98
break;
case CMD_SELECT_COLLATE_SHIFTED: // @Dec/02/98
if (COLLATE_OFF != pOEM->CollateType)
pOEM->CollateType = COLLATE_SHIFTED;
break;
// Final command before print
case CMD_MULTI_COPIES: // pdwParams:NumOfCopies
// If not CustomSize, set max pagesize.
if ((nTmp = pOEM->DocPaperID) != RPDL_CUSTOMSIZE)
{
if (BITTEST32(pOEM->fGeneral2, EDGE2EDGE_PRINT)) // @Nov/27/97
{
pOEM->PageMax.x = RPDLPageSizeE2E[nTmp].x / pOEM->nResoRatio;
pOEM->PageMax.y = RPDLPageSizeE2E[nTmp].y / pOEM->nResoRatio;
}
else
{
pOEM->PageMax.x = RPDLPageSize[nTmp].x / pOEM->nResoRatio;
pOEM->PageMax.y = RPDLPageSize[nTmp].y / pOEM->nResoRatio;
}
if (BITTEST32(pOEM->fGeneral1, ORIENT_LANDSCAPE))
{
LONG tmp;
tmp = pOEM->PageMax.x; // swap x-y
pOEM->PageMax.x = pOEM->PageMax.y;
pOEM->PageMax.y = tmp;
}
}
if (TEST_BUGFIX_FORMFEED(pOEM->fModel) || // add @Sep/15/98
BITTEST32(pOEMExtra->fUiOption, ENABLE_TOMBO))
{
pOEM->PageMaxMoveY = pOEM->PageMax.y;
}
else
{
// PRINTER SIDE ISSUE: RPDL
// Because RPDL do formfeed when vertical position is around
// ymax-coordinate, we shift position upper 1mm.
// Set PageMaxMoveY for checking max vertical position.
nTmp = BITTEST32(pOEM->fGeneral2, EDGE2EDGE_PRINT)? // @Nov/27/97
DISABLE_FF_MARGIN_E2E : DISABLE_FF_MARGIN_STD;
pOEM->PageMaxMoveY = pOEM->PageMax.y - 1 -
(nTmp + pOEM->nResoRatio - 1) /
pOEM->nResoRatio; // KIRIAGE
}
// If 2in1, switch orientation(portrait<->landscape).
if (TEST_2IN1_MODE(pOEM->fGeneral1))
BITSET32(pOEM->fGeneral1, SWITCH_PORT_LAND);
if (BITTEST32(pOEM->fGeneral1, ORIENT_LANDSCAPE))
{
if (BITTEST32(pOEM->fGeneral1, SWITCH_PORT_LAND) ||
BITTEST32(pOEM->fGeneral1, CUSTOMSIZE_MAKE_LAND_PORT))
{
fLandscape = FALSE;
}
else
{
fLandscape = TRUE;
}
}
else // portrait
{
fLandscape = BITTEST32(pOEM->fGeneral1, SWITCH_PORT_LAND)? TRUE : FALSE;
}
// Output RPDL orientation command
if (fLandscape || BITTEST32(pOEM->fGeneral1, CUSTOMSIZE_USE_LAND))
WRITESPOOLBUF(pdevobj, SET_LANDSCAPE, sizeof(SET_LANDSCAPE)-1);
else // portrait
WRITESPOOLBUF(pdevobj, SET_PORTRAIT, sizeof(SET_PORTRAIT)-1);
// Output copy#
// Check whether copy# is in the range. @Sep/01/98
{
DWORD dwCopy, dwMax;
dwCopy = *pdwParams; // NumOfCopies
dwMax = TEST_MAXCOPIES_99(pOEM->fModel)? 99 : 999;
if(dwCopy > dwMax)
dwCopy = dwMax;
else if(dwCopy < 1)
dwCopy = 1;
ocmd = safe_sprintfA(Cmd, sizeof(Cmd), SET_MULTI_COPY, (WORD)dwCopy);
WRITESPOOLBUF(pdevobj, Cmd, ocmd);
// @Jan/08/99 ->
if (1 == dwCopy)
pOEM->CollateType = COLLATE_OFF;
// @Jan/08/99 <-
}
fFinisherSR30Active = FALSE; // @Mar/19/99
// staple
if (pOEM->StapleType)
{
ocmd = 0;
if (BITTEST32(pOEM->fModel, GRP_MF250M)) // model = MF250M (No Punch Unit)
{
// sort:on (add duplex param since NX900 @Jan/08/99)
ocmd = safe_sprintfA(Cmd, sizeof(Cmd), SET_SORT_ON,
BITTEST32(pOEM->fGeneral1, DUPLEX_VALID)? 1 : 0);
// paper_destination:outer tray
ocmd += safe_sprintfA(&Cmd[ocmd], sizeof(Cmd) - ocmd, SET_PAPERDEST_OUTTRAY);
// staple:on
ocmd += safe_sprintfA(&Cmd[ocmd], sizeof(Cmd) - ocmd, SET_STAPLE_CORNER_ON,
(fLandscape)?
STAPLE_UPPERRIGHT_CORNER : STAPLE_UPPERLEFT_CORNER);
}
else // model = MF2700,3500,3550,4550,5550,6550,NXs
{
WORD pnt;
fFinisherSR30Active = TRUE; // @Mar/19/99
// sort:on (add duplex param since NX900 @Jan/08/99)
ocmd = safe_sprintfA(Cmd, sizeof(Cmd), SET_SORT_ON,
BITTEST32(pOEM->fGeneral1, DUPLEX_VALID)? 1 : 0);
// paper_destination:finisher shift tray
// @Jun/25/2001 ->
// if (!TEST_GWMODEL(pOEM->fModel)) // add if @Oct/10/2000
// ocmd += safe_sprintfA(&Cmd[ocmd], sizeof(Cmd) - ocmd, SET_PAPERDEST_FINISHER);
if (TEST_GWMODEL(pOEM->fModel))
ocmd += safe_sprintfA(&Cmd[ocmd], sizeof(Cmd) - ocmd, SET_PAPERDEST_FINISHER_GW, pOEM->FinisherTrayNum);
else
ocmd += safe_sprintfA(&Cmd[ocmd], sizeof(Cmd) - ocmd, SET_PAPERDEST_FINISHER, pOEM->FinisherTrayNum);
// @Jun/25/2001 <-
// Disable rotated collate.
ocmd += safe_sprintfA(&Cmd[ocmd], sizeof(Cmd) - ocmd, COLLATE_DISABLE_ROT); // @Mar/19/99
if (pOEM->StapleType == 2) // 2 staples on the paper
{
switch (pOEM->BindPoint)
{
case BIND_LEFT:
pnt = STAPLE_LEFT2;
break;
case BIND_RIGHT:
pnt = STAPLE_RIGHT2;
break;
case BIND_UPPER:
pnt = STAPLE_UPPER2;
break;
// case BIND_ANY:
default:
pnt = (fLandscape)? STAPLE_UPPER2 : STAPLE_LEFT2;
break;
}
// staple:on
ocmd += safe_sprintfA(&Cmd[ocmd], sizeof(Cmd) - ocmd, SET_STAPLE_ON, pnt);
}
// @Mar/18/99 ->
else if (pOEM->StapleType == 3) // 1 staple with FinisherSR12
{
// @Apr/06/99 ->
// if (BIND_RIGHT == pOEM->BindPoint)
// pnt = STAPLE_UPPERRIGHT_CORNER;
// else
// pnt = (fLandscape)? STAPLE_UPPERRIGHT_CORNER : STAPLE_UPPERLEFT_CORNER;
switch (pOEM->BindPoint)
{
case BIND_LEFT:
pnt = STAPLE_UPPERLEFT_CORNER;
break;
case BIND_RIGHT:
pnt = STAPLE_UPPERRIGHT_CORNER;
break;
default:
// If papersize without transverse (A3,B4,Tabloid,Legal)
if (!strcmp(pOEM->RPDLHeap64, SELECT_PAPER_A3) ||
!strcmp(pOEM->RPDLHeap64, SELECT_PAPER_B4) ||
!strcmp(pOEM->RPDLHeap64, SELECT_PAPER_TABD) ||
!strcmp(pOEM->RPDLHeap64, SELECT_PAPER_LEGL))
{
pnt = (fLandscape)? STAPLE_UPPERLEFT_CORNER : STAPLE_UPPERRIGHT_CORNER;
}
else
{
pnt = (fLandscape)? STAPLE_UPPERRIGHT_CORNER : STAPLE_UPPERLEFT_CORNER;
}
break;
}
// @Apr/06/99 <-
// staple:on
ocmd += safe_sprintfA(&Cmd[ocmd], sizeof(Cmd) - ocmd, SET_STAPLE_CORNER_ON, pnt);
}
// @Mar/18/99 <-
else // 1 staple
{
switch (pOEM->BindPoint)
{
case BIND_RIGHT:
pnt = STAPLE_UPPERRIGHT_CORNER;
break;
default:
pnt = STAPLE_UPPERLEFT_CORNER;
break;
}
// staple:on
ocmd += safe_sprintfA(&Cmd[ocmd], sizeof(Cmd) - ocmd, SET_STAPLE_CORNER_ON, pnt);
}
}
WRITESPOOLBUF(pdevobj, Cmd, ocmd);
}
// punch
if (pOEM->PunchType)
{
WORD pnt;
ocmd = 0;
if (!fFinisherSR30Active) // modify @Mar/19/99
{
if (COLLATE_OFF != pOEM->CollateType)
{
// sort:on (add duplex param since NX900 @Jan/08/99)
ocmd = safe_sprintfA(Cmd, sizeof(Cmd), SET_SORT_ON,
BITTEST32(pOEM->fGeneral1, DUPLEX_VALID)? 1 : 0);
}
// paper_destination:finisher shift tray
// @Jun/25/2001 ->
// if (!TEST_GWMODEL(pOEM->fModel)) // add if @Oct/10/2000
// ocmd += safe_sprintfA(&Cmd[ocmd], sizeof(Cmd) - ocmd, SET_PAPERDEST_FINISHER);
if (TEST_GWMODEL(pOEM->fModel))
ocmd += safe_sprintfA(&Cmd[ocmd], sizeof(Cmd) - ocmd, SET_PAPERDEST_FINISHER_GW, pOEM->FinisherTrayNum);
else
ocmd += safe_sprintfA(&Cmd[ocmd], sizeof(Cmd) - ocmd, SET_PAPERDEST_FINISHER, pOEM->FinisherTrayNum);
// @Jun/25/2001 <-
// SPEC of RPDL @May/27/98
// We must disable rotated collate here.
ocmd += safe_sprintfA(&Cmd[ocmd], sizeof(Cmd) - ocmd, COLLATE_DISABLE_ROT);
}
switch (pOEM->BindPoint)
{
case BIND_LEFT:
pnt = PUNCH_LEFT;
break;
case BIND_RIGHT:
pnt = PUNCH_RIGHT;
break;
case BIND_UPPER:
pnt = PUNCH_UPPER;
break;
default:
pnt = (fLandscape)? PUNCH_UPPER : PUNCH_LEFT;
break;
}
// punch:on
ocmd += safe_sprintfA(&Cmd[ocmd], sizeof(Cmd) - ocmd, SET_PUNCH_ON, pnt);
WRITESPOOLBUF(pdevobj, Cmd, ocmd);
}
// collate (@Jul/31/98, entirely-modify @Dec/02/98)
if (!pOEM->StapleType && !pOEM->PunchType)
{
// sort:on (add duplex param since NX900 @Jan/08/99)
ocmd = safe_sprintfA(Cmd, sizeof(Cmd), SET_SORT_ON,
BITTEST32(pOEM->fGeneral1, DUPLEX_VALID)? 1 : 0);
switch (pOEM->CollateType)
{
case COLLATE_UNIDIR:
ocmd += safe_sprintfA(&Cmd[ocmd], sizeof(Cmd) - ocmd, COLLATE_DISABLE_ROT);
WRITESPOOLBUF(pdevobj, Cmd, ocmd);
break;
case COLLATE_ROTATED:
ocmd += safe_sprintfA(&Cmd[ocmd], sizeof(Cmd) - ocmd, COLLATE_ENABLE_ROT);
WRITESPOOLBUF(pdevobj, Cmd, ocmd);
break;
// If shifted collate, select finisher shift tray.
case COLLATE_SHIFTED:
// @Jun/25/2001 ->
// if (!TEST_GWMODEL(pOEM->fModel)) // add if @Oct/10/2000
// ocmd += safe_sprintfA(&Cmd[ocmd], sizeof(Cmd) - ocmd, SET_PAPERDEST_FINISHER);
if (TEST_GWMODEL(pOEM->fModel))
ocmd += safe_sprintfA(&Cmd[ocmd], sizeof(Cmd) - ocmd, SET_PAPERDEST_FINISHER_GW, pOEM->FinisherTrayNum);
else
ocmd += safe_sprintfA(&Cmd[ocmd], sizeof(Cmd) - ocmd, SET_PAPERDEST_FINISHER, pOEM->FinisherTrayNum);
// @Jun/25/2001 <-
WRITESPOOLBUF(pdevobj, Cmd, ocmd);
break;
// if collate for MF-p150,MF200,250M,2200,NXs
case COLLATE_ON:
WRITESPOOLBUF(pdevobj, Cmd, ocmd);
break;
default:
break;
}
}
ocmd = 0;
if (TEST_AFTER_SP9II(pOEM->fModel) && !BITTEST32(pOEM->fModel, GRP_NX100))
{
//@Jun/23/2000 ->
// PRINTER SIDE ISSUE: NX610,710,71 RPDL
// Printer hangs up with variable scaling command. Dummy font select is
// effective on this problem.
if (BITTEST32(pOEM->fModel, GRP_NX70) || BITTEST32(pOEM->fModel, GRP_NX710))
{
// Emit dummy Mincho font select.
ocmd = safe_sprintfA(Cmd, sizeof(Cmd), SET_JIS_FONT_SCALE_H_ONLY, 1000L);
ocmd += safe_sprintfA(&Cmd[ocmd], sizeof(Cmd) - ocmd, SET_JIS_FONT_NAME[0]);
WRITESPOOLBUF(pdevobj, Cmd, ocmd);
ocmd = 0;
}
//@Jun/23/2000 <-
// Set IBM extended character code block, and set region to 'USA'. (latter @Feb/22/99)
ocmd += safe_sprintfA(&Cmd[ocmd], sizeof(Cmd) - ocmd, SET_IBM_EXT_BLOCK);
// Disable formfeed when charcter position is around ymax-coordinate
ocmd += safe_sprintfA(&Cmd[ocmd], sizeof(Cmd) - ocmd, SET_PAGEMAX_VALID);
}
// Set color of Textmode RectangleFill black
ocmd += safe_sprintfA(&Cmd[ocmd], sizeof(Cmd) - ocmd, SET_TEXTRECT_BLACK);
pOEM->TextRectGray = 100; // @Jan/07/98
// Set 5mm offset at MF530,150,150e,160.
// (At these models, CMD_SET_BASEOFFSETs aren't called.)
if (TEST_GRP_OLDMF(pOEM->fModel) &&
!BITTEST32(pOEM->fGeneral2, EDGE2EDGE_PRINT) &&
!BITTEST32(pOEMExtra->fUiOption, ENABLE_TOMBO)) // add @Sep/15/98
{
pOEM->BaseOffset.x = pOEM->BaseOffset.y = 5; // mm
}
// Convert mm to dot here ((LONG)<-(DWORD) @Feb/02/99)
pOEM->BaseOffset.x = pOEM->BaseOffset.x * (LONG)(MASTERUNIT*10) /
(LONG)254 / (LONG)pOEM->nResoRatio;
pOEM->BaseOffset.y = pOEM->BaseOffset.y * (LONG)(MASTERUNIT*10) /
(LONG)254 / (LONG)pOEM->nResoRatio;
// Think about scaling (@May/18/98, (LONG)<-(DWORD) @Feb/02/99)
if (pOEM->Scale != 100 && pOEM->Scale != 0)
{
pOEM->BaseOffset.x = pOEM->BaseOffset.x * (LONG)100 / (LONG)pOEM->Scale;
pOEM->BaseOffset.y = pOEM->BaseOffset.y * (LONG)100 / (LONG)pOEM->Scale;
}
// Calculate offset for TOMBO.(BaseOffset will be changed.) @Sep/14/98
if (BITTEST32(pOEMExtra->fUiOption, ENABLE_TOMBO))
DrawTOMBO(pdevobj, INIT_TOMBO);
// Initialize current position
pOEM->TextCurPos.x = pOEM->Offset.x = pOEM->BaseOffset.x;
pOEM->TextCurPos.y = pOEM->Offset.y = pOEM->BaseOffset.y;
pOEM->TextCurPosRealY = pOEM->TextCurPos.y;
// SPEC of Unidrv5 & RPDL @Aug/14/98
// Unidrv5 doesn't order to set coordinate x,y to 0 after returning iRet=0,
// and RPDL doesn't reset coordinate y of SEND_BLOCK after initializing
// printer.
ocmd += safe_sprintfA(&Cmd[ocmd], sizeof(Cmd) - ocmd, ESC_XM_ABS, pOEM->TextCurPos.x);
ocmd += safe_sprintfA(&Cmd[ocmd], sizeof(Cmd) - ocmd, ESC_YM_ABS, pOEM->TextCurPos.y);
WRITESPOOLBUF(pdevobj, Cmd, ocmd);
break;
//
// Following cases are called at the end of a print-job (JOB_FINISH)
//
case CMD_ENDDOC_SP4II: // SP4mkII,5
// If Nin1 && document finished with remaining pages, output FF.
if (TEST_NIN1_MODE(pOEM->fGeneral1) && pOEM->Nin1RemainPage)
WRITESPOOLBUF(pdevobj, FF, sizeof(FF)-1);
// Set Spacing_Unit:(H)1/120,(V)1/48inch, Code:JIS, Scaling:100%
ocmd = safe_sprintfA(Cmd, sizeof(Cmd), ENDDOC1);
goto _ENDDOC_FINISH;
case CMD_ENDDOC_SP8: // SP8(7),8(7)mkII,80,10,10mkII
if (TEST_NIN1_MODE(pOEM->fGeneral1) && pOEM->Nin1RemainPage)
WRITESPOOLBUF(pdevobj, FF, sizeof(FF)-1);
// Set Spacing_Unit:(H)1/120,(V)1/48inch, Code:JIS, Scaling:100%
ocmd = safe_sprintfA(Cmd, sizeof(Cmd), ENDDOC1);
if (TEST_AFTER_SP10(pOEM->fModel)) // SP10,10mkII
{
// Set Graphics_Unit:1/240inch,Engine_Resolution:240dpi
ocmd += safe_sprintfA(&Cmd[ocmd], sizeof(Cmd) - ocmd, ENDDOC2_240DPI);
// Set Coordinate_Unit:1/720inch
ocmd += safe_sprintfA(&Cmd[ocmd], sizeof(Cmd) - ocmd, ENDDOC3);
}
// Set Options[duplex/2in1:off,reversed_output:off,sort/stack:off]
ocmd += safe_sprintfA(&Cmd[ocmd], sizeof(Cmd) - ocmd, ENDDOC4);
goto _ENDDOC_FINISH;
case CMD_ENDDOC_SP9: // SP9,10Pro,9II,10ProII,90
if (TEST_NIN1_MODE(pOEM->fGeneral1) && pOEM->Nin1RemainPage)
WRITESPOOLBUF(pdevobj, FF, sizeof(FF)-1);
ocmd = safe_sprintfA(Cmd, sizeof(Cmd), ENDDOC1);
// Set Graphics_Unit:1/240inch,Engine_Resolution:400dpi
ocmd += safe_sprintfA(&Cmd[ocmd], sizeof(Cmd) - ocmd, ENDDOC2_SP9);
ocmd += safe_sprintfA(&Cmd[ocmd], sizeof(Cmd) - ocmd, ENDDOC3);
ocmd += safe_sprintfA(&Cmd[ocmd], sizeof(Cmd) - ocmd, ENDDOC4);
goto _ENDDOC_FINISH;
case CMD_ENDDOC_400DPI_MODEL: // MF,MF-P,NX,IP-1
if (TEST_NIN1_MODE(pOEM->fGeneral1) && pOEM->Nin1RemainPage)
WRITESPOOLBUF(pdevobj, FF, sizeof(FF)-1);
ocmd = safe_sprintfA(Cmd, sizeof(Cmd), ENDDOC1);
if (TEST_AFTER_SP10(pOEM->fModel) || // MF-P,NX,MF200,250M,MF-p150,MF2200
BITTEST32(pOEM->fModel, GRP_MF150E)) // MF150e,160
{
// Set Graphics_Unit:1/400inch,Engine_Resolution:400dpi
ocmd += safe_sprintfA(&Cmd[ocmd], sizeof(Cmd) - ocmd, ENDDOC2_400DPI);
// Set Coordinate_Unit:1/720inch
ocmd += safe_sprintfA(&Cmd[ocmd], sizeof(Cmd) - ocmd, ENDDOC3);
}
// If staple mode, do not change sort/stack of Options.
if (pOEM->StapleType || pOEM->PunchType)
ocmd += safe_sprintfA(&Cmd[ocmd], sizeof(Cmd) - ocmd, ENDDOC4_FINISHER);
else
ocmd += safe_sprintfA(&Cmd[ocmd], sizeof(Cmd) - ocmd, ENDDOC4);
// goto _ENDDOC_FINISH;
_ENDDOC_FINISH:
// Reset smoothing/tonner_save_mode. (PRINTER SIDE ISSUE: We must not reset SP8.)
if (TEST_BUGFIX_RESET_SMOOTH(pOEM->fModel))
ocmd += safe_sprintfA(&Cmd[ocmd], sizeof(Cmd) - ocmd, SELECT_SMOOTHING2);
// Terminate fax at imagio FAX
if (BITTEST32(pOEMExtra->fUiOption, FAX_MODEL))
ocmd += safe_sprintfA(&Cmd[ocmd], sizeof(Cmd) - ocmd, ENDFAX);
// @Jun/29/2001 Add TEST_NEED_JOBDEF_CMD ->
// PRINTER SIDE ISSUE: RPDL (job define command is needed) GRP_NX900 @Jan/08/99
// if (BITTEST32(pOEM->fModel, GRP_NX900) &&
// (COLLATE_OFF != pOEM->CollateType || pOEM->StapleType || pOEM->PunchType))
if (BITTEST32(pOEM->fModel, GRP_NX900) || TEST_NEED_JOBDEF_CMD(pOEM->fModel))
// @Jun/29/2001 <-
{
ocmd += safe_sprintfA(&Cmd[ocmd], sizeof(Cmd) - ocmd, ENDDOC_JOBDEF_END);
}
// Initialize printer
ocmd += safe_sprintfA(&Cmd[ocmd], sizeof(Cmd) - ocmd, ENDDOC5);
WRITESPOOLBUF(pdevobj, Cmd, ocmd);
ocmd = 0;
// If binding margin is set,reset it to 0mm.
if (BITTEST32(pOEM->fGeneral1, DUPLEX_LEFTMARGIN_VALID))
ocmd += safe_sprintfA(&Cmd[ocmd], sizeof(Cmd) - ocmd, SET_LEFTMARGIN, 1);
else if (BITTEST32(pOEM->fGeneral1, DUPLEX_UPPERMARGIN_VALID))
ocmd += safe_sprintfA(&Cmd[ocmd], sizeof(Cmd) - ocmd, SET_UPPERMARGIN, 1);
WRITESPOOLBUF(pdevobj, Cmd, ocmd);
if(pOEM->pRPDLHeap2K) // @Sep/09/98
MemFree(pOEM->pRPDLHeap2K); // add ; @Aug/02/2000
#ifdef DOWNLOADFONT
if(pOEM->pDLFontGlyphInfo) // @Sep/09/98
MemFree(pOEM->pDLFontGlyphInfo);
#endif // DOWNLOADFONT
break;
default:
ERR((("Unknown callback ID = %d.\n"), dwCmdCbID));
}
return iRet;
} //*** OEMCommandCallback
BOOL APIENTRY bOEMSendFontCmd( // BOOL <- VOID @Mar/27/2002
PDEVOBJ pdevobj,
PUNIFONTOBJ pUFObj,
PFINVOCATION pFInv)
{
PGETINFO_STDVAR pSV;
DWORD adwStdVariable[STDVAR_BUFSIZE(3) / sizeof(DWORD)];
DWORD dwIn, dwOut;
PBYTE pubCmd;
BYTE Cmd[128];
PIFIMETRICS pIFI;
POEMPDEV pOEM = MINIDEV_DATA(pdevobj); // @Oct/06/98
DWORD dwNeeded, dwUFO_FontH, dwUFO_FontW;
DWORD dwUFO_FontMaxW; // MSKK Jul/23/98
LONG lTmp;
VERBOSE(("** bOEMSendFontCmd() entry. **\n"));
// MSKK 1/24/98 UnSelect ->
if (0 == pFInv->dwCount)
{
// No select command. pProbably some of the
// un-select case where no invokation command is
// available. (No explicit un-select.)
return FALSE; // BOOL <- VOID @Mar/27/2002
}
// MSKK 1/24/98 <-
pubCmd = pFInv->pubCommand;
pIFI = pUFObj->pIFIMetrics;
//
// Get standard variables.
//
pSV = (PGETINFO_STDVAR)adwStdVariable;
pSV->dwSize = STDVAR_BUFSIZE(3);
pSV->dwNumOfVariable = 3;
pSV->StdVar[0].dwStdVarID = FNT_INFO_FONTHEIGHT;
pSV->StdVar[1].dwStdVarID = FNT_INFO_FONTMAXWIDTH;
pSV->StdVar[2].dwStdVarID = FNT_INFO_FONTWIDTH;
if (!pUFObj->pfnGetInfo(pUFObj, UFO_GETINFO_STDVARIABLE, pSV,
pSV->dwSize, &dwNeeded))
{
ERR(("UFO_GETINFO_STDVARIABLE failed.\n"));
return FALSE; // BOOL <- VOID @Mar/27/2002
}
// VERBOSE((("FONTHEIGHT=%d\n"), pSV->StdVar[0].lStdVariable));
// VERBOSE((("FONTMAXWIDTH=%d\n"), pSV->StdVar[1].lStdVariable));
// VERBOSE((("FONTWIDTH=%d\n"), pSV->StdVar[2].lStdVariable));
dwUFO_FontH = (DWORD)pSV->StdVar[0].lStdVariable;
dwUFO_FontMaxW = (DWORD)pSV->StdVar[1].lStdVariable; // MSKK Jul/23/98
dwUFO_FontW = (DWORD)pSV->StdVar[2].lStdVariable;
dwOut = 0;
BITCLR_BARCODE(pOEM->fGeneral2);
for (dwIn = 0; dwIn < pFInv->dwCount;)
{
if (pubCmd[dwIn] == '#')
{
//** set width & height of scalable font for Japanese font **
if (pubCmd[dwIn+1] == 'A')
{
DWORD dwWidth, dwHeight;
// pOEM->FontH_DOT(unit:dot) for TextMode clipping
pOEM->FontH_DOT = MASTER_TO_SPACING_UNIT(pOEM, ((WORD)dwUFO_FontH)); // @Jan/30/98
// dwHeight(unit:cpt) for RPDL command parameter
dwHeight = dwUFO_FontH * (DWORD)(DEVICE_MASTER_UNIT / DRIVER_MASTER_UNIT);
if(IS_DBCSCHARSET(pIFI->jWinCharSet))
// MSKK Jul/23/98 ->
// dwWidth = dwUFO_FontW * 2;
dwWidth = dwUFO_FontMaxW;
// MSKK Jul/23/98 <-
else
dwWidth = dwUFO_FontW;
dwWidth *= DEVICE_MASTER_UNIT / DRIVER_MASTER_UNIT;
// VERBOSE(("[OEMSCALABLEFONT] w=%d,h=%d(%ddot)\n",
// (WORD)dwWidth, (WORD)dwHeight, pOEM->FontH_DOT));
// @Jun/25/98 ->
// If width is slightly different to height, we suppose they are same.
if ((lTmp = dwHeight - dwWidth) != 0)
{
if (lTmp < 0)
lTmp = -lTmp;
if ((DWORD)lTmp < dwHeight / 25) // 1/25 = 4%
dwWidth = dwHeight;
}
// @Jun/25/98 <-
// Use 10pt-size raster font at SP4mkII,5,8(7),8(7)mkII
if (TEST_GRP_240DPI(pOEM->fModel) && dwWidth == dwHeight &&
dwWidth >= NEAR10PT_MIN && dwWidth <= NEAR10PT_MAX)
{
dwWidth = dwHeight = 960; // unit:cpt(centi point)
}
pOEM->dwFontW_CPT = dwWidth;
pOEM->dwFontH_CPT = dwHeight;
// @Jan/29/99 ->
// If width equals to height, we emit height parameter only.
// (This is applied to after SP9II because we want to avoid testing
// at too old models.)
if (TEST_AFTER_SP9II(pOEM->fModel) && dwWidth == dwHeight)
dwOut += safe_sprintfA(&Cmd[dwOut], sizeof(Cmd) - dwOut, ",%ld", dwHeight);
else
// @Jan/29/99 <-
dwOut += safe_sprintfA(&Cmd[dwOut], sizeof(Cmd) - dwOut, "%ld,%ld", dwWidth, dwHeight);
dwIn += 2;
} // 'if 'A'' end
//** set width & height of scalable font for IBM ext font **
else if (pubCmd[dwIn+1] == 'B')
{
// @Jan/29/99 ->
if (TEST_AFTER_SP9II(pOEM->fModel) && pOEM->dwFontW_CPT == pOEM->dwFontH_CPT)
dwOut += safe_sprintfA(&Cmd[dwOut], sizeof(Cmd) - dwOut, ",%ld", pOEM->dwFontH_CPT);
else
// @Jan/29/99 <-
dwOut += safe_sprintfA(&Cmd[dwOut], sizeof(Cmd) - dwOut, "%ld,%ld",
pOEM->dwFontW_CPT, pOEM->dwFontH_CPT);
dwIn += 2;
} // 'if 'B'' end
// Set flag for barcode
else if (pubCmd[dwIn+1] == 'C')
{
switch (pubCmd[dwIn+2])
{
case '0': // JAN(STANDARD)
pOEM->nBarMaxLen = 13 + 1; goto _BARCODE_READY;
case '1': // JAN(SHORT)
pOEM->nBarMaxLen = 8 + 1; goto _BARCODE_READY;
// @Dec/07/99 FK#50 ->
case '7': // CUSTOMER
pOEM->nBarMaxLen = 20 + 1; goto _BARCODE_READY;
case '9': // UPC(A)
pOEM->nBarMaxLen = 12 + 1; goto _BARCODE_READY;
case 'A': // UPC(A)
pOEM->nBarMaxLen = 8 + 1; goto _BARCODE_READY;
case '8': // CODE128
// @Dec/07/99 FK#50 <-
case '2': // 2of5(INDUSTRIAL)
case '3': // 2of5(MATRIX)
case '4': // 2of5(ITF)
case '5': // CODE39
case '6': // NW-7
pOEM->nBarMaxLen = BARCODE_MAX;
_BARCODE_READY:
BITSET32(pOEM->fGeneral2, BARCODE_MODE_IN);
pOEM->dwBarRatioW = dwUFO_FontH * (DWORD)(DEVICE_MASTER_UNIT / DRIVER_MASTER_UNIT);
// @Dec/17/99 FK#50 ->
// pOEM->nBarType = pubCmd[dwIn+2] - '0';
if (pubCmd[dwIn+2] < 'A')
pOEM->nBarType = pubCmd[dwIn+2] - '0';
else
pOEM->nBarType = pubCmd[dwIn+2] - 'A' + 10;
// @Dec/17/99 FK#50 <-
pOEM->RPDLHeapCount = 0;
VERBOSE(("** BARCODE(1) ratio=%d **\n",pOEM->dwBarRatioW));
break;
default:
break;
}
dwIn += 3;
} // 'if 'C'' end
//** set width of scalable font **
else if (pubCmd[dwIn+1] == 'W')
{
// MSKK Jul/23/98 ->
// if (dwUFO_FontW > 0)
if (dwUFO_FontW > 0 || dwUFO_FontMaxW > 0)
// MSKK Jul/23/98 <-
{
DWORD dwWidth;
if(IS_DBCSCHARSET(pIFI->jWinCharSet))
// MSKK Jul/23/98 ->
// dwWidth = dwUFO_FontW * 2;
dwWidth = dwUFO_FontMaxW;
// MSKK Jul/23/98 <-
else
dwWidth = dwUFO_FontW;
pOEM->dwFontW_CPT = dwWidth * (DEVICE_MASTER_UNIT / DRIVER_MASTER_UNIT);
dwOut += safe_sprintfA(&Cmd[dwOut], sizeof(Cmd) - dwOut, "%ld", pOEM->dwFontW_CPT);
}
dwIn += 2;
} // 'if 'W'' end
//** set height of scalable font (include Japanese proportional font) **
else if (pubCmd[dwIn+1] == 'H')
{
pOEM->FontH_DOT = MASTER_TO_SPACING_UNIT(pOEM, ((WORD)dwUFO_FontH)); // @Jan/30/98
pOEM->dwFontH_CPT = dwUFO_FontH * (DWORD)(DEVICE_MASTER_UNIT / DRIVER_MASTER_UNIT);
dwOut += safe_sprintfA(&Cmd[dwOut], sizeof(Cmd) - dwOut, "%ld", pOEM->dwFontH_CPT);
dwIn += 2;
} // 'if 'H'' end
//** set font pitch (Horizontal-Motion-Index) **
else if (pubCmd[dwIn+1] == 'P')
{
SHORT nTmp1, nTmp2;
switch (pubCmd[dwIn+2]) // modify(add Arial,Century,etc)
{
case 'D': // DBCS (Japanese font ZENKAKU)
//95/NT4 nTmp1 = lpFont->dfAvgWidth * 2;
// MSKK 1/25/98 nTmp1 = ((SHORT)dwUFO_FontW + 1) / 2 * 2;
// MSKK Jul/23/98 nTmp1 = (SHORT)dwUFO_FontW * 2;
nTmp1 = (SHORT)dwUFO_FontMaxW;
nTmp1 = MASTER_TO_SPACING_UNIT(pOEM, nTmp1); // MSKK 1/25/98
VERBOSE(("** FontMaxW=%d dot **\n", nTmp1));
// @Aug/10/98 nTmp1 = (nTmp1 / 2 + 1) * 2; // bigger even @Jan/30/98
break;
case 'S': // SBCS (Japanese font HANKAKU)
// RPDL pitch setting command of HANKAKU is EFFECTIVE to SPACE.
// OBSOLETE @Mar/26/99 ->
//// @Jan/29/99 ->
// // RPDL pitch setting command of HANKAKU is not effective, so
// // do not emit this. (We may not delete this string in UFM.)
// if (dwOut >= 4 && Cmd[dwOut-4] == '\x1B' && Cmd[dwOut-3] == 'N')
// {
// dwIn += 3; // count up input '#PS'
// dwOut -= 4; // delete previous output '\x1BN\x1B\x1F'
// continue; // goto for loop-end
// }
// else // Maybe none comes here.
// @Jan/29/99 <-
// @Mar/26/99 <-
{
//95/NT4 nTmp1 = lpFont->dfAvgWidth;
// NSKK 1/25/98 nTmp1 = ((SHORT)dwUFO_FontW + 1) / 2;
nTmp1 = (SHORT)dwUFO_FontW;
nTmp1 = MASTER_TO_SPACING_UNIT(pOEM, nTmp1); // MSKK 1/25/98
VERBOSE(("** FontW=%d dot **\n", nTmp1));
// @Aug/10/98 nTmp1++; // 1dot bigger @Jan/30/98
}
break;
case '1': // SBCS (BoldFacePS)
case '2': // SBCS (Arial)
case '3': // SBCS (Century)
nTmp1 = (SHORT)(dwUFO_FontH * 3L / 10L); // * 0.3
nTmp1 = MASTER_TO_SPACING_UNIT(pOEM, nTmp1); // MSKK 1/25/98
break;
case '4': // SBCS (TimesNewRoman)
nTmp1 = (SHORT)(dwUFO_FontH * 27L / 100L); // * 0.27
nTmp1 = MASTER_TO_SPACING_UNIT(pOEM, nTmp1); // MSKK 1/25/98
break;
case '5': // SBCS (Symbol)
nTmp1 = (SHORT)dwUFO_FontH / 4; // * 0.25
nTmp1 = MASTER_TO_SPACING_UNIT(pOEM, nTmp1); // MSKK 1/25/98
break;
case '6': // SBCS (Wingding)
nTmp1 = (SHORT)dwUFO_FontH; // * 1
nTmp1 = MASTER_TO_SPACING_UNIT(pOEM, nTmp1); // MSKK 1/25/98
break;
case '7': // DBCS (Japanese proportional font HANKAKU)
nTmp1 = (SHORT)(dwUFO_FontH * 78L / 256L);
nTmp1 = MASTER_TO_SPACING_UNIT(pOEM, nTmp1); // MSKK 1/25/98
break;
// OBSOLETE @Mar/26/99 ->
// case '8': // DBCS (Japanese proportional font ZENKAKU)
// nTmp1 = (SHORT)(dwUFO_FontH * 170L / 256L);
// nTmp1 = MASTER_TO_SPACING_UNIT(pOEM, nTmp1); // MSKK 1/25/98
// break;
// @Mar/26/99 <-
default: // SBCS (Courier,LetterGothic,PrestigeElite)
//95/NT4 nTmp1 = lpFont->dfPixWidth;
nTmp1 = (SHORT)dwUFO_FontW;
nTmp1 = MASTER_TO_SPACING_UNIT(pOEM, nTmp1); // MSKK 1/25/98
dwIn --;
break;
}
if (nTmp1 >= 0x7E)
{
Cmd[dwOut++] = (BYTE)(((nTmp1 + 2) >> 7) + 0x81);
// PRINTER SIDE ISSUE: RPDL (We cannot set value of 0x7F & 0x80.)
if ((nTmp2 = ((nTmp1 + 2) & 0x7F) + 1) > 0x7E)
nTmp2 = 0x7E;
Cmd[dwOut++] = (BYTE)nTmp2;
}
else
{
Cmd[dwOut++] = (BYTE)(nTmp1 + 1);
}
dwIn += 3;
} // 'if 'P'' end
//** set Vertical-Motion-Index to draw combined font('^'+'A',etc). **
//** (Courier,LetterGothic,PrestigeElite,BoldFacePS) **
else if (pubCmd[dwIn+1] == 'V')
{
SHORT nTmp1, nTmp2;
// Set 1/3 height (adequate value to move vertically)
nTmp1 = (SHORT)dwUFO_FontH / 3;
nTmp1 = MASTER_TO_SPACING_UNIT(pOEM, nTmp1);
if (nTmp1 >= 0x7E)
{
Cmd[dwOut++] = (BYTE)(((nTmp1 + 2) >> 7) + 0x81);
// PRINTER SIDE ISSUE: RPDL (We cannot set value of 0x7F & 0x80.)
if ((nTmp2 = ((nTmp1 + 2) & 0x7F) + 1) > 0x7E)
nTmp2 = 0x7E;
Cmd[dwOut++] = (BYTE)nTmp2;
}
else
{
Cmd[dwOut++] = (BYTE)(nTmp1 + 1);
}
dwIn += 2;
} // 'if 'V'' end
} // 'if '#'' end
else
{
Cmd[dwOut++] = pubCmd[dwIn++];
}
} // 'for (dwIn = 0; dwIn < pFInv->dwCount;)' end
// VERBOSE(("dwOut = %d\n", dwOut)); // MSKK 1/24/98
WRITESPOOLBUF(pdevobj, Cmd, dwOut);
return TRUE; // BOOL <- VOID @Mar/27/2002
} //*** bOEMSendFontCmd
static BYTE IsDBCSLeadByteRPDL(BYTE Ch)
{
return ShiftJisRPDL[Ch];
}
static BYTE IsDifferentPRNFONT(BYTE Ch)
{
return VerticalFontCheck[Ch];
}
//---------------------------*[LOCAL] DrawTOMBO*-------------------------------
// Action:
// (a) INIT_TOMBO: calculate offset in printing. (BaseOffset will be changed)
// (b) DRAW_TOMBO: drawing TOMBO.
// Setp/14/98
//-----------------------------------------------------------------------------
static VOID DrawTOMBO(
PDEVOBJ pdevobj,
SHORT action)
{
POEMUD_EXTRADATA pOEMExtra = MINIPRIVATE_DM(pdevobj); // @Oct/06/98
POEMPDEV pOEM = MINIDEV_DATA(pdevobj); // @Oct/06/98
POINT P0;
POINT PaperSizeDoc, PaperSizeUse;
BYTE Cmd[256]; // build command here
INT ocmd = 0;
LONG lLen3, lLen10, lLen13, lWidth0_1, lSav, lTmp;
SHORT nPaperUse;
switch (pOEM->DocPaperID)
{
case RPDL_A3:
nPaperUse = RPDL_B3; break;
case RPDL_B4:
nPaperUse = RPDL_A3; break;
case RPDL_A4:
nPaperUse = RPDL_B4; break;
case RPDL_A5:
case RPDL_A6:
case RPDL_POSTCARD:
case RPDL_B5:
case RPDL_B6:
nPaperUse = RPDL_A4; break;
default:
return; // draw nothing
}
// Set acutual printed paper size & document paper size
PaperSizeUse = RPDLPageSizeE2E[nPaperUse];
PaperSizeDoc = RPDLPageSizeE2E[pOEM->DocPaperID];
// Orientation?
if (BITTEST32(pOEM->fGeneral1, ORIENT_LANDSCAPE))
{
lTmp = PaperSizeUse.x; // swap x-y
PaperSizeUse.x = PaperSizeUse.y;
PaperSizeUse.y = lTmp;
lTmp = PaperSizeDoc.x;
PaperSizeDoc.x = PaperSizeDoc.y;
PaperSizeDoc.y = lTmp;
}
// upper-left TOMBO
P0.x = (PaperSizeUse.x - PaperSizeDoc.x) / 2 / pOEM->nResoRatio;
P0.y = (PaperSizeUse.y - PaperSizeDoc.y) / 2 / pOEM->nResoRatio;
// If action is INIT_TOMBO, set BaseOffset and return
if (INIT_TOMBO == action)
{
LONG lUnprintable = BITTEST32(pOEM->fGeneral2, EDGE2EDGE_PRINT)?
0 : 240L / pOEM->nResoRatio; // 240masterunit at GPD
pOEM->BaseOffset.x += P0.x + lUnprintable;
pOEM->BaseOffset.y += P0.y + lUnprintable;
return; // exit
}
lSav = P0.x; // save left P0.x
lLen3 = 3L * (LONG)(MASTERUNIT*10) / 254L / pOEM->nResoRatio; // 3mm
lLen10 = 10L * (LONG)(MASTERUNIT*10) / 254L / pOEM->nResoRatio; // 10mm
lLen13 = 13L * (LONG)(MASTERUNIT*10) / 254L / pOEM->nResoRatio; // 13mm
lWidth0_1 = (LONG)MASTERUNIT / 254L / pOEM->nResoRatio; // 0.1mm
if (lWidth0_1 < 1)
lWidth0_1 = 1;
else if (lWidth0_1 >= 2)
lWidth0_1 = lWidth0_1 / 2 * 2 + 1; // make it odd
ocmd = safe_sprintfA(Cmd, sizeof(Cmd), ENTER_VECTOR); // enter VectorMode
ocmd += safe_sprintfA(&Cmd[ocmd], sizeof(Cmd) - ocmd, PEN_WIDTH, lWidth0_1);
ocmd += safe_sprintfA(&Cmd[ocmd], sizeof(Cmd) - ocmd, DRAW_TOMBO_POLYLINE, P0.x, P0.y - lLen13,
0, lLen10, -lLen13, 0);
ocmd += safe_sprintfA(&Cmd[ocmd], sizeof(Cmd) - ocmd, DRAW_TOMBO_POLYLINE, P0.x - lLen3, P0.y - lLen13,
0, lLen13, -lLen10, 0);
// upper-right TOMBO
// Add horizontal distance and adjustment (PaperSizeDoc.x:masterunit, AdjX:0.1mm unit)
P0.x += (PaperSizeDoc.x + (LONG)pOEMExtra->nUiTomboAdjX * (LONG)MASTERUNIT / 254L)
/ pOEM->nResoRatio;
ocmd += safe_sprintfA(&Cmd[ocmd], sizeof(Cmd) - ocmd, DRAW_TOMBO_POLYLINE, P0.x, P0.y - lLen13,
0, lLen10, lLen13, 0);
ocmd += safe_sprintfA(&Cmd[ocmd], sizeof(Cmd) - ocmd, DRAW_TOMBO_POLYLINE, P0.x + lLen3, P0.y - lLen13,
0, lLen13, lLen10, 0);
// lower-left TOMBO
lTmp = P0.x;
P0.x = lSav; // restore left P0.x
lSav = lTmp; // save right P0.x
// Add vertical distance and adjustment (PaperSizeDoc.y:masterunit, AdjY:0.1mm unit)
P0.y += (PaperSizeDoc.y + (LONG)pOEMExtra->nUiTomboAdjY * (LONG)MASTERUNIT / 254L)
/ pOEM->nResoRatio;
ocmd += safe_sprintfA(&Cmd[ocmd], sizeof(Cmd) - ocmd, DRAW_TOMBO_POLYLINE, P0.x, P0.y + lLen13,
0, -lLen10, -lLen13, 0);
ocmd += safe_sprintfA(&Cmd[ocmd], sizeof(Cmd) - ocmd, DRAW_TOMBO_POLYLINE, P0.x - lLen3, P0.y + lLen13,
0, -lLen13, -lLen10, 0);
// lower-right TOMBO
P0.x = lSav; // restore right P0.x
ocmd += safe_sprintfA(&Cmd[ocmd], sizeof(Cmd) - ocmd, DRAW_TOMBO_POLYLINE, P0.x, P0.y + lLen13,
0, -lLen10, lLen13, 0);
ocmd += safe_sprintfA(&Cmd[ocmd], sizeof(Cmd) - ocmd, DRAW_TOMBO_POLYLINE, P0.x + lLen3, P0.y + lLen13,
0, -lLen13, lLen10, 0);
ocmd += safe_sprintfA(&Cmd[ocmd], sizeof(Cmd) - ocmd, EXIT_VECTOR); // exit VectorMode
WRITESPOOLBUF(pdevobj, Cmd, ocmd);
} // *** DrawTOMBO
//---------------------------*[LOCAL] AssignIBMfont*---------------------------
// Action:
// (a) IBMFONT_ENABLE_ALL: assign IBM extended characters to block#1 where
// JIS1 characters used to be assigned.
// (b) IBMFONT_RESUME: resume (re-assign IBM extended characters to block#4.
// block#4 is insufficient for all 388 IBM characters.)
//-----------------------------------------------------------------------------
static VOID AssignIBMfont(
PDEVOBJ pdevobj,
SHORT rcID,
SHORT action)
{
BYTE Cmd[56]; // build command here
INT ocmd = 0;
WORD num;
WORD fHeightParamOnly; // @Jan/29/99
DWORD dwWidth, dwHeight;
POEMPDEV pOEM = MINIDEV_DATA(pdevobj); // @Oct/06/98
switch (rcID)
{
case MINCHO_1: case MINCHO_1+1: // horizontal font: vertical font:
case MINCHO_B1: case MINCHO_B1+1:
case MINCHO_E1: case MINCHO_E1+1:
case GOTHIC_B1: case GOTHIC_B1+1:
case GOTHIC_M1: case GOTHIC_M1+1:
case GOTHIC_E1: case GOTHIC_E1+1:
case MARUGOTHIC_B1: case MARUGOTHIC_B1+1:
case MARUGOTHIC_M1: case MARUGOTHIC_M1+1:
case MARUGOTHIC_L1: case MARUGOTHIC_L1+1:
case GYOSHO_1: case GYOSHO_1+1:
case KAISHO_1: case KAISHO_1+1:
case KYOKASHO_1: case KYOKASHO_1+1:
num = (rcID - MINCHO_1) / 2;
goto _SET_W_H;
case MINCHO_3: case MINCHO_3+1: // for NX-100
num = 0;
goto _SET_W_H;
case GOTHIC_B3: case GOTHIC_B3+1:
num = 3;
_SET_W_H:
dwWidth = pOEM->dwFontW_CPT;
dwHeight = pOEM->dwFontH_CPT;
break;
case MINCHO10_RAS: case MINCHO10_RAS+1:
num = 0; // same to MINCHO_1
dwWidth = dwHeight = 960; // unit:cpt(centi point)
break;
default:
return; // exit AssignIBMfont()
}
// @Jan/29/99 ->
// If width equals to height, we emit height parameter only.
// (This is applied to only NX-100 here.)
if (TEST_AFTER_SP9II(pOEM->fModel) && dwWidth == dwHeight)
fHeightParamOnly = TRUE;
else
fHeightParamOnly = FALSE;
// @Jan/29/99 <-
if (IBMFONT_RESUME == action)
{
// Resume JIS1 characters block where they used to be. (JIS1 -> block#1)
// @Jan/29/99 ->
if (fHeightParamOnly)
ocmd = safe_sprintfA(Cmd, sizeof(Cmd), SET_JIS_FONT_SCALE_H_ONLY, dwHeight);
else
// @Jan/29/99 <-
ocmd = safe_sprintfA(Cmd, sizeof(Cmd), SET_JIS_FONT_SCALE, dwWidth, dwHeight);
ocmd += safe_sprintfA(&Cmd[ocmd], sizeof(Cmd) - ocmd, SET_JIS_FONT_NAME[num]);
WRITESPOOLBUF(pdevobj, Cmd, ocmd);
}
// Assign IBM extended characters to block.
// @Jan/29/99 ->
if (fHeightParamOnly)
ocmd = safe_sprintfA(Cmd, sizeof(Cmd), SET_IBM_FONT_SCALE_H_ONLY, action, dwHeight);
else
// @Jan/29/99 <-
ocmd = safe_sprintfA(Cmd, sizeof(Cmd), SET_IBM_FONT_SCALE, action, dwWidth, dwHeight);
ocmd += safe_sprintfA(&Cmd[ocmd], sizeof(Cmd) - ocmd, SET_IBM_FONT_NAME[num]);
WRITESPOOLBUF(pdevobj, Cmd, ocmd);
return;
} //*** AssignIBMfont
//---------------------------*[LOCAL] SendFaxNum*------------------------------
// Action: send fax number
// (Use fax data file @Sep/30/98, Use private devmode @Oct/15/98)
//-----------------------------------------------------------------------------
static VOID SendFaxNum( // @Sep/17/98
PDEVOBJ pdevobj)
{
BYTE Cmd[256], PreNumBuf[4+16], NumBuf[32+4];
SHORT PreNumLen, cnt, SrcLen, NumLen;
INT ocmd;
LPSTR lpSrc, lpDst;
POEMUD_EXTRADATA pOEMExtra = MINIPRIVATE_DM(pdevobj);
FILEDATA FileData; // <-pFileData (formerly use MemAllocZ) @Mar/17/2000
FileData.fUiOption = 0;
// @Mar/01/2002 ->
// RWFileData(&FileData, pOEMExtra->SharedFileName, GENERIC_READ);
RWFileData(&FileData, pOEMExtra->SharedFileName, sizeof(pOEMExtra->SharedFileName), GENERIC_READ);
// @Mar/01/2002 <-
// If previous fax is finished and hold-options flag isn't valid,
// do nothing and return.
// This prevents unexpected fax until user pushes Apply button on the
// fax property sheet.
if (BITTEST32(FileData.fUiOption, PRINT_DONE) &&
!BITTEST32(pOEMExtra->fUiOption, HOLD_OPTIONS))
{
VERBOSE(("** SendFaxNum: Exit without doing anything. **\n"));
return;
}
// If not fax option ready, exit.
if (!BITTEST32(pOEMExtra->fUiOption, FAX_SEND) || pOEMExtra->FaxNumBuf[0] == 0)
{
return;
}
// Set data_type(1:image, 2:RPDL command), compression (1:MH, 3:MMR),
// simultaneous print avalilable, etc
ocmd = safe_sprintfA(Cmd, sizeof(Cmd), BEGINFAX_HEAD,
BITTEST32(pOEMExtra->fUiOption, FAX_RPDLCMD)? 2 : 1,
BITTEST32(pOEMExtra->fUiOption, FAX_MH)? 1 : 3,
BITTEST32(pOEMExtra->fUiOption, FAX_SIMULPRINT)? 2 : 1);
WRITESPOOLBUF(pdevobj, Cmd, ocmd);
// Copy fax channel & extra number to pre_number buffer
PreNumLen = (SHORT)safe_sprintfA(PreNumBuf, sizeof(PreNumBuf), BEGINFAX_CH, pOEMExtra->FaxCh + 1);
if (pOEMExtra->FaxExtNumBuf[0] != 0)
PreNumLen += (SHORT)safe_sprintfA(&PreNumBuf[PreNumLen], sizeof(PreNumBuf) - PreNumLen, BEGINFAX_EXTNUM, pOEMExtra->FaxExtNumBuf);
// Search each fax number (directly set number & addressbook set number)
lpSrc = pOEMExtra->FaxNumBuf; // fax number which is set directly
SrcLen = FAXBUFSIZE256-1; // FaxNumBuf limit = 255
lpDst = NumBuf;
NumLen = 0;
{
while (SrcLen-- > 0 && *lpSrc != 0)
{
// If character is DBCS, skip.
if (IsDBCSLeadByteRPDL(*lpSrc))
{
lpSrc++;
}
// If character is valid, input it to NumBuf.
else if (*lpSrc >= '0' && *lpSrc <= '9' || *lpSrc == '-' || *lpSrc == '#')
{
*lpDst++ = *lpSrc;
if (NumLen++ > 32) // limit of MF-P
{
return; // error exit
}
}
// If character is ',' , output fax number.
else if (*lpSrc == ',')
{
*lpDst = 0;
// Send fax number
if (NumLen > 0)
{
WRITESPOOLBUF(pdevobj, PreNumBuf, PreNumLen);
WRITESPOOLBUF(pdevobj, NumBuf, NumLen);
}
lpDst = NumBuf;
NumLen = 0;
}
lpSrc++;
} // 'while (SrcLen-- > 0 && *lpSrc != 0)' end
// Flush last fax number
if (NumLen > 0)
{
WRITESPOOLBUF(pdevobj, PreNumBuf, PreNumLen);
WRITESPOOLBUF(pdevobj, NumBuf, NumLen);
}
} // 'while (cnt-- > 0)' end
// Get tickcount for ID
cnt = (SHORT)(GetTickCount() / 1000L);
cnt = ABS(cnt);
// Input ID & resolution & send time, etc
if (BITTEST32(pOEMExtra->fUiOption, FAX_SETTIME) && pOEMExtra->FaxSendTime[0] != 0)
ocmd = safe_sprintfA(Cmd, sizeof(Cmd), BEGINFAX_TAIL, cnt, pOEMExtra->FaxReso + 1, 2, pOEMExtra->FaxSendTime);
else
ocmd = safe_sprintfA(Cmd, sizeof(Cmd), BEGINFAX_TAIL, cnt, pOEMExtra->FaxReso + 1, 1, "");
WRITESPOOLBUF(pdevobj, Cmd, ocmd);
// Set PRINT_DONE flag in the file @Oct/20/98
FileData.fUiOption = pOEMExtra->fUiOption;
BITSET32(FileData.fUiOption, PRINT_DONE);
// @Mar/01/2002 ->
// RWFileData(&FileData, pOEMExtra->SharedFileName, GENERIC_WRITE);
RWFileData(&FileData, pOEMExtra->SharedFileName, sizeof(pOEMExtra->SharedFileName), GENERIC_WRITE);
// @Mar/01/2002 <-
return;
} //*** SendFaxNum
#ifdef JISGTT
//-----------------------------*[LOCAL] jis2sjis*------------------------------
// Action: convert JIS code to SJIS code
//-----------------------------------------------------------------------------
static VOID jis2sjis( // @Oct/27/98
BYTE jis[],
BYTE sjis[])
{
BYTE h, l;
h = jis[0];
l = jis[1];
if (h == 0)
{
sjis[0] = l;
sjis[1] = 0;
return;
}
l += 0x1F;
if (h & 0x01)
h >>= 1;
else
{
h >>= 1;
l += 0x5E;
h--;
}
if (l >= 0x7F)
l++;
if (h < 0x2F)
h += 0x71;
else
h += 0xB1;
sjis[0] = h;
sjis[1] = l;
} //*** jis2sjis
#endif // JISGTT
BOOL APIENTRY bOEMOutputCharStr( // BOOL <- VOID @Mar/27/2002
PDEVOBJ pdevobj,
PUNIFONTOBJ pUFObj,
DWORD dwType,
DWORD dwCount,
PVOID pGlyph)
{
GETINFO_GLYPHSTRING GStr;
PBYTE aubBuff; // <-BYTE aubBuff[256] MSKK Aug/13/98
PTRANSDATA pTrans;
#ifdef DBG_OUTPUTCHARSTR
PWORD pwUnicode;
#endif // DBG_OUTPUTCHARSTR
DWORD dwI;
BYTE Cmd[128];
INT ocmd = 0; // INT<-SHORT @Feb/22/99
SHORT rcID;
WORD fVertFont = FALSE, fEuroFont = FALSE, fIBMFontSupport = FALSE;
WORD fEuroFontFullset = FALSE;
#ifdef JISGTT
WORD fJisCode = FALSE; // @Oct/27/98
#endif // JISGTT
LPSTR lpChar;
BYTE CharTmp1, CharTmp2;
POEMUD_EXTRADATA pOEMExtra = MINIPRIVATE_DM(pdevobj); // @Oct/06/98
POEMPDEV pOEM = MINIDEV_DATA(pdevobj); // @Oct/06/98
#ifdef DOWNLOADFONT
SHORT mov;
WORD wSerialNum; // short->DWORD @Jun/30/98, DWORD->WORD @Aug/21/98
LONG lFontID, lGlyphID; // @Aug/21/98
LPFONTPOS lpDLFont;
#endif // DOWNLOADFONT
DWORD dwNeeded;
WORD fMemAllocated; // @Sep/09/98
// VERBOSE(("** bOEMOutputCharStr() entry. **\n"));
if (BITTEST32(pOEM->fGeneral2, TEXTRECT_CONTINUE)) // add @Dec/11/97
{
BITCLR32(pOEM->fGeneral2, TEXTRECT_CONTINUE);
// If white-rect has been done before, set raster drawmode to OR. @Jan/20/99
if (!pOEM->TextRectGray)
{
if (BITTEST32(pOEM->fGeneral1, FONT_WHITETEXT_ON))
WRITESPOOLBUF(pdevobj, ESC_WHITETEXT_ON, sizeof(ESC_WHITETEXT_ON)-1);
else
WRITESPOOLBUF(pdevobj, ESC_WHITETEXT_OFF, sizeof(ESC_WHITETEXT_OFF)-1);
}
}
//** flush Move_X,Y command saved at OEMCommandCallback
if (BITTEST32(pOEM->fGeneral1, YM_ABS_GONNAOUT))
{
BITCLR32(pOEM->fGeneral1, YM_ABS_GONNAOUT);
// Output Move_Y command here.
ocmd = safe_sprintfA(Cmd, sizeof(Cmd), ESC_YM_ABS, pOEM->TextCurPos.y);
WRITESPOOLBUF(pdevobj, Cmd, ocmd);
}
if (BITTEST32(pOEM->fGeneral1, XM_ABS_GONNAOUT))
{
BITCLR32(pOEM->fGeneral1, XM_ABS_GONNAOUT);
// Output Move_X command here.
ocmd = safe_sprintfA(Cmd, sizeof(Cmd), ESC_XM_ABS, pOEM->TextCurPos.x);
WRITESPOOLBUF(pdevobj, Cmd, ocmd);
}
// VERBOSE(("dwType = %d\n", dwType)); // MKSKK 1/24/98
switch (dwType)
{
case TYPE_GLYPHHANDLE: // device font
// #333653: Change I/F for GETINFO_GLYPHSTRING // MSKK 5/17/99 {
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 the size of buffer for pGlyphOut.
if (pUFObj->pfnGetInfo(pUFObj, UFO_GETINFO_GLYPHSTRING, &GStr,
GStr.dwSize, &dwNeeded) || !GStr.dwGlyphOutSize)
{
ERR(("UNIFONTOBJ_GetInfo:UFO_GETINFO_GLYPHSTRING failed.\n"));
return FALSE; // BOOL <- VOID @Mar/27/2002
}
if (pOEM->pRPDLHeap2K && GStr.dwGlyphOutSize <= HEAPSIZE2K)
{
aubBuff = pOEM->pRPDLHeap2K;
fMemAllocated = FALSE;
}
else
{
if(!(aubBuff = (PBYTE)MemAllocZ(GStr.dwGlyphOutSize)))
{
ERR(("aubBuff memory allocation failed.\n"));
return FALSE; // BOOL <- VOID @Mar/27/2002
}
fMemAllocated = TRUE;
}
// } MSKK 5/17/99
#ifdef DBG_OUTPUTCHARSTR
GStr.dwSize = sizeof(GETINFO_GLYPHSTRING);
GStr.dwCount = dwCount;
GStr.dwTypeIn = TYPE_GLYPHHANDLE;
GStr.pGlyphIn = pGlyph;
GStr.dwTypeOut = TYPE_UNICODE;
GStr.pGlyphOut = aubBuff;
if (!pUFObj->pfnGetInfo(pUFObj, UFO_GETINFO_GLYPHSTRING, &GStr,
GStr.dwSize, &dwNeeded))
{
ERR(("UNIFONTOBJ_GetInfo:UFO_GETINFO_GLYPHSTRING failed.\n"));
// fix memory leak by yasuho Nov/20/2002 ->
if(fMemAllocated)
MemFree(aubBuff);
// Nov/20/2002 <-
return FALSE; // BOOL <- VOID @Mar/27/2002
}
pwUnicode = (PWORD)aubBuff;
for (dwI = 0; dwI < dwCount; dwI ++)
{
VERBOSE((("Unicode[%d] = %x\n"), dwI, pwUnicode[dwI]));
}
#endif // DBG_OUTPUTCHARSTR
#ifdef DOWNLOADFONT
// If moving value of download font remain
if (pOEM->nCharPosMoveX)
{
// Flush moving value of pre-printed download font.
if (pOEM->nCharPosMoveX > 0)
ocmd = safe_sprintfA(Cmd, sizeof(Cmd), ESC_XM_REL, pOEM->nCharPosMoveX);
else
ocmd = safe_sprintfA(Cmd, sizeof(Cmd), ESC_XM_RELLEFT, -pOEM->nCharPosMoveX);
WRITESPOOLBUF(pdevobj, Cmd, ocmd);
// Clear moving value
pOEM->nCharPosMoveX = 0;
} // 'if (nCharPosMoveX)' end
#endif // DOWNLOADFONT
//
// Call the Unidriver service routine to convert
// glyph-handles into the character code data.
//
GStr.dwSize = sizeof (GETINFO_GLYPHSTRING);
GStr.dwCount = dwCount;
GStr.dwTypeIn = TYPE_GLYPHHANDLE;
GStr.pGlyphIn = pGlyph;
GStr.dwTypeOut = TYPE_TRANSDATA;
GStr.pGlyphOut = aubBuff;
if (!pUFObj->pfnGetInfo(pUFObj, UFO_GETINFO_GLYPHSTRING, &GStr,
GStr.dwSize, &dwNeeded))
{
ERR(("UNIFONTOBJ_GetInfo:UFO_GETINFO_GLYPHSTRING failed.\n"));
// fix memory leak by yasuho Nov/20/2002 ->
if(fMemAllocated)
MemFree(aubBuff);
// Nov/20/2002 <-
return FALSE; // BOOL <- VOID @Mar/27/2002
}
pTrans = (PTRANSDATA)aubBuff;
//** Draw barcode **
// fix bug with Excel @Nov/24/98
if (BITTEST32(pOEM->fGeneral2, BARCODE_MODE_IN))
{
WORD unit1, unit2, offset_y;
WORD fCheckdigitCapable, fSetBarWidth, fJANDecrease1Char;
WORD fCode128; // @Feb/08/2000
LPSTR lpDst, lpCmd;
PTRANSDATA pTransTmp; // @Nov/24/98
WORD wLen, wTmp;
ocmd = 0;
// Check start character
wTmp = wLen = (WORD)dwCount;
pTransTmp = pTrans;
while (wTmp-- > 0)
{
if (pTransTmp->uCode.ubCode == '[')
{
// barcode character is valid from now
BITSET32(pOEM->fGeneral2, BARCODE_DATA_VALID);
BITCLR32(pOEM->fGeneral2, BARCODE_CHECKDIGIT_ON);
BITCLR32(pOEM->fGeneral2, BARCODE_ROT90);
BITCLR32(pOEM->fGeneral2, BARCODE_ROT270);
pOEM->RPDLHeapCount = 0;
wLen = wTmp;
pTrans = pTransTmp+1;
#ifdef DEBUG
for (wTmp = 0; wTmp < BARCODE_MAX; wTmp++)
pOEM->RPDLHeap64[wTmp] = 0;
#endif // DEBUG
break;
}
pTransTmp++;
}
// Check barcode character length
VERBOSE(("** BARCODE(2.2) len=%d **\n",wLen));
fJANDecrease1Char = FALSE;
if (wLen > (wTmp = pOEM->nBarMaxLen - pOEM->RPDLHeapCount))
{
wLen = wTmp;
BITSET32(pOEM->fGeneral2, BARCODE_FINISH);
VERBOSE(("** BARCODE(3) limit len=%d(last=%c) **\n", wLen,
(pTrans+wLen-1)->uCode.ubCode));
// Decrease RPDLHeapCount later at JAN
if (pOEM->nBarType == BAR_TYPE_JAN_STD || pOEM->nBarType == BAR_TYPE_JAN_SHORT)
fJANDecrease1Char = TRUE;
}
// Copy barcode characters to RPDLHeap64 (temporary buffer)
lpDst = &pOEM->RPDLHeap64[pOEM->RPDLHeapCount];
fCheckdigitCapable = TEST_AFTER_SP8(pOEM->fModel)? TRUE : FALSE;
while (wLen-- > 0)
{
// Check checkdigit-on-flag-character(?) in pTrans->uCode.ubCode
if (pTrans->uCode.ubCode == '?' && fCheckdigitCapable)
{
BITSET32(pOEM->fGeneral2, BARCODE_CHECKDIGIT_ON);
pTrans++;
continue;
}
// Check end character
if (pTrans->uCode.ubCode == ']')
{
VERBOSE(("** BARCODE(4) terminator **\n"));
BITSET32(pOEM->fGeneral2, BARCODE_FINISH);
break;
}
*lpDst++ = pTrans->uCode.ubCode;
pTrans++;
pOEM->RPDLHeapCount++;
}
VERBOSE(("** BARCODE(5) copy-end BarNum=%d **\n", pOEM->RPDLHeapCount));
VERBOSE((" [%s]\n",pOEM->RPDLHeap64));
VERBOSE((" CHK = %d\n", BITTEST32(pOEM->fGeneral2, BARCODE_CHECKDIGIT_ON)));
// Finish
if (BITTEST32(pOEM->fGeneral2, BARCODE_DATA_VALID) &&
BITTEST32(pOEM->fGeneral2, BARCODE_FINISH))
{
VERBOSE(("** BARCODE(6) finish [%s] **\n", pOEM->RPDLHeap64));
// 1 barcode has been completed here
BITCLR32(pOEM->fGeneral2, BARCODE_DATA_VALID);
BITCLR32(pOEM->fGeneral2, BARCODE_FINISH);
ocmd = safe_sprintfA(Cmd, sizeof(Cmd), ENTER_VECTOR); // enter VectorMode
// Add checkdigit
if (BITTEST32(pOEM->fGeneral2, BARCODE_CHECKDIGIT_ON))
{
ocmd += safe_sprintfA(&Cmd[ocmd], sizeof(Cmd) - ocmd, BAR_CHECKDIGIT);
}
// Check barcode-height
if (pOEMExtra->UiBarHeight == 0)
{
pOEMExtra->UiBarHeight = BAR_H_DEFAULT; // default (=10mm)
}
else if (pOEMExtra->UiBarHeight != BAR_H_DEFAULT)
{
// Set barcode-height (convert unit from mm to dot) (SISHAGONYU)
unit1 = (WORD)(((DWORD)pOEMExtra->UiBarHeight * (DWORD)(MASTERUNIT*10)
/ (DWORD)pOEM->nResoRatio + (DWORD)(254/2)) / (DWORD)254);
VERBOSE(("** BARCODE(7) set height %d **\n", unit1));
ocmd += safe_sprintfA(&Cmd[ocmd], sizeof(Cmd) - ocmd, BAR_H_SET, unit1);
}
if (BITTEST32(pOEMExtra->fUiOption, DISABLE_BAR_SUBFONT))
{
// Disable printing font under barcode
ocmd += safe_sprintfA(&Cmd[ocmd], sizeof(Cmd) - ocmd, BAR_NOFONT[pOEM->nBarType]);
// Set guard-bar-height of JAN
if ((pOEM->nBarType == BAR_TYPE_JAN_STD || pOEM->nBarType == BAR_TYPE_JAN_SHORT) &&
!TEST_AFTER_SP8(pOEM->fModel))
{
offset_y = 2;
}
else // no guard-bar
{
offset_y = 0;
}
}
else
{
offset_y = 3; // font-height = 3mm
}
// @Dec/8/99 FK#50 ->
if (pOEM->nBarType == BAR_TYPE_CUSTOMER)
{
// calculate vertical offset (barcode-height)
offset_y = (WORD)(((DWORD)(BAR_H_CUSTOMER) // 36 x 0.1mm
* (DWORD)MASTERUNIT
/ (DWORD)pOEM->nResoRatio + (DWORD)(254/2)) / (DWORD)254);
}
else
{
// @Dec/8/99 FK#50 <-
// Calculate vertical offset (barcode-height + font-height)
offset_y = (WORD)(((DWORD)(pOEMExtra->UiBarHeight + offset_y)
* (DWORD)(MASTERUNIT*10)
/ (DWORD)pOEM->nResoRatio + (DWORD)(254/2)) / (DWORD)254);
// @Dec/8/99 FK#50 ->
}
// @Dec/8/99 FK#50 <-
// Check vertical-flag-character('@') in RPDLHeap64
VERBOSE(("** BARCODE(7-1) vertical check len=%d(%c..%c) **\n",
pOEM->RPDLHeapCount, pOEM->RPDLHeap64[0],
pOEM->RPDLHeap64[pOEM->RPDLHeapCount-1] ));
// If characters are "@...", vertical(ROT270) barcode
if (pOEM->RPDLHeap64[0] == '@')
{
VERBOSE(("** BARCODE(7-2) vertical(ROT270) **\n"));
BITSET32(pOEM->fGeneral2, BARCODE_ROT270);
pOEM->RPDLHeapCount--;
}
// If characters are "...@", vertical(ROT90) barcode
else if (pOEM->RPDLHeap64[pOEM->RPDLHeapCount-1] == '@')
{
VERBOSE(("** BARCODE(7-2) vertical(ROT90) **\n"));
BITSET32(pOEM->fGeneral2, BARCODE_ROT90);
pOEM->RPDLHeapCount--;
}
// 1 charcter margin for '@' at JAN, we decrease here.
else if (fJANDecrease1Char)
{
pOEM->RPDLHeapCount--;
}
// Set barcode draw position
if (BITTEST32(pOEM->fGeneral2, BARCODE_ROT270) &&
!TEST_NIN1_MODE(pOEM->fGeneral1))
{
ocmd += safe_sprintfA(&Cmd[ocmd], sizeof(Cmd) - ocmd, BAR_ROT270);
ocmd += safe_sprintfA(&Cmd[ocmd], sizeof(Cmd) - ocmd, MOVE_ABSOLUTE,
pOEM->TextCurPos.y,
pOEM->PageMax.x - pOEM->TextCurPos.x - offset_y);
}
else if (BITTEST32(pOEM->fGeneral2, BARCODE_ROT90) &&
!TEST_4IN1_MODE(pOEM->fGeneral1))
{
ocmd += safe_sprintfA(&Cmd[ocmd], sizeof(Cmd) - ocmd, BAR_ROT90);
ocmd += safe_sprintfA(&Cmd[ocmd], sizeof(Cmd) - ocmd, MOVE_ABSOLUTE,
pOEM->PageMax.y - pOEM->TextCurPos.y,
pOEM->TextCurPos.x - offset_y);
}
else
{
ocmd += safe_sprintfA(&Cmd[ocmd], sizeof(Cmd) - ocmd, MOVE_ABSOLUTE,
pOEM->TextCurPos.x,
pOEM->TextCurPos.y - offset_y);
}
// Check whether setting barcode-width or not.
// (Scaling is valid when 5pt<=fontsize<9pt or fontsize>11pt)
if ((pOEM->dwBarRatioW >= BAR_W_MIN_5PT &&
pOEM->dwBarRatioW < NEAR10PT_MIN) ||
pOEM->dwBarRatioW > NEAR10PT_MAX)
{
fSetBarWidth = TRUE;
}
else
{
fSetBarWidth = FALSE;
}
fCode128 = 0; // @Feb/08/2000
switch (pOEM->nBarType)
{
case BAR_TYPE_JAN_STD: // 0:JAN(STANDARD)
case BAR_TYPE_JAN_SHORT: // 1:JAN(SHORT)
case BAR_TYPE_UPC_A: // 9:UPC(A) @Dec/17/99 FK#50
case BAR_TYPE_UPC_E: // 10:UPC(E) @Dec/17/99 FK#50
// Set barcode-width
if (fSetBarWidth)
{
// Convert unit from 1/1000mm_unit*1/1000 to dot (SISHAGONYU)
unit1 = (WORD)(((DWORD)BAR_UNIT_JAN * pOEM->dwBarRatioW
/ (DWORD)pOEM->nResoRatio / (DWORD)100
* (DWORD)MASTERUNIT / (DWORD)254 + (DWORD)(1000/2))
/ (DWORD)1000);
VERBOSE(("** BARCODE(8) set unit %d **\n", unit1));
ocmd += safe_sprintfA(&Cmd[ocmd], sizeof(Cmd) - ocmd, BAR_W_SET_JAN, unit1);
}
// Output barcode command
ocmd += safe_sprintfA(&Cmd[ocmd], sizeof(Cmd) - ocmd, BAR_TYPE[pOEM->nBarType]);
break;
case BAR_TYPE_2OF5IND: // 2:2of5(INDUSTRIAL)
case BAR_TYPE_2OF5MTX: // 3:2of5(MATRIX)
case BAR_TYPE_2OF5ITF: // 4:2of5(ITF)
lpCmd = BAR_W_SET_2OF5;
goto _BARCODE_CMD_OUT1;
case BAR_TYPE_CODE39: // 5:CODE39
lpCmd = BAR_W_SET_C39;
// @Dec/17/99 FK#50 ->
goto _BARCODE_CMD_OUT1;
case BAR_TYPE_CODE128: // 8:CODE128
lpCmd = BAR_W_SET_C39;
fCode128 = 1;
// @Dec/17/99 FK#50 <-
_BARCODE_CMD_OUT1:
// Set standard size of module unit (1/1000mm_unit)
unit1 = BAR_UNIT1_2OF5;
unit2 = BAR_UNIT2_2OF5;
goto _BARCODE_CMD_OUT2;
case BAR_TYPE_NW7: // 6:NW-7
lpCmd = BAR_W_SET_NW7;
// Set standard size of module unit
unit1 = BAR_UNIT1_NW7;
unit2 = BAR_UNIT2_NW7;
_BARCODE_CMD_OUT2:
// Set barcode-width
if (fSetBarWidth)
{
// Convert unit from 1/1000mm_unit*1/1000 to dot (SISHAGONYU)
unit1 = (WORD)(((DWORD)unit1 * pOEM->dwBarRatioW
/ (DWORD)pOEM->nResoRatio / (DWORD)100
* (DWORD)MASTERUNIT / (DWORD)254 + (DWORD)(1000/2))
/ (DWORD)1000);
unit2 = (WORD)(((DWORD)unit2 * pOEM->dwBarRatioW
/ (DWORD)pOEM->nResoRatio / (DWORD)100
* (DWORD)MASTERUNIT / (DWORD)254 + (DWORD)(1000/2))
/ (DWORD)1000);
VERBOSE(("** BARCODE(8) set unit %d,%d **\n", unit1,unit2));
ocmd += safe_sprintfA(&Cmd[ocmd], sizeof(Cmd) - ocmd, lpCmd);
ocmd += safe_sprintfA(&Cmd[ocmd], sizeof(Cmd) - ocmd, BAR_W_PARAMS, unit1, unit1,
unit2, unit2, unit1);
}
// Output barcode command(operand) & character#
// @Dec/17/99 FK#50 ->
// ocmd += safe_sprintfA(&Cmd[ocmd], sizeof(Cmd) - ocmd, BAR_TYPE[pOEM->nBarType],
// pOEM->RPDLHeapCount);
ocmd += safe_sprintfA(&Cmd[ocmd], sizeof(Cmd) - ocmd, BAR_TYPE[pOEM->nBarType],
pOEM->RPDLHeapCount + fCode128);
// @Dec/17/99 FK#50 <-
break;
// @Dec/07/99 FK#50 ->
case BAR_TYPE_CUSTOMER: // 7:CUSTOMER
lpCmd = BAR_W_SET_CUST;
ocmd += safe_sprintfA(&Cmd[ocmd], sizeof(Cmd) - ocmd, lpCmd);
unit1 = (WORD)(((pOEM->dwBarRatioW / 10) + 4) / 5) * 5 ;
if ((unit1 >= 80) && (unit1 <= 115))
{
ocmd += safe_sprintfA(&Cmd[ocmd], sizeof(Cmd) - ocmd, "%d", unit1);
}
// output barcode command(operand) & character#
ocmd += safe_sprintfA(&Cmd[ocmd], sizeof(Cmd) - ocmd, BAR_TYPE[pOEM->nBarType],
pOEM->RPDLHeapCount);
break;
// @Dec/07/99 FK#50 <-
default:
break;
}
WRITESPOOLBUF(pdevobj, Cmd, ocmd);
// @Dec/17/99 FK#50 ->
// Code128 data format ",xx,xx,..."
if (pOEM->nBarType == BAR_TYPE_CODE128)
{
INT len, cnt;
BYTE Code128Buf[8];
LPSTR lpTemp;
lpTemp = pOEM->RPDLHeap64;
if (BITTEST32(pOEM->fGeneral2, BARCODE_ROT270))
lpTemp++;
// send start char
len = safe_sprintfA(Code128Buf, sizeof(Code128Buf),",%d",(BYTE)BAR_CODE128_START);
WRITESPOOLBUF(pdevobj, Code128Buf, len);
for (cnt = 0; cnt < (int)pOEM->RPDLHeapCount; cnt++)
{
len = safe_sprintfA(Code128Buf, sizeof(Code128Buf),",%d",(BYTE)(lpTemp[cnt]-32));
WRITESPOOLBUF(pdevobj, Code128Buf, len);
}
}
else
{
// @Dec/17/99 FK#50 <-
// Output barcode characters
if (BITTEST32(pOEM->fGeneral2, BARCODE_ROT270)) // @Oct/22/97
WRITESPOOLBUF(pdevobj, pOEM->RPDLHeap64+1, pOEM->RPDLHeapCount);
else
WRITESPOOLBUF(pdevobj, pOEM->RPDLHeap64, pOEM->RPDLHeapCount);
// @Dec/17/99 FK#50 ->
}
// @Dec/17/99 FK#50 <-
pOEM->RPDLHeapCount = 0;
// We add ';' for safe finish in case of insufficient character at JAN.
ocmd = safe_sprintfA(Cmd, sizeof(Cmd), TERMINATOR);
ocmd += safe_sprintfA(&Cmd[ocmd], sizeof(Cmd) - ocmd, EXIT_VECTOR); // exit VectorMode
WRITESPOOLBUF(pdevobj, Cmd, ocmd);
} // 'if BARCODE_DATA_VALID && BARCODE_FINISH' end
if(fMemAllocated)
MemFree(aubBuff);
return TRUE; // BOOL <- VOID @Mar/27/2002
}
//** Draw barcode END **
//** Draw device font **
BITCLR32(pOEM->fGeneral1, FONT_VERTICAL_ON);
rcID = (SHORT)pUFObj->ulFontID;
if (rcID >= JPN_FNT_FIRST && rcID <= JPN_FNT_LAST)
{
if (TEST_VERTICALFONT(rcID))
{
fVertFont = TRUE; // vertical font
BITSET32(pOEM->fGeneral1, FONT_VERTICAL_ON);
}
// IBM ext char(SJIS) supported from SP9II
if (rcID >= AFTER_SP9II_FNT_FIRST)
fIBMFontSupport = TRUE;
// @Oct/27/98 ->
#ifdef JISGTT
// Current UFM of PMincho & PGothic declare JIS code set.
if (rcID >= JPN_MSPFNT_FIRST)
fJisCode = TRUE;
#endif // JISGTT
// @Oct/27/98 <-
}
else if (rcID >= EURO_FNT_FIRST && rcID <= EURO_FNT_LAST)
{
fEuroFont = TRUE; // European font(Courier,BoldFacePS,etc).
// Fullset(0x20-0xFF) fonts(Arial,Century,TimesNewRoman,etc) are supported
// from NX-110
if (rcID >= EURO_MSFNT_FIRST)
fEuroFontFullset = TRUE;
}
for (dwI = 0; dwI < dwCount; dwI ++, pTrans ++) // increment pTrans MSKK 98/3/16
{
switch (pTrans->ubType & MTYPE_FORMAT_MASK)
{
case MTYPE_DIRECT: // SBCS (European font & Japanese font HANKAkU)
// VERBOSE((("TYPE_TRANSDATA:ubCode:0x%x\n"), pTrans->uCode.ubCode));
lpChar = &pTrans->uCode.ubCode;
CharTmp1 = *lpChar;
if (fEuroFont) //** European font **
{
// ** print 1st SBCS font(0x20-0x7F) **
if (CharTmp1 < 0x80)
{
// PRINTER SIDE ISSUE: RPDL
// take care of device font bug
if (rcID == SYMBOL && CharTmp1 == 0x60) // "radical extention"
{
WRITESPOOLBUF(pdevobj, DOUBLE_SPACE, sizeof(DOUBLE_SPACE)-1);
WRITESPOOLBUF(pdevobj, &CharTmp1, 1);
WRITESPOOLBUF(pdevobj, DOUBLE_BS, sizeof(DOUBLE_BS)-1);
}
else
{
WRITESPOOLBUF(pdevobj, &CharTmp1, 1);
}
continue; // goto for-loop end
}
// ** print 2nd SBCS font(0x80-0xFF) **
// If full-set(0x20-0xFF) font
if (fEuroFontFullset)
{
// If same to DBCS 1st byte
if (IsDBCSLeadByteRPDL(CharTmp1))
WRITESPOOLBUF(pdevobj, ESC_CTRLCODE, sizeof(ESC_CTRLCODE)-1);
WRITESPOOLBUF(pdevobj, &CharTmp1, 1);
continue; // goto for-loop end
}
// If not full-set font
switch (CharTmp1)
{
case 0x82:
CharTmp1 = ','; goto _WRITE1BYTE;
case 0x88:
CharTmp1 = '^'; goto _WRITE1BYTE;
case 0x8B:
CharTmp1 = '<'; goto _WRITE1BYTE;
case 0x9B:
CharTmp1 = '>'; goto _WRITE1BYTE;
case 0x91: // single quatation
case 0x92:
CharTmp1 = 0x27; goto _WRITE1BYTE;
case 0x93: // double quatation
case 0x94:
CharTmp1 = 0x22; goto _WRITE1BYTE;
case 0x96:
case 0x97:
CharTmp1 = '-'; goto _WRITE1BYTE;
case 0x98:
CharTmp1 = '~'; goto _WRITE1BYTE;
case 0xA6:
CharTmp1 = '|'; goto _WRITE1BYTE;
case 0xAD:
CharTmp1 = '-'; goto _WRITE1BYTE;
case 0xB8:
CharTmp1 = ','; goto _WRITE1BYTE;
case 0xD7:
CharTmp1 = 'x'; goto _WRITE1BYTE;
case 0x83:
CharTmp1 = 0xBF; goto _WRITE1BYTE;
case 0x86:
CharTmp1 = 0xA8; goto _WRITE1BYTE;
case 0x99:
CharTmp1 = 0xA9; goto _WRITE1BYTE;
case 0xE7:
CharTmp1 = 0xA2; goto _WRITE1BYTE;
case 0xE8:
CharTmp1 = 0xBD; goto _WRITE1BYTE;
case 0xE9:
CharTmp1 = 0xBB; goto _WRITE1BYTE;
case 0xF9:
CharTmp1 = 0xBC; goto _WRITE1BYTE;
case 0xFC:
CharTmp1 = 0xFD; goto _WRITE1BYTE;
case 0xA0:
case 0xA3:
case 0xA4:
goto _WRITE1BYTE;
case 0xA2:
CharTmp1 = 0xDE; goto _WRITE1BYTE;
case 0xA5: //YEN mark
CharTmp1 = 0xCC; goto _WRITE1BYTE;
case 0xA7:
CharTmp1 = 0xC0; goto _WRITE1BYTE;
case 0xA8:
CharTmp1 = 0xBE; goto _WRITE1BYTE;
case 0xA9:
CharTmp1 = 0xAB; goto _WRITE1BYTE;
case 0xAE:
CharTmp1 = 0xAA; goto _WRITE1BYTE;
case 0xAF:
CharTmp1 = 0xB0; goto _WRITE1BYTE;
case 0xB0:
case 0xBA:
CharTmp1 = 0xA6; goto _WRITE1BYTE;
case 0xB4:
CharTmp1 = 0xA7; goto _WRITE1BYTE;
case 0xB5:
CharTmp1 = 0xA5; goto _WRITE1BYTE;
case 0xB6:
CharTmp1 = 0xAF; goto _WRITE1BYTE;
case 0xBC:
CharTmp1 = 0xAC; goto _WRITE1BYTE;
case 0xBD:
CharTmp1 = 0xAE; goto _WRITE1BYTE;
case 0xBE:
CharTmp1 = 0xAD; goto _WRITE1BYTE;
case 0xC4:
CharTmp1 = 0xDB; goto _WRITE1BYTE;
case 0xC5:
CharTmp1 = 0xD6; goto _WRITE1BYTE;
case 0xC9:
CharTmp1 = 0xB8; goto _WRITE1BYTE;
case 0xD6:
CharTmp1 = 0xDC; goto _WRITE1BYTE;
case 0xDC:
CharTmp1 = 0xDD; goto _WRITE1BYTE;
case 0xDF:
CharTmp1 = 0xFE; goto _WRITE1BYTE;
_WRITE1BYTE:
WRITESPOOLBUF(pdevobj, &CharTmp1, 1);
break;
// Combine 2 fonts, because next fonts do not exist in device font
case 0x87:
CharTmp1 = '='; CharTmp2 = '|'; goto _COMBINEDFONT;
case 0xD0: // 'D' with middle bar
CharTmp1 = 'D'; CharTmp2 = '-'; goto _COMBINEDFONT;
case 0xD8: // 'O' with slash
CharTmp1 = 'O'; CharTmp2 = '/'; goto _COMBINEDFONT;
case 0xE0: // 'a' with right-down dash
CharTmp1 = 'a'; CharTmp2 = '`'; goto _COMBINEDFONT;
case 0xE1: // 'a' with left-down dash
CharTmp1 = 'a'; CharTmp2 = 0xA7; goto _COMBINEDFONT;
case 0xE2: // 'a' with hat
CharTmp1 = 'a'; CharTmp2 = '^'; goto _COMBINEDFONT;
case 0xE3: // 'a' with tilde
CharTmp1 = 'a'; CharTmp2 = '~'; goto _COMBINEDFONT;
case 0xE4: // 'a' with umlaut
CharTmp1 = 'a'; CharTmp2 = 0xBE; goto _COMBINEDFONT;
case 0xE5: // 'a' with circle
CharTmp1 = 'a'; CharTmp2 = 0xA6; goto _COMBINEDFONT;
case 0xEA: // 'e' with hat
CharTmp1 = 'e'; CharTmp2 = '^'; goto _COMBINEDFONT;
case 0xEB: // 'e' with umlaut
CharTmp1 = 'e'; CharTmp2 = 0xBE; goto _COMBINEDFONT;
case 0xF1: // 'n' with tilde
CharTmp1 = 'n'; CharTmp2 = '~'; goto _COMBINEDFONT;
case 0xF2: // 'o' with right-down dash
CharTmp1 = 'o'; CharTmp2 = '`'; goto _COMBINEDFONT;
case 0xF3: // 'o' with left-down dash
CharTmp1 = 'o'; CharTmp2 = 0xA7; goto _COMBINEDFONT;
case 0xF4: // 'o' with hat
CharTmp1 = 'o'; CharTmp2 = '^'; goto _COMBINEDFONT;
case 0xF5: // 'o' with tilde
CharTmp1 = 'o'; CharTmp2 = '~'; goto _COMBINEDFONT;
case 0xF6: // 'o' with umlaut
CharTmp1 = 'o'; CharTmp2 = 0xBE; goto _COMBINEDFONT;
case 0xF8: // 'o' with slash
CharTmp1 = 'o'; CharTmp2 = '/'; goto _COMBINEDFONT;
case 0xFA: // 'u' with left-down dash
CharTmp1 = 'u'; CharTmp2 = 0xA7; goto _COMBINEDFONT;
case 0xFB: // 'u' with hat
CharTmp1 = 'u'; CharTmp2 = '^'; goto _COMBINEDFONT;
case 0xFD: // 'y' with left-down dash
CharTmp1 = 'y'; CharTmp2 = 0xA7; goto _COMBINEDFONT;
case 0xFF: // 'y' with umlaut
CharTmp1 = 'y'; CharTmp2 = 0xBE; goto _COMBINEDFONT;
_COMBINEDFONT:
WRITESPOOLBUF(pdevobj, &CharTmp2, 1);
WRITESPOOLBUF(pdevobj, BS, sizeof(BS)-1);
if (rcID == BOLDFACEPS && CharTmp1 != 'D') // BoldFacePS(except 'D'+'-')
WRITESPOOLBUF(pdevobj, BS, sizeof(BS)-1);
WRITESPOOLBUF(pdevobj, &CharTmp1, 1);
break;
case 0x9F: // 'Y' with umlaut
CharTmp1 = 'Y'; CharTmp2 = 0xBE; goto _COMBINEDFONT_HALFUP;
case 0xC0: // 'A' with right-down dash
CharTmp1 = 'A'; CharTmp2 = '`'; goto _COMBINEDFONT_HALFUP;
case 0xC1: // 'A' with left-down dash
CharTmp1 = 'A'; CharTmp2 = 0xA7; goto _COMBINEDFONT_HALFUP;
case 0xC2: // 'A' with hat
CharTmp1 = 'A'; CharTmp2 = '^'; goto _COMBINEDFONT_HALFUP;
case 0xC3: // 'A' with tilde
CharTmp1 = 'A'; CharTmp2 = '~'; goto _COMBINEDFONT_HALFUP;
case 0xC8: // 'E' with right-down dash
CharTmp1 = 'E'; CharTmp2 = '`'; goto _COMBINEDFONT_HALFUP;
case 0xCA: // 'E' with hat
CharTmp1 = 'E'; CharTmp2 = '^'; goto _COMBINEDFONT_HALFUP;
case 0xCB: // 'E' with umlaut
CharTmp1 = 'E'; CharTmp2 = 0xBE; goto _COMBINEDFONT_HALFUP;
case 0xCC: // 'I' with right-down dash
CharTmp1 = 'I'; CharTmp2 = '`'; goto _COMBINEDFONT_HALFUP;
case 0xCD: // 'I' with left-down dash
CharTmp1 = 'I'; CharTmp2 = 0xA7; goto _COMBINEDFONT_HALFUP;
case 0xCE: // 'I' with hat
CharTmp1 = 'I'; CharTmp2 = '^'; goto _COMBINEDFONT_HALFUP;
case 0xCF: // 'I' with umlaut
CharTmp1 = 'I'; CharTmp2 = 0xBE; goto _COMBINEDFONT_HALFUP;
case 0xD1: // 'N' with tilde
CharTmp1 = 'N'; CharTmp2 = '~'; goto _COMBINEDFONT_HALFUP;
case 0xD2: // 'O' with right-down dash
CharTmp1 = 'O'; CharTmp2 = '`'; goto _COMBINEDFONT_HALFUP;
case 0xD3: // 'O' with left-down dash
CharTmp1 = 'O'; CharTmp2 = 0xA7; goto _COMBINEDFONT_HALFUP;
case 0xD4: // 'O' with hat
CharTmp1 = 'O'; CharTmp2 = '^'; goto _COMBINEDFONT_HALFUP;
case 0xD5: // 'O' with tilde
CharTmp1 = 'O'; CharTmp2 = '~'; goto _COMBINEDFONT_HALFUP;
case 0xD9: // 'U' with right-down dash
CharTmp1 = 'U'; CharTmp2 = '`'; goto _COMBINEDFONT_HALFUP;
case 0xDA: // 'U' with left-down dash
CharTmp1 = 'U'; CharTmp2 = 0xA7; goto _COMBINEDFONT_HALFUP;
case 0xDB: // 'U' with hat
CharTmp1 = 'U'; CharTmp2 = '^'; goto _COMBINEDFONT_HALFUP;
case 0xDD: // 'Y' with left-down dash
CharTmp1 = 'Y'; CharTmp2 = 0xA7; goto _COMBINEDFONT_HALFUP;
_COMBINEDFONT_HALFUP:
WRITESPOOLBUF(pdevobj, ESC_HALFUP, sizeof(ESC_HALFUP)-1);
WRITESPOOLBUF(pdevobj, &CharTmp2, 1);
WRITESPOOLBUF(pdevobj, ESC_HALFDOWN, sizeof(ESC_HALFDOWN)-1);
WRITESPOOLBUF(pdevobj, BS, sizeof(BS)-1);
if (rcID == BOLDFACEPS && CharTmp1 != 'I') // BoldFacePS(except 'I')
WRITESPOOLBUF(pdevobj, BS, sizeof(BS)-1);
WRITESPOOLBUF(pdevobj, &CharTmp1, 1);
break;
case 0x84: // double quatation at bottom
CharTmp1 = 0x22;
WRITESPOOLBUF(pdevobj, ESC_DOWN, sizeof(ESC_DOWN)-1);
WRITESPOOLBUF(pdevobj, &CharTmp1, 1);
WRITESPOOLBUF(pdevobj, ESC_UP, sizeof(ESC_UP)-1);
break;
case 0xB1: // plus-minus
if (rcID == BOLDFACEPS)
{
CharTmp2 = '_'; CharTmp1 = '+';
WRITESPOOLBUF(pdevobj, &CharTmp2, 1);
WRITESPOOLBUF(pdevobj, BS, sizeof(BS)-1);
}
else
{
CharTmp2 = '+'; CharTmp1 = '-';
WRITESPOOLBUF(pdevobj, &CharTmp2, 1);
}
WRITESPOOLBUF(pdevobj, BS, sizeof(BS)-1);
WRITESPOOLBUF(pdevobj, ESC_DOWN, sizeof(ESC_DOWN)-1);
WRITESPOOLBUF(pdevobj, &CharTmp1, 1);
WRITESPOOLBUF(pdevobj, ESC_UP, sizeof(ESC_UP)-1);
break;
case 0x95:
case 0xB7:
default: // print unprintable font by dot(KATAKANA)
// Set 2nd SBCS font table(0x80-0xFF) as KATAKANA
WRITESPOOLBUF(pdevobj, ESC_SHIFT_IN, sizeof(ESC_SHIFT_IN)-1);
CharTmp1 = 0xA5;
WRITESPOOLBUF(pdevobj, &CharTmp1, 1);
// Set 2nd SBCS font table(0x80-0xFF) as 2ndANK
WRITESPOOLBUF(pdevobj, ESC_SHIFT_OUT, sizeof(ESC_SHIFT_OUT)-1);
break;
} // 'switch (CharTmp1)' end
}
else //** Japanese font (HANKAKU) **
{
if (fVertFont) // vertical font
{
// HANKAKU(Alphabetical&Numeric) fonts must not become vertical.
WRITESPOOLBUF(pdevobj, ESC_VERT_OFF, sizeof(ESC_VERT_OFF)-1);
WRITESPOOLBUF(pdevobj, lpChar, 1);
WRITESPOOLBUF(pdevobj, ESC_VERT_ON, sizeof(ESC_VERT_ON)-1);
}
else // normal (non vertical) font
{
WRITESPOOLBUF(pdevobj, lpChar, 1);
}
} // 'if European font else Japanese font(HANKAKU)' end
break;
case MTYPE_PAIRED: // DBCS (Japanes font ZENKAKU)
// VERBOSE((("TYPE_TRANSDATA:ubPairs:0x%x\n"), *(PWORD)(pTrans->uCode.ubPairs)));
lpChar = pTrans->uCode.ubPairs;
// For proportional font UFM which has GTT @Oct/27/98 ->
#ifdef JISGTT
if (fJisCode)
{
BYTE jis[2], sjis[2];
jis[0] = *lpChar;
jis[1] = *(lpChar+1);
jis2sjis(jis, sjis);
(BYTE)*lpChar = sjis[0];
(BYTE)*(lpChar+1) = sjis[1];
}
#endif // JISGTT
// @Oct/27/98 <-
CharTmp1 = *lpChar;
CharTmp2 = *(lpChar+1);
// Some vertical device font differ from TrueType font
if (fVertFont)
{
if (CharTmp1 == 0x81)
{
// Make vertical device font same to TrueType
if (IsDifferentPRNFONT(CharTmp2))
{
WRITESPOOLBUF(pdevobj, ESC_VERT_OFF, sizeof(ESC_VERT_OFF)-1);
WRITESPOOLBUF(pdevobj, ESC_ROT90, sizeof(ESC_ROT90)-1);
WRITESPOOLBUF(pdevobj, lpChar, 2);
WRITESPOOLBUF(pdevobj, ESC_ROT0, sizeof(ESC_ROT0)-1);
WRITESPOOLBUF(pdevobj, ESC_VERT_ON, sizeof(ESC_VERT_ON)-1);
continue; // goto for-loop end
}
else if (CharTmp2 >= 0xA8 && CharTmp2 <= 0xAB)
{ //IMAGIO's GOTHIC device font differ from TrueType font
goto _WITHOUTROTATION;
}
}
if (CharTmp1 == 0x84 &&
CharTmp2 >= 0x9F && CharTmp2 <= 0xBE)
{
_WITHOUTROTATION:
WRITESPOOLBUF(pdevobj, ESC_VERT_OFF, sizeof(ESC_VERT_OFF)-1);
WRITESPOOLBUF(pdevobj, lpChar, 2);
WRITESPOOLBUF(pdevobj, ESC_VERT_ON, sizeof(ESC_VERT_ON)-1);
continue; // goto for-loop end
}
} // 'if(fVertFont)' end
// Code of HEISEI mark of device font differs from SJIS
if (CharTmp1 == 0x87 && CharTmp2 == 0x7E)
{
(BYTE)*(lpChar+1) = 0x9E;
WRITESPOOLBUF(pdevobj, lpChar, 2);
continue; // goto for-loop end
}
// If models which support IBM ext char code
if (fIBMFontSupport)
{
WRITESPOOLBUF(pdevobj, lpChar, 2);
continue; // goto for-loop end
}
// Handle IBM ext char code here at models which do not support it
switch (CharTmp1)
{
case 0xFA:
if (CharTmp2 >= 0x40 && CharTmp2 <= 0xFC)
(BYTE)*lpChar = 0x0EB;
goto _WRITE2BYTE;
case 0xFB:
if (CharTmp2 >= 0x40 && CharTmp2 <= 0x9E)
{
(BYTE)*lpChar = 0xEC;
goto _WRITE2BYTE;
}
if (CharTmp2 >= 0x9F && CharTmp2 <= 0xDD)
{
(BYTE)*lpChar = 0x8A;
(BYTE)*(lpChar+1) -= 0x5F;
goto _WRITE2BYTE_SWITCHBLOCK;
}
if (CharTmp2 >= 0xDE && CharTmp2 <= 0xFC)
{
(BYTE)*lpChar = 0x8A;
(BYTE)*(lpChar+1) -= 0x5E;
goto _WRITE2BYTE_SWITCHBLOCK;
}
goto _WRITE2BYTE;
case 0xFC:
if (CharTmp2 >= 0x40 && CharTmp2 <= 0x4B)
{
(BYTE)*lpChar = 0x8A;
(BYTE)*(lpChar+1) += 0x5F;
goto _WRITE2BYTE_SWITCHBLOCK;
}
goto _WRITE2BYTE;
case 0xED: //IBM extended char selected by NEC
if (CharTmp2 >= 0x40 && CharTmp2 <= 0x62)
{
(BYTE)*lpChar = 0xEB;
(BYTE)*(lpChar+1) += 0x1C;
goto _WRITE2BYTE;
}
if (CharTmp2 >= 0x63 && CharTmp2 <= 0x7E)
{
(BYTE)*lpChar = 0xEB;
(BYTE)*(lpChar+1) += 0x1D;
goto _WRITE2BYTE;
}
if (CharTmp2 >= 0x80 && CharTmp2 <= 0xE0)
{
(BYTE)*lpChar = 0xEB;
(BYTE)*(lpChar+1) += 0x1C;
goto _WRITE2BYTE;
}
if (CharTmp2 >= 0xE1 && CharTmp2 <= 0xFC)
{
(BYTE)*lpChar = 0xEC;
(BYTE)*(lpChar+1) -= 0xA1;
goto _WRITE2BYTE;
}
goto _WRITE2BYTE;
case 0xEE: //IBM extended char selected by NEC
if (CharTmp2 >= 0x40 && CharTmp2 <= 0x62)
{
(BYTE)*lpChar = 0xEC;
(BYTE)*(lpChar+1) += 0x1C;
goto _WRITE2BYTE;
}
if (CharTmp2 >= 0x63 && CharTmp2 <= 0x7E)
{
(BYTE)*lpChar = 0xEC;
(BYTE)*(lpChar+1) += 0x1D;
goto _WRITE2BYTE;
}
if (CharTmp2 >= 0x80 && CharTmp2 <= 0x82)
{
(BYTE)*lpChar = 0xEC;
(BYTE)*(lpChar+1) += 0x1C;
goto _WRITE2BYTE;
}
if (CharTmp2 >= 0x83 && CharTmp2 <= 0xC1)
{
(BYTE)*lpChar = 0x8A;
(BYTE)*(lpChar+1) -= 0x43;
goto _WRITE2BYTE_SWITCHBLOCK;
}
if (CharTmp2 >= 0xC2 && CharTmp2 <= 0xEC)
{
(BYTE)*lpChar = 0x8A;
(BYTE)*(lpChar+1) -= 0x42;
goto _WRITE2BYTE_SWITCHBLOCK;
}
if (CharTmp2 >= 0xEF && CharTmp2 <= 0xF8)
{
(BYTE)*lpChar = 0xEB;
(BYTE)*(lpChar+1) -= 0xAF;
goto _WRITE2BYTE;
}
if (CharTmp2 >= 0xF9 && CharTmp2 <= 0xFC)
{
(BYTE)*lpChar = 0xEB;
(BYTE)*(lpChar+1) -= 0xA5;
goto _WRITE2BYTE;
}
goto _WRITE2BYTE;
_WRITE2BYTE_SWITCHBLOCK:
// Assign IBM char to JIS1 block
AssignIBMfont(pdevobj, rcID, IBMFONT_ENABLE_ALL);
// Output char code
WRITESPOOLBUF(pdevobj, lpChar, 2);
// Resume the block
AssignIBMfont(pdevobj, rcID, IBMFONT_RESUME);
break;
default:
_WRITE2BYTE:
WRITESPOOLBUF(pdevobj, lpChar, 2);
break;
} // 'switch (CharTmp1)' end
break;
} // 'switch (pTrans->ubType & MTYPE_FORMAT_MASK)' end
} // 'for (dwI = 0; dwI < dwCount; dwI ++, pTrans++)' end
//** Draw device font END **
if(fMemAllocated)
MemFree(aubBuff);
break;
case TYPE_GLYPHID: // donwload font
#ifdef DOWNLOADFONT
// If negative, do not draw. (lFontID should begin from 0.)
// VERBOSE((("** ulFontID=%d **\n"), pUFObj->ulFontID));
if ((lFontID = (LONG)pUFObj->ulFontID - DLFONT_ID_MIN_GPD) < 0)
break; // exit
//** Draw download font **
for (dwI = 0; dwI < dwCount; dwI ++, ((PDWORD)pGlyph)++)
{
// If negative, do not draw. (lGlyphID should begin from 0.)
if ((lGlyphID = (LONG)*(PWORD)pGlyph - DLFONT_GLYPH_MIN_GPD) < 0)
break; // exit for-loop
wSerialNum = (WORD)lGlyphID + (WORD)lFontID * DLFONT_GLYPH_TOTAL;
lpDLFont = &pOEM->pDLFontGlyphInfo[wSerialNum];
// VERBOSE((("** pGlyph=%d, local glyph_id=%d **\n"), *(PWORD)pGlyph, lGlyphID));
// If space character
if (lpDLFont->nPitch < 0)
{
// Save moving value for next font print with reseting flag
pOEM->nCharPosMoveX += -lpDLFont->nPitch;
}
else
{
// Locate print position.
if ((mov = pOEM->nCharPosMoveX + lpDLFont->nOffsetX) != 0)
{
if (mov > 0)
ocmd = safe_sprintfA(Cmd, sizeof(Cmd), ESC_XM_REL, mov);
else
ocmd = safe_sprintfA(Cmd, sizeof(Cmd), ESC_XM_RELLEFT, -mov);
}
// Print download font
ocmd += safe_sprintfA(&Cmd[ocmd], sizeof(Cmd) - ocmd, DLFONT_PRINT, wSerialNum,
pOEM->TextCurPos.y - lpDLFont->nOffsetY);
WRITESPOOLBUF(pdevobj, Cmd, ocmd);
ocmd = 0;
// Save moving value for next font print.
pOEM->nCharPosMoveX = lpDLFont->nPitch - lpDLFont->nOffsetX;
} // 'if (pitch < 0) else' end
} // 'for (dwI = 0; dwI < dwCount; dwI ++, ((PDWORD)pGlyph)++)' end
#endif // DOWNLOADFONT
break;
//** Draw download font END **
} // 'switch (dwType)' end
return TRUE; // BOOL <- VOID @Mar/27/2002
} //*** bOEMOutputCharStr
DWORD APIENTRY OEMDownloadFontHeader(
PDEVOBJ pdevobj,
PUNIFONTOBJ pUFObj)
{
#ifndef DOWNLOADFONT
return 0; // not available
#else // DOWNLOADFONT
VERBOSE(("** OEMDownloadFontHeader() entry. **\n"));
VERBOSE((" FontID=%d\n", pUFObj->ulFontID));
// OBSOLETE @Apr/02/99 ->
// SPEC of Unidrv5
// Unidrv5 doesn't handle 0-return, once OEMTTDownloadMethod returns TTDOWNLOAD_BITMAP.
// POEMPDEV pOEM = MINIDEV_DATA(pdevobj); // @Oct/06/98
// LONG lFontID; // @Aug/21/98
// // If FontID is beyond limit, exit.
// if ((lFontID = (LONG)pUFObj->ulFontID - DLFONT_ID_MIN_GPD) < 0 ||
// lFontID >= (LONG)pOEM->DLFontMaxID)
// {
// return 0;
// }
// @Apr/02/99 <-
return 1; // available
#endif // DOWNLOADFONT
} //*** OEMDownloadFontHeader
DWORD APIENTRY OEMDownloadCharGlyph(
PDEVOBJ pdevobj,
PUNIFONTOBJ pUFObj,
HGLYPH hGlyph,
PDWORD pdwWidth)
{
#ifndef DOWNLOADFONT
return 0; // not available
#else // DOWNLOADFONT
WORD wSerialNum, wHeight, wWidthByte;
DWORD dwNeeded, dwSize;
LPBYTE lpBitmap;
LPFONTPOS lpDLFont;
GETINFO_GLYPHBITMAP GBmp;
POEMPDEV pOEM = MINIDEV_DATA(pdevobj); // @Oct/06/98
LONG lFontID, lGlyphID;
VERBOSE(("** OEMDownloadCharGlyph() entry. **\n"));
// If negative or beyond limit, do not download. (lGlyphID should begin from 0.)
if ((lGlyphID = (LONG)pOEM->DLFontCurGlyph - DLFONT_GLYPH_MIN_GPD) < 0 ||
lGlyphID >= pOEM->DLFontMaxGlyph)
{
return 0; // exit
}
// If beyond limit, do not download. (lFontID should begin from 0.)
if ((lFontID = (LONG)pUFObj->ulFontID - DLFONT_ID_MIN_GPD) < 0 ||
lFontID >= (LONG)pOEM->DLFontMaxID)
{
return 0; // exit
}
VERBOSE((" FontID=%d, GlyphID=%d\n", lFontID, lGlyphID));
wSerialNum = (WORD)lGlyphID + (WORD)lFontID * DLFONT_GLYPH_TOTAL;
//
// GETINFO_GLYPHBITMAP
//
GBmp.dwSize = sizeof(GETINFO_GLYPHBITMAP);
GBmp.hGlyph = hGlyph;
if (!pUFObj->pfnGetInfo(pUFObj, UFO_GETINFO_GLYPHBITMAP, &GBmp,
GBmp.dwSize, &dwNeeded))
{
ERR(("UNIFONTOBJ_GetInfo:UFO_GETINFO_GLYPHBITMAP failed.\n"));
return 0; // exit
}
wWidthByte = ((WORD)GBmp.pGlyphData->gdf.pgb->sizlBitmap.cx + 7) >> 3; // byte:8bit-boundary
wHeight = (WORD)GBmp.pGlyphData->gdf.pgb->sizlBitmap.cy;
lpBitmap = (LPBYTE)GBmp.pGlyphData->gdf.pgb->aj;
lpDLFont = &pOEM->pDLFontGlyphInfo[wSerialNum];
lpDLFont->nPitch = (SHORT)(GBmp.pGlyphData->fxD >> 4);
lpDLFont->nOffsetX = (SHORT)GBmp.pGlyphData->gdf.pgb->ptlOrigin.x;
lpDLFont->nOffsetY = -(SHORT)GBmp.pGlyphData->gdf.pgb->ptlOrigin.y;
dwSize = wHeight * wWidthByte;
// VERBOSE((" width=%dbyte,height=%ddot,bmp[0]=%x\n", wWidthByte, wHeight, *lpBitmap));
// VERBOSE((" pitch=%d(FIX(28.4):%lxh),offsetx=%d,offsety=%d\n",
// GBmp.pGlyphData->fxD >> 4, GBmp.pGlyphData->fxD,
// lpDLFont->nOffsetX, lpDLFont->nOffsetY));
// VERBOSE((" dwSize(raw)=%ldbyte\n", dwSize));
// If space character
if (dwSize == 0 || dwSize == 1 && *lpBitmap == 0)
{
// Negate pitch to indicate space character
lpDLFont->nPitch = -lpDLFont->nPitch;
return 1; // success return (1<-0 @Jun/15/98)
}
else
{
BYTE Cmd[64];
INT ocmd; // INT<-SHORT @Feb/22/99
WORD fDRC = FALSE;
DWORD dwSizeRPDL, dwSizeDRC;
// Do FE-DeltaRow compression (@Jun/15/98, pOEM->pRPDLHeap2K<-OutBuf[1024] @Sep/09/98)
if (TEST_CAPABLE_DOWNLOADFONT_DRC(pOEM->fModel) && pOEM->pRPDLHeap2K &&
-1 != (dwSizeDRC = DRCompression(lpBitmap, pOEM->pRPDLHeap2K, dwSize, HEAPSIZE2K,
(DWORD)wWidthByte, (DWORD)wHeight)))
{
fDRC = TRUE;
dwSize = dwSizeDRC;
lpBitmap = pOEM->pRPDLHeap2K;
}
// Include header size and make it 32byte-boudary.
dwSizeRPDL = (dwSize + (DLFONT_HEADER_SIZE + DLFONT_MIN_BLOCK - 1))
/ DLFONT_MIN_BLOCK * DLFONT_MIN_BLOCK;
// Check available memory size
if((pOEM->dwDLFontUsedMem += dwSizeRPDL) > ((DWORD)pOEM->DLFontMaxMemKB << 10))
{
ERR(("DOWNLOAD MEMORY OVERFLOW.\n"));
return 0; // exit
}
VERBOSE((" Consumed Memory=%ldbyte\n", pOEM->dwDLFontUsedMem));
// Register glyph bitmap image
if (fDRC) // @Jun/15/98
ocmd = safe_sprintfA(Cmd, sizeof(Cmd), DLFONT_SEND_BLOCK_DRC, wWidthByte*8, wHeight, wSerialNum, dwSize);
else
ocmd = safe_sprintfA(Cmd, sizeof(Cmd), DLFONT_SEND_BLOCK, wWidthByte*8, wHeight, wSerialNum);
WRITESPOOLBUF(pdevobj, Cmd, ocmd);
WRITESPOOLBUF(pdevobj, lpBitmap, dwSize);
return dwSizeRPDL;
}
#endif // DOWNLOADFONT
} //*** OEMDownloadCharGlyph
DWORD APIENTRY OEMTTDownloadMethod(
PDEVOBJ pdevobj,
PUNIFONTOBJ pUFObj)
{
#ifndef DOWNLOADFONT
return TTDOWNLOAD_DONTCARE;
#else // DOWNLOADFONT
// @Nov/18/98 ->
GETINFO_FONTOBJ GFo;
POEMPDEV pOEM = MINIDEV_DATA(pdevobj);
DWORD dwNeeded, dwWidth;
VERBOSE(("** OEMTTDownloadMethod() entry. **\n"));
// If printer doesn't support or user disabled downloading, do not download.
if (!pOEM->DLFontMaxMemKB)
return TTDOWNLOAD_DONTCARE;
//
// GETINFO_FONTOBJ
//
GFo.dwSize = sizeof(GETINFO_FONTOBJ);
if (!pUFObj->pfnGetInfo(pUFObj, UFO_GETINFO_FONTOBJ, &GFo,
GFo.dwSize, &dwNeeded))
{
ERR(("UNIFONTOBJ_GetInfo:UFO_GETINFO_FONTOBJ failed.\n"));
return TTDOWNLOAD_GRAPHICS; // <-TTDOWNLOAD_DONTCARE @Apr/02/99
}
// If bold or italic font, do not download.
// (SBCS font which has bold or italic glyph (e.g. Arial) doesn't fit this condition.)
if (GFo.pFontObj->flFontType & (FO_SIM_BOLD | FO_SIM_ITALIC))
{
VERBOSE((" UNAVAILABLE: BOLD/ITALIC\n"));
return TTDOWNLOAD_GRAPHICS; // <-TTDOWNLOAD_DONTCARE @Apr/02/99
}
dwWidth = GFo.pFontObj->cxMax * pOEM->nResoRatio; // masterunit
// VERBOSE((" FontSize=%d\n", GFo.pFontObj->cxMax));
// If font width is beyond limit, do not download.
if (IS_DBCSCHARSET(pUFObj->pIFIMetrics->jWinCharSet))
{
if (dwWidth > DLFONT_SIZE_DBCS11PT_MU || dwWidth < DLFONT_SIZE_DBCS9PT_MU)
{
VERBOSE((" UNAVAILABLE: DBCS FONTSIZE OUT OF RANGE(%ddot,%dcpt)\n",
GFo.pFontObj->cxMax, dwWidth*7200L/MASTERUNIT));
return TTDOWNLOAD_GRAPHICS; // <-TTDOWNLOAD_DONTCARE @Apr/02/99
}
}
else
{
if (dwWidth > DLFONT_SIZE_SBCS11PT_MU || dwWidth < DLFONT_SIZE_SBCS9PT_MU)
{
VERBOSE((" UNAVAILABLE: SBCS FONTSIZE OUT OF RANGE(%ddot,%dcpt)\n",
GFo.pFontObj->cxMax, dwWidth*7200L/MASTERUNIT));
return TTDOWNLOAD_GRAPHICS; // <-TTDOWNLOAD_DONTCARE @Apr/02/99
}
}
VERBOSE((" AVAILABLE\n"));
// @Nov/18/98 <-
return TTDOWNLOAD_BITMAP;
#endif // DOWNLOADFONT
} //*** OEMTTDownloadMethod
INT APIENTRY OEMCompression( // @Jun/04/98
PDEVOBJ pdevobj,
PBYTE pInBuf,
PBYTE pOutBuf,
DWORD dwInLen,
DWORD dwOutLen)
{
POEMPDEV pOEM = MINIDEV_DATA(pdevobj); // @Oct/06/98
// VERBOSE(("OEMCompression() entry.\n"));
return DRCompression(pInBuf, pOutBuf, dwInLen, dwOutLen,
pOEM->dwSrcBmpWidthByte, pOEM->dwSrcBmpHeight);
} //*** OEMCompression
//---------------------------*[LOCAL] DRCompression*---------------------------
// Action: Compress data by FE-DeltaRow method
// Return: number of compressed bytes if successful
// -1 if unable to compress the data within the specific buffer
// History:
// Oct/25/97 Tatsuro Yoshioka(RICOH) Created.
// Jun/11/98 Masatoshi Kubokura(RICOH) Modified.
//-----------------------------------------------------------------------------
static INT DRCompression(
PBYTE pInBuf, // Pointer to raster data to compress
PBYTE pOutBuf, // Pointer to output buffer for compressed data
DWORD dwInLen, // size of input data to compress
DWORD dwOutLen, // size of output buffer in bytes
DWORD dwWidthByte, // width of raster data in bytes
DWORD dwHeight) // height of raster data
{
DWORD dwCurRow, dwCurByte, dwSameByteCnt, dwRepeatByteCnt, dwTmp;
DWORD dwCompLen, dwCnt, dwCnt2;
BYTE *pTmpPre, *pTmpCur, *pCurRow, *pPreRow;
BYTE DiffBytes[16], FlagBit;
// VERBOSE((" dwInLen, dwOutLen=%d, %d\n", dwInLen, dwOutLen));
// VERBOSE((" Width, Height=%d, %d\n", dwWidthByte, dwHeight));
if (dwOutLen > dwInLen) // add @Jun/19/98
dwOutLen = dwInLen;
// @Apr/07/2000 ->
// PRINTER SIDE ISSUE: RPDL
// Bitmap image is destorted when width or height >= 10000dots
if (dwWidthByte >= (10000L/8L) || dwHeight >= 10000L)
return -1;
// @Apr/07/2000 <-
if (dwHeight <= 3 || dwOutLen <= dwWidthByte * 3)
return -1;
pPreRow = pTmpPre = pOutBuf + dwOutLen - dwWidthByte;
dwCnt = dwWidthByte;
while (dwCnt--) // fill seed row with 0
*pTmpPre++ = 0;
dwCompLen = 0;
// Loop of each row
for (dwCurRow = 0, pCurRow = pInBuf; dwCurRow < dwHeight;
dwCurRow++, pCurRow += dwWidthByte)
{
dwCurByte = 0;
// Loop of each byte-data in row
while (dwCurByte < dwWidthByte)
{
// Search same byte-data between current row and previous row
dwSameByteCnt = 0;
dwTmp = dwCurByte;
pTmpPre = pPreRow + dwTmp;
pTmpCur = pCurRow + dwTmp;
while (*pTmpCur++ == *pTmpPre++)
{
// bug fix @Nov/19/98 ->
// if (dwTmp++ >= dwWidthByte)
// break;
// dwSameByteCnt++;
dwSameByteCnt++;
if (++dwTmp >= dwWidthByte)
break;
// @Nov/19/98 <-
}
// If we have same byte-data between current row and previous row
if (dwSameByteCnt)
{
if (dwSameByteCnt != dwWidthByte)
{
if ((dwCnt = dwSameByteCnt) >= 63)
{
dwCnt -= 63;
if (++dwCompLen > dwOutLen)
{
VERBOSE((" OVERSIZE COMPRESSION(1)\n"));
return -1;
}
*pOutBuf++ = 0xBF; // control data (same to previous row)
while (dwCnt >= 255)
{
dwCnt -= 255;
if (++dwCompLen > dwOutLen)
{
VERBOSE((" OVERSIZE COMPRESSION(2)\n"));
return -1;
}
*pOutBuf++ = 0xFF; // repeating count
}
}
else // less than 63
{
dwCnt |= 0x80;
}
if (++dwCompLen > dwOutLen)
{
VERBOSE((" OVERSIZE COMPRESSION(3)\n"));
return -1;
}
// If 63 or more, set the last repeating count, else set control data.
*pOutBuf++ = (BYTE)dwCnt;
}
dwCurByte += dwSameByteCnt;
}
// Same byte-data in previous row is none
else
{
BYTE bTmp = *(pCurRow + dwCurByte);
// How many same byte-data in current row?
dwRepeatByteCnt = 1;
dwTmp = dwCurByte + 1;
pTmpCur = pCurRow + dwTmp;
while (bTmp == *pTmpCur++)
{
// bug fix @Nov/19/98 ->
// if (dwTmp++ >= dwWidthByte)
// break;
// dwRepeatByteCnt++;
dwRepeatByteCnt++;
if (++dwTmp >= dwWidthByte)
break;
// @Nov/19/98 <-
}
// If we have same byte-data in current row
if (dwRepeatByteCnt > 1)
{
if ((dwCnt = dwRepeatByteCnt) >= 63)
{
dwCnt -= 63;
if (++dwCompLen > dwOutLen)
{
VERBOSE((" OVERSIZE COMPRESSION(4)\n"));
return -1;
}
*pOutBuf++ = 0xFF; // repeating count
while (dwCnt >= 255)
{
dwCnt -= 255;
if (++dwCompLen > dwOutLen)
{
VERBOSE((" OVERSIZE COMPRESSION(5)\n"));
return -1;
}
*pOutBuf++ = 0xFF; // repeating count
}
}
// Less than 63
else
{
dwCnt |= 0xC0;
}
if ((dwCompLen += 2) > dwOutLen)
{
VERBOSE((" OVERSIZE COMPRESSION(6)\n"));
return -1;
}
// If 63 or more, set the last repeating count, else set control data.
*pOutBuf++ = (BYTE)dwCnt;
*pOutBuf++ = *(pCurRow+dwCurByte); // replacing data
dwCurByte += dwRepeatByteCnt;
}
// Same byte-data in current row is none
else
{
// If next serial 2 byte-data are same
if (dwWidthByte - dwCurByte > 2 &&
*(pCurRow+dwCurByte+1) == *(pCurRow+dwCurByte+2))
{
if ((dwCompLen += 2) > dwOutLen)
{
VERBOSE((" OVERSIZE COMPRESSION(7)\n"));
return -1;
}
*pOutBuf++ = 0xC1; // control data (1 data)
*pOutBuf++ = *(pCurRow+dwCurByte); // replacing data
dwCurByte++;
continue; // continue while(dwCurByte < dwWidthByte)
}
// We can pack 8 serial byte-data (may or may not be different to previus row)
DiffBytes[0] = 0x00;
DiffBytes[1] = *(pCurRow+dwCurByte);
dwCnt2 = 2;
dwTmp = dwCurByte + 1;
pTmpPre = pPreRow + dwTmp;
pTmpCur = pCurRow + dwTmp;
FlagBit = 0x01;
if ((dwCnt = dwWidthByte - dwTmp) > 7)
dwCnt = 7;
while (dwCnt--)
{
// If encountered different data
if (*pTmpCur != *pTmpPre++)
{
DiffBytes[0] |= FlagBit; // set different-flag
DiffBytes[dwCnt2++] = *pTmpCur; // data
}
FlagBit <<= 1;
pTmpCur++;
}
if ((dwCompLen += dwCnt2) > dwOutLen)
{
VERBOSE((" OVERSIZE COMPRESSION(8)\n"));
return -1;
}
pTmpCur = &DiffBytes[0];
while (dwCnt2--)
*pOutBuf++ = *pTmpCur++; // different packed-data
dwCurByte += 8; // 8 byte-data are packed
} // 'if (dwRepeatByteCnt > 1) else' end
} // 'if (dwSameByteCnt) else' end
} // 'while (dwCurByte < dwWidthByte)' end
if (++dwCompLen > dwOutLen)
{
VERBOSE((" OVERSIZE COMPRESSION(9)\n"));
return -1;
}
*pOutBuf++ = 0x80; // terminator of row
pPreRow = pCurRow;
} // 'for (...; dwCurRow < dwHeight; ...)' end
// VERBOSE((" dwCompLen=%d\n", dwCompLen));
return dwCompLen;
} //*** DRCompression