373 lines
11 KiB
C++
373 lines
11 KiB
C++
/****************************************************************************
|
|
**
|
|
** Copyright (C) 2016 The Qt Company Ltd.
|
|
** Contact: https://www.qt.io/licensing/
|
|
**
|
|
** This file is part of the QtGui module of the Qt Toolkit.
|
|
**
|
|
** $QT_BEGIN_LICENSE:LGPL$
|
|
** Commercial License Usage
|
|
** Licensees holding valid commercial Qt licenses may use this file in
|
|
** accordance with the commercial license agreement provided with the
|
|
** Software or, alternatively, in accordance with the terms contained in
|
|
** a written agreement between you and The Qt Company. For licensing terms
|
|
** and conditions see https://www.qt.io/terms-conditions. For further
|
|
** information use the contact form at https://www.qt.io/contact-us.
|
|
**
|
|
** GNU Lesser General Public License Usage
|
|
** Alternatively, this file may be used under the terms of the GNU Lesser
|
|
** General Public License version 3 as published by the Free Software
|
|
** Foundation and appearing in the file LICENSE.LGPL3 included in the
|
|
** packaging of this file. Please review the following information to
|
|
** ensure the GNU Lesser General Public License version 3 requirements
|
|
** will be met: https://www.gnu.org/licenses/lgpl-3.0.html.
|
|
**
|
|
** GNU General Public License Usage
|
|
** Alternatively, this file may be used under the terms of the GNU
|
|
** General Public License version 2.0 or (at your option) the GNU General
|
|
** Public license version 3 or any later version approved by the KDE Free
|
|
** Qt Foundation. The licenses are as published by the Free Software
|
|
** Foundation and appearing in the file LICENSE.GPL2 and LICENSE.GPL3
|
|
** included in the packaging of this file. Please review the following
|
|
** information to ensure the GNU General Public License requirements will
|
|
** be met: https://www.gnu.org/licenses/gpl-2.0.html and
|
|
** https://www.gnu.org/licenses/gpl-3.0.html.
|
|
**
|
|
** $QT_END_LICENSE$
|
|
**
|
|
****************************************************************************/
|
|
|
|
#include "qpixmap.h"
|
|
|
|
#include <private/qfont_p.h>
|
|
|
|
#include "qpixmap_raster_p.h"
|
|
#include "qimage_p.h"
|
|
#include "qpaintengine.h"
|
|
|
|
#include "qbitmap.h"
|
|
#include "qimage.h"
|
|
#include <QBuffer>
|
|
#include <QImageReader>
|
|
#include <QGuiApplication>
|
|
#include <QScreen>
|
|
#include <private/qsimd_p.h>
|
|
#include <private/qdrawhelper_p.h>
|
|
#include <qpa/qplatformscreen.h>
|
|
|
|
QT_BEGIN_NAMESPACE
|
|
|
|
QPixmap qt_toRasterPixmap(const QImage &image)
|
|
{
|
|
QPlatformPixmap *data =
|
|
new QRasterPlatformPixmap(image.depth() == 1
|
|
? QPlatformPixmap::BitmapType
|
|
: QPlatformPixmap::PixmapType);
|
|
|
|
data->fromImage(image, Qt::AutoColor);
|
|
|
|
return QPixmap(data);
|
|
}
|
|
|
|
QPixmap qt_toRasterPixmap(const QPixmap &pixmap)
|
|
{
|
|
if (pixmap.isNull())
|
|
return QPixmap();
|
|
|
|
if (QPixmap(pixmap).data_ptr()->classId() == QPlatformPixmap::RasterClass)
|
|
return pixmap;
|
|
|
|
return qt_toRasterPixmap(pixmap.toImage());
|
|
}
|
|
|
|
QRasterPlatformPixmap::QRasterPlatformPixmap(PixelType type)
|
|
: QPlatformPixmap(type, RasterClass)
|
|
{
|
|
}
|
|
|
|
QRasterPlatformPixmap::~QRasterPlatformPixmap()
|
|
{
|
|
}
|
|
|
|
QImage::Format QRasterPlatformPixmap::systemNativeFormat()
|
|
{
|
|
if (!QGuiApplication::primaryScreen())
|
|
return QImage::Format_RGB32;
|
|
return QGuiApplication::primaryScreen()->handle()->format();
|
|
}
|
|
|
|
QPlatformPixmap *QRasterPlatformPixmap::createCompatiblePlatformPixmap() const
|
|
{
|
|
return new QRasterPlatformPixmap(pixelType());
|
|
}
|
|
|
|
void QRasterPlatformPixmap::resize(int width, int height)
|
|
{
|
|
QImage::Format format;
|
|
if (pixelType() == BitmapType)
|
|
format = QImage::Format_MonoLSB;
|
|
else
|
|
format = systemNativeFormat();
|
|
|
|
image = QImage(width, height, format);
|
|
w = width;
|
|
h = height;
|
|
d = image.depth();
|
|
is_null = (w <= 0 || h <= 0);
|
|
|
|
if (pixelType() == BitmapType && !image.isNull()) {
|
|
image.setColorCount(2);
|
|
image.setColor(0, QColor(Qt::color0).rgba());
|
|
image.setColor(1, QColor(Qt::color1).rgba());
|
|
}
|
|
|
|
setSerialNumber(image.cacheKey() >> 32);
|
|
}
|
|
|
|
bool QRasterPlatformPixmap::fromData(const uchar *buffer, uint len, const char *format,
|
|
Qt::ImageConversionFlags flags)
|
|
{
|
|
QByteArray a = QByteArray::fromRawData(reinterpret_cast<const char *>(buffer), len);
|
|
QBuffer b(&a);
|
|
b.open(QIODevice::ReadOnly);
|
|
QImage image = QImageReader(&b, format).read();
|
|
if (image.isNull())
|
|
return false;
|
|
|
|
createPixmapForImage(std::move(image), flags);
|
|
return !isNull();
|
|
}
|
|
|
|
void QRasterPlatformPixmap::fromImage(const QImage &sourceImage,
|
|
Qt::ImageConversionFlags flags)
|
|
{
|
|
QImage image = sourceImage;
|
|
createPixmapForImage(std::move(image), flags);
|
|
}
|
|
|
|
void QRasterPlatformPixmap::fromImageInPlace(QImage &sourceImage,
|
|
Qt::ImageConversionFlags flags)
|
|
{
|
|
createPixmapForImage(std::move(sourceImage), flags);
|
|
}
|
|
|
|
void QRasterPlatformPixmap::fromImageReader(QImageReader *imageReader,
|
|
Qt::ImageConversionFlags flags)
|
|
{
|
|
Q_UNUSED(flags);
|
|
QImage image = imageReader->read();
|
|
if (image.isNull())
|
|
return;
|
|
|
|
createPixmapForImage(std::move(image), flags);
|
|
}
|
|
|
|
// from qbackingstore.cpp
|
|
extern void qt_scrollRectInImage(QImage &img, const QRect &rect, const QPoint &offset);
|
|
|
|
void QRasterPlatformPixmap::copy(const QPlatformPixmap *data, const QRect &rect)
|
|
{
|
|
fromImage(data->toImage(rect).copy(), Qt::NoOpaqueDetection);
|
|
}
|
|
|
|
bool QRasterPlatformPixmap::scroll(int dx, int dy, const QRect &rect)
|
|
{
|
|
if (!image.isNull())
|
|
qt_scrollRectInImage(image, rect, QPoint(dx, dy));
|
|
return true;
|
|
}
|
|
|
|
void QRasterPlatformPixmap::fill(const QColor &color)
|
|
{
|
|
uint pixel;
|
|
|
|
if (image.depth() == 1) {
|
|
int gray = qGray(color.rgba());
|
|
// Pick the best approximate color in the image's colortable.
|
|
if (qAbs(qGray(image.color(0)) - gray) < qAbs(qGray(image.color(1)) - gray))
|
|
pixel = 0;
|
|
else
|
|
pixel = 1;
|
|
} else if (image.depth() >= 15) {
|
|
int alpha = color.alpha();
|
|
if (alpha != 255) {
|
|
if (!image.hasAlphaChannel()) {
|
|
QImage::Format toFormat = qt_alphaVersionForPainting(image.format());
|
|
if (!image.reinterpretAsFormat(toFormat))
|
|
image = QImage(image.width(), image.height(), toFormat);
|
|
}
|
|
}
|
|
image.fill(color);
|
|
return;
|
|
} else if (image.format() == QImage::Format_Alpha8) {
|
|
pixel = qAlpha(color.rgba());
|
|
} else if (image.format() == QImage::Format_Grayscale8) {
|
|
pixel = qGray(color.rgba());
|
|
} else if (image.format() == QImage::Format_Grayscale16) {
|
|
QRgba64 c = color.rgba64();
|
|
pixel = qGray(c.red(), c.green(), c.blue());
|
|
} else
|
|
{
|
|
pixel = 0;
|
|
// ### what about 8 bit indexed?
|
|
}
|
|
|
|
image.fill(pixel);
|
|
}
|
|
|
|
bool QRasterPlatformPixmap::hasAlphaChannel() const
|
|
{
|
|
return image.hasAlphaChannel();
|
|
}
|
|
|
|
QImage QRasterPlatformPixmap::toImage() const
|
|
{
|
|
if (!image.isNull()) {
|
|
QImageData *data = const_cast<QImage &>(image).data_ptr();
|
|
if (data->paintEngine && data->paintEngine->isActive()
|
|
&& data->paintEngine->paintDevice() == &image)
|
|
{
|
|
return image.copy();
|
|
}
|
|
}
|
|
|
|
return image;
|
|
}
|
|
|
|
QImage QRasterPlatformPixmap::toImage(const QRect &rect) const
|
|
{
|
|
if (rect.isNull())
|
|
return image;
|
|
|
|
QRect clipped = rect.intersected(QRect(0, 0, w, h));
|
|
const uint du = uint(d);
|
|
if ((du % 8 == 0) && (((uint(clipped.x()) * du)) % 32 == 0)) {
|
|
QImage newImage(image.scanLine(clipped.y()) + clipped.x() * (du / 8),
|
|
clipped.width(), clipped.height(),
|
|
image.bytesPerLine(), image.format());
|
|
newImage.setDevicePixelRatio(image.devicePixelRatio());
|
|
return newImage;
|
|
} else {
|
|
return image.copy(clipped);
|
|
}
|
|
}
|
|
|
|
QPaintEngine* QRasterPlatformPixmap::paintEngine() const
|
|
{
|
|
return image.paintEngine();
|
|
}
|
|
|
|
int QRasterPlatformPixmap::metric(QPaintDevice::PaintDeviceMetric metric) const
|
|
{
|
|
QImageData *d = image.d;
|
|
if (!d)
|
|
return 0;
|
|
|
|
// override the image dpi with the screen dpi when rendering to a pixmap
|
|
switch (metric) {
|
|
case QPaintDevice::PdmWidth:
|
|
return w;
|
|
case QPaintDevice::PdmHeight:
|
|
return h;
|
|
case QPaintDevice::PdmWidthMM:
|
|
return qRound(d->width * 25.4 / qt_defaultDpiX());
|
|
case QPaintDevice::PdmHeightMM:
|
|
return qRound(d->height * 25.4 / qt_defaultDpiY());
|
|
case QPaintDevice::PdmNumColors:
|
|
return d->colortable.size();
|
|
case QPaintDevice::PdmDepth:
|
|
return this->d;
|
|
case QPaintDevice::PdmDpiX:
|
|
return qt_defaultDpiX();
|
|
case QPaintDevice::PdmPhysicalDpiX:
|
|
return qt_defaultDpiX();
|
|
case QPaintDevice::PdmDpiY:
|
|
return qt_defaultDpiY();
|
|
case QPaintDevice::PdmPhysicalDpiY:
|
|
return qt_defaultDpiY();
|
|
case QPaintDevice::PdmDevicePixelRatio:
|
|
return image.devicePixelRatio();
|
|
case QPaintDevice::PdmDevicePixelRatioScaled:
|
|
return image.devicePixelRatio() * QPaintDevice::devicePixelRatioFScale();
|
|
|
|
default:
|
|
qWarning("QRasterPlatformPixmap::metric(): Unhandled metric type %d", metric);
|
|
break;
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
void QRasterPlatformPixmap::createPixmapForImage(QImage sourceImage, Qt::ImageConversionFlags flags)
|
|
{
|
|
QImage::Format format;
|
|
if (flags & Qt::NoFormatConversion)
|
|
format = sourceImage.format();
|
|
else
|
|
if (pixelType() == BitmapType) {
|
|
format = QImage::Format_MonoLSB;
|
|
} else {
|
|
if (sourceImage.depth() == 1) {
|
|
format = sourceImage.hasAlphaChannel()
|
|
? QImage::Format_ARGB32_Premultiplied
|
|
: QImage::Format_RGB32;
|
|
} else {
|
|
QImage::Format nativeFormat = systemNativeFormat();
|
|
QImage::Format opaqueFormat = qt_opaqueVersionForPainting(nativeFormat);
|
|
QImage::Format alphaFormat = qt_alphaVersionForPainting(nativeFormat);
|
|
|
|
if (!sourceImage.hasAlphaChannel()) {
|
|
format = opaqueFormat;
|
|
} else if ((flags & Qt::NoOpaqueDetection) == 0
|
|
&& !sourceImage.data_ptr()->checkForAlphaPixels())
|
|
{
|
|
format = opaqueFormat;
|
|
} else {
|
|
format = alphaFormat;
|
|
}
|
|
}
|
|
}
|
|
|
|
// image has alpha format but is really opaque, so try to do a
|
|
// more efficient conversion
|
|
if (format == QImage::Format_RGB32 && (sourceImage.format() == QImage::Format_ARGB32
|
|
|| sourceImage.format() == QImage::Format_ARGB32_Premultiplied))
|
|
{
|
|
image = std::move(sourceImage);
|
|
image.reinterpretAsFormat(QImage::Format_RGB32);
|
|
} else {
|
|
image = std::move(sourceImage).convertToFormat(format, flags);
|
|
}
|
|
|
|
if (image.d) {
|
|
w = image.d->width;
|
|
h = image.d->height;
|
|
d = image.d->depth;
|
|
} else {
|
|
w = h = d = 0;
|
|
}
|
|
is_null = (w <= 0 || h <= 0);
|
|
|
|
//ensure the pixmap and the image resulting from toImage() have the same cacheKey();
|
|
setSerialNumber(image.cacheKey() >> 32);
|
|
if (image.d)
|
|
setDetachNumber(image.d->detach_no);
|
|
}
|
|
|
|
QImage* QRasterPlatformPixmap::buffer()
|
|
{
|
|
return ℑ
|
|
}
|
|
|
|
qreal QRasterPlatformPixmap::devicePixelRatio() const
|
|
{
|
|
return image.devicePixelRatio();
|
|
}
|
|
|
|
void QRasterPlatformPixmap::setDevicePixelRatio(qreal scaleFactor)
|
|
{
|
|
image.setDevicePixelRatio(scaleFactor);
|
|
}
|
|
|
|
QT_END_NAMESPACE
|