/****************************************************************************
**
** Copyright (C) 2016 The Qt Company Ltd.
** Contact: https://www.qt.io/licensing/
**
** This file is part of the test suite of the Qt Toolkit.
**
** $QT_BEGIN_LICENSE:GPL-EXCEPT$
** Commercial License Usage
** Licensees holding valid commercial Qt licenses may use this file in
** accordance with the commercial license agreement provided with the
** Software or, alternatively, in accordance with the terms contained in
** a written agreement between you and The Qt Company. For licensing terms
** and conditions see https://www.qt.io/terms-conditions. For further
** information use the contact form at https://www.qt.io/contact-us.
**
** GNU General Public License Usage
** Alternatively, this file may be used under the terms of the GNU
** General Public License version 3 as published by the Free Software
** Foundation with exceptions as appearing in the file LICENSE.GPL3-EXCEPT
** included in the packaging of this file. Please review the following
** information to ensure the GNU General Public License requirements will
** be met: https://www.gnu.org/licenses/gpl-3.0.html.
**
** $QT_END_LICENSE$
**
****************************************************************************/

#ifndef QT_NO_PRINTER

#include "printdialogpanel.h"
#include "utils.h"

#include <QPrinter>
#include <QPrinterInfo>
#include <QPrintDialog>
#include <QPrintPreviewDialog>
#include <QPageSetupDialog>
#include <QApplication>
#include <QDesktopWidget>
#include <QGroupBox>
#include <QCheckBox>
#include <QLabel>
#include <QPushButton>
#include <QGridLayout>
#include <QFormLayout>
#include <QVBoxLayout>
#include <QMessageBox>
#include <QDoubleSpinBox>
#include <QPainter>
#include <QFont>
#include <QFontMetrics>
#include <QDateTime>
#include <QDebug>
#include <QTextStream>
#include <QDir>

#if QT_VERSION >= 0x050000
#  include <QScreen>
#endif

const FlagData printerModeComboData[] =
{
    {"ScreenResolution", QPrinter::ScreenResolution},
    {"PrinterResolution", QPrinter::PrinterResolution},
    {"HighResolution", QPrinter::HighResolution}
};

#if QT_VERSION < 0x050300
const FlagData pageSizeComboData[] =
{
    {"A4", QPrinter::A4},
    {"B5", QPrinter::B5},
    {"Letter", QPrinter::Letter},
    {"Legal", QPrinter::Legal},
    {"Executive", QPrinter::Executive},
    {"A0", QPrinter::A0},
    {"A1", QPrinter::A1},
    {"A2", QPrinter::A2},
    {"A3", QPrinter::A3},
    {"A5", QPrinter::A5},
    {"A6", QPrinter::A6},
    {"A7", QPrinter::A7},
    {"A8", QPrinter::A8},
    {"A9", QPrinter::A9},
    {"B0", QPrinter::B0},
    {"B1", QPrinter::B1},
    {"B10", QPrinter::B10},
    {"B2", QPrinter::B2},
    {"B3", QPrinter::B3},
    {"B4", QPrinter::B4},
    {"B6", QPrinter::B6},
    {"B7", QPrinter::B7},
    {"B8", QPrinter::B8},
    {"B9", QPrinter::B9},
    {"C5E", QPrinter::C5E},
    {"Comm10E", QPrinter::Comm10E},
    {"DLE", QPrinter::DLE},
    {"Folio", QPrinter::Folio},
    {"Ledger", QPrinter::Ledger},
    {"Tabloid", QPrinter::Tabloid},
    {"Custom", QPrinter::Custom}
};
#endif

const FlagData printRangeComboData[] =
{
    {"AllPages", QPrinter::AllPages},
    {"Selection", QPrinter::Selection},
    {"PageRange", QPrinter::PageRange},
    {"CurrentPage", QPrinter::CurrentPage}
};

const FlagData pageOrderComboData[] =
{
    {"FirstPageFirst", QPrinter::FirstPageFirst},
    {"LastPageFirst", QPrinter::LastPageFirst},
};

