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

**

** Copyright (C) 2010 Nokia Corporation and/or its subsidiary(-ies).

** 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$

**

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

#ifndef QT_NO_PRINTER

#include "qprinter_p.h"

#include "qprintengine_win_p.h"

#include <limits.h>

#include <private/qfont_p.h>

#include <private/qfontengine_p.h>

#include <private/qpainter_p.h>

#include <qbitmap.h>

#include <qdebug.h>

#include <qvector.h>

#include <qpicture.h>

#include <private/qpicture_p.h>

QT_BEGIN_NAMESPACE

extern QPainterPath qt_regionToPath(const QRegion &region);

// #define QT_DEBUG_DRAW

static void draw_text_item_win(const QPointF &_pos, const QTextItemInt &ti, HDC hdc,

                               bool convertToText, const QTransform &xform, const QPointF &topLeft);

static const struct {

    int winSizeName;

    QPrinter::PaperSize qtSizeName;

} dmMapping[] = {

    { DMPAPER_LETTER,             QPrinter::Letter },

    { DMPAPER_LETTERSMALL,        QPrinter::Letter },

    { DMPAPER_TABLOID,            QPrinter::Tabloid },

    { DMPAPER_LEDGER,             QPrinter::Ledger },

    { DMPAPER_LEGAL,              QPrinter::Legal },

    { DMPAPER_EXECUTIVE,          QPrinter::Executive },

    { DMPAPER_A3,                 QPrinter::A3 },

    { DMPAPER_A4,                 QPrinter::A4 },

    { DMPAPER_A4SMALL,            QPrinter::A4 },

    { DMPAPER_A5,                 QPrinter::A5 },

    { DMPAPER_B4,                 QPrinter::B4 },

    { DMPAPER_B5,                 QPrinter::B5 },

    { DMPAPER_FOLIO,              QPrinter::Folio },

    { DMPAPER_ENV_10,             QPrinter::Comm10E },

    { DMPAPER_ENV_DL,             QPrinter::DLE },

    { DMPAPER_ENV_C3,             QPrinter::C5E },

    { DMPAPER_LETTER_EXTRA,       QPrinter::Letter },

    { DMPAPER_LEGAL_EXTRA,        QPrinter::Legal },

    { DMPAPER_TABLOID_EXTRA,      QPrinter::Tabloid },

    { DMPAPER_A4_EXTRA,           QPrinter::A4},

    { DMPAPER_LETTER_TRANSVERSE,  QPrinter::Letter},

    { DMPAPER_A4_TRANSVERSE,      QPrinter::A4},

    { DMPAPER_LETTER_EXTRA_TRANSVERSE, QPrinter::Letter },

    { DMPAPER_A_PLUS,             QPrinter::A4 },

    { DMPAPER_B_PLUS,             QPrinter::A3 },

    { DMPAPER_LETTER_PLUS,        QPrinter::Letter },

    { DMPAPER_A4_PLUS,            QPrinter::A4 },

    { DMPAPER_A5_TRANSVERSE,      QPrinter::A5 },

    { DMPAPER_B5_TRANSVERSE,      QPrinter::B5 },

    { DMPAPER_A3_EXTRA,           QPrinter::A3 },

    { DMPAPER_A5_EXTRA,           QPrinter::A5 },

    { DMPAPER_B5_EXTRA,           QPrinter::B5 },

    { DMPAPER_A2,                 QPrinter::A2 },

    { DMPAPER_A3_TRANSVERSE,      QPrinter::A3 },

    { DMPAPER_A3_EXTRA_TRANSVERSE,QPrinter::A3 },

    { 0, QPrinter::Custom }

};

QPrinter::PaperSize mapDevmodePaperSize(int s)

{

    int i = 0;

    while ((dmMapping[i].winSizeName > 0) && (dmMapping[i].winSizeName != s))

        i++;

    return dmMapping[i].qtSizeName;

}

static int mapPaperSizeDevmode(QPrinter::PaperSize s)

{

    int i = 0;

 while ((dmMapping[i].winSizeName > 0) && (dmMapping[i].qtSizeName != s))

        i++;

    return dmMapping[i].winSizeName;

}

