QtopiaPrintEnginePrivate Class Reference

#include <qprintengine_qws_p.h>

Inheritance diagram for QtopiaPrintEnginePrivate:

Public Functions
void	initialize ()
QPaintEngine *	paintEngine ()
	QtopiaPrintEnginePrivate (QPrinter::PrinterMode m)
void	writeG3BlackRun (int len)
void	writeG3Code (int code, int bits)
void	writeG3EOL ()
void	writeG3FaxHeader ()
void	writeG3FaxPage ()
int	writeG3IFDEntry (int tag, int type, int count, int value)
void	writeG3WhiteRun (int len)
	~QtopiaPrintEnginePrivate ()
Public Functions inherited from QPaintEnginePrivate
void	drawBoxTextItem (const QPointF &p, const QTextItemInt &ti)
	QPaintEnginePrivate ()
void	setSystemTransform (const QTransform &xform)
void	setSystemViewport (const QRegion &region)
virtual void	systemStateChanged ()
void	transformSystemClip ()
virtual	~QPaintEnginePrivate ()

Public Variables
QPaintEngine *	_paintEngine
QtopiaPrintBuffer	buffer
bool	collateCopies
QPrinter::ColorMode	colorMode
QString	creator
QString	docName
bool	fullPage
int	ifdPatch
QPrinter::PrinterMode	mode
int	numCopies
QPrinter::Orientation	orientation
QString	outputFileName
bool	outputToFile
QImage *	pageImage
int	pageNumber
QPrinter::PageOrder	pageOrder
QPrinter::PaperSize	paperSize
QPrinter::PaperSource	paperSource
int	partialBits
int	partialByte
QString	printerName
QPrinter::PrinterState	printerState
QString	printProgram
int	resolution
Public Variables inherited from QPaintEnginePrivate
QWidget *	currentClipWidget
uint	hasSystemTransform: 1
uint	hasSystemViewport: 1
QPaintDevice *	pdev
QPaintEngine *	q_ptr
QRegion	systemClip
QRect	systemRect
QTransform	systemTransform
QRegion	systemViewport

Detailed Description

Definition at line 137 of file qprintengine_qws_p.h.

Constructors and Destructors

QtopiaPrintEnginePrivate()

QtopiaPrintEnginePrivate::QtopiaPrintEnginePrivate ( QPrinter::PrinterMode  m )

inline

Definition at line 141 of file qprintengine_qws_p.h.

                                                    :
    mode(m),
    printerState(QPrinter::Idle),
    orientation(QPrinter::Portrait),
    paperSize(QPrinter::A4),
    pageOrder(QPrinter::FirstPageFirst),
    colorMode(QPrinter::GrayScale),
    paperSource(QPrinter::OnlyOne),
        resolution(QT_QWS_PRINTER_DEFAULT_DPI),
        _paintEngine(0),
    numCopies(1),
        outputToFile(false),
        fullPage(false),
        collateCopies(false),
    pageNumber(0),
    pageImage(0),
    partialByte(0),
    partialBits(0)
    {
    }

~QtopiaPrintEnginePrivate()

QtopiaPrintEnginePrivate::~QtopiaPrintEnginePrivate

(

)

Definition at line 378 of file qprintengine_qws.cpp.

{
    if ( pageImage )
    delete pageImage;
}

Functions

initialize()

void QtopiaPrintEnginePrivate::initialize

(

)

Definition at line 384 of file qprintengine_qws.cpp.

{
    _paintEngine = 0;
}

paintEngine()

QPaintEngine * QtopiaPrintEnginePrivate::paintEngine

(

)

Definition at line 389 of file qprintengine_qws.cpp.

{
    if (!_paintEngine)
        _paintEngine = new QRasterPaintEngine(pageImage);
    return _paintEngine;
}

writeG3BlackRun()

void QtopiaPrintEnginePrivate::writeG3BlackRun

(

int

len

)

Definition at line 712 of file qprintengine_qws.cpp.

