qpixmap.cpp

Go to the documentation of this file.

// Copyright (C) 2021 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 <qglobal.h>
 
#include "qpixmap.h"
#include <qpa/qplatformpixmap.h>
#include "qimagepixmapcleanuphooks_p.h"
 
#include "qbitmap.h"
#include "qimage.h"
#include "qpainter.h"
#include "qdatastream.h"
#include "qbuffer.h"
#include <private/qguiapplication_p.h>
#include "qevent.h"
#include "qfile.h"
#include "qfileinfo.h"
#include "qpixmapcache.h"
#include "qdatetime.h"
#include "qimagereader.h"
#include "qimagewriter.h"
#include "qpaintengine.h"
#include "qscreen.h"
#include "qthread.h"
#include "qdebug.h"
 
#include <qpa/qplatformintegration.h>
 
#include "qpixmap_raster_p.h"
#include "private/qhexstring_p.h"
 
#include <qtgui_tracepoints_p.h>
 
#include <memory>
 
QT_BEGIN_NAMESPACE
 
using namespace Qt::StringLiterals;
 
Q_TRACE_PARAM_REPLACE(Qt::AspectRatioMode, int);
Q_TRACE_PARAM_REPLACE(Qt::TransformationMode, int);
 
// MSVC 19.28 does show spurious warning "C4723: potential divide by 0" for code that divides
// by height() in release builds. Anyhow, all the code paths in this file are only executed
// for valid QPixmap's, where height() cannot be 0. Therefore disable the warning.
QT_WARNING_DISABLE_MSVC(4723)
 
static bool qt_pixmap_thread_test()
{
    if (Q_UNLIKELY(!QCoreApplication::instance())) {
        qFatal("QPixmap: Must construct a QGuiApplication before a QPixmap");
        return false;
    }
    if (QGuiApplicationPrivate::instance()
        && qApp->thread() != QThread::currentThread()
        && !QGuiApplicationPrivate::platformIntegration()->hasCapability(QPlatformIntegration::ThreadedPixmaps)) {
        qWarning("QPixmap: It is not safe to use pixmaps outside the GUI thread on this platform");
        return false;
    }
    return true;
}
 
void QPixmap::doInit(int w, int h, int type)
{
    if ((w > 0 && h > 0) || type == QPlatformPixmap::BitmapType)
        data = QPlatformPixmap::create(w, h, (QPlatformPixmap::PixelType) type);
    else
        data = nullptr;
}
 
QPixmap::QPixmap()
    : QPaintDevice()
{
    (void) qt_pixmap_thread_test();
    doInit(0, 0, QPlatformPixmap::PixmapType);
}
 
QPixmap::QPixmap(int w, int h)
    : QPixmap(QSize(w, h))
{
}
 
QPixmap::QPixmap(const QSize &size)
    : QPixmap(size, QPlatformPixmap::PixmapType)
{
}
 
QPixmap::QPixmap(const QSize &s, int type)
{
    if (!qt_pixmap_thread_test())
        doInit(0, 0, static_cast<QPlatformPixmap::PixelType>(type));
    else
        doInit(s.width(), s.height(), static_cast<QPlatformPixmap::PixelType>(type));
}
 
QPixmap::QPixmap(QPlatformPixmap *d)
    : QPaintDevice(), data(d)
{
}
 
QPixmap::QPixmap(const QString& fileName, const char *format, Qt::ImageConversionFlags flags)
    : QPaintDevice()
{
    doInit(0, 0, QPlatformPixmap::PixmapType);
    if (!qt_pixmap_thread_test())
        return;
 
    load(fileName, format, flags);
}
 
QPixmap::QPixmap(const QPixmap &pixmap)
    : QPaintDevice()
{
    if (!qt_pixmap_thread_test()) {
        doInit(0, 0, QPlatformPixmap::PixmapType);
        return;
    }
    if (pixmap.paintingActive()) {                // make a deep copy
        pixmap.copy().swap(*this);
    } else {
        data = pixmap.data;
    }
}
 
