PythonQwt 0.16.2__py3-none-any.whl → 0.16.3__py3-none-any.whl

{pythonqwt-0.16.2.dist-info → pythonqwt-0.16.3.dist-info}/METADATA

@@ -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.dist-info → pythonqwt-0.16.3.dist-info}/RECORD

@@ -1,5 +1,5 @@
-pythonqwt-0.16.2.dist-info/licenses/LICENSE,sha256=qjEk8TRuXmFS7QC-omINvD1UPGqWaOs6CzcCZoMEhdI,33457
-qwt/__init__.py,sha256=U3tgDHGBj6RL0pfmUJR82xLCU-f4m_uzWb3LuSIr3lI,5990
+pythonqwt-0.16.3.dist-info/licenses/LICENSE,sha256=qjEk8TRuXmFS7QC-omINvD1UPGqWaOs6CzcCZoMEhdI,33457
+qwt/__init__.py,sha256=0eKAVij0c3t6sNd8fHi5OulCvZbC3PAT6hZrJcCSgJU,5990
 qwt/_math.py,sha256=fNcPJcaK-ldCCFB20T2N58LEkQ1lwZY1-q5veXXhwl8,1501
 qwt/color_map.py,sha256=fLRpymqOXtLrhuPrbbCxTvNINbr2GH7pYBG4fZidrcs,11812
 qwt/column_symbol.py,sha256=0aFyQ05ryTKbaSTctkhtXa0pB_tWG444zlH3991_bt0,5760
@@ -7,11 +7,11 @@ qwt/dyngrid_layout.py,sha256=wgff6mZ1okNhQRRbwaw1I__vOXqGdUG0uafkShuns08,13477
 qwt/graphic.py,sha256=rSxvgIAm9ctcyszvZrN_03KpBhKSHabbPYdcrztSta8,28962
 qwt/interval.py,sha256=PMrCQxV9NXGk2JG0MNjJ3zGTNTSSRfa_noxbpm-Okns,12287
 qwt/legend.py,sha256=GBUim67HWgwLat5tOWDpK98fWcFxV-RkxWjoyWd9Gao,31313
-qwt/null_paintdevice.py,sha256=1pgbcvyRTVN32RGzuPzUOm0iUImjvPQ4l5OfJVyA3hg,9375
+qwt/null_paintdevice.py,sha256=MQ_H4yc9qMqjAoCziaP3Sa6Mnu9wMSpbxTDisI7j1Dw,9381
 qwt/painter.py,sha256=k345puF4MAoTye0WBveiTNpCNWXx1K2o62_I0PZYlIA,16536
 qwt/painter_command.py,sha256=7D3goNsX_2Ufr5kCpC3Cr1t8GoD5Yz0G1oIZJKvoGBY,8501
-qwt/plot.py,sha256=XXcITYdLiAjIbT-8YfGkroNn5IhZsUs9oPvm1k_uFoE,76659
-qwt/plot_canvas.py,sha256=-Yjlkt0igkrsis6z8GaT2DXOMeaR699gi5wmU9EtPH4,30835
+qwt/plot.py,sha256=qw35nDxdDcrH-5MxijNo73r3xZ7EYb0S1UiHpavhEVE,77707
+qwt/plot_canvas.py,sha256=KK4saSTuoz5rab2xaQCAimlQlNQIo6GE3TVmHhMdsIc,31038
 qwt/plot_curve.py,sha256=ThlfxUjB4yiP_Dh96P7PXusyqUfDWcRcyt31OHvu2vk,37059
 qwt/plot_directpainter.py,sha256=JCWNhCC21L1A1HZnxd-C95QNlrVJbLztmGab-X8gCGc,10165
 qwt/plot_grid.py,sha256=h-cDTzibEzQyX2g25SBg5ysyXwmONmMFy9NcuzFySYc,16607
@@ -19,9 +19,10 @@ qwt/plot_layout.py,sha256=tD94nsFzWt1LQNFxgZbYsyM66ib6I6wBK3ObS7M1w_o,46183
 qwt/plot_marker.py,sha256=6vDHdMsyGClMruWLA4lChUCpoLzmxGNkvmICm0KjP6I,21284
 qwt/plot_renderer.py,sha256=v-fSwicMGQBa_kQx4hJJptlVNpNsKbgWk9jjqG-r_1g,27201
 qwt/plot_series.py,sha256=Wa_Wunu-t_L8vl95RJq6__k-XA8UV2YNIsc8yNGpTT8,10654
