internal.h

HP喷墨打印机驱动代码 HP内部资料！ 珍贵 珍贵 珍贵

//Compressor
//!\internal
//! Base for data compression methods
/*!
Impliment compression

******************************************************************************/
class Compressor : public Processor
{
public:
    Compressor(SystemServices* pSys, unsigned int RasterSize, BOOL useseed);
    virtual ~Compressor();

    virtual BOOL Process(RASTERDATA* InputRaster=NULL)=0;

    virtual void Flush() { }    // no pending output

    unsigned int GetOutputWidth(COLORTYPE color);
    virtual BYTE* NextOutputRaster(COLORTYPE color);

    void SetSeedRow(BYTE* seed) { SeedRow=seed; }

    DRIVER_ERROR constructor_error;

    SystemServices* pSS;
    // buffer is public for use by GraphicsTranslator
    BYTE* compressBuf;      // output buffer
    BYTE* SeedRow;
    BOOL UseSeedRow;
	BYTE* originalKData;

    unsigned int compressedsize;
    unsigned int inputsize;
    BOOL seeded;
}; //Compressor


//ClassName
//!
/*
\internal
*/
class Mode9 : public Compressor
{
public:
    Mode9(SystemServices* pSys,unsigned int RasterSize);
    virtual ~Mode9();
    BOOL Process(RASTERDATA* input);
    void Flush();
	BOOL ResetSeedRow;
}; //Mode9

//ClassName
//!
/*
\internal
*/
class Mode2 : public Compressor
{
public:
    Mode2(SystemServices* pSys,unsigned int RasterSize);
    virtual ~Mode2();
    BOOL Process(RASTERDATA* input);
}; //Mode2

//ClassName
//!
/*
\internal
*/
class Mode3 : public Compressor
{
public:
    Mode3 (SystemServices* pSys, Printer *pPrinter, unsigned int RasterSize);
    virtual ~Mode3 ();
    BOOL Process (RASTERDATA* input);
    void    Flush ();
private:
    Printer *m_pPrinter;
}; //Mode3

////////////////////////////////////////////////////////////////////////////
#if defined(APDK_FONTS_NEEDED)


//TextTranslator
//! ASCII data support
/*!
\internal
Does encapsulation work specific to ascii data, including handling of fonts
and treatments.

******************************************************************************/
class TextTranslator
{
public:
    TextTranslator(Printer* p,int quality,unsigned int colorplanes);
    virtual ~TextTranslator();

    DRIVER_ERROR TextOut(const char* pTextString, unsigned int LenString,
                const Font& font, BOOL sendfont=FALSE,
                int iAbsX=-1, int iAbsY=-1);

    DRIVER_ERROR SendCAP(unsigned int iAbsX,unsigned int iAbsY);
    const BYTE* ColorSequence(TEXTCOLOR eColor);
    BYTE ColorCode(TEXTCOLOR eColor);
    int TypefaceCode(const char* FontName);
    const BYTE* PointsizeSequence(unsigned int iPointsize);
    const BYTE* PitchSequence(unsigned int iPitch);
    const BYTE* StyleSequence(BOOL bItalic);
    const BYTE* WeightSequence(BOOL bBold);
    const BYTE* CompleteSequence(const Font& font);
    const BYTE* UnderlineSequence();
    const BYTE* DisableUnderlineSequence();

    // "transparent mode" escape to treat control code (BYTE b) as normal char
    int TransparentChar(unsigned int iMaxLen, BYTE b, BYTE* outbuff);

    DRIVER_ERROR constructor_error;

    DRIVER_ERROR SendFont(const Font& font);
    DRIVER_ERROR SendColorSequence(const TEXTCOLOR eColor);
    DRIVER_ERROR SendPointsize(const unsigned int iPointsize);
    DRIVER_ERROR SendPitch(const unsigned int iPitch);
    DRIVER_ERROR SendStyle(const BOOL bItalic);
    DRIVER_ERROR SendWeight(const BOOL bBold);
    DRIVER_ERROR SendUnderline();
    DRIVER_ERROR SendCompleteSequence(const Font& font);
    DRIVER_ERROR DisableUnderline();


private:
    Printer* thePrinter;
    int qualcode;                       // pcl code for text quality
    BYTE EscSeq[MAX_ESC_SEQ];           // storage for the command
    unsigned int iNumPlanes;                        // color planes, based on pen
    BYTE ColorCode1(TEXTCOLOR eColor);  // if iNumPlanes==1 (black)
    BYTE ColorCode3(TEXTCOLOR eColor);  // if iNumPlanes==3 (CMY)
    BYTE ColorCode4(TEXTCOLOR eColor);  // if iNumPlanes==4 (KCMY)

    // items for avoiding redundant font resets
    // (cheaper than copying whole font)
    TEXTCOLOR lastcolor;
    char lastname[20];
    char lastcharset[MAX_CHAR_SET];
    int lastpointsize;
    BOOL lastitalic;
    BOOL lastbold;
    void SetLast(const Font& font);

}; //TextTranslator

