qsgbasicinternalimagenode.cpp

++ // 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 "qsgbasicinternalimagenode_p.h"

++

++ #include <QtCore/qvarlengtharray.h>

++ #include <QtCore/qmath.h>

++

++ QT_BEGIN_NAMESPACE

++

++ namespace

++ {

++     struct SmoothImageVertex

++     {

++         float x, y, u, v;

++         float dx, dy, du, dv;

++     };

++

++     const QSGGeometry::AttributeSet &smoothImageAttributeSet()

++     {

++         static QSGGeometry::Attribute data[] = {

++             QSGGeometry::Attribute::createWithAttributeType(0, 2, QSGGeometry::FloatType, QSGGeometry::PositionAttribute),

++             QSGGeometry::Attribute::createWithAttributeType(1, 2, QSGGeometry::FloatType, QSGGeometry::TexCoordAttribute),

++             QSGGeometry::Attribute::createWithAttributeType(2, 2, QSGGeometry::FloatType, QSGGeometry::TexCoord1Attribute),

++             QSGGeometry::Attribute::createWithAttributeType(3, 2, QSGGeometry::FloatType, QSGGeometry::TexCoord2Attribute)

++         };

++         static QSGGeometry::AttributeSet attrs = { 4, sizeof(SmoothImageVertex), data };

++         return attrs;

++     }

++ }

++

++ QSGBasicInternalImageNode::QSGBasicInternalImageNode()

++     : m_innerSourceRect(0, 0, 1, 1)

++     , m_subSourceRect(0, 0, 1, 1)

++     , m_antialiasing(false)

++     , m_mirrorHorizontally(false)

++     , m_mirrorVertically(false)

++     , m_dirtyGeometry(false)

++     , m_geometry(QSGGeometry::defaultAttributes_TexturedPoint2D(), 4)

++     , m_dynamicTexture(nullptr)

++ {

++     setGeometry(&m_geometry);

++

++ #ifdef QSG_RUNTIME_DESCRIPTION

++     qsgnode_set_description(this, QLatin1String("internalimage"));

++ #endif

++ }

++

++ void QSGBasicInternalImageNode::setTargetRect(const QRectF &rect)

++ {

++     if (rect == m_targetRect)

++         return;

++     m_targetRect = rect;

++     m_dirtyGeometry = true;

++ }

++

++ void QSGBasicInternalImageNode::setInnerTargetRect(const QRectF &rect)

++ {

++     if (rect == m_innerTargetRect)

++         return;

++     m_innerTargetRect = rect;

++     m_dirtyGeometry = true;

++ }

++

++ void QSGBasicInternalImageNode::setInnerSourceRect(const QRectF &rect)

++ {

++     if (rect == m_innerSourceRect)

++         return;

++     m_innerSourceRect = rect;

++     m_dirtyGeometry = true;

++ }

++

++ void QSGBasicInternalImageNode::setSubSourceRect(const QRectF &rect)

++ {

++     if (rect == m_subSourceRect)

++         return;

++     m_subSourceRect = rect;

++     m_dirtyGeometry = true;

++ }

++

++ void QSGBasicInternalImageNode::setTexture(QSGTexture *texture)

++ {

++     Q_ASSERT(texture);

++

++     setMaterialTexture(texture);

++     updateMaterialBlending();

++

++     markDirty(DirtyMaterial);

++

++     // Because the texture can be a different part of the atlas, we need to update it...

++     m_dirtyGeometry = true;

++ }

++

++ void QSGBasicInternalImageNode::setAntialiasing(bool antialiasing)

++ {

++     if (antialiasing == m_antialiasing)

++         return;

++     m_antialiasing = antialiasing;

++     if (m_antialiasing) {

++         setGeometry(new QSGGeometry(smoothImageAttributeSet(), 0));

++         setFlag(OwnsGeometry, true);

++     } else {

++         setGeometry(&m_geometry);

++         setFlag(OwnsGeometry, false);

++     }

++     updateMaterialAntialiasing();

++     m_dirtyGeometry = true;

++ }

++

++ void QSGBasicInternalImageNode::setMirror(bool mirrorHorizontally, bool mirrorVertically)

++ {

++     if (mirrorHorizontally == m_mirrorHorizontally && mirrorVertically == m_mirrorVertically)

++         return;

++     m_mirrorHorizontally = mirrorHorizontally;

++     m_mirrorVertically = mirrorVertically;

++     m_dirtyGeometry = true;

++ }