const FlagData duplexModeComboData[] =
{
    {"DuplexNone", QPrinter::DuplexNone},
    {"DuplexAuto", QPrinter::DuplexAuto},
    {"DuplexLongSide", QPrinter::DuplexLongSide},
    {"DuplexShortSide", QPrinter::DuplexShortSide},
};

const FlagData paperSourceComboData[] =
{
    {"OnlyOne", QPrinter::OnlyOne},
    {"Lower", QPrinter::Lower},
    {"Middle", QPrinter::Middle},
    {"Manual", QPrinter::Manual},
    {"Envelope", QPrinter::Envelope},
    {"EnvelopeManual", QPrinter::EnvelopeManual},
    {"Auto", QPrinter::Auto},
    {"Tractor", QPrinter::Tractor},
    {"SmallFormat", QPrinter::SmallFormat},
    {"LargeFormat", QPrinter::LargeFormat},
    {"LargeCapacity", QPrinter::LargeCapacity},
    {"Cassette", QPrinter::Cassette},
    {"FormSource", QPrinter::FormSource},
    {"DuplexLongSide", QPrinter::DuplexLongSide},
    {"DuplexShortSide", QPrinter::DuplexShortSide},
};

const FlagData colorModeComboData[] =
{
    {"GrayScale", QPrinter::GrayScale},
    {"Color", QPrinter::Color},
};

const FlagData unitsComboData[] =
{
    {"Millimeter", QPageLayout::Millimeter},
    {"Inch", QPageLayout::Inch},
    {"Point", QPageLayout::Point},
    {"Pica", QPageLayout::Pica},
    {"Didot", QPageLayout::Didot},
    {"Cicero", QPageLayout::Cicero},
};

const FlagData orientationComboData[] =
{
    {"Portrait", QPageLayout::Portrait},
    {"Landscape", QPageLayout::Landscape},
};

const FlagData layoutModeComboData[] =
{
    {"StandardMode", QPageLayout::StandardMode},
    {"FullPageMode", QPageLayout::FullPageMode},
};

const FlagData printDialogOptions[] =
{
    {"PrintToFile", QPrintDialog::PrintToFile},
    {"PrintSelection", QPrintDialog::PrintSelection},
    {"PrintPageRange", QPrintDialog::PrintPageRange},
    {"PrintShowPageSize", QPrintDialog::PrintShowPageSize},
    {"PrintCollateCopies", QPrintDialog::PrintCollateCopies},
    {"PrintCurrentPage", QPrintDialog::PrintCurrentPage}
};

QTextStream &operator<<(QTextStream &s, const QSizeF &size)
{
    s << size.width() << 'x' << size.height();
    return s;
}

QTextStream &operator<<(QTextStream &s, const QRectF &rect)
{
    s << rect.width() << 'x' << rect.height() << forcesign << rect.x() << rect.y() << noforcesign;
    return s;
}

QTextStream &operator<<(QTextStream &s, const QPrinter &printer)
{
    s << '"' << printer.printerName() << "\"\nPaper #" <<printer.paperSize()
#if QT_VERSION >= 0x050000
        << " \"" << printer.paperName() << '"'
#endif
      << (printer.orientation() == QPrinter::Portrait ? ", Portrait" : ", Landscape");
    if (printer.fullPage())
        s << ", full page";
    s << "\nPaper size: "
        << printer.paperSize(QPrinter::Point) << "pt "
        << printer.paperSize(QPrinter::Millimeter) << "mm "
      << "\n            " << printer.paperSize(QPrinter::DevicePixel) << "device pt "
        << printer.paperSize(QPrinter::Inch) << "inch "
#if QT_VERSION >= 0x050000
      << "\nPagedPaintDevSize: " <<   printer.pageSizeMM() << "mm"
#endif
      << "\nLogical resolution : " << printer.logicalDpiX() << ',' << printer.logicalDpiY() << "DPI"
      << "\nPhysical resolution: " << printer.physicalDpiX() << ',' << printer.physicalDpiY() << "DPI"
      << "\nPaperRect: " << printer.paperRect(QPrinter::Point) << "pt "
        << printer.paperRect(QPrinter::Millimeter) << "mm "
      << "\n           " << printer.paperRect(QPrinter::DevicePixel) << "device pt"
      << "\nPageRect:  " << printer.pageRect(QPrinter::Point) << "pt "
        << printer.pageRect(QPrinter::Millimeter) << "mm "
      << "\n           " << printer.pageRect(QPrinter::DevicePixel) << "device pt";
    return s;
}

