qprinter.cpp

Go to the documentation of this file.

// Copyright (C) 2016 The Qt Company Ltd.
// SPDX-License-Identifier: LicenseRef-Qt-Commercial OR LGPL-3.0-only OR GPL-2.0-only OR GPL-3.0-only
 
#include "qprinter.h"
#include "qprinter_p.h"
 
#ifndef QT_NO_PRINTER
 
#include <qpa/qplatformprintplugin.h>
#include <qpa/qplatformprintersupport.h>
 
#include "qprintengine.h"
#include "qlist.h"
#include <qcoreapplication.h>
#include <qfileinfo.h>
 
#include <private/qpagedpaintdevice_p.h>
 
#include "qprintengine_pdf_p.h"
 
#include <qpicture.h>
#if QT_CONFIG(printpreviewwidget)
#include <private/qpaintengine_preview_p.h>
#endif
 
QT_BEGIN_NAMESPACE
 
using namespace Qt::StringLiterals;
 
#define ABORT_IF_ACTIVE(location) \
    if (d->printEngine->printerState() == QPrinter::Active) { \
        qWarning("%s: Cannot be changed while printer is active", location); \
        return; \
    }
 
#define ABORT_IF_ACTIVE_RETURN(location, retValue) \
    if (d->printEngine->printerState() == QPrinter::Active) { \
        qWarning("%s: Cannot be changed while printer is active", location); \
        return retValue; \
    }
 
extern qreal qt_pixelMultiplier(int resolution);
extern QMarginsF qt_convertMargins(const QMarginsF &margins, QPageLayout::Unit fromUnits, QPageLayout::Unit toUnits);
 
QPrinterInfo QPrinterPrivate::findValidPrinter(const QPrinterInfo &printer)
{
    // Try find a valid printer to use, either the one given, the default or the first available
    QPrinterInfo printerToUse = printer;
    if (printerToUse.isNull()) {
        printerToUse = QPrinterInfo::defaultPrinter();
        if (printerToUse.isNull()) {
            QStringList availablePrinterNames = QPrinterInfo::availablePrinterNames();
            if (!availablePrinterNames.isEmpty())
                printerToUse = QPrinterInfo::printerInfo(availablePrinterNames.at(0));
        }
    }
    return printerToUse;
}
 
void QPrinterPrivate::initEngines(QPrinter::OutputFormat format, const QPrinterInfo &printer)
{
    // Default to PdfFormat
    outputFormat = QPrinter::PdfFormat;
    QPlatformPrinterSupport *ps = nullptr;
    QString printerName;
 
    // Only set NativeFormat if we have a valid plugin and printer to use
    if (format == QPrinter::NativeFormat) {
        ps = QPlatformPrinterSupportPlugin::get();
        QPrinterInfo printerToUse = findValidPrinter(printer);
        if (ps && !printerToUse.isNull()) {
            outputFormat = QPrinter::NativeFormat;
            printerName = printerToUse.printerName();
        }
    }
 
    if (outputFormat == QPrinter::NativeFormat) {
        printEngine = ps->createNativePrintEngine(printerMode, printerName);
        paintEngine = ps->createPaintEngine(printEngine, printerMode);
    } else {
        static const QHash<QPrinter::PdfVersion, QPdfEngine::PdfVersion> engineMapping {
            {QPrinter::PdfVersion_1_4, QPdfEngine::Version_1_4},
            {QPrinter::PdfVersion_A1b, QPdfEngine::Version_A1b},
            {QPrinter::PdfVersion_1_6, QPdfEngine::Version_1_6}
        };
        const auto pdfEngineVersion = engineMapping.value(pdfVersion, QPdfEngine::Version_1_4);
        QPdfPrintEngine *pdfEngine = new QPdfPrintEngine(printerMode, pdfEngineVersion);
        paintEngine = pdfEngine;
        printEngine = pdfEngine;
    }
 
    use_default_engine = true;
    had_default_engines = true;
    validPrinter = true;
}
 
