qmlmathplot 0.4.0__tar.gz → 0.4.1__tar.gz

{qmlmathplot-0.4.0 → qmlmathplot-0.4.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: qmlmathplot
-Version: 0.4.0
+Version: 0.4.1
 Summary: Embeddable function plotter for Qt Quick / QtWidgets (implicit per-pixel drawing, MVVM)
 Author: I-AM-A-NOOB
 Author-email: I-AM-A-NOOB <suzc08@outlook.com>
@@ -145,7 +145,7 @@ The model:
 |---|---|
 | `Plot` | `camera`, `curves`, `xlim`/`ylim`/`aspect` (forwarded), `add_curve()` / `add_implicit()` / `remove_curve()`, `available_themes`, and the style properties: `background`, `grid`, `grid_color`, `grid_width`, `grid_alpha`, `grid_style`, `axis_color`, `axis_width`, `axes_position`, `color_cycle`, `line_width`, `text_color`, `tick_color`, `tick_length`, `font_size`, `tick_font_size`, `title`, `xlabel`, `ylabel`, `title_color`, `title_font_size`, `title_bold`, `ticks_visible`, `theme` |
 | `Camera` | `centre`, `zoom` (world units per logical pixel), `aspect`, `xlim`/`ylim` (derived), `ticks_x`/`ticks_y`, `zoomStep` / `panEnabled` / `zoomEnabled`, `animationDuration`, `input` (a `ViewInput`), slots `set_viewport(w, h)` / `zoom_by(delta, u, v, w, h)` / `zoom_at(factor, u, v, w, h)` / `pan_pixels(dx, dy)` / `animate_zoom(...)` / `animate_pan(dx, dy, ms)` / `stop_animation()` / `reset()` |
-| `ViewInput` | `keyboardEnabled`, `keyPanStep`, `panLeftShortcut` / `panRightShortcut` / `panUpShortcut` / `panDownShortcut` / `zoomInShortcut` / `zoomOutShortcut`, `matches(key, modifiers, shortcut)` |
+| `ViewInput` | `keyboardEnabled`, `keyPanStep`, `keyPanRepeatInterval`, `panLeftShortcut` / `panRightShortcut` / `panUpShortcut` / `panDownShortcut` / `zoomInShortcut` / `zoomOutShortcut`, `matches(key, modifiers, shortcut)` |
 | `Curve` | `expression` (string or sympy expression), `expr` (the parsed expression, read-only), `implicit`, `color`, `lineWidth`, `visible`, `label`, `error` (read-only), the baked `vertexShader` / `fragmentShader` |
 | `CurveListModel` | the curves as a model (`curve`, `expression`, `color`, `lineWidth`, `visible`, `vertexShader`, `fragmentShader` roles) so QML puts one `ShaderEffect` behind each |
 
@@ -239,9 +239,16 @@ and `add_implicit` asks for the level-set artist explicitly — also for a funct
 which is a pair of vertical lines. Only a *third* free symbol is refused: substitute parameters
 first.
 
+A sympy `Eq(lhs, rhs)` is always a level set: it is normalized to `lhs - rhs = 0`, and an
+equation with only `x` still means the vertical lines where it holds (`Eq(x**2, 1)`), not
+`y = x**2 - 1`. The canonical `expression` keeps the `Eq(...)` text and `expr` is the normalized
+difference.
+
 ```python
+x, y = sp.symbols("x y")
 plot.add_curve("x**2 + y**2 - 1")        # a circle: {x, y} routes to the level-set artist
-plot.add_implicit("x*y - 1")             # the same artist, asked for by name
+plot.add_curve(sp.Eq(x**2 + y**2, 1))    # the same circle in equation form
+plot.add_implicit(sp.Eq(x, sp.sin(y)))   # asked for by name, equation form
 plot.curves.at(0).expression = "x**2 + y**2 - 4"   # re-routes the curve that is already there
 plot.add_curve("a*sin(x)")               # ValueError: substitute `a` first
 ```
@@ -306,9 +313,12 @@ plot.plot.camera.zoom_by(120, 0.5, 0.5, w, h)     # one wheel notch, anchored at
 ## Keyboard, touch and animation
 
 Clicking the plot gives it focus; while it has focus the arrow keys pan (10% of the viewport
-per press by default), `+`/`=` zooms in and `-`/`_` zooms out. Every command is a property on
-the camera's `input` object, so a host can rebind it — the value is a `QKeySequence` string,
-and `|` separates alternatives (empty disables the command). `input.keyPanStep`,
+per press by default), `+`/`=` zooms in and `-`/`_` zooms out. Held keys advance continuously:
+one `keyPanStep` per `keyPanRepeatInterval` (100 ms by default), integrated every frame, so
+there is no OS key-repeat delay or granular stepping. Several arrows combine, so `Left+Up`
+moves diagonally at the normal speed. Every command is a property on the camera's `input`
+object, so a host can rebind it — the value is a `QKeySequence` string, and `|` separates
+alternatives (empty disables the command). `input.keyPanStep`, `input.keyPanRepeatInterval`,
 `input.keyboardEnabled`, `panEnabled` and `zoomEnabled` shape the behaviour the same way.
 
 ```python
@@ -318,8 +328,9 @@ input.panLeftShortcut = "A"           # rebind one arrow
 input.panRightShortcut = "D"
 input.zoomInShortcut = "Ctrl+="
 input.zoomOutShortcut = "Ctrl+-"
-input.keyPanStep = 0.2                # 20% of the viewport per arrow press
-camera.animationDuration = 220        # ms; 0 disables easing
+input.keyPanStep = 0.2                # 20% of the viewport per step
+input.keyPanRepeatInterval = 80       # ms per step; smaller = faster pan/zoom
+camera.animationDuration = 220        # ms; tap easing
 ```
 
 Wheel and keyboard moves are **eased** (scale interpolates geometrically, so a zoom feels like

{qmlmathplot-0.4.0 → qmlmathplot-0.4.1}/README.md

@@ -132,7 +132,7 @@ The model:
 |---|---|
 | `Plot` | `camera`, `curves`, `xlim`/`ylim`/`aspect` (forwarded), `add_curve()` / `add_implicit()` / `remove_curve()`, `available_themes`, and the style properties: `background`, `grid`, `grid_color`, `grid_width`, `grid_alpha`, `grid_style`, `axis_color`, `axis_width`, `axes_position`, `color_cycle`, `line_width`, `text_color`, `tick_color`, `tick_length`, `font_size`, `tick_font_size`, `title`, `xlabel`, `ylabel`, `title_color`, `title_font_size`, `title_bold`, `ticks_visible`, `theme` |
 | `Camera` | `centre`, `zoom` (world units per logical pixel), `aspect`, `xlim`/`ylim` (derived), `ticks_x`/`ticks_y`, `zoomStep` / `panEnabled` / `zoomEnabled`, `animationDuration`, `input` (a `ViewInput`), slots `set_viewport(w, h)` / `zoom_by(delta, u, v, w, h)` / `zoom_at(factor, u, v, w, h)` / `pan_pixels(dx, dy)` / `animate_zoom(...)` / `animate_pan(dx, dy, ms)` / `stop_animation()` / `reset()` |
-| `ViewInput` | `keyboardEnabled`, `keyPanStep`, `panLeftShortcut` / `panRightShortcut` / `panUpShortcut` / `panDownShortcut` / `zoomInShortcut` / `zoomOutShortcut`, `matches(key, modifiers, shortcut)` |
+| `ViewInput` | `keyboardEnabled`, `keyPanStep`, `keyPanRepeatInterval`, `panLeftShortcut` / `panRightShortcut` / `panUpShortcut` / `panDownShortcut` / `zoomInShortcut` / `zoomOutShortcut`, `matches(key, modifiers, shortcut)` |
 | `Curve` | `expression` (string or sympy expression), `expr` (the parsed expression, read-only), `implicit`, `color`, `lineWidth`, `visible`, `label`, `error` (read-only), the baked `vertexShader` / `fragmentShader` |
 | `CurveListModel` | the curves as a model (`curve`, `expression`, `color`, `lineWidth`, `visible`, `vertexShader`, `fragmentShader` roles) so QML puts one `ShaderEffect` behind each |
 
@@ -226,9 +226,16 @@ and `add_implicit` asks for the level-set artist explicitly — also for a funct
 which is a pair of vertical lines. Only a *third* free symbol is refused: substitute parameters
 first.
 
+A sympy `Eq(lhs, rhs)` is always a level set: it is normalized to `lhs - rhs = 0`, and an
+equation with only `x` still means the vertical lines where it holds (`Eq(x**2, 1)`), not
+`y = x**2 - 1`. The canonical `expression` keeps the `Eq(...)` text and `expr` is the normalized
+difference.
+
 ```python
+x, y = sp.symbols("x y")
 plot.add_curve("x**2 + y**2 - 1")        # a circle: {x, y} routes to the level-set artist
-plot.add_implicit("x*y - 1")             # the same artist, asked for by name
+plot.add_curve(sp.Eq(x**2 + y**2, 1))    # the same circle in equation form
+plot.add_implicit(sp.Eq(x, sp.sin(y)))   # asked for by name, equation form
 plot.curves.at(0).expression = "x**2 + y**2 - 4"   # re-routes the curve that is already there
 plot.add_curve("a*sin(x)")               # ValueError: substitute `a` first
 ```
@@ -293,9 +300,12 @@ plot.plot.camera.zoom_by(120, 0.5, 0.5, w, h)     # one wheel notch, anchored at
 ## Keyboard, touch and animation
 
 Clicking the plot gives it focus; while it has focus the arrow keys pan (10% of the viewport
-per press by default), `+`/`=` zooms in and `-`/`_` zooms out. Every command is a property on
-the camera's `input` object, so a host can rebind it — the value is a `QKeySequence` string,
-and `|` separates alternatives (empty disables the command). `input.keyPanStep`,
+per press by default), `+`/`=` zooms in and `-`/`_` zooms out. Held keys advance continuously:
+one `keyPanStep` per `keyPanRepeatInterval` (100 ms by default), integrated every frame, so
+there is no OS key-repeat delay or granular stepping. Several arrows combine, so `Left+Up`
+moves diagonally at the normal speed. Every command is a property on the camera's `input`
+object, so a host can rebind it — the value is a `QKeySequence` string, and `|` separates
+alternatives (empty disables the command). `input.keyPanStep`, `input.keyPanRepeatInterval`,
 `input.keyboardEnabled`, `panEnabled` and `zoomEnabled` shape the behaviour the same way.
 
 ```python
@@ -305,8 +315,9 @@ input.panLeftShortcut = "A"           # rebind one arrow
 input.panRightShortcut = "D"
 input.zoomInShortcut = "Ctrl+="
 input.zoomOutShortcut = "Ctrl+-"
-input.keyPanStep = 0.2                # 20% of the viewport per arrow press
-camera.animationDuration = 220        # ms; 0 disables easing
+input.keyPanStep = 0.2                # 20% of the viewport per step
+input.keyPanRepeatInterval = 80       # ms per step; smaller = faster pan/zoom
+camera.animationDuration = 220        # ms; tap easing
 ```
 
 Wheel and keyboard moves are **eased** (scale interpolates geometrically, so a zoom feels like

{qmlmathplot-0.4.0 → qmlmathplot-0.4.1}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "qmlmathplot"
-version = "0.4.0"
+version = "0.4.1"
 description = "Embeddable function plotter for Qt Quick / QtWidgets (implicit per-pixel drawing, MVVM)"
 readme = "README.md"
 requires-python = ">=3.11"

{qmlmathplot-0.4.0 → qmlmathplot-0.4.1}/pyproject.toml.orig

@@ -1,6 +1,6 @@
 [project]
 name = "qmlmathplot"
-version = "0.4.0"
+version = "0.4.1"
 description = "Embeddable function plotter for Qt Quick / QtWidgets (implicit per-pixel drawing, MVVM)"
 readme = "README.md"
 authors = [

{qmlmathplot-0.4.0 → qmlmathplot-0.4.1}/src/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))
@@ -475,7 +518,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 +534,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-0.4.0 → qmlmathplot-0.4.1}/src/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-0.4.0 → qmlmathplot-0.4.1}/src/qmlmathplot/plot.py

