qmlmathplot 0.1.0__py3-none-any.whl

qmlmathplot/plot.py

@@ -0,0 +1,213 @@
+"""Plot layer: what the view binds to — a camera, a list of curves, and the styling.
+
+The plot owns no pixels: it is a plain QObject, so the same plot can be shown by
+``PlotView``, embedded through ``MathPlotWidget`` or rendered offscreen. Styling lives here
+(one property per knob, each with a notify signal) so a theme is just a dict of property
+names — see ``theme``.
+"""
+
+from __future__ import annotations
+
+from PySide6.QtCore import Property, QObject, Signal, Slot
+from PySide6.QtGui import QColor, QVector2D
+
+from .camera import Camera
+from .curve import DEFAULT_COLOR_CYCLE, Curve, CurveListModel
+
+__all__ = ["Plot"]
+
+
+def _to_color(value: object) -> QColor:
+    return QColor(value) if not isinstance(value, QColor) else QColor(value)
+
+
+#: Value conversions per style kind (QML hands over whatever JS has: 1 for a bool, a string
+#: for a colour, …).
+_CONVERTERS = {
+    bool: bool,
+    float: float,
+    str: str,
+    QColor: _to_color,
+}
+
+
+def _style(kind: object, name: str, notify: Signal, default: object) -> Property:
+    """One style Property, with the house rules baked in: converts, idempotent, and emits its
+    notify signal only on a real change (a theme writes every knob in a row).
+
+    ``notify`` must be the signal *object* (PySide6 needs it to wire the property up; a name
+    string silently leaves the property without a notify signal, and QML bindings then never
+    refresh). Emitting goes through the descriptor protocol to reach this instance's signal.
+    """
+    convert = _CONVERTERS.get(kind)
+
+    def getter(self: Plot) -> object:
+        return getattr(self, "_" + name, default)
+
+    def setter(self: Plot, value: object) -> None:
+        value = convert(value) if convert is not None else value  # type: ignore[operator]
+        if value == getattr(self, "_" + name, default):
+            return
+        setattr(self, "_" + name, value)
+        notify.__get__(self, type(self)).emit()
+
+    return Property(kind, getter, setter, notify=notify)
+
+
+class Plot(QObject):
+    """The canvas state: a camera, the curves, and how they are dressed."""
+
+    cameraChanged = Signal()
+    curvesChanged = Signal()
+    viewChanged = Signal()
+    aspectChanged = Signal()        # forwarded from the camera (the forwarded `aspect`)
+    themeChanged = Signal()
+
+    backgroundChanged = Signal()
+    gridChanged = Signal()
+    gridColorChanged = Signal()
+    gridWidthChanged = Signal()
+    gridAlphaChanged = Signal()
+    gridStyleChanged = Signal()
+    colorCycleChanged = Signal()
+    lineWidthChanged = Signal()
+    textColorChanged = Signal()
+    tickColorChanged = Signal()
+    tickLengthChanged = Signal()
+    fontSizeChanged = Signal()
+    tickFontSizeChanged = Signal()
+    titleChanged = Signal()
+    titleColorChanged = Signal()
+    titleFontSizeChanged = Signal()
+    titleBoldChanged = Signal()
+    ticksVisibleChanged = Signal()
+
+    def __init__(self, parent: QObject | None = None) -> None:
+        super().__init__(parent)
+        self._camera = Camera(self)
+        self._curves = CurveListModel(DEFAULT_COLOR_CYCLE, self.line_width, self)
+        self._camera.viewChanged.connect(self.viewChanged)
+        self._camera.aspectChanged.connect(self.aspectChanged)
+        self.cameraChanged.emit()
+        self.curvesChanged.emit()
+
+    # ------------------------------------------------------------- the model
+    def _get_camera(self) -> Camera:
+        return self._camera
+
+    camera: Camera = Property(Camera, _get_camera, notify=cameraChanged)
+
+    def _get_curves(self) -> CurveListModel:
+        return self._curves
+
+    # Declared as QObject: PySide6 cannot register a Python QAbstractListModel subclass as a
+    # Qt property type (the meta-object rejects "QAbstractListModel*"), and QML only needs the
+    # object to *be* a list model.
+    curves: CurveListModel = Property(QObject, _get_curves, notify=curvesChanged)
+
+    def _get_xlim(self) -> QVector2D:
+        return self._camera.xlim
+
+    def _set_xlim(self, value: object) -> None:
+        self._camera.xlim = value
+
+    def _get_ylim(self) -> QVector2D:
+        return self._camera.ylim
+
+    def _set_ylim(self, value: object) -> None:
+        self._camera.ylim = value
+
+    def _get_aspect(self) -> str | float:
+        return self._camera.aspect
+
+    def _set_aspect(self, value: object) -> None:
+        self._camera.aspect = value
+
+    # Forwarded to the camera; "QVariant" so a plain (lo, hi) pair is accepted as well.
+    xlim: QVector2D = Property("QVariant", _get_xlim, _set_xlim, notify=viewChanged)
+    ylim: QVector2D = Property("QVariant", _get_ylim, _set_ylim, notify=viewChanged)
+    # `aspect` is forwarded too because a QML *binding* cannot reach through an object chain
+    # (`plot.camera.aspect: 1.0` is rejected by QML), while a direct property binds fine.
+    aspect: str | float = Property("QVariant", _get_aspect, _set_aspect, notify=aspectChanged)
+
+    @Slot(str, "QVariant", "QVariant", str, result=QObject)
+    @Slot(str, result=QObject)
+    def add_curve(
+        self,
+        expression: str,
+        color: object = None,
+        line_width: object = None,
+        label: str = "",
+    ) -> Curve:
+        """Add a curve (colour and width default to the plot's cycle and ``lineWidth``)."""
+        return self._curves.add_curve(expression, color, line_width, label)
+
+    @Slot(QObject)
+    def remove_curve(self, curve: Curve) -> None:
+        self._curves.remove_curve(curve)
+
+    # -------------------------------------------------------------- styling
+    background: QColor = _style(QColor, "background", backgroundChanged, QColor("#14141e"))
+    grid: bool = _style(bool, "grid", gridChanged, True)
+    grid_color: QColor = _style(QColor, "grid_color", gridColorChanged, QColor("#2a2a3a"))
+    grid_width: float = _style(float, "grid_width", gridWidthChanged, 1.0)
+    grid_alpha: float = _style(float, "grid_alpha", gridAlphaChanged, 0.5)
+    #: "-" | "--" | ":" | "-." (QML turns it into a dash pattern).
+    grid_style: str = _style(str, "grid_style", gridStyleChanged, "-")
+    text_color: QColor = _style(QColor, "text_color", textColorChanged, QColor("#c8c8d2"))
+    tick_color: QColor = _style(QColor, "tick_color", tickColorChanged, QColor("#6a6a80"))
+    tick_length: float = _style(float, "tick_length", tickLengthChanged, 6.0)
+    font_size: float = _style(float, "font_size", fontSizeChanged, 12.0)
+    tick_font_size: float = _style(float, "tick_font_size", tickFontSizeChanged, 11.0)
+    title: str = _style(str, "title", titleChanged, "")
+    title_color: QColor = _style(QColor, "title_color", titleColorChanged, QColor("#e8e8f0"))
+    title_font_size: float = _style(float, "title_font_size", titleFontSizeChanged, 15.0)
+    title_bold: bool = _style(bool, "title_bold", titleBoldChanged, True)
+    ticks_visible: bool = _style(bool, "ticks_visible", ticksVisibleChanged, True)
+
+    def _get_color_cycle(self) -> list[str]:
+        return list(getattr(self, "_color_cycle", DEFAULT_COLOR_CYCLE))
+
+    def _set_color_cycle(self, value: object) -> None:
+        cycle = [str(entry) for entry in value] or [DEFAULT_COLOR_CYCLE[0]]  # type: ignore[union-attr]
+        if cycle == self._get_color_cycle():
+            return
+        self._color_cycle = cycle
+        self._curves.set_color_cycle(tuple(cycle))
+        self.colorCycleChanged.emit()
+
+    color_cycle: list[str] = Property("QVariant", _get_color_cycle, _set_color_cycle,
+                                      notify=colorCycleChanged)
+
+    def _get_line_width(self) -> float:
+        return float(getattr(self, "_line_width", 1.5))
+
+    def _set_line_width(self, value: float) -> None:
+        value = float(value)
+        if value == self._get_line_width():
+            return
+        self._line_width = value
+        self._curves.set_default_line_width(value)   # default for the curves added later
+        self.lineWidthChanged.emit()
+
+    #: Default line width of new curves (logical pixels).
+    line_width: float = Property(float, _get_line_width, _set_line_width,
+                                 notify=lineWidthChanged)
+
+    def _get_theme(self) -> str:
+        return getattr(self, "_theme", "")
+
+    def _set_theme(self, name: str) -> None:
+        """Apply a named theme: every entry is a style property of this object."""
+        name = str(name)
+        if name == self._get_theme():
+            return
+        from .themes import resolve      # lazy: a missing themes module must not break import
+
+        resolved = resolve(name)         # unknown name -> KeyError, theme unchanged
+        for key, value in resolved.items():
+            setattr(self, key, value)
+        self._theme = name
+        self.themeChanged.emit()
+
+    theme: str = Property(str, _get_theme, _set_theme, notify=themeChanged)