void QPrinterPrivate::changeEngines(QPrinter::OutputFormat format, const QPrinterInfo &printer)
{
    QPrintEngine *oldPrintEngine = printEngine;
    const bool def_engine = use_default_engine;
 
    initEngines(format, printer);
 
    if (oldPrintEngine) {
        const auto properties = m_properties; // take a copy: setProperty() below modifies m_properties
        for (const auto &key : properties) {
            QVariant prop;
            // PPK_NumberOfCopies need special treatmeant since it in most cases
            // will return 1, disregarding the actual value that was set
            // PPK_PrinterName also needs special treatment as initEngines has set it already
            if (key == QPrintEngine::PPK_NumberOfCopies)
                prop = QVariant(q_ptr->copyCount());
            else if (key != QPrintEngine::PPK_PrinterName)
                prop = oldPrintEngine->property(key);
            if (prop.isValid())
                setProperty(key, prop);
        }
    }
 
    if (def_engine)
        delete oldPrintEngine;
}
 
#if QT_CONFIG(printpreviewwidget)
QList<const QPicture *> QPrinterPrivate::previewPages() const
{
    if (previewEngine)
        return previewEngine->pages();
    return QList<const QPicture *>();
}
 
bool QPrinterPrivate::previewMode() const
{
    return (previewEngine != nullptr) && (previewEngine == printEngine);
}
 
void QPrinterPrivate::setPreviewMode(bool enable)
{
    Q_Q(QPrinter);
    if (enable) {
        if (!previewEngine)
            previewEngine = new QPreviewPaintEngine;
        had_default_engines = use_default_engine;
        use_default_engine = false;
        realPrintEngine = printEngine;
        realPaintEngine = paintEngine;
        q->setEngines(previewEngine, previewEngine);
        previewEngine->setProxyEngines(realPrintEngine, realPaintEngine);
    } else {
        q->setEngines(realPrintEngine, realPaintEngine);
        use_default_engine = had_default_engines;
    }
}
#endif // QT_CONFIG(printpreviewwidget)
 
void QPrinterPrivate::setProperty(QPrintEngine::PrintEnginePropertyKey key, const QVariant &value)
{
    printEngine->setProperty(key, value);
    m_properties.insert(key);
}
 
 
class QPrinterPagedPaintDevicePrivate : public QPagedPaintDevicePrivate
{
public:
    QPrinterPagedPaintDevicePrivate(QPrinter *p)
        : QPagedPaintDevicePrivate(), m_printer(p)
    {}
 
    virtual ~QPrinterPagedPaintDevicePrivate()
    {}
 
    bool setPageLayout(const QPageLayout &newPageLayout) override
    {
        QPrinterPrivate *pd = QPrinterPrivate::get(m_printer);
 
        if (pd->paintEngine->type() != QPaintEngine::Pdf
            && pd->printEngine->printerState() == QPrinter::Active) {
            qWarning("QPrinter::setPageLayout: Cannot be changed while printer is active");
            return false;
        }
 
        // Try to set the print engine page layout
        pd->setProperty(QPrintEngine::PPK_QPageLayout, QVariant::fromValue(newPageLayout));
 
        return pageLayout().isEquivalentTo(newPageLayout);
    }
 
    bool setPageSize(const QPageSize &pageSize) override
    {
        QPrinterPrivate *pd = QPrinterPrivate::get(m_printer);
 
        if (pd->paintEngine->type() != QPaintEngine::Pdf
            && pd->printEngine->printerState() == QPrinter::Active) {
            qWarning("QPrinter::setPageLayout: Cannot be changed while printer is active");
            return false;
        }
 
 
        // Try to set the print engine page size
        pd->setProperty(QPrintEngine::PPK_QPageSize, QVariant::fromValue(pageSize));
 
        return pageLayout().pageSize().isEquivalentTo(pageSize);
    }
 
    bool setPageOrientation(QPageLayout::Orientation orientation) override
    {
        QPrinterPrivate *pd = QPrinterPrivate::get(m_printer);
 
        // Set the print engine value
        pd->setProperty(QPrintEngine::PPK_Orientation, orientation);
 
        return pageLayout().orientation() == orientation;
    }
 
    bool setPageMargins(const QMarginsF &margins, QPageLayout::Unit units) override
    {
        QPrinterPrivate *pd = QPrinterPrivate::get(m_printer);
 
        // Try to set print engine margins
        QPair<QMarginsF, QPageLayout::Unit> pair = qMakePair(margins, units);
        pd->setProperty(QPrintEngine::PPK_QPageMargins, QVariant::fromValue(pair));
 
        return pageLayout().margins() == margins && pageLayout().units() == units;
    }
 
    QPageLayout pageLayout() const override
    {
        QPrinterPrivate *pd = QPrinterPrivate::get(m_printer);
 
        return qvariant_cast<QPageLayout>(pd->printEngine->property(QPrintEngine::PPK_QPageLayout));
    }
 