@@ -152,7 +152,7 @@ class Plot(QObject):
     @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 = "",
@@ -162,7 +162,8 @@ class Plot(QObject):
         The artist follows the expression's free symbols: ``x`` (or none) is a 1-D curve
         ``y = f(x)``, ``x`` **and** ``y`` is an implicit curve — the level set ``F(x, y) = 0``,
         so ``add_curve("x**2 + y**2 - 1")`` is a circle — and any other free symbol raises
-        ``ValueError`` (substitute parameters first).
+        ``ValueError`` (substitute parameters first). A sympy ``Eq(lhs, rhs)`` is normalized to
+        ``lhs - rhs`` and treated as a level set even when only ``x`` is free.
         """
         return self._curves.add_curve(expression, color, line_width, label)
 
@@ -170,13 +171,14 @@ class Plot(QObject):
     @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 = "",
     ) -> Curve:
         """Add an implicit curve — the level set ``F(x, y) = 0`` — explicitly, whatever the
-        expression's free symbols (``x`` alone gives vertical lines).
+        expression's free symbols (``x`` alone gives vertical lines; ``Eq(lhs, rhs)`` is
+        normalized to ``lhs - rhs``).
 
         Drawn per pixel like the other artists, with no sampling: ``|F|`` divided by ``|grad F|``
         in pixels is the distance to the level set. Smooth, single-sheet level sets only for now