++

++

++ void QSGBasicInternalImageNode::update()

++ {

++     if (m_dirtyGeometry)

++         updateGeometry();

++ }

++

++ void QSGBasicInternalImageNode::preprocess()

++ {

++     bool doDirty = false;

++     QSGDynamicTexture *t = qobject_cast<QSGDynamicTexture *>(materialTexture());

++     if (t) {

++         doDirty = t->updateTexture();

++         if (doDirty) {

++             // The geometry may need updating. This is expensive however, so do

++             // it only when something relevant has changed.

++             if (t != m_dynamicTexture

++                     || t->textureSize() != m_dynamicTextureSize

++                     || t->normalizedTextureSubRect() != m_dynamicTextureSubRect) {

++                 updateGeometry();

++                 m_dynamicTextureSize = t->textureSize();

++                 m_dynamicTextureSubRect = t->normalizedTextureSubRect();

++             }

++         }

++     }

++     m_dynamicTexture = t;

++

++     if (updateMaterialBlending())

++         doDirty = true;

++

++     if (doDirty)

++         markDirty(DirtyMaterial);

++ }

++

++ namespace {

++     struct X { float x, tx; };

++     struct Y { float y, ty; };

++ }

++

++ static inline void appendQuad(int indexType, void **indexData,

++                               int topLeft, int topRight,

++                               int bottomLeft, int bottomRight)

++ {

++     if (indexType == QSGGeometry::UnsignedIntType) {

++         quint32 *indices = static_cast<quint32 *>(*indexData);

++         *indices++ = topLeft;

++         *indices++ = bottomLeft;

++         *indices++ = bottomRight;

++         *indices++ = bottomRight;

++         *indices++ = topRight;

++         *indices++ = topLeft;

++         *indexData = indices;

++     } else {

++         Q_ASSERT(indexType == QSGGeometry::UnsignedShortType);

++         quint16 *indices = static_cast<quint16 *>(*indexData);

++         *indices++ = topLeft;

++         *indices++ = bottomLeft;

++         *indices++ = bottomRight;

++         *indices++ = bottomRight;

++         *indices++ = topRight;

++         *indices++ = topLeft;

++         *indexData = indices;

++     }

++ }

++

++ QSGGeometry *QSGBasicInternalImageNode::updateGeometry(const QRectF &targetRect,

++                                                const QRectF &innerTargetRect,

++                                                const QRectF &sourceRect,

++                                                const QRectF &innerSourceRect,

++                                                const QRectF &subSourceRect,

++                                                QSGGeometry *geometry,

++                                                bool mirrorHorizontally,

++                                                bool mirrorVertically,

++                                                bool antialiasing)