    QPrinter *m_printer;
};
 
 
QPrinter::QPrinter(PrinterMode mode)
    : QPagedPaintDevice(new QPrinterPagedPaintDevicePrivate(this)),
      d_ptr(new QPrinterPrivate(this))
{
    d_ptr->init(QPrinterInfo(), mode);
}
 
QPrinter::QPrinter(const QPrinterInfo& printer, PrinterMode mode)
    : QPagedPaintDevice(new QPrinterPagedPaintDevicePrivate(this)),
      d_ptr(new QPrinterPrivate(this))
{
    d_ptr->init(printer, mode);
}
 
void QPrinterPrivate::init(const QPrinterInfo &printer, QPrinter::PrinterMode mode)
{
    if (Q_UNLIKELY(!QCoreApplication::instance())) {
        qFatal("QPrinter: Must construct a QCoreApplication before a QPrinter");
        return;
    }
 
    printerMode = mode;
 
    initEngines(QPrinter::NativeFormat, printer);
}
 
void QPrinter::setEngines(QPrintEngine *printEngine, QPaintEngine *paintEngine)
{
    Q_D(QPrinter);
 
    if (d->use_default_engine)
        delete d->printEngine;
 
    d->printEngine = printEngine;
    d->paintEngine = paintEngine;
    d->use_default_engine = false;
}
 
QPrinter::~QPrinter()
{
    Q_D(QPrinter);
    if (d->use_default_engine)
        delete d->printEngine;
#if QT_CONFIG(printpreviewwidget)
    delete d->previewEngine;
#endif
}
 
void QPrinter::setOutputFormat(OutputFormat format)
{
    Q_D(QPrinter);
 
    if (d->outputFormat == format)
        return;
 
    if (format == QPrinter::NativeFormat) {
        QPrinterInfo printerToUse = d->findValidPrinter();
        if (!printerToUse.isNull())
            d->changeEngines(format, printerToUse);
    } else {
        d->changeEngines(format, QPrinterInfo());
    }
}
 
QPrinter::OutputFormat QPrinter::outputFormat() const
{
    Q_D(const QPrinter);
    return d->outputFormat;
}
 
void QPrinter::setPdfVersion(PdfVersion version)
{
    Q_D(QPrinter);
 
    if (d->pdfVersion == version)
        return;
 
    d->pdfVersion = version;
 
    if (d->outputFormat == QPrinter::PdfFormat) {
        d->changeEngines(d->outputFormat, QPrinterInfo());
    }
}
 
QPrinter::PdfVersion QPrinter::pdfVersion() const
{
    Q_D(const QPrinter);
    return d->pdfVersion;
}
 
int QPrinter::devType() const
{
    return QInternal::Printer;
}
 
QString QPrinter::printerName() const
{
    Q_D(const QPrinter);
    return d->printEngine->property(QPrintEngine::PPK_PrinterName).toString();
}
 
void QPrinter::setPrinterName(const QString &name)
{
    Q_D(QPrinter);
    ABORT_IF_ACTIVE("QPrinter::setPrinterName");
 
    if (printerName() == name)
        return;
 
    if (name.isEmpty()) {
        setOutputFormat(QPrinter::PdfFormat);
        return;
    }
 
    QPrinterInfo printerToUse = QPrinterInfo::printerInfo(name);
    if (printerToUse.isNull())
        return;
 
    if (outputFormat() == QPrinter::PdfFormat) {
        d->changeEngines(QPrinter::NativeFormat, printerToUse);
    } else {
        d->setProperty(QPrintEngine::PPK_PrinterName, name);
    }
}
 
bool QPrinter::isValid() const
{
    Q_D(const QPrinter);
    if (!qApp)
        return false;
    return d->validPrinter;
}
 
QString QPrinter::outputFileName() const
{
    Q_D(const QPrinter);
    return d->printEngine->property(QPrintEngine::PPK_OutputFileName).toString();
}
 