qmlmathplot-0.4.1/src/qmlmathplot/qml/PlotView.qml

@@ -0,0 +1,275 @@
+// View layer composition: background, one shader pass per curve, screen-space furniture and
+// pointer/keyboard input. The reusable pieces live in PlotCurves.qml, PlotFurniture.qml and
+// PlotInput.qml; this file owns the model injection, the camera mapping and keyboard focus.
+//
+// Usage (the host creates the model and injects it; MVVM):
+//     PlotView { plot: myPlot }
+// It also works standalone: the component brings its own empty Plot (`defaultExpression` adds
+// a curve). The view owns no state: everything it draws is read from the Plot.
+import QtQuick
+import QmlMathPlot 1.0
+
+Item {
+    id: root
+
+    implicitWidth: 800
+    implicitHeight: 600
+
+    // Keyboard navigation is opt-in by focus: a click (or a host focusing the QQuickWidget)
+    // makes this the active item, and the keys are handled only then, so a host's shortcuts
+    // keep working while the plot is idle. `focus: true` is the default *within* this scene,
+    // not a grab: the QQuickWidget is still ClickFocus and does not enter the Tab chain.
+    focus: true
+    Keys.onPressed: (event) => {
+        if (root._handleKeyPress(event))
+            event.accepted = true;
+    }
+    Keys.onReleased: (event) => {
+        if (root._handleKeyRelease(event))
+            event.accepted = true;
+    }
+    onActiveFocusChanged: {
+        if (!activeFocus)
+            root._clearHeld();
+    }
+
+    // The model (injected by the host). Without injection the component brings its own plot;
+    // it adds no curve by itself. A standalone user opts into one with `defaultExpression`
+    // (``PlotView { defaultExpression: "sin(x)" }``) — no hidden default, and a host that
+    // injects a model or adds its own curves never races this handler.
+    property Plot plot: defaultPlot
+    property string defaultExpression: ""
+    Plot {
+        id: defaultPlot
+    }
+
+    // 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);
+    }
+
+    // Keyboard: arrow keys move the view (the camera moves, so the content follows), the
+    // zoom shortcuts anchor at the viewport centre. Every mapping is on camera.input, so a
+    // host can rebind it; an empty string disables a command.
+    //
+    // Held keys are tracked here rather than relying on the OS auto-repeat (which begins with
+    // a ~0.5 s delay and then repeats in bursts). One frame-rate Timer advances both pan and
+    // zoom by `dt / keyPanRepeatInterval` of a step, so movement is continuous and several
+    // keys combine (diagonal movement is normalised). The press itself still animates one
+    // step, so a tap keeps the one-step semantics.
+    property var _heldKeys: ({})
+    property real _lastTickMs: 0
+
+    Timer {
+        id: keyTimer
+        interval: 16
+        repeat: true
+        onTriggered: root._keyTick()
+    }
+
+    Connections {
+        target: root.plot.camera
+        function onPanEnabledChanged() {
+            if (!root.plot.camera.panEnabled) {
+                root._dropHeld("left");
+                root._dropHeld("right");
+                root._dropHeld("up");
+                root._dropHeld("down");
+            }
+        }
+        function onZoomEnabledChanged() {
+            if (!root.plot.camera.zoomEnabled) {
+                root._dropHeld("zoomIn");
+                root._dropHeld("zoomOut");
+            }
+        }
+    }
+    Connections {
+        target: root.plot.camera.input
+        function onKeyboardEnabledChanged() {
+            if (!root.plot.camera.input.keyboardEnabled)
+                root._clearHeld();
+        }
+    }
+
+    // One command name for this event, or "" when it is not bound.
+    function _commandFor(event, requireEnabled) {
+        const camera = root.plot.camera;
+        const input = camera.input;
+        if (!input.keyboardEnabled)
+            return "";
+        if (input.matches(event.key, event.modifiers, input.panLeftShortcut))
+            return (!requireEnabled || camera.panEnabled) ? "left" : "";
+        if (input.matches(event.key, event.modifiers, input.panRightShortcut))
+            return (!requireEnabled || camera.panEnabled) ? "right" : "";
+        if (input.matches(event.key, event.modifiers, input.panUpShortcut))
+            return (!requireEnabled || camera.panEnabled) ? "up" : "";
+        if (input.matches(event.key, event.modifiers, input.panDownShortcut))
+            return (!requireEnabled || camera.panEnabled) ? "down" : "";
+        if (camera.zoomEnabled) {
+            if (input.matches(event.key, event.modifiers, input.zoomInShortcut))
+                return "zoomIn";
+            if (input.matches(event.key, event.modifiers, input.zoomOutShortcut))
+                return "zoomOut";
+        }
+        return "";
+    }
+
+    function _isPanCommand(command) {
+        return command === "left" || command === "right"
+            || command === "up" || command === "down";
+    }
+
+    function _clearHeld() {
+        root._heldKeys = ({});
+        keyTimer.stop();
+    }
+
+    function _dropHeld(command) {
+        delete root._heldKeys[command];
+        if (Object.keys(root._heldKeys).length === 0)
+            keyTimer.stop();
+    }
+
+    function _ensureTimer() {
+        if (!keyTimer.running) {
+            root._lastTickMs = Date.now();
+            keyTimer.start();
+        }
+    }
+
+    // Frame-rate integration: a step per keyPanRepeatInterval, scaled by the real elapsed
+    // time (a delayed frame moves farther instead of slowing the pan down).
+    function _keyTick() {
+        const camera = root.plot.camera;
+        const input = camera.input;
+        if (!input.keyboardEnabled) {
+            root._clearHeld();
+            return;
+        }
+        const now = Date.now();
+        const dt = Math.min(100, Math.max(0, now - root._lastTickMs));
+        root._lastTickMs = now;
+        if (dt <= 0)
+            return;
+        const fraction = dt / Math.max(1, input.keyPanRepeatInterval);
+
+        let dx = 0;
+        let dy = 0;
+        if (root._heldKeys.left)
+            dx += 1;
+        if (root._heldKeys.right)
+            dx -= 1;
+        if (root._heldKeys.up)
+            dy += 1;
+        if (root._heldKeys.down)
+            dy -= 1;
+        if ((dx !== 0 || dy !== 0) && camera.panEnabled) {
+            if (dx !== 0 && dy !== 0) {
+                dx *= Math.SQRT1_2;
+                dy *= Math.SQRT1_2;
+            }
+            camera.pan_pixels(input.keyPanStep * root.width * dx * fraction,
+                              input.keyPanStep * root.height * dy * fraction);
+        }
+
+        let zoom = 0;
+        if (root._heldKeys.zoomIn)
+            zoom += 1;
+        if (root._heldKeys.zoomOut)
+            zoom -= 1;
+        if (zoom !== 0 && camera.zoomEnabled) {
+            camera.zoom_by(120 * zoom * fraction, 0.5, 0.5, root.width, root.height);
+        }
+    }
+
+    function _handleKeyPress(event) {
+        const command = root._commandFor(event, true);
+        if (command === "")
+            return false;
+        if (event.isAutoRepeat)                       // the Timer owns repeats
+            return true;
+        const camera = root.plot.camera;
+        const input = camera.input;
+        root._heldKeys[command] = true;
+        root._ensureTimer();
+        if (root._isPanCommand(command)) {
+            // One eased step for a tap; the frame timer cancels it on the first held frame
+            // and takes over continuously.
+            const step = input.keyPanStep;
+            if (command === "left")
+                camera.animate_pan(step * root.width, 0, camera.animationDuration);
+            else if (command === "right")
+                camera.animate_pan(-step * root.width, 0, camera.animationDuration);
+            else if (command === "up")
+                camera.animate_pan(0, step * root.height, camera.animationDuration);
+            else
+                camera.animate_pan(0, -step * root.height, camera.animationDuration);
+        } else if (command === "zoomIn") {
+            camera.animate_zoom(120, 0.5, 0.5, root.width, root.height,
+                                camera.animationDuration);
+        } else if (command === "zoomOut") {
+            camera.animate_zoom(-120, 0.5, 0.5, root.width, root.height,
+                                camera.animationDuration);
+        }
+        return true;
+    }
+
+    function _handleKeyRelease(event) {
+        const command = root._commandFor(event, false);
+        if (command === "")
+            return false;
+        if (event.isAutoRepeat)
+            return true;
+        root._dropHeld(command);
+        if (Object.keys(root._heldKeys).length > 0)
+            root._ensureTimer();
+        return true;
+    }
+
+    // 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: {
+        if (defaultExpression !== "" && curves.rowCount() === 0)
+            add_curve(defaultExpression);
+        root.plot.camera.set_viewport(width, height);
+    }
+    onWidthChanged: root.plot.camera.set_viewport(width, height)
+    onHeightChanged: root.plot.camera.set_viewport(width, height)
+
+    Rectangle {
+        anchors.fill: parent
+        color: root.plot.background
+    }
+
+    PlotCurves {
+        anchors.fill: parent
+        view: root
+    }
+
+    PlotFurniture {
+        anchors.fill: parent
+        view: root
+    }
+
+    PlotInput {
+        anchors.fill: parent
+        view: root
+    }
+}