// Print a page with a rectangular frame, vertical / horizontal rulers in cm and printer info.

static void drawHorizCmRuler(QPainter &painter, int x1, int x2, int y)
{
    painter.drawLine(x1, y, x2, y);
    const int dpI = painter.device()->logicalDpiX();
    const int dpCm = qRound(double(dpI) / 2.54);
    const int h = dpCm / 2;
    const QFontMetrics fm(painter.font());
    for (int cm = 0, x = x1; x < x2; x += dpCm, ++cm) {
        painter.drawLine(x, y, x, y - h);
        if (cm) {
            const QString n = QString::number(cm);
            const QRect br = fm.boundingRect(n);
            painter.drawText(x - br.width() / 2, y - h - 10, n);
        }
    }
}

static void drawVertCmRuler(QPainter &painter, int x, int y1, int y2)
{
    painter.drawLine(x, y1, x, y2);
    const int dpI = painter.device()->logicalDpiY();
    const int dpCm = qRound(double(dpI) / 2.54);
    const int h = dpCm / 2;
    const QFontMetrics fm(painter.font());
    for (int cm = 0, y = y1; y < y2; y += dpCm, ++cm) {
        painter.drawLine(x, y, x + h, y);
        if (cm) {
            const QString n = QString::number(cm);
            const QRect br = fm.boundingRect(n);
            painter.drawText(x + h + 10, y + br.height() / 2, n);
        }
    }
}

static bool print(QPrinter *printer, QString *errorMessage)
{
    QPainter painter;

    if (!printer->isValid()) {
        *errorMessage = QLatin1String("Invalid printer.");
        return false;
    }

    if (printer->printerState() != QPrinter::Idle) {
        *errorMessage = QLatin1String("Printer not idle (state ")
            + QString::number(printer->printerState())
            + QLatin1String(").");
        return false;
    }

    if (!painter.begin(printer)) {
        *errorMessage = QLatin1String("QPainter::begin() failed.");
        return false;
    }

    const QRectF pageF = printer->pageRect();

    QFont font = painter.font();
    font.setFamily("Courier");
    font.setPointSize(10);

    // Format message.
    const int charHeight = QFontMetrics(font).boundingRect('X').height();
    QString msg;
    QTextStream str(&msg);
    str << "Qt "<< QT_VERSION_STR;
#if QT_VERSION >= 0x050000
    str << ' ' << QGuiApplication::platformName();
#endif
    str << ' ' << QDateTime::currentDateTime().toString()
        << "\nFont: " << font.family() << ' ' << font.pointSize() << '\n'
        << *printer;

    if (!painter.device()->logicalDpiY() || !painter.device()->logicalDpiX()) {
        *errorMessage = QLatin1String("Bailing out due to invalid DPI.");
        return false;
    }

    painter.drawRect(pageF);

    drawHorizCmRuler(painter, pageF.x(), pageF.right(), pageF.height() /2);
    drawVertCmRuler(painter, pageF.x() + pageF.width() / 2, pageF.top(), pageF.bottom());

    painter.setFont(font);
    QPointF textPoint = pageF.topLeft() + QPoint(10, charHeight + 10);
    foreach (const QString &line, msg.split('\n')) {
        painter.drawText(textPoint, line);
        textPoint.ry() += (15 * charHeight) / 10;
    }

    if (!painter.end()) {
        *errorMessage = QLatin1String("QPainter::end() failed.");
        return false;
    }

    return true;
}

static bool print(QPrinter *printer, QWidget *dialogParent)
{
    QString errorMessage;
    const bool result = print(printer, &errorMessage);
    if (!result)
        QMessageBox::warning(dialogParent, QLatin1String("Printing Failed"), errorMessage);
    return result;
}

