~ubuntu-branches/ubuntu/gutsy/hplip/gutsy-security

/*****************************************************************************\
  printer.cpp : Implimentation for the Printer class

  Copyright (c) 1996 - 2001, Hewlett-Packard Co.
  All rights reserved.

  Redistribution and use in source and binary forms, with or without
  modification, are permitted provided that the following conditions
  are met:
  1. Redistributions of source code must retain the above copyright
     notice, this list of conditions and the following disclaimer.
  2. Redistributions in binary form must reproduce the above copyright
     notice, this list of conditions and the following disclaimer in the
     documentation and/or other materials provided with the distribution.
  3. Neither the name of Hewlett-Packard nor the names of its
     contributors may be used to endorse or promote products derived
     from this software without specific prior written permission.

  THIS SOFTWARE IS PROVIDED BY THE AUTHOR "AS IS" AND ANY EXPRESS OR IMPLIED
  WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
  MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.  IN
  NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
  SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED
  TO, PATENT INFRINGEMENT; PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS
  OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON
  ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
  THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
\*****************************************************************************/


#include "header.h"
#include "io_defs.h"
#include "resources.h"


//
// ** Printer CLASS **

APDK_BEGIN_NAMESPACE
extern BYTE* GetHTBinary();
APDK_END_NAMESPACE

APDK_BEGIN_NAMESPACE

Printer::Printer
(
    SystemServices* pSys,
    int numfonts,
    BOOL proto
) :
    constructor_error(NO_ERROR),
    IOMode(pSys->IOMode),
#if defined(APDK_FONTS_NEEDED)
    iNumFonts(numfonts),
#else
    iNumFonts(0),
#endif
    bCheckForCancelButton(FALSE),
    ulBytesSentSinceCancelCheck(0),
    ePen(NO_PEN),
    CMYMap(NULL),
    pSS(pSys),
    InSlowPollMode(0),
    iTotal_SLOW_POLL_Count(0),
    iMax_SLOW_POLL_Count(DEFAULT_SLOW_POLL_COUNT),
    ErrorTerminationState(FALSE),
    iBuffSize(pSys->GetSendBufferSize()),
    iCurrBuffSize(0),
    EndJob(FALSE),
    ModeCount(2),
    m_bVIPPrinter(FALSE)
{

    int i = 0; // counter

    for (i = 0; i < MAX_PRINTMODES; i++)
    {
        pMode[i]=NULL;
    }

    //CompatiblePens[0] = BOTH_PENS;
    //for (i = 1; i < MAX_COMPATIBLE_PENS; i++)
    //{
    //    CompatiblePens[i] = DUMMY_PEN;
    //}

    if (IOMode.bDevID)
    {
       iMax_SLOW_POLL_Count = DEFAULT_SLOW_POLL_BIDI;
    }

    // Allocate memory for my send buffer
    pSendBuffer = NULL;
#ifdef APDK_BUFFER_SEND
    pSendBuffer = pSS->AllocMem(iBuffSize);
    CNEWCHECK(pSendBuffer);
#endif

#ifdef APDK_AUTODUPLEX
    bDuplexCapable = FALSE;
    m_bRotateBackPage = TRUE;
#endif

/*
 *  LaserJet printers do not send status via device id string. PJL is used to
 *  get status.
 *  REVISIT:    Do the same for Business Inkjets as well.
 */

    m_bStatusByPJL = FALSE;
    char    *tmpStr;
    if ((strstr ((char *) pSS->strDevID, "LaserJet")) &&
        (tmpStr = strstr ((char *) pSS->strDevID, "CMD:")) &&
        (tmpStr = strstr (tmpStr+4, "PJL")))
    {
        m_bStatusByPJL = TRUE;
    }

#if defined(APDK_FONTS_NEEDED)
    // create dummy font objects to be queried via EnumFont
    // these fonts used by all except DJ400

    for (i = 0; i<=MAX_PRINTER_FONTS; i++)
        fontarray[i] = NULL;


#ifdef APDK_COURIER
    fontarray[COURIER_INDEX] = new Courier();
    CNEWCHECK(fontarray[COURIER_INDEX]);
#endif
#ifdef APDK_CGTIMES
    fontarray[CGTIMES_INDEX] = new CGTimes();
    CNEWCHECK(fontarray[CGTIMES_INDEX]);
#endif
#ifdef APDK_LTRGOTHIC
    fontarray[LETTERGOTHIC_INDEX] = new LetterGothic();
    CNEWCHECK(fontarray[LETTERGOTHIC_INDEX]);
#endif
#ifdef APDK_UNIVERS
    fontarray[UNIVERS_INDEX] = new Univers();
    CNEWCHECK(fontarray[UNIVERS_INDEX]);
#endif

#endif  //
} //Printer