++ {

++     int floorLeft = qFloor(subSourceRect.left());

++     int ceilRight = qCeil(subSourceRect.right());

++     int floorTop = qFloor(subSourceRect.top());

++     int ceilBottom = qCeil(subSourceRect.bottom());

++     int hTiles = ceilRight - floorLeft;

++     int vTiles = ceilBottom - floorTop;

++

++     int hCells = hTiles;

++     int vCells = vTiles;

++     if (innerTargetRect.width() == 0)

++         hCells = 0;

++     if (innerTargetRect.left() != targetRect.left())

++         ++hCells;

++     if (innerTargetRect.right() != targetRect.right())

++         ++hCells;

++     if (innerTargetRect.height() == 0)

++         vCells = 0;

++     if (innerTargetRect.top() != targetRect.top())

++         ++vCells;

++     if (innerTargetRect.bottom() != targetRect.bottom())

++         ++vCells;

++

++     QVarLengthArray<X, 32> xData(2 * hCells);

++     QVarLengthArray<Y, 32> yData(2 * vCells);

++     X *xs = xData.data();

++     Y *ys = yData.data();

++

++     if (innerTargetRect.left() != targetRect.left()) {

++         xs[0].x = targetRect.left();

++         xs[0].tx = sourceRect.left();

++         xs[1].x = innerTargetRect.left();

++         xs[1].tx = innerSourceRect.left();

++         xs += 2;

++     }

++     if (innerTargetRect.width() != 0 && hTiles > 0) {

++         xs[0].x = innerTargetRect.left();

++         xs[0].tx = innerSourceRect.x() + (subSourceRect.left() - floorLeft) * innerSourceRect.width();

++         ++xs;

++         float b = innerTargetRect.width() / subSourceRect.width();

++         float a = innerTargetRect.x() - subSourceRect.x() * b;

++         for (int i = floorLeft + 1; i <= ceilRight - 1; ++i) {

++             xs[0].x = xs[1].x = a + b * i;

++             xs[0].tx = innerSourceRect.right();

++             xs[1].tx = innerSourceRect.left();

++             xs += 2;

++         }

++         xs[0].x = innerTargetRect.right();

++         xs[0].tx = innerSourceRect.x() + (subSourceRect.right() - ceilRight + 1) * innerSourceRect.width();

++         ++xs;

++     }

++     if (innerTargetRect.right() != targetRect.right()) {

++         xs[0].x = innerTargetRect.right();

++         xs[0].tx = innerSourceRect.right();

++         xs[1].x = targetRect.right();

++         xs[1].tx = sourceRect.right();

++         xs += 2;

++     }

++     Q_ASSERT(xs == xData.data() + xData.size());

++     if (mirrorHorizontally) {

++         float leftPlusRight = targetRect.left() + targetRect.right();

++         int count = xData.size();

++         xs = xData.data();

++         for (int i = 0; i < (count >> 1); ++i)

++             qSwap(xs[i], xs[count - 1 - i]);

++         for (int i = 0; i < count; ++i)

++             xs[i].x = leftPlusRight - xs[i].x;

++     }

++

++     if (innerTargetRect.top() != targetRect.top()) {

++         ys[0].y = targetRect.top();

++         ys[0].ty = sourceRect.top();

++         ys[1].y = innerTargetRect.top();

++         ys[1].ty = innerSourceRect.top();

++         ys += 2;

++     }

++     if (innerTargetRect.height() != 0 && vTiles > 0) {

++         ys[0].y = innerTargetRect.top();

++         ys[0].ty = innerSourceRect.y() + (subSourceRect.top() - floorTop) * innerSourceRect.height();

++         ++ys;

++         float b = innerTargetRect.height() / subSourceRect.height();

++         float a = innerTargetRect.y() - subSourceRect.y() * b;

++         for (int i = floorTop + 1; i <= ceilBottom - 1; ++i) {

++             ys[0].y = ys[1].y = a + b * i;

++             ys[0].ty = innerSourceRect.bottom();

++             ys[1].ty = innerSourceRect.top();

++             ys += 2;

++         }

++         ys[0].y = innerTargetRect.bottom();

++         ys[0].ty = innerSourceRect.y() + (subSourceRect.bottom() - ceilBottom + 1) * innerSourceRect.height();

++         ++ys;

++     }

++     if (innerTargetRect.bottom() != targetRect.bottom()) {

++         ys[0].y = innerTargetRect.bottom();

++         ys[0].ty = innerSourceRect.bottom();

++         ys[1].y = targetRect.bottom();

++         ys[1].ty = sourceRect.bottom();

++         ys += 2;

++     }

++     Q_ASSERT(ys == yData.data() + yData.size());

++     if (mirrorVertically) {

++         float topPlusBottom = targetRect.top() + targetRect.bottom();

++         int count = yData.size();

++         ys = yData.data();

++         for (int i = 0; i < (count >> 1); ++i)

++             qSwap(ys[i], ys[count - 1 - i]);

++         for (int i = 0; i < count; ++i)

++             ys[i].y = topPlusBottom - ys[i].y;

++     }

++

++     QSGGeometry::Type indexType = QSGGeometry::UnsignedShortType;

++     // We can handled up to 0xffff indices, but keep the limit lower here to

++     // merge better in the batch renderer.

++     if (hCells * vCells * 4 > 0x7fff)

++         indexType = QSGGeometry::UnsignedIntType;

++

++     if (antialiasing) {

++         if (!geometry || geometry->indexType() != indexType) {

++             geometry = new QSGGeometry(smoothImageAttributeSet(),

++                                        hCells * vCells * 4 + (hCells + vCells - 1) * 4,

++                                        hCells * vCells * 6 + (hCells + vCells) * 12,

++                                        indexType);

++         } else {

++             geometry->allocate(hCells * vCells * 4 + (hCells + vCells - 1) * 4,

++                                hCells * vCells * 6 + (hCells + vCells) * 12);

++         }

++         QSGGeometry *g = geometry;

++         Q_ASSERT(g);

++

++         g->setDrawingMode(QSGGeometry::DrawTriangles);

++         auto *vertices = reinterpret_cast<SmoothImageVertex *>(g->vertexData());

++         memset(vertices, 0, g->vertexCount() * g->sizeOfVertex());

++         void *indexData = g->indexData();

++

++         // The deltas are how much the fuzziness can reach into the image.

++         // Only the border vertices are moved by the vertex shader, so the fuzziness

++         // can't reach further into the image than the closest interior vertices.

++         float leftDx = xData.at(1).x - xData.at(0).x;

++         float rightDx = xData.at(xData.size() - 1).x - xData.at(xData.size() - 2).x;

++         float topDy = yData.at(1).y - yData.at(0).y;

++         float bottomDy = yData.at(yData.size() - 1).y - yData.at(yData.size() - 2).y;

++

++         float leftDu = xData.at(1).tx - xData.at(0).tx;

++         float rightDu = xData.at(xData.size() - 1).tx - xData.at(xData.size() - 2).tx;

++         float topDv = yData.at(1).ty - yData.at(0).ty;

++         float bottomDv = yData.at(yData.size() - 1).ty - yData.at(yData.size() - 2).ty;

++

++         if (hCells == 1) {

++             leftDx = rightDx *= 0.5f;

++             leftDu = rightDu *= 0.5f;

++         }

++         if (vCells == 1) {

++             topDy = bottomDy *= 0.5f;

++             topDv = bottomDv *= 0.5f;

++         }

++

++         // This delta is how much the fuzziness can reach out from the image.

++         float delta = float(qAbs(targetRect.width()) < qAbs(targetRect.height())

++                             ? targetRect.width() : targetRect.height()) * 0.5f;

++

++         int index = 0;

++         ys = yData.data();

++         for (int j = 0; j < vCells; ++j, ys += 2) {

++             xs = xData.data();

++             bool isTop = j == 0;

++             bool isBottom = j == vCells - 1;

++             for (int i = 0; i < hCells; ++i, xs += 2) {

++                 bool isLeft = i == 0;

++                 bool isRight = i == hCells - 1;

++

++                 SmoothImageVertex *v = vertices + index;

++

++                 int topLeft = index;

++                 for (int k = (isTop || isLeft ? 2 : 1); k--; ++v, ++index) {

++                     v->x = xs[0].x;

++                     v->u = xs[0].tx;

++                     v->y = ys[0].y;

++                     v->v = ys[0].ty;

++                 }

++

++                 int topRight = index;

++                 for (int k = (isTop || isRight ? 2 : 1); k--; ++v, ++index) {

++                     v->x = xs[1].x;

++                     v->u = xs[1].tx;

++                     v->y = ys[0].y;

++                     v->v = ys[0].ty;

++                 }

++

++                 int bottomLeft = index;

++                 for (int k = (isBottom || isLeft ? 2 : 1); k--; ++v, ++index) {

++                     v->x = xs[0].x;

++                     v->u = xs[0].tx;

++                     v->y = ys[1].y;

++                     v->v = ys[1].ty;

++                 }

++

++                 int bottomRight = index;

++                 for (int k = (isBottom || isRight ? 2 : 1); k--; ++v, ++index) {

++                     v->x = xs[1].x;

++                     v->u = xs[1].tx;

++                     v->y = ys[1].y;

++                     v->v = ys[1].ty;

++                 }

++

++                 appendQuad(g->indexType(), &indexData, topLeft, topRight, bottomLeft, bottomRight);

++

++                 if (isTop) {

++                     vertices[topLeft].dy = vertices[topRight].dy = topDy;

++                     vertices[topLeft].dv = vertices[topRight].dv = topDv;

++                     vertices[topLeft + 1].dy = vertices[topRight + 1].dy = -delta;

++                     appendQuad(g->indexType(), &indexData, topLeft + 1, topRight + 1, topLeft, topRight);

++                 }

++

++                 if (isBottom) {

++                     vertices[bottomLeft].dy = vertices[bottomRight].dy = -bottomDy;

++                     vertices[bottomLeft].dv = vertices[bottomRight].dv = -bottomDv;

++                     vertices[bottomLeft + 1].dy = vertices[bottomRight + 1].dy = delta;

++                     appendQuad(g->indexType(), &indexData, bottomLeft, bottomRight, bottomLeft + 1, bottomRight + 1);

++                 }

++

++                 if (isLeft) {

++                     vertices[topLeft].dx = vertices[bottomLeft].dx = leftDx;

++                     vertices[topLeft].du = vertices[bottomLeft].du = leftDu;

++                     vertices[topLeft + 1].dx = vertices[bottomLeft + 1].dx = -delta;

++                     appendQuad(g->indexType(), &indexData, topLeft + 1, topLeft, bottomLeft + 1, bottomLeft);

++                 }

++

++                 if (isRight) {

++                     vertices[topRight].dx = vertices[bottomRight].dx = -rightDx;

++                     vertices[topRight].du = vertices[bottomRight].du = -rightDu;

++                     vertices[topRight + 1].dx = vertices[bottomRight + 1].dx = delta;

++                     appendQuad(g->indexType(), &indexData, topRight, topRight + 1, bottomRight, bottomRight + 1);

++                 }

++             }

++         }

++

++         Q_ASSERT(index == g->vertexCount());

++     } else {

++         if (!geometry || geometry->indexType() != indexType) {

++             geometry = new QSGGeometry(QSGGeometry::defaultAttributes_TexturedPoint2D(),

++                                        hCells * vCells * 4, hCells * vCells * 6,

++                                        indexType);

++         } else {

++             geometry->allocate(hCells * vCells * 4, hCells * vCells * 6);

++         }

++         geometry->setDrawingMode(QSGGeometry::DrawTriangles);

++         QSGGeometry::TexturedPoint2D *vertices = geometry->vertexDataAsTexturedPoint2D();

++         ys = yData.data();

++         for (int j = 0; j < vCells; ++j, ys += 2) {

++             xs = xData.data();

++             for (int i = 0; i < hCells; ++i, xs += 2) {

++                 vertices[0].x = vertices[2].x = xs[0].x;

++                 vertices[0].tx = vertices[2].tx = xs[0].tx;

++                 vertices[1].x = vertices[3].x = xs[1].x;

++                 vertices[1].tx = vertices[3].tx = xs[1].tx;

++

++                 vertices[0].y = vertices[1].y = ys[0].y;

++                 vertices[0].ty = vertices[1].ty = ys[0].ty;

++                 vertices[2].y = vertices[3].y = ys[1].y;

++                 vertices[2].ty = vertices[3].ty = ys[1].ty;

++

++                 vertices += 4;

++             }

++         }

++         void *indexData = geometry->indexData();

++         for (int i = 0; i < 4 * vCells * hCells; i += 4)

++             appendQuad(geometry->indexType(), &indexData, i, i + 1, i + 2, i + 3);

++     }

++     return geometry;

++ }

