plot-io 0.12.0__py3-none-win_amd64.whl

plot_io/legend.py

@@ -0,0 +1,605 @@
+"""Legend layout and drawing: one entry per named series."""
+
+import math
+from typing import Any
+
+from vec_io import Path
+from vec_io.arrays import doubles
+
+from .canvas import Canvas
+from ._methods import SizeLegendMixin
+from .color.values import resolve_color, with_alpha
+from .settings import Setting, Settings, table, text
+from .validators import length
+from .shapes import swatch
+from .text import Font, draw_run, font_of, measure, run
+
+__all__ = ["Entries", "SizeRows", "SizeKey", "size_key_values"]
+
+def size_key_values(axis: Any, given: Any = None) -> list[float]:
+    """Values shown in the size key of a trained size axis: ``given``, else the axis'
+    ``ticks``, else 3–5 nice numbers inside its limits."""
+    from .mapped import trained
+    from .ticks import numeric_ticks
+    if isinstance(given, (list, tuple)):
+        return [float(v) for v in given]
+    ticks = axis.resolve("ticks")
+    if isinstance(ticks, list):
+        return [float(v) for v in ticks]
+    st = trained(axis)
+    scale = st.scale
+    assert scale is not None
+    lo, hi = sorted((st.lo, st.hi))
+    eps = (hi - lo) * 1e-9
+    vals: list[float] = []
+    for most in (4, 5, 6, 8):
+        tk, _ = numeric_ticks(scale, lo, hi, most, minor=False, length=133.0)
+        vals = [t.value for t in tk if t.major and lo - eps <= t.value <= hi + eps
+                and (t.value > 0 or scale.name != "linear" or lo <= 0)]
+        if len(vals) >= 3:
+            break
+    return vals if len(vals) >= 2 else [lo, hi]
+
+
+def size_key_labels(axis: Any, values: list[float], plot: Any) -> list[Any]:
+    """The labels of a size key's values: the axis' ``tick_format`` and number format."""
+    from .numbers import NumberStyle, format_numbers
+    fmt = axis.resolve("tick_format")
+    if fmt == "auto" and plot is not None:
+        return format_numbers(values, "auto", plot)
+    return format_numbers(values, fmt, NumberStyle.of(axis), "tick_format")
+
+
+def _named(label: Any) -> bool:
+    """Whether a legend label has text (``name=""`` makes no entry)."""
+    return not (label is None or (isinstance(label, (str, list, tuple)) and not label))
+
+
+class SizeKey:
+    """Entries of a size key: a header (the size axis' label) and sample markers."""
+
+    header = False
+
+    def __init__(self, axis: Any, series: list[Any], values: list[float], labels: list[Any],
+                 title: Any) -> None:
+        self.axis = axis
+        self.series = series
+        self.values = values
+        self.labels = labels
+        self.title = title
+
+    def sizes(self) -> list[float]:
+        from .markers import area_factor
+        from .mapped import trained
+        st = trained(self.axis)
+        assert st.scale is not None
+        s = self.series[0]
+        d = self.axis.size_map().map(doubles(self.values), st.flo, st.fhi,
+                                     st.scale.function, s)
+        marker = s.resolve("marker") if "marker" in s.SETTINGS else "circle"
+        marker = marker[0] if isinstance(marker, list) else marker
+        factor = area_factor(marker) if s.resolve("size_basis") == "area" else 1.0
+        return [v * factor if v == v else 0.0 for v in d]
+
+    def glyph(self, ctx: Any, i: int, x: float, y: float, w: float, h: float) -> None:
+        from .markers import resolve
+        s = self.series[0]
+        size = self.sizes()[i]
+        if not size:
+            return
+        marker = s.resolve("marker") if "marker" in s.SETTINGS else "circle"
+        marker = marker[0] if isinstance(marker, list) else marker
+        from .values import Values, is_computed
+        mapped = any(isinstance(s.resolve(n), Values) or is_computed(s.resolve(n))
+                     for n in ("color", "edge_color") if n in s.SETTINGS)
+        if len(self.series) == 1 and not mapped:
+            from .layers.paint import MarkerStyle, base_color
+            st = MarkerStyle(s, ctx, "", base_color(s, ctx), 1, True)
+            fill, stroke, lw = st.first_color("fill"), st.first_color("stroke"), st.line_width
+            if fill is None and stroke is None:
+                fill = base_color(s, ctx)
+        else:
+            fill, stroke, lw = "#888888", None, None
+        ctx.canvas.draw_markers([x + w / 2], [y + h / 2], marker=resolve(marker)[0],
+                                size=size, fill=fill, stroke=stroke, stroke_width=lw)
+
+
+def group_key(g: Any, plot: Any) -> SizeKey:
+    """The size key of size group ``g`` (:class:`plot_io.mapped.SizeGroup`), its labels
+    formatted as ``plot``'s numbers."""
+    members, axis = g.listed, g.axis
+    values = size_key_values(axis)
+    labels = size_key_labels(axis, values, plot)
+    title = axis.resolve("label")
+    if title is None:
+        title = next((s.columns["size"] for s in members
+                      if "size" in getattr(s, "columns", {})), None)
+    return SizeKey(axis, members, values, labels, title)
+
+
+class _Header:
+    header = True
+
+
+class Entries:
+    """A legend's content (the guide's, :class:`~plot_io.guides.GuideState`): its entries,
+    those of a plot and its twins (a twin's: none) or, merged, those of a figure legend's
+    plots, then its size keys; laid out in rows and columns."""
+
+    form = "entries"
+    guide: Any = None
+
+    def __init__(self, legend: Any, ps: Any = None) -> None:
+        self.ps = ps
+        self.legend = legend
+        self.twin = False
+        #: the entries of the series and decorations (without size keys)
+        self.listed: list[tuple[Any, Any, int]] = []
+        #: whether a figure legend shows the listed entries instead
+        self.shared = False
+        self.keys: list[SizeKey] = []
+        #: a figure legend: ``id(source)`` → the plot state whose context draws its symbol
+        self.owners: dict[int, Any] = {}
+        self.entries: list[tuple[Any, Any, int]] = []
+        self.size = (0.0, 0.0)
+        self._cols: list[float] = []
+        self._rows = 0
+        self._ncols = 0
+        self._heights: list[float] = []
+        self._title_h = 0.0
+
+    @classmethod
+    def of_plot(cls, plot_state: Any) -> "Entries":
+        """A plot's legend: the entries of the plot and its twins (a twin's: none)."""
+        plot = plot_state.plot
+        self = cls(plot.legend, plot_state)
+        from .layers.pipeline import plot_calls
+        #: a twin shows its entries in its main plot's legend (one legend per axes)
+        self.twin = getattr(plot, "twin_of", None) is not None
+        plots = [] if self.twin else [plot, *getattr(plot, "twins", [])]
+        own = [c for q in plots for c in plot_calls(q)]
+        self.listed = [(e, e.label, 0) for c in own for e in c.entries if _named(e.label)]
+        self.listed += [(d, label, i) for q in plots for d in q.decorations
+                        for i, label in enumerate(d.legend_labels()) if _named(label)]
+        self.keys = self._size_keys(plot_state)
+        self.compose()
+        return self
+
+    @classmethod
+    def merged(cls, legend: Any, states: list[Any]) -> "Entries":
+        """A figure legend (:class:`~plot_io.plot.FigureLegend`): the entries of its plots
+        (``states``), merged (the same label and symbol once)."""
+        self = cls(legend)
+        by_label: dict[str, list[tuple[Any, int]]] = {}
+        from .plot import _figure_legend_title
+        headers = _figure_legend_title(legend) is None    # plot titles head their entries
+        headed: list[str] = []
+        for ps in states:
+            header = ps.plot.legend.resolve("title") if headers else None
+            for src, label, k in ps.legend.listed:
+                if getattr(src, "header", False):             # a level section's title
+                    if _label_key(label) not in headed:
+                        headed.append(_label_key(label))
+                        self.listed.append((src, label, k))
+                    continue
+                self.owners[id(src)] = ps
+                same = by_label.setdefault(_label_key(label), [])
+                if any(self._same(src, k, other, j) for other, j in same):
+                    continue
+                same.append((src, k))
+                if header is not None and _label_key(header) not in headed:
+                    headed.append(_label_key(header))
+                    self.listed.append((_Header(), header, 0))
+                header = None
+                self.listed.append((src, label, k))
+        self.compose()
+        return self
+
+    def compose(self) -> None:
+        """The entries shown: the listed ones (unless ``shared``), then the size keys."""
+        self.entries = [] if self.shared else list(self.listed)
+        for key in self.keys:
+            if key.title is not None:
+                self.entries.append((_Header(), key.title, 0))
+            self.entries.extend((key, lab, i) for i, lab in enumerate(key.labels))
+
+    def _size_keys(self, ps: Any) -> list[SizeKey]:
+        """The size keys the plot's legend shows (one per shared size axis across the
+        figure: :func:`plot_io.mapped.size_keys`)."""
+        from .spec import current
+        r = current()
+        if self.twin:
+            return []
+        plots = {id(ps.plot), *(id(t) for t in getattr(ps.plot, "twins", []))}
+        return [group_key(g, g.plot) for g in (r.size_keys.values() if r is not None else ())
+                if id(g.plot) in plots]
+
+    def font(self) -> Font:
+        g = self.legend
+        return font_of(g, g.resolve("font_size"), color=g.resolve("color"))
+
+    def _metrics(self) -> tuple[float, float, float, float]:
+        g = self.legend
+        return (g.resolve("glyph_length"), g.resolve("glyph_gap"), g.resolve("row_height"),
+                g.resolve("inner_pad"))
+
+    def _columns(self, labels: list[float], heights: list[float], room: float | None) -> int:
+        """The number of columns of the entries (``labels``: their label widths,
+        ``heights``: their row heights): ``columns`` when set; else within ``room`` px along
+        the legend's side (its width when entries go in rows, its height when in columns;
+        ``None``: unlimited), the most columns whose rows fit, or the fewest columns whose
+        height fits (at least one column, one row)."""
+        n = len(labels)
+        cols = min(self.legend.resolve("columns"), n)
+        if self.legend.is_set("columns"):
+            return cols
+        row_major = self.guide.row_major
+        if room is None:
+            return n if row_major else cols
+        glyph, gap, _, inner = self._metrics()
+        if row_major:
+            col_gap = self.legend.resolve("column_gap")
+            for cols in range(n, 1, -1):
+                cells = [0.0] * cols
+                for i, lw in enumerate(labels):
+                    cells[i % cols] = max(cells[i % cols], lw)
+                if sum(glyph + gap + c for c in cells) + col_gap * (cols - 1) + 2 * inner <= room:
+                    return cols
+            return 1
+        for cols in range(1, n):
+            rows = math.ceil(n / cols)
+            tall = [0.0] * rows
+            for i, rh in enumerate(heights):
+                tall[i % rows] = max(tall[i % rows], rh)
+            if self._title_h + sum(tall) + 2 * inner <= room:
+                return cols
+        return max(n, 1)
+
+    def _pos(self, i: int) -> tuple[int, int]:
+        """Column and row of entry ``i``."""
+        if self.guide.row_major:
+            r, c = divmod(i, self._ncols)
+            return c, r
+        return divmod(i, self._rows)
+
+    def measure(self, fonts: Any, room: float | None = None) -> tuple[float, float]:
+        """The legend's size; ``room``: the length along its side it wraps within (its
+        width when entries go in rows, its height when in columns; see :meth:`_columns`)."""
+        if not self.guide.active():
+            self.size = (0.0, 0.0)
+            return self.size
+        font = self.font()
+        glyph, gap, row, inner = self._metrics()
+        n = len(self.entries)
+        labels = []
+        heights = []
+        for s, label, k in self.entries:
+            lw = measure(fonts, label, font)[0]
+            if getattr(s, "header", False):
+                lw -= glyph + gap
+            labels.append(lw)
+            heights.append(max(row, 1.15 * s.sizes()[k]) if isinstance(s, SizeKey) else row)
+        title = self.legend.resolve("title")
+        self._title_h = 0.0
+        tw = 0.0
+        if title is not None:
+            tw, a, d = measure(fonts, title, font)
+            self._title_h = a + d + self.legend.resolve("title_gap")
+        cols = self._columns(labels, heights, room)
+        rows = math.ceil(n / cols)
+        self._rows, self._ncols = rows, cols
+        widths = [0.0] * cols
+        self._heights = [row] * rows
+        for i in range(n):
+            c, r = self._pos(i)
+            widths[c] = max(widths[c], labels[i])
+            self._heights[r] = max(self._heights[r], heights[i])
+        self._cols = [glyph + gap + w for w in widths]
+        w = max(sum(self._cols) + self.legend.resolve("column_gap") * (cols - 1), tw)
+        h = self._title_h + sum(self._heights)
+        self.size = (w + 2 * inner, h + 2 * inner)
+        return self.size
+
+    def place_at(self, fonts: Any, x: float, y: float) -> Any:
+        """The legend's geometry with its box's top-left corner at ``(x, y)``."""
+        from .geometry import LegendGeometry, LegendItem
+        w, h = self.size
+        font = self.font()
+        glyph, gap, row, inner = self._metrics()
+        cx, cy = x + inner, y + inner
+        title = self.legend.resolve("title")
+        head = None
+        if title is not None:
+            head = run(fonts, title, cx, cy, font, "left", "top")
+            cy += self._title_h
+        items = []
+        col_gap = self.legend.resolve("column_gap")
+        for i, (s, label, k) in enumerate(self.entries):
+            c, r = self._pos(i)
+            ex = cx + sum(self._cols[:c]) + col_gap * c
+            ey = cy + sum(self._heights[:r])
+            rh = self._heights[r]
+            if getattr(s, "header", False):
+                items.append(LegendItem("header", s, k, (ex, ey, 0.0, rh),
+                                        run(fonts, label, ex, ey + rh / 2, font, "left",
+                                            "center")))
+                continue
+            if isinstance(s, SizeKey):
+                items.append(LegendItem("size", s, k, (ex, ey, glyph, rh),
+                                        run(fonts, label, ex + glyph + gap, ey + rh / 2, font,
+                                            "left", "center")))
+                continue
+            ey += (rh - row) / 2
+            items.append(LegendItem("entry", s, k, (ex, ey + 0.1 * row, glyph, 0.8 * row),
+                                    run(fonts, label, ex + glyph + gap, ey + row / 2, font,
+                                        "left", "center")))
+        return LegendGeometry((x, y, w, h), head, tuple(items))
+
+    def draw(self, canvas: Canvas, ctx: Any, g: Any) -> None:
+        """Draw the legend placed as ``g`` (see :meth:`~plot_io.guides.GuideState.place`)."""
+        self._draw(canvas, g, ctx.cycle, lambda item: ctx)
+
+    def _draw(self, canvas: Canvas, g: Any, cycle: Any, ctx_of: Any) -> None:
+        """Draw the legend placed as ``g``: its frame with ``cycle`` (the plot's colors), each item's symbol
+        in the drawing context ``ctx_of(item)`` gives."""
+        if g is None:
+            return
+        x, y, w, h = g.box
+        lg = self.legend
+        if lg.resolve("frame"):
+            opacity = lg.resolve("frame_opacity")
+            bg = with_alpha(resolve_color(lg.resolve("background"), cycle), opacity)
+            fc = with_alpha(resolve_color(lg.resolve("frame_color"), cycle), opacity)
+            with canvas.state():
+                r = min(lg.resolve("frame_radius"), w / 2, h / 2)
+                path = Path().rect(x, y, w, h, rx=r)
+                if bg is not None:
+                    canvas.draw_path(path, fill=bg, stroke=None)
+                if fc is not None and lg.resolve("frame_width"):
+                    canvas.stroke_width = lg.resolve("frame_width")
+                    canvas.draw_path(path, fill=None, stroke=fc)
+        draw_run(canvas, g.title)
+        for item in g.items:
+            if item.kind != "header":
+                with canvas.state():
+                    self.glyph(ctx_of(item), item.kind, item.source, item.index,
+                               *item.glyph)
+            draw_run(canvas, item.label)
+
+    def glyph(self, ctx: Any, kind: str, source: Any, index: int, x: float, y: float,
+              w: float, h: float) -> None:
+        """The symbol of an item (``kind``: ``"size"`` or ``"entry"``) in box ``x, y, w,
+        h``."""
+        if kind == "size":
+            source.glyph(ctx, index, x, y, w, h)
+            return
+        style = self.legend.resolve("glyph")
+        if style == "series":
+            source.legend_glyph_at(ctx, index, x, y, w, h)
+        else:
+            _simple_glyph(ctx, source, index, style, self.legend.resolve("glyph_opacity"),
+                          x, y, w, h)
+
+    def _same(self, a: Any, i: int, b: Any, j: int) -> bool:
+        """Whether two entries draw the same symbol: equal symbols and values (simple
+        symbols: equal colors)."""
+        try:
+            ca, cb = self._context(a), self._context(b)
+            if self.legend.resolve("glyph") == "series":
+                return a.legend_key_at(ca, i) == b.legend_key_at(cb, j)
+            return repr(a.legend_colors_at(ca, i)) == repr(b.legend_colors_at(cb, j))
+        except Exception:
+            return False
+
+    def _context(self, src: Any) -> Any:
+        """A drawing context of the plot of an entry, for its values."""
+        from .layers.context import DrawContext
+        ps = self.owners[id(src)]
+        return DrawContext(None, ps.plot, (0.0, 0.0, 100.0, 100.0), ps.x, ps.y, ps.cycle)
+
+    def draw_figure(self, canvas: Canvas, g: Any, contexts: dict[int, Any]) -> None:
+        """Draw the legend placed as ``g``, each symbol in the context of its plot
+        (``contexts``: ``id(plot)`` → its drawing context)."""
+        def ctx_of(item: Any) -> Any:
+            if isinstance(item.source, SizeKey):
+                plot = item.source.series[0].plot
+                plot = plot.twin_of[0] if getattr(plot, "twin_of", None) else plot
+                return contexts[id(plot)]
+            return contexts[id(self.owners[id(item.source)].plot)]
+        first = next(iter(contexts.values()), None)
+        self._draw(canvas, g, first.cycle if first is not None else (), ctx_of)
+
+
+def _label_key(label: Any) -> str:
+    """A legend label compared as written (strings and rich content)."""
+    return label if isinstance(label, str) else repr(label)
+
+
+def _opaque(c: Any) -> Any:
+    if c is None:
+        return None
+    from .color.values import rgba_of
+    rgba = rgba_of(c)
+    return None if rgba is None else (rgba[0], rgba[1], rgba[2], 1.0)
+
+
+def _simple_glyph(ctx: Any, series: Any, k: int, kind: str, opacity: Any, x: float, y: float,
+                  w: float, h: float) -> None:
+    """A legend symbol in the series' colors: a filled box, a circle or a line (``opacity``:
+    the legend's ``glyph_opacity``)."""
+    canvas = ctx.canvas
+    fill, stroke = series.legend_colors_at(ctx, k)
+    if opacity is not None and kind != "line":
+        base = _opaque(fill if fill is not None else stroke)
+        if base is not None:
+            fill, stroke = with_alpha(base, opacity), (stroke if stroke is not None else base)
+    if kind == "line":
+        c = stroke if stroke is not None else fill
+        if c is not None:
+            canvas.draw_lines([x, x + w], [y + h / 2, y + h / 2], stroke=c,
+                              stroke_width=min(2.0, h / 3))
+        return
+    if kind == "circle":
+        d = 0.75 * h
+        canvas.draw_markers([x + w / 2], [y + h / 2], size=d, fill=fill, stroke=stroke,
+                            stroke_width=1.25 if stroke is not None else None)
+        return
+    path = Path().rect(*swatch(x, y, w, h))
+    if fill is not None:
+        canvas.draw_path(path, fill=fill, stroke=None)
+    if stroke is not None:
+        canvas.stroke_width = 1.25
+        canvas.draw_path(path, fill=None, stroke=stroke)
+
+
+def _values(v: Any) -> tuple[float, ...]:
+    if isinstance(v, (str, bytes)) or not hasattr(v, "__iter__"):
+        raise ValueError(f"expected a list of numbers, got {v!r}")
+    return tuple(float(x) for x in v)
+
+
+class SizeLegend(SizeLegendMixin, Settings):
+    """A size key in its own grid area (``figure.size_legend(source, id=…)``): the guide of
+    a size axis (``source``: a series mapping sizes, or a size axis).
+
+    A series whose ``size`` goes through a size axis has a size key: by default a key like a
+    colorbar's (:class:`Colorbar`); with ``size_key="legend"``, rows in its plot's legend
+    below the series entries: the axis' ``label`` (default the ``size`` column) as a header,
+    then sample markers at their real size with their values (the axis' ``ticks``, else 3–5
+    nice numbers).  Series sharing a size axis share one key, in grey (one series: its
+    color), in the legend of the rightmost, then topmost, of their plots.  A size legend
+    area shows every series of its axis, and no plot legend repeats it.
+    """
+
+    SETTINGS = table(
+        values=Setting(_values, expr=False,
+                       doc="The sizes shown, one marker each; default: the axis' `ticks`, "
+                           "else 3–5 nice numbers inside its limits."),
+        title=Setting(text, doc="Title; default: the size axis' `label`."),
+        font_size=Setting(length(positive=True, percent="em"),
+                          doc="Font size; default: the legends' (`Legend.font_size`)."),
+    )
+
+    def __init__(self, source: Any, figure: Any, **settings: Any) -> None:
+        from .mapped import SizeAxis, size_axis_of
+        axis = source if isinstance(source, SizeAxis) else \
+            size_axis_of(source) if hasattr(source, "SETTINGS") else None
+        if axis is None:
+            raise ValueError("a size legend shows a size axis: give a series mapping sizes, "
+                             "or a shared figure.size_axis(…)")
+        self.size_axis = axis
+        self.figure = figure
+        self.id: Any = None
+        super().__init__(**settings)
+
+    def _parent(self) -> Settings:
+        return self.figure
+
+    def __repr__(self) -> str:
+        return f"SizeLegend({self.size_axis!r})"
+
+
+class SizeRows:
+    """A size legend's content (the guide's, :class:`~plot_io.guides.GuideState`, in its
+    own grid area): a size key's rows, its title first."""
+
+    form = "rows"
+    guide: Any = None
+    vertical = True
+
+    def __init__(self, sl: SizeLegend) -> None:
+        from .mapped import size_group
+        from .plot import Legend, Plot
+        self.sl = sl
+        fig = sl.figure
+        axis = sl.size_axis
+        group = size_group(axis)
+        users = group.users if group is not None else []
+        self.key = None
+        self.thickness = 1.0
+        if users:
+            given = sl.resolve("values")
+            values = size_key_values(axis, None if given is None else list(given))
+            labels = size_key_labels(axis, values, users[0].plot if isinstance(
+                users[0].plot, Plot) else None)
+            title = sl.resolve("title")
+            if title is None:
+                title = axis.resolve("label")
+            self.key = SizeKey(axis, users, values, labels, title)
+        self.legend = Legend(fig)              # the legend settings of the figure's style
+        if sl.resolve("font_size") is not None:
+            self.legend.set(font_size=sl.resolve("font_size"))
+        size = self.legend.resolve("font_size")
+        self.font = font_of(fig, size, color=fig.resolve("text_color"))
+        self._layout: list[tuple[str, Any, float]] = []
+
+    @property
+    def cell_size(self) -> float:
+        """Its width, as a cell of the grid of its own."""
+        return self.thickness
+
+    def measure_area(self, fonts: Any, w: float, h: float) -> tuple[float, float, float, float]:
+        """Margins of the size legend in its area ``w`` × ``h`` (none: its width is its
+        cell's)."""
+        if self.key is None:
+            return (0.0, 0.0, 0.0, 0.0)
+        g = self.legend
+        glyph, gap, row = g.resolve("glyph_length"), g.resolve("glyph_gap"), g.resolve("row_height")
+        sizes = self.key.sizes()
+        width = 0.0
+        rows: list[tuple[str, Any, float]] = []
+        if self.key.title is not None:
+            width = measure(fonts, self.key.title, self.font)[0]
+            rows.append(("title", self.key.title, row))
+        g = max([glyph] + [1.1 * s for s in sizes])
+        for lab, s in zip(self.key.labels, sizes):
+            width = max(width, g + gap + measure(fonts, lab, self.font)[0])
+            rows.append(("entry", lab, max(row, 1.15 * s)))
+        self._layout = rows
+        self._glyph = g
+        self.thickness = width
+        return (0.0, 0.0, 0.0, 0.0)
+
+    def bar_rect(self, rect: tuple[float, float, float, float]) -> tuple:
+        x0, y0, x1, y1 = rect
+        return (x0, y0, min(x1, x0 + self.thickness), y1)
+
+    def place_area(self, fonts: Any, rect: tuple[float, float, float, float]) -> Any:
+        """The key's rows placed from the top-left corner of ``rect``."""
+        from .geometry import KeyGeometry
+        if self.key is None:
+            return KeyGeometry(self, ())
+        x0, y = rect[0], rect[1]
+        rows = []
+        gap = self.legend.resolve("glyph_gap")
+        for kind, lab, h in self._layout:
+            if kind == "title":
+                rows.append((kind, (x0, y, 0.0, h),
+                             run(fonts, lab, x0, y + h / 2, self.font, "left", "center")))
+            else:
+                rows.append((kind, (x0, y, self._glyph, h),
+                             run(fonts, lab, x0 + self._glyph + gap, y + h / 2, self.font,
+                                 "left", "center")))
+            y += h
+        return KeyGeometry(self, tuple(rows))
+
+    def draw(self, canvas: Canvas, g: Any) -> None:
+        if self.key is None:
+            return
+        from .color.maps import cycle_of, map_of
+        from .color.values import resolve_color
+        plot = self.key.series[0].plot
+        cycle = cycle_of(map_of(plot, "qualitative"), 10)
+
+        class _Ctx:
+            def color(self, value: Any) -> Any:
+                return resolve_color(value, cycle)
+        ctx: Any = _Ctx()
+        ctx.canvas, ctx.cycle, ctx.plot = canvas, cycle, plot
+        i = 0
+        for kind, glyph, label in g.rows:
+            if kind != "title":
+                with canvas.state():
+                    self.key.glyph(ctx, i, *glyph)
+                i += 1
+            draw_run(canvas, label)