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

**

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

**

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

#include <private/qprintengine_mac_p.h>

#include <qdebug.h>

#include <qthread.h>

#include <QtCore/qcoreapplication.h>

#ifndef QT_NO_PRINTER

QT_BEGIN_NAMESPACE

extern QSizeF qt_paperSizeToQSizeF(QPrinter::PaperSize size);

extern int qt_defaultDpi();

QMacPrintEngine::QMacPrintEngine(QPrinter::PrinterMode mode) : QPaintEngine(*(new QMacPrintEnginePrivate))

{

    Q_D(QMacPrintEngine);

    d->mode = mode;

    d->initialize();

}

bool QMacPrintEngine::begin(QPaintDevice *dev)

{

    Q_D(QMacPrintEngine);

    Q_ASSERT(dev && dev->devType() == QInternal::Printer);

    if (!static_cast<QPrinter *>(dev)->isValid())

	return false;

    if (d->state == QPrinter::Idle && !d->isPrintSessionInitialized()) // Need to reinitialize

        d->initialize();

    d->paintEngine->state = state;

    d->paintEngine->begin(dev);

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

    if (PMSessionValidatePrintSettings(d->session, d->settings, kPMDontWantBoolean) != noErr

        || PMSessionValidatePageFormat(d->session, d->format, kPMDontWantBoolean) != noErr) {

        d->state = QPrinter::Error;

        return false;

    }

    if (!d->outputFilename.isEmpty()) {

        QCFType<CFURLRef> outFile = CFURLCreateWithFileSystemPath(kCFAllocatorSystemDefault,

                                                                  QCFString(d->outputFilename),

                                                                  kCFURLPOSIXPathStyle,

                                                                  false);

        if (PMSessionSetDestination(d->session, d->settings, kPMDestinationFile,

                                    kPMDocumentFormatPDF, outFile) != noErr) {

            qWarning("QMacPrintEngine::begin: Problem setting file [%s]", d->outputFilename.toUtf8().constData());

            return false;

        }

    }

    OSStatus status = noErr;

#ifndef QT_MAC_USE_COCOA

    status = d->shouldSuppressStatus() ? PMSessionBeginCGDocumentNoDialog(d->session, d->settings, d->format)

                                       : PMSessionBeginCGDocument(d->session, d->settings, d->format);

#else

    status = PMSessionBeginCGDocumentNoDialog(d->session, d->settings, d->format);

#endif

    if (status != noErr) {

        d->state = QPrinter::Error;

        return false;

    }

    d->state = QPrinter::Active;

    setActive(true);

    d->newPage_helper();

    return true;

}

bool QMacPrintEngine::end()

{

    Q_D(QMacPrintEngine);

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

        return true;  // I was just here a function call ago :)

    if(d->paintEngine->type() == QPaintEngine::CoreGraphics) {

        // We dont need the paint engine to call restoreGraphicsState()

        static_cast<QCoreGraphicsPaintEngine*>(d->paintEngine)->d_func()->stackCount = 0;

        static_cast<QCoreGraphicsPaintEngine*>(d->paintEngine)->d_func()->hd = 0;

    }

    d->paintEngine->end();

    if (d->state != QPrinter::Idle)

	d->releaseSession();

    d->state  = QPrinter::Idle;

    return true;

}

QPaintEngine *

QMacPrintEngine::paintEngine() const

{

    return d_func()->paintEngine;

}

Qt::HANDLE QMacPrintEngine::handle() const

{

    QCoreGraphicsPaintEngine *cgEngine = static_cast<QCoreGraphicsPaintEngine*>(paintEngine());

    return cgEngine->d_func()->hd;

}

QMacPrintEnginePrivate::~QMacPrintEnginePrivate()

{

#ifdef QT_MAC_USE_COCOA

    [printInfo release];

#endif

    delete paintEngine;

}

void QMacPrintEnginePrivate::setPaperSize(QPrinter::PaperSize ps)