+qwt/qtdesigner.py,sha256=9oXSPD3m6vk1Tc8KLUM7daRuELXnOvNumbo1hlcrvJ4,6753
 qwt/qthelpers.py,sha256=GpvLr96Ip8SIGwyFfs0f7ocHyKPB7PEjHBQyrpw84xw,1405
 qwt/scale_div.py,sha256=_iI5cy4s8H6wigE8xsn7W44T2-DqVADqdjQ31uJPa_I,9266
-qwt/scale_draw.py,sha256=KYal9YOpvHjFWGkBFPVVNq_64cxM1vsHg_f_n-2nKNU,40547
+qwt/scale_draw.py,sha256=ZE8NSm3qSqwGtYo236mUZT5OC7weTwTWo_GZorhAIN4,40545
 qwt/scale_engine.py,sha256=7KQB5k-JXuJMsEMQXBJBNppCN-rTN97UKQCYXdazvqQ,36674
 qwt/scale_map.py,sha256=rHmPv7e9voEFuAIInQJq60mTtIGrLMViNlgJYu20znA,9605
 qwt/scale_widget.py,sha256=p202DrRgMraGbVcubzkatvVXOLbO9CPho729hz6gqa0,27125
@@ -46,16 +47,21 @@ qwt/tests/test_eventfilter.py,sha256=31vCsCzRcoq3cyMlDAH5fthA45QqeFXKaWyhfZME6rE
 qwt/tests/test_highdpi.py,sha256=Xafo016q-RX4918JddBGD60HZ4GpuYJBJokEO15md24,1053
 qwt/tests/test_image.py,sha256=yY_AplKEdm-M7uB5G50p4E68ZzNamYvGSfN5rvlVPPM,6549
 qwt/tests/test_issue107_gdi_leak.py,sha256=7IgZd9vJyD0_ea4CIDJ_SjlYDwYkA94aSRWEqt4y2ew,2203
+qwt/tests/test_issue109_backingstore.py,sha256=2PbNmobG7QsdXhE-vgPiKI6TaXbAz9m6G_qIDIkvMa8,2461
+qwt/tests/test_issue33_sidebyside.py,sha256=Tuu6XcRrV4ucPXmR8Y94uegRwCDWAN40EfuDQyVKHzE,10186
+qwt/tests/test_issue88_mousetracking.py,sha256=jr6iSBb1LIa32Rqt8opBXElC_ar0ru1j8XG1RUM_y5c,2360
 qwt/tests/test_loadtest.py,sha256=ZTHatcGAbLyvS0BpbOWbzPD2Bjz4rckF7oxZsUVQ5KM,1812
 qwt/tests/test_logcurve.py,sha256=XOtR0asSqFfzc0VL0qfXN0fXNvxvLnz5fxmNZ2gzQWk,1129
 qwt/tests/test_mapdemo.py,sha256=e7rvB8IPKYVVii8UgdHSbOHLc3i7eB21EQNKZ151Kc8,3423
 qwt/tests/test_multidemo.py,sha256=YS-P08qcakD41OJy6ZI53ofKOnUvD-2_uum0yOLiIRc,2530
+qwt/tests/test_qtdesigner.py,sha256=DOVapZrBvNAIA1GS0zFyLkA4Wxlyllh5lMhuGVfL2gc,1542
+qwt/tests/test_qtdesigner.ui,sha256=iqxZYkst-ZhBe08YVeptVvbohathyEHFxsHtErpHMj0,685
 qwt/tests/test_relativemargin.py,sha256=Shn0aE7UeETSSaQFpt4DrMOFeMN3p4rmEHKqPhXfQTI,2097
 qwt/tests/test_simple.py,sha256=4opQp_-RkcVdpRyYSh89ddBkeXCPrppB-_2KTiu5vjI,2347
 qwt/tests/test_stylesheet.py,sha256=cuL1iY4pp5ZoMX4OI86amJA6R5SzQsH1JUWLtEiitZ4,950
 qwt/tests/test_symbols.py,sha256=YcGM0_Em8QtcbqpLSU98PxvGo7BIIYviP2o_4Fg2LbI,5607
 qwt/tests/test_vertical.py,sha256=hWhPASIRb1nrd6d3m3dPoccwl5RoCVH_r_C8VK2znMI,3285
