openkylin
/
qtbase-opensource-src
mirror of https://gitee.com/openkylin/qtbase-opensource-src.git
9
0
Fork 0
Code Issues Projects Releases Wiki Activity
qtbase-opensource-src/tests/manual/dialogs/printdialogpanel.cpp

741 lines
27 KiB
C++
Raw Permalink 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 <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
Reference in New Issue View Git Blame Copy Permalink