#endif //fonts needed


//Header
//! Composes a header stream
/*!
\internal
Composes a header stream, embodying specific requirements of the Printer.

******************************************************************************/
class Header
{
friend class Job;
public:
    Header(Printer* p,PrintContext* pc);

    virtual DRIVER_ERROR Send()=0;

    virtual DRIVER_ERROR EndJob();

    virtual DRIVER_ERROR SendCAPy(unsigned int iAbsY);  // made virtual for crossbow
    virtual DRIVER_ERROR FormFeed();                    // made virtual for crossbow

    unsigned int CAPy;  // may be moved during header; retrieved by Job

protected:
    Printer* thePrinter;
    PrintContext* thePrintContext;
    PrintMode* thePrintMode;
    /// routines to set values of internal variables
    void SetMediaType(MediaType mtype);
    void SetMediaSize(PAPER_SIZE papersize);
    void SetMediaSource(MediaSource msource);
    void SetQuality(Quality qual);
    void SetSimpleColor();

    // components of a header
    DRIVER_ERROR Margins();
    virtual DRIVER_ERROR Graphics();
    DRIVER_ERROR Simple();
    DRIVER_ERROR Modes();
    DRIVER_ERROR ConfigureRasterData();

    // common escapes, plus mode and margin setting
    virtual DRIVER_ERROR StartSend();

////// data members /////////////////////////////////
    unsigned int ResolutionX[MAXCOLORPLANES];
    unsigned int ResolutionY[MAXCOLORPLANES];
    unsigned int dyeCount;

    // utilities

    unsigned int ColorLevels(unsigned int ColorPlane);

    // escape sequence constants
    char SimpleColor[6]; BYTE sccount;      // color command string, and its size
    char mediatype[6]; BYTE mtcount;        // mediatype string, and its size
    char mediasize[8]; BYTE mscount;        // mediasize string, and its size
    char mediasource[6]; BYTE msrccount;    // mediasource string, and its size
    char quality[6]; BYTE qualcount;        // quality string, and its size
    BYTE QualityCode();         // returns just the variable byte of quality

}; //Header


//ClassName
/*
******************************************************************************/
class Header350 : public Header
{
public:
    Header350(Printer* p,PrintContext* pc);
    DRIVER_ERROR Send();
}; //Header350


//ClassName
/*
******************************************************************************/
class Header400 : public Header
{
public:
    Header400(Printer* p,PrintContext* pc);
    DRIVER_ERROR Send();

}; //Header400


//ClassName
/*
******************************************************************************/
class Header6XX : public Header
{
public:
    Header6XX(Printer* p,PrintContext* pc);
    virtual DRIVER_ERROR Send();
protected:

}; //Header6XX


//ClassName
/*
******************************************************************************/
class Header600 : public Header6XX
{
public:
    Header600(Printer* p,PrintContext* pc);
    DRIVER_ERROR Send();

}; //Header600


//ClassName
/*
******************************************************************************/
class Header690 : public Header
{
public:
    Header690(Printer* p,PrintContext* pc);
    DRIVER_ERROR Send();
}; //Header690


//ClassName
/*
******************************************************************************/
class Header540 : public Header
{
public:
    Header540(Printer* p,PrintContext* pc);
    DRIVER_ERROR Send();

}; //Header540


//ClassName
/*
******************************************************************************/
class Header895 : public Header
{
public:
    Header895(Printer* p,PrintContext* pc);
    virtual DRIVER_ERROR Send();

protected:
    DRIVER_ERROR Graphics();
    DRIVER_ERROR StartSend();
}; //Header895


//ClassName
/*
******************************************************************************/
class Header850 : public Header895
{
public:
    Header850(Printer* p,PrintContext* pc);

protected:
    DRIVER_ERROR StartSend();

}; //Header850


//ClassName
/*
******************************************************************************/
class Header900 : public Header895
{
public:
    Header900(Printer* p,PrintContext* pc);
    virtual DRIVER_ERROR Send();

protected:
    BOOL DuplexEnabled(BYTE* bDevIDBuff);
}; //Header900


//ClassName
/*
******************************************************************************/
class HeaderAladdin : public Header
{
public:
    HeaderAladdin(Printer* p,PrintContext* pc);
    DRIVER_ERROR ConfigureRasterData();
    DRIVER_ERROR ConfigureImageData();
    DRIVER_ERROR Send();
    DRIVER_ERROR StartSend();
    void SetMediaSource(MediaSource msource);
}; //HeaderAladdin


//ClassName
/*
******************************************************************************/
class Header630 : public Header
{
public:
    Header630(Printer* p,PrintContext* pc);
    DRIVER_ERROR Send();
}; //Header630


//ClassName
/*
******************************************************************************/
class Header2xxx : public Header
{
public:
    Header2xxx(Printer* p,PrintContext* pc);
    DRIVER_ERROR Send();
}; //Header2xxx