-qwt/tests/utils.py,sha256=kmAl8B0yKq1FCzVU4pBDAXwcQUGa4BE8m6FsNECEVEQ,10584
+qwt/tests/utils.py,sha256=5DdF53mL9VEn-f2WjXL4LMRO2MaUMFUvsKFprHnN3nw,10646
 qwt/tests/data/PythonQwt.svg,sha256=t-NYdVPqz7BcqtXNWCJvo8udrRmtGh57ksSYWUl1h4o,15232
 qwt/tests/data/bodedemo.png,sha256=8jP1YLE6HdwjEmrQyJclLxiYI4Zs4t0z0BoN1JT3GPQ,24414
 qwt/tests/data/cartesian.png,sha256=Cwbn5Jy3VT-OisFHxzMCVbfdbJacUMZ9uGCD9sCxA-Q,51094
@@ -78,8 +84,8 @@ qwt/tests/data/symbol.svg,sha256=ONkkohVqpg3OO2-XEZge7UZLqqNyOQXbSpLgHXcTBFU,127
 qwt/tests/data/symbols.png,sha256=wiqRBc2MJluJ-am9LtZ0K9DHV9BnreYMiEvfzJUFzCk,55586
 qwt/tests/data/testlauncher.png,sha256=WmucObp30QYYKsVRBs5-6t1aEN0FbIWRmOVFN1gt-vQ,139676
 qwt/tests/data/vertical.png,sha256=EvyG6q6rZm6pTT08Y_nzdBYCnqmoX1QDuEQtp2pyGlw,34076
-pythonqwt-0.16.2.dist-info/METADATA,sha256=iy-EOwIq8Y7_5k0xwlPDLm1TuBLmomXNEZ-vl3BMPhY,45515
-pythonqwt-0.16.2.dist-info/WHEEL,sha256=aeYiig01lYGDzBgS8HxWXOg3uV61G9ijOsup-k9o1sk,91
-pythonqwt-0.16.2.dist-info/entry_points.txt,sha256=pdPda-YcYigCi00hR4tMxWKu6byxM2x3zA8BQFDYvwI,46
-pythonqwt-0.16.2.dist-info/top_level.txt,sha256=KB1IBdWRWnaItyJMaECwZiEi1jWt3IvqCrRVVhMjTu8,4
-pythonqwt-0.16.2.dist-info/RECORD,,
+pythonqwt-0.16.3.dist-info/METADATA,sha256=X3YbzcMwmBSzowUYsNzto4vrDG8cbHUiqNFRDK5GzDM,45515
+pythonqwt-0.16.3.dist-info/WHEEL,sha256=K260EYznzXsJYBQGqmI8VTxEdiZYNvDZwW9cBh9-_MA,91
+pythonqwt-0.16.3.dist-info/entry_points.txt,sha256=pdPda-YcYigCi00hR4tMxWKu6byxM2x3zA8BQFDYvwI,46
+pythonqwt-0.16.3.dist-info/top_level.txt,sha256=KB1IBdWRWnaItyJMaECwZiEi1jWt3IvqCrRVVhMjTu8,4
+pythonqwt-0.16.3.dist-info/RECORD,,

{pythonqwt-0.16.2.dist-info → pythonqwt-0.16.3.dist-info}/WHEEL

@@ -1,5 +1,5 @@
 Wheel-Version: 1.0
-Generator: setuptools (82.0.1)
+Generator: setuptools (83.0.0)
 Root-Is-Purelib: true
 Tag: py3-none-any
 

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"
 
 

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

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()

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):

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

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

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")

qwt/tests/test_issue33_sidebyside.py