{
    static struct {
    unsigned short code;
    unsigned short bits;
    } blackCodes[64 + 27] = {
    {0x0037, 10},       // 0
    {0x0002, 3},
    {0x0003, 2},
    {0x0002, 2},
    {0x0003, 3},
    {0x0003, 4},
    {0x0002, 4},
    {0x0003, 5},
    {0x0005, 6},        // 8
    {0x0004, 6},
    {0x0004, 7},
    {0x0005, 7},
    {0x0007, 7},
    {0x0004, 8},
    {0x0007, 8},
    {0x0018, 9},
    {0x0017, 10},       // 16
    {0x0018, 10},
    {0x0008, 10},
    {0x0067, 11},
    {0x0068, 11},
    {0x006C, 11},
    {0x0037, 11},
    {0x0028, 11},
    {0x0017, 11},       // 24
    {0x0018, 11},
    {0x00CA, 12},
    {0x00CB, 12},
    {0x00CC, 12},
    {0x00CD, 12},
    {0x0068, 12},
    {0x0069, 12},
    {0x006A, 12},       // 32
    {0x006B, 12},
    {0x00D2, 12},
    {0x00D3, 12},
    {0x00D4, 12},
    {0x00D5, 12},
    {0x00D6, 12},
    {0x00D7, 12},
    {0x006C, 12},       // 40
    {0x006D, 12},
    {0x00DA, 12},
    {0x00DB, 12},
    {0x0054, 12},
    {0x0055, 12},
    {0x0056, 12},
    {0x0057, 12},
    {0x0064, 12},       // 48
    {0x0065, 12},
    {0x0052, 12},
    {0x0053, 12},
    {0x0024, 12},
    {0x0037, 12},
    {0x0038, 12},
    {0x0027, 12},
    {0x0028, 12},       // 56
    {0x0058, 12},
    {0x0059, 12},
    {0x002B, 12},
    {0x002C, 12},
    {0x005A, 12},
    {0x0066, 12},
    {0x0067, 12},
    {0x000F, 10},       // Make up codes: 64
    {0x00C8, 12},       // 128
    {0x00C9, 12},       // 192
    {0x005B, 12},       // 256
    {0x0033, 12},       // 320
    {0x0034, 12},       // 384
    {0x0035, 12},       // 448
    {0x006C, 13},       // 512
    {0x006D, 13},       // 576
    {0x004A, 13},       // 640
    {0x004B, 13},       // 704
    {0x004C, 13},       // 768
    {0x004D, 13},       // 832
    {0x0072, 13},       // 896
    {0x0073, 13},       // 960
    {0x0074, 13},       // 1024
    {0x0075, 13},       // 1088
    {0x0076, 13},       // 1152
    {0x0077, 13},       // 1216
    {0x0052, 13},       // 1280
    {0x0053, 13},       // 1344
    {0x0054, 13},       // 1408
    {0x0055, 13},       // 1472
    {0x005A, 13},       // 1536
    {0x005B, 13},       // 1600
    {0x0064, 13},       // 1664
    {0x0065, 13},       // 1728
    };
    if ( len >= 64 ) {
    int index = 63 + (len >> 6);
    writeG3Code( blackCodes[index].code, blackCodes[index].bits );
    len &= 63;
    }
    writeG3Code( blackCodes[len].code, blackCodes[len].bits );
}

writeG3Code()

void QtopiaPrintEnginePrivate::writeG3Code	(	int	code,
		int	bits
	)

Definition at line 596 of file qprintengine_qws.cpp.

{
    partialByte = ( ( partialByte << bits ) | code );
    partialBits += bits;
    while ( partialBits >= 8 ) {
    partialBits -= 8;
    buffer.append( (char)( partialByte >> partialBits ) );
    }
}

writeG3EOL()

void QtopiaPrintEnginePrivate::writeG3EOL

(

)

Definition at line 818 of file qprintengine_qws.cpp.

{
    int bitToPad;
    if ( partialBits <= 4 ) {
        bitToPad = 4 - partialBits;
    } else {
        bitToPad = 8 - partialBits + 4;
    }

    partialByte = ((partialByte << (bitToPad + 12)) | 0x0001);
    partialBits += bitToPad + 12;

    while ( partialBits >= 8 ) {
        partialBits -= 8;
        buffer.append( (char)(partialByte >> partialBits ) );
    }
//    writeG3Code( 0x0001, 12 );
}

writeG3FaxHeader()

void QtopiaPrintEnginePrivate::writeG3FaxHeader

(

)

Definition at line 396 of file qprintengine_qws.cpp.

{
    // Write the TIFF file magic number (little-endian TIFF).
    buffer.append( (char)'I' );
    buffer.append( (char)'I' );
    buffer.append( (char)42 );
    buffer.append( (char)0 );

    // Leave a place-holder for the IFD offset of the first page.
    ifdPatch = buffer.size();
    buffer.append( (int)0 );
}

writeG3FaxPage()

void QtopiaPrintEnginePrivate::writeG3FaxPage

(

)

Definition at line 443 of file qprintengine_qws.cpp.