QT_DEFINE_QESDP_SPECIALIZATION_DTOR(QPlatformPixmap)
 
 
#ifndef QT_NO_IMAGEFORMAT_XPM
QPixmap::QPixmap(const char * const xpm[])
    : QPaintDevice()
{
    doInit(0, 0, QPlatformPixmap::PixmapType);
    if (!xpm)
        return;
 
    QImage image(xpm);
    if (!image.isNull()) {
        if (data && data->pixelType() == QPlatformPixmap::BitmapType)
            *this = QBitmap::fromImage(std::move(image));
        else
            *this = fromImage(std::move(image));
    }
}
#endif
 
 
QPixmap::~QPixmap()
{
    Q_ASSERT(!data || data->ref.loadRelaxed() >= 1); // Catch if ref-counting changes again
}
 
int QPixmap::devType() const
{
    return QInternal::Pixmap;
}
 
QPixmap QPixmap::copy(const QRect &rect) const
{
    if (isNull())
        return QPixmap();
 
    QRect r(0, 0, width(), height());
    if (!rect.isEmpty())
        r = r.intersected(rect);
 
    QPlatformPixmap *d = data->createCompatiblePlatformPixmap();
    d->copy(data.data(), r);
    return QPixmap(d);
}
 
void QPixmap::scroll(int dx, int dy, const QRect &rect, QRegion *exposed)
{
    if (isNull() || (dx == 0 && dy == 0))
        return;
    QRect dest = rect & this->rect();
    QRect src = dest.translated(-dx, -dy) & dest;
    if (src.isEmpty()) {
        if (exposed)
            *exposed += dest;
        return;
    }
 
    detach();
 
    if (!data->scroll(dx, dy, src)) {
        // Fallback
        QPixmap pix = *this;
        QPainter painter(&pix);
        painter.setCompositionMode(QPainter::CompositionMode_Source);
        painter.drawPixmap(src.translated(dx, dy), *this, src);
        painter.end();
        *this = pix;
    }
 
    if (exposed) {
        *exposed += dest;
        *exposed -= src.translated(dx, dy);
    }
}
 
QPixmap &QPixmap::operator=(const QPixmap &pixmap)
{
    if (paintingActive()) {
        qWarning("QPixmap::operator=: Cannot assign to pixmap during painting");
        return *this;
    }
    if (pixmap.paintingActive()) {                // make a deep copy
        pixmap.copy().swap(*this);
    } else {
        data = pixmap.data;
    }
    return *this;
}
 
QPixmap::operator QVariant() const
{
    return QVariant::fromValue(*this);
}
 
QImage QPixmap::toImage() const
{
    if (isNull())
        return QImage();
 
    return data->toImage();
}
 
QTransform QPixmap::trueMatrix(const QTransform &m, int w, int h)
{
    return QImage::trueMatrix(m, w, h);
}
 
bool QPixmap::isQBitmap() const
{
    return data && data->type == QPlatformPixmap::BitmapType;
}
 
bool QPixmap::isNull() const
{
    return !data || data->isNull();
}
 
int QPixmap::width() const
{
    return data ? data->width() : 0;
}
 
int QPixmap::height() const
{
    return data ? data->height() : 0;
}
 
QSize QPixmap::size() const
{
    return data ? QSize(data->width(), data->height()) : QSize(0, 0);
}
 
QRect QPixmap::rect() const
{
    return data ? QRect(0, 0, data->width(), data->height()) : QRect();
}
 
int QPixmap::depth() const
{
    return data ? data->depth() : 0;
}
 
void QPixmap::setMask(const QBitmap &mask)
{
    if (paintingActive()) {
        qWarning("QPixmap::setMask: Cannot set mask while pixmap is being painted on");
        return;
    }
 
    if (!mask.isNull() && mask.size() != size()) {
        qWarning("QPixmap::setMask() mask size differs from pixmap size");
        return;
    }
 
    if (isNull())
        return;
 
    if (static_cast<const QPixmap &>(mask).data == data) // trying to selfmask
       return;
 
    detach();
    data->setMask(mask);
}
 
qreal QPixmap::devicePixelRatio() const
{
    if (!data)
        return qreal(1.0);
    return data->devicePixelRatio();
}
 
void QPixmap::setDevicePixelRatio(qreal scaleFactor)
{
    if (isNull())
        return;
 
    if (scaleFactor == data->devicePixelRatio())
        return;
 
    detach();
    data->setDevicePixelRatio(scaleFactor);
}
 