qmlmathplot/qml/PlotView.qml

@@ -0,0 +1,247 @@
+// View layer: the plot on screen — background, grid, ticks and title in QML, one fragment
+// shader pass per curve.
+//
+// Usage (the host creates the model and injects it; MVVM):
+//     PlotView { plot: myPlot }
+// It also works standalone: the component brings its own Plot and one sin(x) curve.
+//
+// The view owns no state: everything it draws is read from the Plot (the camera for the
+// mapping, the curves model for the passes, the style properties for the dressing). Sizes are
+// reported to the camera for the derived ranges only — the shader derives its own mapping from
+// the camera and the item size, so drawing never depends on a size report arriving in order.
+import QtQuick
+import QmlMathPlot 1.0
+
+Item {
+    id: root
+
+    implicitWidth: 800
+    implicitHeight: 600
+
+    // The model (injected by the host). Without injection the component brings its own plot
+    // with one sin(x) curve, so it is usable standalone; a host that adds curves itself keeps
+    // this handler from firing (it only acts on an empty model).
+    property Plot plot: defaultPlot
+    Plot {
+        id: defaultPlot
+
+        Component.onCompleted: {
+            if (curves.rowCount() === 0)
+                add_curve("sin(x)");
+        }
+    }
+
+    // Forwarders, so a host can drive the component without knowing where the knob lives:
+    // `view.camera.aspect = 1.0`, `view.curves.add_curve("tan(x)")`. These are plain
+    // properties rather than QML aliases simply because an alias cannot reach through two
+    // objects (the plot is an injected property, not an id).
+    property QtObject camera: root.plot.camera
+    property QtObject curves: root.plot.curves
+
+    // World <-> screen. The camera maps the centre to the middle of the item, so screen x grows
+    // right and screen y grows down (vUV is top-down in the shader too).
+    function mapToScreen(x, y) {
+        const camera = root.plot.camera;
+        return Qt.point((x - camera.centre.x) / camera.scale_x + width / 2,
+                        (camera.centre.y - y) / camera.scale_y + height / 2);
+    }
+
+    function mapFromScreen(point) {
+        const camera = root.plot.camera;
+        return Qt.point(camera.centre.x + (point.x - width / 2) * camera.scale_x,
+                        camera.centre.y - (point.y - height / 2) * camera.scale_y);
+    }
+
+    function _gridDash(style) {
+        if (style === "--")
+            return [6, 4];
+        if (style === ":")
+            return [1, 3];
+        if (style === "-.")
+            return [6, 3, 1, 3];
+        return [];
+    }
+
+    // The first report resolves the home view for the real size; later ones keep the scales, so
+    // nothing zooms while a window or a splitter is dragged.
+    Component.onCompleted: root.plot.camera.setViewport(width, height)
+    onWidthChanged: root.plot.camera.setViewport(width, height)
+    onHeightChanged: root.plot.camera.setViewport(width, height)
+
+    Rectangle {
+        anchors.fill: parent
+        color: root.plot.background
+    }
+
+    // Grid: one line per tick, straight from the camera's tick values. Regenerated on camera
+    // and style changes only — never per frame.
+    Canvas {
+        id: gridCanvas
+        anchors.fill: parent
+        visible: root.plot.grid
+
+        onPaint: {
+            const ctx = getContext("2d");
+            ctx.clearRect(0, 0, width, height);
+            ctx.lineWidth = root.plot.grid_width;
+            ctx.strokeStyle = root.plot.grid_color;
+            ctx.globalAlpha = root.plot.grid_alpha;
+            ctx.setLineDash(root._gridDash(root.plot.grid_style));
+            ctx.beginPath();
+            for (const tick of root.plot.camera.ticks_x) {
+                const px = Math.round(root.mapToScreen(tick[0], 0).x) + 0.5;
+                ctx.moveTo(px, 0);
+                ctx.lineTo(px, height);
+            }
+            for (const tick of root.plot.camera.ticks_y) {
+                const py = Math.round(root.mapToScreen(0, tick[0]).y) + 0.5;
+                ctx.moveTo(0, py);
+                ctx.lineTo(width, py);
+            }
+            ctx.stroke();
+        }
+
+        onWidthChanged: requestPaint()
+        onHeightChanged: requestPaint()
+
+        Connections {
+            target: root.plot.camera
+            function onViewChanged() { gridCanvas.requestPaint(); }
+            function onTicksChanged() { gridCanvas.requestPaint(); }
+        }
+        Connections {
+            target: root.plot
+            function onGridChanged() { gridCanvas.requestPaint(); }
+            function onGridColorChanged() { gridCanvas.requestPaint(); }
+            function onGridWidthChanged() { gridCanvas.requestPaint(); }
+            function onGridAlphaChanged() { gridCanvas.requestPaint(); }
+            function onGridStyleChanged() { gridCanvas.requestPaint(); }
+        }
+    }
+
+    // Curves: one full-screen fragment pass each. The expression lives in the shader, so a
+    // change swaps the .qsb and costs one pass.
+    Repeater {
+        model: root.plot.curves
+
+        delegate: ShaderEffect {
+            anchors.fill: parent
+            visible: model.visible
+
+            property vector4d camera: Qt.vector4d(root.plot.camera.centre.x,
+                                                  root.plot.camera.centre.y,
+                                                  root.plot.camera.scale_x,
+                                                  root.plot.camera.scale_y)
+            property vector2d size: Qt.vector2d(root.width, root.height)
+            property real lineWidth: model.lineWidth
+            property color color: model.color
+
+            vertexShader: model.vertexShader
+            fragmentShader: model.fragmentShader
+        }
+    }
+
+    // Ticks, labels and title: screen-space furniture, so plain items.
+    Item {
+        anchors.fill: parent
+        visible: root.plot.ticks_visible
+
+        Repeater {
+            model: root.plot.camera.ticks_x
+
+            delegate: Item {
+                required property var modelData
+
+                x: Math.round(root.mapToScreen(modelData[0], 0).x)
+                width: 1
+                height: root.plot.tick_length
+                anchors.bottom: parent.bottom
+
+                Rectangle {
+                    anchors.fill: parent
+                    color: root.plot.tick_color
+                }
+                Text {
+                    text: modelData[1]
+                    color: root.plot.text_color
+                    font.pixelSize: root.plot.tick_font_size
+                    x: -Math.round(width / 2)
+                    y: -height - 3
+                }
+            }
+        }
+
+        Repeater {
+            model: root.plot.camera.ticks_y
+
+            delegate: Item {
+                required property var modelData
+
+                y: Math.round(root.mapToScreen(0, modelData[0]).y)
+                width: root.plot.tick_length
+                height: 1
+                anchors.left: parent.left
+
+                Rectangle {
+                    anchors.fill: parent
+                    color: root.plot.tick_color
+                }
+                Text {
+                    text: modelData[1]
+                    color: root.plot.text_color
+                    font.pixelSize: root.plot.tick_font_size
+                    x: root.plot.tick_length + 3
+                    y: -Math.round(height / 2)
+                }
+            }
+        }
+    }
+
+    Text {
+        anchors.horizontalCenter: parent.horizontalCenter
+        anchors.top: parent.top
+        anchors.topMargin: 6
+
+        text: root.plot.title
+        visible: text !== ""
+        color: root.plot.title_color
+        font.pixelSize: root.plot.title_font_size
+        font.bold: root.plot.title_bold
+    }
+
+    MouseArea {
+        anchors.fill: parent
+        acceptedButtons: Qt.LeftButton
+        enabled: root.plot.camera.panEnabled
+        // Panning must win over any ancestor Flickable/ScrollView: without this the Flickable
+        // steals the grab once the drag passes its threshold, and the plot only moves a few
+        // pixels before panning stops.
+        preventStealing: true
+
+        property real lastX: 0
+        property real lastY: 0
+
+        onPressed: (mouse) => {
+            lastX = mouse.x;
+            lastY = mouse.y;
+        }
+        onPositionChanged: (mouse) => {
+            root.plot.camera.pan_pixels(mouse.x - lastX, mouse.y - lastY);
+            lastX = mouse.x;
+            lastY = mouse.y;
+        }
+    }
+
+    WheelHandler {
+        enabled: root.plot.camera.zoomEnabled
+
+        // The cursor position is the anchor; delta is the raw wheel delta, 120 = one notch.
+        // Note: Qt 6's QML WheelEvent has no position, only x/y (relative to this item).
+        onWheel: (event) => {
+            const d = event.angleDelta.y !== 0 ? event.angleDelta.y : event.pixelDelta.y;
+            root.plot.camera.zoom_by(d, event.x / root.width, event.y / root.height,
+                                     root.width, root.height);
+            event.accepted = true;
+        }
+    }
+}

