Beautiful Slides

"""Render the bar chart in all 5 modes as separate 16:9 slides."""

import sys
from pathlib import Path

from pptx import Presentation
from pptx.util import Inches

sys.path.insert(0, str(Path(__file__).resolve().parent.parent))
from tokens import MODES  # noqa: E402

from render import render


DATA_SINGLE = {
    "orientation": "vertical",
    "title": "Revenue by segment, Q1",
    "categories": ["Enterprise", "Mid-market", "SMB", "Startup"],
    "series": [
        {"name": "Q1 Actual", "values": [12.4, 8.1, 4.3, 1.8]},
    ],
    "value_suffix": "M",
    "show_values": True,
}

DATA_GROUPED = {
    "orientation": "vertical",
    "title": "Q1 actual vs. plan, by segment",
    "categories": ["Enterprise", "Mid-market", "SMB", "Startup"],
    "series": [
        {"name": "Actual", "values": [12.4, 8.1, 4.3, 1.8]},
        {"name": "Plan",   "values": [11.0, 8.5, 5.0, 2.0]},
    ],
    "value_suffix": "M",
    "show_values": True,
}

DATA_HORIZONTAL = {
    "orientation": "horizontal",
    "title": "Revenue by segment, Q1",
    "categories": ["Enterprise", "Mid-market", "SMB", "Startup"],
    "series": [
        {"name": "Q1 Actual", "values": [12.4, 8.1, 4.3, 1.8]},
    ],
    "value_suffix": "M",
    "show_values": True,
}


# Pair each mode with a data variant so we exercise grouped + horizontal forms.
MODE_DATA = {
    "sv-keynote": DATA_SINGLE,
    "editorial-magazine": DATA_HORIZONTAL,
    "playful-marketing": DATA_GROUPED,
    "consulting-boardroom": DATA_GROUPED,
    "craft-minimal": DATA_SINGLE,
}


def main():
    out_dir = Path(__file__).parent
    for mode, tokens in MODES.items():
        prs = Presentation()
        prs.slide_width = Inches(13.333)
        prs.slide_height = Inches(7.5)
        slide = prs.slides.add_slide(prs.slide_layouts[6])

        margin = Inches(0.5)
        bounds = (
            margin,
            margin,
            prs.slide_width - 2 * margin,
            prs.slide_height - 2 * margin,
        )

        data = MODE_DATA[mode]
        render(slide, data, tokens, bounds)

        out = out_dir / f"example-{mode}.pptx"
        prs.save(str(out))
        print(f"wrote {out.name}")


if __name__ == "__main__":
    main()

"""Bar chart renderer — native python-pptx shapes only.

Public API: render(slide, data, tokens, bounds)
"""

from pptx.dml.color import RGBColor
from pptx.enum.shapes import MSO_SHAPE
from pptx.enum.text import PP_ALIGN, MSO_ANCHOR
from pptx.util import Emu, Pt


# EMU constants
_EMU_PER_PX = 9525  # 96 DPI reference
_EMU_PER_PT = 12700


def _rgb(hex_):
    return RGBColor.from_string(hex_.lstrip("#"))


def _set_fill(shape, hex_):
    shape.fill.solid()
    shape.fill.fore_color.rgb = _rgb(hex_)


def _no_fill(shape):
    shape.fill.background()


def _set_line(shape, hex_, width_emu=None):
    shape.line.color.rgb = _rgb(hex_)
    if width_emu is not None:
        shape.line.width = Emu(int(width_emu))


def _no_line(shape):
    shape.line.fill.background()


def _style_run(run, font_name, size_pt, hex_color, bold=False):
    run.font.name = font_name
    run.font.size = Pt(size_pt)
    run.font.color.rgb = _rgb(hex_color)
    run.font.bold = bold


def _add_text(slide, x, y, w, h, text, font_name, size_pt, hex_color,
              bold=False, align=PP_ALIGN.LEFT, anchor=MSO_ANCHOR.MIDDLE):
    tb = slide.shapes.add_textbox(Emu(int(x)), Emu(int(y)), Emu(int(w)), Emu(int(h)))
    tf = tb.text_frame
    tf.margin_left = 0
    tf.margin_right = 0
    tf.margin_top = 0
    tf.margin_bottom = 0
    tf.word_wrap = True
    tf.vertical_anchor = anchor
    p = tf.paragraphs[0]
    p.alignment = align
    run = p.add_run()
    run.text = text
    _style_run(run, font_name, size_pt, hex_color, bold=bold)
    return tb


def _add_bar(slide, x, y, w, h, fill_hex, radius_px):
    w_i = max(1, int(w))
    h_i = max(1, int(h))
    if radius_px and radius_px > 0:
        shape = slide.shapes.add_shape(
            MSO_SHAPE.ROUNDED_RECTANGLE, Emu(int(x)), Emu(int(y)), Emu(w_i), Emu(h_i)
        )
        # adjustment is a ratio of the short side
        short_emu = min(w_i, h_i)
        radius_emu = radius_px * _EMU_PER_PX
        ratio = max(0.0, min(0.5, radius_emu / short_emu / 2.0))
        try:
            shape.adjustments[0] = ratio
        except Exception:
            pass
    else:
        shape = slide.shapes.add_shape(
            MSO_SHAPE.RECTANGLE, Emu(int(x)), Emu(int(y)), Emu(w_i), Emu(h_i)
        )
    _set_fill(shape, fill_hex)
    _no_line(shape)
    return shape


def _add_line(slide, x1, y1, x2, y2, hex_color, width_emu):
    ln = slide.shapes.add_connector(1, Emu(int(x1)), Emu(int(y1)), Emu(int(x2)), Emu(int(y2)))
    ln.line.color.rgb = _rgb(hex_color)
    ln.line.width = Emu(int(width_emu))
    return ln


def _nice_ticks(vmax, target=5):
    if vmax <= 0:
        return [0, 1], 1
    import math
    raw = vmax / target
    magnitude = 10 ** math.floor(math.log10(raw)) if raw > 0 else 1
    residual = raw / magnitude
    if residual < 1.5:
        step = 1 * magnitude
    elif residual < 3:
        step = 2 * magnitude
    elif residual < 7:
        step = 5 * magnitude
    else:
        step = 10 * magnitude
    top = step * math.ceil(vmax / step)
    ticks = []
    v = 0.0
    while v <= top + 1e-9:
        ticks.append(v)
        v += step
    return ticks, top