class PrintPreviewDialog : public QPrintPreviewDialog {
    Q_OBJECT
public:
    explicit PrintPreviewDialog(QPrinter *printer, QWidget *parent = 0) : QPrintPreviewDialog(printer, parent)
    {
        connect(this, SIGNAL(paintRequested(QPrinter*)), this, SLOT(slotPaintRequested(QPrinter*)));
    }

public slots:
    void slotPaintRequested(QPrinter *p) { print(p, this); }
};

PrintDialogPanel::PrintDialogPanel(QWidget *parent)
    : QWidget(parent), m_blockSignals(true)
{
#if QT_VERSION < 0x050300
    m_printerLayout.setOutputFormat(QPrinter::PdfFormat);
#endif

    m_panel.setupUi(this);

    // Setup the Create box
    populateCombo(m_panel.m_printerModeCombo, printerModeComboData, sizeof(printerModeComboData)/sizeof(FlagData));
    connect(m_panel.m_createButton, SIGNAL(clicked()), this, SLOT(createPrinter()));
    connect(m_panel.m_deleteButton, SIGNAL(clicked()), this, SLOT(deletePrinter()));

    // Setup the Page Layout box
    populateCombo(m_panel.m_unitsCombo, unitsComboData, sizeof(unitsComboData)/sizeof(FlagData));
    connect(m_panel.m_unitsCombo, SIGNAL(currentIndexChanged(int)), this, SLOT(unitsChanged()));
#if QT_VERSION >= 0x050300
    for (int i = QPageSize::A4; i < QPageSize::LastPageSize; ++i) {
        QPageSize::PageSizeId id = QPageSize::PageSizeId(i);
        m_panel.m_pageSizeCombo->addItem(QPageSize::name(id), QVariant(id));
    }
#else
    populateCombo(m_panel.m_pageSizeCombo, pageSizeComboData, sizeof(pageSizeComboData)/sizeof(FlagData));
#endif
    connect(m_panel.m_pageSizeCombo, SIGNAL(currentIndexChanged(int)), this, SLOT(pageSizeChanged()));
    connect(m_panel.m_pageWidth, SIGNAL(valueChanged(double)), this, SLOT(pageDimensionsChanged()));
    connect(m_panel.m_pageHeight, SIGNAL(valueChanged(double)), this, SLOT(pageDimensionsChanged()));
    populateCombo(m_panel.m_orientationCombo, orientationComboData, sizeof(orientationComboData)/sizeof(FlagData));
    connect(m_panel.m_orientationCombo, SIGNAL(currentIndexChanged(int)), this, SLOT(orientationChanged()));
    connect(m_panel.m_leftMargin, SIGNAL(valueChanged(double)), this, SLOT(marginsChanged()));
    connect(m_panel.m_topMargin, SIGNAL(valueChanged(double)), this, SLOT(marginsChanged()));
    connect(m_panel.m_rightMargin, SIGNAL(valueChanged(double)), this, SLOT(marginsChanged()));
    connect(m_panel.m_bottomMargin, SIGNAL(valueChanged(double)), this, SLOT(marginsChanged()));
    populateCombo(m_panel.m_layoutModeCombo, layoutModeComboData, sizeof(layoutModeComboData)/sizeof(FlagData));
    connect(m_panel.m_layoutModeCombo, SIGNAL(currentIndexChanged(int)), this, SLOT(layoutModeChanged()));

    // Setup the Print Job box
    m_panel.m_printerCombo->addItem(tr("Print to PDF"), QVariant("PdfFormat"));
#if QT_VERSION >= 0x050300
    foreach (const QString &name, QPrinterInfo::availablePrinterNames())
        m_panel.m_printerCombo->addItem(name, QVariant(name));
#else
    foreach (const QPrinterInfo &printer, QPrinterInfo::availablePrinters())
        m_panel.m_printerCombo->addItem(printer.printerName(), QVariant(printer.printerName()));
#endif
    connect(m_panel.m_printerCombo, SIGNAL(currentIndexChanged(int)), this, SLOT(printerChanged()));
    populateCombo(m_panel.m_printRangeCombo, printRangeComboData, sizeof(printRangeComboData)/sizeof(FlagData));
    populateCombo(m_panel.m_pageOrderCombo, pageOrderComboData, sizeof(pageOrderComboData)/sizeof(FlagData));
    populateCombo(m_panel.m_duplexModeCombo, duplexModeComboData, sizeof(duplexModeComboData)/sizeof(FlagData));
    populateCombo(m_panel.m_paperSourceCombo, paperSourceComboData, sizeof(paperSourceComboData)/sizeof(FlagData));
    populateCombo(m_panel.m_colorModeCombo, colorModeComboData, sizeof(colorModeComboData)/sizeof(FlagData));

    // Setup the Dialogs box
    m_panel.m_dialogOptionsGroupBox->populateOptions(printDialogOptions, sizeof(printDialogOptions) / sizeof(FlagData));
    QPrintDialog dialog;
    m_panel.m_dialogOptionsGroupBox->setValue(dialog.options());
    connect(m_panel.m_printButton, SIGNAL(clicked()), this, SLOT(showPrintDialog()));
    connect(m_panel.m_printPreviewButton, SIGNAL(clicked()), this, SLOT(showPreviewDialog()));
    connect(m_panel.m_pageSetupButton, SIGNAL(clicked()), this, SLOT(showPageSetupDialog()));
    connect(m_panel.m_directPrintButton, SIGNAL(clicked()), this, SLOT(directPrint()));

    enablePanels();
    m_blockSignals = false;
}