qmlmathplot/qsb.py

@@ -0,0 +1,96 @@
+"""Bake runtime-generated GLSL into .qsb (Qt 6's ShaderEffect / custom materials only take .qsb).
+
+Why it must be baked at runtime: the shader carries the user-entered expression (generated by
+sympy), while Qt's official workflow bakes with qsb at build time and ships the .qsb as a
+resource — impossible here. The baked result is cached in a temp directory keyed by the source
+sha256, so only the first use of an expression pays for the bake and the frame loop makes no
+calls at all.
+
+Cross-platform: on Windows the wheel ships ``PySide6/qsb.exe``; PySide6's packaging script has no
+platform condition for it, so all three platforms are expected to have it, but only Windows has
+been confirmed. If it is not found we fall back to PATH, and otherwise raise with the ways to
+obtain it.
+"""
+
+from __future__ import annotations
+
+import hashlib
+import os
+import shutil
+import subprocess
+import tempfile
+from pathlib import Path
+
+__all__ = ["bake", "qsb_binary"]
+
+_EXE = "qsb.exe" if os.name == "nt" else "qsb"
+
+
+def _candidates() -> list[Path]:
+    """Places qsb may live: the PySide6 package directory (layout differs per platform), Qt's
+    libexec, and PATH."""
+    cands: list[Path] = []
+    try:
+        import PySide6  # lazy import: only the QML front-end needs to bake shaders
+
+        pkg = Path(PySide6.__file__).parent
+        cands += [pkg / _EXE, pkg / "Qt" / "bin" / _EXE, pkg / "Qt" / "libexec" / _EXE]
+    except ImportError:  # without PySide6, a qsb on PATH is still allowed
+        pass
+    found = shutil.which("qsb")
+    if found:
+        cands.append(Path(found))
+    return cands
+
+
+def qsb_binary() -> Path:
+    """Locate qsb (the Qt Shader Baker)."""
+    for cand in _candidates():
+        if cand.exists():
+            return cand
+    raise RuntimeError(
+        "cannot find qsb (Qt Shader Baker); the QML front-end cannot bake its shaders. "
+        "Three ways to get it:\n"
+        "  1) use the PySide6 wheel (ships qsb.exe on Windows; check other platforms first)\n"
+        "  2) install Qt Shader Tools: a distribution package (e.g. qt6-shadertools) or the "
+        "Qt online installer\n"
+        "  3) if you already have qsb, put it on PATH\n"
+        "see https://doc.qt.io/qt-6/qtshadertools-index.html"
+    )
+
+
+def bake(source: str, stage: str, cache_dir: Path | str | None = None) -> Path:
+    """Bake one GLSL source into .qsb and return the file path (cached by source hash).
+
+    stage: "vert" or "frag"
+    """
+    if stage not in ("vert", "frag"):
+        raise ValueError(f"stage must be 'vert' or 'frag', got {stage!r}")
+
+    # v2: the source file must use a .vert/.frag suffix — qsb detects the stage from the
+    #     suffix, so a .glsl file is treated as a vertex shader. The version goes into the
+    #     hash, which invalidates old cache entries.
+    key = hashlib.sha256(f"v2\0{stage}\0{source}".encode()).hexdigest()[:16]
+    out_dir = Path(cache_dir) if cache_dir else Path(tempfile.gettempdir()) / "qmlmathplot-qsb"
+    out_dir.mkdir(parents=True, exist_ok=True)
+    out_path = out_dir / f"{stage}-{key}.qsb"
+    if out_path.exists():
+        return out_path
+
+    src_path = out_dir / f"{stage}-{key}.{stage}"
+    src_path.write_text(source, encoding="utf-8")
+    tmp_out = out_path.with_suffix(".qsb.tmp")
+    # --qt6 == --glsl "100 es,120,150" --hlsl 50 --msl 12, the standard target set for Qt Quick
+    # materials
+    proc = subprocess.run(  # noqa: S603
+        [str(qsb_binary()), "--qt6", "-o", str(tmp_out), str(src_path)],
+        capture_output=True,
+        text=True,
+        check=False,
+    )
+    if proc.returncode != 0 or not tmp_out.exists():
+        raise RuntimeError(
+            f"qsb bake failed ({stage}, rc={proc.returncode}):\n{proc.stdout}\n{proc.stderr}"
+        )
+    tmp_out.replace(out_path)  # atomic replace: no half-written file on interrupt/concurrency
+    return out_path