@@ -0,0 +1,260 @@
+# -*- coding: utf-8 -*-
+#
+# Licensed under the terms of the MIT License
+# Copyright (c) 2024 Pierre Raybaut
+# (see LICENSE file for more details)
+
+"""
+Side-by-side plots sharing a single vertical scale (issue #33)
+--------------------------------------------------------------
+
+This example answers `issue #33
+<https://github.com/PlotPyStack/PythonQwt/issues/33>`_: how to display several
+vertical plots side-by-side, perfectly aligned on a *single* shared vertical
+scale (here the depth down a drilled core), while each plot keeps its own
+horizontal scale (element concentration, density, ...).
+
+Two practical problems are solved here:
+
+1. **Vertical alignment.** When the left-most plot shows the depth axis and the
+   others do not, their canvases do not line up: an enabled vertical scale
+   reserves a "border distance" at both ends (so the extreme tick labels are not
+   clipped), which pushes its canvas down by a few pixels. To keep every canvas
+   aligned, the depth axis is *enabled on every plot* but only *drawn* on the
+   first one; on the other plots its components (labels, ticks, backbone) are
+   hidden while the very same border distance is reserved through
+   :py:meth:`qwt.scale_widget.QwtScaleWidget.setMinBorderDist`. This survives
+   relayout/zoom because :py:meth:`qwt.plot.QwtPlot.updateLayout` always honors
+   the minimum border distance.
+
+2. **Synchronized zoom/scroll.** A single vertical scroll bar and a pair of
+   zoom buttons drive the visible depth window of *all* plots at once, by
+   calling :py:meth:`qwt.plot.QwtPlot.setAxisScale` on the shared ``yLeft``
+   axis of each plot.
+"""
+
+SHOW = True  # Show test in GUI-based test launcher
+
+import numpy as np
+from qtpy import QtCore as QC
+from qtpy import QtGui as QG
+from qtpy import QtWidgets as QW
+
+from qwt import (
+    QwtLinearScaleEngine,
+    QwtPlot,
+    QwtPlotCurve,
+    QwtPlotGrid,
+    QwtScaleDraw,
+)
+from qwt.tests import utils
+
+DEPTH_MIN, DEPTH_MAX = 0.0, 120.0  # meters
+SCROLL_RESOLUTION = 100  # scroll bar steps per meter
+
+
+def make_drillcore_data():
+    """Return synthetic drill-core logs as ``(title, [(label, x, depth)], unit)``"""
+    depth = np.linspace(DEPTH_MIN, DEPTH_MAX, 800)
+    rng = np.random.default_rng(42)
+
+    def log(base, amp, n_bumps, noise):
+        signal = base + noise * rng.standard_normal(depth.size)
+        for _ in range(n_bumps):
+            center = rng.uniform(DEPTH_MIN, DEPTH_MAX)
+            width = rng.uniform(3.0, 12.0)
+            # Clip the exponent to avoid float64 underflow (numpy may be set to
+            # raise on underflow in the test suite).
+            signal += amp * np.exp(
+                np.clip(-(((depth - center) / width) ** 2), -50.0, 0.0)
+            )
+        return np.clip(signal, 0, None)
+
+    return [
+        (
+            "Iron",
+            "Fe (%)",
+            [("Fe", log(8.0, 18.0, 5, 0.6), depth)],
+        ),
+        (
+            "Copper",
+            "Cu (ppm)",
+            [
+                ("Cu", log(150.0, 600.0, 4, 20.0), depth),
+                ("Cu (smoothed)", log(150.0, 580.0, 4, 2.0), depth),
+            ],
+        ),
+        (
+            "Density",
+            "rho (g/cm3)",
+            [("rho", 2.6 + 0.04 * np.sin(depth / 6.0) + log(0.0, 0.2, 3, 0.01), depth)],
+        ),
+    ]
+
+
+class DepthPlot(QwtPlot):
+    """A single drill-core log plot with depth on the (inverted) left axis"""
+
+    CURVE_COLORS = ("#1f77b4", "#d62728", "#2ca02c", "#9467bd")
+
+    def _curve_color(self, index):
+        """Return a :py:class:`QColor` for the curve at ``index``"""
+        return QG.QColor(self.CURVE_COLORS[index % len(self.CURVE_COLORS)])
+
+    def __init__(self, title, x_title, curves, show_depth_axis, parent=None):
+        super().__init__(parent)
+        self.setObjectName(title)
+        self.setTitle(title)
+
+        # By default QwtPlot uses a MinimumExpanding horizontal policy, which
+        # makes the surrounding layout treat sizeHint() (not minimumSizeHint())
+        # as a hard minimum width. With several plots side-by-side this prevents
+        # the widget from being shrunk. An "Ignored" horizontal policy lets every
+        # column shrink freely and share the available width equally.
+        self.setSizePolicy(QW.QSizePolicy.Ignored, QW.QSizePolicy.Preferred)
+
+        # Horizontal (data) axis on top, like column headers in a core log
+        self.enableAxis(self.xBottom, False)
+        self.enableAxis(self.xTop, True)
+        self.setAxisTitle(self.xTop, x_title)
+        # Limit the number of major ticks: the horizontal axis reserves room for
+        # all its tick labels (minLabelDist * majorCount), which otherwise sets a
+        # very large minimum width and crowds the labels when the plot is narrow.
+        self.setAxisMaxMajor(self.xTop, 4)
+
+        # Vertical (depth) axis: inverted so depth increases downwards
+        self.enableAxis(self.yLeft, True)
+        self.axisScaleEngine(self.yLeft).setAttribute(
+            QwtLinearScaleEngine.Inverted, True
+        )
+
+        if show_depth_axis:
+            self.setAxisTitle(self.yLeft, "Depth (m)")
+        else:
+            # Keep the axis enabled (so the canvas stays aligned with the
+            # reference plot) but hide everything it draws.
+            scale_draw = self.axisScaleDraw(self.yLeft)
+            scale_draw.enableComponent(QwtScaleDraw.Labels, False)
+            scale_draw.enableComponent(QwtScaleDraw.Ticks, False)
+            scale_draw.enableComponent(QwtScaleDraw.Backbone, False)
+            scale_draw.setMinimumExtent(0)
+
+        QwtPlotGrid.make(self, color=QC.Qt.lightGray, width=0, style=QC.Qt.DotLine)
+
+        for index, (label, x, depth) in enumerate(curves):
+            color = self._curve_color(index)
+            curve = QwtPlotCurve.make(x, depth, label, self, linecolor=color)
+            curve.setAxes(self.xTop, self.yLeft)
+
+        self.setAxisScale(self.yLeft, DEPTH_MIN, DEPTH_MAX)
+
+
+class DrillCoreViewer(QW.QWidget):
+    """Several depth plots side-by-side, aligned on a single shared depth scale"""
+
+    def __init__(self, parent=None):
+        super().__init__(parent)
+        self.full_span = DEPTH_MAX - DEPTH_MIN
+        self.view_span = self.full_span
+        self.view_top = DEPTH_MIN
+
+        self.plots = []
+        plots_layout = QW.QHBoxLayout()
+        plots_layout.setSpacing(0)
+        for index, (title, x_title, curves) in enumerate(make_drillcore_data()):
+            plot = DepthPlot(title, x_title, curves, show_depth_axis=index == 0)
+            self.plots.append(plot)
+            plots_layout.addWidget(plot)
+
+        # Vertical scroll bar to move the visible depth window
+        self.scrollbar = QW.QScrollBar(QC.Qt.Vertical)
+        self.scrollbar.valueChanged.connect(self.scroll_to)
+        plots_layout.addWidget(self.scrollbar)
+
+        # Zoom buttons
+        zoom_in = QW.QToolButton()
+        zoom_in.setText("+")
+        zoom_in.setToolTip("Zoom in (depth)")
+        zoom_in.clicked.connect(lambda: self.zoom(0.5))
+        zoom_out = QW.QToolButton()
+        zoom_out.setText("-")
+        zoom_out.setToolTip("Zoom out (depth)")
+        zoom_out.clicked.connect(lambda: self.zoom(2.0))
+        reset = QW.QToolButton()
+        reset.setText("Reset")
+        reset.clicked.connect(self.reset_view)
+        toolbar = QW.QHBoxLayout()
+        toolbar.addWidget(QW.QLabel("Depth zoom:"))
+        toolbar.addWidget(zoom_in)
+        toolbar.addWidget(zoom_out)
+        toolbar.addWidget(reset)
+        toolbar.addStretch()
+
+        layout = QW.QVBoxLayout()
+        layout.addLayout(toolbar)
+        layout.addLayout(plots_layout)
+        self.setLayout(layout)
+
+        # Align the hidden depth axes with the reference one and apply the view.
+        QC.QTimer.singleShot(0, self._align_and_refresh)
+
+    def _align_and_refresh(self):
+        """Force identical vertical border distance on every depth axis"""
+        for plot in self.plots:
+            plot.replot()  # ensure scale divisions are computed
+        ref_widget = self.plots[0].axisWidget(self.plots[0].yLeft)
+        start, end = ref_widget.getBorderDistHint()
+        for plot in self.plots[1:]:
+            plot.axisWidget(plot.yLeft).setMinBorderDist(start, end)
+        self._apply_view()
+
+    def _apply_view(self):
+        """Apply the current depth window to every plot and update the scroll bar"""
+        bottom = self.view_top + self.view_span
+        for plot in self.plots:
+            plot.setAxisScale(plot.yLeft, self.view_top, bottom)
+            plot.replot()
+        self._update_scrollbar()
+
+    def _update_scrollbar(self):
+        """Reflect the current depth window in the scroll bar geometry"""
+        hidden = max(self.full_span - self.view_span, 0.0)
+        self.scrollbar.blockSignals(True)
+        self.scrollbar.setRange(0, int(round(hidden * SCROLL_RESOLUTION)))
+        self.scrollbar.setPageStep(int(round(self.view_span * SCROLL_RESOLUTION)))
+        self.scrollbar.setSingleStep(
+            int(round(self.view_span * SCROLL_RESOLUTION / 10))
+        )
+        self.scrollbar.setValue(
+            int(round((self.view_top - DEPTH_MIN) * SCROLL_RESOLUTION))
+        )
+        self.scrollbar.setEnabled(hidden > 0)
+        self.scrollbar.blockSignals(False)
+
+    def scroll_to(self, value):
+        """Scroll bar handler: move the visible depth window"""
+        self.view_top = DEPTH_MIN + value / SCROLL_RESOLUTION
+        self._apply_view()
+
+    def zoom(self, factor):
+        """Zoom the visible depth window around its center by ``factor``"""
+        center = self.view_top + self.view_span / 2.0
+        self.view_span = min(self.full_span, self.view_span * factor)
+        self.view_top = center - self.view_span / 2.0
+        self.view_top = max(DEPTH_MIN, min(self.view_top, DEPTH_MAX - self.view_span))
+        self._apply_view()
+
+    def reset_view(self):
+        """Restore the full depth range"""
+        self.view_span = self.full_span
+        self.view_top = DEPTH_MIN
+        self._apply_view()
+
+
+def test_issue33_sidebyside():
+    """Side-by-side plots sharing a single vertical scale (issue #33)"""
+    utils.test_widget(DrillCoreViewer, size=(700, 600))
+
+
+if __name__ == "__main__":
+    test_issue33_sidebyside()