Printer::~Printer()
{
    if (pMode[GRAYMODE_INDEX])
    {
        if (pMode[GRAYMODE_INDEX]->dyeCount==3) // only happens when compgray map used
        {
            pSS->FreeMem((BYTE*) pMode[GRAYMODE_INDEX]->cmap.ulMap1 );
        }
    }

    for (int i = 0; i < MAX_PRINTMODES; i++)
    {
        if (pMode[i])
        {
            delete pMode[i];
        }
    }

#ifdef APDK_BUFFER_SEND
    if (pSendBuffer != NULL)
    {
        pSS->FreeMem(pSendBuffer);
    }
#endif

#ifdef APDK_COURIER
    delete fontarray[COURIER_INDEX];
#endif
#ifdef APDK_CGTIMES
    delete fontarray[CGTIMES_INDEX];
#endif
#ifdef APDK_LTRGOTHIC
    delete fontarray[LETTERGOTHIC_INDEX];
#endif
#ifdef APDK_UNIVERS
    delete fontarray[UNIVERS_INDEX];
#endif

} //~Printer


////////////////////////////////////////////////////////////////////////////
Compressor* Printer::CreateCompressor (unsigned int RasterSize)
{
    return new Mode9 (pSS, RasterSize);   // most printers use mode 9
}

////////////////////////////////////////////////////////////////////////////
Compressor* Printer::CreateBlackPlaneCompressor (unsigned int RasterSize,
                                                 BOOL bVIPPrinter)
{
    return new Mode9 (pSS, RasterSize, bVIPPrinter);   // most printers use mode 9
}

////////////////////////////////////////////////////////////////////////////
// ** API functions
//


DRIVER_ERROR Printer::Flush
(
    int FlushSize       // = MAX_RASTERSIZE
)
// flush possible leftover garbage --
// default call will send one (maximal) raster's worth of zeroes
{
    ASSERT(FlushSize > 0);
    ASSERT(FlushSize <= MAX_RASTERSIZE);

    DRIVER_ERROR err = NO_ERROR;
    int iChunkSize = 1000;
    BYTE *zero = NULL;

    // Try to allocate iChunkSize bytes of memory.  If we fail then cut size
    // in half and try again.  If we can't allocate even 10 bytes then bail
    // with a memory allocation error.  Flush is called at the beginning of
    // the print job - if there is no memory allocate now then we won't be
    // printing in any case.
    while (iChunkSize > 10 && zero == NULL)
    {
        zero = pSS->AllocMem(iChunkSize);
        if (zero == NULL)
        {
            iChunkSize /= 2;
        }
    }

    if (zero == NULL)
    {
        return ALLOCMEM_ERROR;
    }

    memset(zero, 0, iChunkSize);
    int iChunks = (FlushSize / iChunkSize) + 1;

    for (int i = 0; i < iChunks; i++)
    {
        if ((err = Send( zero, iChunkSize)) != NO_ERROR)
        {
            break;              // there was an error
        }
    }
    pSS->FreeMem(zero);         //break to here
    return err;
} //Flush


/*
 *  Function name: ParseError
 *
 *  Owner: Darrell Walker
 *
 *  Purpose:  To determine what error state the printer is in.
 *
 *  Called by: Send()
 *
 *  Parameters on entry: status_reg is the contents of the centronics
 *                      status register (at the time the error was
 *                      detected)
 *
 *  Parameters on exit: unchanged
 *
 *  Return Values: The proper DISPLAY_STATUS to reflect the printer
 *              error state.
 *
 */

DISPLAY_STATUS Printer::ParseError
(
    BYTE status_reg
)
{
    DBG1("Printer: parsing error info\n");

    DRIVER_ERROR err = NO_ERROR;
    BYTE DevIDBuffer[DevIDBuffSize];

    if(IOMode.bDevID)
    {
        // If a bi-di cable was plugged in and everything was OK, let's see if it's still
        // plugged in and everything is OK
        err = pSS->GetDeviceID(DevIDBuffer, DevIDBuffSize, TRUE);
        if(err != NO_ERROR)
        {
            // job was bi-di but now something's messed up, probably cable unplugged
            // or printer turned off during print job
            return DISPLAY_COMM_PROBLEM;
        }
    }

    // check for errors we can detect from the status reg

    if (IOMode.bStatus)
    {
        if ( DEVICE_IS_OOP(status_reg) )
        {
            DBG1("Out Of Paper\n");
            return DISPLAY_OUT_OF_PAPER;
        }

		if (DEVICE_PAPER_JAMMED(status_reg))
		{
			DBG1("Paper Jammed\n");
			return DISPLAY_PAPER_JAMMED;
		}
		if (DEVICE_IO_TRAP(status_reg))
        {
            DBG1("IO Trap\n");
            return DISPLAY_ERROR_TRAP;
        }
    }

    if (IOMode.bDevID)
    {
        if ( TopCoverOpen(status_reg) )
        {
            DBG1("Top Cover Open\n");
            return DISPLAY_TOP_COVER_OPEN;
        }

        // VerifyPenInfo will handle prompting the user
        //  if this is a problem
        VerifyPenInfo();
    }

    // don't know what the problem is-
    //  Is the PrinterAlive?
    if (pSS->PrinterIsAlive())  // <- This is only viable if bStatus is TRUE
    {
        iTotal_SLOW_POLL_Count += iMax_SLOW_POLL_Count;

        // -Note that iTotal_SLOW_POLL_Count is a multiple of
        //  iMax_SLOW_POLL_Count allowing us to check this
        //  on an absolute time limit - not relative to the number
        //  of times we happen to have entered ParseError.
        // -Also note that we have different thresholds for uni-di & bi-di.

        // REVISIT these counts - they are relative to the speed through
        // the send loop aren't they?  They may be too long!
        if(
            ((IOMode.bDevID == FALSE) && (iTotal_SLOW_POLL_Count >= 60)) ||
            ((IOMode.bDevID == TRUE)  && (iTotal_SLOW_POLL_Count >= 120))
          )
        {
            return DISPLAY_BUSY;
        }
        else
        {
            return DISPLAY_PRINTING;
        }
    }
    else
    {
        return DISPLAY_COMM_PROBLEM;
    }
} //ParseError