def _fmt(v, suffix=""):
    if abs(v - round(v)) < 1e-9:
        s = f"{int(round(v))}"
    else:
        s = f"{v:.1f}"
    return f"{s}{suffix}" if suffix else s


def render(slide, data, tokens, bounds):
    x, y, w, h = bounds

    orientation = (data.get("orientation") or "vertical").lower()
    title = data.get("title")
    categories = list(data.get("categories") or [])
    series = list(data.get("series") or [])
    value_suffix = data.get("value_suffix") or ""
    show_values = bool(data.get("show_values", True))

    if not categories or not series:
        return

    # Pad to at most 2 series
    series = series[:2]

    bg = tokens["bg"]
    primary = tokens["primary"]
    accent = tokens["accent"]
    text_c = tokens["text"]
    muted = tokens["muted"]
    font_display = tokens["font_display"]
    font_body = tokens["font_body"]
    font_mono = tokens["font_mono"]
    base_pt = int(tokens["font_size_base_pt"])
    radius_px = int(tokens.get("radius_px") or 0)

    # Background
    bg_shape = slide.shapes.add_shape(MSO_SHAPE.RECTANGLE, Emu(int(x)), Emu(int(y)), Emu(int(w)), Emu(int(h)))
    _set_fill(bg_shape, bg)
    _no_line(bg_shape)

    # Outer padding
    pad = int(min(w, h) * 0.04)
    ix = x + pad
    iy = y + pad
    iw = w - 2 * pad
    ih = h - 2 * pad

    title_h = 0
    if title:
        title_pt = int(round(base_pt * 1.6))
        title_h = int(Pt(title_pt).emu * 1.8)
        _add_text(
            slide, ix, iy, iw, title_h, title,
            font_name=font_display, size_pt=title_pt, hex_color=text_c,
            bold=True, align=PP_ALIGN.LEFT, anchor=MSO_ANCHOR.TOP,
        )
        iy += title_h + int(Pt(base_pt).emu * 0.6)
        ih = (y + h - pad) - iy

    series_colors = [primary, accent][: len(series)]

    # Determine value range
    all_vals = []
    for s in series:
        all_vals.extend(s.get("values") or [])
    if not all_vals:
        return
    vmax_raw = max(all_vals)
    ticks, vmax = _nice_ticks(max(vmax_raw, 0.0))

    # Legend (only if >=2 series)
    legend_h = 0
    if len(series) >= 2:
        legend_pt = max(int(base_pt * 0.85), 8)
        legend_h = int(Pt(legend_pt).emu * 2.0)
        _draw_legend(slide, ix, iy, iw, legend_h, series, series_colors,
                     font_body, legend_pt, text_c, muted, radius_px)
        iy += legend_h
        ih -= legend_h

    tick_pt = max(int(base_pt * 0.78), 8)
    cat_pt = max(int(base_pt * 0.92), 9)
    val_pt = max(int(base_pt * 0.78), 8)

    if orientation == "horizontal":
        _draw_horizontal(
            slide, ix, iy, iw, ih, categories, series, series_colors,
            ticks, vmax, text_c, muted, font_body, font_mono,
            cat_pt, tick_pt, val_pt, radius_px, value_suffix, show_values,
        )
    else:
        _draw_vertical(
            slide, ix, iy, iw, ih, categories, series, series_colors,
            ticks, vmax, text_c, muted, font_body, font_mono,
            cat_pt, tick_pt, val_pt, radius_px, value_suffix, show_values,
        )


def _draw_legend(slide, x, y, w, h, series, colors, font_body, pt, text_c, muted, radius_px):
    # Right-aligned legend: [sw] name  [sw] name
    swatch = int(Pt(pt).emu * 0.9)
    gap = int(Pt(pt).emu * 0.4)
    item_gap = int(Pt(pt).emu * 1.2)

    # Measure approximate widths
    widths = []
    for s, _c in zip(series, colors):
        name = s.get("name") or ""
        est_text_w = int(Pt(pt).emu * 0.55 * max(len(name), 1))
        widths.append(swatch + gap + est_text_w)
    total = sum(widths) + item_gap * (len(widths) - 1)
    cursor = x + max(0, w - total)
    cy = y + (h - swatch) // 2
    ty = y
    for (s, c), wd in zip(zip(series, colors), widths):
        sw = slide.shapes.add_shape(MSO_SHAPE.OVAL, Emu(int(cursor)), Emu(int(cy)), Emu(swatch), Emu(swatch))
        _set_fill(sw, c)
        _no_line(sw)
        tx = cursor + swatch + gap
        tw = wd - swatch - gap
        _add_text(
            slide, tx, ty, tw, h, s.get("name") or "",
            font_name=font_body, size_pt=pt, hex_color=text_c,
            align=PP_ALIGN.LEFT, anchor=MSO_ANCHOR.MIDDLE,
        )
        cursor += wd + item_gap