{
    // Pad the image file to a word boundary, just in case.
    buffer.pad();

    // Back-patch the IFD link for the previous page.
    buffer.patch( ifdPatch, buffer.size() );

    // Output the contents of the IFD for this page (these must be
    // in ascending order of tag value).
    buffer.append( (short)19 );     // Number of IFD entries.
    writeG3IFDEntry( TIFF_IFD_NEW_SUB_FILE_TYPE, TIFF_TYPE_LONG, 1, 2 );
    writeG3IFDEntry( TIFF_IFD_IMAGE_WIDTH, TIFF_TYPE_LONG, 1, TIFF_FAX_WIDTH );
    writeG3IFDEntry
    ( TIFF_IFD_IMAGE_LENGTH, TIFF_TYPE_LONG, 1, pageImage->height() );
    writeG3IFDEntry( TIFF_IFD_BITS_PER_SAMPLE, TIFF_TYPE_SHORT, 1, 1 );
    writeG3IFDEntry( TIFF_IFD_COMPRESSION, TIFF_TYPE_SHORT, 1, 3 );
    writeG3IFDEntry( TIFF_IFD_PHOTOMETRIC_INTERP, TIFF_TYPE_SHORT, 1, 0 );
    writeG3IFDEntry( TIFF_IFD_FILL_ORDER, TIFF_TYPE_SHORT, 1, 1 );
    int stripOffsets =
    writeG3IFDEntry( TIFF_IFD_STRIP_OFFSETS, TIFF_TYPE_LONG, 1, 0 );
    writeG3IFDEntry( TIFF_IFD_ORIENTATION, TIFF_TYPE_SHORT, 1, 1 );
    writeG3IFDEntry( TIFF_IFD_SAMPLES_PER_PIXEL, TIFF_TYPE_SHORT, 1, 1 );
    writeG3IFDEntry
    ( TIFF_IFD_ROWS_PER_STRIP, TIFF_TYPE_LONG, 1, pageImage->height() );
    int stripBytes = writeG3IFDEntry
    ( TIFF_IFD_STRIP_BYTE_COUNTS, TIFF_TYPE_LONG, 1, 0 );
    int xres =
    writeG3IFDEntry( TIFF_IFD_X_RESOLUTION, TIFF_TYPE_RATIONAL, 1, 0 );
    int yres =
    writeG3IFDEntry( TIFF_IFD_Y_RESOLUTION, TIFF_TYPE_RATIONAL, 1, 0 );
    writeG3IFDEntry( TIFF_IFD_PLANAR_CONFIG, TIFF_TYPE_SHORT, 1, 1 );
    writeG3IFDEntry( TIFF_IFD_T4_OPTIONS, TIFF_TYPE_LONG, 1, 2 );
    writeG3IFDEntry( TIFF_IFD_RESOLUTION_UNIT, TIFF_TYPE_SHORT, 1, 2 );
    writeG3IFDEntry( TIFF_IFD_PAGE_NUMBER, TIFF_TYPE_SHORT, 2,
             TIFF_SHORT_PAIR( pageNumber, 0 ) );
    writeG3IFDEntry( TIFF_IFD_CLEAN_FAX_DATA, TIFF_TYPE_SHORT, 1, 0 );

    // Leave a place-holder for the IFD offset of the next page.
    ifdPatch = buffer.size();
    buffer.append( (int)0 );

    // Output the X and Y resolutions, as rational values (usually 200/1).
    buffer.patch( xres, buffer.size() );
    buffer.append( (int)resolution );
    buffer.append( (int)1 );
    buffer.patch( yres, buffer.size() );
    buffer.append( (int)resolution );
    buffer.append( (int)1 );

    // We are now at the start of the image data - set the strip offset.
    int start = buffer.size();
    buffer.patch( stripOffsets, start );

    // Output the image data.
    int width = pageImage->width();
    QImage::Format imageFormat = pageImage->format();
    for ( int y = 0; y < pageImage->height(); ++y ) {
    unsigned char *scan = pageImage->scanLine(y);
    int prev, pixel, len;
        writeG3EOL();
    prev = 0;
    len = 0;

        uint currentColor = qRgb(255, 255, 255); // start with white

    for ( int x = 0; x < width && x < TIFF_FAX_WIDTH; ++x ) {
            if ( imageFormat == QImage::Format_RGB32 ) {
                // read color of the current pixel
                uint *p = (uint *)scan + x;

                if ( *p == currentColor ) { // if it is the same color
                    len++; // imcrement length
                } else { // otherwise write color into the buffer
                    if ( len > 0 ) {
                        if ( currentColor == qRgb(0, 0, 0) )
                            writeG3BlackRun( len );
                        else
                            writeG3WhiteRun( len );
                    }
                    // initialise length and color;
                    len = 1;
                    currentColor = *p;
                }
            } else if ( imageFormat == QImage::Format_Mono ) {
                pixel = ((scan[x >> 3] & (1 << (x & 7))) != 0);
                if ( pixel != prev ) {
            if ( prev ) {
                writeG3BlackRun( len );
                    } else {
                    writeG3WhiteRun( len );
            }
            prev = pixel;
            len = 1;
            } else {
            ++len;
            }
            }
    }

        if ( imageFormat == QImage::Format_RGB32 ) {
            // Output the last run on the line, and pad to TIFF_FAX_WIDTH.
            if ( len != 0 ) {
                if ( currentColor == qRgb(0, 0, 0) )
                    writeG3BlackRun( len );
                else
                    writeG3WhiteRun( len );
            }
            if ( width < TIFF_FAX_WIDTH )
                writeG3WhiteRun( TIFF_FAX_WIDTH - width );
        } else if ( imageFormat == QImage::Format_Mono ) {
            if ( len != 0 ) {
            if ( prev ) {
            writeG3BlackRun( len );
            if ( width < TIFF_FAX_WIDTH ) {
                writeG3WhiteRun( TIFF_FAX_WIDTH - width );
            }
            } else {
            if ( width < TIFF_FAX_WIDTH ) {
                writeG3WhiteRun( len + ( TIFF_FAX_WIDTH - width ) );
            } else {
                writeG3WhiteRun( len );
            }
            }
        }
        }
    }

    // Flush the last partial byte, which is padded with zero fill bits.
    if ( partialBits > 0 ) {
    buffer.append( (char)( partialByte << ( 8 - partialBits ) ) );
    partialByte = 0;
    partialBits = 0;
    }

    // end of page add six EOLs
    for ( int i = 0; i < 6; i++ )
        writeG3EOL();

    // Update the byte count for the image data strip.
    buffer.patch( stripBytes, buffer.size() - start );
}