QSizeF QPixmap::deviceIndependentSize() const
{
    if (!data)
        return QSizeF(0, 0);
    return QSizeF(data->width(), data->height()) / data->devicePixelRatio();
}
 
#ifndef QT_NO_IMAGE_HEURISTIC_MASK
QBitmap QPixmap::createHeuristicMask(bool clipTight) const
{
    QBitmap m = QBitmap::fromImage(toImage().createHeuristicMask(clipTight));
    return m;
}
#endif
 
QBitmap QPixmap::createMaskFromColor(const QColor &maskColor, Qt::MaskMode mode) const
{
    QImage image = toImage().convertToFormat(QImage::Format_ARGB32);
    return QBitmap::fromImage(std::move(image).createMaskFromColor(maskColor.rgba(), mode));
}
 
bool QPixmap::load(const QString &fileName, const char *format, Qt::ImageConversionFlags flags)
{
    if (!fileName.isEmpty()) {
 
        QFileInfo info(fileName);
        // Note: If no extension is provided, we try to match the
        // file against known plugin extensions
        if (info.completeSuffix().isEmpty() || info.exists()) {
            const bool inGuiThread = qApp->thread() == QThread::currentThread();
 
            QString key = "qt_pixmap"_L1
                    % info.absoluteFilePath()
                    % HexString<uint>(info.lastModified(QTimeZone::UTC).toSecsSinceEpoch())
                    % HexString<quint64>(info.size())
                    % HexString<uint>(data ? data->pixelType() : QPlatformPixmap::PixmapType);
 
            if (inGuiThread && QPixmapCache::find(key, this))
                return true;
 
            data = QPlatformPixmap::create(0, 0, data ? data->pixelType() : QPlatformPixmap::PixmapType);
 
            if (data->fromFile(fileName, format, flags)) {
                if (inGuiThread)
                    QPixmapCache::insert(key, *this);
                return true;
            }
        }
    }
 
    if (!isNull()) {
        if (isQBitmap())
            *this = QBitmap();
        else
            data.reset();
    }
    return false;
}
 
bool QPixmap::loadFromData(const uchar *buf, uint len, const char *format, Qt::ImageConversionFlags flags)
{
    if (len == 0 || buf == nullptr) {
        data.reset();
        return false;
    }
 
    data = QPlatformPixmap::create(0, 0, QPlatformPixmap::PixmapType);
 
    if (data->fromData(buf, len, format, flags))
        return true;
 
    data.reset();
    return false;
}
 
bool QPixmap::save(const QString &fileName, const char *format, int quality) const
{
    if (isNull())
        return false;                                // nothing to save
    QImageWriter writer(fileName, format);
    return doImageIO(&writer, quality);
}
 
bool QPixmap::save(QIODevice* device, const char* format, int quality) const
{
    if (isNull())
        return false;                                // nothing to save
    QImageWriter writer(device, format);
    return doImageIO(&writer, quality);
}
 
bool QPixmap::doImageIO(QImageWriter *writer, int quality) const
{
    if (quality > 100  || quality < -1)
        qWarning("QPixmap::save: quality out of range [-1,100]");
    if (quality >= 0)
        writer->setQuality(qMin(quality,100));
    return writer->write(toImage());
}
 
 
void QPixmap::fill(const QColor &color)
{
    if (isNull())
        return;
 
    // Some people are probably already calling fill while a painter is active, so to not break
    // their programs, only print a warning and return when the fill operation could cause a crash.
    if (paintingActive() && (color.alpha() != 255) && !hasAlphaChannel()) {
        qWarning("QPixmap::fill: Cannot fill while pixmap is being painted on");
        return;
    }
 
    if (data->ref.loadRelaxed() == 1) {
        // detach() will also remove this pixmap from caches, so
        // it has to be called even when ref == 1.
        detach();
    } else {
        // Don't bother to make a copy of the data object, since
        // it will be filled with new pixel data anyway.
        QPlatformPixmap *d = data->createCompatiblePlatformPixmap();
        d->resize(data->width(), data->height());
        d->setDevicePixelRatio(data->devicePixelRatio());
        data = d;
    }
    data->fill(color);
}
 