qmlmathplot-0.4.0/src/qmlmathplot/qml/PlotView.qml

@@ -1,134 +0,0 @@
-// View layer composition: background, one shader pass per curve, screen-space furniture and
-// pointer/keyboard input. The reusable pieces live in PlotCurves.qml, PlotFurniture.qml and
-// PlotInput.qml; this file owns the model injection, the camera mapping and keyboard focus.
-//
-// Usage (the host creates the model and injects it; MVVM):
-//     PlotView { plot: myPlot }
-// It also works standalone: the component brings its own empty Plot (`defaultExpression` adds
-// a curve). The view owns no state: everything it draws is read from the Plot.
-import QtQuick
-import QmlMathPlot 1.0
-
-Item {
-    id: root
-
-    implicitWidth: 800
-    implicitHeight: 600
-
-    // Keyboard navigation is opt-in by focus: a click (or a host focusing the QQuickWidget)
-    // makes this the active item, and the keys are handled only then, so a host's shortcuts
-    // keep working while the plot is idle. `focus: true` is the default *within* this scene,
-    // not a grab: the QQuickWidget is still ClickFocus and does not enter the Tab chain.
-    focus: true
-    Keys.onPressed: (event) => {
-        if (root._handleKey(event))
-            event.accepted = true;
-    }
-
-    // The model (injected by the host). Without injection the component brings its own plot;
-    // it adds no curve by itself. A standalone user opts into one with `defaultExpression`
-    // (``PlotView { defaultExpression: "sin(x)" }``) — no hidden default, and a host that
-    // injects a model or adds its own curves never races this handler.
-    property Plot plot: defaultPlot
-    property string defaultExpression: ""
-    Plot {
-        id: defaultPlot
-    }
-
-    // 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);
-    }
-
-    // Keyboard: arrow keys move the view (the camera moves, so the content follows), the
-    // zoom shortcuts anchor at the viewport centre. Every mapping is on camera.input, so a
-    // host can rebind it; an empty string disables a command.
-    function _matches(event, shortcut) {
-        return root.plot.camera.input.matches(event.key, event.modifiers, shortcut);
-    }
-
-    function _handleKey(event) {
-        const camera = root.plot.camera;
-        const input = camera.input;
-        if (!input.keyboardEnabled)
-            return false;
-        const dx = input.keyPanStep * root.width;
-        const dy = input.keyPanStep * root.height;
-        const duration = camera.animationDuration;
-        if (camera.panEnabled) {
-            if (_matches(event, input.panLeftShortcut)) {
-                camera.animate_pan(dx, 0, duration);
-                return true;
-            }
-            if (_matches(event, input.panRightShortcut)) {
-                camera.animate_pan(-dx, 0, duration);
-                return true;
-            }
-            if (_matches(event, input.panUpShortcut)) {
-                camera.animate_pan(0, dy, duration);
-                return true;
-            }
-            if (_matches(event, input.panDownShortcut)) {
-                camera.animate_pan(0, -dy, duration);
-                return true;
-            }
-        }
-        if (camera.zoomEnabled) {
-            if (_matches(event, input.zoomInShortcut)) {
-                camera.animate_zoom(120, 0.5, 0.5, root.width, root.height, duration);
-                return true;
-            }
-            if (_matches(event, input.zoomOutShortcut)) {
-                camera.animate_zoom(-120, 0.5, 0.5, root.width, root.height, duration);
-                return true;
-            }
-        }
-        return false;
-    }
-
-    // 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: {
-        if (defaultExpression !== "" && curves.rowCount() === 0)
-            add_curve(defaultExpression);
-        root.plot.camera.set_viewport(width, height);
-    }
-    onWidthChanged: root.plot.camera.set_viewport(width, height)
-    onHeightChanged: root.plot.camera.set_viewport(width, height)
-
-    Rectangle {
-        anchors.fill: parent
-        color: root.plot.background
-    }
-
-    PlotCurves {
-        anchors.fill: parent
-        view: root
-    }
-
-    PlotFurniture {
-        anchors.fill: parent
-        view: root
-    }
-
-    PlotInput {
-        anchors.fill: parent
-        view: root
-    }
-}