fix(graphic): render toPixmap/toImage into a QRectF

QwtGraphic.toPixmap(size), QwtGraphic.toImage() and QwtGraphic.toImage(size)
raised a TypeError instead of rendering the graphic, and could abort the
process because the painter was still active when the pixmap or image was
destroyed.

The Qwt C++ code passes a QRect to render(), which is implicitly converted
to a QRectF. The Python port passed the QRect as is, which render() rejects,
and QRect(0, 0, width, height) also fails when the size is a QSizeF.
toImage(size) did not end its painter either.

- Build a QRectF, like toPixmap() already does, and end the painter in
  toImage(size).
- Regression tests: default size, given size and kept aspect ratio, for
  both toPixmap and toImage.
- Changelog entry.

Refs #115

Assisted-by: Claude Opus 5.5

Author: PierreRaybaut

CHANGELOG.md

@@ -9,6 +9,7 @@
 ### Bug fixes
 
 - Fixed [Issue #113](https://github.com/PlotPyStack/PythonQwt/issues/113): after replacing the scale draw of an axis (`QwtPlot.setAxisScaleDraw`), the axis ticks could be misaligned with the grid lines and plot items, until the next scale division change (e.g. after panning or zooming): a replot did not fix it. The new scale draw was laid out before getting the position and length of the previous one, so that the axis reserved space for its end labels that the canvas did not take into account. The new scale draw now takes the geometry of the previous one, and the axis stays aligned with the canvas
+- Fixed `QwtGraphic.toPixmap(size)`, `QwtGraphic.toImage()` and `QwtGraphic.toImage(size)`, which raised a `TypeError` (possibly aborting the process, as the painter was still active on the destroyed pixmap or image) instead of rendering the graphic: they now render it like `QwtGraphic.toPixmap()` ([Issue #115](https://github.com/PlotPyStack/PythonQwt/issues/115))
 
 ## Version 0.16.3
 

qwt/graphic.py

@@ -15,7 +15,7 @@
 
 import math
 
-from qtpy.QtCore import QObject, QPointF, QRect, QRectF, QSize, QSizeF, Qt
+from qtpy.QtCore import QObject, QPointF, QRectF, QSize, QSizeF, Qt
 from qtpy.QtGui import (
     QImage,
     QPaintEngine,
@@ -603,7 +603,7 @@ def toPixmap(self, *args):
                 aspectRatioMode = args[-1]
             pixmap = QPixmap(size)
             pixmap.fill(Qt.transparent)
-            r = QRect(0, 0, size.width(), size.height())
+            r = QRectF(0.0, 0.0, size.width(), size.height())
             painter = QPainter(pixmap)
             self.render(painter, r, aspectRatioMode)
             painter.end()
@@ -652,7 +652,7 @@ def toImage(self, *args):
             h = math.ceil(sz.height())
             image = QImage(w, h, QImage.Format_ARGB32)
             image.fill(0)
-            r = QRect(0, 0, sz.width(), sz.height())
+            r = QRectF(0.0, 0.0, sz.width(), sz.height())
             painter = QPainter(image)
             self.render(painter, r, Qt.KeepAspectRatio)
             painter.end()
@@ -664,9 +664,10 @@ def toImage(self, *args):
                 aspectRatioMode = args[-1]
             image = QImage(size, QImage.Format_ARGB32_Premultiplied)
             image.fill(0)
-            r = QRect(0, 0, size.width(), size.height())
+            r = QRectF(0.0, 0.0, size.width(), size.height())
             painter = QPainter(image)
             self.render(painter, r, aspectRatioMode)
+            painter.end()
             return image
 
     def drawPath(self, path):

qwt/tests/test_issue115_porting_bugs.py

@@ -0,0 +1,105 @@
+# -*- coding: utf-8 -*-
+#
+# Licensed under the terms of the Qwt License
+# (see LICENSE file for more details)
+
+"""
+Tests for issue 115: porting bugs making several rarely used APIs fail.
+
+Each test covers a difference between the Python port and the Qwt C++ code,
+which made the API raise an exception or ignore some of its arguments.
+"""
+
+import pytest
+from qtpy import QtCore as QC
+from qtpy import QtGui as QG
+from qtpy import QtWidgets as QW
+
+from qwt.graphic import QwtGraphic
+
+RED = QG.QColor(QC.Qt.red)
+
+
+def _ensure_app():
+    # A live QApplication must exist before constructing any QWidget or
+    # QPixmap, otherwise Qt aborts the process. Tests run in a shared
+    # interpreter, but no test keeps a persistent Python reference to the
+    # application, so the singleton may be garbage-collected between tests.
+    return QW.QApplication.instance() or QW.QApplication([])
+
+
+# ---------------------------------------------------------------------------
+# QwtGraphic.toPixmap / QwtGraphic.toImage
+# ---------------------------------------------------------------------------
+
+
+def _make_graphic():
+    """Return a graphic made of a red rectangle of 20 x 10 points"""
+    graphic = QwtGraphic()
+    path = QG.QPainterPath()
+    path.addRect(QC.QRectF(0.0, 0.0, 20.0, 10.0))
+    painter = QG.QPainter(graphic)
+    painter.setPen(QC.Qt.NoPen)
+    painter.setBrush(RED)
+    painter.drawPath(path)
+    painter.end()
+    return graphic
+
+
+def _to_qimage(result):
+    """Return result as a QImage (result: QPixmap or QImage)"""
+    if isinstance(result, QG.QPixmap):
+        return result.toImage()
+    return result
+
+
+def _is_red(image, x, y):
+    color = image.pixelColor(x, y)
+    return color.alpha() == 255 and color.rgb() == RED.rgb()
+
+
+@pytest.mark.parametrize("method", ("toPixmap", "toImage"))
+def test_graphic_conversion_default_size(method):
+    """toPixmap() and toImage() render the graphic in its default size"""
+    app = _ensure_app()  # keep a reference alive for the duration of the test
+    result = getattr(_make_graphic(), method)()
+    assert not result.isNull()
+    assert result.size() == QC.QSize(20, 10)
+    assert _is_red(_to_qimage(result), 10, 5)
+    del app
+
+
+@pytest.mark.parametrize("method", ("toPixmap", "toImage"))
+def test_graphic_conversion_given_size(method):
+    """toPixmap(size) and toImage(size) scale the graphic to the given size"""
+    app = _ensure_app()  # keep a reference alive for the duration of the test
+    result = getattr(_make_graphic(), method)(QC.QSize(40, 20))
+    assert not result.isNull()
+    assert result.size() == QC.QSize(40, 20)
+    image = _to_qimage(result)
+    assert _is_red(image, 20, 10)
+    assert _is_red(image, 2, 2)
+    assert _is_red(image, 37, 17)
+    del app
+
+
+@pytest.mark.parametrize("method", ("toPixmap", "toImage"))
+def test_graphic_conversion_keep_aspect_ratio(method):
+    """toPixmap(size, mode) and toImage(size, mode) honor the aspect ratio"""
+    app = _ensure_app()  # keep a reference alive for the duration of the test
+    result = getattr(_make_graphic(), method)(QC.QSize(40, 40), QC.Qt.KeepAspectRatio)
+    assert result.size() == QC.QSize(40, 40)
+    image = _to_qimage(result)
+    # The 2:1 graphic is scaled to 40 x 20 and centered vertically
+    assert _is_red(image, 20, 20)
+    assert image.pixelColor(20, 2).alpha() == 0
+    assert image.pixelColor(20, 37).alpha() == 0
+    del app
+
+
+if __name__ == "__main__":
+    for name in ("toPixmap", "toImage"):
+        test_graphic_conversion_default_size(name)
+        test_graphic_conversion_given_size(name)
+        test_graphic_conversion_keep_aspect_ratio(name)
+    print("OK")