PrintDialogPanel::~PrintDialogPanel()
{
}

void PrintDialogPanel::enablePanels()
{
    const bool exists = !m_printer.isNull();
    m_panel.m_createButton->setEnabled(!exists);
    m_panel.m_printerModeCombo->setEnabled(!exists);
    m_panel.m_deleteButton->setEnabled(exists);
    m_panel.m_pageLayoutGroupBox->setEnabled(exists);
    m_panel.m_printJobGroupBox->setEnabled(exists);
    m_panel.m_dialogsGroupBox->setEnabled(exists);
}

void PrintDialogPanel::createPrinter()
{
    const QPrinter::PrinterMode mode = comboBoxValue<QPrinter::PrinterMode>(m_panel.m_printerModeCombo);
    m_printer.reset(new QPrinter(mode)); // Can set only once.
    retrieveSettings(m_printer.data());
    enablePanels();
}

void PrintDialogPanel::deletePrinter()
{
    m_printer.reset();
    enablePanels();
}

QSizeF PrintDialogPanel::customPageSize() const
{
    return QSizeF(m_panel.m_pageWidth->value(), m_panel.m_pageHeight->value());
}

// Apply the settings to the QPrinter
void PrintDialogPanel::applySettings(QPrinter *printer) const
{
    const int currentIndex = m_panel.m_printerCombo->currentIndex();
    QString printerName = m_panel.m_printerCombo->itemData(currentIndex).toString();
    if (printerName == QLatin1String("PdfFormat"))
        printer->setOutputFileName(m_panel.m_fileName->text());
    else
        printer->setPrinterName(printerName);
    printer->setPrintRange(comboBoxValue<QPrinter::PrintRange>(m_panel.m_printRangeCombo));
    printer->setFromTo(m_panel.m_fromPage->value(), m_panel.m_toPage->value());
    printer->setPageOrder(comboBoxValue<QPrinter::PageOrder>(m_panel.m_pageOrderCombo));
    printer->setCopyCount(m_panel.m_copyCount->value());
    printer->setCollateCopies(m_panel.m_collateCopies->isChecked());
    printer->setDuplex(comboBoxValue<QPrinter::DuplexMode>(m_panel.m_duplexModeCombo));
    printer->setPaperSource(comboBoxValue<QPrinter::PaperSource>(m_panel.m_paperSourceCombo));
    printer->setColorMode(comboBoxValue<QPrinter::ColorMode>(m_panel.m_colorModeCombo));
    printer->setResolution(m_panel.m_resolution->value());

#if QT_VERSION >= 0x050300
    printer->setPageLayout(m_pageLayout);
#else
    if (m_printerLayout.pageSize() == QPrinter::Custom)
        printer->setPaperSize(customPageSize(), m_units);
    else
        printer->setPageSize(m_printerLayout.pageSize());
    printer->setOrientation(m_printerLayout.orientation());
    printer->setFullPage(m_printerLayout.fullPage());
    double left, top, right, bottom;
    m_printerLayout.getPageMargins(&left, &top, &right, &bottom, m_units);
    printer->setPageMargins(left, top, right, bottom, m_units);
#endif
}

