qprinterinfo.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 "qprinterinfo.h"
#include "qprinterinfo_p.h"
#include "qprintdevice_p.h"
 
#ifndef QT_NO_PRINTER
 
#include <QtCore/qdebug.h>
 
#include <qpa/qplatformprintplugin.h>
#include <qpa/qplatformprintersupport.h>
 
QT_BEGIN_NAMESPACE
 
Q_GLOBAL_STATIC(QPrinterInfoPrivate, shared_null);
 
class QPrinterInfoPrivateDeleter
{
public:
    static inline void cleanup(QPrinterInfoPrivate *d)
    {
        if (d != &*shared_null)
            delete d;
    }
};
 
QPrinterInfoPrivate::QPrinterInfoPrivate(const QString &id)
{
    if (!id.isEmpty()) {
        QPlatformPrinterSupport *ps = QPlatformPrinterSupportPlugin::get();
        if (ps)
            m_printDevice = ps->createPrintDevice(id);
    }
}
 
QPrinterInfoPrivate::~QPrinterInfoPrivate()
{
}
 
QPrinterInfo::QPrinterInfo()
    : d_ptr(shared_null)
{
}
 
QPrinterInfo::QPrinterInfo(const QPrinterInfo &other)
    : d_ptr((other.d_ptr.data() == shared_null) ? &*shared_null : new QPrinterInfoPrivate(*other.d_ptr))
{
}
 
QPrinterInfo::QPrinterInfo(const QPrinter &printer)
    : d_ptr(shared_null)
{
    QPlatformPrinterSupport *ps = QPlatformPrinterSupportPlugin::get();
    if (ps) {
        QPrinterInfo pi(printer.printerName());
        if (pi.d_ptr.data() == shared_null)
            d_ptr.reset(shared_null);
        else
            d_ptr.reset(new QPrinterInfoPrivate(*pi.d_ptr));
    }
}
 
QPrinterInfo::QPrinterInfo(const QString &name)
    : d_ptr(new QPrinterInfoPrivate(name))
{
}
 
QPrinterInfo::~QPrinterInfo()
{
}
 
QPrinterInfo &QPrinterInfo::operator=(const QPrinterInfo &other)
{
    Q_ASSERT(d_ptr);
    if (other.d_ptr.data() == shared_null)
        d_ptr.reset(shared_null);
    else
        d_ptr.reset(new QPrinterInfoPrivate(*other.d_ptr));
    return *this;
}
 
QString QPrinterInfo::printerName() const
{
    const Q_D(QPrinterInfo);
    return d->m_printDevice.id();
}
 
QString QPrinterInfo::description() const
{
    const Q_D(QPrinterInfo);
    return d->m_printDevice.name();
}
 
QString QPrinterInfo::location() const
{
    const Q_D(QPrinterInfo);
    return d->m_printDevice.location();
}
 
QString QPrinterInfo::makeAndModel() const
{
    const Q_D(QPrinterInfo);
    return d->m_printDevice.makeAndModel();
}
 
bool QPrinterInfo::isNull() const
{
    Q_D(const QPrinterInfo);
    return d == shared_null || !d->m_printDevice.isValid();
}
 
bool QPrinterInfo::isDefault() const
{
    Q_D(const QPrinterInfo);
    return d->m_printDevice.isDefault();
}
 
bool QPrinterInfo::isRemote() const
{
    Q_D(const QPrinterInfo);
    return d->m_printDevice.isRemote();
}
 
QPrinter::PrinterState QPrinterInfo::state() const
{
    Q_D(const QPrinterInfo);
    return QPrinter::PrinterState(d->m_printDevice.state());
}
 
QList<QPageSize> QPrinterInfo::supportedPageSizes() const
{
    Q_D(const QPrinterInfo);
    return d->m_printDevice.supportedPageSizes();
}
 
QPageSize QPrinterInfo::defaultPageSize() const
{
    Q_D(const QPrinterInfo);
    return d->m_printDevice.defaultPageSize();
}
 