DRIVER_ERROR Printer::Encapsulate
(
    const RASTERDATA* InputRaster,
    BOOL bLastPlane
)
{
    DRIVER_ERROR    err;
    char            scratch[20];
    int             scratchLen;

    if (bLastPlane)
    {
		if (VIPPrinter())
		{
			if (InputRaster->rastersize[COLORTYPE_BLACK] != 0)
			{
				if (InputRaster->rastersize[COLORTYPE_COLOR] != 0)
				{
					scratchLen = sprintf (scratch, "\033*b%uV", InputRaster->rastersize[COLORTYPE_BLACK]);
					err = Send ((const BYTE*) scratch, scratchLen);
					if (err == NO_ERROR)
					{
						err = Send (InputRaster->rasterdata[COLORTYPE_BLACK], InputRaster->rastersize[COLORTYPE_BLACK]);
					}
					if (err == NO_ERROR)
					{
						scratchLen = sprintf (scratch, "\033*b%uW", InputRaster->rastersize[COLORTYPE_COLOR]);
						err = Send ((const BYTE*) scratch, scratchLen);
						if (err == NO_ERROR)
						{
							err = Send (InputRaster->rasterdata[COLORTYPE_COLOR], InputRaster->rastersize[COLORTYPE_COLOR]);
						}
					}
				}
				else
				{
					scratchLen = sprintf (scratch, "\033*b%uV", InputRaster->rastersize[COLORTYPE_BLACK]);
					err = Send ((const BYTE*) scratch, scratchLen);
					if (err == NO_ERROR)
					{
						err = Send (InputRaster->rasterdata[COLORTYPE_BLACK], InputRaster->rastersize[COLORTYPE_BLACK]);
						if (err == NO_ERROR)
						{
							scratchLen = sprintf (scratch, "\033*b%uW", 0);
							err = Send ((const BYTE*) scratch, scratchLen);
						}
					}
				}
			}
			else
			{
				scratchLen = sprintf (scratch, "\033*b%uV", 0);
				err = Send ((const BYTE*) scratch, scratchLen);
				if (err == NO_ERROR)
				{
					scratchLen = sprintf (scratch, "\033*b%uW", InputRaster->rastersize[COLORTYPE_COLOR]);
					err = Send ((const BYTE*) scratch, scratchLen);
					if (err == NO_ERROR && InputRaster->rastersize[COLORTYPE_COLOR] != 0)
					{
						err = Send (InputRaster->rasterdata[COLORTYPE_COLOR], InputRaster->rastersize[COLORTYPE_COLOR]);
					}
				}
			}
		}
		else
		{
			scratchLen = sprintf (scratch, "\033*b%uW", InputRaster->rastersize[COLORTYPE_COLOR]);
			err = Send ((const BYTE*) scratch, scratchLen);
			if (err == NO_ERROR)
			{
				err = Send (InputRaster->rasterdata[COLORTYPE_COLOR], InputRaster->rastersize[COLORTYPE_COLOR]);
			}
		}
    }
    else
    {
        scratchLen = sprintf (scratch, "\033*b%uV", InputRaster->rastersize[COLORTYPE_COLOR]);
		err = Send ((const BYTE*) scratch, scratchLen);
		if (err == NO_ERROR)
		{
			err = Send (InputRaster->rasterdata[COLORTYPE_COLOR], InputRaster->rastersize[COLORTYPE_COLOR]);
		}
    }
    return err;
}


DRIVER_ERROR Printer::Send
(
    const BYTE* pWriteBuff
)
{
    ASSERT(pWriteBuff);
    int len = strlen((const char*)pWriteBuff);
    return Send(pWriteBuff,len);
} //Send


