Revision control
++ // Copyright (C) 2016 The Qt Company Ltd.
++ // SPDX-License-Identifier: LicenseRef-Qt-Commercial OR LGPL-3.0-only OR GPL-2.0-only OR GPL-3.0-only
++ // Qt-Security score:significant reason:default
++
++ #include "qplatformpixmap.h"
++ #include <qpa/qplatformintegration.h>
++ #include <QtCore/qbuffer.h>
++ #include <QtGui/qbitmap.h>
++ #include <QtGui/qimagereader.h>
++ #include <private/qguiapplication_p.h>
++ #include <private/qimagepixmapcleanuphooks_p.h>
++
++ QT_BEGIN_NAMESPACE
++
++ /*!
++ \class QPlatformPixmap
++ \since 5.0
++ \internal
++ \preliminary
++ \ingroup qpa
++
++ \brief The QPlatformPixmap class provides an abstraction for native pixmaps.
++ */
++ QPlatformPixmap *QPlatformPixmap::create(int w, int h, PixelType type)
++ {
++ if (Q_UNLIKELY(!QGuiApplicationPrivate::platformIntegration()))
++ qFatal("QPlatformPixmap: QGuiApplication required");
++
++ QPlatformPixmap *data = QGuiApplicationPrivate::platformIntegration()->createPlatformPixmap(static_cast<QPlatformPixmap::PixelType>(type));
++ data->resize(w, h);
++ return data;
++ }
++
++
++ QPlatformPixmap::QPlatformPixmap(PixelType pixelType, int objectId)
++ : w(0),
++ h(0),
++ d(0),
++ is_null(true),
++ detach_no(0),
++ type(pixelType),
++ id(objectId),
++ ser_no(0),
++ is_cached(false)
++ {
++ }
++
++ QPlatformPixmap::~QPlatformPixmap()
++ {
++ callDestructionHooks();
++ }
++
++ // Sometimes derived classes need the cache cleanup / destruction hooks to be executed _before_
++ // deleting their native pixmap handles. Such classes can call this function from their own
++ // destructor. The is_cached guard ensures the hooks are only executed once even though both the
++ // derived and base destructors call this function.
++ void QPlatformPixmap::callDestructionHooks()
++ {
++ if (is_cached) {
++ QImagePixmapCleanupHooks::executePlatformPixmapDestructionHooks(this);
++ is_cached = false;
++ }
++ }
++
++ QPlatformPixmap *QPlatformPixmap::createCompatiblePlatformPixmap() const
++ {
++ QPlatformPixmap *d = QGuiApplicationPrivate::platformIntegration()->createPlatformPixmap(pixelType());
++ return d;
++ }
++
++ static QImage makeBitmapCompliantIfNeeded(QPlatformPixmap *d, QImage image, Qt::ImageConversionFlags flags)
++ {
++ if (d->pixelType() == QPlatformPixmap::BitmapType) {
++ QImage img = std::move(image).convertToFormat(QImage::Format_MonoLSB, flags);
++
++ // make sure image.color(0) == Qt::color0 (white)
++ // and image.color(1) == Qt::color1 (black)
++ const QRgb c0 = QColor(Qt::black).rgb();
++ const QRgb c1 = QColor(Qt::white).rgb();
++ if (img.color(0) == c0 && img.color(1) == c1) {
++ img.invertPixels();
++ img.setColor(0, c1);
++ img.setColor(1, c0);
++ }
++ return img;
++ }
++
++ return image;
++ }
++
++ void QPlatformPixmap::fromImageReader(QImageReader *imageReader,
++ Qt::ImageConversionFlags flags)
++ {
++ const QImage image = imageReader->read();
++ fromImage(image, flags);
++ }
++
++ bool QPlatformPixmap::fromFile(const QString &fileName, const char *format,
++ Qt::ImageConversionFlags flags)
++ {
++ QImage image = QImageReader(fileName, format).read();
++ if (image.isNull())
++ return false;
++ fromImage(makeBitmapCompliantIfNeeded(this, std::move(image), flags), flags);
++ return !isNull();
++ }
++
++ bool QPlatformPixmap::fromData(const uchar *buf, uint len, const char *format, Qt::ImageConversionFlags flags)
++ {
++ QByteArray a = QByteArray::fromRawData(reinterpret_cast<const char *>(buf), len);
++ QBuffer b(&a);
++ b.open(QIODevice::ReadOnly);
++ QImage image = QImageReader(&b, format).read();
++ if (image.isNull())
++ return false;
++ fromImage(makeBitmapCompliantIfNeeded(this, std::move(image), flags), flags);
++ return !isNull();
++ }
++
++ void QPlatformPixmap::copy(const QPlatformPixmap *data, const QRect &rect)
++ {
++ fromImage(data->toImage(rect), Qt::NoOpaqueDetection);
++ }
++
++ bool QPlatformPixmap::scroll(int dx, int dy, const QRect &rect)
++ {
++ Q_UNUSED(dx);
++ Q_UNUSED(dy);
++ Q_UNUSED(rect);
++ return false;
++ }
++
++ QBitmap QPlatformPixmap::mask() const
++ {
++ if (!hasAlphaChannel())
++ return QBitmap();
++
++ QImage img = toImage();
++ bool shouldConvert = (img.format() != QImage::Format_ARGB32 && img.format() != QImage::Format_ARGB32_Premultiplied);
++ const QImage image = (shouldConvert ? std::move(img).convertToFormat(QImage::Format_ARGB32_Premultiplied) : img);
++ const int w = image.width();
++ const int h = image.height();
++
++ QImage mask(w, h, QImage::Format_MonoLSB);
++ if (mask.isNull()) // allocation failed
++ return QBitmap();
++
++ mask.setDevicePixelRatio(devicePixelRatio());
++ mask.setColorCount(2);
++ mask.setColor(0, QColor(Qt::color0).rgba());
++ mask.setColor(1, QColor(Qt::color1).rgba());
++
++ const qsizetype bpl = mask.bytesPerLine();
++
++ for (int y = 0; y < h; ++y) {
++ const QRgb *src = reinterpret_cast<const QRgb*>(image.scanLine(y));
++ uchar *dest = mask.scanLine(y);
++ memset(dest, 0, bpl);
++ for (int x = 0; x < w; ++x) {
++ if (qAlpha(*src) > 0)
++ dest[x >> 3] |= (1 << (x & 7));
++ ++src;
++ }
++ }
++
++ return QBitmap::fromImage(std::move(mask));
++ }
++
++ void QPlatformPixmap::setMask(const QBitmap &mask)
++ {
++ QImage image = toImage();
++ if (mask.size().isEmpty()) {
++ if (image.depth() != 1) { // hw: ????
++ image = std::move(image).convertToFormat(QImage::Format_RGB32);
++ }
++ } else {
++ const int w = image.width();
++ const int h = image.height();
++
++ switch (image.depth()) {
++ case 1: {
++ const QImage imageMask = mask.toImage().convertToFormat(image.format());
++ for (int y = 0; y < h; ++y) {
++ const uchar *mscan = imageMask.scanLine(y);
++ uchar *tscan = image.scanLine(y);
++ qsizetype bytesPerLine = image.bytesPerLine();
++ for (int i = 0; i < bytesPerLine; ++i)
++ tscan[i] &= mscan[i];
++ }
++ break;
++ }
++ default: {
++ const QImage imageMask = mask.toImage().convertToFormat(QImage::Format_MonoLSB);
++ image = std::move(image).convertToFormat(QImage::Format_ARGB32_Premultiplied);
++ for (int y = 0; y < h; ++y) {
++ const uchar *mscan = imageMask.scanLine(y);
++ QRgb *tscan = (QRgb *)image.scanLine(y);
++ for (int x = 0; x < w; ++x) {
++ if (!(mscan[x>>3] & (1 << (x&7))))
++ tscan[x] = 0;
++ }
++ }
++ break;
++ }
++ }
++ }
++ fromImage(image, Qt::AutoColor);
++ }
++
++ QPixmap QPlatformPixmap::transformed(const QTransform &matrix,
++ Qt::TransformationMode mode) const
++ {
++ return QPixmap::fromImage(toImage().transformed(matrix, mode));
++ }
++
++ void QPlatformPixmap::setSerialNumber(int serNo)
++ {
++ ser_no = serNo;
++ }
++
++ void QPlatformPixmap::setDetachNumber(int detNo)
++ {
++ detach_no = detNo;
++ }
++
++ QImage QPlatformPixmap::toImage(const QRect &rect) const
++ {
++ if (rect.contains(QRect(0, 0, w, h)))
++ return toImage();
++ else
++ return toImage().copy(rect);
++ }
++
++ QImage* QPlatformPixmap::buffer()
++ {
++ return nullptr;
++ }
++
++
++ QT_END_NAMESPACE