qint64 QPixmap::cacheKey() const
{
    if (isNull())
        return 0;
 
    Q_ASSERT(data);
    return data->cacheKey();
}
 
#if 0
static void sendResizeEvents(QWidget *target)
{
    QResizeEvent e(target->size(), QSize());
    QApplication::sendEvent(target, &e);
 
    const QObjectList children = target->children();
    for (int i = 0; i < children.size(); ++i) {
        QWidget *child = static_cast<QWidget*>(children.at(i));
        if (child->isWidgetType() && !child->isWindow() && child->testAttribute(Qt::WA_PendingResizeEvent))
            sendResizeEvents(child);
    }
}
#endif
 
 
/*****************************************************************************
  QPixmap stream functions
 *****************************************************************************/
#if !defined(QT_NO_DATASTREAM)
QDataStream &operator<<(QDataStream &stream, const QPixmap &pixmap)
{
    return stream << pixmap.toImage();
}
 
QDataStream &operator>>(QDataStream &stream, QPixmap &pixmap)
{
    QImage image;
    stream >> image;
 
    if (image.isNull()) {
        pixmap = QPixmap();
    } else if (image.depth() == 1) {
        pixmap = QBitmap::fromImage(std::move(image));
    } else {
        pixmap = QPixmap::fromImage(std::move(image));
    }
    return stream;
}
 
#endif // QT_NO_DATASTREAM
 
bool QPixmap::isDetached() const
{
    return data && data->ref.loadRelaxed() == 1;
}
 
bool QPixmap::convertFromImage(const QImage &image, Qt::ImageConversionFlags flags)
{
    detach();
    if (image.isNull() || !data)
        *this = QPixmap::fromImage(image, flags);
    else
        data->fromImage(image, flags);
    return !isNull();
}
 
QPixmap Q_TRACE_INSTRUMENT(qtgui) QPixmap::scaled(const QSize& s, Qt::AspectRatioMode aspectMode, Qt::TransformationMode mode) const
{
    if (isNull()) {
        qWarning("QPixmap::scaled: Pixmap is a null pixmap");
        return QPixmap();
    }
    if (s.isEmpty())
        return QPixmap();
 
    QSize newSize = size();
    newSize.scale(s, aspectMode);
    newSize.rwidth() = qMax(newSize.width(), 1);
    newSize.rheight() = qMax(newSize.height(), 1);
    if (newSize == size())
        return *this;
 
    Q_TRACE_SCOPE(QPixmap_scaled, s, aspectMode, mode);
 
    QTransform wm = QTransform::fromScale((qreal)newSize.width() / width(),
                                          (qreal)newSize.height() / height());
    QPixmap pix = transformed(wm, mode);
    return pix;
}
 
QPixmap Q_TRACE_INSTRUMENT(qtgui) QPixmap::scaledToWidth(int w, Qt::TransformationMode mode) const
{
    if (isNull()) {
        qWarning("QPixmap::scaleWidth: Pixmap is a null pixmap");
        return copy();
    }
    if (w <= 0)
        return QPixmap();
 
    Q_TRACE_SCOPE(QPixmap_scaledToWidth, w, mode);
 
    qreal factor = (qreal) w / width();
    QTransform wm = QTransform::fromScale(factor, factor);
    return transformed(wm, mode);
}
 
QPixmap Q_TRACE_INSTRUMENT(qtgui) QPixmap::scaledToHeight(int h, Qt::TransformationMode mode) const
{
    if (isNull()) {
        qWarning("QPixmap::scaleHeight: Pixmap is a null pixmap");
        return copy();
    }
    if (h <= 0)
        return QPixmap();
 
    Q_TRACE_SCOPE(QPixmap_scaledToHeight, h, mode);
 
    qreal factor = (qreal) h / height();
    QTransform wm = QTransform::fromScale(factor, factor);
    return transformed(wm, mode);
}
 
QPixmap QPixmap::transformed(const QTransform &transform,
                             Qt::TransformationMode mode) const
{
    if (isNull() || transform.type() <= QTransform::TxTranslate)
        return *this;
 
    return data->transformed(transform, mode);
}
 
bool QPixmap::hasAlpha() const
{
    return data && data->hasAlphaChannel();
}
 
bool QPixmap::hasAlphaChannel() const
{
    return data && data->hasAlphaChannel();
}
 