/*
 *  Function name: Printer::Send
 *
 *  Owner: Darrell Walker
 *
 *  Purpose:  Encapsulate error handling generated by performing I/O
 *
 *  Called by:
 *
 *  Calls made: WritePort(), GetStatus(), BusyWait(), ParseError(),
 *              DisplayPrinterStatus(), YieldToSystem()
 *
 *  Parameters on entry: pJob is a pointer to the current JOBSTRUCT,
 *                      pWriteBuff is a pointer to the data the
 *                      caller wishes to send to the pritner,
 *                      wWriteCount is the number of bytes of
 *                      pWriteBuff to send
 *
 *  Parameters on exit: Unchanged
 *
 *  Side effects: Sends data to the printer, may update print dialog,
 *              may change pJob->InSlowPollMode,
 *              pJob->ErrorTerminationState
 *
 *  Return Values: NO_ERROR or JOB_CANCELED or IO_ERROR
 *
 *  Comments: (TJL) This routine now has functionality to attempt iterating
 *      through wWriteCount bytes of data (until we hit slow poll mode)
 *      before sending PCL cleanup code.  This still leaves the possibility of
 *      prematurely exiting with an incomplete raster, but gives I/O a fighting chance
 *      of completing the raster while also protecting from a bogged down slow poll phase
 *      which would prevent a timely exit from CANCEL.  A JobCanceled flag is used
 *      because JOB_CANCELED cannot be maintained by write_error through the while
 *      loop since it will be overwritten by next ToDevice.
 *
 */