def _draw_vertical(slide, x, y, w, h, categories, series, colors, ticks, vmax,
                   text_c, muted, font_body, font_mono, cat_pt, tick_pt, val_pt,
                   radius_px, suffix, show_values):
    # Reserve space for y-axis tick labels on left, and category labels below
    # Longest tick label drives left margin
    tick_labels = [_fmt(t) for t in ticks]
    max_tick_chars = max(len(s) for s in tick_labels) if tick_labels else 1
    left_margin = int(Pt(tick_pt).emu * 0.65 * (max_tick_chars + 1))
    bottom_margin = int(Pt(cat_pt).emu * 2.2)
    top_margin = int(Pt(val_pt).emu * 1.6)  # headroom for value labels
    right_margin = int(Pt(val_pt).emu * 1.2)

    plot_x = x + left_margin
    plot_y = y + top_margin
    plot_w = max(1, w - left_margin - right_margin)
    plot_h = max(1, h - top_margin - bottom_margin)

    hairline = max(int(_EMU_PER_PX * 0.5), 3175)

    # Gridlines for tick values (light)
    for i, t in enumerate(ticks):
        ty = plot_y + plot_h - int(plot_h * (t / vmax)) if vmax > 0 else plot_y + plot_h
        # y-axis tick label
        lbl_w = left_margin - int(Pt(tick_pt).emu * 0.3)
        lbl_h = int(Pt(tick_pt).emu * 1.4)
        _add_text(
            slide, x, ty - lbl_h // 2, lbl_w, lbl_h,
            _fmt(t) + (suffix if t != 0 and i == len(ticks) - 1 else ""),
            font_name=font_mono, size_pt=tick_pt, hex_color=muted,
            align=PP_ALIGN.RIGHT, anchor=MSO_ANCHOR.MIDDLE,
        )
        # hairline gridline across plot (skip zero which becomes baseline)
        if i > 0:
            _add_line(slide, plot_x, ty, plot_x + plot_w, ty, muted, hairline)

    # Baseline (axis)
    base_y = plot_y + plot_h
    _add_line(slide, plot_x, base_y, plot_x + plot_w, base_y, muted, hairline * 2)

    n_cat = len(categories)
    n_series = len(series)
    group_w = plot_w / n_cat
    inner_pad = group_w * 0.18
    bars_region = group_w - 2 * inner_pad
    bar_gap = bars_region * 0.08 if n_series > 1 else 0
    bar_w = (bars_region - bar_gap * (n_series - 1)) / n_series

    for ci, cat in enumerate(categories):
        group_left = plot_x + ci * group_w
        # Category label
        cat_y = base_y + int(Pt(cat_pt).emu * 0.4)
        cat_h = int(Pt(cat_pt).emu * 1.6)
        _add_text(
            slide, group_left, cat_y, group_w, cat_h, str(cat),
            font_name=font_body, size_pt=cat_pt, hex_color=text_c,
            align=PP_ALIGN.CENTER, anchor=MSO_ANCHOR.TOP,
        )
        for si, (s, color) in enumerate(zip(series, colors)):
            vals = s.get("values") or []
            if ci >= len(vals):
                continue
            v = vals[ci]
            bh = int(plot_h * (max(v, 0) / vmax)) if vmax > 0 else 0
            bx = group_left + inner_pad + si * (bar_w + bar_gap)
            by = base_y - bh
            if bh > 0:
                _add_bar(slide, bx, by, bar_w, bh, color, radius_px)
            if show_values:
                vt = _fmt(v, suffix)
                vh = int(Pt(val_pt).emu * 1.3)
                _add_text(
                    slide, bx, by - vh - int(Pt(val_pt).emu * 0.1),
                    bar_w, vh, vt,
                    font_name=font_mono, size_pt=val_pt, hex_color=text_c,
                    align=PP_ALIGN.CENTER, anchor=MSO_ANCHOR.BOTTOM,
                )


def _draw_horizontal(slide, x, y, w, h, categories, series, colors, ticks, vmax,
                     text_c, muted, font_body, font_mono, cat_pt, tick_pt, val_pt,
                     radius_px, suffix, show_values):
    # Category labels on left; bars extend right; tick labels on bottom
    max_cat_chars = max((len(str(c)) for c in categories), default=4)
    left_margin = int(Pt(cat_pt).emu * 0.55 * (max_cat_chars + 2))
    bottom_margin = int(Pt(tick_pt).emu * 2.0)
    top_margin = int(Pt(val_pt).emu * 0.6)
    right_margin = int(Pt(val_pt).emu * 3.0)  # room for bar value labels

    plot_x = x + left_margin
    plot_y = y + top_margin
    plot_w = max(1, w - left_margin - right_margin)
    plot_h = max(1, h - top_margin - bottom_margin)

    hairline = max(int(_EMU_PER_PX * 0.5), 3175)

    # x-axis ticks (bottom)
    for i, t in enumerate(ticks):
        tx = plot_x + int(plot_w * (t / vmax)) if vmax > 0 else plot_x
        tlh = int(Pt(tick_pt).emu * 1.4)
        _add_text(
            slide, tx - int(Pt(tick_pt).emu * 2), plot_y + plot_h + int(Pt(tick_pt).emu * 0.3),
            int(Pt(tick_pt).emu * 4), tlh,
            _fmt(t) + (suffix if t != 0 and i == len(ticks) - 1 else ""),
            font_name=font_mono, size_pt=tick_pt, hex_color=muted,
            align=PP_ALIGN.CENTER, anchor=MSO_ANCHOR.TOP,
        )
        if i > 0:
            _add_line(slide, tx, plot_y, tx, plot_y + plot_h, muted, hairline)

    # Baseline (left axis)
    _add_line(slide, plot_x, plot_y, plot_x, plot_y + plot_h, muted, hairline * 2)

    n_cat = len(categories)
    n_series = len(series)
    row_h = plot_h / n_cat
    inner_pad = row_h * 0.18
    bars_region = row_h - 2 * inner_pad
    bar_gap = bars_region * 0.08 if n_series > 1 else 0
    bar_h = (bars_region - bar_gap * (n_series - 1)) / n_series

    for ci, cat in enumerate(categories):
        row_top = plot_y + ci * row_h
        # Category label on left, vertically centered on the row
        cat_h_em = int(Pt(cat_pt).emu * 1.4)
        _add_text(
            slide, x, row_top + (row_h - cat_h_em) / 2,
            left_margin - int(Pt(cat_pt).emu * 0.4), cat_h_em,
            str(cat),
            font_name=font_body, size_pt=cat_pt, hex_color=text_c,
            align=PP_ALIGN.RIGHT, anchor=MSO_ANCHOR.MIDDLE,
        )
        for si, (s, color) in enumerate(zip(series, colors)):
            vals = s.get("values") or []
            if ci >= len(vals):
                continue
            v = vals[ci]
            bw = int(plot_w * (max(v, 0) / vmax)) if vmax > 0 else 0
            by = row_top + inner_pad + si * (bar_h + bar_gap)
            bx = plot_x
            if bw > 0:
                _add_bar(slide, bx, by, bw, bar_h, color, radius_px)
            if show_values:
                vt = _fmt(v, suffix)
                vh = int(Pt(val_pt).emu * 1.3)
                vw_em = int(Pt(val_pt).emu * 4)
                _add_text(
                    slide, bx + bw + int(Pt(val_pt).emu * 0.3),
                    by + (bar_h - vh) / 2, vw_em, vh, vt,
                    font_name=font_mono, size_pt=val_pt, hex_color=text_c,
                    align=PP_ALIGN.LEFT, anchor=MSO_ANCHOR.MIDDLE,
                )

import os
import sys

from pptx import Presentation
from pptx.dml.color import RGBColor
from pptx.util import Emu, Inches

HERE = os.path.dirname(os.path.abspath(__file__))
sys.path.insert(0, HERE)
sys.path.insert(0, os.path.dirname(HERE))  # charts/ for shared tokens module

from tokens import MODES  # noqa: E402
from render import render, _rgb  # noqa: E402