// Retrieve the settings from the QPrinter
void PrintDialogPanel::retrieveSettings(const QPrinter *printer)
{
    if (printer->outputFormat() == QPrinter::NativeFormat) {
        m_panel.m_printerCombo->setCurrentIndex(m_panel.m_printerCombo->findData(QVariant(printer->printerName())));
        m_panel.m_fileName->setEnabled(false);
    } else {
        m_panel.m_printerCombo->setCurrentIndex(m_panel.m_printerCombo->findData(QVariant(QLatin1String("PdfFormat"))));
        m_panel.m_fileName->setEnabled(true);
    }
    m_panel.m_fileName->setText(printer->outputFileName());
    setComboBoxValue(m_panel.m_printRangeCombo, printer->printRange());
    m_panel.m_fromPage->setValue(printer->fromPage());
    m_panel.m_toPage->setValue(printer->toPage());
    setComboBoxValue(m_panel.m_pageOrderCombo, printer->pageOrder());
    m_panel.m_copyCount->setValue(printer->copyCount());
    m_panel.m_collateCopies->setChecked(printer->collateCopies());
    setComboBoxValue(m_panel.m_duplexModeCombo, printer->duplex());
    setComboBoxValue(m_panel.m_paperSourceCombo, printer->paperSource());
    setComboBoxValue(m_panel.m_colorModeCombo, printer->colorMode());
    m_panel.m_resolution->setValue(printer->resolution());

#ifdef Q_OS_WIN
    QString availPaperSources;
    foreach (QPrinter::PaperSource ps, printer->supportedPaperSources())
        availPaperSources += QString::number(int(ps)) + QLatin1Char(' ');
    m_panel.availPaperSourceLabel->setText(availPaperSources);
#else
    m_panel.availPaperSourceLabel->setText(QLatin1String("N/A"));
#endif

#if QT_VERSION >= 0x050300
    m_pageLayout = printer->pageLayout();
#else
    if (printer->pageSize() == QPrinter::Custom)
        m_printerLayout.setPaperSize(customPageSize(), m_units);
    else
        m_printerLayout.setPageSize(printer->pageSize());
    m_printerLayout.setOrientation(printer->orientation());
    m_printerLayout.setFullPage(printer->fullPage());
    double left, top, right, bottom;
    printer->getPageMargins(&left, &top, &right, &bottom, m_units);
    m_printerLayout.setPageMargins(left, top, right, bottom, m_units);
#endif
    updatePageLayoutWidgets();
}