static const struct {

    int winSourceName;

    QPrinter::PaperSource qtSourceName;

}  sources[] = {

    { DMBIN_ONLYONE,        QPrinter::OnlyOne },

    { DMBIN_LOWER,          QPrinter::Lower },

    { DMBIN_MIDDLE,         QPrinter::Middle },

    { DMBIN_MANUAL,         QPrinter::Manual },

    { DMBIN_ENVELOPE,       QPrinter::Envelope },

    { DMBIN_ENVMANUAL,      QPrinter::EnvelopeManual },

    { DMBIN_AUTO,           QPrinter::Auto },

    { DMBIN_TRACTOR,        QPrinter::Tractor },

    { DMBIN_SMALLFMT,       QPrinter::SmallFormat },

    { DMBIN_LARGEFMT,       QPrinter::LargeFormat },

    { DMBIN_LARGECAPACITY,  QPrinter::LargeCapacity },

    { DMBIN_CASSETTE,       QPrinter::Cassette },

    { DMBIN_FORMSOURCE,     QPrinter::FormSource },

    { 0, (QPrinter::PaperSource) -1 }

};

static QPrinter::PaperSource mapDevmodePaperSource(int s)

{

    int i = 0;

    while ((sources[i].winSourceName > 0) && (sources[i].winSourceName != s))

        i++;

    return sources[i].winSourceName ? sources[i].qtSourceName : (QPrinter::PaperSource) s;

}

static int mapPaperSourceDevmode(QPrinter::PaperSource s)

{

    int i = 0;

    while ((sources[i].qtSourceName >= 0) && (sources[i].qtSourceName != s))

        i++;

    return sources[i].winSourceName ? sources[i].winSourceName : s;

}

QWin32PrintEngine::QWin32PrintEngine(QPrinter::PrinterMode mode)

    : QAlphaPaintEngine(*(new QWin32PrintEnginePrivate),

                   PaintEngineFeatures(PrimitiveTransform

                                       | PixmapTransform

                                       | PerspectiveTransform

                                       | PainterPaths

                                       | Antialiasing

                                       | PaintOutsidePaintEvent))

{

    Q_D(QWin32PrintEngine);

    d->docName = QLatin1String("document1");

    d->mode = mode;

    d->queryDefault();

    d->initialize();

}

bool QWin32PrintEngine::begin(QPaintDevice *pdev)

{

    Q_D(QWin32PrintEngine);

    QAlphaPaintEngine::begin(pdev);

    if (!continueCall())

        return true;

    if (d->reinit) {

       d->resetDC();

       d->reinit = false;

    }

    // ### set default colors and stuff...

    bool ok = d->state == QPrinter::Idle;

    if (!d->hdc)

        return false;

    // Assign the FILE: to get the query...

    if (d->printToFile && d->fileName.isEmpty())

        d->fileName = d->port;

    d->devMode->dmCopies = d->num_copies;

    DOCINFO di;

    memset(&di, 0, sizeof(DOCINFO));

    di.cbSize = sizeof(DOCINFO);

    di.lpszDocName = reinterpret_cast<const wchar_t *>(d->docName.utf16());

    if (d->printToFile && !d->fileName.isEmpty())

        di.lpszOutput = reinterpret_cast<const wchar_t *>(d->fileName.utf16());

    if (ok && StartDoc(d->hdc, &di) == SP_ERROR) {

        qErrnoWarning("QWin32PrintEngine::begin: StartDoc failed");

        ok = false;

    }

    if (StartPage(d->hdc) <= 0) {

        qErrnoWarning("QWin32PrintEngine::begin: StartPage failed");

        ok = false;

    }

    if (!ok) {

        d->state = QPrinter::Idle;

    } else {

        d->state = QPrinter::Active;

    }

    d->matrix = QTransform();

    d->has_pen = true;

    d->pen = QColor(Qt::black);

    d->has_brush = false;

    d->complex_xform = false;

    updateMatrix(d->matrix);

    if (!ok)

        cleanUp();

    return ok;

}

bool QWin32PrintEngine::end()

{

    Q_D(QWin32PrintEngine);

    if (d->hdc) {

        if (d->state == QPrinter::Aborted) {

            cleanUp();

            AbortDoc(d->hdc);

            return true;

        }

    }

    QAlphaPaintEngine::end();

    if (!continueCall())

        return true;

    if (d->hdc) {

        EndPage(d->hdc);                 // end; printing done

        EndDoc(d->hdc);

    }

    d->state = QPrinter::Idle;

    d->reinit = true;

    return true;

}

bool QWin32PrintEngine::newPage()

