AuroraMiddleware/qt5base-lts
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity
a0bd8c7893
qt5base-lts/tests/manual/dialogs/printdialogpanel.cpp
Volker Hilsheimer 44fb925f50 Phase 2 of removing QDesktopWidget 
Remove QDestopWidget public header, simplify the implementation that
maintains a Qt::Desktop type QWidget for each QScreen, and turn
QWidget's initial target screen into a QScreen pointer.

QApplication::desktop() now takes an optional QScreen pointer, and
returns a QWidget pointer, so that applications and widgets can get
access to the root widget for a specific screen without having to
resort to private APIs.

QDesktopWidgetPrivate implementations to look up a screen for an index,
widget, or point are now all inline functions that thinly wrap
QGuiApplication::screens/screenAt calls. We should consider adding those
as convenience APIs to QScreen instead.

Note that QWidget::screen is assumed to return a valid pointer; there is
code that handles the case that it returns nullptr (but also code that
trusts that it never is nullptr), so this needs to be defined, verified
with tests, and asserted. We can then simplify the code further.

Change-Id: Ifc89be65a0dce265b6729feaf54121c35137cb94
Reviewed-by: Shawn Rutledge <shawn.rutledge@qt.io>
Reviewed-by: Tor Arne Vestbø <tor.arne.vestbo@qt.io>
Reviewed-by: Qt CI Bot <qt_ci_bot@qt-project.org>
2020-06-08 20:29:49 +02:00

741 lines
27 KiB
C++
Raw Blame History

/****************************************************************************
**
** 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 <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() << Qt::forcesign << rect.x() << rect.y()
<< Qt::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
Reference in New Issue View Git Blame Copy Permalink