rgrid-python 4.5.3.post2__py3-none-any.whl → 4.5.3.post4__py3-none-any.whl

grid_py/__init__.py

@@ -6,7 +6,7 @@ units, viewports, grobs (graphical objects), layouts, and rendering via
 Cairo (pycairo).
 """
 
-__version__ = "4.5.3.post2"
+__version__ = "4.5.3.post4"
 
 # --- Utilities ---
 from grid_py._utils import depth, explode, grid_pretty, n2mfrow

grid_py/_curve.py

@@ -1383,6 +1383,8 @@ def grid_curve(
 def xspline_grob(
     x: Optional[Any] = None,
     y: Optional[Any] = None,
+    id: Optional[Any] = None,
+    id_lengths: Optional[Any] = None,
     default_units: str = "npc",
     shape: Union[float, Sequence[float]] = 0.0,
     open_: bool = True,
@@ -1402,6 +1404,15 @@ def xspline_grob(
     x, y : Unit, numeric, sequence, or None
         Control-point coordinates.  Defaults to ``Unit([0, 1], "npc")``
         when ``None``.
+    id : array-like of int or None
+        Group label for each control point.  Points sharing an ``id`` are
+        rendered as one X-spline; the grob therefore renders one spline
+        per unique ``id`` value.  Mirrors R ``xsplineGrob(id=...)``.
+        Mutually meaningful with ``id_lengths``: pass at most one.
+    id_lengths : array-like of int or None
+        Run-length encoding of ``id``: the n-th entry is the number of
+        consecutive control points belonging to spline n.  Mirrors R's
+        ``xsplineGrob(id.lengths=...)``.
     default_units : str
         Unit type for bare numerics.
     shape : float or sequence of float
@@ -1439,9 +1450,16 @@ def xspline_grob(
     if np.any((shape_arr < -1) | (shape_arr > 1)):
         raise ValueError("all 'shape' values must be between -1 and 1")
 
+    id_arr = None if id is None else np.asarray(id, dtype=np.int64)
+    id_lengths_arr = (
+        None if id_lengths is None else np.asarray(id_lengths, dtype=np.int64)
+    )
+
     return Grob(
         x=x,
         y=y,
+        id=id_arr,
+        id_lengths=id_lengths_arr,
         shape=shape_arr,
         open_=bool(open_),
         arrow=arrow,
@@ -1456,6 +1474,8 @@ def xspline_grob(
 def grid_xspline(
     x: Optional[Any] = None,
     y: Optional[Any] = None,
+    id: Optional[Any] = None,
+    id_lengths: Optional[Any] = None,
     default_units: str = "npc",
     shape: Union[float, Sequence[float]] = 0.0,
     open_: bool = True,
@@ -1497,7 +1517,8 @@ def grid_xspline(
         The xspline grob.
     """
     grob = xspline_grob(
-        x=x, y=y, default_units=default_units,
+        x=x, y=y, id=id, id_lengths=id_lengths,
+        default_units=default_units,
         shape=shape, open_=open_, arrow=arrow,
         repEnds=repEnds, name=name, gp=gp, vp=vp,
     )

grid_py/_draw.py

