/****************************************************************************

**

** All rights reserved.

** Contact: Nokia Corporation (qt-info@nokia.com)

**

** This file is part of the QtGui module of the Qt Toolkit.

**

** $QT_BEGIN_LICENSE:LGPL$

** No Commercial Usage

** This file contains pre-release code and may not be distributed.

** You may use this file in accordance with the terms and conditions

** contained in the Technology Preview License Agreement accompanying

** this package.

**

** GNU Lesser General Public License Usage

** Alternatively, this file may be used under the terms of the GNU Lesser

** General Public License version 2.1 as published by the Free Software

** Foundation and appearing in the file LICENSE.LGPL included in the

** packaging of this file.  Please review the following information to

** ensure the GNU Lesser General Public License version 2.1 requirements

** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.

**

** In addition, as a special exception, Nokia gives you certain additional

** rights.  These rights are described in the Nokia Qt LGPL Exception

** version 1.1, included in the file LGPL_EXCEPTION.txt in this package.

**

** If you have questions regarding the use of this file, please contact

** Nokia at qt-info@nokia.com.

**

**

**

**

**

**

**

**

** $QT_END_LICENSE$

**

****************************************************************************/

#include <private/qprintengine_qws_p.h>

#ifndef QT_NO_PRINTER

#include <private/qpaintengine_raster_p.h>

#include <qimage.h>

#include <qfile.h>

#include <qdebug.h>

#include <QCopChannel>

QT_BEGIN_NAMESPACE

#define MM(n) int((n * 720 + 127) / 254)

#define IN(n) int(n * 72)

extern QSizeF qt_paperSizeToQSizeF(QPrinter::PaperSize size);

QtopiaPrintEngine::QtopiaPrintEngine(QPrinter::PrinterMode mode)

    : QPaintEngine(*(new QtopiaPrintEnginePrivate( mode )))

{

    d_func()->initialize();

}

bool QtopiaPrintEngine::begin(QPaintDevice *)

{

    Q_D(QtopiaPrintEngine);

    Q_ASSERT_X(d->printerState == QPrinter::Idle, "QtopiaPrintEngine", "printer already active");

    // Create a new off-screen monochrome image to handle the drawing process.

    QSize size = paperRect().size();

    if ( d->pageImage )

	delete d->pageImage;

    d->pageImage = new QImage( size, QImage::Format_RGB32 );

    if ( !(d->pageImage) )

	return false;

    // Recreate the paint engine on the new image.

    delete d->_paintEngine;

    d->_paintEngine = 0;

    d->paintEngine()->state = state;

    // Begin the paint process on the image.

    if (!d->paintEngine()->begin(d->pageImage))

        return false;

    // Clear the first page to all-white.

    clearPage();

    // Clear the print buffer and output the image header.

    d->buffer.clear();

    d->writeG3FaxHeader();

    // The print engine is currently active.

    d->printerState = QPrinter::Active;

    return true;

}

bool QtopiaPrintEngine::end()

{

    Q_D(QtopiaPrintEngine);

    d->paintEngine()->end();

    // Flush the last page.

    flushPage();

    // Output the fax data to a file (TODO: send to the print queuing daemon).

    QString filename;

    if ( !d->outputFileName.isEmpty() )

        filename = QString::fromLocal8Bit(qgetenv("HOME").constData()) + QLatin1String("/Documents/") + d->outputFileName;

    else

        filename = QString::fromLocal8Bit(qgetenv("HOME").constData()) + QLatin1String("/tmp/qwsfax.tiff");

    setProperty(QPrintEngine::PPK_OutputFileName, filename);

    QFile file( filename );

    if ( !file.open( QIODevice::WriteOnly | QIODevice::Truncate ) ) {

	qDebug( "Failed to open %s for printer output",

		filename.toLatin1().constData() );

    } else {

	file.write( d->buffer.data() );

	file.close();

    }

    // Free up the memory for the image buffer.

    d->buffer.clear();

    // Finalize the print job.

    d->printerState = QPrinter::Idle;

    // call qcop service

    QMap<QString, QVariant> map;

    for ( int x = 0; x <= QPrintEngine::PPK_Duplex; x++ )

        map.insert( QString::number(x), property((QPrintEngine::PrintEnginePropertyKey)(x)));

    QVariant variant(map);

    QByteArray data;

    QDataStream out(&data, QIODevice::WriteOnly);

    out << variant;

    QCopChannel::send(QLatin1String("QPE/Service/Print"), QLatin1String("print(QVariant)"), data);

    return true;

}

QPaintEngine *QtopiaPrintEngine::paintEngine() const