DATA = {
    "title": "Enterprise pipeline, Q1",
    "stages": [
        {"label": "Leads",       "value": 10000},
        {"label": "Qualified",   "value":  4200},
        {"label": "Demo'd",      "value":  1800},
        {"label": "Proposal",    "value":   620},
        {"label": "Negotiation", "value":   310},
        {"label": "Closed-won",  "value":   180},
    ],
    "show_conversion": True,
    "value_format": "{:,}",
}


def _set_slide_bg(slide, hex_color):
    bg = slide.background
    fill = bg.fill
    fill.solid()
    fill.fore_color.rgb = RGBColor.from_string(hex_color.lstrip("#"))


def build(mode_name, tokens, out_path):
    prs = Presentation()
    prs.slide_width = Inches(13.333)
    prs.slide_height = Inches(7.5)
    blank = prs.slide_layouts[6]
    slide = prs.slides.add_slide(blank)

    _set_slide_bg(slide, tokens["bg"])

    margin = Inches(0.6)
    x = int(margin)
    y = int(margin)
    w = int(prs.slide_width) - 2 * int(margin)
    h = int(prs.slide_height) - 2 * int(margin)

    render(slide, DATA, tokens, (x, y, w, h))

    prs.save(out_path)


def main():
    for name, tokens in MODES.items():
        path = os.path.join(HERE, f"example-{name}.pptx")
        build(name, tokens, path)
        print(f"wrote {path}")


if __name__ == "__main__":
    main()

from pptx.dml.color import RGBColor
from pptx.util import Emu, Pt
from pptx.enum.text import PP_ALIGN, MSO_ANCHOR


def _rgb(hex_):
    return RGBColor.from_string(hex_.lstrip("#"))


def _lerp_hex(h1, h2, t):
    h1 = h1.lstrip("#")
    h2 = h2.lstrip("#")
    r1, g1, b1 = int(h1[0:2], 16), int(h1[2:4], 16), int(h1[4:6], 16)
    r2, g2, b2 = int(h2[0:2], 16), int(h2[2:4], 16), int(h2[4:6], 16)
    r = round(r1 + (r2 - r1) * t)
    g = round(g1 + (g2 - g1) * t)
    b = round(b1 + (b2 - b1) * t)
    return f"#{r:02X}{g:02X}{b:02X}"


def _add_textbox(slide, x, y, w, h, text, font_name, size_pt, color_hex,
                 align=PP_ALIGN.LEFT, bold=False, anchor=MSO_ANCHOR.MIDDLE):
    tb = slide.shapes.add_textbox(Emu(x), Emu(y), Emu(w), Emu(h))
    tf = tb.text_frame
    tf.margin_left = 0
    tf.margin_right = 0
    tf.margin_top = 0
    tf.margin_bottom = 0
    tf.word_wrap = True
    tf.vertical_anchor = anchor
    p = tf.paragraphs[0]
    p.alignment = align
    run = p.add_run()
    run.text = text
    run.font.name = font_name
    run.font.size = Pt(size_pt)
    run.font.bold = bold
    run.font.color.rgb = _rgb(color_hex)
    return tb


def _draw_trapezoid(slide, tl_x, tl_y, tr_x, bl_x, br_x, bottom_y, fill_hex):
    ff = slide.shapes.build_freeform(int(tl_x), int(tl_y), scale=1.0)
    ff.add_line_segments(
        [
            (int(tr_x), int(tl_y)),
            (int(br_x), int(bottom_y)),
            (int(bl_x), int(bottom_y)),
        ],
        close=True,
    )
    shape = ff.convert_to_shape()
    shape.fill.solid()
    shape.fill.fore_color.rgb = _rgb(fill_hex)
    shape.line.fill.background()
    return shape