qwt/tests/test_issue88_mousetracking.py

@@ -0,0 +1,70 @@
+# -*- coding: utf-8 -*-
+#
+# Licensed under the terms of the Qwt License
+# (see LICENSE file for more details)
+
+"""
+Test for issue 88: ``QwtPlot.setMouseTracking`` was ignored.
+
+The plot's drawing area is occupied by the canvas widget, so mouse move events
+over the plot are delivered to the canvas rather than to the ``QwtPlot`` frame.
+Calling ``QwtPlot.setMouseTracking(True)`` therefore had no visible effect: the
+canvas kept its default (button-pressed-only) move events. ``QwtPlot`` now
+propagates its mouse-tracking state to the canvas so that the setting behaves
+as documented by ``QWidget.setMouseTracking``.
+"""
+
+from qtpy import QtWidgets as QW
+
+from qwt import QwtPlot, QwtPlotCanvas
+
+
+def _ensure_app():
+    # 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).
+    return QW.QApplication.instance() or QW.QApplication([])
+
+
+def test_set_mouse_tracking_propagates_to_canvas():
+    """Enabling/disabling mouse tracking on the plot updates the canvas."""
+    app = _ensure_app()  # keep a reference alive for the duration of the test
+    plot = QwtPlot()
+
+    # By default mouse tracking is off on both the plot and its canvas.
+    assert not plot.hasMouseTracking()
+    assert not plot.canvas().hasMouseTracking()
+
+    plot.setMouseTracking(True)
+    assert plot.hasMouseTracking()
+    assert plot.canvas().hasMouseTracking()
+
+    plot.setMouseTracking(False)
+    assert not plot.hasMouseTracking()
+    assert not plot.canvas().hasMouseTracking()
+
+    plot.close()
+    del app
+
+
+def test_set_canvas_inherits_mouse_tracking_state():
+    """A canvas set after enabling tracking inherits the plot's state."""
+    app = _ensure_app()  # keep a reference alive for the duration of the test
+    plot = QwtPlot()
+    plot.setMouseTracking(True)
+
+    new_canvas = QwtPlotCanvas(plot)
+    assert not new_canvas.hasMouseTracking()
+
+    plot.setCanvas(new_canvas)
+    assert plot.canvas() is new_canvas
+    assert new_canvas.hasMouseTracking()
+
+    plot.close()
+    del app
+
+
+if __name__ == "__main__":
+    test_set_mouse_tracking_propagates_to_canvas()
+    test_set_canvas_inherits_mouse_tracking_state()

