Introduce QQuickPaintedItem::textureSize and support HighDpi.

contentsSize/Scale/BoundingRect are confusing and will in
most cases not produce what the user wants, but since
they might be in use, we keep their behavior and simply
obsolete them. New code should use textureSize, though most
code can simply rely on implicit HighDpi support.

[ChangeLog][QtQuick][QQuickPaintedItem] Implement high-dpi
support and add function textureSize. This obsoletes the
existing contentsSize, contentsScale and contentsBoundingRect
functions.

Task-number: QTBUG-32510
Task-number: QTBUG-40489
Change-Id: I660bbf394594b6ea588d4de9cc83c8c5eb28cb28
Reviewed-by: Yoann Lopes <yoann.lopes@theqtcompany.com>

1 files changed, 80 insertions, 26 deletions

diff --git a/src/quick/items/qquickpainteditem.cpp b/src/quick/items/qquickpainteditem.cpp
index 033000c159..4172b83419 100644
--- a/src/quick/items/qquickpainteditem.cpp
+++ b/src/quick/items/qquickpainteditem.cpp
@@ -67,15 +67,11 @@ public:
 
     To enable QPainter to do anti-aliased rendering, use setAntialiasing().
 
-    To write your own painted item, you first create a subclass of QQuickPaintedItem, and then
-    start by implementing its only pure virtual public function: paint(), which implements
-    the actual painting. To get the size of the area painted by the item, use
-    contentsBoundingRect().
-
-    Starting Qt 5.4, the QQuickPaintedItem is a
-    \l{QSGTextureProvider}{texture provider}
-    and can be used directly in \l {ShaderEffect}{ShaderEffects} and other
-    classes that consume texture providers.
+    To write your own painted item, you first create a subclass of
+    QQuickPaintedItem, and then start by implementing its only pure virtual
+    public function: paint(), which implements the actual painting. The
+    painting will be inside the rectangle spanning from 0,0 to
+    width(),height().
 */
 
 /*!
@@ -333,16 +329,47 @@ void QQuickPaintedItem::setPerformanceHints(QQuickPaintedItem::PerformanceHints
     update();
 }
 
+QSize QQuickPaintedItem::textureSize() const
+{
+    Q_D(const QQuickPaintedItem);
+    return d->textureSize;
+}
+
 /*!
-    This function returns the outer bounds of the item as a rectangle; all painting must be
-    restricted to inside an item's bounding rect.
+    \property QQuickPaintedItem::textureSize
+
+    \brief Defines the size of the texture.
+
+    Changing the texture's size does not affect the coordinate system used in
+    paint(). A scale factor is instead applied so painting should still happen
+    inside 0,0 to width(),height().
+
+    By default, the texture size will have the same size as this item.
+
+    \note If the item is on a window with a device pixel ratio different from
+    1, this scale factor will be implicitly applied to the texture size.
+
+ */
+void QQuickPaintedItem::setTextureSize(const QSize &size)
+{
+    Q_D(QQuickPaintedItem);
+    if (d->textureSize == size)
+        return;
+    d->textureSize = size;
+    emit textureSizeChanged();
+}
+
+#if QT_VERSION >= 0x060000
+#warning "Remove: QQuickPaintedItem::contentsBoundingRect, contentsScale, contentsSize. Also remove them from qsgadaptationlayer_p.h and qsgdefaultpainternode.h/cpp."
+#endif
 