def render(slide, data, tokens, bounds):
    x, y, w, h = bounds

    primary = tokens["primary"]
    muted = tokens["muted"]
    text_c = tokens["text"]
    font_display = tokens["font_display"]
    font_body = tokens["font_body"]
    font_mono = tokens["font_mono"]
    base_pt = tokens["font_size_base_pt"]

    stages = data.get("stages", [])
    if not stages:
        return
    title = data.get("title")
    show_conversion = data.get("show_conversion", True)
    value_format = data.get("value_format", "{:,}")

    n = len(stages)
    max_val = max(s["value"] for s in stages) or 1

    # Layout regions
    cur_y = y
    pad = Emu(Pt(6)).emu if False else int(Pt(6))  # not used directly; keep simple
    title_h = 0
    if title:
        title_h = int(Pt(base_pt * 1.6) * 1.8)
        _add_textbox(
            slide,
            x, cur_y, w, title_h,
            title, font_display, int(base_pt * 1.5), text_c,
            align=PP_ALIGN.LEFT, bold=True, anchor=MSO_ANCHOR.TOP,
        )
        cur_y += title_h + int(Pt(base_pt * 0.6))

    # Reserve label columns on left and right
    label_col_w = int(w * 0.22)
    value_col_w = int(w * 0.18)
    gap_labels = int(w * 0.015)
    funnel_x = x + label_col_w + gap_labels
    funnel_w = w - label_col_w - value_col_w - 2 * gap_labels
    if funnel_w < int(w * 0.3):
        funnel_w = int(w * 0.3)
        label_col_w = int((w - funnel_w) * 0.55)
        value_col_w = int((w - funnel_w) * 0.45) - 2 * gap_labels
        funnel_x = x + label_col_w + gap_labels

    funnel_center = funnel_x + funnel_w // 2
    max_funnel_w = int(funnel_w * 0.98)
    min_funnel_w = max(int(max_funnel_w * 0.18), int(Emu(Pt(8)).emu))

    # Vertical layout: n stages + (n-1) gaps; if show_conversion, the gap holds text
    avail_h = (y + h) - cur_y
    inter_gap = int(Pt(base_pt * (1.6 if show_conversion else 0.55)))
    total_gaps = inter_gap * (n - 1)
    stage_h = max(int((avail_h - total_gaps) / n), int(Pt(base_pt * 1.4)))

    def width_for(val):
        t = val / max_val
        return int(min_funnel_w + (max_funnel_w - min_funnel_w) * t)

    stage_y = cur_y
    prev_bottom_w = None
    for i, stage in enumerate(stages):
        # Top width = width for this stage's value
        top_w = width_for(stage["value"])
        # Bottom width = width for next stage (or slightly narrower if last)
        if i < n - 1:
            bot_w = width_for(stages[i + 1]["value"])
        else:
            bot_w = max(int(top_w * 0.45), min_funnel_w // 2)

        tl_x = funnel_center - top_w // 2
        tr_x = funnel_center + top_w // 2
        bl_x = funnel_center - bot_w // 2
        br_x = funnel_center + bot_w // 2
        tl_y = stage_y
        bottom_y = stage_y + stage_h

        t = i / (n - 1) if n > 1 else 0.0
        fill_hex = _lerp_hex(primary, muted, t)
        _draw_trapezoid(slide, tl_x, tl_y, tr_x, bl_x, br_x, bottom_y, fill_hex)

        # Label on left
        label_x = x
        label_w = label_col_w
        _add_textbox(
            slide,
            label_x, stage_y, label_w, stage_h,
            stage["label"], font_body, base_pt, text_c,
            align=PP_ALIGN.RIGHT, bold=False, anchor=MSO_ANCHOR.MIDDLE,
        )

        # Value on right
        val_x = x + label_col_w + gap_labels + funnel_w + gap_labels
        val_w = (x + w) - val_x
        if val_w < int(w * 0.1):
            val_w = int(w * 0.1)
        val_text = value_format.format(stage["value"])
        _add_textbox(
            slide,
            val_x, stage_y, val_w, stage_h,
            val_text, font_mono, base_pt, text_c,
            align=PP_ALIGN.LEFT, bold=True, anchor=MSO_ANCHOR.MIDDLE,
        )

        # Conversion between this stage and next
        if show_conversion and i < n - 1:
            next_val = stages[i + 1]["value"]
            if stage["value"] > 0:
                pct = (next_val / stage["value"]) * 100
            else:
                pct = 0
            conv_text = f"{pct:.0f}% \u2193"
            conv_y = bottom_y
            conv_h = inter_gap
            _add_textbox(
                slide,
                funnel_x, conv_y, funnel_w, conv_h,
                conv_text, font_mono, max(int(base_pt * 0.75), 8), muted,
                align=PP_ALIGN.CENTER, bold=False, anchor=MSO_ANCHOR.MIDDLE,
            )

        stage_y = bottom_y + inter_gap

    return None

import os
import sys
from pptx import Presentation
from pptx.util import Emu, Inches

HERE = os.path.dirname(os.path.abspath(__file__))
sys.path.insert(0, HERE)
sys.path.insert(0, os.path.dirname(HERE))  # charts/ for shared tokens module

from tokens import MODES  # noqa: E402
from render import render, _rgb  # noqa: E402


def _data():
    rows = ["Mon", "Tue", "Wed", "Thu", "Fri", "Sat", "Sun"]
    cols = ["00", "02", "04", "06", "08", "10", "12", "14", "16", "18", "20", "22"]
    base = [
        [0.08, 0.05, 0.03, 0.03, 0.18, 0.55, 0.72, 0.85, 0.88, 0.78, 0.60, 0.35],
        [0.07, 0.04, 0.03, 0.04, 0.22, 0.58, 0.76, 0.90, 0.92, 0.82, 0.62, 0.40],
        [0.09, 0.06, 0.04, 0.05, 0.24, 0.60, 0.80, 0.94, 0.96, 0.86, 0.66, 0.45],
        [0.10, 0.06, 0.04, 0.04, 0.26, 0.62, 0.82, 0.95, 0.97, 0.88, 0.70, 0.48],
        [0.14, 0.10, 0.06, 0.06, 0.28, 0.58, 0.78, 0.88, 0.84, 0.80, 0.72, 0.62],
        [0.22, 0.18, 0.12, 0.08, 0.16, 0.32, 0.50, 0.58, 0.64, 0.72, 0.80, 0.78],
        [0.25, 0.20, 0.14, 0.09, 0.14, 0.28, 0.42, 0.50, 0.54, 0.60, 0.66, 0.58],
    ]
    return {
        "title": "Usage intensity — weekday × hour",
        "row_labels": rows,
        "col_labels": cols,
        "values": base,
        "value_min": 0.0,
        "value_max": 1.0,
        "show_values": True,
        "value_format": "{:.0%}",
    }


def _make_pptx(mode_name, tokens, data, out_dir):
    prs = Presentation()
    prs.slide_width = Inches(13.333)
    prs.slide_height = Inches(7.5)
    blank = prs.slide_layouts[6]
    slide = prs.slides.add_slide(blank)

    bg_shape = slide.shapes.add_shape(
        1,
        0, 0,
        prs.slide_width, prs.slide_height,
    )
    bg_shape.shadow.inherit = False
    bg_shape.fill.solid()
    bg_shape.fill.fore_color.rgb = _rgb(tokens["bg"])
    bg_shape.line.fill.background()
    bg_shape.text_frame.text = ""

    margin = Inches(0.6)
    bounds = (
        margin,
        margin,
        prs.slide_width - 2 * margin,
        prs.slide_height - 2 * margin,
    )

    render(slide, data, tokens, bounds)

    out_path = os.path.join(out_dir, f"example-{mode_name}.pptx")
    prs.save(out_path)
    return out_path


def main():
    data = _data()
    written = []
    for name, tokens in MODES.items():
        path = _make_pptx(name, tokens, data, HERE)
        written.append(path)
        print(f"wrote {path}")
    print(f"OK: {len(written)} files")


if __name__ == "__main__":
    main()

from pptx.util import Emu, Pt
from pptx.dml.color import RGBColor
from pptx.enum.shapes import MSO_SHAPE
from pptx.enum.text import PP_ALIGN, MSO_ANCHOR


def _rgb(hex_):
    return RGBColor.from_string(hex_.lstrip("#"))


def _lerp_hex(h1, h2, t):
    t = max(0.0, min(1.0, t))
    h1 = h1.lstrip("#")
    h2 = h2.lstrip("#")
    r1, g1, b1 = int(h1[0:2], 16), int(h1[2:4], 16), int(h1[4:6], 16)
    r2, g2, b2 = int(h2[0:2], 16), int(h2[2:4], 16), int(h2[4:6], 16)
    r = round(r1 + (r2 - r1) * t)
    g = round(g1 + (g2 - g1) * t)
    b = round(b1 + (b2 - b1) * t)
    return f"#{r:02X}{g:02X}{b:02X}"


def _luminance(hex_):
    h = hex_.lstrip("#")
    r = int(h[0:2], 16) / 255.0
    g = int(h[2:4], 16) / 255.0
    b = int(h[4:6], 16) / 255.0
    return 0.2126 * r + 0.7152 * g + 0.0722 * b


def _set_text(tf, text, font_name, size_pt, color_hex, bold=False, align=PP_ALIGN.CENTER, anchor=MSO_ANCHOR.MIDDLE):
    tf.word_wrap = True
    tf.margin_left = Emu(0)
    tf.margin_right = Emu(0)
    tf.margin_top = Emu(0)
    tf.margin_bottom = Emu(0)
    tf.vertical_anchor = anchor
    p = tf.paragraphs[0]
    p.alignment = align
    if p.runs:
        for r in list(p.runs):
            r.text = ""
    run = p.add_run()
    run.text = str(text)
    run.font.name = font_name
    run.font.size = Pt(size_pt)
    run.font.bold = bold
    run.font.color.rgb = _rgb(color_hex)


def _add_rect(slide, x, y, w, h, fill_hex, line_hex=None, line_w_emu=0, radius_emu=0):
    shape_type = MSO_SHAPE.ROUNDED_RECTANGLE if radius_emu > 0 else MSO_SHAPE.RECTANGLE
    shp = slide.shapes.add_shape(shape_type, Emu(int(x)), Emu(int(y)), Emu(int(w)), Emu(int(h)))
    if radius_emu > 0:
        try:
            short = min(w, h)
            adj = max(0.0, min(0.5, (radius_emu / short)))
            shp.adjustments[0] = adj
        except Exception:
            pass
    shp.shadow.inherit = False
    shp.fill.solid()
    shp.fill.fore_color.rgb = _rgb(fill_hex)
    if line_hex is None or line_w_emu <= 0:
        shp.line.fill.background()
    else:
        shp.line.color.rgb = _rgb(line_hex)
        shp.line.width = Emu(int(line_w_emu))
    shp.text_frame.text = ""
    tf = shp.text_frame
    tf.margin_left = Emu(0)
    tf.margin_right = Emu(0)
    tf.margin_top = Emu(0)
    tf.margin_bottom = Emu(0)
    return shp


def _add_textbox(slide, x, y, w, h, text, font_name, size_pt, color_hex, bold=False, align=PP_ALIGN.CENTER, anchor=MSO_ANCHOR.MIDDLE):
    tb = slide.shapes.add_textbox(Emu(int(x)), Emu(int(y)), Emu(int(w)), Emu(int(h)))
    _set_text(tb.text_frame, text, font_name, size_pt, color_hex, bold=bold, align=align, anchor=anchor)
    return tb


def render(slide, data, tokens, bounds):
    x, y, w, h = bounds

    row_labels = list(data.get("row_labels", []))
    col_labels = list(data.get("col_labels", []))
    values = data.get("values", [])
    title = data.get("title")
    show_values = bool(data.get("show_values", False))
    value_format = data.get("value_format", "{:.2f}")

    n_rows = len(row_labels)
    n_cols = len(col_labels)
    if n_rows == 0 or n_cols == 0 or not values:
        return None

    flat = [v for row in values for v in row]
    vmin = data.get("value_min")
    vmax = data.get("value_max")
    if vmin is None:
        vmin = min(flat) if flat else 0.0
    if vmax is None:
        vmax = max(flat) if flat else 1.0
    if vmax == vmin:
        vmax = vmin + 1.0

    bg_hex = tokens["bg"]
    primary_hex = tokens["primary"]
    text_hex = tokens["text"]
    muted_hex = tokens["muted"]
    font_body = tokens["font_body"]
    font_display = tokens["font_display"]
    font_mono = tokens["font_mono"]
    base_pt = int(tokens["font_size_base_pt"])
    radius_px = int(tokens.get("radius_px") or 0)
    radius_emu = radius_px * 9525

    label_pt = max(7, int(round(base_pt * 0.72)))
    title_pt = max(base_pt + 2, int(round(base_pt * 1.15)))
    cell_value_pt = max(6, int(round(base_pt * 0.55)))
    legend_pt = max(6, int(round(base_pt * 0.6)))

    title_h = 0
    if title:
        title_h = int(Pt(title_pt * 1.6))

    legend_h = int(Pt(base_pt * 2.2))

    row_label_w = int(Pt(base_pt * 2.6))
    col_label_h = int(Pt(base_pt * 1.4))

    for lbl in row_labels:
        est = int(Pt(base_pt * 0.55 * max(3, len(str(lbl)))))
        if est > row_label_w:
            row_label_w = est
    row_label_w = min(row_label_w, int(w * 0.22))

    inner_x = x
    inner_y = y + title_h
    inner_w = w
    inner_h = h - title_h - legend_h

    grid_x = inner_x + row_label_w
    grid_y = inner_y + col_label_h
    grid_w = inner_w - row_label_w
    grid_h = inner_h - col_label_h

    gap = max(1, int(Emu(0.5 * 9525)))
    cell_w = (grid_w - gap * (n_cols - 1)) / n_cols
    cell_h = (grid_h - gap * (n_rows - 1)) / n_rows

    if title:
        _add_textbox(
            slide,
            x, y, w, title_h,
            title,
            font_display,
            title_pt,
            text_hex,
            bold=True,
            align=PP_ALIGN.LEFT,
            anchor=MSO_ANCHOR.TOP,
        )

    for ci, cl in enumerate(col_labels):
        cx = grid_x + ci * (cell_w + gap)
        _add_textbox(
            slide,
            int(cx), int(inner_y), int(cell_w), int(col_label_h),
            cl,
            font_body,
            label_pt,
            muted_hex,
            align=PP_ALIGN.CENTER,
            anchor=MSO_ANCHOR.MIDDLE,
        )

    for ri, rl in enumerate(row_labels):
        ry = grid_y + ri * (cell_h + gap)
        pad_right = int(Pt(base_pt * 0.3))
        _add_textbox(
            slide,
            int(inner_x), int(ry), int(row_label_w - pad_right), int(cell_h),
            rl,
            font_body,
            label_pt,
            muted_hex,
            align=PP_ALIGN.RIGHT,
            anchor=MSO_ANCHOR.MIDDLE,
        )

    for ri in range(n_rows):
        row = values[ri] if ri < len(values) else []
        for ci in range(n_cols):
            v = row[ci] if ci < len(row) else vmin
            try:
                t = (float(v) - float(vmin)) / (float(vmax) - float(vmin))
            except Exception:
                t = 0.0
            t = max(0.0, min(1.0, t))
            fill_hex = _lerp_hex(bg_hex, primary_hex, t)

            cx = grid_x + ci * (cell_w + gap)
            cy = grid_y + ri * (cell_h + gap)

            _add_rect(
                slide,
                cx, cy, cell_w, cell_h,
                fill_hex,
                line_hex=muted_hex,
                line_w_emu=int(Emu(0.25 * 9525)),
                radius_emu=radius_emu,
            )

            if show_values:
                try:
                    vtxt = value_format.format(v)
                except Exception:
                    vtxt = str(v)
                cell_lum = _luminance(fill_hex)
                bg_lum = _luminance(bg_hex)
                if bg_lum < 0.5:
                    label_color = text_hex if cell_lum < 0.55 else bg_hex
                else:
                    label_color = bg_hex if cell_lum < 0.45 else text_hex
                _add_textbox(
                    slide,
                    int(cx), int(cy), int(cell_w), int(cell_h),
                    vtxt,
                    font_mono,
                    cell_value_pt,
                    label_color,
                    align=PP_ALIGN.CENTER,
                    anchor=MSO_ANCHOR.MIDDLE,
                )

    legend_y = inner_y + inner_h
    legend_w = int(min(inner_w * 0.35, Pt(base_pt * 14)))
    legend_x = x + w - legend_w
    legend_bar_h = int(Pt(base_pt * 0.55))
    legend_bar_y = legend_y + int(Pt(base_pt * 0.3))

    steps = 24
    step_w = legend_w / steps
    for i in range(steps):
        t = i / (steps - 1) if steps > 1 else 0.0
        fill_hex = _lerp_hex(bg_hex, primary_hex, t)
        sx = legend_x + i * step_w
        _add_rect(
            slide,
            sx, legend_bar_y, step_w + Emu(1), legend_bar_h,
            fill_hex,
            line_hex=None,
            line_w_emu=0,
            radius_emu=0,
        )

    try:
        min_lbl = value_format.format(vmin)
        max_lbl = value_format.format(vmax)
    except Exception:
        min_lbl = f"{vmin}"
        max_lbl = f"{vmax}"

    lbl_y = legend_bar_y + legend_bar_h + int(Pt(base_pt * 0.15))
    lbl_h = int(Pt(legend_pt * 1.4))
    _add_textbox(
        slide,
        int(legend_x), int(lbl_y), int(legend_w / 2), lbl_h,
        min_lbl,
        font_mono,
        legend_pt,
        muted_hex,
        align=PP_ALIGN.LEFT,
        anchor=MSO_ANCHOR.TOP,
    )
    _add_textbox(
        slide,
        int(legend_x + legend_w / 2), int(lbl_y), int(legend_w / 2), lbl_h,
        max_lbl,
        font_mono,
        legend_pt,
        muted_hex,
        align=PP_ALIGN.RIGHT,
        anchor=MSO_ANCHOR.TOP,
    )

    return None

"""Render KPI tiles in all 5 modes. Generates one .pptx per mode."""

import os
import sys

from pptx import Presentation
from pptx.util import Emu, Inches

HERE = os.path.dirname(os.path.abspath(__file__))
sys.path.insert(0, HERE)
sys.path.insert(0, os.path.dirname(HERE))  # charts/ for shared tokens module

from tokens import MODES  # noqa: E402
from render import render, _rgb  # noqa: E402
from pptx.enum.shapes import MSO_SHAPE  # noqa: E402


TILES = [
    {
        "label": "ARR",
        "value": "$47.2M",
        "delta": "+12.4% vs plan",
        "delta_direction": "up",
        "footnote": "Source: NetSuite, Apr 10",
    },
    {
        "label": "Gross Margin",
        "value": "72.8%",
        "delta": "-1.1 pts QoQ",
        "delta_direction": "down",
        "footnote": "Non-GAAP, ex. one-time",
    },
    {
        "label": "NPS",
        "value": "64",
        "delta": "+6 vs Q4",
        "delta_direction": "up",
        "footnote": "n=1,842, mixed segment",
    },
]


def _paint_slide_bg(slide, hex_):
    bg = slide.shapes.add_shape(
        MSO_SHAPE.RECTANGLE, 0, 0,
        slide.part.package.presentation_part.presentation.slide_width,
        slide.part.package.presentation_part.presentation.slide_height,
    )
    bg.fill.solid()
    bg.fill.fore_color.rgb = _rgb(hex_)
    bg.line.fill.background()
    # Send to back.
    spTree = bg._element.getparent()
    spTree.remove(bg._element)
    spTree.insert(2, bg._element)


def build(mode, tokens):
    prs = Presentation()
    prs.slide_width = Inches(13.333)
    prs.slide_height = Inches(7.5)
    slide = prs.slides.add_slide(prs.slide_layouts[6])  # blank

    _paint_slide_bg(slide, tokens["bg"])

    sw = prs.slide_width
    sh = prs.slide_height

    # Layout: 3 tiles side-by-side.
    margin_x = int(sw * 0.06)
    margin_y_top = int(sh * 0.22)
    gutter = int(sw * 0.03)
    tile_area_w = sw - 2 * margin_x
    tile_w = (tile_area_w - 2 * gutter) // 3
    tile_h = int(sh * 0.48)

    for i, tile in enumerate(TILES):
        bx = margin_x + i * (tile_w + gutter)
        by = margin_y_top
        render(slide, tile, tokens, (bx, by, tile_w, tile_h))

    out = os.path.join(HERE, f"example-{mode}.pptx")
    prs.save(out)
    return out


def main():
    for mode, tokens in MODES.items():
        path = build(mode, tokens)
        print(f"wrote {path}")


if __name__ == "__main__":
    main()

"""KPI tile — big-number, label, delta, footnote."""

from pptx.util import Emu, Pt
from pptx.dml.color import RGBColor
from pptx.enum.shapes import MSO_SHAPE
from pptx.enum.text import PP_ALIGN, MSO_ANCHOR


def _rgb(hex_):
    return RGBColor.from_string(hex_.lstrip("#"))


_LIGHT_BG_HEXES = {"F6F1E8", "FFF4EB", "FFFFFF", "FCFBF8"}


def _is_dark_mode(bg_hex):
    return bg_hex.lstrip("#").upper() not in _LIGHT_BG_HEXES


def _add_textbox(slide, x, y, w, h, text, *, font, size_pt, color_hex,
                 bold=False, align=PP_ALIGN.LEFT, anchor=MSO_ANCHOR.TOP,
                 letter_spacing=None):
    tb = slide.shapes.add_textbox(Emu(int(x)), Emu(int(y)), Emu(int(w)), Emu(int(h)))
    tf = tb.text_frame
    tf.margin_left = Emu(0)
    tf.margin_right = Emu(0)
    tf.margin_top = Emu(0)
    tf.margin_bottom = Emu(0)
    tf.word_wrap = True
    tf.vertical_anchor = anchor
    p = tf.paragraphs[0]
    p.alignment = align
    run = p.add_run()
    run.text = text
    f = run.font
    f.name = font
    f.size = Pt(size_pt)
    f.bold = bold
    f.color.rgb = _rgb(color_hex)
    return tb


def render(slide, data, tokens, bounds):
    x, y, w, h = bounds

    label = data.get("label", "")
    value = data.get("value", "")
    delta = data.get("delta")
    direction = data.get("delta_direction")
    footnote = data.get("footnote")

    bg_hex = tokens["bg"]
    text_hex = tokens["text"]
    muted_hex = tokens["muted"]
    primary_hex = tokens["primary"]
    accent_hex = tokens["accent"]
    font_display = tokens["font_display"]
    font_body = tokens["font_body"]
    font_mono = tokens["font_mono"]
    base_pt = tokens["font_size_base_pt"]
    radius_px = tokens.get("radius_px", 0) or 0
    dark = _is_dark_mode(bg_hex)

    # Tile background — subtle rounded rect with hairline border.
    radius_emu = Emu(int(radius_px * 9525))  # px → EMU (approx 9525 EMU/px)
    if radius_px > 0:
        tile = slide.shapes.add_shape(MSO_SHAPE.ROUNDED_RECTANGLE,
                                      Emu(int(x)), Emu(int(y)),
                                      Emu(int(w)), Emu(int(h)))
        # python-pptx rounded-rect adjustment is relative (0.0–~0.5).
        try:
            short_side = min(w, h)
            adj = max(0.0, min(0.5, float(radius_emu) / float(short_side)))
            tile.adjustments[0] = adj
        except Exception:
            pass
    else:
        tile = slide.shapes.add_shape(MSO_SHAPE.RECTANGLE,
                                      Emu(int(x)), Emu(int(y)),
                                      Emu(int(w)), Emu(int(h)))

    tile.fill.solid()
    tile.fill.fore_color.rgb = _rgb(bg_hex)
    tile.line.color.rgb = _rgb(muted_hex)
    tile.line.width = Emu(6350)  # 0.5 pt hairline
    # Remove default shadow.
    try:
        sp = tile.shadow
        sp.inherit = False
    except Exception:
        pass

    # Padding inside tile.
    pad_x = int(w * 0.07)
    pad_y = int(h * 0.09)
    inner_x = x + pad_x
    inner_y = y + pad_y
    inner_w = w - 2 * pad_x
    inner_h = h - 2 * pad_y

    # Label (top, small caps-ish via font).
    label_size = max(8, int(base_pt * 0.78))
    label_h = Pt(label_size).emu * 1.5
    _add_textbox(slide, inner_x, inner_y, inner_w, label_h,
                 label.upper() if label else "",
                 font=font_body, size_pt=label_size,
                 color_hex=muted_hex, bold=True, align=PP_ALIGN.LEFT)

    # Value — hero number. Size based on tile height.
    value_pt_from_h = (h / 12700.0) * 0.22
    value_pt = max(36, min(int(value_pt_from_h), 96))
    # Shrink if the string is long relative to width.
    est_char_w_emu = Pt(value_pt).emu * 0.55
    est_w = est_char_w_emu * max(1, len(value))
    if est_w > inner_w:
        scale = inner_w / est_w
        value_pt = max(28, int(value_pt * scale))

    value_h = Pt(value_pt).emu * 1.2
    value_y = inner_y + label_h + Pt(base_pt * 0.35).emu
    _add_textbox(slide, inner_x, value_y, inner_w, value_h,
                 value,
                 font=font_display, size_pt=value_pt,
                 color_hex=text_hex, bold=True, align=PP_ALIGN.LEFT,
                 anchor=MSO_ANCHOR.TOP)

    # Neon underline under the hero number in dark mode (sv-keynote signature).
    if dark:
        underline_w = int(inner_w * 0.18)
        underline_h = Emu(int(Pt(3).emu))
        underline_y = value_y + value_h + Pt(base_pt * 0.15).emu
        ul = slide.shapes.add_shape(MSO_SHAPE.RECTANGLE,
                                    Emu(int(inner_x)), Emu(int(underline_y)),
                                    Emu(int(underline_w)), underline_h)
        ul.fill.solid()
        ul.fill.fore_color.rgb = _rgb(primary_hex)
        ul.line.fill.background()
    else:
        underline_y = value_y + value_h
        underline_h = 0

    # Delta — under the value.
    delta_y = (underline_y + (Pt(base_pt * 0.45).emu if dark else Pt(base_pt * 0.25).emu)
               + (int(underline_h) if dark else 0))
    if delta:
        if direction == "up":
            delta_color = accent_hex
            glyph = "\u25B2 "  # ▲
        elif direction == "down":
            delta_color = primary_hex if not dark else accent_hex
            # If primary is the same hue family as up-accent we already got,
            # fall back to muted to signal "attention" without clashing.
            if delta_color == accent_hex:
                delta_color = muted_hex
            glyph = "\u25BC "  # ▼
        else:
            delta_color = muted_hex
            glyph = ""

        delta_pt = max(10, int(base_pt * 0.95))
        delta_h = Pt(delta_pt).emu * 1.5
        _add_textbox(slide, inner_x, delta_y, inner_w, delta_h,
                     f"{glyph}{delta}",
                     font=font_mono, size_pt=delta_pt,
                     color_hex=delta_color, bold=False, align=PP_ALIGN.LEFT)
        delta_y_end = delta_y + delta_h
    else:
        delta_y_end = delta_y

    # Footnote at bottom.
    if footnote:
        foot_pt = max(7, int(base_pt * 0.7))
        foot_h = Pt(foot_pt).emu * 1.4
        foot_y = y + h - pad_y - foot_h
        if foot_y < delta_y_end:
            foot_y = delta_y_end + Pt(base_pt * 0.2).emu
        _add_textbox(slide, inner_x, foot_y, inner_w, foot_h,
                     footnote,
                     font=font_body, size_pt=foot_pt,
                     color_hex=muted_hex, bold=False, align=PP_ALIGN.LEFT)

    return tile