PythonQwt 0.16.1__tar.gz → 0.16.3__tar.gz

{pythonqwt-0.16.1/PythonQwt.egg-info → pythonqwt-0.16.3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: PythonQwt
-Version: 0.16.1
+Version: 0.16.3
 Summary: Qt plotting widgets for Python
 Author-email: Pierre Raybaut <pierre.raybaut@gmail.com>
 License: PythonQwt License Agreement

{pythonqwt-0.16.1 → pythonqwt-0.16.3/PythonQwt.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: PythonQwt
-Version: 0.16.1
+Version: 0.16.3
 Summary: Qt plotting widgets for Python
 Author-email: Pierre Raybaut <pierre.raybaut@gmail.com>
 License: PythonQwt License Agreement

{pythonqwt-0.16.1 → pythonqwt-0.16.3}/PythonQwt.egg-info/SOURCES.txt

@@ -44,6 +44,7 @@ doc/reference/plot.rst
 doc/reference/plot_directpainter.rst
 doc/reference/plot_layout.rst
 doc/reference/plot_series.rst
+doc/reference/qtdesigner.rst
 doc/reference/scale.rst
 doc/reference/symbol.rst
 doc/reference/text.rst
@@ -69,6 +70,7 @@ qwt/plot_layout.py
 qwt/plot_marker.py
 qwt/plot_renderer.py
 qwt/plot_series.py
+qwt/qtdesigner.py
 qwt/qthelpers.py
 qwt/scale_div.py
 qwt/scale_draw.py
@@ -95,10 +97,16 @@ qwt/tests/test_errorbar.py
 qwt/tests/test_eventfilter.py
 qwt/tests/test_highdpi.py
 qwt/tests/test_image.py
+qwt/tests/test_issue107_gdi_leak.py
+qwt/tests/test_issue109_backingstore.py
+qwt/tests/test_issue33_sidebyside.py
+qwt/tests/test_issue88_mousetracking.py
 qwt/tests/test_loadtest.py
 qwt/tests/test_logcurve.py
 qwt/tests/test_mapdemo.py
 qwt/tests/test_multidemo.py
+qwt/tests/test_qtdesigner.py
+qwt/tests/test_qtdesigner.ui
 qwt/tests/test_relativemargin.py
 qwt/tests/test_simple.py
 qwt/tests/test_stylesheet.py

{pythonqwt-0.16.1 → pythonqwt-0.16.3}/doc/reference/index.rst

@@ -5,18 +5,19 @@ Public API:
 
 .. toctree::
     :maxdepth: 2
-    
+
     plot
     scale
     symbol
     text
     toqimage
+    qtdesigner
 
 Private API:
 
 .. toctree::
     :maxdepth: 2
-    
+
     graphic
     interval
     plot_directpainter

pythonqwt-0.16.3/doc/reference/qtdesigner.rst

@@ -0,0 +1,50 @@
+Qt Designer
+===========
+
+PythonQwt ships a Qt Designer plugin which makes a 2D plotting widget
+(:class:`qwt.qtdesigner.QwtPlotWidget`, a thin :class:`qwt.QwtPlot` subclass)
+available directly inside Qt Designer's widget box, in the "PythonQwt" group.
+
+Installing the plugin
+---------------------
+
+The plugin file ``qwtplugin.py`` lives in the ``qtdesigner`` directory at the
+root of the PythonQwt source tree. To make it available in Qt Designer, add
+that directory to the ``PYQTDESIGNERPATH`` environment variable before
+starting Qt Designer:
+
+.. code-block:: bash
+
+    # Linux/macOS
+    export PYQTDESIGNERPATH=<path to PythonQwt>/qtdesigner
+    designer
+
+.. code-block:: bat
+
+    rem Windows
+    set PYQTDESIGNERPATH=<path to PythonQwt>\qtdesigner
+    designer
+
+.. note::
+
+    Qt Designer custom widget plugins require PyQt5 or PyQt6. PySide6 does not
+    expose ``QPyDesignerCustomWidgetPlugin``.
+
+Loading a ``.ui`` file at runtime
+---------------------------------
+
+The :mod:`qwt.qtdesigner` module provides helper functions to load or compile
+``.ui`` files embedding :class:`qwt.qtdesigner.QwtPlotWidget` widgets:
+
+.. code-block:: python
+
+    from qwt.qtdesigner import loadui
+
+    FormClass = loadui("myform.ui")
+    form = FormClass()
+    form.plotwidget.setTitle("Loaded from Qt Designer")
+
+Reference
+---------
+
+.. automodule:: qwt.qtdesigner

{pythonqwt-0.16.1 → pythonqwt-0.16.3}/pyproject.toml

@@ -50,7 +50,7 @@ test = ["pytest", "pytest-xvfb"]
 include = ["qwt*"]
 
 [tool.setuptools.package-data]
-"*" = ["*.png", "*.svg", "*.mo", "*.cfg", "*.toml"]
+"*" = ["*.png", "*.svg", "*.mo", "*.cfg", "*.toml", "*.ui"]
 
 [tool.setuptools.dynamic]
 version = { attr = "qwt.__version__" }

{pythonqwt-0.16.1 → pythonqwt-0.16.3}/qwt/__init__.py

@@ -63,7 +63,7 @@ from qwt.symbol import QwtSymbol as QSbl  # see deprecated section
 from qwt.text import QwtText  # noqa: F401
 from qwt.toqimage import array_to_qimage as toQImage  # noqa: F401
 
-__version__ = "0.16.1"
+__version__ = "0.16.3"
 QWT_VERSION_STR = "6.1.5"
 
 

{pythonqwt-0.16.1 → pythonqwt-0.16.3}/qwt/null_paintdevice.py

@@ -275,7 +275,7 @@ class QwtNullPaintDevice(QPaintDevice):
         elif deviceMetric == QPaintDevice.PdmDevicePixelRatio:
             value = 1
         elif deviceMetric == QPaintDevice.PdmDevicePixelRatioScaled:
-            value = 1
+            value = 0x10000
         else:
             value = super(QwtNullPaintDevice, self).metric(deviceMetric)
         return value

{pythonqwt-0.16.1 → pythonqwt-0.16.3}/qwt/plot.py

@@ -20,6 +20,7 @@ QwtPlotItem
 """
 
 import math
+import weakref
 
 import numpy as np
 from qtpy.QtCore import QEvent, QObject, QRectF, QSize, Qt, Signal
@@ -996,9 +997,30 @@ class QwtPlot(QFrame):
         if canvas is not None:
             canvas.setParent(self)
             canvas.installEventFilter(self)
+            # Mouse move events occur over the canvas widget, not the plot frame
+            # itself, so the canvas must share the plot's mouse-tracking state
+            # for `QwtPlot.setMouseTracking` to behave as expected.
+            canvas.setMouseTracking(self.hasMouseTracking())
             if self.isVisible():
                 canvas.show()
 
+    def setMouseTracking(self, enable):
+        """
+        Enable or disable mouse tracking for the plot.
+
+        The plot's drawing area is occupied by the canvas widget, so mouse move
+        events over the plot are received by the canvas rather than the plot
+        itself. This override propagates the mouse-tracking state to the canvas
+        so that enabling tracking on the plot delivers mouse move events even
+        when no mouse button is pressed (see Issue #88).
+
+        :param bool enable: True to enable mouse tracking, False to disable it
+        """
+        super(QwtPlot, self).setMouseTracking(enable)
+        canvas = self.__data.canvas
+        if canvas is not None:
+            canvas.setMouseTracking(enable)
+
     def event(self, event):
         if event.type() == QEvent.LayoutRequest:
             self.updateLayout()
@@ -1007,7 +1029,12 @@ class QwtPlot(QFrame):
         return QFrame.event(self, event)
 
     def eventFilter(self, obj, event):
-        if obj is self.__data.canvas:
+        try:
+            canvas = self.__data.canvas
+        except AttributeError:
+            # The plot is being destroyed: Python attributes already cleared
+            return QFrame.eventFilter(self, obj, event)
+        if obj is canvas:
             if event.type() == QEvent.Resize:
                 self.updateCanvasMargins()
             elif event.type() == 178:  # QEvent.ContentsRectChange:
@@ -1195,7 +1222,12 @@ class QwtPlot(QFrame):
         """
         :return: Return a minimum size hint
         """
-        hint = self.__data.layout.minimumSizeHint(self)
+        try:
+            layout = self.__data.layout
+        except AttributeError:
+            # The plot is being destroyed: Python attributes already cleared
+            return QSize()
+        hint = layout.minimumSizeHint(self)
         hint += QSize(2 * self.frameWidth(), 2 * self.frameWidth())
         return hint
 
@@ -1815,16 +1847,23 @@ class QwtPlotItem(object):
 
             :py:meth:`detach()`
         """
-        if plot is self.__data.plot:
+        if plot is self.plot():
             return
 
-        if self.__data.plot:
-            self.__data.plot.attachItem(self, False)
+        current = self.plot()
+        if current is not None:
+            current.attachItem(self, False)
 
-        self.__data.plot = plot
+        # Store the parent plot as a WEAK reference: an item must not keep its
+        # plot (and the plot's GDI-backed child widgets) alive. A strong
+        # back-reference here forms a ``plot <-> item`` reference cycle that can
+        # only be reclaimed by the cyclic garbage collector, which delays the
+        # release of native GDI handles and can lead to GDI-handle exhaustion
+        # on Windows when many plots are created and destroyed.
+        self.__data.plot = None if plot is None else weakref.ref(plot)
 
-        if self.__data.plot:
-            self.__data.plot.attachItem(self, True)
+        if plot is not None:
+            plot.attachItem(self, True)
 
     def detach(self):
         """
@@ -1854,7 +1893,8 @@ class QwtPlotItem(object):
         """
         :return: attached plot
         """
-        return self.__data.plot
+        ref = self.__data.plot
+        return None if ref is None else ref()
 
     def z(self):
         """
@@ -1881,11 +1921,12 @@ class QwtPlotItem(object):
             :py:meth:`z()`, :py:meth:`QwtPlotDict.itemList()`
         """
         if self.__data.z != z:
-            if self.__data.plot:
-                self.__data.plot.attachItem(self, False)
+            plot = self.plot()
+            if plot is not None:
+                plot.attachItem(self, False)
             self.__data.z = z
-            if self.__data.plot:
-                self.__data.plot.attachItem(self, True)
+            if plot is not None:
+                plot.attachItem(self, True)
             self.itemChanged()
 
     def setTitle(self, title):
@@ -2091,8 +2132,9 @@ class QwtPlotItem(object):
 
             :py:meth:`QwtPlot.legendChanged()`, :py:meth:`QwtPlot.autoRefresh()`
         """
-        if self.__data.plot:
-            self.__data.plot.autoRefresh()
+        plot = self.plot()
+        if plot is not None:
+            plot.autoRefresh()
 
     def legendChanged(self):
         """
@@ -2102,8 +2144,9 @@ class QwtPlotItem(object):
 
             :py:meth:`QwtPlot.updateLegend()`, :py:meth:`itemChanged()`
         """
-        if self.testItemAttribute(QwtPlotItem.Legend) and self.__data.plot:
-            self.__data.plot.updateLegend(self)
+        plot = self.plot()
+        if self.testItemAttribute(QwtPlotItem.Legend) and plot is not None:
+            plot.updateLegend(self)
 
     def setAxes(self, xAxis, yAxis):
         """

{pythonqwt-0.16.1 → pythonqwt-0.16.3}/qwt/plot_canvas.py

@@ -13,6 +13,7 @@ QwtPlotCanvas
    :members:
 """
 
+import weakref
 from collections.abc import Sequence
 
 from qtpy.QtCore import QEvent, QObject, QPoint, QPointF, QRect, QRectF, QSize, Qt
@@ -442,7 +443,12 @@ class QwtPlotCanvas(QFrame):
 
     def __init__(self, plot=None):
         super(QwtPlotCanvas, self).__init__(plot)
-        self.__plot = plot
+        # Store the parent plot as a WEAK reference to avoid a
+        # ``plot <-> canvas`` reference cycle (the plot already owns the canvas
+        # through Qt's parent/child relationship). A strong back-reference here
+        # would keep the plot alive until the cyclic garbage collector runs,
+        # delaying the release of native GDI handles on Windows.
+        self.__plot = None if plot is None else weakref.ref(plot)
         self.setFrameStyle(QFrame.Panel | QFrame.Sunken)
         self.setLineWidth(2)
         self.__data = QwtPlotCanvas_PrivateData()
@@ -456,7 +462,8 @@ class QwtPlotCanvas(QFrame):
         """
         :return: Parent plot widget
         """
-        return self.__plot
+        ref = self.__plot
+        return None if ref is None else ref()
 
     def setPaintAttribute(self, attribute, on=True):
         """
@@ -584,7 +591,6 @@ class QwtPlotCanvas(QFrame):
         if (
             self.testPaintAttribute(self.BackingStore)
             and self.__data.backingStore is not None
-            and not self.__data.backingStore.isNull()
         ):
             bs = self.__data.backingStore
             pixelRatio = bs.devicePixelRatio()
@@ -608,6 +614,10 @@ class QwtPlotCanvas(QFrame):
                     if self.frameWidth() > 0:
                         self.drawBorder(p)
                     p.end()
+                # Store the regenerated pixmap back: the C++ original uses a
+                # reference into the stored pixmap, whereas the rebinding above
+                # only updates the local variable.
+                self.__data.backingStore = bs
             painter.drawPixmap(0, 0, self.__data.backingStore)
         else:
             if self.testAttribute(Qt.WA_StyledBackground):
@@ -695,7 +705,9 @@ class QwtPlotCanvas(QFrame):
             else:
                 #                print('**DEBUG: QwtPlotCanvas.drawCanvas')
                 painter.setClipRect(self.contentsRect(), Qt.IntersectClip)
-        self.plot().drawCanvas(painter)
+        plot = self.plot()
+        if plot is not None:
+            plot.drawCanvas(painter)
         painter.restore()
         if withBackground and hackStyledBackground:
             #  Now paint the border on top

pythonqwt-0.16.3/qwt/qtdesigner.py

@@ -0,0 +1,211 @@
+# -*- coding: utf-8 -*-
+#
+# Licensed under the terms of the Qwt License
+# Copyright (c) 2015 Pierre Raybaut, for the Qt Designer plugin helpers
+# (see LICENSE file for more details)
+
+"""
+Qt Designer
+-----------
+
+The :mod:`qwt.qtdesigner` module provides helpers to integrate :mod:`qwt`
+widgets into Qt Designer:
+
+    * :py:class:`QwtPlotWidget`
+    * :py:func:`loadui`
+    * :py:func:`compileui`
+    * :py:func:`create_qtdesigner_plugin`
+
+:class:`QwtPlotWidget` is a thin :class:`qwt.QwtPlot` subclass exposing the
+standard Qt widget constructor (``__init__(self, parent=None)``). It is the
+widget promoted by the Qt Designer plugin, so that the code generated by
+``uic`` (e.g. ``QwtPlotWidget(parent=...)`` with PyQt6) instantiates it
+correctly. :class:`qwt.QwtPlot` itself keeps its historical constructor.
+
+.. note::
+
+    Qt Designer custom widget plugins rely on
+    :class:`QtDesigner.QPyDesignerCustomWidgetPlugin`, which is only available
+    with PyQt5/PyQt6. PySide6 does not expose this class.
+
+.. autoclass:: QwtPlotWidget
+
+.. autofunction:: loadui
+
+.. autofunction:: compileui
+
+.. autofunction:: create_qtdesigner_plugin
+"""
+
+from __future__ import annotations
+
+import io
+
+from qtpy import QtGui as QG
+from qtpy import uic
+
+from qwt.plot import QwtPlot
+
+
+class QwtPlotWidget(QwtPlot):
+    """:class:`qwt.QwtPlot` widget with the standard Qt constructor.
+
+    This subclass is meant to be promoted in Qt Designer: unlike
+    :class:`qwt.QwtPlot` (whose constructor accepts the historical
+    ``QwtPlot([title], [parent])`` overloads), it exposes the conventional
+    ``__init__(self, parent=None)`` signature expected by the code generated
+    by ``uic`` (notably PyQt6, which uses ``QwtPlotWidget(parent=...)``).
+
+    Args:
+        parent: Parent widget
+    """
+
+    def __init__(self, parent=None):
+        super().__init__(parent)
+
+
+def loadui(fname: str, replace_class: str | None = None):
+    """Return Widget or Window class from a Qt Designer ``.ui`` file.
+
+    When a promoted widget inherits from a class that is not known to the
+    ``uic`` parser (i.e. not a standard Qt widget), ``loadUiType`` fails to
+    resolve the widget hierarchy. Passing the offending base class name as
+    ``replace_class`` neutralizes it by substituting ``QFrame`` (the base
+    class of :class:`qwt.QwtPlot`) before the file is parsed.
+
+    For a plain :class:`qwt.QwtPlot` widget (which already inherits from
+    ``QFrame``), no replacement is required and ``replace_class`` can be left
+    to ``None``.
+
+    Args:
+        fname: Path to the ``.ui`` file
+        replace_class: Base class name to replace by ``QFrame``, or ``None``
+         to load the file unchanged
+
+    Returns:
+        The generated form class
+    """
+    with open(fname) as f:
+        uifile_text = f.read()
+    if replace_class is not None:
+        uifile_text = uifile_text.replace(replace_class, "QFrame")
+    ui, base_class = uic.loadUiType(io.StringIO(uifile_text))
+
+    class Form(base_class, ui):
+        """Form class generated from the ``.ui`` file"""
+
+        def __init__(self, parent=None):
+            super().__init__(parent)
+            self.setupUi(self)
+
+    return Form
+
+
+def compileui(fname: str, replace_class: str | None = None) -> None:
+    """Compile a Qt Designer ``.ui`` file into a Python module.
+
+    Args:
+        fname: Path to the ``.ui`` file
+        replace_class: Base class name to replace by ``QFrame``, or ``None``
+         to compile the file unchanged
+    """
+    with open(fname) as f:
+        uifile_text = f.read()
+    if replace_class is not None:
+        uifile_text = uifile_text.replace(replace_class, "QFrame")
+    with open(fname.replace(".ui", "_ui.py"), "w") as pyfile:
+        uic.compileUi(io.StringIO(uifile_text), pyfile, pyqt3_wrapper=True)
+
+
+def create_qtdesigner_plugin(
+    group: str,
+    module_name: str,
+    class_name: str,
+    icon: str | QG.QIcon | None = None,
+    tooltip: str = "",
+    whatsthis: str = "",
+):
+    """Return a custom Qt Designer plugin class.
+
+    Args:
+        group: Name of the group the widget belongs to in Qt Designer
+        module_name: Name of the module where the widget class is defined
+        class_name: Name of the widget class
+        icon: Icon shown in Qt Designer (path to an image file or
+         :class:`QtGui.QIcon` instance)
+        tooltip: Tool tip shown in Qt Designer
+        whatsthis: "What's this" help text shown in Qt Designer
+
+    Returns:
+        A :class:`QtDesigner.QPyDesignerCustomWidgetPlugin` subclass
+
+    Example::
+
+        Plugin = create_qtdesigner_plugin(
+            group="PythonQwt",
+            module_name="qwt.qtdesigner",
+            class_name="QwtPlotWidget",
+        )
+    """
+    from qtpy.QtDesigner import QPyDesignerCustomWidgetPlugin
+
+    Widget = getattr(__import__(module_name, fromlist=[class_name]), class_name)
+
+    class CustomWidgetPlugin(QPyDesignerCustomWidgetPlugin):
+        """Qt Designer plugin for the ``%s`` widget""" % class_name
+
+        def __init__(self, parent=None):
+            QPyDesignerCustomWidgetPlugin.__init__(self)
+            self.initialized = False
+
+        def initialize(self, core):
+            """Initialize the plugin"""
+            if self.initialized:
+                return
+            self.initialized = True
+
+        def isInitialized(self):
+            """Return whether the plugin has been initialized"""
+            return self.initialized
+
+        def createWidget(self, parent):
+            """Return a new instance of the custom widget"""
+            return Widget(parent)
+
+        def name(self):
+            """Return the name of the custom widget class"""
+            return class_name
+
+        def group(self):
+            """Return the name of the group the widget belongs to"""
+            return group
+
+        def icon(self):
+            """Return the icon shown in Qt Designer"""
+            if isinstance(icon, QG.QIcon):
+                return icon
+            elif isinstance(icon, str):
+                return QG.QIcon(icon)
+            return QG.QIcon()
+
+        def toolTip(self):
+            """Return the tool tip shown in Qt Designer"""
+            return tooltip
+
+        def whatsThis(self):
+            """Return the "What's this" help text shown in Qt Designer"""
+            return whatsthis
+
+        def isContainer(self):
+            """Return whether the widget is a container"""
+            return False
+
+        def domXml(self):
+            """Return the XML used to define the widget in Qt Designer"""
+            return f'<widget class="{class_name}" name="{class_name.lower()}" />\n'
+
+        def includeFile(self):
+            """Return the module name where the widget class is defined"""
+            return module_name
+
+    return CustomWidgetPlugin

{pythonqwt-0.16.1 → pythonqwt-0.16.3}/qwt/scale_draw.py

@@ -607,7 +607,7 @@ class QwtScaleDraw(QwtAbstractScaleDraw):
             * start: Start border distance
             * end: End border distance
         """
-        start, end = 0, 1.0
+        start, end = 0, 1
 
         if not self.hasComponent(QwtAbstractScaleDraw.Labels):
             return start, end

pythonqwt-0.16.3/qwt/tests/test_issue107_gdi_leak.py

@@ -0,0 +1,72 @@
+# -*- coding: utf-8 -*-
+#
+# Licensed under the terms of the Qwt License
+# (see LICENSE file for more details)
+
+"""
+Test for issue 107: GDI handle exhaustion on Windows.
+"""
+
+import numpy as np
+import pytest
+from qtpy import QtCore as QC
+from qtpy import QtWidgets as QW
+
+from qwt import QwtPlot, QwtPlotCurve
+from qwt.tests.utils import TestEnvironment
+
+
+def run_stress_cycle():
+    """Run one cycle of plot creation, rendering and destruction."""
+    plot = QwtPlot()
+    plot.resize(QC.QSize(800, 600))
+    plot.show()
+
+    # Create many curves with different fonts (via titles) to pressure caches
+    for i in range(20):
+        curve = QwtPlotCurve(f"Curve {i}")
+        x = np.linspace(0, 10, 100)
+        y = np.sin(x + i / 10.0)
+        curve.setData(x, y)
+        curve.attach(plot)
+
+    plot.replot()
+    QW.QApplication.processEvents()
+
+    plot.close()
+    plot.deleteLater()
+    QW.QApplication.processEvents()
+
+
+def test_gdi_leak_stability():
+    """
+    Repeatedly create/render/destroy plots to check for GDI leak stability.
+    On Windows, without the fix, this would crash after a certain number of cycles
+    due to GDI handle exhaustion.
+    """
+    env = TestEnvironment()
+    if not env.unattended:
+        pytest.skip("This test is for CI/unattended mode only")
+
+    # Close any top-level widgets left alive by previous tests in the shared
+    # QApplication. This test aggressively drives ``deleteLater()`` +
+    # ``processEvents()`` in-process; processing deferred deletions while stale
+    # widgets from earlier tests are still pending triggers a Qt teardown
+    # fast-fail (0xC0000409) on Windows. Starting from a clean widget set makes
+    # the test robust inside the full suite (it already passes in isolation).
+    app = QW.QApplication.instance() or QW.QApplication([])
+    for widget in list(app.topLevelWidgets()):
+        widget.close()
+        widget.deleteLater()
+    app.processEvents()
+    app.sendPostedEvents(None, QC.QEvent.DeferredDelete)
+    app.processEvents()
+
+    n_cycles = 50
+    for i in range(n_cycles):
+        run_stress_cycle()
+
+
+if __name__ == "__main__":
+    app = QW.QApplication.instance() or QW.QApplication([])
+    test_gdi_leak_stability()