PythonQwt 0.16.2__tar.gz → 0.16.3__tar.gz

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: PythonQwt
-Version: 0.16.2
+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.2 → pythonqwt-0.16.3/PythonQwt.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: PythonQwt
-Version: 0.16.2
+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.2 → 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
@@ -96,10 +98,15 @@ 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.2 → 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.2 → 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.2 → 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.2"
+__version__ = "0.16.3"
 QWT_VERSION_STR = "6.1.5"
 
 

{pythonqwt-0.16.2 → 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.2 → pythonqwt-0.16.3}/qwt/plot.py

@@ -997,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()

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

@@ -591,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()
@@ -615,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):

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.2 → 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_issue109_backingstore.py

@@ -0,0 +1,68 @@
+# -*- coding: utf-8 -*-
+#
+# Licensed under the terms of the Qwt License
+# (see LICENSE file for more details)
+
+"""
+Test for issue 109: the ``QwtPlotCanvas.BackingStore`` paint attribute was
+non-functional.
+
+After ``invalidateBackingStore()`` reset the buffer to an empty ``QPixmap()``,
+``paintEvent`` skipped the backing-store branch because of an extra
+``isNull()`` guard, so the double-buffering cache was never regenerated. The
+regenerated pixmap was also only bound to a local variable and never stored
+back. This test ensures the cache is refreshed (and reused) as intended.
+"""
+
+import numpy as np
+from qtpy import QtCore as QC
+from qtpy import QtWidgets as QW
+
+from qwt import QwtPlot, QwtPlotCurve
+
+
+def _make_plot_with_backing_store():
+    plot = QwtPlot()
+    plot.resize(QC.QSize(400, 300))
+    canvas = plot.canvas()
+    canvas.setPaintAttribute(canvas.BackingStore, True)
+    x = np.linspace(0, 10, 100)
+    QwtPlotCurve.make(x, np.sin(x), "Sine", plot)
+    return plot, canvas
+
+
+def test_backing_store_is_regenerated_after_replot():
+    """The backing store must be repopulated when painting after a replot."""
+    # A live QApplication must exist before constructing any QWidget, 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 (observed on Linux/PyQt5 in CI).
+    app = QW.QApplication.instance() or QW.QApplication([])
+
+    plot, canvas = _make_plot_with_backing_store()
+    plot.show()
+    app.processEvents()  # lay the canvas out and paint it a first time
+
+    plot.replot()  # invalidates the backing store
+
+    # Force a paint so the backing store branch runs. ``grab()`` synchronously
+    # triggers ``paintEvent`` and works headless (QT_QPA_PLATFORM=offscreen),
+    # without depending on the event loop delivering a deferred repaint.
+    canvas.grab()
+
+    bs = canvas.backingStore()
+    assert bs is not None
+    assert not bs.isNull()
+    # The regenerated pixmap must match the canvas size (accounting for the
+    # device pixel ratio), proving it was actually rebuilt and stored back.
+    assert bs.size() == canvas.size() * bs.devicePixelRatio()
+
+    plot.close()
+    plot.deleteLater()
+    app.processEvents()
+
+
+if __name__ == "__main__":
+    app = QW.QApplication.instance() or QW.QApplication([])
+    test_backing_store_is_regenerated_after_replot()
+    print("OK")