void QPrinter::setOutputFileName(const QString &fileName)
{
    Q_D(QPrinter);
    ABORT_IF_ACTIVE("QPrinter::setOutputFileName");
 
    QFileInfo fi(fileName);
    if (!fi.suffix().compare("pdf"_L1, Qt::CaseInsensitive))
        setOutputFormat(QPrinter::PdfFormat);
    else if (fileName.isEmpty())
        setOutputFormat(QPrinter::NativeFormat);
 
    d->setProperty(QPrintEngine::PPK_OutputFileName, fileName);
}
 
 
QString QPrinter::printProgram() const
{
    Q_D(const QPrinter);
    return d->printEngine->property(QPrintEngine::PPK_PrinterProgram).toString();
}
 
 
void QPrinter::setPrintProgram(const QString &printProg)
{
    Q_D(QPrinter);
    ABORT_IF_ACTIVE("QPrinter::setPrintProgram");
    d->setProperty(QPrintEngine::PPK_PrinterProgram, printProg);
}
 
 
QString QPrinter::docName() const
{
    Q_D(const QPrinter);
    return d->printEngine->property(QPrintEngine::PPK_DocumentName).toString();
}
 
 
void QPrinter::setDocName(const QString &name)
{
    Q_D(QPrinter);
    ABORT_IF_ACTIVE("QPrinter::setDocName");
    d->setProperty(QPrintEngine::PPK_DocumentName, name);
}
 
 
QString QPrinter::creator() const
{
    Q_D(const QPrinter);
    return d->printEngine->property(QPrintEngine::PPK_Creator).toString();
}
 
 
void QPrinter::setCreator(const QString &creator)
{
    Q_D(QPrinter);
    ABORT_IF_ACTIVE("QPrinter::setCreator");
    d->setProperty(QPrintEngine::PPK_Creator, creator);
}
 
void QPrinter::setPageOrder(PageOrder pageOrder)
{
    d->pageOrderAscending = (pageOrder == FirstPageFirst);
 
    Q_D(QPrinter);
    ABORT_IF_ACTIVE("QPrinter::setPageOrder");
    d->setProperty(QPrintEngine::PPK_PageOrder, pageOrder);
}
 
 
QPrinter::PageOrder QPrinter::pageOrder() const
{
    Q_D(const QPrinter);
    return QPrinter::PageOrder(d->printEngine->property(QPrintEngine::PPK_PageOrder).toInt());
}
 
 
void QPrinter::setColorMode(ColorMode newColorMode)
{
    Q_D(QPrinter);
    ABORT_IF_ACTIVE("QPrinter::setColorMode");
    d->setProperty(QPrintEngine::PPK_ColorMode, newColorMode);
}
 
 
QPrinter::ColorMode QPrinter::colorMode() const
{
    Q_D(const QPrinter);
    return QPrinter::ColorMode(d->printEngine->property(QPrintEngine::PPK_ColorMode).toInt());
}
 
void QPrinter::setCopyCount(int count)
{
    Q_D(QPrinter);
    ABORT_IF_ACTIVE("QPrinter::setCopyCount;");
    d->setProperty(QPrintEngine::PPK_CopyCount, count);
}
 
int QPrinter::copyCount() const
{
    Q_D(const QPrinter);
    return d->printEngine->property(QPrintEngine::PPK_CopyCount).toInt();
}
 
bool QPrinter::supportsMultipleCopies() const
{
    Q_D(const QPrinter);
    return d->printEngine->property(QPrintEngine::PPK_SupportsMultipleCopies).toBool();
}
 
bool QPrinter::collateCopies() const
{
    Q_D(const QPrinter);
    return d->printEngine->property(QPrintEngine::PPK_CollateCopies).toBool();
}
 
 
void QPrinter::setCollateCopies(bool collate)
{
    Q_D(QPrinter);
    ABORT_IF_ACTIVE("QPrinter::setCollateCopies");
    d->setProperty(QPrintEngine::PPK_CollateCopies, collate);
}
 
 
 
void QPrinter::setFullPage(bool fp)
{
    Q_D(QPrinter);
    // Set the print engine
    d->setProperty(QPrintEngine::PPK_FullPage, fp);
}
 
 
bool QPrinter::fullPage() const
{
    Q_D(const QPrinter);
    return d->printEngine->property(QPrintEngine::PPK_FullPage).toBool();
}
 
 
void QPrinter::setResolution(int dpi)
{
    Q_D(QPrinter);
    ABORT_IF_ACTIVE("QPrinter::setResolution");
    d->setProperty(QPrintEngine::PPK_Resolution, dpi);
}
 
 
int QPrinter::resolution() const
{
    Q_D(const QPrinter);
    return d->printEngine->property(QPrintEngine::PPK_Resolution).toInt();
}
 
void QPrinter::setPaperSource(PaperSource source)
{
    Q_D(QPrinter);
    d->setProperty(QPrintEngine::PPK_PaperSource, source);
}
 