DRIVER_ERROR Printer::Send
(
    const BYTE* pWriteBuff,
    DWORD dwWriteCount
)
{
    ASSERT(pWriteBuff);

    DRIVER_ERROR    write_error = NO_ERROR;
    DWORD           residual = 0;
    const BYTE *    pWritePos = NULL;
    BOOL            error_displayed = FALSE;
    BYTE            status_reg = 0;
    DISPLAY_STATUS  eDisplayStatus = DISPLAY_PRINTING;
    BOOL            JobCanceled = FALSE;  // see comments in function header

    // these are just an abstraction layer - buffered vs. non-buffered
    const BYTE *    pBuffer = pWriteBuff;
    DWORD           dwSendSize = dwWriteCount;

////////////////////////////////////////////////////////////////
#ifdef NULL_IO
    // test imaging speed independent of printer I/O, will not
    // send any data to the device
    return NO_ERROR;
#endif
////////////////////////////////////////////////////////////////

    if (ErrorTerminationState)  // don't try any more IO if we previously
    {
        return JOB_CANCELED;    // terminated in an error state
    }

    if (EndJob == FALSE && dwWriteCount == 0)    // don't bother processing
    {
        return NO_ERROR;                         //  an empty Send call
    }

#ifdef APDK_BUFFER_SEND
    DWORD BytesToWrite = dwWriteCount;

    do
    {
        // we should bypass the buffering for a large Send, but don't lose what may already be buffered
        if ( (BytesToWrite >= iBuffSize) && (iCurrBuffSize == 0) )
        {
            pBuffer = pWriteBuff+(dwWriteCount-BytesToWrite);
            dwSendSize = BytesToWrite;
            BytesToWrite = 0;  // this is checked for at the end of the outer loop
        }
        else // we will buffer this data
        {
            // if it'll fit then just copy everything to the buffer
            if (BytesToWrite <= DWORD(iBuffSize-iCurrBuffSize))
            {
                memcpy((void*)(pSendBuffer+iCurrBuffSize),
                    (void*)(pWriteBuff+(dwWriteCount-BytesToWrite)),BytesToWrite);
               iCurrBuffSize += BytesToWrite;
               BytesToWrite = 0;
            }
              else // copy what we can into the buffer, we'll get the rest later
            {
              memcpy((void*)(pSendBuffer+iCurrBuffSize),
                (void*)(pWriteBuff+(dwWriteCount-BytesToWrite)),
                iBuffSize-iCurrBuffSize);
                BytesToWrite -= (iBuffSize-iCurrBuffSize);
                iCurrBuffSize = iBuffSize;
            }

            // if the buffer is now full (ready-to-send) or if we're at
            // the end of the job, then send what we have in the buffer.
            // otherwise just break (the buffer isn't ready to send)
            if ( (EndJob == FALSE) && (iCurrBuffSize != iBuffSize) )
            {
                break;  // we're not ready to send yet
            }
            else // send this buffered data
            {
                pBuffer = pSendBuffer;
                dwSendSize = iCurrBuffSize;
            }
		}
#endif

    // initialize our 'residual' to the full send size
    residual = dwSendSize;

    if (bCheckForCancelButton &&
        (ulBytesSentSinceCancelCheck >= CANCEL_BUTTON_CHECK_THRESHOLD) )
    {
        ulBytesSentSinceCancelCheck = 0;
        char* tmpStr;
        BYTE DevIDBuffer[DevIDBuffSize];
        DRIVER_ERROR tmpErr = pSS->GetDeviceID(DevIDBuffer, DevIDBuffSize, TRUE);
        if(tmpErr)
            return tmpErr;
        BOOL cancelcheck=FALSE;

        if((tmpStr = strstr((char*)DevIDBuffer + 2,"CNCL")))
        {
            cancelcheck=TRUE;
        }
        else
        {
            int     iVersion = pSS->GetVIPVersion ();

            if((tmpStr = strstr((char*)DevIDBuffer + 2,";S:")) &&
                iVersion < 6)    // DJ990 devID style
            {
                // point to PrinterState
/*
 *				VIPVersion = DevID Version + 1 - DevID Version no is 2 bytes following ;S:
 *				Version 00 and 01 report 12 bytes for status info
 *				Version 02 and onwards, report two additional bytes before pen info
 */

				if (iVersion < 3)
				{
					tmpStr += 17;   // 3 for ";S:", 2 for version, 12 for features = 17
				}
				else if (iVersion < 5)
				{
					tmpStr += 19;	// 17 as above plus 1 for MaxPaperSize, 1 reserved = 19
				}
                else
                {
                    tmpStr += 23;   // Crystal added 4 more nibbles
                }

                BYTE b1=*tmpStr++;
                BYTE b2=*tmpStr++;
                if (((b1=='0') && (b2=='5')) && iVersion <= 5)     // 05 = cancel
                {
                    cancelcheck=TRUE;
                }
            }
        }
        if (cancelcheck)
        {
            // Since the printer is now just throwing data away, we can bail
            // immediately w/o worrying about finishing the raster so the
            // end-of-job FF will work.
            ErrorTerminationState = TRUE;
            pSS->DisplayPrinterStatus(DISPLAY_PRINTING_CANCELED);
            return JOB_CANCELED;
        }
    }

    // If we have nothing to send, we need to bail to avoid spurious dialogs
    //  at the end of the ::send function.  I'd prefer a solution where we don't
    //  bail from a while loop but in practice this shouldn't have any ill effects.
    if (residual <= 0)
    {
        return NO_ERROR;
    }

    while (residual > 0)    // while still data to send in this request
    {
        DWORD prev_residual = residual;     // WritePort overwrites request
                                            // count, need to save

        pWritePos = (const BYTE *) &(pBuffer[dwSendSize-residual]);
        write_error = pSS->ToDevice(pWritePos, &residual);

        // The following error handling code is recommended, but is not supported
        // on several current platforms for this reason:  when the printer buffer
        // fills and declines more data, the O/S returns a BUSY error in one form
        // or another.  The real solution is to allow the code below and have the
        // derived pSS->ToDevice functions catch and ignore any BUSY error - only
        // returning a real error to ::Send.  The current workaround here is that we
        // literally ignore all errors returned from the I/O system and ultimately catch
        // them after we've reached our slow poll limit via the slow poll logic below. -TL
//        if(write_error != NO_ERROR)
//        {
//            DBG1("IO_ERROR returned from ToDevice - ABORT!\n");
//            ErrorTerminationState = TRUE;
//            return write_error;
//        }

        write_error = NO_ERROR;
        eDisplayStatus = DISPLAY_PRINTING;
        if (residual == 0) // no more data to send this time
        {
            if (m_bStatusByPJL)
            {
                status_reg = (BYTE) DISPLAY_PRINTING;
                eDisplayStatus = ParseError (status_reg);
                if (eDisplayStatus != DISPLAY_PRINTING)
                    write_error = IO_ERROR;
            }

            // did we want to transition out of slow poll?
            if ( (InSlowPollMode != 0) &&
                (prev_residual > MIN_XFER_FOR_SLOW_POLL) )
            {
                InSlowPollMode = 0;
                iTotal_SLOW_POLL_Count = 0;
            }
            if (write_error == NO_ERROR)
                break;  // out of while loop
        }


        // if we are here, WritePort() was not able to
        // send the full request so start looking for errors

        // decide whether we've waited long enough to check for an error
        if (InSlowPollMode > iMax_SLOW_POLL_Count )
        {
            if (JobCanceled == TRUE)
            // Well, I/O didn't finish in time to meet the CANCEL request and avoid
            // the SlowPoll threshold.  We have to bail for prompt cancel response.
            {
                DBG1("Send(SlowPoll): Premature return w/ JOB_CANCELED\n");
                ErrorTerminationState = TRUE;
                return JOB_CANCELED;
            }

            DBG1("Printer slow poll times exceeded\n");
            // reset counter so we will not pop it next time
            InSlowPollMode = 1;
            write_error = IO_ERROR;
        }
        else
        {
            write_error = NO_ERROR;
        }

        // are we in slow poll mode?  If so, track our count
        if ( (prev_residual - residual) <= MIN_XFER_FOR_SLOW_POLL)
        {
            InSlowPollMode++;

#if defined(DEBUG) && (DBG_MASK & DBG_LVL1)
            if (InSlowPollMode == 1)
            {
                printf("entering slow poll mode\n");
            }
            else
            {
                printf("still in slow poll mode, count = %d\n",
                                    InSlowPollMode);
            }
#endif
            // give the printer some time to process
            if (pSS->BusyWait((DWORD)200) == JOB_CANCELED)
            {
                DBG1("Send: JOB_CANCELED\n");
                JobCanceled = TRUE;
                pSS->DisplayPrinterStatus(DISPLAY_PRINTING_CANCELED);
            }
        }
        else
        {
            // still busy, but taking enough data that
            // we are not in slow poll mode
            DBG1("Partial Send but not slow poll mode\n");
            InSlowPollMode = 0;
            iTotal_SLOW_POLL_Count = 0;
        }


        if (write_error != NO_ERROR || (m_bStatusByPJL && eDisplayStatus != DISPLAY_PRINTING))
        // slow poll times exceeded
        // the printer isn't taking data so let's see what's wrong...
        {
            DBG1("Parsing possible error state...\n");
            error_displayed = TRUE;

            if (m_bStatusByPJL)
            {
                status_reg = (BYTE) eDisplayStatus;
            }
            else
            {
                // go get the status of the printer
                if (IOMode.bStatus)
                {
                    pSS->GetStatusInfo(&status_reg);
                }

                // determine the error
                eDisplayStatus = ParseError(status_reg);
            }

            switch (eDisplayStatus)
            {
                case DISPLAY_PRINTING_CANCELED:

                        // user canceled in an error state,
                        // so we don't want to attempt any
                        // further communication with the printer

                        ErrorTerminationState = TRUE;
                        pSS->DisplayPrinterStatus(eDisplayStatus);
                        return JOB_CANCELED;

                case DISPLAY_ERROR_TRAP:
                case DISPLAY_COMM_PROBLEM:
                        // these are unrecoverable cases
                        // don't let any more of this job
                        // be sent to the printer

                        ErrorTerminationState = TRUE;
                        pSS->DisplayPrinterStatus(eDisplayStatus);

                        // wait for user to cancel the job,
                        // otherwise they might miss the
                        // error message
                        while (pSS->BusyWait(500) != JOB_CANCELED)
                        {
                                // nothing....
                            ;
                        }
                        return IO_ERROR;

                case DISPLAY_TOP_COVER_OPEN:

                    pSS->DisplayPrinterStatus(DISPLAY_TOP_COVER_OPEN);

                    // wait for top cover to close
                    while ( eDisplayStatus == DISPLAY_TOP_COVER_OPEN)
                    {
                        if (pSS->BusyWait((DWORD)500) == JOB_CANCELED)
                        // although we'll leave an incomplete job in the printer,
                        // we really need to bail for proper CANCEL response.
                        {
                            ErrorTerminationState = TRUE;
                            return JOB_CANCELED;
                        }

                        if (m_bStatusByPJL)
                        {
                            status_reg = (BYTE) eDisplayStatus;
                        }
                        else
                        {
                            if (IOMode.bStatus)
                            {
                                pSS->GetStatusInfo(&status_reg);
                            }
                        }

                        eDisplayStatus = ParseError(status_reg);
                    }

                    pSS->DisplayPrinterStatus(DISPLAY_PRINTING);

                    // Wait for printer to come back online
                    if (pSS->BusyWait((DWORD)1000) == JOB_CANCELED)
                    // Since the top_cover error HAS been handled, we have
                    // the opportunity to finish the raster before we hit
                    // the next slowpoll threshold.
                    {
                        DBG1("Send: JOB_CANCELED\n");
                        JobCanceled = TRUE;
                        pSS->DisplayPrinterStatus(DISPLAY_PRINTING_CANCELED);
                    }

                    break;

                case DISPLAY_OUT_OF_PAPER:
				case DISPLAY_PHOTOTRAY_MISMATCH:
				{
					DISPLAY_STATUS	tmpStatus = eDisplayStatus;
                    pSS->DisplayPrinterStatus(eDisplayStatus);

                    // wait for the user to add paper and
                    // press resume
                    while ( eDisplayStatus == tmpStatus)
                    {
                        if (pSS->BusyWait((DWORD)500) == JOB_CANCELED)
                        // although we'll leave an incomplete job in the printer,
                        // we really need to bail for proper CANCEL response.
                        {
                            ErrorTerminationState = TRUE;
                            return JOB_CANCELED;
                        }

                        if (m_bStatusByPJL)
                        {
                            status_reg = (BYTE) eDisplayStatus;
                        }
                        else
                        {
                            if (IOMode.bStatus)
                            {
                                pSS->GetStatusInfo(&status_reg);
                            }
                        }

                        eDisplayStatus = ParseError(status_reg);
                    }

                    pSS->DisplayPrinterStatus(DISPLAY_PRINTING);

                    break;
				}

                case DISPLAY_BUSY:

                    if (pSS->BusyWait((DWORD)5000) == JOB_CANCELED)
                    {
                        ErrorTerminationState = TRUE;
                        return JOB_CANCELED;
                    }

                    pSS->DisplayPrinterStatus(DISPLAY_BUSY);

                    break;

                // other cases need no special handling, display
                // the error and try to continue
                default:
                    pSS->DisplayPrinterStatus(eDisplayStatus);
                    break;
            }// switch
        } // if

        // give printer time to digest the data and check for 'cancel' before
        // the next iteration of the loop
        if (pSS->BusyWait((DWORD)100) == JOB_CANCELED)
        {
            DBG1("Send: JOB_CANCELED\n");
            JobCanceled = TRUE;
            pSS->DisplayPrinterStatus(DISPLAY_PRINTING_CANCELED);
        }

    }   // while (residual > 0)

    // The above BusyWait's will not be checked if residual gets sent the first time, every time
    // because we 'break' at that point for efficiency.  However, we want to make sure we check
    // at least once for a CANCEL event for timely job-cancel response.
    if (pSS->BusyWait((DWORD)0) == JOB_CANCELED)
    {
        JobCanceled = TRUE;
        pSS->DisplayPrinterStatus(DISPLAY_PRINTING_CANCELED);
    }

#ifdef APDK_BUFFER_SEND
    // Our buffer is now empty: reset the size so concurrent writes start at the beginning
        iCurrBuffSize = 0;

    } while (BytesToWrite > 0);
#endif

    // restore my JOB_CANCELED error
    if (JobCanceled == TRUE)
    {
        DBG1("Send: Clean return w/ JOB_CANCELED\n");
        // ensure that display still says we're cancelling
        pSS->DisplayPrinterStatus(DISPLAY_PRINTING_CANCELED);
        return JOB_CANCELED;
    }
    else
    {
        // ensure any error message has been cleared
        pSS->DisplayPrinterStatus(DISPLAY_PRINTING);
        if (bCheckForCancelButton)
        {
            ulBytesSentSinceCancelCheck += dwWriteCount;
        }
        return NO_ERROR;
    }
} //Send


