qmlmathplot 0.4.0__py3-none-any.whl → 0.4.2__py3-none-any.whl

qmlmathplot/__init__.py

@@ -54,6 +54,7 @@ from .camera import HOME_SIZE, HOME_VIEW, Camera, nice_ticks
 from .curve import Curve, CurveListModel, ImplicitCurve
 from .figure import Axes, Figure
 from .input import ViewInput
+from .overlay import Annotation, Guide
 from .plot import Plot
 from .qsb import cache_dir, cache_info, clear_cache, prune_cache
 from .view import QML_MAJOR, QML_MINOR, QML_URI, qml_component_path, register_qml_types
@@ -63,6 +64,7 @@ if TYPE_CHECKING:  # only for type checkers; at runtime the module-level __getat
     from .widget import MathPlotWidget
 
 __all__ = [
+    "Annotation",
     "Axes",
     "cache_dir",
     "cache_info",
@@ -72,6 +74,7 @@ __all__ = [
     "CurveListModel",
     "Figure",
     "FigureCanvasQt",
+    "Guide",
     "HOME_SIZE",
     "HOME_VIEW",
     "ImplicitCurve",

qmlmathplot/curve.py

@@ -80,19 +80,36 @@ def _color(value: object) -> QColor:
     return QColor(value) if not isinstance(value, QColor) else QColor(value)
 
 
-def parsed(value: str | sp.Expr) -> tuple[str, sp.Expr]:
+def _parse(value: str | sp.Basic) -> tuple[str, sp.Expr, bool]:
+    """Canonical text, normalized expression and whether the input was an equation.
+
+    ``Eq(lhs, rhs)`` becomes the level set ``lhs - rhs = 0`` and is flagged as implicit even
+    when only ``x`` is free (``Eq(x**2, 1)`` is two vertical lines, not ``y = x**2 - 1``).
+    """
+    if isinstance(value, sp.Basic):
+        text = str(value)
+        expr = value
+    else:
+        text = str(value)
+        expr = sp.sympify(value, locals={"x": sp.Symbol("x"), "y": sp.Symbol("y")})
+    if isinstance(expr, sp.Eq):
+        return text, expr.lhs - expr.rhs, True
+    return text, expr, False
+
+
+def parsed(value: str | sp.Basic) -> tuple[str, sp.Expr]:
     """The canonical string and the parsed expression of a curve input.
 
     A string is parsed here, once; a sympy expression is used as it is (no ``Expr -> str ->
-    Expr`` round trip). The canonical string is what identifies the expression.
+    Expr`` round trip). ``Eq(lhs, rhs)`` is normalized to ``lhs - rhs``. The canonical string
+    is what identifies the expression.
     """
-    if isinstance(value, sp.Basic):
-        return str(value), value
-    return str(value), sp.sympify(value, locals={"x": sp.Symbol("x"), "y": sp.Symbol("y")})
+    text, expr, _ = _parse(value)
+    return text, expr
 
 
 def curve_for(
-    expression: str | sp.Expr,
+    expression: str | sp.Basic,
     *,
     implicit: bool | None = None,
     color: object = None,
@@ -106,17 +123,25 @@ def curve_for(
     is an implicit curve (the level set ``F(x, y) = 0``), and anything else raises — a parameter
     must be substituted before it is plotted, and silently evaluating it as a pixel coordinate is
     exactly the trap this avoids. ``implicit=True`` picks the level-set artist regardless of the
-    symbols (``add_implicit``).
+    symbols (``add_implicit``). A sympy ``Eq`` is always a level set (``lhs - rhs = 0``), even
+    when only ``x`` is free; it keeps the ordinary ``Curve`` class so a later assignment can
+    re-route it.
     """
-    text, expr = parsed(expression)
+    text, expr, is_equation = _parse(expression)
     names = {symbol.name for symbol in expr.free_symbols}
     if names - {"x", "y"}:
         raise ValueError(
             f"{sorted(names - {'x', 'y'})} must be substituted first: only x (or x and y) may "
             f"be free, got {text!r}"
         )
-    cls: type[Curve] = ImplicitCurve if (implicit or "y" in names) else Curve
-    return cls(expr, color=color, line_width=line_width, label=label, parent=parent)
+    if implicit:
+        cls: type[Curve] = ImplicitCurve
+    elif is_equation:
+        cls = Curve
+    else:
+        cls = ImplicitCurve if "y" in names else Curve
+    source = expression if is_equation else expr
+    return cls(source, color=color, line_width=line_width, label=label, parent=parent)
 
 
 class Curve(QObject):
@@ -125,7 +150,8 @@ class Curve(QObject):
     The fragment shader follows the expression: ``y = f(x)`` while only ``x`` (or nothing) is
     free, the level set ``F(x, y) = 0`` as soon as ``y`` appears — so ``add_curve`` and assigning
     to ``expression`` both route themselves, and a text field can turn a function into a level
-    set. ``ImplicitCurve`` forces the level-set template regardless of the symbols.
+    set. A sympy ``Eq(lhs, rhs)`` is always a level set (``lhs - rhs = 0``), even when only ``x``
+    is free. ``ImplicitCurve`` forces the level-set template regardless of the symbols.
     """
 
     #: Forced to the level-set template (see ``ImplicitCurve``).
@@ -145,7 +171,7 @@ class Curve(QObject):
 
     def __init__(
         self,
-        expression: str | sp.Expr = "sin(x)",
+        expression: str | sp.Basic = "sin(x)",
         color: str | QColor = DEFAULT_COLOR,
         line_width: float = 1.5,
         label: str = "",
@@ -164,6 +190,7 @@ class Curve(QObject):
         self._fragment = QUrl()
         self._generation = 0
         self._pending_expr: sp.Expr | None = None
+        self._pending_implicit: bool | None = None
         # Not parented: a job may outlive the curve; the signal object must stay valid for the
         # queued connection (Qt disconnects the receiver when the curve is destroyed).
         self._bake_signals = _BakeSignals()
@@ -174,51 +201,50 @@ class Curve(QObject):
     def _get_expression(self) -> str:
         return self._expression
 
-    def _set_expression(self, source: str | sp.Expr, *, synchronous: bool = False) -> None:
+    def _set_expression(self, source: str | sp.Basic, *, synchronous: bool = False) -> None:
         """Set the expression from a string (parsed here, once) or from a sympy expression.
 
         The canonical **string** is what identifies the expression — ``sp.sin(x)`` and
         ``"sin(x)"`` are the same, and re-setting either is free — while the parsed
         ``sp.Expr`` is cached for the bake and for the matplotlib hand-off, so neither ever
-        stringifies and re-parses again.
+        stringifies and re-parses again. ``Eq(lhs, rhs)`` is normalized to ``lhs - rhs`` and
+        drawn as the level set, even when only ``x`` is free.
 
         Parsing and source generation are synchronous (microseconds); the qsb subprocess runs
         on the thread pool for later assignments. ``expr`` keeps the last successfully baked
         expression until the new shaders arrive, so a failed or pending edit never draws an
         incomplete curve.
         """
-        if isinstance(source, str):
-            canonical = source
-        else:
-            canonical = str(source)
+        canonical = source if isinstance(source, str) else str(source)
         if canonical == self._expression:
             return
         self._generation += 1
         generation = self._generation
         self._pending_expr = None
-        if isinstance(source, sp.Basic):          # already an expression: use it as it is
-            expr: sp.Expr = source
-        else:
-            try:
-                expr = sp.sympify(source, locals={"x": self._symbol, "y": sp.Symbol("y")})
-            except Exception as exc:
-                # Keep the last drawn expression: the shaders stay, `expression` is what was
-                # typed and `error` says why.
-                self._expression = str(canonical)
-                self._error = f"{type(exc).__name__}: {exc}"
-                self.expressionChanged.emit()
-                self.errorChanged.emit()
-                return
+        self._pending_implicit = None
+        try:
+            _, expr, is_equation = _parse(source)
+        except Exception as exc:
+            # Keep the last drawn expression: the shaders stay, `expression` is what was
+            # typed and `error` says why.
+            self._expression = str(canonical)
+            self._error = f"{type(exc).__name__}: {exc}"
+            self.expressionChanged.emit()
+            self.errorChanged.emit()
+            return
+        forced_implicit = type(self)._force_implicit or is_equation
         self._expression = str(canonical)
         self.expressionChanged.emit()
-        self._start_bake(generation, expr, synchronous=synchronous)
+        self._start_bake(
+            generation, expr, synchronous=synchronous, force_implicit=forced_implicit
+        )
 
     # Annotate the value type (PySide6 idiom): Property is a descriptor, so without the
     # annotation a type checker only sees the Property object and flags every read and write.
     # Declared "QVariant" so an ``sp.Expr`` reaches the setter unconverted; the getter is always
     # the canonical string (QML, a project file and the text field all want one).
-    expression: str | sp.Expr = Property("QVariant", _get_expression, _set_expression,
-                                         notify=expressionChanged)
+    expression: str | sp.Basic = Property("QVariant", _get_expression, _set_expression,
+                                          notify=expressionChanged)
 
     def _get_expr(self) -> sp.Expr:
         return self._expr
@@ -302,7 +328,9 @@ class Curve(QObject):
         """
         return self._force_implicit or "y" in {symbol.name for symbol in self._expr.free_symbols}
 
-    def _sources(self, expr: sp.Expr) -> tuple[str, str]:
+    def _sources(
+        self, expr: sp.Expr, *, force_implicit: bool | None = None
+    ) -> tuple[str, str]:
         """The shader sources for this expression; anything unrenderable raises ``ValueError``
         (which ``_start_bake`` turns into ``error``, keeping the last working shaders)."""
         names = {symbol.name for symbol in expr.free_symbols}
@@ -311,22 +339,33 @@ class Curve(QObject):
                 f"only x (or x and y) may be free, got {sorted(names)}: substitute parameters "
                 "first"
             )
-        return implicit_shader_sources(expr) if (self._force_implicit or "y" in names) \
+        implicit = self._force_implicit if force_implicit is None else force_implicit
+        return implicit_shader_sources(expr) if (implicit or "y" in names) \
             else shader_sources(expr)
 
-    def _start_bake(self, generation: int, expr: sp.Expr, *, synchronous: bool) -> None:
+    def _start_bake(
+        self,
+        generation: int,
+        expr: sp.Expr,
+        *,
+        synchronous: bool,
+        force_implicit: bool | None = None,
+    ) -> None:
         """Generate the GLSL now and bake it on the pool unless this curve is synchronous.
 
         Source generation is cheap and stays on the caller's thread; only the qsb subprocess
         (the ~126 ms cache miss) leaves it.
         """
         try:
-            vertex_source, fragment_source = self._sources(expr)
+            vertex_source, fragment_source = self._sources(
+                expr, force_implicit=force_implicit
+            )
         except Exception as exc:  # noqa: BLE001 - reported through error, previous shaders stay
             self._error = f"{type(exc).__name__}: {exc}"
             self.errorChanged.emit()
             return
         self._pending_expr = expr
+        self._pending_implicit = force_implicit
         if synchronous or not self.bake_async or QCoreApplication.instance() is None:
             self._run_bake(generation, vertex_source, fragment_source)
             return
@@ -349,7 +388,9 @@ class Curve(QObject):
         if generation != self._generation:
             return
         expr = self._pending_expr
+        implicit = self._pending_implicit
         self._pending_expr = None
+        self._pending_implicit = None
         if isinstance(result, Exception):
             self._error = f"{type(result).__name__}: {result}"
             self.errorChanged.emit()
@@ -358,6 +399,8 @@ class Curve(QObject):
             return
         vertex, fragment = result           # type: ignore[misc]
         self._expr = expr
+        if implicit is not None:
+            self._force_implicit = bool(implicit)
         self._error = ""
         self._vertex = QUrl.fromLocalFile(str(vertex))
         self._fragment = QUrl.fromLocalFile(str(fragment))
@@ -388,6 +431,7 @@ class CurveListModel(QAbstractListModel):
     VisibleRole = CurveRole + 4
     VertexShaderRole = CurveRole + 5
     FragmentShaderRole = CurveRole + 6
+    LabelRole = CurveRole + 7
 
     _ROLES = {
         CurveRole: b"curve",
@@ -397,6 +441,7 @@ class CurveListModel(QAbstractListModel):
         VisibleRole: b"visible",
         VertexShaderRole: b"vertexShader",
         FragmentShaderRole: b"fragmentShader",
+        LabelRole: b"label",
     }
 
     def __init__(
@@ -435,6 +480,8 @@ class CurveListModel(QAbstractListModel):
             return curve.vertexShader
         if role == self.FragmentShaderRole:
             return curve.fragmentShader
+        if role == self.LabelRole:
+            return curve.label
         return None
 
     def _notify(self, curve: Curve, roles: tuple[int, ...]) -> None:
@@ -455,6 +502,7 @@ class CurveListModel(QAbstractListModel):
             lambda c=curve: self._notify(c, (self.ColorRole, self.LineWidthRole))
         )
         curve.visibleChanged.connect(lambda c=curve: self._notify(c, (self.VisibleRole,)))
+        curve.labelChanged.connect(lambda c=curve: self._notify(c, (self.LabelRole,)))
 
     # ---------------------------------------------------------------- public
     def _defaults(self, color: object, line_width: object) -> tuple[QColor, float]:
@@ -475,7 +523,7 @@ class CurveListModel(QAbstractListModel):
     @Slot("QVariant", result=QObject)
     def add_curve(
         self,
-        expression: str | sp.Expr,
+        expression: str | sp.Basic,
         color: object = None,
         line_width: object = None,
         label: str = "",
@@ -491,7 +539,7 @@ class CurveListModel(QAbstractListModel):
     @Slot("QVariant", result=QObject)
     def add_implicit(
         self,
-        expression: str | sp.Expr,
+        expression: str | sp.Basic,
         color: object = None,
         line_width: object = None,
         label: str = "",

qmlmathplot/export.py

@@ -14,7 +14,7 @@ from __future__ import annotations
 from collections.abc import Sequence
 from typing import TYPE_CHECKING
 
-from PySide6.QtCore import QSize, Qt, QUrl
+from PySide6.QtCore import QCoreApplication, QSize, Qt, QUrl
 from PySide6.QtGui import QColor, QImage
 
 if TYPE_CHECKING:  # pragma: no cover - typing only; the real imports stay lazy
@@ -155,6 +155,10 @@ def render(
 
         camera.set_viewport(logical[0], logical[1])
         camera.set_view(centre[0], centre[1], scale[0], scale[1])
+        # Let QML's Canvas-based furniture (grid, guides) handle its queued paint before the
+        # synchronous readback; the scene-graph items are already ready, Canvas is not.
+        for _ in range(3):
+            QCoreApplication.processEvents()
         image = widget.grabFramebuffer()
     finally:
         # Restore before the event loop runs again, so no live view repaints the export state.

qmlmathplot/figure.py

@@ -213,7 +213,13 @@ class Axes:
 
     # -------------------------------------------------------------- dressing
     def grid(self, visible: bool | None = True, **kwargs: object) -> None:
-        self.model.grid = True if visible is None else bool(visible)
+        axis = str(kwargs.pop("axis", "both")).lower()
+        enabled = True if visible is None else bool(visible)
+        self.model.grid = enabled
+        if axis in ("x", "both"):
+            self.model.grid_x = enabled
+        if axis in ("y", "both"):
+            self.model.grid_y = enabled
         if "color" in kwargs:
             self.model.grid_color = kwargs["color"]  # type: ignore[assignment]
         width = kwargs.get("linewidth", kwargs.get("lw"))
@@ -255,11 +261,19 @@ class Axes:
     def clear(self) -> None:
         self._figure.clf()
 
-    # ------------------------------------------------------ explicitly absent
+    # ------------------------------------------------------- text and annotation
     def legend(self, *args: object, **kwargs: object) -> None:
-        raise _unsupported(
-            "legend()", "chrome belongs to the host: use Curve.label and a PlotView.overlay"
-        )
+        if args and args[0] in (False, None):
+            self.model.legend = False
+            return None
+        loc = kwargs.get("loc", kwargs.get("location"))
+        if loc is not None:
+            text = str(loc).replace("_", " ").lower()
+            if text not in self.model._LEGEND_POSITIONS:
+                raise ValueError(f"unsupported legend location {loc!r}")
+            self.model.legend_position = text
+        self.model.legend = True
+        return None
 
     def set_xscale(self, value: object, **kwargs: object) -> None:
         raise _unsupported("log axes", "the shader mapping is linear today")
@@ -267,17 +281,77 @@ class Axes:
     def set_yscale(self, value: object, **kwargs: object) -> None:
         raise _unsupported("log axes", "the shader mapping is linear today")
 
-    def annotate(self, *args: object, **kwargs: object) -> None:
-        raise _unsupported("annotate()", "annotations are not implemented")
-
-    def text(self, *args: object, **kwargs: object) -> None:
-        raise _unsupported("text()", "annotations are not implemented")
+    def annotate(
+        self,
+        text: object,
+        xy: object,
+        xytext: object = (24, -18),
+        arrowprops: dict[str, object] | None = None,
+        **kwargs: object,
+    ):
+        color = kwargs.pop("color", None)
+        fontsize = kwargs.pop("fontsize", kwargs.pop("size", None))
+        if arrowprops and "color" in arrowprops:
+            color = arrowprops["color"]
+        return self.model.add_annotation(
+            "" if text is None else str(text),
+            xy,
+            xytext,
+            arrowprops is not None,
+            color,
+            None if fontsize is None else float(fontsize),  # type: ignore[arg-type]
+        )
 
-    def set_xticks(self, *args: object, **kwargs: object) -> None:
-        raise _unsupported("set_xticks()", "ticks are automatic nice numbers today")
+    def text(self, x: float, y: float, s: object, fontdict: object = None, **kwargs: object):
+        color = kwargs.pop("color", None)
+        size = kwargs.pop("fontsize", kwargs.pop("size", None))
+        return self.model.add_text(x, y, "" if s is None else str(s), color=color,
+                                   font_size=None if size is None else float(size))
+
+    def set_xticks(self, ticks: object, labels: object = None, **kwargs: object) -> None:
+        self.model.set_xticks(ticks, labels)
+
+    def set_yticks(self, ticks: object, labels: object = None, **kwargs: object) -> None:
+        self.model.set_yticks(ticks, labels)
+
+    def tick_params(self, axis: str = "both", **kwargs: object) -> None:
+        axis = str(axis).lower()
+        if "length" in kwargs:
+            self.model.tick_length = float(kwargs["length"])  # type: ignore[arg-type]
+        if "width" in kwargs:
+            self.model.tick_width = float(kwargs["width"])  # type: ignore[arg-type]
+        if "pad" in kwargs:
+            self.model.tick_pad = float(kwargs["pad"])  # type: ignore[arg-type]
+        if "labelsize" in kwargs:
+            self.model.tick_font_size = float(kwargs["labelsize"])  # type: ignore[arg-type]
+        colors = kwargs.get("colors", kwargs.get("color"))
+        if colors is not None:
+            self.model.tick_color = colors  # type: ignore[assignment]
+        labelcolor = kwargs.get("labelcolor")
+        if labelcolor is not None:
+            self.model.text_color = labelcolor  # type: ignore[assignment]
+        if "top" in kwargs and axis in ("x", "both"):
+            self.model.ticks_top = bool(kwargs["top"])
+        if "right" in kwargs and axis in ("y", "both"):
+            self.model.ticks_right = bool(kwargs["right"])
+        if str(kwargs.get("which", "")).lower() == "minor":
+            self.model.minor_ticks = True
+
+    def axhline(self, y: float = 0.0, **kwargs: object):
+        return self.model.add_hline(
+            y,
+            color=kwargs.get("color", kwargs.get("c")),
+            width=float(kwargs.get("linewidth", kwargs.get("lw", 1.0))),  # type: ignore[arg-type]
+            style=str(kwargs.get("linestyle", kwargs.get("ls", "--"))),
+        )
 
-    def set_yticks(self, *args: object, **kwargs: object) -> None:
-        raise _unsupported("set_yticks()", "ticks are automatic nice numbers today")
+    def axvline(self, x: float = 0.0, **kwargs: object):
+        return self.model.add_vline(
+            x,
+            color=kwargs.get("color", kwargs.get("c")),
+            width=float(kwargs.get("linewidth", kwargs.get("lw", 1.0))),  # type: ignore[arg-type]
+            style=str(kwargs.get("linestyle", kwargs.get("ls", "--"))),
+        )
 
 
 class Figure:

qmlmathplot/input.py

@@ -39,12 +39,14 @@ class ViewInput(QObject):
 
     keyboardEnabledChanged = Signal()
     keyPanStepChanged = Signal()
+    keyPanRepeatIntervalChanged = Signal()
     shortcutsChanged = Signal()
 
     def __init__(self, parent: QObject | None = None) -> None:
         super().__init__(parent)
         self._keyboard_enabled = True
         self._key_pan_step = 0.1
+        self._key_pan_repeat_interval = 100
         self._pan_left = "Left"
         self._pan_right = "Right"
         self._pan_up = "Up"
@@ -85,6 +87,26 @@ class ViewInput(QObject):
         float, _get_key_pan_step, _set_key_pan_step, notify=keyPanStepChanged
     )
 
+    def _get_key_pan_repeat_interval(self) -> int:
+        return self._key_pan_repeat_interval
+
+    def _set_key_pan_repeat_interval(self, value: int) -> None:
+        value = int(value)
+        if value <= 0:
+            raise ValueError(f"keyPanRepeatInterval must be positive, got {value!r}")
+        if value == self._key_pan_repeat_interval:
+            return
+        self._key_pan_repeat_interval = value
+        self.keyPanRepeatIntervalChanged.emit()
+
+    #: Milliseconds per held-key step (the frame timer integrates at dt / this value).
+    keyPanRepeatInterval: int = Property(
+        int,
+        _get_key_pan_repeat_interval,
+        _set_key_pan_repeat_interval,
+        notify=keyPanRepeatIntervalChanged,
+    )
+
     #: Key sequences (QKeySequence text) for the six view commands. ``|`` separates
     #: alternatives, so the default zoom-in is ``"+|="`` (Shift+= and the unshifted key).
     panLeftShortcut: str = _shortcut_property("_pan_left", shortcutsChanged)

qmlmathplot/model.py

@@ -440,21 +440,43 @@ void main() {
     float y_bot = camera.y - 0.5 * spany;
 
 #if USE_INTERVAL
+    // Conservative reject: every sample/segment used below lies within ±2 columns, so the
+    // interval over that window bounds the curve's y values there. A pixel farther than the
+    // stroke radius from that range cannot be painted; skip the 14 F evaluations and the
+    // column/stroke-footprint intervals. This is the cheap analogue of a column cache: one
+    // interval evaluation instead of the whole per-pixel sample loop. Whole/infinite columns
+    // do not reject (the envelope may fill the viewport); empty columns have no curve at all.
+    IVal wide = FI(x - 2.0 * dx, x + 2.0 * dx);
+    if (wide.kind == IK_EMPTY) {
+        fragColor = vec4(0.0);
+        return;
+    }
+    if (wide.kind == IK_CONNECTED && wide.lo > -IINF && wide.hi < IINF) {
+        float pad = R * camera.w;
+        if (y < wide.lo - pad || y > wide.hi + pad) {
+            fragColor = vec4(0.0);
+            return;
+        }
+    }
+
     IVal own = FI(x - 0.5 * dx, x + 0.5 * dx);
-    bool own_empty = own.kind == IK_EMPTY;
     IVal col = own;
-    IVal gate = FI(x - R * dx, x + R * dx);
-    if (col.kind == IK_EMPTY && gate.kind != IK_EMPTY) {
-        // The stroke's outer half may cross the domain boundary by up to one radius.
-        col = gate;
+    if (col.kind == IK_EMPTY) {
+        // The stroke's outer half may cross the domain boundary by up to one radius. Only a
+        // column with no in-domain value needs this wider footprint; skipping it for every
+        // other pixel removes one interval evaluation from the common path.
+        IVal gate = FI(x - R * dx, x + R * dx);
+        if (gate.kind != IK_EMPTY) {
+            col = gate;
+        }
     }
 
     // ---- fixed-x sub-pixel polyline (GeoGebra's sampled polyline, on the GPU) ----
-    // 16 samples over ±2 columns (0.25-column spacing) cover the perpendicular foot even at
+    // 14 samples over ±2 columns (0.286-column spacing) cover the perpendicular foot even at
     // 89°: a ±1-column window lost 42 % of the width at 84°. Joining the samples gives a
     // polyline whose segments are diagonal, so the stroke is smooth at any zoom. The interval
     // band stays separate (below); it no longer has to be inferred from this window.
-    const int NS = 16;
+    const int NS = 14;
     float smp[NS];
     float smpx[NS];
     bool ok[NS];

qmlmathplot/mpl.py

@@ -149,31 +149,92 @@ def figure_for(
         axes.spines["bottom"].set_position("zero")
         axes.spines["top"].set_visible(False)
         axes.spines["right"].set_visible(False)
+    elif plot.axes_position == "box":
+        for side, visible in (
+            ("top", plot.spine_top), ("bottom", plot.spine_bottom),
+            ("left", plot.spine_left), ("right", plot.spine_right),
+        ):
+            axes.spines[side].set_visible(visible)
     for spine in axes.spines.values():
         spine.set_color(plot.axis_color.name())
         spine.set_linewidth(plot.axis_width * PX_TO_PT)
 
+    if plot.xticks:
+        axes.set_xticks([float(value) for value, _label in plot.xticks],
+                        labels=[label for _value, label in plot.xticks])
+    if plot.yticks:
+        axes.set_yticks([float(value) for value, _label in plot.yticks],
+                        labels=[label for _value, label in plot.yticks])
+
     axes.set_axisbelow(True)                      # the Qt view paints its grid below the curves
+    grid_kwargs = {
+        "color": plot.grid_color.name(),
+        "linewidth": plot.grid_width * PX_TO_PT,
+        "alpha": plot.grid_alpha,
+        "linestyle": plot.grid_style,
+    }
     if plot.grid:
-        axes.grid(True, color=plot.grid_color.name(),
-                  linewidth=plot.grid_width * PX_TO_PT, alpha=plot.grid_alpha,
-                  linestyle=plot.grid_style)
+        axes.grid(False)
+        if plot.grid_x:
+            axes.xaxis.grid(True, **grid_kwargs)
+        if plot.grid_y:
+            axes.yaxis.grid(True, **grid_kwargs)
     else:
-        # Passing line properties together with `False` makes matplotlib *enable* the grid.
         axes.grid(False)
-    axes.tick_params(colors=plot.tick_color.name(), labelcolor=plot.text_color.name(),
-                     labelsize=plot.tick_font_size * PX_TO_PT)
+    axes.tick_params(
+        colors=plot.tick_color.name(),
+        labelcolor=plot.text_color.name(),
+        labelsize=plot.tick_font_size * PX_TO_PT,
+        width=plot.tick_width * PX_TO_PT,
+        pad=plot.tick_pad * PX_TO_PT,
+        top=plot.ticks_top,
+        right=plot.ticks_right,
+    )
+    if plot.minor_ticks:
+        axes.minorticks_on()
     axes.xaxis.label.set_fontsize(plot.font_size * PX_TO_PT)
     axes.yaxis.label.set_fontsize(plot.font_size * PX_TO_PT)
+    if plot.xlabel:
+        axes.set_xlabel(plot.xlabel, color=plot.text_color.name())
+    if plot.ylabel:
+        axes.set_ylabel(plot.ylabel, color=plot.text_color.name())
     if plot.title:
         axes.set_title(plot.title, color=plot.title_color.name(),
                        fontsize=plot.title_font_size * PX_TO_PT,
                        fontweight="bold" if plot.title_bold else "normal")
 
+    for index in range(plot.annotations.rowCount()):
+        annotation = plot.annotations.at(index)
+        if not annotation.visible:
+            continue
+        options: dict[str, object] = {
+            "xycoords": "data",
+            "textcoords": "offset points",
+            "xytext": (annotation.xytext.x(), annotation.xytext.y()),
+            "color": annotation.color.name(),
+            "fontsize": annotation.fontSize * PX_TO_PT,
+        }
+        if annotation.arrow:
+            options["arrowprops"] = {"arrowstyle": "->", "color": annotation.color.name()}
+        axes.annotate(annotation.text, (annotation.xy.x(), annotation.xy.y()), **options)
+
+    for index in range(plot.guides.rowCount()):
+        guide = plot.guides.at(index)
+        if not guide.visible:
+            continue
+        if guide.kind == "h":
+            axes.axhline(guide.value, color=guide.color.name(),
+                         linewidth=guide.width * PX_TO_PT, linestyle=guide.style)
+        else:
+            axes.axvline(guide.value, color=guide.color.name(),
+                         linewidth=guide.width * PX_TO_PT, linestyle=guide.style)
+
     for curve in _visible_curves(plot):
         xs, ys = _sample(curve, x_range[0], x_range[1], samples)
         axes.plot(xs, ys, color=curve.color.name(), linewidth=curve.lineWidth * PX_TO_PT,
                   label=curve.label or curve.expression)
+    if plot.legend and any(curve.label for curve in _visible_curves(plot)):
+        axes.legend(loc=plot.legend_position)
     return figure