@@ -215,7 +215,12 @@ def _draw_arrow_heads(
     try:
         l_w = float(renderer.resolve_w(length_unit, gp=gp))
         l_h = float(renderer.resolve_h(length_unit, gp=gp))
-    except Exception:
+    except (ValueError, AttributeError, TypeError) as exc:
+        warnings.warn(
+            f"arrow length cannot be resolved ({exc}); arrow head skipped",
+            UserWarning,
+            stacklevel=2,
+        )
         return
     length_dev = min(l_w, l_h)
     if not (length_dev > 0):
@@ -412,7 +417,15 @@ def _render_grob(
             xs, ys = _calc_xspline_points(
                 x, y, shape=shape_arr, open_=open_, repEnds=rep_ends,
             )
-            renderer.draw_polyline(xs, ys, id_=None, gp=gp)
+            # R's ``xsplineGrob(open=FALSE)`` is a *filled closed* shape, not
+            # a stroked path; route through ``draw_polygon`` so ``gp$fill``
+            # actually paints (R/grid: drawDetails.xspline → C_xspline,
+            # filled when ``open == FALSE``).  ``open=TRUE`` stays a stroked
+            # polyline.
+            if open_:
+                renderer.draw_polyline(xs, ys, id_=None, gp=gp)
+            else:
+                renderer.draw_polygon(xs, ys, gp=gp)
             if arr is not None and len(xs) >= 2:
                 _draw_arrow_heads(xs, ys, arr, renderer, gp)
         else:
@@ -436,12 +449,24 @@ def _render_grob(
                 out_id += 1
                 per_group.append((xs_g, ys_g))
             if all_xs:
-                renderer.draw_polyline(
-                    np.asarray(all_xs, dtype=float),
-                    np.asarray(all_ys, dtype=float),
-                    id_=np.asarray(all_ids, dtype=int),
-                    gp=gp,
-                )
+                # Multi-id closed splines render as N separate filled
+                # subpolygons (R: xsplineGrob(id=..., open=FALSE)); use
+                # ``draw_path`` with the path_id array.  Open splines stay
+                # multi-stroke polylines.
+                if open_:
+                    renderer.draw_polyline(
+                        np.asarray(all_xs, dtype=float),
+                        np.asarray(all_ys, dtype=float),
+                        id_=np.asarray(all_ids, dtype=int),
+                        gp=gp,
+                    )
+                else:
+                    renderer.draw_path(
+                        np.asarray(all_xs, dtype=float),
+                        np.asarray(all_ys, dtype=float),
+                        path_id=np.asarray(all_ids, dtype=int),
+                        gp=gp,
+                    )
                 if arr is not None:
                     for xs_g, ys_g in per_group:
                         if len(xs_g) >= 2:
@@ -564,15 +589,18 @@ def _render_grob(
         if image is None:
             image = getattr(grob, "image", None)
         if image is not None:
-            # Apply justification (same as rect_grob)
             hj, vj = _resolve_just(grob)
             raw_x = renderer.resolve_x(getattr(grob, "x", 0.0), gp=gp)
             raw_y = renderer.resolve_y(getattr(grob, "y", 0.0), gp=gp)
             raw_w = renderer.resolve_w(getattr(grob, "width", 1.0), gp=gp)
             raw_h = renderer.resolve_h(getattr(grob, "height", 1.0), gp=gp)
-            # Compute bottom-left corner from anchor + justification
+            # `renderer.draw_raster` expects the *top-left* corner in y-down
+            # device pixels. `resolve_y` already returns y-down coords, so the
+            # y component of justification must be flipped relative to R's
+            # `justifyY(y, h, vjust) = y - h*vjust` (which assumes y-up NPC).
+            # Same correction `draw_rect` applies (renderer.py:815).
             x0 = raw_x - raw_w * hj
-            y0 = raw_y - raw_h * vj
+            y0 = raw_y - raw_h * (1.0 - vj)
             renderer.draw_raster(
                 image=image,
                 x=x0,

grid_py/_gpar.py

@@ -20,14 +20,12 @@ __all__ = ["Gpar", "gpar", "get_gpar"]
 # Constants
 # ---------------------------------------------------------------------------
 
-_VALID_LTY: set[str] = {
-    "solid",
-    "dashed",
-    "dotted",
-    "dotdash",
-    "longdash",
-    "twodash",
-}
+# Derived from grid_py._lty so there is exactly one source of truth for
+# the named-lty set.  ``"blank"`` is added because R par/grid accepts it
+# even though it has no hex equivalent (it short-circuits the stroke).
+from ._lty import valid_named_lty as _valid_named_lty
+
+_VALID_LTY: frozenset[str] = _valid_named_lty()
 
 _VALID_LINEEND: set[str] = {"round", "butt", "square"}
 
@@ -77,9 +75,12 @@ def _as_list(value: Any) -> list:
     return [value]
 
 
-def _is_hex_lty(s: str) -> bool:
-    """Return True when *s* looks like a valid hex-string line-type spec."""
-    return all(c in "0123456789abcdefABCDEF" for c in s) and len(s) > 0
+# NOTE: ``_is_hex_lty`` used to live here.  It has been removed because
+# hex-string validity is now decided by ``grid_py._lty.resolve_lty``,
+# which is the single source of truth for both "is this lty valid?" and
+# "what dash array does it expand to?".  Keeping a separate validator
+# here would create the same kind of dual-source landmine that
+# motivated B7 in the first place.
 
 
 def _resolve_fontface(value: Any) -> int:
@@ -254,14 +255,19 @@ class Gpar:
                     ) from exc
 
             elif name == "lty":
+                # Validation delegates to grid_py._lty so accept/reject
+                # decisions match the renderer-time resolver exactly.
+                # ``resolve_lty`` raises ValueError on bad input with a
+                # message already containing the offending value, so we
+                # let it propagate (no try/except — principle 4).
+                from ._lty import is_blank_lty, resolve_lty
                 for v in vals:
-                    if isinstance(v, str):
-                        if v not in _VALID_LTY and not _is_hex_lty(v):
-                            raise ValueError(
-                                f"invalid line type '{v}'; must be one of "
-                                f"{sorted(_VALID_LTY)} or a hex string"
-                            )
-                    elif not isinstance(v, (int, float, np.integer, np.floating)):
+                    if is_blank_lty(v):
+                        continue
+                    if isinstance(v, (str, int, float, np.integer, np.floating)) \
+                       and not isinstance(v, bool):
+                        resolve_lty(v)   # raises ValueError if invalid
+                    else:
                         raise TypeError(
                             f"'lty' must be str or numeric, got {type(v).__name__}"
                         )
@@ -462,6 +468,26 @@ class Gpar:
         gp._params = merged
         return gp
 
+    # -- mod (R: mod.gpar) -------------------------------------------------
+
+    def _mod(self, new_gp: "Gpar") -> "Gpar":
+        """Edit-time merge (R ``mod.gpar`` — gpar.R:298-304).
+
+        Plain key overwrite — ``new_gp``'s keys replace ``self``'s keys,
+        unmentioned keys are kept unchanged. Unlike :meth:`_merge`
+        (which mirrors R ``set.gpar`` and multiplies cumulative
+        params like ``cex`` / ``alpha`` / ``lex``), this method is the
+        one used by ``editGrob`` and does NOT multiply — R's
+        ``mod.gpar`` does a single ``gp[names(newgp)] <- newgp``.
+        """
+        if not self._params:
+            return new_gp
+        merged = copy.deepcopy(self._params)
+        merged.update(copy.deepcopy(new_gp._params))
+        gp = object.__new__(Gpar)
+        gp._params = merged
+        return gp
+
     # -- display -----------------------------------------------------------
 
     def __repr__(self) -> str:

grid_py/_grob.py

@@ -1157,12 +1157,15 @@ def _edit_this_grob(grob: Grob, specs: dict[str, Any]) -> Grob:
         if not key:
             continue
         if key == "gp":
-            # Special handling: merge gpar
+            # Special handling — R editGrob uses ``mod.gpar`` (gpar.R:298-304)
+            # which does a plain key overwrite (``gp[names(newgp)] <- newgp``)
+            # *without* the cumulative cex/alpha/lex multiplication that
+            # viewport-push's ``set.gpar`` applies. ``Gpar._mod`` is the
+            # mirror; ``Gpar._merge`` is the cumulative one.
             if value is None:
                 grob._gp = None
             elif grob._gp is not None:
-                # Merge new gp on top of existing
-                grob._gp = grob._gp.merge(value) if hasattr(grob._gp, "merge") else value
+                grob._gp = grob._gp._mod(value)
             else:
                 grob._gp = value
         elif key == "name":

grid_py/_lty.py

@@ -0,0 +1,197 @@
+"""Linetype resolution — R-faithful port of GE_LTYpar + CairoLineType.
+
+This is the single source of truth for translating any R-accepted lty
+specification (named string, R integer 0..6, hex string of length
+{2,4,6,8}) into a Cairo / SVG ready dash array.  Both the Cairo and the
+Web renderers consume the same ``resolve_lty`` output, so any lty
+behaviour fix lands in exactly one place.
+
+R reference (R 4.5.3):
+    src/include/R_ext/GraphicsEngine.h:406-412   (LTY_* constants)
+    src/main/engine.c::GE_LTYpar                 (string -> 32-bit int)
+    src/library/grDevices/src/cairoFns.c::CairoLineType
+                                                 (int -> dash array)
+
+The cairo-dash scaling factor is *1.0*: ``set_dash([nibble * lwd, ...])``.
+This was empirically verified by reverse-engineering R's cairo PNG output
+(lty="44" at lwd in {1, 1.5, 2, 4, 6, 8} matches ``period = 2*nibble*lwd
++ 2*cap``, where cap ~= lwd for the default lineend="round").  A 0.75
+factor that appeared in early drafts of this file was a memory error
+(possibly conflated with a non-cairo R device) and would cause every
+dash pattern to shrink by 25 %.
+"""
+
+from __future__ import annotations
+
+from typing import Any, Optional, Sequence, Union
+
+import numpy as np
+
+__all__ = [
+    "resolve_lty",
+    "is_blank_lty",
+    "valid_named_lty",
+]
+
+
+# ---------------------------------------------------------------------------
+# R-gold constants (verbatim from R source, do not edit without R reference)
+# ---------------------------------------------------------------------------
+
+# GraphicsEngine.h:407-412 — every named lty is *also* expressible as a
+# hex string, so resolve_lty has a single parser code path.  Low nibble
+# of the integer constant sits in the leftmost character of the hex
+# string (R's GE_LTYpar packs bits low-to-high as it scans left-to-right).
+#   LTY_SOLID    = 0          ""
+#   LTY_DASHED   = 0x44       "44"
+#   LTY_DOTTED   = 0x31       -> low nibble 1, high nibble 3 -> "13"
+#   LTY_DOTDASH  = 0x3431                                     "1343"
+#   LTY_LONGDASH = 0x37                                       "73"
+#   LTY_TWODASH  = 0x2622                                     "2262"
+_LTY_NAMED_TO_HEX: dict[str, str] = {
+    "solid":    "",
+    "dashed":   "44",
+    "dotted":   "13",
+    "dotdash":  "1343",
+    "longdash": "73",
+    "twodash":  "2262",
+}
+
+# R ?par integer codes (user-facing).  Note that "user-facing 0" is BLANK,
+# *not* the internal LTY_SOLID=0 constant: GE_LTYpar maps user 0 -> internal
+# LTY_BLANK (-1) and user 1 -> internal LTY_SOLID (0).
+_LTY_INT_TO_NAME: dict[int, str] = {
+    1: "solid",
+    2: "dashed",
+    3: "dotted",
+    4: "dotdash",
+    5: "longdash",
+    6: "twodash",
+}
+
+# R-gold (empirically verified): GE_LTYpar rejects any hex string whose
+# length is not in {2, 4, 6, 8}.  Single nibble "F" -> "invalid line
+# type: must be length 2, 4, 6 or 8".
+_LTY_VALID_HEX_LENS: frozenset[int] = frozenset({2, 4, 6, 8})
+
+LtyInput = Union[str, int, float, None, list, tuple, np.ndarray]
+
+
+# ---------------------------------------------------------------------------
+# Public API
+# ---------------------------------------------------------------------------
+
+def valid_named_lty() -> frozenset[str]:
+    """Set of R named lty values accepted by Gpar (includes ``"blank"``)."""
+    return frozenset(_LTY_NAMED_TO_HEX.keys()) | {"blank"}
+
+
+def is_blank_lty(value: LtyInput) -> bool:
+    """True iff *value* represents R LTY_BLANK (caller should skip stroke).
+
+    Mirrors R par convention:
+      * user-facing integer 0   -> blank
+      * "blank" (string)        -> blank
+      * NA / None inside a Gpar list sentinel  -> blank
+      * **but** scalar ``None`` (no lty supplied) -> not blank (= solid)
+      * **but** string ``"0"`` -> not blank (R rejects len-1 hex; see
+        resolve_lty); we follow R's quirk and only treat *integer* 0 as
+        blank, not string "0".
+    """
+    if value is None:
+        return False
+    raw = value[0] if isinstance(value, (list, tuple, np.ndarray)) and len(value) else value
+    if raw is None:
+        return True
+    if isinstance(raw, (int, float, np.integer, np.floating)) and not isinstance(raw, bool):
+        return int(raw) == 0
+    return str(raw).lower() == "blank"
+
+
+def resolve_lty(value: LtyInput, lwd: float = 1.0) -> Optional[list[float]]:
+    """Resolve any R-accepted lty input into a Cairo-ready dash array.
+
+    Parameters
+    ----------
+    value : str | int | float | None | sequence
+        - ``None``                       -> solid
+        - One of ``valid_named_lty()``   -> the canonical hex pattern
+        - Hex string, length in {2,4,6,8} with chars [0-9A-Fa-f]
+        - Integer in 1..6 (R par convention; 0 is BLANK and must be
+          caught by ``is_blank_lty`` *before* calling this function)
+        - List/tuple/ndarray: first element is used (R recycling rule
+          is the caller's job)
+
+    Returns
+    -------
+    None or list[float]
+        - ``None`` for solid (no dashing)
+        - Otherwise the cairo ``set_dash`` array.  Each element is
+          ``hex_digit * lwd`` user-space units (or whatever space the
+          caller's ``lwd`` lives in — caller must keep lwd and dash in
+          the same coordinate system).
+
+    Raises
+    ------
+    ValueError
+        On unrecognised input.  Caller must invoke ``is_blank_lty``
+        first; passing a blank-representing value here raises.
+    """
+    if value is None:
+        return None
+    raw = value[0] if isinstance(value, (list, tuple, np.ndarray)) and len(value) else value
+    if raw is None:
+        # Caller forgot to short-circuit via is_blank_lty.  Fail loud
+        # (per principle 4 — do not silently convert blank to solid).
+        raise ValueError(
+            "blank lty (NA sentinel) must be handled by caller via is_blank_lty()"
+        )
+
+    # R integer path — par convention 1..6 (0 is BLANK, handled by caller).
+    if isinstance(raw, (int, float, np.integer, np.floating)) and not isinstance(raw, bool):
+        i = int(raw)
+        if i == 0:
+            raise ValueError(
+                "lty=0 is BLANK; caller must check is_blank_lty() before resolve_lty()"
+            )
+        if i not in _LTY_INT_TO_NAME:
+            raise ValueError(f"Invalid integer lty: {i!r} (must be in 1..6)")
+        raw = _LTY_INT_TO_NAME[i]
+
+    s = str(raw)
+
+    # Named lty -> canonical hex (single parser path below for both forms)
+    if s in _LTY_NAMED_TO_HEX:
+        s = _LTY_NAMED_TO_HEX[s]
+
+    if s == "":
+        return None   # solid
+
+    # Hex string validation — R GE_LTYpar rules (empirically verified):
+    #   non-hex char        -> "invalid hex digit in 'color' or 'lty'"
+    #   length not in 2/4/6/8 -> "invalid line type: must be length 2, 4, 6 or 8"
+    if not all(c in "0123456789abcdefABCDEF" for c in s):
+        raise ValueError(f"Invalid lty: {s!r} (invalid hex digit)")
+    if len(s) not in _LTY_VALID_HEX_LENS:
+        raise ValueError(
+            f"Invalid lty: {s!r} (length {len(s)} not in {{2,4,6,8}})"
+        )
+
+    # Cairo dash expansion — equivalent to R cairoFns.c::CairoLineType:
+    #     while (l < 8 && lty != 0) {
+    #         dt = lty & 15;
+    #         if (dt == 0) break;     // zero nibble terminates pattern
+    #         ls[l] = dt * lwd;       // scale factor 1.0 (R-verified)
+    #         lty = lty >> 4;
+    #         l++;
+    #     }
+    # R's length pre-check guarantees s is len 2/4/6/8, so the only place a
+    # zero nibble appears is at the *end* of a longer pattern (e.g. "4400"
+    # legitimately means [4, 4] then stop).
+    dashes: list[float] = []
+    for c in s:
+        d = int(c, 16)
+        if d == 0:
+            break
+        dashes.append(d * lwd)
+    return dashes if dashes else None

grid_py/_patterns.py

@@ -914,8 +914,13 @@ def _resolve_linear_gradient(grad: LinearGradient) -> ResolvedPattern:
             "stops": grad.stops,
             "extend": grad.extend,
         }
-    except Exception:
-        # Fallback: store the original gradient for later resolution
+    except (ValueError, AttributeError, TypeError, IndexError):
+        # Documented deferred-resolution fallback: when the gradient's
+        # endpoint Units can't be resolved against the current
+        # renderer state (e.g. ``"npc"`` outside a viewport), stash the
+        # original gradient so the renderer can resolve it later. R's
+        # ``resolvePattern.GridLinearGradient`` (patterns.R:401-418)
+        # delegates the same way via lazy attr lookup.
         ref = {"type": "linear_gradient", "pattern": grad}
 
     return ResolvedPattern(grad, ref)
@@ -949,7 +954,8 @@ def _resolve_radial_gradient(grad: RadialGradient) -> ResolvedPattern:
             "stops": grad.stops,
             "extend": grad.extend,
         }
-    except Exception:
+    except (ValueError, AttributeError, TypeError, IndexError):
+        # Deferred-resolution fallback — see ``_resolve_linear_gradient``.
         ref = {"type": "radial_gradient", "pattern": grad}
 
     return ResolvedPattern(grad, ref)
@@ -974,7 +980,8 @@ def _resolve_tiling_pattern(pat: Pattern) -> ResolvedPattern:
             "width": float(wh["w"][0]), "height": float(wh["h"][0]),
             "extend": pat.extend,
         }
-    except Exception:
+    except (ValueError, AttributeError, TypeError, IndexError):
+        # Deferred-resolution fallback — see ``_resolve_linear_gradient``.
         ref = {"type": "tiling_pattern", "pattern": pat}
 
     return ResolvedPattern(pat, ref)

grid_py/_primitives.py

@@ -20,6 +20,7 @@ rendering.  When ``draw=False`` the grob is simply returned.
 
 from __future__ import annotations
 
+import numpy as np
 from typing import (
     Any,
     Callable,
@@ -723,9 +724,13 @@ def points_grob(
     Parameters
     ----------
     x : Unit, numeric, or None
-        Horizontal coordinates.  When ``None`` a default is chosen.
+        Horizontal coordinates.  ``None`` mirrors R's
+        ``pointsGrob`` default of ``stats::runif(10)`` — 10 random
+        points drawn from ``np.random.uniform(0, 1, 10)``. The numpy
+        global RNG state controls reproducibility; seed via
+        ``np.random.seed(...)`` if you need deterministic output.
     y : Unit, numeric, or None
-        Vertical coordinates.  When ``None`` a default is chosen.
+        Vertical coordinates.  Same defaulting rule as *x*.
     size : Unit, numeric, or None
         Symbol size.  Defaults to ``Unit(1, "char")`` when ``None``.
     default_units : str
@@ -744,13 +749,21 @@ def points_grob(
     -------
     Grob
         A grob with ``_grid_class="points"``.
+
+    Notes
+    -----
+    R parity (primitives.R:1562-1563): ``pointsGrob`` defaults are
+    ``x = stats::runif(10), y = stats::runif(10)``. Every no-arg call
+    therefore produces a different scatter — this is a debug /
+    illustration default, not a deterministic API. Real usage should
+    pass explicit coordinates.
     """
     if x is None:
-        x = Unit(0.5, "npc")
+        x = Unit(np.random.uniform(0.0, 1.0, 10), default_units)
     else:
         x = _ensure_unit(x, default_units)
     if y is None:
-        y = Unit(0.5, "npc")
+        y = Unit(np.random.uniform(0.0, 1.0, 10), default_units)
     else:
         y = _ensure_unit(y, default_units)
     if size is None:
@@ -767,7 +780,7 @@ def grid_points(
     x: Any = None,
     y: Any = None,
     size: Optional[Any] = None,
-    default_units: str = "npc",
+    default_units: str = "native",
     pch: Union[int, str] = 1,
     name: Optional[str] = None,
     gp: Optional[Gpar] = None,

grid_py/_renderer_base.py

@@ -18,6 +18,7 @@ Coordinate pipeline (matches R's grid/src/unit.c + viewport.c):
 from __future__ import annotations
 
 import math
+import warnings
 from abc import ABC, abstractmethod
 from typing import Any, Dict, List, Optional, Sequence, Tuple, Union
 
@@ -369,7 +370,24 @@ class GridRenderer(ABC):
         return self.text_extents(text, gp=gp)
 
     def _do_apply_clip_vtr(self, vp: Any, vtr: ViewportTransformResult) -> None:
-        """Apply clipping for a viewport using its transform."""
+        """Apply clipping for a viewport using its transform.
+
+        Dispatches on the viewport's ``_clip`` value:
+
+        * ``True`` / ``"on"`` → rectangular clip to viewport bounds
+          (the long-standing default; ``_apply_clip_rect``)
+        * :class:`GridClipPath` → arbitrary clip path against the grob
+          stored in the GridClipPath (R 4.1+; ``_apply_clip_grob``)
+        * Anything else → no clip (push ``False`` so ``pop`` knows not
+          to restore)
+
+        ``_clip_stack`` stores the clip kind so ``pop_viewport`` can
+        decide whether to call ``_restore_clip`` (which undoes both
+        rect and path clips uniformly via the backend's save/restore
+        pair).
+        """
+        from ._clippath import GridClipPath
+
         clip = getattr(vp, "_clip", None)
         if clip is True or clip == "on":
             # Compute clip rect in device coords from the viewport bounds
@@ -384,6 +402,13 @@ class GridRenderer(ABC):
             y0_device = self._device_height - y0_bottom - ph
             self._apply_clip_rect(x0, y0_device, pw, ph)
             self._clip_stack.append(True)
+        elif isinstance(clip, GridClipPath):
+            # R viewport.R:86-96 — grob/path clip is honoured by
+            # rendering the grob's geometry into the renderer's
+            # current path then applying ``cairo_clip`` (or the web
+            # backend equivalent). Backend-specific.
+            self._apply_clip_grob(clip._grob, vtr)
+            self._clip_stack.append(clip)
         else:
             self._clip_stack.append(False)
 
@@ -425,8 +450,15 @@ class GridRenderer(ABC):
         from ._layout import _calc_layout_sizes, GridLayout
 
         if isinstance(layout, GridLayout):
+            # Use device-units-per-inch (= dpi for raster ImageSurface, 72 for
+            # vector PDF/SVG/PS surfaces) so that absolute units (cm/mm/in/pt
+            # …) get converted to the SAME unit as ``parent_w``/``parent_h``.
+            # Passing ``self.dpi`` blindly would, for vector surfaces, scale
+            # absolute widths by dpi while the parent is measured in points,
+            # over-allocating fixed cells by ``dpi/72`` and shrinking the
+            # null-unit panel by the same factor.
             col_widths, row_heights = _calc_layout_sizes(
-                layout, parent_w, parent_h, self.dpi,
+                layout, parent_w, parent_h, self._dev_units_per_inch,
             )
         else:
             nrow = getattr(layout, "nrow", 1)
@@ -531,7 +563,10 @@ class GridRenderer(ABC):
         try:
             from ._state import get_state
             return get_state()._scale
-        except Exception:
+        except (ImportError, AttributeError):
+            # Init-order edge: state module may not be importable during
+            # very early renderer construction. 1.0 is the documented
+            # default (R grid GSS_SCALE).
             return 1.0
 
     # ===================================================================== #
@@ -721,7 +756,16 @@ class GridRenderer(ABC):
             if grob.vp is not None:
                 _pop_grob_vp(grob.vp)
 
-        except Exception:
+        except (ValueError, AttributeError, TypeError, IndexError) as exc:
+            # Evaluating a grob unit (grobWidth/Height/Ascent/Descent of
+            # a user grob) requires the grob to have valid coords + a
+            # measurable ``*Details`` method. Bad inputs surface here as
+            # a warning rather than silently returning 0 (which would
+            # collapse the grob into a degenerate point).
+            warnings.warn(
+                f"grob unit evaluation failed; falling back to 0 inches: {exc}",
+                UserWarning, stacklevel=2,
+            )
             result = 0.0
         finally:
             # --- Restore state (R unit.c:561-562) ---
@@ -763,18 +807,35 @@ class GridRenderer(ABC):
             y_unit = Unit(0.5, "npc")
         try:
             x_inches = self._resolve_to_inches(x_unit, "x", False, gp)
-        except Exception:
+        except (ValueError, AttributeError, TypeError, IndexError) as exc:
+            warnings.warn(
+                f"grob x-coord could not be resolved; "
+                f"defaulting anchor to x=0 inches: {exc}",
+                UserWarning, stacklevel=2,
+            )
             x_inches = 0.0
         try:
             y_inches = self._resolve_to_inches(y_unit, "y", False, gp)
-        except Exception:
+        except (ValueError, AttributeError, TypeError, IndexError) as exc:
+            warnings.warn(
+                f"grob y-coord could not be resolved; "
+                f"defaulting anchor to y=0 inches: {exc}",
+                UserWarning, stacklevel=2,
+            )
             y_inches = 0.0
 
         # Width / height of the grob's bounding box, in inches.
         def _details_inches(fn, axis: str) -> float:
             try:
                 u = fn(grob)
-            except Exception:
+            except (ValueError, AttributeError, TypeError) as exc:
+                # User grob's ``width_details`` / ``height_details`` raised;
+                # surface so the user knows their grob is mis-implementing
+                # the size protocol.
+                warnings.warn(
+                    f"grob {fn.__name__} failed; using 0 inches: {exc}",
+                    UserWarning, stacklevel=2,
+                )
                 return 0.0
             if u is None:
                 return 0.0
@@ -784,7 +845,12 @@ class GridRenderer(ABC):
                 return 0.0
             try:
                 return float(self._resolve_to_inches(u, axis, True, gp))
-            except Exception:
+            except (ValueError, AttributeError, TypeError, IndexError) as exc:
+                warnings.warn(
+                    f"grob {axis}-dim unit could not be resolved; "
+                    f"using 0 inches: {exc}",
+                    UserWarning, stacklevel=2,
+                )
                 return 0.0
 
         w_in = _details_inches(width_details, "x")
@@ -1159,6 +1225,32 @@ class GridRenderer(ABC):
     def _restore_clip(self) -> None:
         ...
 
+    def _apply_clip_grob(self, grob: Any, vtr: ViewportTransformResult) -> None:
+        """Apply a grob-based clip path (R 4.1+ ``viewport(clip = grob)``).
+
+        Default implementation raises ``NotImplementedError`` — backends
+        that support arbitrary clip paths should override.  The standard
+        Cairo backend uses its existing ``_path_collecting`` mode to
+        render the grob's geometry into the current path then calls
+        ``ctx.clip()``; ``_restore_clip`` (paired with the implicit
+        ``ctx.save()`` here) reverts.
+
+        Parameters
+        ----------
+        grob : Grob
+            The grob whose geometry defines the clip path. Typically a
+            primitive (rect/circle/polygon/path); ``gTree`` is unioned.
+        vtr : ViewportTransformResult
+            The current viewport transform; backends that need to
+            push a temporary viewport before rendering the clip grob
+            should use this.
+        """
+        raise NotImplementedError(
+            f"{type(self).__name__} does not support grob/GridClipPath "
+            "viewport clips. Use clip='on' / 'off' / 'inherit', or a "
+            "renderer backend that implements ``_apply_clip_grob``."
+        )
+
     # ===================================================================== #
     # Abstract methods: graphics state save/restore                         #
     # ===================================================================== #

grid_py/_viewport.py

@@ -113,20 +113,29 @@ _CLIP_MAP = {
 def _valid_clip(clip: Any) -> Any:
     """Normalise *clip* to its internal representation.
 
+    R parity (viewport.R:86-97): ``viewport(clip = ...)`` accepts
+    string sentinels (``"on"``/``"off"``/``"inherit"``), booleans /
+    ``NA``, **and** a grob / ``GridPath`` / ``GridClipPath`` for
+    arbitrary clip-path masking (R 4.1+ feature). Grobs and GridPaths
+    are coerced to :class:`~grid_py.GridClipPath` exactly as R wraps
+    them via ``createClipPath(as.path(grob))``.
+
     Parameters
     ----------
-    clip : bool, str, or other
-        ``"on"`` -> ``True``, ``"off"`` -> ``None``, ``"inherit"`` -> ``False``.
-        Booleans and ``None`` pass through unchanged.
+    clip : bool, str, grob, GridPath, GridClipPath, or None
+        ``"on"`` → ``True``, ``"off"`` → ``None``, ``"inherit"`` →
+        ``False``. Booleans and ``None`` pass through unchanged. Grob /
+        GridPath / GridClipPath produce a :class:`GridClipPath` (the
+        renderer dispatches on this type at viewport-push time).
 
     Returns
     -------
-    bool or None
+    bool, None, or GridClipPath
 
     Raises
     ------
     ValueError
-        If *clip* is a string that is not one of the accepted values.
+        If *clip* is none of the accepted shapes.
     """
     if isinstance(clip, bool) or clip is None:
         return clip
@@ -135,13 +144,25 @@ def _valid_clip(clip: Any) -> Any:
         if val is None and clip.lower() != "off":
             raise ValueError(
                 f"invalid 'clip' value {clip!r}; "
-                "must be 'on', 'off', 'inherit', or a boolean"
+                "must be 'on', 'off', 'inherit', a boolean, or a grob / "
+                "GridPath / GridClipPath"
             )
         # "off" -> None is correct from the map
         return _CLIP_MAP.get(clip.lower(), None)
+    # R 4.1+: grob / GridPath / GridClipPath as clip
+    from ._clippath import GridClipPath, as_clip_path
+    if isinstance(clip, GridClipPath):
+        return clip
+    from ._path import GridPath
+    if isinstance(clip, GridPath):
+        return as_clip_path(clip)
+    from ._grob import Grob
+    if isinstance(clip, Grob):
+        return as_clip_path(clip)
     raise ValueError(
         f"invalid 'clip' value {clip!r}; "
-        "must be 'on', 'off', 'inherit', or a boolean"
+        "must be 'on', 'off', 'inherit', a boolean, or a grob / "
+        "GridPath / GridClipPath"
     )
 
 

grid_py/renderer.py

@@ -13,6 +13,7 @@ from __future__ import annotations
 
 import io
 import math
+import warnings
 from typing import Any, Dict, List, Optional, Sequence, Tuple, Union
 
 import numpy as np
@@ -27,6 +28,7 @@ except ImportError:
 
 from ._colour import parse_r_colour as _parse_colour
 from ._gpar import Gpar
+from ._lty import is_blank_lty, resolve_lty
 from ._patterns import LinearGradient, RadialGradient, Pattern
 from ._renderer_base import GridRenderer
 
@@ -40,28 +42,12 @@ __all__ = ["CairoRenderer"]
 # Line-type mapping
 # ---------------------------------------------------------------------------
 
-_LTY_DASHES: Dict[str, Optional[Sequence[float]]] = {
-    "solid": None,
-    "dashed": [6.0, 4.0],
-    "dotted": [2.0, 2.0],
-    "dotdash": [2.0, 2.0, 6.0, 2.0],
-    "longdash": [10.0, 3.0],
-    "twodash": [5.0, 2.0, 10.0, 2.0],
-    "blank": [0.0, 100.0],
-}
-
-# R allows ``lty`` to be an integer 0..6 (par docs): 0=blank, 1=solid,
-# 2=dashed, 3=dotted, 4=dotdash, 5=longdash, 6=twodash.  Map to the
-# named equivalents so downstream dash lookup works for both forms.
-_LTY_INT_TO_NAME: Dict[int, str] = {
-    0: "blank",
-    1: "solid",
-    2: "dashed",
-    3: "dotted",
-    4: "dotdash",
-    5: "longdash",
-    6: "twodash",
-}
+# Linetype dash arrays come from grid_py._lty.resolve_lty (single source
+# of truth, shared with the Web renderer).  The legacy ``_LTY_DASHES``
+# table and ``_LTY_INT_TO_NAME`` dict used to live here; they have been
+# removed because their dash values were not R-faithful (e.g. "dashed"
+# resolved to [6, 4] instead of R's [4, 4]) and they offered no path for
+# hex-string lty.  See grid_py/_lty.py for the R-verified replacement.
 
 _LINEEND_MAP = {
     "round": cairo.LINE_CAP_ROUND,
@@ -141,6 +127,17 @@ class CairoRenderer(GridRenderer):
             if filename is None:
                 raise ValueError("filename is required for SVG surface")
             self._surface = cairo.SVGSurface(filename, width_pt, height_pt)
+            # Cairo's SVGSurface measures user-space in points; emit explicit
+            # ``pt`` units in the resulting <svg width="...pt" height="...pt">
+            # so SVG renderers (browsers, cairosvg, Inkscape) interpret the
+            # canvas at the intended physical size instead of treating the
+            # raw numbers as user-units (= pixels by SVG default).
+            try:
+                self._surface.set_document_unit(cairo.SVG_UNIT_PT)
+            except (AttributeError, TypeError):
+                # Older pycairo / cairo without set_document_unit — file is
+                # still well-formed, just unit-less.
+                pass
         elif surface_type == "ps":
             if filename is None:
                 raise ValueError("filename is required for PS surface")
@@ -170,6 +167,33 @@ class CairoRenderer(GridRenderer):
         self._ctx.rectangle(x0, y0, w, h)
         self._ctx.clip()
 
+    def _apply_clip_grob(self, grob, vtr):
+        """Apply a grob-based clip path (R 4.1+ ``viewport(clip=grob)``).
+
+        Re-uses the existing ``_path_collecting`` mode (originally for
+        R 4.2+ ``fillStroke`` grobs): primitives drop their stroke /
+        fill calls but still emit Cairo path commands. After the
+        grob's geometry is in the current path we call ``ctx.clip()``;
+        the matching ``ctx.save()`` here pairs with the standard
+        ``_restore_clip`` (``ctx.restore()``) on viewport pop, so
+        non-rect clips share the same pop machinery as rect clips.
+        """
+        ctx = self._ctx
+        ctx.save()
+        # Mirrors begin_path_collect but inline because we manage
+        # save/restore ourselves above.
+        ctx.new_path()
+        prior_mode = self._path_collecting
+        self._path_collecting = True
+        try:
+            # Use the standard draw pipeline so per-primitive coord /
+            # unit / gp handling stays in one place.
+            from ._draw import grid_draw
+            grid_draw(grob, recording=False)
+        finally:
+            self._path_collecting = prior_mode
+        ctx.clip()
+
     def _restore_clip(self) -> None:
         self._ctx.restore()
 
@@ -285,7 +309,14 @@ class CairoRenderer(GridRenderer):
                 grid_draw(mask_grob, recording=False)
             finally:
                 state._renderer = orig_renderer
-        except Exception:
+        except Exception as exc:
+            # Mask grob is user code — any exception is possible. Surface
+            # it as a warning so the user knows their mask didn't render,
+            # but don't crash the whole plot.
+            warnings.warn(
+                f"mask grob render failed; mask skipped: {exc}",
+                UserWarning, stacklevel=2,
+            )
             return None
 
         return mask_surface
@@ -322,6 +353,38 @@ class CairoRenderer(GridRenderer):
 
     # ---- gpar application --------------------------------------------------
 
+    def _lwd_to_user(self, lwd_pt: float) -> float:
+        """Convert R-grid lwd (points) to a Cairo user-space line width.
+
+        R's grid measures ``lwd`` in 1/72 inch (points) regardless of the
+        active viewport scale — a value of 1 should always produce a stroke
+        1pt wide on the output medium.  Cairo's ``set_line_width`` takes a
+        user-space distance, so we have to:
+
+        1. Map points → device units.  Raster ``ImageSurface`` has 1 user
+           unit = 1 pixel, so device units per point = ``dpi/72``.  Vector
+           surfaces (PDF/SVG/PS) have 1 user unit = 1 pt, so the conversion
+           factor is 1.0.  Equivalently, use ``_dev_units_per_inch / 72``.
+        2. Undo any active CTM scaling via ``device_to_user_distance`` so
+           that nested viewports (which scale the CTM) do not also scale
+           the stroke.
+
+        This is the analogue of the font-size handling in ``_set_font``.
+        """
+        if self._surface_type == "image":
+            lw_dev = lwd_pt * self.dpi / 72.0
+        else:
+            lw_dev = lwd_pt
+        try:
+            ux, uy = self._ctx.device_to_user_distance(lw_dev, lw_dev)
+            return max(abs(ux), abs(uy))
+        except cairo.Error:
+            # Cairo can refuse the conversion when the user-space matrix
+            # is singular (e.g. zero-area viewport). Fall back to the
+            # device value — this is graceful degradation, not a bug
+            # to surface.
+            return lw_dev
+
     def _apply_stroke(self, gp: Optional[Gpar]) -> Tuple[float, float, float, float]:
         """Set stroke colour, line width, dash, caps, joins from Gpar.
 
@@ -331,7 +394,7 @@ class CairoRenderer(GridRenderer):
         ctx = self._ctx
         if gp is None:
             ctx.set_source_rgba(0, 0, 0, 1)
-            ctx.set_line_width(1.0)
+            ctx.set_line_width(self._lwd_to_user(1.0))
             return (0.0, 0.0, 0.0, 1.0)
 
         col = gp.get("col", None)
@@ -367,40 +430,27 @@ class CairoRenderer(GridRenderer):
         # R semantics: lwd=0 means invisible line
         if lw <= 0:
             return (0.0, 0.0, 0.0, 0.0)
-        # R grid semantics: ``lwd`` is always in **points** (1/72 inch)
-        # regardless of the current viewport's scale.  Cairo's
-        # ``set_line_width`` takes a user-space distance, which the
-        # viewport CTM has scaled down to NPC-like units — so a value
-        # of 0.5 user-space becomes sub-pixel after ``scale(w, h)``.
-        # Convert ``lw`` from points → device pixels using the
-        # renderer's DPI, then back to user-space via
-        # ``device_to_user_distance`` so the stroke width stays at
-        # 0.5pt on the output device no matter how deep the
-        # viewport stack is (matches R grid's device-unit lwd).
-        dpi = getattr(self, "dpi", None) or getattr(self, "_dpi", 72.0) or 72.0
-        lw_px = lw * dpi / 72.0
-        try:
-            ux, uy = ctx.device_to_user_distance(lw_px, lw_px)
-            lw_user = max(abs(ux), abs(uy))
-        except Exception:
-            lw_user = lw
+        # lwd is supplied in R points; convert to user-space units once
+        # so set_line_width AND the dash array (below) share coordinates.
+        lw_user = self._lwd_to_user(lw)
         ctx.set_line_width(lw_user)
 
+        # lty handling — single source of truth in grid_py/_lty.py.
+        # Short-circuit pattern is symmetric with the col=NA and lwd<=0
+        # branches above: ``Gpar(lty=NA)`` / ``Gpar(lty=0)`` skip the
+        # stroke entirely (R par convention).
         lty = gp.get("lty", None)
-        if lty is not None:
-            raw = lty[0] if isinstance(lty, (list, tuple)) else lty
-            # R integer code (0..6) → name
-            if isinstance(raw, (int, float, np.integer, np.floating)) and \
-               not isinstance(raw, bool):
-                raw = _LTY_INT_TO_NAME.get(int(raw), str(raw))
-            lty_val = str(raw)
-            dashes = _LTY_DASHES.get(lty_val)
-            if dashes is not None:
-                ctx.set_dash(dashes)
-            else:
-                ctx.set_dash([])
-        else:
+        if is_blank_lty(lty):
+            return (0.0, 0.0, 0.0, 0.0)
+        if lty is None:
             ctx.set_dash([])
+        else:
+            # lwd lives in *user space* after ``_lwd_to_user`` (see
+            # commit ef7aee5 for the historical CTM regression that
+            # established this).  resolve_lty must receive the same
+            # space so set_dash and set_line_width share coordinates.
+            dashes = resolve_lty(lty, lwd=lw_user)
+            ctx.set_dash(dashes if dashes else [])
 
         lineend = gp.get("lineend", None)
         if lineend is not None:
@@ -663,8 +713,14 @@ class CairoRenderer(GridRenderer):
                 grid_draw(pat.grob, recording=False)
             finally:
                 state._renderer = orig_renderer
-        except Exception:
-            # If grob rendering fails, return transparent
+        except Exception as exc:
+            # Tiling-pattern grob is user code — surface failures so the
+            # user knows their pattern fell back to transparent.
+            warnings.warn(
+                f"tiling pattern grob render failed; "
+                f"falling back to transparent: {exc}",
+                UserWarning, stacklevel=2,
+            )
             return (0.0, 0.0, 0.0, 0.0)
 
         tile_surface = tile_renderer._surface
@@ -1197,7 +1253,7 @@ class CairoRenderer(GridRenderer):
         """
         ctx.save()
         ctx.new_path()  # clear any residual path from prior draws
-        ctx.set_line_width(lwd)
+        ctx.set_line_width(self._lwd_to_user(lwd))
 
         if pch_val <= 14:
             # --- Group 0-14: stroke-only (use col for outline, no fill) ---
@@ -1720,7 +1776,11 @@ class CairoRenderer(GridRenderer):
             result = ctx.pop_group()
             return result
 
-        except Exception:
+        except cairo.Error as exc:
+            warnings.warn(
+                f"group composition failed (cairo): {exc}",
+                UserWarning, stacklevel=2,
+            )
             return None
 
     def use_group(self, ref: Any, transform: Any = None) -> None:

grid_py/renderer_web.py

@@ -17,6 +17,7 @@ import numpy as np
 
 from ._font_metrics import get_font_backend, FontMetricsBackend
 from ._gpar import Gpar
+from ._lty import is_blank_lty, resolve_lty
 from ._patterns import LinearGradient, RadialGradient, Pattern
 from ._renderer_base import GridRenderer
 from ._scene_graph import (
@@ -38,11 +39,20 @@ from ._colour import colour_to_css as _parse_colour_str
 
 
 def _serialise_gpar(gp: Optional[Gpar], defs: DefsCollection, id_gen: _IdGenerator) -> dict:
-    """Convert Gpar to a JSON-safe dict.  Gradient/pattern fills become def refs."""
+    """Convert Gpar to a JSON-safe dict.  Gradient/pattern fills become def refs.
+
+    Linetype handling: ``gpar.lty`` is *not* transmitted to JS as a string.
+    Instead we pre-resolve it to a numeric dash array via
+    :func:`grid_py._lty.resolve_lty` (R-faithful) and emit it as
+    ``result["dash"]``.  ``Gpar(lty=NA)`` (blank) becomes
+    ``result["skip_stroke"] = True``.  This collapses all R lty knowledge
+    into one Python module — the JS side just paints whatever array it
+    receives.
+    """
     if gp is None:
         return {}
     result: Dict[str, Any] = {}
-    for key in ("col", "fill", "lwd", "lty", "lineend", "linejoin",
+    for key in ("col", "fill", "lwd", "lineend", "linejoin",
                 "fontsize", "fontfamily", "fontface", "alpha"):
         val = gp.get(key, None)
         if val is None:
@@ -80,6 +90,25 @@ def _serialise_gpar(gp: Optional[Gpar], defs: DefsCollection, id_gen: _IdGenerat
             result[key] = float(val)
         else:
             result[key] = str(val) if not isinstance(val, (int, float)) else val
+
+    # ---- lty -> dash array (single source of truth via _lty.resolve_lty) ----
+    # Web backend lwd convention: raw R points (matches the unconverted
+    # ``result["lwd"] = float(...)`` we just emitted, which is what JS
+    # passes verbatim to SVG `stroke-width`).  SVG `stroke-dasharray`
+    # does *not* auto-scale with stroke-width, so the resolver pre-multiplies
+    # ``nibble × lwd`` here; the two end up in the same coordinate space.
+    lty_in = gp.get("lty", None)
+    if lty_in is not None and (not isinstance(lty_in, (list, tuple, np.ndarray)) or len(lty_in) > 0):
+        if is_blank_lty(lty_in):
+            result["skip_stroke"] = True
+        else:
+            lwd_raw_in = gp.get("lwd", None)
+            if isinstance(lwd_raw_in, (list, tuple, np.ndarray)) and len(lwd_raw_in):
+                lwd_raw_in = lwd_raw_in[0]
+            lwd_raw = float(lwd_raw_in) if lwd_raw_in is not None else 1.0
+            dash = resolve_lty(lty_in, lwd=lwd_raw)
+            if dash is not None:
+                result["dash"] = dash
     return result
 
 

grid_py/resources/gridpy.js

@@ -24,13 +24,24 @@ var gridpy = (function () {
 
     function applyGparSvg(sel, gpar) {
         if (!gpar) return;
+        // skip_stroke is set by the Python serializer for blank lty
+        // (R LTY_BLANK) — mirrors col=NA short-circuit.
+        if (gpar.skip_stroke) {
+            sel.attr("stroke", "none");
+            return;
+        }
         var fill = parseColour(gpar.fill);
         var col = parseColour(gpar.col);
         if (fill !== undefined) sel.attr("fill", fill || "none");
         if (col !== undefined) sel.attr("stroke", col || "none");
         if (gpar.lwd !== undefined) sel.attr("stroke-width", gpar.lwd);
         if (gpar.alpha !== undefined) sel.attr("opacity", gpar.alpha);
-        if (gpar.lty) sel.attr("stroke-dasharray", ltyToDash(gpar.lty));
+        // gpar.dash is the R-faithful dash array pre-resolved by
+        // grid_py._lty.resolve_lty (single source of truth shared with
+        // the Cairo backend).  No JS-side lty knowledge needed.
+        if (gpar.dash && gpar.dash.length > 0) {
+            sel.attr("stroke-dasharray", gpar.dash.join(","));
+        }
         if (gpar.lineend) sel.attr("stroke-linecap", gpar.lineend);
         if (gpar.linejoin) sel.attr("stroke-linejoin",
             gpar.linejoin === "mitre" ? "miter" : gpar.linejoin);
@@ -55,6 +66,12 @@ var gridpy = (function () {
 
     function applyGparCanvas(ctx, gpar) {
         if (!gpar) return;
+        if (gpar.skip_stroke) {
+            // R LTY_BLANK — short-circuit by zeroing stroke alpha.
+            ctx.strokeStyle = "rgba(0,0,0,0)";
+            ctx.setLineDash([]);
+            return;
+        }
         var fill = parseColour(gpar.fill);
         var col = parseColour(gpar.col);
         ctx.fillStyle = fill || "rgba(0,0,0,0)";
@@ -64,30 +81,10 @@ var gridpy = (function () {
         if (gpar.lineend) ctx.lineCap = gpar.lineend;
         if (gpar.linejoin) ctx.lineJoin =
             gpar.linejoin === "mitre" ? "miter" : (gpar.linejoin || "round");
-        if (gpar.lty) {
-            var dash = ltyToDashArray(gpar.lty);
-            ctx.setLineDash(dash || []);
-        } else {
-            ctx.setLineDash([]);
-        }
-    }
-
-    function ltyToDash(lty) {
-        var map = {
-            "dashed": "6,4", "dotted": "2,2",
-            "dotdash": "2,2,6,2", "longdash": "10,3",
-            "twodash": "5,2,10,2", "blank": "0,100"
-        };
-        return map[lty] || null;
-    }
-
-    function ltyToDashArray(lty) {
-        var map = {
-            "dashed": [6, 4], "dotted": [2, 2],
-            "dotdash": [2, 2, 6, 2], "longdash": [10, 3],
-            "twodash": [5, 2, 10, 2], "blank": [0, 100]
-        };
-        return map[lty] || [];
+        // gpar.dash is the pre-resolved cairo-style dash array from the
+        // Python side (grid_py._lty.resolve_lty).  See applyGparSvg for
+        // the rationale.
+        ctx.setLineDash(gpar.dash || []);
     }
 
     function hjustToAnchor(hj) {

{rgrid_python-4.5.3.post2.dist-info → rgrid_python-4.5.3.post4.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: rgrid-python
-Version: 4.5.3.post2
+Version: 4.5.3.post4
 Summary: Python port of the R grid package (tracks R grid 4.5.3)
 Project-URL: Homepage, https://github.com/Bio-Babel/grid_py
 Project-URL: Repository, https://github.com/Bio-Babel/grid_py

{rgrid_python-4.5.3.post2.dist-info → rgrid_python-4.5.3.post4.dist-info}/RECORD

@@ -1,26 +1,27 @@
-grid_py/__init__.py,sha256=UWOAMmQkCKI5H7Kx1yPSwFvI6pLQRci2jVDURr8d6H8,10520
+grid_py/__init__.py,sha256=K_SAUQUXVz-7mYQEYPWR9_5aWLPJjUdhu1nVSunpk_I,10520
 grid_py/_arrow.py,sha256=pgn4OCgF6TZY2yXl7ML-kt08DbwqlvT1ulApDcmRz4k,10867
 grid_py/_clippath.py,sha256=p6fUAkcEc5Bg8chv-lIZwaOjEUbLK57duwjtIpDjAkw,4015
 grid_py/_colour.py,sha256=WqaxGop-SM1LYZG4uMPmMX3Zjh6Y_ip0HcanP5wEij8,22872
 grid_py/_coords.py,sha256=9cDD3MWHmw9TnT1I8QKHQA96SCG06OxRXNqYGFZsfwg,47210
-grid_py/_curve.py,sha256=MV7hl1MR-4FZfKBKEm4MCSvHgJLYP9UaWLp8eHXPhv0,54041
+grid_py/_curve.py,sha256=QnUkh9lWLd0OSm7h7QwS78JjzBAu9WHmRY4ZpZhccpY,54989
 grid_py/_display_list.py,sha256=uMFAupSJaCgUCbLMv2-RDBQ-YLxCkAldypRqc7CnF3w,13622
-grid_py/_draw.py,sha256=seDvNzkxz3PYcWLeI6MXQ80elWaY18HgfyKshr2cMl0,49662
+grid_py/_draw.py,sha256=YR2JYfOspg3MRb-vR47ebhBJq3pKJZ7QMarkcVNHkNA,51150
 grid_py/_edit.py,sha256=vQDZGBTTYy6DmlW33l94s1KJLrzPNym21NR4Od4qIFw,22263
 grid_py/_font_metrics.py,sha256=XC_dgIN3eB72VPXIRFU-tynnS3wJl3bPugGHrwVzyeo,11086
-grid_py/_gpar.py,sha256=AW3PNlD7UWOozzZvY5Y3f7ZGTWCTRnOs2YqOvlFD1_A,19757
+grid_py/_gpar.py,sha256=Bsq5oevTOf-ISb6T1K4cqPcA7UKX0XHbg-AddMomWzQ,21302
 grid_py/_grab.py,sha256=XAPdYG2gyl9Px29xM_rByIPA2NwuvkbFaLcHGrqpaUQ,15423
-grid_py/_grob.py,sha256=kHSxkPHWqHHyMVum7ueKS-ddDqFF2E-8tUQOM-azEXU,39992
+grid_py/_grob.py,sha256=pxbXCt5aYstiBKLw3TyII_avZOZVLR79eSoWi_bE2Ag,40224
 grid_py/_group.py,sha256=jmPQPcy_lrVjurF8w5ovhCXvwKLBeGVkOwAvX0X0gA0,22828
 grid_py/_highlevel.py,sha256=KVcFc0aUm6WBGyNKlYJfZ16qC4bRolng8ZKb86lSLpc,61803
 grid_py/_just.py,sha256=lh9ar8lw6JRqZE5qHP4Wx7GHPIW0y7Wp0EgJ7vhFjek,10590
 grid_py/_layout.py,sha256=opOEvxTO2gjwuLEt8sbKjp4yexjnx0Gik6d95yoL3aI,19721
 grid_py/_ls.py,sha256=RhUGZJCZkcTUjUK97fft_G4D9KxuyBr3OMFhzC5IShc,25547
+grid_py/_lty.py,sha256=ciQKy_P_QmJbmYTsSeQY8cGxXvnrowJbBS-Zzf4birE,7762
 grid_py/_mask.py,sha256=d2Wm2z-RJnfEKHdAHcjteL7VubimcaK1_f9Us9MfrUk,4902
 grid_py/_path.py,sha256=Tr5bNNcGwPpOsxWKqEp65MRri-KV8IqplUh2Z90sxnk,11421
-grid_py/_patterns.py,sha256=PBwV2b3oJkbueTLCku6cxeZ1PThREjiPcA6lmrwH3pE,32691
-grid_py/_primitives.py,sha256=dpX5_q5CS8p1vhuVzTa77MVbtaxigGBA5mmUzfFfHks,58861
-grid_py/_renderer_base.py,sha256=-wZYsKXaetQw1wPDsjUJoJffIDmjEVZN6P_lj5xOPT4,54239
+grid_py/_patterns.py,sha256=t6IkayYPaupEbF9bFZQmS0iXZhB9TWrvN2xRZzR7baA,33302
+grid_py/_primitives.py,sha256=Aq0fCdsy-eJ57v_X9JeFlsmm62jEZMlEOuK3u3v6YEg,59522
+grid_py/_renderer_base.py,sha256=wECYIgNR2UNXXneWoaJspbBkclBTxTbM3in5Hva7nNY,59011
 grid_py/_scene_graph.py,sha256=mKhNEMkUolbWt4_CFgGhrGUudrYenxFNXaBp6GLN9_Y,7412
 grid_py/_size.py,sha256=q9yYdhO7dcp-RtQzJIIsXssFH5oFbsm5_P6UxZlFKjg,43312
 grid_py/_state.py,sha256=SsEzcicTmxWaGExDeLLNNVXT-G38aUFtgSuZTJEYBbw,22800
@@ -28,15 +29,15 @@ grid_py/_transforms.py,sha256=mQvs_Qm6icti66peLXTsjgmSmvIUCCphf_-D-tiE1O4,11675
 grid_py/_typeset.py,sha256=J_PJ5YcOAOnnFkBfo8IW86utJdkdsrnGZi3MvnHc8io,11516
 grid_py/_units.py,sha256=bGrHV23Vr2A6lO15LJvcP7Qs1Yx_uQJLmyQ6bRB3yjc,61893
 grid_py/_utils.py,sha256=QaWNkCF3BbPHyrqPPRxN7Ji2vB5ethNwVT3SJ1ad9Lc,8335
-grid_py/_viewport.py,sha256=AOrYmv05Y4QJbsTksn86RLStfHdbOHERc2YDHdZAekE,48477
+grid_py/_viewport.py,sha256=qscv8eRKt0vHH0osxZUkbwM9PfgZwTKXi8n7L8921DE,49490
 grid_py/_vp_calc.py,sha256=v0MJc-YmWohO5t7LHFopk5ogH-Sink_A_zNFV_1769w,32935
 grid_py/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-grid_py/renderer.py,sha256=hzCRgHMrR8tFpsdqT1al09gnZhgShoe_kIEO4MTYZNY,61620
-grid_py/renderer_web.py,sha256=pbOijES1eUUqkeAadXVyZPCBRIUIgzs3HIOgAElTYmo,27958
+grid_py/renderer.py,sha256=DlzC7srfqZ0JRpEUddjwX39Kw4PUg9-FDH57-sI1RcQ,65093
+grid_py/renderer_web.py,sha256=ntbLwcvTJNz_S0xRNGweiZmrkThUfW1AvCCCDSn2vSY,29461
 grid_py/resources/d3.v7.min.js,sha256=8glLv2FBs1lyLE_kVOtsSw8OQswQzHr5IfwVj864ZTk,279706
 grid_py/resources/gridpy.css,sha256=tR5LF2rLvi_bGRWuH9CnmLQk-aG2f-jlZjQZqS7_4uY,1351
-grid_py/resources/gridpy.js,sha256=l8KGgK-qZbJPVvrMAmLUu57RhpSAo_LMibs6rx3RnvA,28340
-rgrid_python-4.5.3.post2.dist-info/METADATA,sha256=uGrI2aBhk9PL1tjCk4izXQNr0niwxEGVhjbI4eOpmJM,19910
-rgrid_python-4.5.3.post2.dist-info/WHEEL,sha256=QccIxa26bgl1E6uMy58deGWi-0aeIkkangHcxk2kWfw,87
-rgrid_python-4.5.3.post2.dist-info/licenses/LICENSE,sha256=8zNQKZlkc4JOaW7br_a8aALg4baZwZkLKLTQx3kuHkc,48
-rgrid_python-4.5.3.post2.dist-info/RECORD,,
+grid_py/resources/gridpy.js,sha256=ekbmsIMCJU9ZqIU0WC1c-Y-LBEinGIL8UftFEVF9pC4,28555
+rgrid_python-4.5.3.post4.dist-info/METADATA,sha256=3sNILdeJwNGhe9zFPrssIt90C_csOUrrrd7Ad6Uw3IY,19910
+rgrid_python-4.5.3.post4.dist-info/WHEEL,sha256=QccIxa26bgl1E6uMy58deGWi-0aeIkkangHcxk2kWfw,87
+rgrid_python-4.5.3.post4.dist-info/licenses/LICENSE,sha256=8zNQKZlkc4JOaW7br_a8aALg4baZwZkLKLTQx3kuHkc,48
+rgrid_python-4.5.3.post4.dist-info/RECORD,,