Revision control
Copy as Markdown
// 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 "qsgsoftwareinternalimagenode_p.h"
#include "qsgsoftwarepixmaptexture_p.h"
#include "qsgsoftwarelayer_p.h"
#include <QPainter>
#include <qmath.h>
QT_BEGIN_NAMESPACE
namespace QSGSoftwareHelpers {
// Helper from widgets/styles/qdrawutil.cpp
static inline QMargins normalizedMargins(const QMargins &m)
{
return QMargins(qMax(m.left(), 0), qMax(m.top(), 0), qMax(m.right(), 0), qMax(m.bottom(), 0));
}
void qDrawBorderPixmap(QPainter *painter, const QRect &targetRect, const QMargins &targetMarginsIn,
const QPixmap &pixmap, const QRect &sourceRect, const QMargins &sourceMarginsIn,
const QTileRules &rules, QDrawBorderPixmap::DrawingHints hints)
{
QPainter::PixmapFragment d;
d.opacity = 1.0;
d.rotation = 0.0;
QPixmapFragmentsArray opaqueData;
QPixmapFragmentsArray translucentData;
QMargins sourceMargins = normalizedMargins(sourceMarginsIn);
QMargins targetMargins = normalizedMargins(targetMarginsIn);
const qreal sourceDpr = pixmap.devicePixelRatio();
sourceMargins *= sourceDpr;
// source center
const int sourceCenterTop = sourceRect.top() + sourceMargins.top();
const int sourceCenterLeft = sourceRect.left() + sourceMargins.left();
const int sourceCenterBottom = sourceRect.bottom() - sourceMargins.bottom() + 1;
const int sourceCenterRight = sourceRect.right() - sourceMargins.right() + 1;
const int sourceCenterWidth = sourceCenterRight - sourceCenterLeft;
const int sourceCenterHeight = sourceCenterBottom - sourceCenterTop;
// target center
const int targetCenterTop = targetRect.top() + targetMargins.top();
const int targetCenterLeft = targetRect.left() + targetMargins.left();
const int targetCenterBottom = targetRect.bottom() - targetMargins.bottom() + 1;
const int targetCenterRight = targetRect.right() - targetMargins.right() + 1;
const int targetCenterWidth = targetCenterRight - targetCenterLeft;
const int targetCenterHeight = targetCenterBottom - targetCenterTop;
QVarLengthArray<qreal, 16> xTarget; // x-coordinates of target rectangles
QVarLengthArray<qreal, 16> yTarget; // y-coordinates of target rectangles
int columns = 3;
int rows = 3;
if (rules.horizontal != Qt::StretchTile && sourceCenterWidth != 0)
columns = qMax(3, 2 + qCeil((targetCenterWidth * sourceDpr) / qreal(sourceCenterWidth)));
if (rules.vertical != Qt::StretchTile && sourceCenterHeight != 0)
rows = qMax(3, 2 + qCeil((targetCenterHeight * sourceDpr) / qreal(sourceCenterHeight)));
xTarget.resize(columns + 1);
yTarget.resize(rows + 1);
xTarget[0] = targetRect.left();
xTarget[1] = targetCenterLeft;
xTarget[columns - 1] = targetCenterRight;
xTarget[columns] = targetRect.left() + targetRect.width();
yTarget[0] = targetRect.top();
yTarget[1] = targetCenterTop;
yTarget[rows - 1] = targetCenterBottom;
yTarget[rows] = targetRect.top() + targetRect.height();
qreal dx = targetCenterWidth;
qreal dy = targetCenterHeight;
switch (rules.horizontal) {
case Qt::StretchTile:
dx = targetCenterWidth;
break;
case Qt::RepeatTile:
dx = sourceCenterWidth / sourceDpr;
break;
case Qt::RoundTile:
dx = targetCenterWidth / qreal(columns - 2);
break;
}
for (int i = 2; i < columns - 1; ++i)
xTarget[i] = xTarget[i - 1] + dx;
switch (rules.vertical) {
case Qt::StretchTile:
dy = targetCenterHeight;
break;
case Qt::RepeatTile:
dy = sourceCenterHeight / sourceDpr;
break;
case Qt::RoundTile:
dy = targetCenterHeight / qreal(rows - 2);
break;
}
for (int i = 2; i < rows - 1; ++i)
yTarget[i] = yTarget[i - 1] + dy;
// corners
if (targetMargins.top() > 0 && targetMargins.left() > 0 && sourceMargins.top() > 0 && sourceMargins.left() > 0) { // top left
d.x = (0.5 * (xTarget[1] + xTarget[0]));
d.y = (0.5 * (yTarget[1] + yTarget[0]));
d.sourceLeft = sourceRect.left();
d.sourceTop = sourceRect.top();
d.width = sourceMargins.left();
d.height = sourceMargins.top();
d.scaleX = qreal(xTarget[1] - xTarget[0]) / d.width;
d.scaleY = qreal(yTarget[1] - yTarget[0]) / d.height;
if (hints & QDrawBorderPixmap::OpaqueTopLeft)
opaqueData.append(d);
else
translucentData.append(d);
}
if (targetMargins.top() > 0 && targetMargins.right() > 0 && sourceMargins.top() > 0 && sourceMargins.right() > 0) { // top right
d.x = (0.5 * (xTarget[columns] + xTarget[columns - 1]));
d.y = (0.5 * (yTarget[1] + yTarget[0]));
d.sourceLeft = sourceCenterRight;
d.sourceTop = sourceRect.top();
d.width = sourceMargins.right();
d.height = sourceMargins.top();
d.scaleX = qreal(xTarget[columns] - xTarget[columns - 1]) / d.width;
d.scaleY = qreal(yTarget[1] - yTarget[0]) / d.height;
if (hints & QDrawBorderPixmap::OpaqueTopRight)
opaqueData.append(d);
else
translucentData.append(d);
}
if (targetMargins.bottom() > 0 && targetMargins.left() > 0 && sourceMargins.bottom() > 0 && sourceMargins.left() > 0) { // bottom left
d.x = (0.5 * (xTarget[1] + xTarget[0]));
d.y =(0.5 * (yTarget[rows] + yTarget[rows - 1]));
d.sourceLeft = sourceRect.left();
d.sourceTop = sourceCenterBottom;
d.width = sourceMargins.left();
d.height = sourceMargins.bottom();
d.scaleX = qreal(xTarget[1] - xTarget[0]) / d.width;
d.scaleY = qreal(yTarget[rows] - yTarget[rows - 1]) / d.height;
if (hints & QDrawBorderPixmap::OpaqueBottomLeft)
opaqueData.append(d);
else
translucentData.append(d);
}
if (targetMargins.bottom() > 0 && targetMargins.right() > 0 && sourceMargins.bottom() > 0 && sourceMargins.right() > 0) { // bottom right
d.x = (0.5 * (xTarget[columns] + xTarget[columns - 1]));
d.y = (0.5 * (yTarget[rows] + yTarget[rows - 1]));
d.sourceLeft = sourceCenterRight;
d.sourceTop = sourceCenterBottom;
d.width = sourceMargins.right();
d.height = sourceMargins.bottom();
d.scaleX = qreal(xTarget[columns] - xTarget[columns - 1]) / d.width;
d.scaleY = qreal(yTarget[rows] - yTarget[rows - 1]) / d.height;
if (hints & QDrawBorderPixmap::OpaqueBottomRight)
opaqueData.append(d);
else
translucentData.append(d);
}
// horizontal edges
if (targetCenterWidth > 0 && sourceCenterWidth > 0) {
if (targetMargins.top() > 0 && sourceMargins.top() > 0) { // top
QPixmapFragmentsArray &data = hints & QDrawBorderPixmap::OpaqueTop ? opaqueData : translucentData;
d.sourceLeft = sourceCenterLeft;
d.sourceTop = sourceRect.top();
d.width = sourceCenterWidth;
d.height = sourceMargins.top();
d.y = (0.5 * (yTarget[1] + yTarget[0]));
d.scaleX = dx / d.width;
d.scaleY = qreal(yTarget[1] - yTarget[0]) / d.height;
for (int i = 1; i < columns - 1; ++i) {
d.x = (0.5 * (xTarget[i + 1] + xTarget[i]));
data.append(d);
}
if (rules.horizontal == Qt::RepeatTile)
data[data.size() - 1].width = ((xTarget[columns - 1] - xTarget[columns - 2]) / d.scaleX);
}
if (targetMargins.bottom() > 0 && sourceMargins.bottom() > 0) { // bottom
QPixmapFragmentsArray &data = hints & QDrawBorderPixmap::OpaqueBottom ? opaqueData : translucentData;
d.sourceLeft = sourceCenterLeft;
d.sourceTop = sourceCenterBottom;
d.width = sourceCenterWidth;
d.height = sourceMargins.bottom();
d.y = (0.5 * (yTarget[rows] + yTarget[rows - 1]));
d.scaleX = dx / d.width;
d.scaleY = qreal(yTarget[rows] - yTarget[rows - 1]) / d.height;
for (int i = 1; i < columns - 1; ++i) {
d.x = (0.5 * (xTarget[i + 1] + xTarget[i]));
data.append(d);
}
if (rules.horizontal == Qt::RepeatTile)
data[data.size() - 1].width = ((xTarget[columns - 1] - xTarget[columns - 2]) / d.scaleX);
}
}
// vertical edges
if (targetCenterHeight > 0 && sourceCenterHeight > 0) {
if (targetMargins.left() > 0 && sourceMargins.left() > 0) { // left
QPixmapFragmentsArray &data = hints & QDrawBorderPixmap::OpaqueLeft ? opaqueData : translucentData;
d.sourceLeft = sourceRect.left();
d.sourceTop = sourceCenterTop;
d.width = sourceMargins.left();
d.height = sourceCenterHeight;
d.x = (0.5 * (xTarget[1] + xTarget[0]));
d.scaleX = qreal(xTarget[1] - xTarget[0]) / d.width;
d.scaleY = dy / d.height;
for (int i = 1; i < rows - 1; ++i) {
d.y = (0.5 * (yTarget[i + 1] + yTarget[i]));
data.append(d);
}
if (rules.vertical == Qt::RepeatTile)
data[data.size() - 1].height = ((yTarget[rows - 1] - yTarget[rows - 2]) / d.scaleY);
}
if (targetMargins.right() > 0 && sourceMargins.right() > 0) { // right
QPixmapFragmentsArray &data = hints & QDrawBorderPixmap::OpaqueRight ? opaqueData : translucentData;
d.sourceLeft = sourceCenterRight;
d.sourceTop = sourceCenterTop;
d.width = sourceMargins.right();
d.height = sourceCenterHeight;
d.x = (0.5 * (xTarget[columns] + xTarget[columns - 1]));
d.scaleX = qreal(xTarget[columns] - xTarget[columns - 1]) / d.width;
d.scaleY = dy / d.height;
for (int i = 1; i < rows - 1; ++i) {
d.y = (0.5 * (yTarget[i + 1] + yTarget[i]));
data.append(d);
}
if (rules.vertical == Qt::RepeatTile)
data[data.size() - 1].height = ((yTarget[rows - 1] - yTarget[rows - 2]) / d.scaleY);
}
}
// center
if (targetCenterWidth > 0 && targetCenterHeight > 0 && sourceCenterWidth > 0 && sourceCenterHeight > 0) {
QPixmapFragmentsArray &data = hints & QDrawBorderPixmap::OpaqueCenter ? opaqueData : translucentData;
d.sourceLeft = sourceCenterLeft;
d.sourceTop = sourceCenterTop;
d.width = sourceCenterWidth;
d.height = sourceCenterHeight;
d.scaleX = dx / d.width;
d.scaleY = dy / d.height;
qreal repeatWidth = (xTarget[columns - 1] - xTarget[columns - 2]) / d.scaleX;
qreal repeatHeight = (yTarget[rows - 1] - yTarget[rows - 2]) / d.scaleY;
for (int j = 1; j < rows - 1; ++j) {
d.y = (0.5 * (yTarget[j + 1] + yTarget[j]));
for (int i = 1; i < columns - 1; ++i) {
d.x = (0.5 * (xTarget[i + 1] + xTarget[i]));
data.append(d);
}
if (rules.horizontal == Qt::RepeatTile)
data[data.size() - 1].width = repeatWidth;
}
if (rules.vertical == Qt::RepeatTile) {
for (int i = 1; i < columns - 1; ++i)
data[data.size() - i].height = repeatHeight;
}
}
if (opaqueData.size())
painter->drawPixmapFragments(opaqueData.data(), opaqueData.size(), pixmap, QPainter::OpaqueHint);
if (translucentData.size())
painter->drawPixmapFragments(translucentData.data(), translucentData.size(), pixmap);
}
} // QSGSoftwareHelpers namespace
QSGSoftwareInternalImageNode::QSGSoftwareInternalImageNode()
: m_innerSourceRect(0, 0, 1, 1)
, m_subSourceRect(0, 0, 1, 1)
, m_texture(nullptr)
, m_mirrorHorizontally(false)
, m_mirrorVertically(false)
, m_textureIsLayer(false)
, m_smooth(true)
, m_tileHorizontal(false)
, m_tileVertical(false)
, m_cachedMirroredPixmapIsDirty(false)
{
setMaterial((QSGMaterial*)1);
setGeometry((QSGGeometry*)1);
}
void QSGSoftwareInternalImageNode::setTargetRect(const QRectF &rect)
{
if (rect == m_targetRect)
return;
m_targetRect = rect;
markDirty(DirtyGeometry);
}
void QSGSoftwareInternalImageNode::setInnerTargetRect(const QRectF &rect)
{
if (rect == m_innerTargetRect)
return;
m_innerTargetRect = rect;
markDirty(DirtyGeometry);
}
void QSGSoftwareInternalImageNode::setInnerSourceRect(const QRectF &rect)
{
if (rect == m_innerSourceRect)
return;
m_innerSourceRect = rect;
markDirty(DirtyGeometry);
}
void QSGSoftwareInternalImageNode::setSubSourceRect(const QRectF &rect)
{
if (rect == m_subSourceRect)
return;
m_subSourceRect = rect;
markDirty(DirtyGeometry);
}
void QSGSoftwareInternalImageNode::setTexture(QSGTexture *texture)
{
m_texture = texture;
m_cachedMirroredPixmapIsDirty = true;
m_textureIsLayer = static_cast<bool>(qobject_cast<QSGSoftwareLayer*>(texture));
markDirty(DirtyMaterial);
}
void QSGSoftwareInternalImageNode::setMirror(bool mirrorHorizontally, bool mirrorVertically)
{
if (mirrorHorizontally == m_mirrorHorizontally && mirrorVertically == m_mirrorVertically)
return;
m_mirrorHorizontally = mirrorHorizontally;
m_mirrorVertically = mirrorVertically;
m_cachedMirroredPixmapIsDirty = true;
markDirty(DirtyMaterial);
}
void QSGSoftwareInternalImageNode::setMipmapFiltering(QSGTexture::Filtering /*filtering*/)
{
}
void QSGSoftwareInternalImageNode::setFiltering(QSGTexture::Filtering filtering)
{
bool smooth = (filtering == QSGTexture::Linear);
if (smooth == m_smooth)
return;
m_smooth = smooth;
markDirty(DirtyMaterial);
}
void QSGSoftwareInternalImageNode::setHorizontalWrapMode(QSGTexture::WrapMode wrapMode)
{
bool tileHorizontal = (wrapMode == QSGTexture::Repeat);
if (tileHorizontal == m_tileHorizontal)
return;
m_tileHorizontal = tileHorizontal;
markDirty(DirtyMaterial);
}
void QSGSoftwareInternalImageNode::setVerticalWrapMode(QSGTexture::WrapMode wrapMode)
{
bool tileVertical = (wrapMode == QSGTexture::Repeat);
if (tileVertical == m_tileVertical)
return;
m_tileVertical = (wrapMode == QSGTexture::Repeat);
markDirty(DirtyMaterial);
}
void QSGSoftwareInternalImageNode::update()
{
updateCachedMirroredPixmap();
}
void QSGSoftwareInternalImageNode::preprocess()
{
bool doDirty = false;
QSGLayer *t = qobject_cast<QSGLayer *>(m_texture);
if (t) {
doDirty = t->updateTexture();
markDirty(DirtyGeometry);
}
if (doDirty)
markDirty(DirtyMaterial);
m_cachedMirroredPixmapIsDirty = doDirty;
}
static Qt::TileRule getTileRule(qreal factor)
{
int ifactor = qRound(factor);
if (qFuzzyCompare(factor, ifactor )) {
if (ifactor == 1 || ifactor == 0)
return Qt::StretchTile;
return Qt::RoundTile;
}
return Qt::RepeatTile;
}
void QSGSoftwareInternalImageNode::paint(QPainter *painter)
{
painter->setRenderHint(QPainter::SmoothPixmapTransform, m_smooth);
// Disable antialiased clipping. It causes transformed tiles to have gaps.
painter->setRenderHint(QPainter::Antialiasing, false);
updateCachedMirroredPixmap();
const QPixmap &pm = m_mirrorHorizontally || m_mirrorVertically || m_textureIsLayer ? m_cachedMirroredPixmap : pixmap();
if (m_innerTargetRect != m_targetRect) {
// border image
QMargins margins(m_innerTargetRect.left() - m_targetRect.left(), m_innerTargetRect.top() - m_targetRect.top(),
m_targetRect.right() - m_innerTargetRect.right(), m_targetRect.bottom() - m_innerTargetRect.bottom());
QSGSoftwareHelpers::QTileRules tilerules(getTileRule(m_subSourceRect.width()), getTileRule(m_subSourceRect.height()));
QSGSoftwareHelpers::qDrawBorderPixmap(painter, m_targetRect.toRect(), margins, pm, QRect(0, 0, pm.width(), pm.height()),
margins, tilerules, QSGSoftwareHelpers::QDrawBorderPixmap::DrawingHints{});
return;
}
if (m_tileHorizontal || m_tileVertical) {
painter->save();
qreal sx = m_targetRect.width()/(m_subSourceRect.width()*pm.width());
qreal sy = m_targetRect.height()/(m_subSourceRect.height()*pm.height());
painter->setTransform(QTransform::fromScale(sx, sy), true);
painter->drawTiledPixmap(QRectF(m_targetRect.x()/sx, m_targetRect.y()/sy, m_targetRect.width()/sx, m_targetRect.height()/sy),
pm,
QPointF(m_subSourceRect.left()*pm.width(), m_subSourceRect.top()*pm.height()));
painter->restore();
} else {
QRectF sr(m_subSourceRect.left()*pm.width(), m_subSourceRect.top()*pm.height(),
m_subSourceRect.width()*pm.width(), m_subSourceRect.height()*pm.height());
painter->drawPixmap(m_targetRect, pm, sr);
}
}
QRectF QSGSoftwareInternalImageNode::rect() const
{
return m_targetRect;
}
const QPixmap &QSGSoftwareInternalImageNode::pixmap() const
{
if (QSGSoftwarePixmapTexture *pt = qobject_cast<QSGSoftwarePixmapTexture*>(m_texture))
return pt->pixmap();
if (QSGSoftwareLayer *layer = qobject_cast<QSGSoftwareLayer*>(m_texture))
return layer->pixmap();
Q_ASSERT(m_texture == nullptr);
static const QPixmap nullPixmap;
return nullPixmap;
}
void QSGSoftwareInternalImageNode::updateCachedMirroredPixmap()
{
if (m_cachedMirroredPixmapIsDirty) {
if (m_mirrorHorizontally || m_mirrorVertically || m_textureIsLayer) {
QTransform transform(
(m_mirrorHorizontally ? -1 : 1), 0,
0 , (m_textureIsLayer ? -1 : 1) * (m_mirrorVertically ? -1 : 1),
0 , 0
);
m_cachedMirroredPixmap = pixmap().transformed(transform);
} else {
//Cleanup cached pixmap if necessary
if (!m_cachedMirroredPixmap.isNull())
m_cachedMirroredPixmap = QPixmap();
}
m_cachedMirroredPixmapIsDirty = false;
}
}
QT_END_NAMESPACE