BOOL Printer::TopCoverOpen
(
    BYTE /*status_reg*/
)
{
    char * pStr;
    BYTE bDevIDBuff[DevIDBuffSize];

    if(IOMode.bDevID == FALSE)
    {
        return FALSE;
    }

    DRIVER_ERROR err = pSS->GetDeviceID(bDevIDBuff, DevIDBuffSize, TRUE);
    if (err != NO_ERROR)
    {
        return FALSE;
    }

    if( (pStr=strstr((char*)bDevIDBuff+2,"VSTATUS:")) ) //  find the VSTATUS area
    {
        pStr+=8;
        // now parse VSTATUS parameters
        // looking for UP for open, DN for closed
        if (strstr((char*)pStr,"UP"))
        {
            return TRUE;
        }
        if (strstr((char*)pStr,"DN"))
        {
            return FALSE;
        }

        DBG1("didn't find UP or DN!!\n");
        return FALSE;
    }
    else
    if (( pStr = strstr ((char*) bDevIDBuff+2, ";S")))
    {
        if ( (*(pStr+5) == '9') )
        {
            return TRUE;
        }
        else
        {
            return FALSE;
        }
    }
    else
    {
        return FALSE;  // if we can't find VSTATUS or binary status field, assume top is not open
    }
} //TopCoverOpen