void PrintDialogPanel::updatePageLayoutWidgets()
{
    m_blockSignals = true;
#if QT_VERSION >= 0x050300
    setComboBoxValue(m_panel.m_unitsCombo, m_pageLayout.units());
    setComboBoxValue(m_panel.m_pageSizeCombo, m_pageLayout.pageSize().id());
    QSizeF sizef = m_pageLayout.pageSize().size(QPageSize::Unit(m_pageLayout.units()));
    bool custom = (m_pageLayout.pageSize().id() == QPageSize::Custom);
    setComboBoxValue(m_panel.m_orientationCombo, m_pageLayout.orientation());
    m_panel.m_leftMargin->setValue(m_pageLayout.margins().left());
    m_panel.m_topMargin->setValue(m_pageLayout.margins().top());
    m_panel.m_rightMargin->setValue(m_pageLayout.margins().right());
    m_panel.m_bottomMargin->setValue(m_pageLayout.margins().bottom());
    setComboBoxValue(m_panel.m_layoutModeCombo, m_pageLayout.mode());
    QRectF rectf = m_pageLayout.paintRect();
#else
    setComboBoxValue(m_panel.m_unitsCombo, m_units);
    setComboBoxValue(m_panel.m_pageSizeCombo, m_printerLayout.pageSize());
    QSizeF sizef = m_printerLayout.paperSize(m_units);
    bool custom = (m_printerLayout.pageSize() == QPrinter::Custom);
    setComboBoxValue(m_panel.m_orientationCombo, m_printerLayout.orientation());
    double left, top, right, bottom;
    m_printerLayout.getPageMargins(&left, &top, &right, &bottom, m_units);
    m_panel.m_leftMargin->setValue(left);
    m_panel.m_topMargin->setValue(top);
    m_panel.m_rightMargin->setValue(right);
    m_panel.m_bottomMargin->setValue(bottom);
    if (m_printerLayout.fullPage())
        setComboBoxValue(m_panel.m_layoutModeCombo, QPageLayout::FullPageMode);
    else
        setComboBoxValue(m_panel.m_layoutModeCombo, QPageLayout::StandardMode);
    QRectF rectf = m_printerLayout.pageRect(m_units);
#endif
    m_panel.m_pageWidth->setValue(sizef.width());
    m_panel.m_pageHeight->setValue(sizef.height());
    m_panel.m_pageWidth->setEnabled(custom);
    m_panel.m_pageHeight->setEnabled(custom);
    m_panel.m_rectX->setValue(rectf.x());
    m_panel.m_rectY->setValue(rectf.y());
    m_panel.m_rectWidth->setValue(rectf.width());
    m_panel.m_rectHeight->setValue(rectf.height());
    QString suffix;
    switch (comboBoxValue<QPageLayout::Unit>(m_panel.m_unitsCombo)) {
    case QPageLayout::Millimeter:
        suffix = tr(" mm");
        break;
    case QPageLayout::Point:
        suffix = tr(" pt");
        break;
    case QPageLayout::Inch:
        suffix = tr(" in");
        break;
    case QPageLayout::Pica:
        suffix = tr(" pc");
        break;
    case QPageLayout::Didot:
        suffix = tr(" DD");
        break;
    case QPageLayout::Cicero:
        suffix = tr(" CC");
        break;
    }
    m_panel.m_pageWidth->setSuffix(suffix);
    m_panel.m_pageHeight->setSuffix(suffix);
    m_panel.m_leftMargin->setSuffix(suffix);
    m_panel.m_topMargin->setSuffix(suffix);
    m_panel.m_rightMargin->setSuffix(suffix);
    m_panel.m_bottomMargin->setSuffix(suffix);
    m_panel.m_rectX->setSuffix(suffix);
    m_panel.m_rectY->setSuffix(suffix);
    m_panel.m_rectWidth->setSuffix(suffix);
    m_panel.m_rectHeight->setSuffix(suffix);
    m_blockSignals = false;
}

void PrintDialogPanel::unitsChanged()
{
    if (m_blockSignals)
        return;
#if QT_VERSION >= 0x050300
    m_pageLayout.setUnits(comboBoxValue<QPageLayout::Unit>(m_panel.m_unitsCombo));
#else
    m_units = comboBoxValue<QPrinter::Unit>(m_panel.m_unitsCombo);
#endif
    updatePageLayoutWidgets();
}

void PrintDialogPanel::pageSizeChanged()
{
    if (m_blockSignals)
        return;
#if QT_VERSION >= 0x050300
    const QPageSize::PageSizeId pageSizeId = comboBoxValue<QPageSize::PageSizeId>(m_panel.m_pageSizeCombo);
    QPageSize pageSize;
    if (pageSizeId == QPageSize::Custom)
        pageSize = QPageSize(QSizeF(200, 200), QPageSize::Unit(m_pageLayout.units()));
    else
        pageSize = QPageSize(pageSizeId);
    m_pageLayout.setPageSize(pageSize);
#else
    const QPrinter::PageSize pageSize = comboBoxValue<QPrinter::PageSize>(m_panel.m_pageSizeCombo);
    if (pageSize == QPrinter::Custom)
        m_printerLayout.setPaperSize(QSizeF(200, 200), m_units);
    else
        m_printerLayout.setPageSize(pageSize);
#endif
    updatePageLayoutWidgets();
}

