// 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()

        && !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 = 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;

}

/*!

    \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