DRIVER_ERROR Printer::CleanPen()
{
    DBG1("Printer::ClearPen() called\n");

    DWORD length=sizeof(PEN_CLEAN_PML);
    return pSS->ToDevice(PEN_CLEAN_PML,&length);
} //CleanPen


PrintMode* Printer::GetMode
(
    unsigned int index
)
{
    if (index >= ModeCount)
    {
        return NULL;
    }

    return pMode[index];
} //GetMode


PrintMode::PrintMode
(
    uint32_t *map1,
    uint32_t *map2
)
{
    pmQuality = QUALITY_NORMAL;
    pmMediaType = MEDIA_PLAIN;
    pmColor = COLOR;
    int iCount;

    cmap.ulMap1 = map1;
    cmap.ulMap2 = map2;
    cmap.ulMap3 = NULL;

    BaseResX = BaseResY = TextRes = 300;
    MixedRes= FALSE;

    // default setting
    for (iCount = 0; iCount < MAXCOLORPLANES; iCount++)
    {
        ResolutionX[iCount] = BaseResX;
        ResolutionY[iCount] = BaseResY;
        ColorDepth[iCount] = 1;
    }

    medium = mediaPlain;
    theQuality = qualityNormal;
    dyeCount=4;

    Config.bResSynth = TRUE;

#if defined(APDK_VIP_COLORFILTERING)
    Config.bErnie = FALSE;
#endif

    Config.bPixelReplicate = TRUE;
    Config.bColorImage = TRUE;
    Config.bCompress = TRUE;
    Config.eHT = FED;
    BlackFEDTable = GetHTBinary();
    ColorFEDTable = GetHTBinary();


    // set for most common cases
    bFontCapable = TRUE;
    CompatiblePens[0] = BOTH_PENS;
    for(iCount = 1; iCount < MAX_COMPATIBLE_PENS; iCount++)
    {
        CompatiblePens[iCount] = DUMMY_PEN;
    }

#ifdef APDK_AUTODUPLEX
    bDuplexCapable = FALSE;
    DuplexMode = DUPLEXMODE_NONE;
#endif

} //PrintMode