{

    Q_Q(QMacPrintEngine);

    QSizeF newSize = qt_paperSizeToQSizeF(ps);

    QCFType<CFArrayRef> formats;

    PMPrinter printer;

    if (PMSessionGetCurrentPrinter(session, &printer) == noErr

        && PMSessionCreatePageFormatList(session, printer, &formats) == noErr) {

        CFIndex total = CFArrayGetCount(formats);

        PMPageFormat tmp;

        PMRect paper;

        for (CFIndex idx = 0; idx < total; ++idx) {

            tmp = static_cast<PMPageFormat>(

                                        const_cast<void *>(CFArrayGetValueAtIndex(formats, idx)));

            PMGetUnadjustedPaperRect(tmp, &paper);

            int wMM = int((paper.right - paper.left) / 72 * 25.4 + 0.5);

            int hMM = int((paper.bottom - paper.top) / 72 * 25.4 + 0.5);

            if (newSize.width() == wMM && newSize.height() == hMM) {

                PMCopyPageFormat(tmp, format);

                // reset the orientation and resolution as they are lost in the copy.

                q->setProperty(QPrintEngine::PPK_Orientation, orient);

                if (PMSessionValidatePageFormat(session, format, kPMDontWantBoolean) != noErr) {

                    // Don't know, warn for the moment.

                    qWarning("QMacPrintEngine, problem setting format and resolution for this page size");

                }

                break;

            }

        }

    }

}

QPrinter::PaperSize QMacPrintEnginePrivate::paperSize() const

{

    PMRect paper;

    PMGetUnadjustedPaperRect(format, &paper);

    int wMM = int((paper.right - paper.left) / 72 * 25.4 + 0.5);

    int hMM = int((paper.bottom - paper.top) / 72 * 25.4 + 0.5);

    for (int i = QPrinter::A4; i < QPrinter::NPaperSize; ++i) {

        QSizeF s = qt_paperSizeToQSizeF(QPrinter::PaperSize(i));

        if (s.width() == wMM && s.height() == hMM)

            return (QPrinter::PaperSize)i;

    }

    return QPrinter::Custom;

}

QList<QVariant> QMacPrintEnginePrivate::supportedResolutions() const

{

    Q_ASSERT_X(session, "QMacPrinterEngine::supportedResolutions",

               "must have a valid printer session");

    UInt32 resCount;

    QList<QVariant> resolutions;

    PMPrinter printer;

    if (PMSessionGetCurrentPrinter(session, &printer) == noErr) {

        PMResolution res;

        OSStatus status = PMPrinterGetPrinterResolutionCount(printer, &resCount);

        if (status  == kPMNotImplemented) {

#if (MAC_OS_X_VERSION_MAX_ALLOWED < MAC_OS_X_VERSION_10_5)

            // *Sigh* we have to use the non-indexed version.

            if (PMPrinterGetPrinterResolution(printer, kPMMinSquareResolution, &res) == noErr)

                resolutions.append(int(res.hRes));

            if (PMPrinterGetPrinterResolution(printer, kPMMaxSquareResolution, &res) == noErr) {

                QVariant var(int(res.hRes));

                if (!resolutions.contains(var))

                    resolutions.append(var);

            }

            if (PMPrinterGetPrinterResolution(printer, kPMDefaultResolution, &res) == noErr) {

                QVariant var(int(res.hRes));

                if (!resolutions.contains(var))

                    resolutions.append(var);

            }

#endif

        } else if (status == noErr) {

            // According to the docs, index start at 1.

            for (UInt32 i = 1; i <= resCount; ++i) {

                if (PMPrinterGetIndexedPrinterResolution(printer, i, &res) == noErr)

                    resolutions.append(QVariant(int(res.hRes)));

            }

        } else {

            qWarning("QMacPrintEngine::supportedResolutions: Unexpected error: %ld", long(status));

        }

    }

    return resolutions;

}

bool QMacPrintEnginePrivate::shouldSuppressStatus() const

{

    if (suppressStatus == true)

        return true;

    // Supress displaying the automatic progress dialog if we are printing

    // from a non-gui thread.

    return (qApp->thread() != QThread::currentThread());

}

QPrinter::PrinterState QMacPrintEngine::printerState() const

{

    return d_func()->state;

}

bool QMacPrintEngine::newPage()

{

    Q_D(QMacPrintEngine);

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

    OSStatus err =

#ifndef QT_MAC_USE_COCOA

    d->shouldSuppressStatus() ? PMSessionEndPageNoDialog(d->session)

                              : PMSessionEndPage(d->session);

#else

    PMSessionEndPageNoDialog(d->session);

#endif

    if (err != noErr)  {

        if (err == kPMCancel) {

            // User canceled, we need to abort!

            abort();

        } else {

            // Not sure what the problem is...

            qWarning("QMacPrintEngine::newPage: Cannot end current page. %ld", long(err));

            d->state = QPrinter::Error;

        }

        return false;

    }

    return d->newPage_helper();

}

bool QMacPrintEngine::abort()