{

    Q_D(QWin32PrintEngine);

    Q_ASSERT(isActive());

    Q_ASSERT(d->hdc);

    flushAndInit();

    bool transparent = GetBkMode(d->hdc) == TRANSPARENT;

    if (!EndPage(d->hdc)) {

        qErrnoWarning("QWin32PrintEngine::newPage: EndPage failed");

        return false;

    }

    if (d->reinit) {

        if (!d->resetDC()) {

            qErrnoWarning("QWin32PrintEngine::newPage: ResetDC failed");

            return false;

        }

        d->reinit = false;

    }

    if (!StartPage(d->hdc)) {

        qErrnoWarning("Win32PrintEngine::newPage: StartPage failed");

        return false;

    }

    SetTextAlign(d->hdc, TA_BASELINE);

    if (transparent)

        SetBkMode(d->hdc, TRANSPARENT);

    // ###

    return true;

    bool success = false;

    if (d->hdc && d->state == QPrinter::Active) {

        if (EndPage(d->hdc) != SP_ERROR) {

            // reinitialize the DC before StartPage if needed,

            // because resetdc is disabled between calls to the StartPage and EndPage functions

            // (see StartPage documentation in the Platform SDK:Windows GDI)

//          state = PST_ACTIVEDOC;

//          reinit();

//          state = PST_ACTIVE;

            // start the new page now

            if (d->reinit) {

                if (!d->resetDC())

                    qErrnoWarning("QWin32PrintEngine::newPage(), ResetDC failed (2)");

                d->reinit = false;

            }

            success = (StartPage(d->hdc) != SP_ERROR);

        }

        if (!success) {

            d->state = QPrinter::Aborted;

            return false;

        }

    }

    return true;

}

bool QWin32PrintEngine::abort()

{

    // do nothing loop.

    return false;

}

void QWin32PrintEngine::drawTextItem(const QPointF &p, const QTextItem &textItem)

{

    Q_D(const QWin32PrintEngine);

    QAlphaPaintEngine::drawTextItem(p, textItem);

    if (!continueCall())

        return;

    const QTextItemInt &ti = static_cast<const QTextItemInt &>(textItem);

    QRgb brushColor = state->pen().brush().color().rgb();

    bool fallBack = state->pen().brush().style() != Qt::SolidPattern

                    || qAlpha(brushColor) != 0xff

                    || d->txop >= QTransform::TxProject

                    || ti.fontEngine->type() != QFontEngine::Win;

    if (!fallBack) {

        QFontEngineWin *fe = static_cast<QFontEngineWin *>(ti.fontEngine);

        // Try selecting the font to see if we get a substitution font

        SelectObject(d->hdc, fe->hfont);

        if (GetDeviceCaps(d->hdc, TECHNOLOGY) != DT_CHARSTREAM) {

            wchar_t n[64];

            GetTextFace(d->hdc, 64, n);

            fallBack = QString::fromWCharArray(n)

                    != QString::fromWCharArray(fe->logfont.lfFaceName);

        }

    }

    if (fallBack) {

        QPaintEngine::drawTextItem(p, textItem);

        return ;

    }

    // We only want to convert the glyphs to text if the entire string is compatible with ASCII

    // and if we actually have access to the chars.

    bool convertToText = ti.chars != 0;

    for (int i=0;  i < ti.num_chars; ++i) {

        if (ti.chars[i].unicode() >= 0x80) {

            convertToText = false;

            break;

        }

        if (ti.logClusters[i] != i) {

            convertToText = false;

            break;

        }

    }

    COLORREF cf = RGB(qRed(brushColor), qGreen(brushColor), qBlue(brushColor));

    SelectObject(d->hdc, CreateSolidBrush(cf));

    SelectObject(d->hdc, CreatePen(PS_SOLID, 1, cf));

    SetTextColor(d->hdc, cf);

    draw_text_item_win(p, ti, d->hdc, convertToText, d->matrix, d->devPaperRect.topLeft());

    DeleteObject(SelectObject(d->hdc,GetStockObject(HOLLOW_BRUSH)));

    DeleteObject(SelectObject(d->hdc,GetStockObject(BLACK_PEN)));

}

static inline qreal mmToInches(double mm)

{

    return mm*0.039370147;

}

static inline qreal inchesToMM(double in)

{

    return in/0.039370147;

}

int QWin32PrintEngine::metric(QPaintDevice::PaintDeviceMetric m) const