qmlmathplot/themes/LICENSE.matplotlib

@@ -0,0 +1,99 @@
+License agreement for matplotlib versions 1.3.0 and later
+=========================================================
+
+1. This LICENSE AGREEMENT is between the Matplotlib Development Team
+("MDT"), and the Individual or Organization ("Licensee") accessing and
+otherwise using matplotlib software in source or binary form and its
+associated documentation.
+
+2. Subject to the terms and conditions of this License Agreement, MDT
+hereby grants Licensee a nonexclusive, royalty-free, world-wide license
+to reproduce, analyze, test, perform and/or display publicly, prepare
+derivative works, distribute, and otherwise use matplotlib
+alone or in any derivative version, provided, however, that MDT's
+License Agreement and MDT's notice of copyright, i.e., "Copyright (c)
+2012- Matplotlib Development Team; All Rights Reserved" are retained in
+matplotlib  alone or in any derivative version prepared by
+Licensee.
+
+3. In the event Licensee prepares a derivative work that is based on or
+incorporates matplotlib or any part thereof, and wants to
+make the derivative work available to others as provided herein, then
+Licensee hereby agrees to include in any such work a brief summary of
+the changes made to matplotlib .
+
+4. MDT is making matplotlib available to Licensee on an "AS
+IS" basis.  MDT MAKES NO REPRESENTATIONS OR WARRANTIES, EXPRESS OR
+IMPLIED.  BY WAY OF EXAMPLE, BUT NOT LIMITATION, MDT MAKES NO AND
+DISCLAIMS ANY REPRESENTATION OR WARRANTY OF MERCHANTABILITY OR FITNESS
+FOR ANY PARTICULAR PURPOSE OR THAT THE USE OF MATPLOTLIB
+WILL NOT INFRINGE ANY THIRD PARTY RIGHTS.
+
+5. MDT SHALL NOT BE LIABLE TO LICENSEE OR ANY OTHER USERS OF MATPLOTLIB
+ FOR ANY INCIDENTAL, SPECIAL, OR CONSEQUENTIAL DAMAGES OR
+LOSS AS A RESULT OF MODIFYING, DISTRIBUTING, OR OTHERWISE USING
+MATPLOTLIB , OR ANY DERIVATIVE THEREOF, EVEN IF ADVISED OF
+THE POSSIBILITY THEREOF.
+
+6. This License Agreement will automatically terminate upon a material
+breach of its terms and conditions.
+
+7. Nothing in this License Agreement shall be deemed to create any
+relationship of agency, partnership, or joint venture between MDT and
+Licensee.  This License Agreement does not grant permission to use MDT
+trademarks or trade name in a trademark sense to endorse or promote
+products or services of Licensee, or any third party.
+
+8. By copying, installing or otherwise using matplotlib ,
+Licensee agrees to be bound by the terms and conditions of this License
+Agreement.
+
+License agreement for matplotlib versions prior to 1.3.0
+========================================================
+
+1. This LICENSE AGREEMENT is between John D. Hunter ("JDH"), and the
+Individual or Organization ("Licensee") accessing and otherwise using
+matplotlib software in source or binary form and its associated
+documentation.
+
+2. Subject to the terms and conditions of this License Agreement, JDH
+hereby grants Licensee a nonexclusive, royalty-free, world-wide license
+to reproduce, analyze, test, perform and/or display publicly, prepare
+derivative works, distribute, and otherwise use matplotlib
+alone or in any derivative version, provided, however, that JDH's
+License Agreement and JDH's notice of copyright, i.e., "Copyright (c)
+2002-2011 John D. Hunter; All Rights Reserved" are retained in
+matplotlib  alone or in any derivative version prepared by
+Licensee.
+
+3. In the event Licensee prepares a derivative work that is based on or
+incorporates matplotlib  or any part thereof, and wants to
+make the derivative work available to others as provided herein, then
+Licensee hereby agrees to include in any such work a brief summary of
+the changes made to matplotlib.
+
+4. JDH is making matplotlib  available to Licensee on an "AS
+IS" basis.  JDH MAKES NO REPRESENTATIONS OR WARRANTIES, EXPRESS OR
+IMPLIED.  BY WAY OF EXAMPLE, BUT NOT LIMITATION, JDH MAKES NO AND
+DISCLAIMS ANY REPRESENTATION OR WARRANTY OF MERCHANTABILITY OR FITNESS
+FOR ANY PARTICULAR PURPOSE OR THAT THE USE OF MATPLOTLIB
+WILL NOT INFRINGE ANY THIRD PARTY RIGHTS.
+
+5. JDH SHALL NOT BE LIABLE TO LICENSEE OR ANY OTHER USERS OF MATPLOTLIB
+ FOR ANY INCIDENTAL, SPECIAL, OR CONSEQUENTIAL DAMAGES OR
+LOSS AS A RESULT OF MODIFYING, DISTRIBUTING, OR OTHERWISE USING
+MATPLOTLIB , OR ANY DERIVATIVE THEREOF, EVEN IF ADVISED OF
+THE POSSIBILITY THEREOF.
+
+6. This License Agreement will automatically terminate upon a material
+breach of its terms and conditions.
+
+7. Nothing in this License Agreement shall be deemed to create any
+relationship of agency, partnership, or joint venture between JDH and
+Licensee.  This License Agreement does not grant permission to use JDH
+trademarks or trade name in a trademark sense to endorse or promote
+products or services of Licensee, or any third party.
+
+8. By copying, installing or otherwise using matplotlib,
+Licensee agrees to be bound by the terms and conditions of this License
+Agreement.

qmlmathplot/themes/README.md

@@ -0,0 +1,15 @@
+# Vendored Matplotlib style sheets
+
+Origin: [matplotlib](https://github.com/matplotlib/matplotlib), path
+`lib/matplotlib/mpl-data/stylelib/<name>.mplstyle`, from branch `main` at commit
+`4dd8b5c29a0cf54a4fcef5012ee3c54a26d252ce` (fetched 2026-10-08). The files are copied
+verbatim; only line endings were normalised to LF.
+
+They are Matplotlib's own style sheets, redistributed here under Matplotlib's BSD
+license — see `LICENSE.matplotlib` in this directory.
+
+Our loader converts the `rcParams` keys found in these files into plot style
+properties and silently ignores keys it does not recognise.
+
+Dropping a new `*.mplstyle` file into this directory makes it selectable by its file
+name (the name without the extension), with no registration step.