GrayMode::GrayMode
(
    uint32_t *map
) :
    PrintMode(map)
// grayscale uses econo, 300, 1 bit
{
    ColorDepth[K] = 1;
    dyeCount = 1;
    CompatiblePens[1] = BLACK_PEN;  // accept either black or both
    pmColor = GREY_K;
} //GrayMode


CMYGrayMode::CMYGrayMode
(
    uint32_t *map
) :
    GrayMode(map)
{
    CompatiblePens[1] = COLOR_PEN;  // accept either color or both
    dyeCount = 3;
    pmColor = GREY_CMY;
} //CMYGrayMode


KCMYGrayMode::KCMYGrayMode
(
    uint32_t *map
) :
    GrayMode(map)
{
    dyeCount = 4;
    pmColor = GREY_CMY;
} //KCMYGrayMode


DRIVER_ERROR Printer::SetPenInfo
(
    char*& pStr,
    BOOL QueryPrinter
)
{
    DRIVER_ERROR err;

    if (QueryPrinter)
    {
        // read the DevID into the stored strDevID
        err = pSS->GetDeviceID(pSS->strDevID, DevIDBuffSize, TRUE);
        ERRCHECK;

        // update the static values of the pens
        err = pSS->DR->ParseDevIDString((const char*)(pSS->strDevID),pSS->strModel,&(pSS->VIPVersion),pSS->strPens);
        ERRCHECK;

        if ((pStr = strstr((char*)pSS->strDevID,"VSTATUS:")))   //  find the VSTATUS area
        {
            pStr += 8;
        }
        else if ((pStr = strstr((char*)pSS->strDevID, ";S:00")))  // binary encoded device ID status (version 0)
        {
            pStr += 19;     // get to the number of pens field - 12 byte feature field
        }
        else if ((pStr = strstr ((char *) pSS->strDevID, ";S:01")))
        {
            pStr += 19;     // same as version 00
        }
        else if ((pStr = strstr((char*)pSS->strDevID, ";S:02")))  // binary encoded device ID status (version 2)
        {
//            pStr += 21;     // get to the number of pens field - 14 byte feature field
            pStr += 19;     // same as version 00 - see registry.cpp
        }
        else if ((pStr = strstr((char*)pSS->strDevID, ";S:03")))  // binary encoded device ID status (version 3)
        {
            pStr += 21;     // get to the number of pens field - 14 byte feature field
        }
        else if ((pStr = strstr((char*)pSS->strDevID, ";S:04")))  // binary encoded device ID status (version 3)
        {
            pStr += 25;     // get to the number of pens field - 18 byte feature field
        }
        else if ((pSS->GetVIPVersion ()) > 5)
        {
            return NO_ERROR;
        }
        else
        {
            TRACE("Printer::SetPenInfo - Unsupported DeviceID %s.\n", pSS->strDevID);
/*            ASSERT (0);  // you must have a printer with a new version that is not supported yet! */
            return BAD_DEVICE_ID;  // - code should never reach this point
        }
    }
    else
    {
        pStr = pSS->strPens;
    }
    return NO_ERROR;
} //SetPenInfo


BOOL PrintMode::Compatible
(
    PEN_TYPE pens
)
{
    BOOL res = FALSE;
    for (int i=0; i < MAX_COMPATIBLE_PENS; i++)
    {
        if (CompatiblePens[i] == pens)
        {
            res = TRUE;
        }
    }
    return res;
} //Compatible



DRIVER_ERROR Printer::SetPens
(
    PEN_TYPE eNewPen
)
{
    ASSERT(eNewPen <= MAX_PEN_TYPE);
    // We are (probably)in unidi.  We have to trust they know what pens are
    // in the printer.  We'll let them set any pen set (even if this printer
    // doesn't support it.  We'll find out during SelectPrintMode
    if (eNewPen <= MAX_PEN_TYPE)
    {
        ePen = eNewPen;
        return NO_ERROR;
    }
    else
    {
        return UNSUPPORTED_PEN;
    }
} //SetPens

void PrintMode::GetValues
(
    QUALITY_MODE& eQuality,
    MEDIATYPE& eMedia,
    COLORMODE& eColor,
    BOOL& bDeviceText
)
{
    if (&eQuality != NULL)
    {
        eQuality = pmQuality;
    }

    if (&eMedia != NULL)
    {
        eMedia = pmMediaType;
    }

    if (&eColor != NULL)
    {
        eColor = pmColor;
    }

    if (&bDeviceText != NULL)
    {
        bDeviceText = bFontCapable;
    }
} //GetValues


void Printer::SetPMIndices()
{
    for (unsigned int i=0; i < ModeCount; i++)
    {
        pMode[i]->myIndex = i;
    }
} //SetPMIndices

APDK_END_NAMESPACE