{

    return const_cast<QtopiaPrintEnginePrivate *>(d_func())->paintEngine();

}

void QtopiaPrintEngine::drawPixmap(const QRectF &r, const QPixmap &pm, const QRectF &sr)

{

    Q_D(QtopiaPrintEngine);

    Q_ASSERT(d->printerState == QPrinter::Active);

    d->paintEngine()->drawPixmap(r, pm, sr);

}

void QtopiaPrintEngine::drawTextItem(const QPointF &p, const QTextItem &ti)

{

    Q_D(QtopiaPrintEngine);

    Q_ASSERT(d->printerState == QPrinter::Active);

    d->paintEngine()->drawTextItem(p, ti);

}

void QtopiaPrintEngine::updateState(const QPaintEngineState &state)

{

    Q_D(QtopiaPrintEngine);

    d->paintEngine()->updateState(state);

}

QRect QtopiaPrintEngine::paperRect() const

{

    QSizeF s = qt_paperSizeToQSizeF(d_func()->paperSize);

    s.rwidth() = MM(s.width());

    s.rheight() = MM(s.height());

    int w = qRound(s.width()*d_func()->resolution/72.);

    int h = qRound(s.height()*d_func()->resolution/72.);

    if (d_func()->orientation == QPrinter::Portrait)

        return QRect(0, 0, w, h);

    else

        return QRect(0, 0, h, w);

}

QRect QtopiaPrintEngine::pageRect() const

{

    QRect r = paperRect();

    if (d_func()->fullPage)

        return r;

    // would be nice to get better margins than this.

    return QRect(d_func()->resolution/3, d_func()->resolution/3, r.width()-2*d_func()->resolution/3, r.height()-2*d_func()->resolution/3);

}

bool QtopiaPrintEngine::newPage()

{

    flushPage();

    clearPage();

    ++(d_func()->pageNumber);

    return true;

}

bool QtopiaPrintEngine::abort()

{

    return false;

}

QPrinter::PrinterState QtopiaPrintEngine::printerState() const

{

    return d_func()->printerState;

}

int QtopiaPrintEngine::metric(QPaintDevice::PaintDeviceMetric metricType) const

{

    int val;

    QRect r = d_func()->fullPage ? paperRect() : pageRect();

    switch (metricType) {

    case QPaintDevice::PdmWidth:

        val = r.width();

        break;

    case QPaintDevice::PdmHeight:

        val = r.height();

        break;

    case QPaintDevice::PdmDpiX:

        val = d_func()->resolution;

        break;

    case QPaintDevice::PdmDpiY:

        val = d_func()->resolution;

        break;

    case QPaintDevice::PdmPhysicalDpiX:

    case QPaintDevice::PdmPhysicalDpiY:

        val = QT_QWS_PRINTER_DEFAULT_DPI;

        break;

    case QPaintDevice::PdmWidthMM:

        val = qRound(r.width()*25.4/d_func()->resolution);

        break;

    case QPaintDevice::PdmHeightMM:

        val = qRound(r.height()*25.4/d_func()->resolution);

        break;

    case QPaintDevice::PdmNumColors:

        val = 2;

        break;

    case QPaintDevice::PdmDepth:

        val = 1;

        break;

    default:

        qWarning("QtopiaPrintEngine::metric: Invalid metric command");

        return 0;

    }

    return val;

}

QVariant QtopiaPrintEngine::property(PrintEnginePropertyKey key) const

{

    Q_D(const  QtopiaPrintEngine);

    QVariant ret;

    switch (key) {

    case PPK_CollateCopies:

        ret = d->collateCopies;

        break;

    case PPK_ColorMode:

        ret = d->colorMode;

        break;

    case PPK_Creator:

        ret = d->creator;

        break;

    case PPK_DocumentName:

        ret = d->docName;

        break;

    case PPK_FullPage:

        ret = d->fullPage;

        break;

    case PPK_NumberOfCopies:

        ret = d->numCopies;

        break;

    case PPK_Orientation:

        ret = d->orientation;

        break;

    case PPK_OutputFileName:

        ret = d->outputFileName;

        break;

    case PPK_PageOrder:

        ret = d->pageOrder;

        break;

    case PPK_PageRect:

        ret = pageRect();

        break;

    case PPK_PaperSize:

        ret = d->paperSize;

        break;

    case PPK_PaperRect:

        ret = paperRect();

        break;

    case PPK_PaperSource:

        ret = d->paperSource;

        break;

    case PPK_PrinterName:

        ret = d->printerName;

        break;

    case PPK_PrinterProgram:

        ret = d->printProgram;

        break;

    case PPK_Resolution:

        ret = d->resolution;

        break;

    case PPK_SupportedResolutions:

        ret = QList<QVariant>() << QT_QWS_PRINTER_DEFAULT_DPI;

        break;

    default:

        break;

    }

    return ret;

}