{

    Q_D(const QWin32PrintEngine);

    if (!d->hdc)

        return 0;

    int val;

    int res = d->resolution;

    switch (m) {

    case QPaintDevice::PdmWidth:

        if (d->has_custom_paper_size) {

            val =  qRound(d->paper_size.width() * res / 72.0);

        } else {

            int logPixelsX = GetDeviceCaps(d->hdc, LOGPIXELSX);

            if (logPixelsX == 0) {

                qWarning("QWin32PrintEngine::metric: GetDeviceCaps() failed, "

                        "might be a driver problem");

                logPixelsX = 600; // Reasonable default

            }

            val = res

                  * GetDeviceCaps(d->hdc, d->fullPage ? PHYSICALWIDTH : HORZRES)

                  / logPixelsX;

        }

        if (d->pageMarginsSet)

            val -= int(mmToInches((d->previousDialogMargins.left() +

                                   d->previousDialogMargins.width()) / 100.0) * res);

        break;

    case QPaintDevice::PdmHeight:

        if (d->has_custom_paper_size) {

            val = qRound(d->paper_size.height() * res / 72.0);

        } else {

            int logPixelsY = GetDeviceCaps(d->hdc, LOGPIXELSY);

            if (logPixelsY == 0) {

                qWarning("QWin32PrintEngine::metric: GetDeviceCaps() failed, "

                        "might be a driver problem");

                logPixelsY = 600; // Reasonable default

            }

            val = res

                  * GetDeviceCaps(d->hdc, d->fullPage ? PHYSICALHEIGHT : VERTRES)

                  / logPixelsY;

        }

        if (d->pageMarginsSet)

            val -= int(mmToInches((d->previousDialogMargins.top() +

                                   d->previousDialogMargins.height()) / 100.0) * res);

        break;

    case QPaintDevice::PdmDpiX:

        val = res;

        break;

    case QPaintDevice::PdmDpiY:

        val = res;

        break;

    case QPaintDevice::PdmPhysicalDpiX:

        val = GetDeviceCaps(d->hdc, LOGPIXELSX);

        break;

    case QPaintDevice::PdmPhysicalDpiY:

        val = GetDeviceCaps(d->hdc, LOGPIXELSY);

        break;

    case QPaintDevice::PdmWidthMM:

        if (d->has_custom_paper_size) {

            val = qRound(d->paper_size.width()*25.4/72);

        } else {

            if (!d->fullPage) {

                val = GetDeviceCaps(d->hdc, HORZSIZE);

            } else {

                float wi = 25.4 * GetDeviceCaps(d->hdc, PHYSICALWIDTH);

                int logPixelsX = GetDeviceCaps(d->hdc,  LOGPIXELSX);

                if (logPixelsX == 0) {

                    qWarning("QWin32PrintEngine::metric: GetDeviceCaps() failed, "

                            "might be a driver problem");

                    logPixelsX = 600; // Reasonable default

                }

                val = qRound(wi / logPixelsX);

            }

        }

        if (d->pageMarginsSet)

            val -= (d->previousDialogMargins.left() +

                    d->previousDialogMargins.width()) / 100.0;

        break;

    case QPaintDevice::PdmHeightMM:

        if (d->has_custom_paper_size) {

            val = qRound(d->paper_size.height()*25.4/72);

        } else {

            if (!d->fullPage) {

                val = GetDeviceCaps(d->hdc, VERTSIZE);

            } else {

                float hi = 25.4 * GetDeviceCaps(d->hdc, PHYSICALHEIGHT);

                int logPixelsY = GetDeviceCaps(d->hdc,  LOGPIXELSY);

                if (logPixelsY == 0) {

                    qWarning("QWin32PrintEngine::metric: GetDeviceCaps() failed, "

                            "might be a driver problem");

                    logPixelsY = 600; // Reasonable default

                }

                val = qRound(hi / logPixelsY);

            }

        }

        if (d->pageMarginsSet)

            val -= (d->previousDialogMargins.top() +

                    d->previousDialogMargins.height()) / 100.0;

        break;

    case QPaintDevice::PdmNumColors:

        {

            int bpp = GetDeviceCaps(d->hdc, BITSPIXEL);

            if(bpp==32)

                val = INT_MAX;

            else if(bpp<=8)

                val = GetDeviceCaps(d->hdc, NUMCOLORS);

            else

                val = 1 << (bpp * GetDeviceCaps(d->hdc, PLANES));

        }

        break;

    case QPaintDevice::PdmDepth:

        val = GetDeviceCaps(d->hdc, PLANES);

        break;

    default:

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

        return 0;

    }

    return val;

}

void QWin32PrintEngine::updateState(const QPaintEngineState &state)

{