{

    Q_D(QMacPrintEngine);

    if (d->state != QPrinter::Active)

        return false;

    bool ret = end();

    d->state = QPrinter::Aborted;

    return ret;

}

static inline int qt_get_PDMWidth(PMPageFormat pformat, bool fullPage,

                                  const PMResolution &resolution)

{

    int val = 0;

    PMRect r;

    qreal hRatio = resolution.hRes / 72;

    if (fullPage) {

        if (PMGetAdjustedPaperRect(pformat, &r) == noErr)

            val = qRound((r.right - r.left) * hRatio);

    } else {

        if (PMGetAdjustedPageRect(pformat, &r) == noErr)

            val = qRound((r.right - r.left) * hRatio);

    }

    return val;

}

static inline int qt_get_PDMHeight(PMPageFormat pformat, bool fullPage,

                                   const PMResolution &resolution)

{

    int val = 0;

    PMRect r;

    qreal vRatio = resolution.vRes / 72;

    if (fullPage) {

        if (PMGetAdjustedPaperRect(pformat, &r) == noErr)

            val = qRound((r.bottom - r.top) * vRatio);

    } else {

        if (PMGetAdjustedPageRect(pformat, &r) == noErr)

            val = qRound((r.bottom - r.top) * vRatio);

    }

    return val;

}

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

{

    Q_D(const QMacPrintEngine);

    int val = 1;

    switch (m) {

    case QPaintDevice::PdmWidth:

        if (d->hasCustomPaperSize) {

            val = qRound(d->customSize.width());

            if (d->hasCustomPageMargins) {

                val -= qRound(d->leftMargin + d->rightMargin);

            } else {

                QList<QVariant> margins = property(QPrintEngine::PPK_PageMargins).toList();

                val -= qRound(margins.at(0).toDouble() + margins.at(2).toDouble());

            }

        } else {

            val = qt_get_PDMWidth(d->format, property(PPK_FullPage).toBool(), d->resolution);

        }

        break;

    case QPaintDevice::PdmHeight:

        if (d->hasCustomPaperSize) {

            val = qRound(d->customSize.height());

            if (d->hasCustomPageMargins) {

                val -= qRound(d->topMargin + d->bottomMargin);

            } else {

                QList<QVariant> margins = property(QPrintEngine::PPK_PageMargins).toList();

                val -= qRound(margins.at(1).toDouble() + margins.at(3).toDouble());

            }

        } else {

            val = qt_get_PDMHeight(d->format, property(PPK_FullPage).toBool(), d->resolution);

        }

        break;

    case QPaintDevice::PdmWidthMM:

        val = metric(QPaintDevice::PdmWidth);

        val = int((val * 254 + 5 * d->resolution.hRes) / (10 * d->resolution.hRes));

        break;

    case QPaintDevice::PdmHeightMM:

        val = metric(QPaintDevice::PdmHeight);

        val = int((val * 254 + 5 * d->resolution.vRes) / (10 * d->resolution.vRes));

        break;

    case QPaintDevice::PdmPhysicalDpiX:

    case QPaintDevice::PdmPhysicalDpiY: {

        PMPrinter printer;

        if(PMSessionGetCurrentPrinter(d->session, &printer) == noErr) {

            PMResolution resolution;

#ifndef QT_MAC_USE_COCOA

#  if (MAC_OS_X_VERSION_MAX_ALLOWED >= MAC_OS_X_VERSION_10_5)

            if (QSysInfo::MacintoshVersion >= QSysInfo::MV_10_5) {

                PMPrinterGetOutputResolution(printer, d->settings, &resolution);

            } else

#  endif

            {

                PMPrinterGetPrinterResolution(printer, kPMCurrentValue, &resolution);

            }

#else

            PMPrinterGetOutputResolution(printer, d->settings, &resolution);

#endif

            val = (int)resolution.vRes;

            break;

        }

        //otherwise fall through

    }

    case QPaintDevice::PdmDpiY:

        val = (int)d->resolution.vRes;

        break;

    case QPaintDevice::PdmDpiX:

        val = (int)d->resolution.hRes;

        break;

    case QPaintDevice::PdmNumColors:

        val = (1 << metric(QPaintDevice::PdmDepth));

        break;

    case QPaintDevice::PdmDepth:

        val = 24;

        break;

    default:

        val = 0;

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

    }

    return val;

}

void QMacPrintEnginePrivate::initialize()

