1 files changed, 373 insertions, 117 deletions

diff --git a/tests/manual/dialogs/printdialogpanel.cpp b/tests/manual/dialogs/printdialogpanel.cpp
index 5c89055e22..f7d027020c 100644
--- a/tests/manual/dialogs/printdialogpanel.cpp
+++ b/tests/manual/dialogs/printdialogpanel.cpp
@@ -45,6 +45,7 @@
 #include "utils.h"
 
 #include <QPrinter>
+#include <QPrinterInfo>
 #include <QPrintDialog>
 #include <QPrintPreviewDialog>
 #include <QPageSetupDialog>
@@ -64,20 +65,16 @@
 #include <QDateTime>
 #include <QDebug>
 #include <QTextStream>
+#include <QDir>
 
-const FlagData modeComboData[] =
+const FlagData printerModeComboData[] =
 {
     {"ScreenResolution", QPrinter::ScreenResolution},
     {"PrinterResolution", QPrinter::PrinterResolution},
     {"HighResolution", QPrinter::HighResolution}
 };
 
-const FlagData orientationComboData[] =
-{
-    {"Portrait", QPrinter::Portrait},
-    {"Landscape", QPrinter::Landscape},
-};
-
+#if QT_VERSION < 0x050300
 const FlagData pageSizeComboData[] =
 {
     {"A4", QPrinter::A4},
@@ -112,6 +109,76 @@ const FlagData pageSizeComboData[] =
     {"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[] =
 {
@@ -123,14 +190,6 @@ const FlagData printDialogOptions[] =
     {"PrintCurrentPage", QPrintDialog::PrintCurrentPage}
 };
 
-const FlagData printRangeOptions[] =
-{
-    {"AllPages", QPrintDialog::AllPages},
-    {"Selection", QPrintDialog::Selection},
-    {"PageRange", QPrintDialog::PageRange},
-    {"CurrentPage", QPrintDialog::CurrentPage}
-};
-
 QTextStream &operator<<(QTextStream &s, const QSizeF &size)
 {
     s << size.width() << 'x' << size.height();
@@ -260,93 +319,69 @@ public slots:
     void slotPaintRequested(QPrinter *p) { print(p); }
 };
 
-class PageSizeControl : public QWidget {
-public:
-    explicit PageSizeControl(QWidget *parent = 0);
-    QSizeF pageSize() const { return QSizeF(m_width->value(), m_height->value()); }
-    void setPageSize(const QSizeF &s) { m_width->setValue(s.width()); m_height->setValue(s.height()); }
-
-private:
-    QDoubleSpinBox *m_width;
-    QDoubleSpinBox *m_height;
-};
+PrintDialogPanel::PrintDialogPanel(QWidget *parent)
+    : QWidget(parent), m_blockSignals(true)
+{
+#if QT_VERSION < 0x050300
+    m_printerLayout.setOutputFormat(QPrinter::PdfFormat);
+#endif
 
-PageSizeControl::PageSizeControl(QWidget *parent)
-    : QWidget(parent)
-    , m_width(new QDoubleSpinBox(this))
-    , m_height(new QDoubleSpinBox(this))
-{
-    m_width->setRange(1, 1000);
-    m_width->setSingleStep(10);
-    m_height->setRange(1, 1000);
-    m_height->setSingleStep(10);
-    QHBoxLayout *hBoxLayout = new QHBoxLayout(this);
-    hBoxLayout->addWidget(m_width);
-    hBoxLayout->addWidget(new QLabel("x", this));
-    hBoxLayout->addWidget(m_height);
-    hBoxLayout->addWidget(new QLabel("mm", this));
-}
+    m_panel.setupUi(this);
 
-PrintDialogPanel::PrintDialogPanel(QWidget *parent)
-    : QWidget(parent)
-    , m_creationGroupBox(new QGroupBox(tr("Create"), this))
-    , m_settingsGroupBox(new QGroupBox(tr("Settings"), this))
-    , m_dialogsGroupBox(new QGroupBox(tr("Dialogs"), this))
-    , m_pageSizeCombo(new QComboBox)
-{
-    // Create with resolution
-    QHBoxLayout *hBoxLayout = new QHBoxLayout(m_creationGroupBox);
-    m_modeCombo = createCombo(m_creationGroupBox, modeComboData, sizeof(modeComboData)/sizeof(FlagData));
-    hBoxLayout->addWidget(m_modeCombo);
-    m_createButton = new QPushButton(tr("Create"), m_creationGroupBox);
-    connect(m_createButton, SIGNAL(clicked()), this, SLOT(createPrinter()));
-    hBoxLayout->addWidget(m_createButton);
-    m_deleteButton = new QPushButton(tr("Delete"), m_creationGroupBox);
-    connect(m_deleteButton, SIGNAL(clicked()), this, SLOT(deletePrinter()));
-    hBoxLayout->addWidget(m_deleteButton);
-    hBoxLayout->addItem(new QSpacerItem(0, 0, QSizePolicy::MinimumExpanding, QSizePolicy::Ignored));
-
-    QFormLayout *formLayout = new QFormLayout(m_settingsGroupBox);
-    m_pageSizeCombo = createCombo(m_settingsGroupBox, pageSizeComboData, sizeof(pageSizeComboData)/sizeof(FlagData));
-    connect(m_pageSizeCombo, SIGNAL(currentIndexChanged(int)), this, SLOT(enableCustomSizeControl()));
-    formLayout->addRow(tr("Paper #:"), m_pageSizeCombo);
-    m_customPageSizeControl = new PageSizeControl;
-    formLayout->addRow(tr("Custom size:"), m_customPageSizeControl);
-    m_orientationCombo = createCombo(m_settingsGroupBox, orientationComboData, sizeof(orientationComboData)/sizeof(FlagData));
-    formLayout->addRow("Orientation:", m_orientationCombo);
-    m_fullPageCheckBox = new QCheckBox(tr("Full page"), m_settingsGroupBox);
-    formLayout->addRow(m_fullPageCheckBox);
-
-    QVBoxLayout *vBoxLayout = new QVBoxLayout(m_dialogsGroupBox);
-
-    m_printDialogOptionsControl = new OptionsControl(tr("Options"), printDialogOptions, sizeof(printDialogOptions) / sizeof(FlagData), m_dialogsGroupBox);
-    vBoxLayout->addWidget(m_printDialogOptionsControl);
-    m_printDialogRangeCombo = createCombo(m_dialogsGroupBox, printRangeOptions, sizeof(printRangeOptions) / sizeof(FlagData));
-    vBoxLayout->addWidget(m_printDialogRangeCombo);
+    // 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()));
 
-    {
-        QPrintDialog dialog;
-        m_printDialogOptionsControl->setValue(dialog.options());
-        m_printDialogRangeCombo->setCurrentIndex(dialog.printRange());
+    // 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));
     }
-
-    QPushButton *button = new QPushButton(tr("Print..."), m_dialogsGroupBox);
-    connect(button, SIGNAL(clicked()), this, SLOT(showPrintDialog()));
-    vBoxLayout->addWidget(button);
-    button = new QPushButton(tr("Preview..."), m_dialogsGroupBox);
-    connect(button, SIGNAL(clicked()), this, SLOT(showPreviewDialog()));
-    vBoxLayout->addWidget(button);
-    button = new QPushButton(tr("Page Setup..."), m_dialogsGroupBox);
-    connect(button, SIGNAL(clicked()), this, SLOT(showPageSetupDialog()));
-    vBoxLayout->addWidget(button);
-
-    QGridLayout *gridLayout = new QGridLayout(this);
-    gridLayout->addWidget(m_creationGroupBox, 0, 0);
-    gridLayout->addWidget(m_settingsGroupBox, 1, 0);
-    gridLayout->addWidget(m_dialogsGroupBox, 0, 1, 2, 1);
-    gridLayout->addItem(new QSpacerItem(0, 0, QSizePolicy::Ignored, QSizePolicy::MinimumExpanding), 2, 0, 1, 2);
+#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()));
 
     enablePanels();
+    m_blockSignals = false;
 }
 
 PrintDialogPanel::~PrintDialogPanel()
@@ -356,20 +391,20 @@ PrintDialogPanel::~PrintDialogPanel()
 void PrintDialogPanel::enablePanels()
 {
     const bool exists = !m_printer.isNull();
-    m_createButton->setEnabled(!exists);
-    m_modeCombo->setEnabled(!exists);
-    m_deleteButton->setEnabled(exists);
-    m_settingsGroupBox->setEnabled(exists);
-    m_dialogsGroupBox->setEnabled(exists);
+    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_modeCombo);
+    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();
-    enableCustomSizeControl();
 }
 
 void PrintDialogPanel::deletePrinter()
@@ -378,36 +413,256 @@ void PrintDialogPanel::deletePrinter()
     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 QPrinter::PageSize pageSize = comboBoxValue<QPrinter::PageSize>(m_pageSizeCombo);
-    if (pageSize == QPrinter::Custom)
-        printer->setPaperSize(m_customPageSizeControl->pageSize(), QPrinter::Millimeter);
+    QString printerName = m_panel.m_printerCombo->currentData().toString();
+    if (printerName == QStringLiteral("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(pageSize);
-    printer->setOrientation(comboBoxValue<QPrinter::Orientation>(m_orientationCombo));
-    printer->setFullPage(m_fullPageCheckBox->isChecked());
+        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)
 {
-    setComboBoxValue(m_pageSizeCombo, printer->pageSize());
-    setComboBoxValue(m_orientationCombo, printer->orientation());
-    m_fullPageCheckBox->setChecked(printer->fullPage());
-    m_customPageSizeControl->setPageSize(m_printer->paperSize(QPrinter::Millimeter));
+    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(QStringLiteral("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());
+
+#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::enableCustomSizeControl()
+void PrintDialogPanel::printerChanged()
 {
-    m_customPageSizeControl->setEnabled(m_pageSizeCombo->currentIndex() == QPrinter::Custom);
+    bool isPdf = (m_panel.m_printerCombo->currentData().toString() == QStringLiteral("PdfFormat"));
+    m_panel.m_fileName->setEnabled(isPdf);
+    if (isPdf && m_panel.m_fileName->text().isEmpty())
+        m_panel.m_fileName->setText(QDir::homePath() + QDir::separator() + QStringLiteral("print.pdf"));
 }
 
 void PrintDialogPanel::showPrintDialog()
 {
     applySettings(m_printer.data());
     QPrintDialog dialog(m_printer.data(), this);
-    dialog.setOptions(m_printDialogOptionsControl->value<QPrintDialog::PrintDialogOptions>());
-    dialog.setPrintRange(comboBoxValue<QPrintDialog::PrintRange>(m_printDialogRangeCombo));
+    dialog.setOptions(m_panel.m_dialogOptionsGroupBox->value<QPrintDialog::PrintDialogOptions>());
     if (dialog.exec() == QDialog::Accepted) {
         retrieveSettings(m_printer.data());
         print(m_printer.data());
@@ -431,6 +686,7 @@ void PrintDialogPanel::showPageSetupDialog()
         retrieveSettings(m_printer.data());
 }
 
+#include "moc_printdialogpanel.cpp"
 #include "printdialogpanel.moc"
 
 #endif // !QT_NO_PRINTER