writeG3IFDEntry()

int QtopiaPrintEnginePrivate::writeG3IFDEntry	(	int	tag,
		int	type,
		int	count,
		int	value
	)

Definition at line 587 of file qprintengine_qws.cpp.

Referenced by writeG3FaxPage().

{
    buffer.append( (short)tag );
    buffer.append( (short)type );
    buffer.append( count );
    buffer.append( value );
    return buffer.size() - 4;    // Offset of the value for back-patching.
}

writeG3WhiteRun()

void QtopiaPrintEnginePrivate::writeG3WhiteRun

(

int

len

)

Definition at line 606 of file qprintengine_qws.cpp.

{
    static struct {
    unsigned short code;
    unsigned short bits;
    } whiteCodes[64 + 27] = {
    {0x0035, 8},        // 0
    {0x0007, 6},
    {0x0007, 4},
    {0x0008, 4},
    {0x000B, 4},
    {0x000C, 4},
    {0x000E, 4},
    {0x000F, 4},
    {0x0013, 5},        // 8
    {0x0014, 5},
    {0x0007, 5},
    {0x0008, 5},
    {0x0008, 6},
    {0x0003, 6},
    {0x0034, 6},
    {0x0035, 6},
    {0x002A, 6},        // 16
    {0x002B, 6},
    {0x0027, 7},
    {0x000C, 7},
    {0x0008, 7},
    {0x0017, 7},
    {0x0003, 7},
    {0x0004, 7},
    {0x0028, 7},        // 24
    {0x002B, 7},
    {0x0013, 7},
    {0x0024, 7},
    {0x0018, 7},
    {0x0002, 8},
    {0x0003, 8},
    {0x001A, 8},
    {0x001B, 8},        // 32
    {0x0012, 8},
    {0x0013, 8},
    {0x0014, 8},
    {0x0015, 8},
    {0x0016, 8},
    {0x0017, 8},
    {0x0028, 8},
    {0x0029, 8},        // 40
    {0x002A, 8},
    {0x002B, 8},
    {0x002C, 8},
    {0x002D, 8},
    {0x0004, 8},
    {0x0005, 8},
    {0x000A, 8},
    {0x000B, 8},        // 48
    {0x0052, 8},
    {0x0053, 8},
    {0x0054, 8},
    {0x0055, 8},
    {0x0024, 8},
    {0x0025, 8},
    {0x0058, 8},
    {0x0059, 8},        // 56
    {0x005A, 8},
    {0x005B, 8},
    {0x004A, 8},
    {0x004B, 8},
    {0x0032, 8},
    {0x0033, 8},
    {0x0034, 8},
    {0x001B, 5},        // Make up codes: 64
    {0x0012, 5},        // 128
    {0x0017, 6},        // 192
    {0x0037, 7},        // 256
    {0x0036, 8},        // 320
    {0x0037, 8},        // 384
    {0x0064, 8},        // 448
    {0x0065, 8},        // 512
    {0x0068, 8},        // 576
    {0x0067, 8},        // 640
    {0x00CC, 9},        // 704
    {0x00CD, 9},        // 768
    {0x00D2, 9},        // 832
    {0x00D3, 9},        // 896
    {0x00D4, 9},        // 960
    {0x00D5, 9},        // 1024
    {0x00D6, 9},        // 1088
    {0x00D7, 9},        // 1152
    {0x00D8, 9},        // 1216
    {0x00D9, 9},        // 1280
    {0x00DA, 9},        // 1344
    {0x00DB, 9},        // 1408
    {0x0098, 9},        // 1472
    {0x0099, 9},        // 1536
    {0x009A, 9},        // 1600
    {0x0018, 6},        // 1664
    {0x009B, 9},        // 1728
    };
    if ( len >= 64 ) {
    int index = 63 + (len >> 6);
    writeG3Code( whiteCodes[index].code, whiteCodes[index].bits );
    len &= 63;
    }
    writeG3Code( whiteCodes[len].code, whiteCodes[len].bits );
}

