Revision control
++ // 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
++ // Qt-Security score:significant reason:default
++
++ #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 (!QCoreApplication::instanceExists()) {
++ qFatal("QPixmap: Must construct a QGuiApplication before a QPixmap");
++ return false;
++ }
++ if (QGuiApplicationPrivate::instance()
++ && !QThread::isMainThread()
++ && Q_LIKELY(QGuiApplicationPrivate::platformIntegration())
++ && !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;
++ }
++
++ /*!
++ Constructs a null pixmap.
++
++ \sa isNull()
++ */
++
++ QPixmap::QPixmap()
++ : QPaintDevice()
++ {
++ (void) qt_pixmap_thread_test();
++ doInit(0, 0, QPlatformPixmap::PixmapType);
++ }
++
++ /*!
++ \fn QPixmap::QPixmap(int width, int height)
++
++ Constructs a pixmap with the given \a width and \a height. If
++ either \a width or \a height is zero, a null pixmap is
++ constructed.
++
++ \warning This will create a QPixmap with uninitialized data. Call
++ fill() to fill the pixmap with an appropriate color before drawing
++ onto it with QPainter.
++
++ \sa isNull()
++ */
++
++ QPixmap::QPixmap(int w, int h)
++ : QPixmap(QSize(w, h))
++ {
++ }
++
++ /*!
++ \overload
++
++ Constructs a pixmap of the given \a size.
++
++ \warning This will create a QPixmap with uninitialized data. Call
++ fill() to fill the pixmap with an appropriate color before drawing
++ onto it with QPainter.
++ */
++
++ QPixmap::QPixmap(const QSize &size)
++ : QPixmap(size, QPlatformPixmap::PixmapType)
++ {
++ }
++
++ /*!
++ \internal
++ */
++ 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));
++ }
++
++ /*!
++ \internal
++ */
++ QPixmap::QPixmap(QPlatformPixmap *d)
++ : QPaintDevice(), data(d)
++ {
++ }
++
++ /*!
++ Constructs a pixmap from the file with the given \a fileName. If the
++ file does not exist or is of an unknown format, the pixmap becomes a
++ null pixmap.
++
++ The loader attempts to read the pixmap using the specified \a
++ format. If the \a format is not specified (which is the default),
++ the loader probes the file for a header to guess the file format.
++
++ The file name can either refer to an actual file on disk or to
++ one of the application's embedded resources. See the
++ \l{resources.html}{Resource System} overview for details on how
++ to embed images and other resource files in the application's
++ executable.
++
++ If the image needs to be modified to fit in a lower-resolution
++ result (e.g. converting from 32-bit to 8-bit), use the \a
++ flags to control the conversion.
++
++ The \a fileName, \a format and \a flags parameters are
++ passed on to load(). This means that the data in \a fileName is
++ not compiled into the binary. If \a fileName contains a relative
++ path (e.g. the filename only) the relevant file must be found
++ relative to the runtime working directory.
++
++ \sa {QPixmap#Reading and Writing Image Files}{Reading and Writing
++ Image Files}
++ */
++
++ 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);
++ }
++
++ /*!
++ Constructs a pixmap that is a copy of the given \a pixmap.
++
++ \sa copy()
++ */
++
++ 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;
++ }
++ }
++
++ /*! \fn QPixmap::QPixmap(QPixmap &&other)
++ Move-constructs a QPixmap instance from \a other.
++
++ \sa swap(), operator=(QPixmap&&)
++ */
++
++ QT_DEFINE_QESDP_SPECIALIZATION_DTOR(QPlatformPixmap)
++
++ /*!
++ Constructs a pixmap from the given \a xpm data, which must be a
++ valid XPM image.
++
++ Errors are silently ignored.
++
++ Note that it's possible to squeeze the XPM variable a little bit
++ by using an unusual declaration:
++
++ \snippet code/src_gui_image_qimage.cpp 2
++
++ The extra \c const makes the entire definition read-only, which is
++ slightly more efficient (for example, when the code is in a shared
++ library) and ROMable when the application is to be stored in ROM.
++ */
++ #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
++
++
++ /*!
++ Destroys the pixmap.
++ */
++
++ QPixmap::~QPixmap()
++ {
++ Q_ASSERT(!data || data->ref.loadRelaxed() >= 1); // Catch if ref-counting changes again
++ }
++
++ /*!
++ \internal
++ */
++ int QPixmap::devType() const
++ {
++ return QInternal::Pixmap;
++ }
++
++ /*!
++ \fn QPixmap QPixmap::copy(int x, int y, int width, int height) const
++ \overload
++
++ Returns a deep copy of the subset of the pixmap that is specified
++ by the rectangle QRect( \a x, \a y, \a width, \a height).
++ */
++
++ /*!
++ \fn QPixmap QPixmap::copy(const QRect &rectangle) const
++
++ Returns a deep copy of the subset of the pixmap that is specified
++ by the given \a rectangle. For more information on deep copies,
++ see the \l {Implicit Data Sharing} documentation.
++
++ If the given \a rectangle is empty, the whole image is copied.
++
++ \sa operator=(), QPixmap(), {QPixmap#Pixmap
++ Transformations}{Pixmap Transformations}
++ */
++ 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);
++ }
++
++ /*!
++ \fn QPixmap::scroll(int dx, int dy, int x, int y, int width, int height, QRegion *exposed)
++
++ This convenience function is equivalent to calling QPixmap::scroll(\a dx,
++ \a dy, QRect(\a x, \a y, \a width, \a height), \a exposed).
++
++ \sa QWidget::scroll(), QGraphicsItem::scroll()
++ */
++
++ /*!
++ Scrolls the area \a rect of this pixmap by (\a dx, \a dy). The exposed
++ region is left unchanged. You can optionally pass a pointer to an empty
++ QRegion to get the region that is \a exposed by the scroll operation.
++
++ \snippet code/src_gui_image_qpixmap.cpp 2
++
++ You cannot scroll while there is an active painter on the pixmap.
++
++ \sa QWidget::scroll(), QGraphicsItem::scroll()
++ */
++ 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);
++ }
++ }
++
++ /*!
++ Assigns the given \a pixmap to this pixmap and returns a reference
++ to this pixmap.
++
++ \sa copy(), QPixmap()
++ */
++
++ 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;
++ }
++
++ /*!
++ \fn QPixmap &QPixmap::operator=(QPixmap &&other)
++
++ Move-assigns \a other to this QPixmap instance.
++
++ \since 5.2
++ */
++
++ /*!
++ \fn void QPixmap::swap(QPixmap &other)
++ \memberswap{pixmap}
++ */
++
++ /*!
++ Returns the pixmap as a QVariant.
++ */
++ QPixmap::operator QVariant() const
++ {
++ return QVariant::fromValue(*this);
++ }
++
++ /*!
++ \fn bool QPixmap::operator!() const
++
++ Returns \c true if this is a null pixmap; otherwise returns \c false.
++
++ \sa isNull()
++ */
++
++ /*!
++ Converts the pixmap to a QImage. Returns a null image if the
++ conversion fails.
++
++ If the pixmap has 1-bit depth, the returned image will also be 1
++ bit deep. Images with more bits will be returned in a format
++ closely represents the underlying system. Usually this will be
++ QImage::Format_ARGB32_Premultiplied for pixmaps with an alpha and
++ QImage::Format_RGB32 or QImage::Format_RGB16 for pixmaps without
++ alpha.
++
++ Note that for the moment, alpha masks on monochrome images are
++ ignored.
++
++ \sa fromImage(), {QImage#Image Formats}{Image Formats}
++ */
++ QImage QPixmap::toImage() const
++ {
++ if (isNull())
++ return QImage();
++
++ return data->toImage();
++ }
++
++ /*!
++ \fn QTransform QPixmap::trueMatrix(const QTransform &matrix, int width, int height)
++
++ Returns the actual matrix used for transforming a pixmap with the
++ given \a width, \a height and \a matrix.
++
++ When transforming a pixmap using the transformed() function, the
++ transformation matrix is internally adjusted to compensate for
++ unwanted translation, i.e. transformed() returns the smallest
++ pixmap containing all transformed points of the original
++ pixmap. This function returns the modified matrix, which maps
++ points correctly from the original pixmap into the new pixmap.
++
++ \sa transformed(), {QPixmap#Pixmap Transformations}{Pixmap
++ Transformations}
++ */
++ QTransform QPixmap::trueMatrix(const QTransform &m, int w, int h)
++ {
++ return QImage::trueMatrix(m, w, h);
++ }
++
++ /*!
++ \fn bool QPixmap::isQBitmap() const
++
++ Returns \c true if this is a QBitmap; otherwise returns \c false.
++ */
++
++ bool QPixmap::isQBitmap() const
++ {
++ return data && data->type == QPlatformPixmap::BitmapType;
++ }
++
++ /*!
++ \fn bool QPixmap::isNull() const
++
++ Returns \c true if this is a null pixmap; otherwise returns \c false.
++
++ A null pixmap has zero width, zero height and no contents. You
++ cannot draw in a null pixmap.
++ */
++ bool QPixmap::isNull() const
++ {
++ return !data || data->isNull();
++ }
++
++ /*!
++ \fn int QPixmap::width() const
++
++ Returns the width of the pixmap.
++
++ \sa size(), {QPixmap#Pixmap Information}{Pixmap Information}
++ */
++ int QPixmap::width() const
++ {
++ return data ? data->width() : 0;
++ }
++
++ /*!
++ \fn int QPixmap::height() const
++
++ Returns the height of the pixmap.
++
++ \sa size(), {QPixmap#Pixmap Information}{Pixmap Information}
++ */
++ int QPixmap::height() const
++ {
++ return data ? data->height() : 0;
++ }
++
++ /*!
++ \fn QSize QPixmap::size() const
++
++ Returns the size of the pixmap.
++
++ \sa width(), height(), {QPixmap#Pixmap Information}{Pixmap
++ Information}
++ */
++ QSize QPixmap::size() const
++ {
++ return data ? QSize(data->width(), data->height()) : QSize(0, 0);
++ }
++
++ /*!
++ \fn QRect QPixmap::rect() const
++
++ Returns the pixmap's enclosing rectangle.
++
++ \sa {QPixmap#Pixmap Information}{Pixmap Information}
++ */
++ QRect QPixmap::rect() const
++ {
++ return data ? QRect(0, 0, data->width(), data->height()) : QRect();
++ }
++
++ /*!
++ \fn int QPixmap::depth() const
++
++ Returns the depth of the pixmap.
++
++ The pixmap depth is also called bits per pixel (bpp) or bit planes
++ of a pixmap. A null pixmap has depth 0.
++
++ \sa defaultDepth(), {QPixmap#Pixmap Information}{Pixmap
++ Information}
++ */
++ int QPixmap::depth() const
++ {
++ return data ? data->depth() : 0;
++ }
++
++ /*!
++ Sets a mask bitmap.
++
++ This function merges the \a mask with the pixmap's alpha channel. A pixel
++ value of 1 on the mask means the pixmap's pixel is unchanged; a value of 0
++ means the pixel is transparent. The mask must have the same size as this
++ pixmap.
++
++ Setting a null mask resets the mask, leaving the previously transparent
++ pixels black. The effect of this function is undefined when the pixmap is
++ being painted on.
++
++ \warning This is potentially an expensive operation.
++
++ \sa mask(), {QPixmap#Pixmap Transformations}{Pixmap Transformations},
++ QBitmap
++ */
++ 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);
++ }
++
++ /*!
++ Returns the device pixel ratio for the pixmap. This is the
++ ratio between \e{device pixels} and \e{device independent pixels}.
++
++ Use this function when calculating layout geometry based on
++ the pixmap size: QSize layoutSize = image.size() / image.devicePixelRatio()
++
++ The default value is 1.0.
++
++ \sa setDevicePixelRatio(), QImageReader
++ */
++ qreal QPixmap::devicePixelRatio() const
++ {
++ if (!data)
++ return qreal(1.0);
++ return data->devicePixelRatio();
++ }
++
++ /*!
++ Sets the device pixel ratio for the pixmap. This is the
++ ratio between image pixels and device-independent pixels.
++
++ The default \a scaleFactor is 1.0. Setting it to something else has
++ two effects:
++
++ QPainters that are opened on the pixmap will be scaled. For
++ example, painting on a 200x200 image if with a ratio of 2.0
++ will result in effective (device-independent) painting bounds
++ of 100x100.
++
++ Code paths in Qt that calculate layout geometry based on the
++ pixmap size will take the ratio into account:
++ QSize layoutSize = pixmap.size() / pixmap.devicePixelRatio()
++ The net effect of this is that the pixmap is displayed as
++ high-DPI pixmap rather than a large pixmap
++ (see \l{Drawing High Resolution Versions of Pixmaps and Images}).
++
++ \sa devicePixelRatio(), deviceIndependentSize()
++ */
++ void QPixmap::setDevicePixelRatio(qreal scaleFactor)
++ {
++ if (isNull())
++ return;
++
++ if (scaleFactor == data->devicePixelRatio())
++ return;
++
++ detach();
++ data->setDevicePixelRatio(scaleFactor);
++ }
++
++ /*!
++ Returns the size of the pixmap in device independent pixels.
++
++ This value should be used when using the pixmap size in user interface
++ size calculations.
++
++ The return value is equivalent to pixmap.size() / pixmap.devicePixelRatio().
++
++ \since 6.2
++ */
++ QSizeF QPixmap::deviceIndependentSize() const
++ {
++ if (!data)
++ return QSizeF(0, 0);
++ return QSizeF(data->width(), data->height()) / data->devicePixelRatio();
++ }
++
++ #ifndef QT_NO_IMAGE_HEURISTIC_MASK
++ /*!
++ Creates and returns a heuristic mask for this pixmap.
++
++ The function works by selecting a color from one of the corners
++ and then chipping away pixels of that color, starting at all the
++ edges. If \a clipTight is true (the default) the mask is just
++ large enough to cover the pixels; otherwise, the mask is larger
++ than the data pixels.
++
++ The mask may not be perfect but it should be reasonable, so you
++ can do things such as the following:
++
++ \snippet code/src_gui_image_qpixmap.cpp 1
++
++ This function is slow because it involves converting to/from a
++ QImage, and non-trivial computations.
++
++ \sa QImage::createHeuristicMask(), createMaskFromColor()
++ */
++ QBitmap QPixmap::createHeuristicMask(bool clipTight) const
++ {
++ QBitmap m = QBitmap::fromImage(toImage().createHeuristicMask(clipTight));
++ return m;
++ }
++ #endif
++
++ /*!
++ Creates and returns a mask for this pixmap based on the given \a
++ maskColor. If the \a mode is Qt::MaskInColor, all pixels matching the
++ maskColor will be transparent. If \a mode is Qt::MaskOutColor, all pixels
++ matching the maskColor will be opaque.
++
++ This function is slow because it involves converting to/from a
++ QImage.
++
++ \sa createHeuristicMask(), QImage::createMaskFromColor()
++ */
++ 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));
++ }
++
++ /*!
++ Loads a pixmap from the file with the given \a fileName. Returns
++ true if the pixmap was successfully loaded; otherwise invalidates
++ the pixmap and returns \c false.
++
++ The loader attempts to read the pixmap using the specified \a
++ format. If the \a format is not specified (which is the default),
++ the loader probes the file for a header to guess the file format.
++
++ The file name can either refer to an actual file on disk or to one
++ of the application's embedded resources. See the
++ \l{resources.html}{Resource System} overview for details on how to
++ embed pixmaps and other resource files in the application's
++ executable.
++
++ If the data needs to be modified to fit in a lower-resolution
++ result (e.g. converting from 32-bit to 8-bit), use the \a flags to
++ control the conversion.
++
++ Note that QPixmaps are automatically added to the QPixmapCache
++ when loaded from a file in main thread; the key used is internal
++ and cannot be acquired.
++
++ \sa loadFromData(), {QPixmap#Reading and Writing Image
++ Files}{Reading and Writing Image Files}
++ */
++
++ 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 = QThread::isMainThread();
++
++ 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;
++ }
++
++ /*!
++ \fn bool QPixmap::loadFromData(const uchar *data, uint len, const char *format, Qt::ImageConversionFlags flags)
++
++ Loads a pixmap from the \a len first bytes of the given binary \a
++ data. Returns \c true if the pixmap was loaded successfully;
++ otherwise invalidates the pixmap and returns \c false.
++
++ The loader attempts to read the pixmap using the specified \a
++ format. If the \a format is not specified (which is the default),
++ the loader probes the file for a header to guess the file format.
++
++ If the data needs to be modified to fit in a lower-resolution
++ result (e.g. converting from 32-bit to 8-bit), use the \a flags to
++ control the conversion.
++
++ \sa load(), {QPixmap#Reading and Writing Image Files}{Reading and
++ Writing Image Files}
++ */
++
++ 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;
++ }
++
++ /*!
++ \fn bool QPixmap::loadFromData(const QByteArray &data, const char *format, Qt::ImageConversionFlags flags)
++
++ \overload
++
++ Loads a pixmap from the binary \a data using the specified \a
++ format and conversion \a flags.
++ */
++
++
++ /*!
++ Saves the pixmap to the file with the given \a fileName using the
++ specified image file \a format and \a quality factor. Returns \c true
++ if successful; otherwise returns \c false.
++
++ The \a quality factor must be in the range [0,100] or -1. Specify
++ 0 to obtain small compressed files, 100 for large uncompressed
++ files, and -1 to use the default settings.
++
++ If \a format is \nullptr, an image format will be chosen from
++ \a fileName's suffix.
++
++ \sa {QPixmap#Reading and Writing Image Files}{Reading and Writing
++ Image Files}
++ */
++
++ 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);
++ }
++
++ /*!
++ \overload
++
++ This function writes a QPixmap to the given \a device using the
++ specified image file \a format and \a quality factor. This can be
++ used, for example, to save a pixmap directly into a QByteArray:
++
++ \snippet image/image.cpp 1
++ */
++
++ 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);
++ }
++
++ /*! \internal
++ */
++ 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());
++ }
++
++
++ /*!
++ Fills the pixmap with the given \a color.
++
++ The effect of this function is undefined when the pixmap is
++ being painted on.
++
++ \sa {QPixmap#Pixmap Transformations}{Pixmap Transformations}
++ */
++
++ 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);
++ }
++
++ /*!
++ Returns a number that identifies this QPixmap. Distinct QPixmap
++ objects can only have the same cache key if they refer to the same
++ contents.
++
++ The cacheKey() will change when the pixmap is altered.
++ */
++ 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)
++ /*!
++ \relates QPixmap
++
++ Writes the given \a pixmap to the given \a stream as a PNG
++ image. Note that writing the stream to a file will not produce a
++ valid image file.
++
++ \sa QPixmap::save(), {Serializing Qt Data Types}
++ */
++
++ QDataStream &operator<<(QDataStream &stream, const QPixmap &pixmap)
++ {
++ return stream << pixmap.toImage();
++ }
++
++ /*!
++ \relates QPixmap
++
++ Reads an image from the given \a stream into the given \a pixmap.
++
++ \sa QPixmap::load(), {Serializing Qt Data Types}
++ */
++
++ 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
++
++ /*!
++ \internal
++ */
++
++ bool QPixmap::isDetached() const
++ {
++ return data && data->ref.loadRelaxed() == 1;
++ }
++
++ /*!
++ Replaces this pixmap's data with the given \a image using the
++ specified \a flags to control the conversion. The \a flags
++ argument is a bitwise-OR of the \l{Qt::ImageConversionFlags}.
++ Passing 0 for \a flags sets all the default options. Returns \c true
++ if the result is that this pixmap is not null.
++
++ \sa fromImage()
++ */
++ 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();
++ }
++
++ /*!
++ \fn QPixmap QPixmap::scaled(int width, int height,
++ Qt::AspectRatioMode aspectRatioMode, Qt::TransformationMode
++ transformMode) const
++
++ \overload
++
++ Returns a copy of the pixmap scaled to a rectangle with the given
++ \a width and \a height according to the given \a aspectRatioMode and
++ \a transformMode.
++
++ If either the \a width or the \a height is zero or negative, this
++ function returns a null pixmap.
++ */
++
++ /*!
++ \fn QPixmap QPixmap::scaled(const QSize &size, Qt::AspectRatioMode
++ aspectRatioMode, Qt::TransformationMode transformMode) const
++
++ Scales the pixmap to the given \a size, using the aspect ratio and
++ transformation modes specified by \a aspectRatioMode and \a
++ transformMode.
++
++ \image qimage-scaling.png {Three aspect ratio modes compared}
++
++ \list
++ \li If \a aspectRatioMode is Qt::IgnoreAspectRatio, the pixmap
++ is scaled to \a size.
++ \li If \a aspectRatioMode is Qt::KeepAspectRatio, the pixmap is
++ scaled to a rectangle as large as possible inside \a size, preserving the aspect ratio.
++ \li If \a aspectRatioMode is Qt::KeepAspectRatioByExpanding,
++ the pixmap is scaled to a rectangle as small as possible
++ outside \a size, preserving the aspect ratio.
++ \endlist
++
++ If the given \a size is empty, this function returns a null
++ pixmap.
++
++
++ In some cases it can be more beneficial to draw the pixmap to a
++ painter with a scale set rather than scaling the pixmap. This is
++ the case when the painter is for instance based on OpenGL or when
++ the scale factor changes rapidly.
++
++ \sa isNull(), {QPixmap#Pixmap Transformations}{Pixmap
++ Transformations}
++
++ */
++ 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;
++ }
++
++ /*!
++ \fn QPixmap QPixmap::scaledToWidth(int width, Qt::TransformationMode
++ mode) const
++
++ Returns a scaled copy of the image. The returned image is scaled
++ to the given \a width using the specified transformation \a mode.
++ The height of the pixmap is automatically calculated so that the
++ aspect ratio of the pixmap is preserved.
++
++ If \a width is 0 or negative, a null pixmap is returned.
++
++ \sa isNull(), {QPixmap#Pixmap Transformations}{Pixmap
++ Transformations}
++ */
++ 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);
++ }
++
++ /*!
++ \fn QPixmap QPixmap::scaledToHeight(int height,
++ Qt::TransformationMode mode) const
++
++ Returns a scaled copy of the image. The returned image is scaled
++ to the given \a height using the specified transformation \a mode.
++ The width of the pixmap is automatically calculated so that the
++ aspect ratio of the pixmap is preserved.
++
++ If \a height is 0 or negative, a null pixmap is returned.
++
++ \sa isNull(), {QPixmap#Pixmap Transformations}{Pixmap
++ Transformations}
++ */
++ 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);
++ }
++
++ /*!
++ Returns a copy of the pixmap that is transformed using the given
++ transformation \a transform and transformation \a mode. The original
++ pixmap is not changed.
++
++ The transformation \a transform is internally adjusted to compensate
++ for unwanted translation; i.e. the pixmap produced is the smallest
++ pixmap that contains all the transformed points of the original
++ pixmap. Use the trueMatrix() function to retrieve the actual
++ matrix used for transforming the pixmap.
++
++ This function is slow because it involves transformation to a
++ QImage, non-trivial computations and a transformation back to a
++ QPixmap.
++
++ \sa trueMatrix(), {QPixmap#Pixmap Transformations}{Pixmap
++ Transformations}
++ */
++ QPixmap QPixmap::transformed(const QTransform &transform,
++ Qt::TransformationMode mode) const
++ {
++ if (isNull() || transform.type() <= QTransform::TxTranslate)
++ return *this;
++
++ return data->transformed(transform, mode);
++ }
++
++ /*!
++ \class QPixmap
++ \inmodule QtGui
++
++ \brief The QPixmap class is an off-screen image representation
++ that can be used as a paint device.
++
++ \ingroup painting
++ \ingroup shared
++
++
++ Qt provides four classes for handling image data: QImage, QPixmap,
++ QBitmap and QPicture. QImage is designed and optimized for I/O,
++ and for direct pixel access and manipulation, while QPixmap is
++ designed and optimized for showing images on screen. QBitmap is
++ only a convenience class that inherits QPixmap, ensuring a depth
++ of 1. The isQBitmap() function returns \c true if a QPixmap object is
++ really a bitmap, otherwise returns \c false. Finally, the QPicture class
++ is a paint device that records and replays QPainter commands.
++
++ A QPixmap can easily be displayed on the screen using QLabel or
++ one of QAbstractButton's subclasses (such as QPushButton and
++ QToolButton). QLabel has a pixmap property, whereas
++ QAbstractButton has an icon property.
++
++ QPixmap objects can be passed around by value since the QPixmap
++ class uses implicit data sharing. For more information, see the \l
++ {Implicit Data Sharing} documentation. QPixmap objects can also be
++ streamed.
++
++ Note that the pixel data in a pixmap is internal and is managed by
++ the underlying window system. Because QPixmap is a QPaintDevice
++ subclass, QPainter can be used to draw directly onto pixmaps.
++ Pixels can only be accessed through QPainter functions or by
++ converting the QPixmap to a QImage. However, the fill() function
++ is available for initializing the entire pixmap with a given color.
++
++ There are functions to convert between QImage and
++ QPixmap. Typically, the QImage class is used to load an image
++ file, optionally manipulating the image data, before the QImage
++ object is converted into a QPixmap to be shown on
++ screen. Alternatively, if no manipulation is desired, the image
++ file can be loaded directly into a QPixmap.
++
++ QPixmap provides a collection of functions that can be used to
++ obtain a variety of information about the pixmap. In addition,
++ there are several functions that enables transformation of the
++ pixmap.
++
++ \section1 Reading and Writing Image Files
++
++ QPixmap provides several ways of reading an image file: The file
++ can be loaded when constructing the QPixmap object, or by using
++ the load() or loadFromData() functions later on. When loading an
++ image, the file name can either refer to an actual file on disk or
++ to one of the application's embedded resources. See \l{The Qt
++ Resource System} overview for details on how to embed images and
++ other resource files in the application's executable.
++
++ Simply call the save() function to save a QPixmap object.
++
++ The complete list of supported file formats are available through
++ the QImageReader::supportedImageFormats() and
++ QImageWriter::supportedImageFormats() functions. New file formats
++ can be added as plugins. By default, Qt supports the following
++ formats:
++
++ \table
++ \header \li Format \li Description \li Qt's support
++ \row \li BMP \li Windows Bitmap \li Read/write
++ \row \li CUR \li Windows Cursor \li Read/write
++ \row \li GIF \li Graphic Interchange Format \li Read
++ \row \li ICO \li Windows Icon \li Read/write
++ \row \li JFIF \li JPEG File Interchange Format \li Read/write
++ \row \li JPEG \li Joint Photographic Experts Group \li Read/write
++ \row \li JPG \li Joint Photographic Experts Group \li Read/write
++ \row \li PBM \li Portable Bitmap \li Read/write
++ \row \li PGM \li Portable Graymap \li Read/write
++ \row \li PNG \li Portable Network Graphics \li Read/write
++ \row \li PPM \li Portable Pixmap \li Read/write
++ \row \li SVG \li Scalable Vector Graphics \li Read
++ \row \li SVGZ \li Scalable Vector Graphics (Compressed) \li Read
++ \row \li XBM \li X11 Bitmap \li Read/write
++ \row \li XPM \li X11 Pixmap \li Read/write
++ \endtable
++
++ Further formats are supported if the \l{Qt Image Formats} module is installed.
++
++ \section1 Pixmap Information
++
++ QPixmap provides a collection of functions that can be used to
++ obtain a variety of information about the pixmap:
++
++ \table
++ \header
++ \li \li Available Functions
++ \row
++ \li Geometry
++ \li
++ The size(), width() and height() functions provide information
++ about the pixmap's size. The rect() function returns the image's
++ enclosing rectangle.
++
++ \row
++ \li Alpha component
++ \li
++
++ The hasAlphaChannel() returns \c true if the pixmap has a format that
++ respects the alpha channel, otherwise returns \c false. The hasAlpha(),
++ setMask() and mask() functions are legacy and should not be used.
++ They are potentially very slow.
++
++ The createHeuristicMask() function creates and returns a 1-bpp
++ heuristic mask (i.e. a QBitmap) for this pixmap. It works by
++ selecting a color from one of the corners and then chipping away
++ pixels of that color, starting at all the edges. The
++ createMaskFromColor() function creates and returns a mask (i.e. a
++ QBitmap) for the pixmap based on a given color.
++
++ \row
++ \li Low-level information
++ \li
++
++ The depth() function returns the depth of the pixmap. The
++ defaultDepth() function returns the default depth, i.e. the depth
++ used by the application on the given screen.
++
++ The cacheKey() function returns a number that uniquely
++ identifies the contents of the QPixmap object.
++
++ \endtable
++
++ \section1 Pixmap Conversion
++
++ A QPixmap object can be converted into a QImage using the
++ toImage() function. Likewise, a QImage can be converted into a
++ QPixmap using the fromImage(). If this is too expensive an
++ operation, you can use QBitmap::fromImage() instead.
++
++ To convert a QPixmap to and from HICON you can use the
++ QImage::toHICON() and QImage::fromHICON() functions respectively
++ (after converting the QPixmap to a QImage, as explained above).
++
++ \section1 Pixmap Transformations
++
++ QPixmap supports a number of functions for creating a new pixmap
++ that is a transformed version of the original:
++
++ The scaled(), scaledToWidth() and scaledToHeight() functions
++ return scaled copies of the pixmap, while the copy() function
++ creates a QPixmap that is a plain copy of the original one.
++
++ The transformed() function returns a copy of the pixmap that is
++ transformed with the given transformation matrix and
++ transformation mode: Internally, the transformation matrix is
++ adjusted to compensate for unwanted translation,
++ i.e. transformed() returns the smallest pixmap containing all
++ transformed points of the original pixmap. The static trueMatrix()
++ function returns the actual matrix used for transforming the
++ pixmap.
++
++ \sa QBitmap, QImage, QImageReader, QImageWriter
++ */
++
++
++ /*!
++ \typedef QPixmap::DataPtr
++ \internal
++ */
++
++ /*!
++ \fn DataPtr &QPixmap::data_ptr()
++ \internal
++ */
++
++ /*!
++ Returns \c true if this pixmap has an alpha channel, \e or has a
++ mask, otherwise returns \c false.
++
++ \sa hasAlphaChannel(), mask()
++ */
++ bool QPixmap::hasAlpha() const
++ {
++ return data && data->hasAlphaChannel();
++ }
++
++ /*!
++ Returns \c true if the pixmap has a format that respects the alpha
++ channel, otherwise returns \c false.
++
++ \sa hasAlpha()
++ */
++ bool QPixmap::hasAlphaChannel() const
++ {
++ return data && data->hasAlphaChannel();
++ }
++
++ /*!
++ \internal
++ */
++ int QPixmap::metric(PaintDeviceMetric metric) const
++ {
++ return data ? data->metric(metric) : 0;
++ }
++
++ /*!
++ \internal
++ */
++ QPaintEngine *QPixmap::paintEngine() const
++ {
++ return data ? data->paintEngine() : nullptr;
++ }
++
++ /*!
++ \fn QBitmap QPixmap::mask() const
++
++ Extracts a bitmap mask from the pixmap's alpha channel.
++
++ \warning This is potentially an expensive operation. The mask of
++ the pixmap is extracted dynamically from the pixeldata.
++
++ \sa setMask(), {QPixmap#Pixmap Information}{Pixmap Information}
++ */
++ QBitmap QPixmap::mask() const
++ {
++ return data ? data->mask() : QBitmap();
++ }
++
++ /*!
++ Returns the default pixmap depth used by the application.
++
++ On all platforms the depth of the primary screen will be returned.
++
++ \note QGuiApplication must be created before calling this function.
++
++ \sa depth(), {QPixmap#Pixmap Information}{Pixmap Information}
++
++ */
++ 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;
++ }
++
++ /*!
++ Detaches the pixmap from shared pixmap data.
++
++ A pixmap is automatically detached by Qt whenever its contents are
++ about to change. This is done in almost all QPixmap member
++ functions that modify the pixmap (fill(), fromImage(),
++ load(), etc.), and in QPainter::begin() on a pixmap.
++
++ There are two exceptions in which detach() must be called
++ explicitly, that is when calling the handle() or the
++ x11PictureHandle() function (only available on X11). Otherwise,
++ any modifications done using system calls, will be performed on
++ the shared data.
++
++ The detach() function returns immediately if there is just a
++ single reference or if the pixmap has not been initialized yet.
++ */
++ 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;
++ }
++
++ /*!
++ \fn QPixmap QPixmap::fromImage(const QImage &image, Qt::ImageConversionFlags flags)
++
++ Converts the given \a image to a pixmap using the specified \a
++ flags to control the conversion. The \a flags argument is a
++ bitwise-OR of the \l{Qt::ImageConversionFlags}. Passing 0 for \a
++ flags sets all the default options.
++
++ In case of monochrome and 8-bit images, the image is first
++ converted to a 32-bit pixmap and then filled with the colors in
++ the color table. If this is too expensive an operation, you can
++ use QBitmap::fromImage() instead.
++
++ \sa fromImageReader(), toImage(), {QPixmap#Pixmap Conversion}{Pixmap Conversion}
++ */
++ 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());
++ }
++
++ /*!
++ \fn QPixmap QPixmap::fromImage(QImage &&image, Qt::ImageConversionFlags flags)
++ \since 5.3
++ \overload
++
++ Converts the given \a image to a pixmap without copying if possible.
++ */
++
++
++ /*!
++ \internal
++ */
++ 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());
++ }
++
++ /*!
++ \fn QPixmap QPixmap::fromImageReader(QImageReader *imageReader, Qt::ImageConversionFlags flags)
++
++ Create a QPixmap from an image read directly from an \a imageReader.
++ The \a flags argument is a bitwise-OR of the \l{Qt::ImageConversionFlags}.
++ Passing 0 for \a flags sets all the default options.
++
++ On some systems, reading an image directly to QPixmap can use less memory than
++ reading a QImage to convert it to QPixmap.
++
++ \sa fromImage(), toImage(), {QPixmap#Pixmap Conversion}{Pixmap Conversion}
++ */
++ 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());
++ }
++
++ /*!
++ \internal
++ */
++ 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