qwt/tests/test_qtdesigner.py

@@ -0,0 +1,55 @@
+# -*- coding: utf-8 -*-
+#
+# Licensed under the terms of the Qwt License
+# Copyright (c) 2015 Pierre Raybaut, for the Qt Designer plugin test
+# (see LICENSE file for more details)
+
+"""
+Testing PythonQwt Qt Designer plugin
+
+This plugin makes the :class:`qwt.QwtPlot` widget available in Qt Designer.
+The test loads a ``.ui`` file embedding a ``QwtPlot`` widget, as Qt Designer
+would generate it once the plugin is installed.
+"""
+
+SHOW = True  # Show test in GUI-based test launcher
+
+import os.path as osp
+
+import numpy as np
+import pytest
+from qtpy.QtCore import Qt
+
+import qwt
+from qwt.qtdesigner import loadui
+from qwt.tests import utils
+
+try:
+    FormClass = loadui(osp.splitext(__file__)[0] + ".ui")
+except Exception as exc:  # pragma: no cover - binding-specific uic limitation
+    pytest.skip(
+        "Qt Designer .ui loading is not supported by this Qt binding (%s)" % exc,
+        allow_module_level=True,
+    )
+
+
+class QtDesignerWindow(FormClass):
+    """Window built from the Qt Designer ``.ui`` file"""
+
+    def __init__(self):
+        super().__init__()
+        plot = self.plotwidget
+        plot.setTitle("QtDesigner plugin example")
+        x = np.linspace(0.0, 10.0, 500)
+        qwt.QwtPlotCurve.make(x, np.sin(x), "y = sin(x)", plot, linecolor="red")
+        qwt.QwtPlotGrid.make(plot, color=Qt.lightGray, width=0, style=Qt.DotLine)
+        plot.replot()
+
+
+def test_qtdesigner():
+    """Qt Designer plugin example"""
+    utils.test_widget(QtDesignerWindow, size=(600, 400))
+
+
+if __name__ == "__main__":
+    test_qtdesigner()