{

    Q_Q(QMacPrintEngine);

#ifndef QT_MAC_USE_COCOA

    Q_ASSERT(!session);

#else

    Q_ASSERT(!printInfo);

#endif

    if (!paintEngine)

        paintEngine = new QCoreGraphicsPaintEngine();

    q->gccaps = paintEngine->gccaps;

    fullPage = false;

#ifndef QT_MAC_USE_COCOA

    if (PMCreateSession(&session) != 0)

        session = 0;

#else

    QMacCocoaAutoReleasePool pool;

    printInfo = [[NSPrintInfo alloc] initWithDictionary:[NSDictionary dictionary]];

    session = static_cast<PMPrintSession>([printInfo PMPrintSession]);

#endif

    PMPrinter printer;

    if (session && PMSessionGetCurrentPrinter(session, &printer) == noErr) {

        QList<QVariant> resolutions = supportedResolutions();

        if (!resolutions.isEmpty() && mode != QPrinter::ScreenResolution) {

            if (resolutions.count() > 1 && mode == QPrinter::HighResolution) {

                int max = 0;

                for (int i = 0; i < resolutions.count(); ++i) {

                    int value = resolutions.at(i).toInt();

                    if (value > max)

                        max = value;

                }

                resolution.hRes = resolution.vRes = max;

            } else {

                resolution.hRes = resolution.vRes = resolutions.at(0).toInt();

            }

            if(resolution.hRes == 0)

                resolution.hRes = resolution.vRes = 600;

        } else {

            resolution.hRes = resolution.vRes = qt_defaultDpi();

        }

    }

#ifndef QT_MAC_USE_COCOA

    bool settingsInitialized = (settings != 0);

    bool settingsOK = !settingsInitialized ? PMCreatePrintSettings(&settings) == noErr : true;

    if (settingsOK && !settingsInitialized)

        settingsOK = PMSessionDefaultPrintSettings(session, settings) == noErr;

    bool formatInitialized = (format != 0);

    bool formatOK = !formatInitialized ? PMCreatePageFormat(&format) == noErr : true;

    if (formatOK) {

        if (!formatInitialized) {

            formatOK = PMSessionDefaultPageFormat(session, format) == noErr;

        }

        formatOK = PMSessionValidatePageFormat(session, format, kPMDontWantBoolean) == noErr;

    }

#else

    settings = static_cast<PMPrintSettings>([printInfo PMPrintSettings]);

    format = static_cast<PMPageFormat>([printInfo PMPageFormat]);

#endif

#ifndef QT_MAC_USE_COCOA

    if (!settingsOK || !formatOK) {

        qWarning("QMacPrintEngine::initialize: Unable to initialize QPainter");

        state = QPrinter::Error;

    }

#endif

    QHash<QMacPrintEngine::PrintEnginePropertyKey, QVariant>::const_iterator propC;

    for (propC = valueCache.constBegin(); propC != valueCache.constEnd(); propC++) {

        q->setProperty(propC.key(), propC.value());

    }

}

void QMacPrintEnginePrivate::releaseSession()

{

#ifndef QT_MAC_USE_COCOA

    if (shouldSuppressStatus()) {

	PMSessionEndPageNoDialog(session);

	PMSessionEndDocumentNoDialog(session);

    } else {

	PMSessionEndPage(session);

	PMSessionEndDocument(session);

    }

    PMRelease(session);

#else

    PMSessionEndPageNoDialog(session);

    PMSessionEndDocumentNoDialog(session);

    [printInfo release];

#endif

    printInfo = 0;

    session = 0;

}

bool QMacPrintEnginePrivate::newPage_helper()

{

    Q_Q(QMacPrintEngine);

    Q_ASSERT(state == QPrinter::Active);

    if (PMSessionError(session) != noErr) {

        q->abort();

        return false;

    }

    // pop the stack of saved graphic states, in case we get the same

    // context back - either way, the stack count should be 0 when we

    // get the new one

    QCoreGraphicsPaintEngine *cgEngine = static_cast<QCoreGraphicsPaintEngine*>(paintEngine);

    while (cgEngine->d_func()->stackCount > 0)

        cgEngine->d_func()->restoreGraphicsState();

    OSStatus status =

#ifndef QT_MAC_USE_COCOA

        shouldSuppressStatus() ? PMSessionBeginPageNoDialog(session, format, 0)

                               : PMSessionBeginPage(session, format, 0);

#else

        PMSessionBeginPageNoDialog(session, format, 0);

#endif

    if(status != noErr) {

        state = QPrinter::Error;

        return false;

    }

    QRect page = q->property(QPrintEngine::PPK_PageRect).toRect();

    QRect paper = q->property(QPrintEngine::PPK_PaperRect).toRect();