++

++ void QSGBasicInternalImageNode::updateGeometry()

++ {

++     Q_ASSERT(!m_targetRect.isEmpty());

++     const QSGTexture *t = materialTexture();

++     if (!t) {

++         QSGGeometry *g = geometry();

++         g->allocate(4);

++         g->setDrawingMode(QSGGeometry::DrawTriangleStrip);

++         memset(g->vertexData(), 0, g->sizeOfVertex() * 4);

++     } else {

++         QRectF sourceRect = t->normalizedTextureSubRect();

++

++         QRectF innerSourceRect(sourceRect.x() + m_innerSourceRect.x() * sourceRect.width(),

++                                sourceRect.y() + m_innerSourceRect.y() * sourceRect.height(),

++                                m_innerSourceRect.width() * sourceRect.width(),

++                                m_innerSourceRect.height() * sourceRect.height());

++

++         bool hasMargins = m_targetRect != m_innerTargetRect;

++

++         int floorLeft = qFloor(m_subSourceRect.left());

++         int ceilRight = qCeil(m_subSourceRect.right());

++         int floorTop = qFloor(m_subSourceRect.top());

++         int ceilBottom = qCeil(m_subSourceRect.bottom());

++         int hTiles = ceilRight - floorLeft;

++         int vTiles = ceilBottom - floorTop;

++

++         bool hasTiles = hTiles > 1 || vTiles > 1;

++         bool fullTexture = innerSourceRect == QRectF(0, 0, 1, 1);

++

++         // An image can be rendered as a single quad if:

++         // - There are no margins, and either:

++         //   - the image isn't repeated

++         //   - the source rectangle fills the entire texture so that texture wrapping can be used,

++         //     and NPOT is supported

++         if (!hasMargins && (!hasTiles || (fullTexture && supportsWrap(t->textureSize())))) {

++             QRectF sr;

++             if (!fullTexture) {

++                 sr = QRectF(innerSourceRect.x() + (m_subSourceRect.left() - floorLeft) * innerSourceRect.width(),

++                             innerSourceRect.y() + (m_subSourceRect.top() - floorTop) * innerSourceRect.height(),

++                             m_subSourceRect.width() * innerSourceRect.width(),

++                             m_subSourceRect.height() * innerSourceRect.height());

++             } else {

++                 sr = QRectF(m_subSourceRect.left() - floorLeft, m_subSourceRect.top() - floorTop,

++                             m_subSourceRect.width(), m_subSourceRect.height());

++             }

++             if (m_mirrorHorizontally) {

++                 qreal oldLeft = sr.left();

++                 sr.setLeft(sr.right());

++                 sr.setRight(oldLeft);

++             }

++             if (m_mirrorVertically) {

++                 qreal oldTop = sr.top();

++                 sr.setTop(sr.bottom());

++                 sr.setBottom(oldTop);

++             }

++

++             if (m_antialiasing) {

++                 QSGGeometry *g = geometry();

++                 Q_ASSERT(g != &m_geometry);

++                 if (g->indexType() != QSGGeometry::UnsignedShortType) {

++                     setGeometry(new QSGGeometry(smoothImageAttributeSet(), 0));

++                     g = geometry();

++                 }

++                 g->allocate(8, 14);

++                 g->setDrawingMode(QSGGeometry::DrawTriangleStrip);

++                 auto *vertices = reinterpret_cast<SmoothImageVertex *>(g->vertexData());

++                 float delta = float(qAbs(m_targetRect.width()) < qAbs(m_targetRect.height())

++                         ? m_targetRect.width() : m_targetRect.height()) * 0.5f;

++                 float sx = float(sr.width() / m_targetRect.width());

++                 float sy = float(sr.height() / m_targetRect.height());

++                 for (int d = -1; d <= 1; d += 2) {

++                     for (int j = 0; j < 2; ++j) {

++                         for (int i = 0; i < 2; ++i, ++vertices) {

++                             vertices->x = m_targetRect.x() + i * m_targetRect.width();

++                             vertices->y = m_targetRect.y() + j * m_targetRect.height();

++                             vertices->u = sr.x() + i * sr.width();

++                             vertices->v = sr.y() + j * sr.height();

++                             vertices->dx = (i == 0 ? delta : -delta) * d;

++                             vertices->dy = (j == 0 ? delta : -delta) * d;

++                             vertices->du = (d < 0 ? 0 : vertices->dx * sx);

++                             vertices->dv = (d < 0 ? 0 : vertices->dy * sy);

++                         }

++                     }

++                 }

++                 Q_ASSERT(vertices - g->vertexCount() == g->vertexData());

++                 static const quint16 indices[] = {

++                     0, 4, 1, 5, 3, 7, 2, 6, 0, 4,

++                     4, 6, 5, 7

++                 };

++                 Q_ASSERT(g->sizeOfIndex() * g->indexCount() == sizeof(indices));

++                 memcpy(g->indexDataAsUShort(), indices, sizeof(indices));

++             } else {

++                 m_geometry.allocate(4);

++                 m_geometry.setDrawingMode(QSGGeometry::DrawTriangleStrip);

++                 QSGGeometry::updateTexturedRectGeometry(&m_geometry, m_targetRect, sr);

++             }

++         } else {

++             QSGGeometry *g = geometry();

++             g = updateGeometry(m_targetRect, m_innerTargetRect,

++                                sourceRect, innerSourceRect, m_subSourceRect,

++                                g, m_mirrorHorizontally, m_mirrorVertically, m_antialiasing);

++             if (g != geometry()) {

++                 setGeometry(g);

++                 setFlag(OwnsGeometry, true);

++             }

++         }

++     }

++     markDirty(DirtyGeometry);

++     m_dirtyGeometry = false;

++ }

++

++ QT_END_NAMESPACE

Revision control