qwt/tests/test_qtdesigner.ui

@@ -0,0 +1,31 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<ui version="4.0">
+ <class>Dialog</class>
+ <widget class="QDialog" name="Dialog">
+  <property name="geometry">
+   <rect>
+    <x>0</x>
+    <y>0</y>
+    <width>500</width>
+    <height>400</height>
+   </rect>
+  </property>
+  <property name="windowTitle">
+   <string>Dialog</string>
+  </property>
+  <layout class="QVBoxLayout" name="verticalLayout">
+   <item>
+    <widget class="QwtPlotWidget" name="plotwidget"/>
+   </item>
+  </layout>
+ </widget>
+ <customwidgets>
+  <customwidget>
+   <class>QwtPlotWidget</class>
+   <extends>QFrame</extends>
+   <header>qwt.qtdesigner</header>
+  </customwidget>
+ </customwidgets>
+ <resources/>
+ <connections/>
+</ui>

qwt/tests/utils.py

@@ -41,6 +41,8 @@ TEST_PATH = osp.abspath(osp.dirname(__file__))
 
 
 class TestEnvironment:
+    __test__ = False  # Tell pytest this is not a test class
+
     UNATTENDED_ARG = "unattended"
     SCREENSHOTS_ARG = "screenshots"
     UNATTENDED_ENV = "PYTHONQWT_UNATTENDED_TESTS"