//ClassName
/*
******************************************************************************/
class Header3320 : public Header
{
public:
    Header3320 (Printer *p, PrintContext *pc);
    DRIVER_ERROR Send ();
protected:
    DRIVER_ERROR EndJob ();
    DRIVER_ERROR FormFeed ();
    DRIVER_ERROR SendCAPy (unsigned int iAbsY);
};
//ClassName
/*
******************************************************************************/
class Header21xx : public Header
{
public:
    Header21xx(Printer* p,PrintContext* pc);
    DRIVER_ERROR Send();
};  //Header21xx

//ClassName
/*
******************************************************************************/
class HeaderLJMono : public Header
{
public:
    HeaderLJMono (Printer* p,PrintContext* pc);
    virtual DRIVER_ERROR Send();

protected:
    DRIVER_ERROR EndJob ();
    DRIVER_ERROR Graphics ();
    DRIVER_ERROR StartSend ();
}; //HeaderLJMono

//ClassName
/*
******************************************************************************/
class HeaderLJColor : public Header
{
public:
    HeaderLJColor (Printer* p,PrintContext* pc);
    virtual DRIVER_ERROR Send();
	virtual DRIVER_ERROR FormFeed ();

protected:
    DRIVER_ERROR EndJob ();
    DRIVER_ERROR Graphics ();
    DRIVER_ERROR StartSend ();
    DRIVER_ERROR SendCAPy (unsigned int iAbsY);
}; //HeaderLJMono

//ClassName
/*
******************************************************************************/
class HeaderPScript : public Header
{
public:
    HeaderPScript (Printer *p, PrintContext *pc);
    DRIVER_ERROR Send ();
protected:
    DRIVER_ERROR EndJob ();
    DRIVER_ERROR FormFeed ();
    DRIVER_ERROR SendCAPy (unsigned int iAbsY);
    DRIVER_ERROR StartSend ();
};

//RasterSender
//! Send rasters to the device
/*!
******************************************************************************/
class RasterSender : public Processor
{
friend class Header;
friend class Header895;
friend class Header900;
public:
   // installs Header and Connection
    RasterSender(Printer* pP, PrintContext* pPC,
                Job* pJob,Halftoner* pHalftoner);

    virtual ~RasterSender();

    // processor interface ////////////////////////////////////
    //BOOL Process(BYTE* InputRaster=NULL, unsigned int size=0);
	BOOL Process(RASTERDATA* InputRaster=NULL);
    void Flush() { };
    BYTE* NextOutputRaster(COLORTYPE  rastercolor) { return NULL; }   // end of pipeline
    unsigned int GetOutputWidth(COLORTYPE  rastercolor) { return 0; } // never called


    DRIVER_ERROR constructor_error;

    DRIVER_ERROR SendRaster(RASTERDATA* InputRaster=NULL);

private:
    Printer* thePrinter;

    PrintContext* thePrintContext;
    Job* theJob;
    Halftoner* theHalftoner;
    long    m_lNBlankRasters;	/* XXX unused? */
}; //RasterSender

// end of RasterSender section ///////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////

#if defined(APDK_FONTS_NEEDED)

//TextMapper
//! Encapsulate mappings
/*!
\internal
Component of TextManager
This class encapsulates mappings that may be peculiar to different partners
or data sources. The use is as follows:
 1. invoke Map
 2. now access SubstLen and charset

Currently sets charset to LATIN1 at construction.

******************************************************************************/
class TextMapper
{
public:
    TextMapper(TextTranslator* t);

    // main function -- puts alternate string in buffer
    virtual void Map(BYTE b,BYTE* bSubst);

    // public members for access after call to Map()
    unsigned int SubstLen;
    char charset[MAX_CHAR_SET];

protected:
    TextTranslator* theTranslator;
}; //TextMapper

//GenericMapper
//!
/*
******************************************************************************/
class GenericMapper : public TextMapper
{
public:
    GenericMapper(TextTranslator* t);
    void Map(BYTE b,BYTE* bSubst);
}; //GenericMapper


//TextManager
//!
/*!
\internal
******************************************************************************/
class TextManager
// Component of TextJob
{
public:
    TextManager(TextTranslator* t,unsigned int PrintableX, unsigned int PrintableY);
    virtual ~TextManager();

    virtual DRIVER_ERROR TextOut(const char* pTextString, unsigned int iLenString,
                const Font& font, int iAbsX=-1, int iAbsY=-1);
    TextTranslator* theTranslator;

    DRIVER_ERROR constructor_error;

protected:

    unsigned int PrintableRegionX;
    unsigned int PrintableRegionY;

    DRIVER_ERROR CheckCoords(unsigned int iAbsX, unsigned int iAbsY );

    TextMapper* theMapper;

}; //TextManager

#endif     // FONTS

APDK_END_NAMESPACE

#endif //APDK_INTERNAL_H