void QtopiaPrintEngine::setProperty(PrintEnginePropertyKey key, const QVariant &value)

{

    Q_D(QtopiaPrintEngine);

    switch (key) {

    case PPK_CollateCopies:

        d->collateCopies = value.toBool();

        break;

    case PPK_ColorMode:

        d->colorMode = QPrinter::ColorMode(value.toInt());

        break;

    case PPK_Creator:

        d->creator = value.toString();

        break;

    case PPK_DocumentName:

        d->docName = value.toString();

        break;

    case PPK_FullPage:

        d->fullPage = value.toBool();

        break;

    case PPK_NumberOfCopies:

        d->numCopies = value.toInt();

        break;

    case PPK_Orientation:

        d->orientation = QPrinter::Orientation(value.toInt());

        break;

    case PPK_OutputFileName:

        d->outputFileName = value.toString();

        break;

    case PPK_PageOrder:

        d->pageOrder = QPrinter::PageOrder(value.toInt());

        break;

    case PPK_PaperSize:

        d->paperSize = QPrinter::PaperSize(value.toInt());

        break;

    case PPK_PaperSource:

        d->paperSource = QPrinter::PaperSource(value.toInt());

    case PPK_PrinterName:

        d->printerName = value.toString();

        break;

    case PPK_PrinterProgram:

        d->printProgram = value.toString();

        break;

    case PPK_Resolution:

        d->resolution = value.toInt();

        break;

    default:

        break;

    }

}

void QtopiaPrintEngine::clearPage()

{

    d_func()->pageImage->fill(QColor(255, 255, 255).rgb());

}

void QtopiaPrintEngine::flushPage()

{

    d_func()->writeG3FaxPage();

}

QtopiaPrintEnginePrivate::~QtopiaPrintEnginePrivate()

{

    if ( pageImage )

	delete pageImage;

}

void QtopiaPrintEnginePrivate::initialize()

{

    _paintEngine = 0;

}

QPaintEngine *QtopiaPrintEnginePrivate::paintEngine()

{

    if (!_paintEngine)

        _paintEngine = new QRasterPaintEngine(pageImage);

    return _paintEngine;

}

void QtopiaPrintEnginePrivate::writeG3FaxHeader()

{

    // 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 );

}

// Tag values, from RFC 2301.

#define	TIFF_IFD_NEW_SUB_FILE_TYPE	254

#define	TIFF_IFD_IMAGE_WIDTH		256

#define	TIFF_IFD_IMAGE_LENGTH		257

#define	TIFF_IFD_BITS_PER_SAMPLE	258

#define	TIFF_IFD_COMPRESSION		259

#define	TIFF_IFD_PHOTOMETRIC_INTERP	262

#define	TIFF_IFD_FILL_ORDER		266

#define	TIFF_IFD_STRIP_OFFSETS		273

#define	TIFF_IFD_ORIENTATION		274

#define	TIFF_IFD_SAMPLES_PER_PIXEL	277

#define	TIFF_IFD_ROWS_PER_STRIP		278

#define	TIFF_IFD_STRIP_BYTE_COUNTS	279

#define	TIFF_IFD_X_RESOLUTION	    	282

#define	TIFF_IFD_Y_RESOLUTION	    	283

#define	TIFF_IFD_PLANAR_CONFIG		284

#define	TIFF_IFD_T4_OPTIONS		292

#define	TIFF_IFD_RESOLUTION_UNIT	296

#define	TIFF_IFD_PAGE_NUMBER	    	297

#define	TIFF_IFD_CLEAN_FAX_DATA		327

// IFD type values.

#define	TIFF_TYPE_SHORT			3

#define	TIFF_TYPE_LONG			4

#define	TIFF_TYPE_RATIONAL		5

// Construct a SHORT pair from two values.

#define	TIFF_SHORT_PAIR(a,b)		(((a) & 0xFFFF) | ((b) << 16))

// Width of a FAX page in pixels, in the baseline specification from RFC 2301.

// This must be hard-wired, as per the RFC.  We truncate any pixels that

// are beyond this limit, or pad lines to reach this limit.

#define	TIFF_FAX_WIDTH			1728

void QtopiaPrintEnginePrivate::writeG3FaxPage()

{

    // 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 );