QPrinter::PaperSource QPrinter::paperSource() const
{
    Q_D(const QPrinter);
    return QPrinter::PaperSource(d->printEngine->property(QPrintEngine::PPK_PaperSource).toInt());
}
 
 
void QPrinter::setFontEmbeddingEnabled(bool enable)
{
    Q_D(QPrinter);
    d->setProperty(QPrintEngine::PPK_FontEmbedding, enable);
}
 
bool QPrinter::fontEmbeddingEnabled() const
{
    Q_D(const QPrinter);
    return d->printEngine->property(QPrintEngine::PPK_FontEmbedding).toBool();
}
 
void QPrinter::setDuplex(DuplexMode duplex)
{
    Q_D(QPrinter);
    d->setProperty(QPrintEngine::PPK_Duplex, duplex);
}
 
QPrinter::DuplexMode QPrinter::duplex() const
{
    Q_D(const QPrinter);
    return static_cast <DuplexMode> (d->printEngine->property(QPrintEngine::PPK_Duplex).toInt());
}
 
QRectF QPrinter::pageRect(Unit unit) const
{
    if (unit == QPrinter::DevicePixel)
        return pageLayout().paintRectPixels(resolution());
    else
        return pageLayout().paintRect(QPageLayout::Unit(unit));
}
 
 
QRectF QPrinter::paperRect(Unit unit) const
{
    if (unit == QPrinter::DevicePixel)
        return pageLayout().fullRectPixels(resolution());
    else
        return pageLayout().fullRect(QPageLayout::Unit(unit));
}
 
int QPrinter::metric(PaintDeviceMetric id) const
{
    Q_D(const QPrinter);
    return d->printEngine->metric(id);
}
 
QPaintEngine *QPrinter::paintEngine() const
{
    Q_D(const QPrinter);
    return d->paintEngine;
}
 
QPrintEngine *QPrinter::printEngine() const
{
    Q_D(const QPrinter);
    return d->printEngine;
}
 
QList<int> QPrinter::supportedResolutions() const
{
    Q_D(const QPrinter);
    const QList<QVariant> varlist
        = d->printEngine->property(QPrintEngine::PPK_SupportedResolutions).toList();
    QList<int> intlist;
    intlist.reserve(varlist.size());
    for (const auto &var : varlist)
        intlist << var.toInt();
    return intlist;
}
 
bool QPrinter::newPage()
{
    Q_D(QPrinter);
    if (d->printEngine->printerState() != QPrinter::Active)
        return false;
    return d->printEngine->newPage();
}
 
bool QPrinter::abort()
{
    Q_D(QPrinter);
    return d->printEngine->abort();
}
 
QPrinter::PrinterState QPrinter::printerState() const
{
    Q_D(const QPrinter);
    return d->printEngine->printerState();
}
 
#if defined(Q_OS_WIN) || defined(Q_QDOC)
QList<QPrinter::PaperSource> QPrinter::supportedPaperSources() const
{
    Q_D(const QPrinter);
    QVariant v = d->printEngine->property(QPrintEngine::PPK_PaperSources);
 
    const QList<QVariant> variant_list = v.toList();
    QList<QPrinter::PaperSource> int_list;
    int_list.reserve(variant_list.size());
    for (const auto &variant : variant_list)
        int_list << QPrinter::PaperSource(variant.toInt());
 
    return int_list;
}
 
#endif // Q_OS_WIN
 
QString QPrinter::printerSelectionOption() const
{
    Q_D(const QPrinter);
    return d->printEngine->property(QPrintEngine::PPK_SelectionOption).toString();
}
 
void QPrinter::setPrinterSelectionOption(const QString &option)
{
    Q_D(QPrinter);
    d->setProperty(QPrintEngine::PPK_SelectionOption, option);
}
 
int QPrinter::fromPage() const
{
    return d->pageRanges.firstPage();
}
 
int QPrinter::toPage() const
{
    return d->pageRanges.lastPage();
}
 
void QPrinter::setFromTo(int from, int to)
{
    d->pageRanges.clear();
    if (from && to)
        d->pageRanges.addRange(from, to);
}
 
void QPrinter::setPrintRange( PrintRange range )
{
    d->printSelectionOnly = (range == Selection);
 
    Q_D(QPrinter);
    d->printRange = range;
}
 
QPrinter::PrintRange QPrinter::printRange() const
{
    Q_D(const QPrinter);
    return d->printRange;
}
 
 
QT_END_NAMESPACE
 
#endif // QT_NO_PRINTER