void PrintDialogPanel::pageDimensionsChanged()
{
    if (m_blockSignals)
        return;
#if QT_VERSION >= 0x050300
    m_pageLayout.setPageSize(QPageSize(customPageSize(), QPageSize::Unit(m_pageLayout.units())));
#else
    m_printerLayout.setPaperSize(customPageSize(), m_units);
#endif
    updatePageLayoutWidgets();
}

void PrintDialogPanel::orientationChanged()
{
    if (m_blockSignals)
        return;
#if QT_VERSION >= 0x050300
    m_pageLayout.setOrientation(comboBoxValue<QPageLayout::Orientation>(m_panel.m_orientationCombo));
#else
    m_printerLayout.setOrientation(comboBoxValue<QPrinter::Orientation>(m_panel.m_orientationCombo));
#endif
    updatePageLayoutWidgets();
}

void PrintDialogPanel::marginsChanged()
{
    if (m_blockSignals)
        return;
#if QT_VERSION >= 0x050300
    m_pageLayout.setMargins(QMarginsF(m_panel.m_leftMargin->value(), m_panel.m_topMargin->value(),
                                      m_panel.m_rightMargin->value(), m_panel.m_bottomMargin->value()));
#else
    m_printerLayout.setPageMargins(m_panel.m_leftMargin->value(), m_panel.m_topMargin->value(),
                                   m_panel.m_rightMargin->value(), m_panel.m_bottomMargin->value(),
                                   m_units);
#endif
    updatePageLayoutWidgets();
}

void PrintDialogPanel::layoutModeChanged()
{
    if (m_blockSignals)
        return;
#if QT_VERSION >= 0x050300
    m_pageLayout.setMode(comboBoxValue<QPageLayout::Mode>(m_panel.m_layoutModeCombo));
#else
    bool fullPage = (comboBoxValue<QPageLayout::Mode>(m_panel.m_layoutModeCombo) == QPageLayout::FullPageMode);
    m_printerLayout.setFullPage(fullPage);
#endif
    updatePageLayoutWidgets();
}

void PrintDialogPanel::printerChanged()
{
    const int currentIndex = m_panel.m_printerCombo->currentIndex();
    const bool isPdf = (m_panel.m_printerCombo->itemData(currentIndex).toString() == QLatin1String("PdfFormat"));
    m_panel.m_fileName->setEnabled(isPdf);
    if (isPdf && m_panel.m_fileName->text().isEmpty())
        m_panel.m_fileName->setText(QDir::homePath() + QDir::separator() + QLatin1String("print.pdf"));
}

void PrintDialogPanel::showPrintDialog()
{
    applySettings(m_printer.data());
    QPrintDialog dialog(m_printer.data(), this);
    dialog.setOptions(m_panel.m_dialogOptionsGroupBox->value<QPrintDialog::PrintDialogOptions>());
    if (dialog.exec() == QDialog::Accepted) {
        retrieveSettings(m_printer.data());
        print(m_printer.data(), this);
    }
}

void PrintDialogPanel::showPreviewDialog()
{
    applySettings(m_printer.data());
    PrintPreviewDialog dialog(m_printer.data(), this);
#if QT_VERSION >= 0x050000
    const QSize availableSize = screen()->availableSize();
#else
    const QSize availableSize = QApplication::desktop()->availableGeometry().size();
#endif
    dialog.resize(availableSize * 4/ 5);
    if (dialog.exec() == QDialog::Accepted)
        retrieveSettings(m_printer.data());
}

void PrintDialogPanel::showPageSetupDialog()
{
    applySettings(m_printer.data());
    QPageSetupDialog dialog(m_printer.data(), this);
    if (dialog.exec() == QDialog::Accepted)
        retrieveSettings(m_printer.data());
}

void PrintDialogPanel::directPrint()
{
    applySettings(m_printer.data());
    print(m_printer.data(), this);
    retrieveSettings(m_printer.data());
}

#include "moc_printdialogpanel.cpp"
#include "printdialogpanel.moc"

#endif // !QT_NO_PRINTER