int QPixmap::metric(PaintDeviceMetric metric) const
{
    return data ? data->metric(metric) : 0;
}
 
QPaintEngine *QPixmap::paintEngine() const
{
    return data ? data->paintEngine() : nullptr;
}
 
QBitmap QPixmap::mask() const
{
    return data ? data->mask() : QBitmap();
}
 
int QPixmap::defaultDepth()
{
    QScreen *primary = QGuiApplication::primaryScreen();
    if (Q_LIKELY(primary))
        return primary->depth();
    qWarning("QPixmap: QGuiApplication must be created before calling defaultDepth().");
    return 0;
}
 
void QPixmap::detach()
{
    if (!data)
        return;
 
    // QPixmap.data member may be QRuntimePlatformPixmap so use handle() function to get
    // the actual underlying runtime pixmap data.
    QPlatformPixmap *pd = handle();
    QPlatformPixmap::ClassId id = pd->classId();
    if (id == QPlatformPixmap::RasterClass) {
        QRasterPlatformPixmap *rasterData = static_cast<QRasterPlatformPixmap*>(pd);
        rasterData->image.detach();
    }
 
    if (data->is_cached && data->ref.loadRelaxed() == 1)
        QImagePixmapCleanupHooks::executePlatformPixmapModificationHooks(data.data());
 
    if (data->ref.loadRelaxed() != 1) {
        *this = copy();
    }
    ++data->detach_no;
}
 
QPixmap QPixmap::fromImage(const QImage &image, Qt::ImageConversionFlags flags)
{
    if (image.isNull())
        return QPixmap();
 
    if (Q_UNLIKELY(!qobject_cast<QGuiApplication *>(QCoreApplication::instance()))) {
        qWarning("QPixmap::fromImage: QPixmap cannot be created without a QGuiApplication");
        return QPixmap();
    }
 
    std::unique_ptr<QPlatformPixmap> data(QGuiApplicationPrivate::platformIntegration()->createPlatformPixmap(QPlatformPixmap::PixmapType));
    data->fromImage(image, flags);
    return QPixmap(data.release());
}
 
QPixmap QPixmap::fromImageInPlace(QImage &image, Qt::ImageConversionFlags flags)
{
    if (image.isNull())
        return QPixmap();
 
    if (Q_UNLIKELY(!qobject_cast<QGuiApplication *>(QCoreApplication::instance()))) {
        qWarning("QPixmap::fromImageInPlace: QPixmap cannot be created without a QGuiApplication");
        return QPixmap();
    }
 
    std::unique_ptr<QPlatformPixmap> data(QGuiApplicationPrivate::platformIntegration()->createPlatformPixmap(QPlatformPixmap::PixmapType));
    data->fromImageInPlace(image, flags);
    return QPixmap(data.release());
}
 
QPixmap QPixmap::fromImageReader(QImageReader *imageReader, Qt::ImageConversionFlags flags)
{
    if (Q_UNLIKELY(!qobject_cast<QGuiApplication *>(QCoreApplication::instance()))) {
        qWarning("QPixmap::fromImageReader: QPixmap cannot be created without a QGuiApplication");
        return QPixmap();
    }
 
    std::unique_ptr<QPlatformPixmap> data(QGuiApplicationPrivate::platformIntegration()->createPlatformPixmap(QPlatformPixmap::PixmapType));
    data->fromImageReader(imageReader, flags);
    return QPixmap(data.release());
}
 
QPlatformPixmap* QPixmap::handle() const
{
    return data.data();
}
 
#ifndef QT_NO_DEBUG_STREAM
QDebug operator<<(QDebug dbg, const QPixmap &r)
{
    QDebugStateSaver saver(dbg);
    dbg.resetFormat();
    dbg.nospace();
    dbg << "QPixmap(";
    if (r.isNull()) {
        dbg << "null";
    } else {
        dbg << r.size() << ",depth=" << r.depth()
            << ",devicePixelRatio=" << r.devicePixelRatio()
            << ",cacheKey=" << Qt::showbase << Qt::hex << r.cacheKey() << Qt::dec << Qt::noshowbase;
    }
    dbg << ')';
    return dbg;
}
#endif
 
QT_END_NAMESPACE