-    If the contents size has not been set it reflects the size of the item; otherwise
-    it reflects the contents size scaled by the contents scale.
+/*!
+    \obsolete
 
-    Use this function to know the area painted by the item.
+    This function is provided for compatibility, use size in combination
+    with textureSize to decide the size of what you are drawing.
 
-    \sa QQuickItem::width(), QQuickItem::height(), contentsSize(), contentsScale()
+    \sa width(), height(), textureSize()
 */
 QRectF QQuickPaintedItem::contentsBoundingRect() const
 {
@@ -361,11 +388,13 @@ QRectF QQuickPaintedItem::contentsBoundingRect() const
 
 /*!
     \property QQuickPaintedItem::contentsSize
-    \brief The size of the contents
+    \brief Obsolete method for setting the contents size.
+    \obsolete
+
+    This function is provided for compatibility, use size in combination
+    with textureSize to decide the size of what you are drawing.
 
-    The contents size is the size of the item in regards to how it is painted
-    using the paint() function.  This is distinct from the size of the
-    item in regards to height() and width().
+    \sa width(), height(), textureSize()
 */
 QSize QQuickPaintedItem::contentsSize() const
 {
@@ -387,6 +416,7 @@ void QQuickPaintedItem::setContentsSize(const QSize &size)
 }
 
 /*!
+    \obsolete
     This convenience function is equivalent to calling setContentsSize(QSize()).
 */
 void QQuickPaintedItem::resetContentsSize()
@@ -396,12 +426,13 @@ void QQuickPaintedItem::resetContentsSize()
 
 /*!
     \property QQuickPaintedItem::contentsScale
-    \brief The scale of the contents
+    \brief Obsolete method for scaling the contents.
+    \obsolete
 
-    All painting happening in paint() is scaled by the contents scale. This is distinct
-    from the scale of the item in regards to scale().
+    This function is provided for compatibility, use size() in combination
+    with textureSize() to decide the size of what you are drawing.
 
-    The default value is 1.
+    \sa width(), height(), textureSize()
 */
 qreal QQuickPaintedItem::contentsScale() const
 {
@@ -488,6 +519,9 @@ void QQuickPaintedItem::setRenderTarget(RenderTarget target)
     This function, which is usually called by the QML Scene Graph, paints the
     contents of an item in local coordinates.
 
+    The underlying texture will have a size defined by textureSize when set,
+    or the item's size, multiplied by the window's device pixel ratio.
+
     The function is called after the item has been filled with the fillColor.
 
     Reimplement this function in a QQuickPaintedItem subclass to provide the
@@ -501,6 +535,8 @@ void QQuickPaintedItem::setRenderTarget(RenderTarget target)
 
     \warning Extreme caution must be used when creating QObjects, emitting signals, starting
     timers and similar inside this function as these will have affinity to the rendering thread.
+
+    \sa width(), height(), textureSize
 */
 
 /*!
@@ -526,17 +562,35 @@ QSGNode *QQuickPaintedItem::updatePaintNode(QSGNode *oldNode, UpdatePaintNodeDat
         d->node = node;
     }
 
-    QRectF br = contentsBoundingRect();
+    bool hasTextureSize = d->textureSize.width() > 0 && d->textureSize.height() > 0;
+
+    // Use the compat mode if any of the compat things are set and
+    // textureSize is 0x0.
+    if (!hasTextureSize
+        && (d->contentsScale != 1
+            || (d->contentsSize.width() > 0 && d->contentsSize.height() > 0))) {
+        QRectF br = contentsBoundingRect();
+        node->setContentsScale(d->contentsScale);
+        QSize size = QSize(qRound(br.width()), qRound(br.height()));
+        node->setSize(size);
+        node->setTextureSize(size);
+    } else {
+        // The default, use textureSize or item's size * device pixel ratio
+        node->setContentsScale(1);
+        QSize itemSize(qRound(width()), qRound(height()));
+        node->setSize(itemSize);
+        QSize textureSize = (hasTextureSize ? d->textureSize : itemSize)
+                            * window()->effectiveDevicePixelRatio();
+        node->setTextureSize(textureSize);
+    }
 
     node->setPreferredRenderTarget(d->renderTarget);
     node->setFastFBOResizing(d->performanceHints & FastFBOResizing);
-    node->setSize(QSize(qRound(br.width()), qRound(br.height())));
     node->setSmoothPainting(d->antialiasing);
     node->setLinearFiltering(d->smooth);
     node->setMipmapping(d->mipmap);
     node->setOpaquePainting(d->opaquePainting);
     node->setFillColor(d->fillColor);
-    node->setContentsScale(d->contentsScale);
     node->setDirty(d->dirtyRect);
     node->update();