Properties

_paintEngine

QPaintEngine* QtopiaPrintEnginePrivate::_paintEngine

Definition at line 183 of file qprintengine_qws_p.h.

buffer

QtopiaPrintBuffer QtopiaPrintEnginePrivate::buffer

Definition at line 194 of file qprintengine_qws_p.h.

collateCopies

bool QtopiaPrintEnginePrivate::collateCopies

Definition at line 188 of file qprintengine_qws_p.h.

colorMode

QPrinter::ColorMode QtopiaPrintEnginePrivate::colorMode

Definition at line 179 of file qprintengine_qws_p.h.

creator

QString QtopiaPrintEnginePrivate::creator

Definition at line 172 of file qprintengine_qws_p.h.

docName

QString QtopiaPrintEnginePrivate::docName

Definition at line 171 of file qprintengine_qws_p.h.

fullPage

bool QtopiaPrintEnginePrivate::fullPage

Definition at line 187 of file qprintengine_qws_p.h.

ifdPatch

int QtopiaPrintEnginePrivate::ifdPatch

Definition at line 197 of file qprintengine_qws_p.h.

mode

QPrinter::PrinterMode QtopiaPrintEnginePrivate::mode

Definition at line 166 of file qprintengine_qws_p.h.

numCopies

int QtopiaPrintEnginePrivate::numCopies

Definition at line 184 of file qprintengine_qws_p.h.

orientation

QPrinter::Orientation QtopiaPrintEnginePrivate::orientation

Definition at line 176 of file qprintengine_qws_p.h.

outputFileName

QString QtopiaPrintEnginePrivate::outputFileName

Definition at line 169 of file qprintengine_qws_p.h.

outputToFile

bool QtopiaPrintEnginePrivate::outputToFile

Definition at line 186 of file qprintengine_qws_p.h.

pageImage

QImage* QtopiaPrintEnginePrivate::pageImage

Definition at line 192 of file qprintengine_qws_p.h.

pageNumber

int QtopiaPrintEnginePrivate::pageNumber

Definition at line 190 of file qprintengine_qws_p.h.

pageOrder

QPrinter::PageOrder QtopiaPrintEnginePrivate::pageOrder

Definition at line 178 of file qprintengine_qws_p.h.

paperSize

QPrinter::PaperSize QtopiaPrintEnginePrivate::paperSize

Definition at line 177 of file qprintengine_qws_p.h.

paperSource

QPrinter::PaperSource QtopiaPrintEnginePrivate::paperSource

Definition at line 180 of file qprintengine_qws_p.h.

partialBits

int QtopiaPrintEnginePrivate::partialBits

Definition at line 199 of file qprintengine_qws_p.h.

partialByte

int QtopiaPrintEnginePrivate::partialByte

Definition at line 198 of file qprintengine_qws_p.h.

printerName

QString QtopiaPrintEnginePrivate::printerName

Definition at line 168 of file qprintengine_qws_p.h.

printerState

QPrinter::PrinterState QtopiaPrintEnginePrivate::printerState

Definition at line 174 of file qprintengine_qws_p.h.

printProgram

QString QtopiaPrintEnginePrivate::printProgram

Definition at line 170 of file qprintengine_qws_p.h.

resolution

int QtopiaPrintEnginePrivate::resolution

Definition at line 182 of file qprintengine_qws_p.h.

---

The documentation for this class was generated from the following files:

• /src/gui/painting/qprintengine_qws_p.h
• /src/gui/painting/qprintengine_qws.cpp