bool QPrinterInfo::supportsCustomPageSizes() const
{
    Q_D(const QPrinterInfo);
    return d->m_printDevice.supportsCustomPageSizes();
}
 
QPageSize QPrinterInfo::minimumPhysicalPageSize() const
{
    Q_D(const QPrinterInfo);
    return QPageSize(d->m_printDevice.minimumPhysicalPageSize(), QString(), QPageSize::ExactMatch);
}
 
QPageSize QPrinterInfo::maximumPhysicalPageSize() const
{
    Q_D(const QPrinterInfo);
    return QPageSize(d->m_printDevice.maximumPhysicalPageSize(), QString(), QPageSize::ExactMatch);
}
 
QList<int> QPrinterInfo::supportedResolutions() const
{
    Q_D(const QPrinterInfo);
    return d->m_printDevice.supportedResolutions();
}
 
QPrinter::DuplexMode QPrinterInfo::defaultDuplexMode() const
{
    Q_D(const QPrinterInfo);
    return QPrinter::DuplexMode(d->m_printDevice.defaultDuplexMode());
}
 
QList<QPrinter::DuplexMode> QPrinterInfo::supportedDuplexModes() const
{
    Q_D(const QPrinterInfo);
    QList<QPrinter::DuplexMode> list;
    const auto supportedDuplexModes = d->m_printDevice.supportedDuplexModes();
    list.reserve(supportedDuplexModes.size());
    for (QPrint::DuplexMode mode : supportedDuplexModes)
        list << QPrinter::DuplexMode(mode);
    return list;
}
 
QPrinter::ColorMode QPrinterInfo::defaultColorMode() const
{
    Q_D(const QPrinterInfo);
    return QPrinter::ColorMode(d->m_printDevice.defaultColorMode());
}
 
QList<QPrinter::ColorMode> QPrinterInfo::supportedColorModes() const
{
    Q_D(const QPrinterInfo);
    QList<QPrinter::ColorMode> list;
    const auto supportedColorModes = d->m_printDevice.supportedColorModes();
    list.reserve(supportedColorModes.size());
    for (QPrint::ColorMode mode : supportedColorModes)
        list << QPrinter::ColorMode(mode);
    return list;
}
 
QStringList QPrinterInfo::availablePrinterNames()
{
    QPlatformPrinterSupport *ps = QPlatformPrinterSupportPlugin::get();
    if (ps)
        return ps->availablePrintDeviceIds();
    return QStringList();
}
 
QList<QPrinterInfo> QPrinterInfo::availablePrinters()
{
    QList<QPrinterInfo> list;
    QPlatformPrinterSupport *ps = QPlatformPrinterSupportPlugin::get();
    if (ps) {
        const QStringList availablePrintDeviceIds = ps->availablePrintDeviceIds();
        list.reserve(availablePrintDeviceIds.size());
        for (const QString &id : availablePrintDeviceIds)
            list.append(QPrinterInfo(id));
    }
    return list;
}
 
QString QPrinterInfo::defaultPrinterName()
{
    QPlatformPrinterSupport *ps = QPlatformPrinterSupportPlugin::get();
    if (ps)
        return ps->defaultPrintDeviceId();
    return QString();
}
 
QPrinterInfo QPrinterInfo::defaultPrinter()
{
    QPlatformPrinterSupport *ps = QPlatformPrinterSupportPlugin::get();
    if (ps)
        return QPrinterInfo(ps->defaultPrintDeviceId());
    return QPrinterInfo();
}
 
QPrinterInfo QPrinterInfo::printerInfo(const QString &printerName)
{
    return QPrinterInfo(printerName);
}
 
#  ifndef QT_NO_DEBUG_STREAM
QDebug operator<<(QDebug debug, const QPrinterInfo &p)
{
    QDebugStateSaver saver(debug);
    debug.nospace();
    debug << "QPrinterInfo(";
    if (p.isNull())
        debug << "null";
    else
        p.d_ptr->m_printDevice.format(debug);
    debug << ')';
    return debug;
}
#  endif // !QT_NO_DEBUG_STREAM
 
QT_END_NAMESPACE
 
#endif // QT_NO_PRINTER