621 lines
25 KiB
Python
621 lines
25 KiB
Python
"""Paint pass — write IR nodes into the CharGrid as characters.
|
|
|
|
Depth-first traversal: each node writes its content at its assigned
|
|
rect position. Containers recurse into children after drawing their
|
|
own structure (borders, etc.).
|
|
"""
|
|
|
|
from __future__ import annotations
|
|
|
|
import re
|
|
import textwrap
|
|
|
|
from uframe.chars import (
|
|
BOX_CHARS, DIVIDER_CHARS, sparkline_chars,
|
|
)
|
|
from uframe.grid import CharGrid, CellStyle
|
|
from uframe.ir import (
|
|
IRNode, Page, Box, Row, Col, Spacer, Pad,
|
|
Heading, Text, Label, Divider, Link, ListNode, ListItem,
|
|
Gauge, Sparkline, Status, Table,
|
|
Form, Field, Password, Radio, Checkbox, FormButton,
|
|
BigTitle, ImageNode, HNav, VNav,
|
|
HeadingLevel, DividerStyle, ListStyle, Align, BorderWeight,
|
|
)
|
|
from uframe.themes import ThemeDef, THEME_DEFAULT
|
|
from uframe.fonts import render_big_text, get_text_width, FONT_HEIGHTS
|
|
from uframe.imaging import convert_image
|
|
|
|
|
|
def _align_text(text: str, width: int, align: Align) -> str:
|
|
"""Align text within a field of the given width."""
|
|
if len(text) >= width:
|
|
return text[:width]
|
|
if align == Align.CENTER:
|
|
return text.center(width)
|
|
elif align == Align.RIGHT:
|
|
return text.rjust(width)
|
|
return text.ljust(width)
|
|
|
|
|
|
def _style_from_node(node: IRNode) -> CellStyle:
|
|
"""Create a CellStyle from a node's style attributes."""
|
|
return CellStyle(
|
|
fg=node.style.fg,
|
|
bg=node.style.bg,
|
|
bold=node.style.bold,
|
|
italic=node.style.italic,
|
|
underline=node.style.underline,
|
|
)
|
|
|
|
|
|
def paint(node: IRNode, grid: CharGrid, theme: ThemeDef | None = None) -> None:
|
|
"""Recursively paint an IR node and its children into the grid."""
|
|
th = theme or THEME_DEFAULT
|
|
x, y, w = node.rect.x, node.rect.y, node.rect.w
|
|
|
|
# Ensure grid is tall enough
|
|
grid.grow_height(y + node.rect.h)
|
|
|
|
if isinstance(node, Page):
|
|
for child in node.children:
|
|
paint(child, grid, th)
|
|
|
|
elif isinstance(node, Box):
|
|
# Draw the border with themed characters
|
|
title_style = CellStyle(bold=True, fg=node.style.fg or th.palette.accent)
|
|
grid.draw_border(x, y, w, node.rect.h,
|
|
weight=node.weight,
|
|
title=node.title,
|
|
title_style=title_style,
|
|
border_chars=th.border_dict(node.weight.name.lower()),
|
|
title_caps=(th.title_caps.left, th.title_caps.right))
|
|
# Propagate box alignment/color to children that don't have their own
|
|
for child in node.children:
|
|
if node.style.align != Align.LEFT and child.style.align == Align.LEFT:
|
|
child.style.align = node.style.align
|
|
if node.style.fg and not child.style.fg:
|
|
child.style.fg = node.style.fg
|
|
paint(child, grid, th)
|
|
|
|
elif isinstance(node, Row):
|
|
for child in node.children:
|
|
paint(child, grid, th)
|
|
|
|
elif isinstance(node, Col):
|
|
for child in node.children:
|
|
paint(child, grid, th)
|
|
|
|
elif isinstance(node, Spacer):
|
|
pass # Just empty space
|
|
|
|
elif isinstance(node, Pad):
|
|
for child in node.children:
|
|
paint(child, grid, th)
|
|
|
|
elif isinstance(node, Heading):
|
|
style = CellStyle(bold=True)
|
|
if node.level == HeadingLevel.H1:
|
|
style.fg = th.palette.accent
|
|
elif node.level == HeadingLevel.H2:
|
|
style.fg = th.palette.accent2
|
|
elif node.level == HeadingLevel.H3:
|
|
style.fg = th.palette.accent3
|
|
|
|
# Underline-style heading
|
|
grid.put_text(x, y, node.text[:w], style=style)
|
|
|
|
elif isinstance(node, Text):
|
|
style = _style_from_node(node)
|
|
|
|
if node.spans and any(
|
|
s.bold or s.italic or s.underline or s.fg or s.bg
|
|
for s in node.spans
|
|
):
|
|
# Render with inline spans
|
|
col = x
|
|
row = y
|
|
for span in node.spans:
|
|
span_style = CellStyle(
|
|
fg=span.fg or style.fg,
|
|
bg=span.bg or style.bg,
|
|
bold=span.bold or style.bold,
|
|
italic=span.italic or style.italic,
|
|
underline=span.underline or style.underline,
|
|
)
|
|
for ch in span.text:
|
|
if col >= x + w:
|
|
col = x
|
|
row += 1
|
|
if grid.in_bounds(col, row):
|
|
grid.put(col, row, ch, style=span_style)
|
|
col += 1
|
|
else:
|
|
# Simple text with word wrapping
|
|
wrapped = textwrap.wrap(node.content, width=w) if node.content else [""]
|
|
for i, line in enumerate(wrapped):
|
|
if y + i < grid.height:
|
|
text = _align_text(line, w, node.style.align)
|
|
grid.put_text(x, y + i, text, style=style)
|
|
|
|
elif isinstance(node, Label):
|
|
style = _style_from_node(node)
|
|
key_style = CellStyle(bold=True, fg=style.fg, bg=style.bg)
|
|
# Key: value layout with padding
|
|
key_text = f"{node.key}:"
|
|
pad = max(1, 16 - len(key_text))
|
|
grid.put_text(x, y, key_text, style=key_style)
|
|
grid.put_text(x + len(key_text) + pad, y, node.value, style=style)
|
|
|
|
elif isinstance(node, Divider):
|
|
ds = node.divider_style
|
|
char = getattr(th.dividers, ds.name.lower(), th.dividers.light)
|
|
style = CellStyle(fg=th.palette.muted)
|
|
for col in range(x, x + w):
|
|
grid.put(col, y, char, style=style)
|
|
|
|
elif isinstance(node, Link):
|
|
style = CellStyle(fg=th.palette.info, underline=True)
|
|
grid.put_text(x, y, node.display[:w], style=style, link=node.dest)
|
|
|
|
elif isinstance(node, ListNode):
|
|
for child in node.children:
|
|
paint(child, grid, th)
|
|
|
|
elif isinstance(node, ListItem):
|
|
style = _style_from_node(node)
|
|
# Bullet to the left of the content (safe: put_text clips to bounds)
|
|
bullet_x = max(0, x - 2)
|
|
grid.put_text(bullet_x, y, f"{th.ornaments.bullet} ", style=CellStyle(fg=th.palette.label))
|
|
# Wrap content
|
|
wrapped = textwrap.wrap(node.content, width=w) if node.content else [""]
|
|
for i, line in enumerate(wrapped):
|
|
if y + i < grid.height:
|
|
grid.put_text(x, y + i, line, style=style)
|
|
|
|
elif isinstance(node, Gauge):
|
|
style = _style_from_node(node)
|
|
# Label
|
|
label_text = f"{node.label} "
|
|
grid.put_text(x, y, label_text, style=CellStyle(bold=True))
|
|
|
|
bar_x = x + len(label_text)
|
|
bar_w = min(node.bar_width, w - len(label_text) - 6)
|
|
|
|
if bar_w > 0:
|
|
pct = min(node.value / node.max_val, 1.0) if node.max_val > 0 else 0
|
|
filled = int(bar_w * pct)
|
|
|
|
# Determine color based on thresholds
|
|
fg = th.palette.success
|
|
if node.crit is not None and node.value >= node.crit:
|
|
fg = th.palette.danger
|
|
elif node.warn is not None and node.value >= node.warn:
|
|
fg = th.palette.warning
|
|
|
|
for i in range(bar_w):
|
|
if i < filled:
|
|
grid.put(bar_x + i, y, th.gauge.filled, style=CellStyle(fg=fg))
|
|
else:
|
|
grid.put(bar_x + i, y, th.gauge.empty, style=CellStyle(fg=th.palette.muted))
|
|
|
|
# Percentage
|
|
pct_text = f" {int(pct * 100)}%"
|
|
grid.put_text(bar_x + bar_w, y, pct_text, style=CellStyle(fg=fg))
|
|
|
|
elif isinstance(node, Sparkline):
|
|
style = _style_from_node(node)
|
|
label_text = f"{node.label} "
|
|
grid.put_text(x, y, label_text, style=CellStyle(bold=True))
|
|
|
|
spark_x = x + len(label_text)
|
|
chars = sparkline_chars(node.values, node.spark_width)
|
|
spark_style = CellStyle(fg=th.palette.info)
|
|
for i, ch in enumerate(chars):
|
|
grid.put(spark_x + i, y, ch, style=spark_style)
|
|
|
|
elif isinstance(node, Status):
|
|
char = getattr(th.indicators, node.state, th.indicators.unknown)
|
|
color_map = {"online": th.palette.success, "offline": th.palette.danger,
|
|
"degraded": th.palette.warning, "unknown": th.palette.label,
|
|
"alert": th.palette.danger}
|
|
color = color_map.get(node.state, th.palette.label)
|
|
grid.put(x, y, char, style=CellStyle(fg=color))
|
|
grid.put_text(x + 2, y, node.label)
|
|
|
|
elif isinstance(node, HNav):
|
|
_paint_hnav(node, grid, x, y, w, th)
|
|
|
|
elif isinstance(node, VNav):
|
|
_paint_vnav(node, grid, x, y, w, th)
|
|
|
|
elif isinstance(node, ImageNode):
|
|
style = CellStyle(fg=node.style.fg or th.palette.accent)
|
|
try:
|
|
lines = convert_image(node.path, node.mode, node.img_width,
|
|
node.dither, node.invert, node.use_color)
|
|
# Center if aligned
|
|
offset = 0
|
|
actual_w = len(lines[0]) if lines else 0
|
|
if node.style.align == Align.CENTER:
|
|
offset = max(0, (w - actual_w) // 2)
|
|
elif node.style.align == Align.RIGHT:
|
|
offset = max(0, w - actual_w)
|
|
|
|
for row_i, line in enumerate(lines):
|
|
if y + row_i < grid.height:
|
|
grid.put_text(x + offset, y + row_i, line, style=style)
|
|
|
|
# Caption
|
|
if node.caption and y + len(lines) < grid.height:
|
|
cap_style = CellStyle(fg=th.palette.label, italic=True)
|
|
grid.put_text(x + offset, y + len(lines), node.caption, style=cap_style)
|
|
except (ImportError, FileNotFoundError) as e:
|
|
# Render placeholder if image can't be loaded
|
|
grid.put_text(x, y, f"[image: {node.path}]", style=CellStyle(fg=th.palette.muted))
|
|
|
|
elif isinstance(node, BigTitle):
|
|
style = CellStyle(fg=node.style.fg or th.palette.accent, bold=True)
|
|
|
|
# Determine which font fits
|
|
font = node.font
|
|
tw = get_text_width(node.text, font)
|
|
if tw > w:
|
|
# Try fallback cascade
|
|
for fallback in ["pixel", "thin"]:
|
|
if get_text_width(node.text, fallback) <= w:
|
|
font = fallback
|
|
tw = get_text_width(node.text, fallback)
|
|
break
|
|
else:
|
|
# Final fallback: styled single line
|
|
styled = f"═══ {node.text.upper()} ═══"
|
|
grid.put_text(x, y, styled[:w], style=style)
|
|
return
|
|
|
|
lines = render_big_text(node.text, font)
|
|
|
|
# Center if align is set
|
|
offset = 0
|
|
if node.style.align == Align.CENTER:
|
|
offset = max(0, (w - tw) // 2)
|
|
elif node.style.align == Align.RIGHT:
|
|
offset = max(0, w - tw)
|
|
|
|
for row_i, line in enumerate(lines):
|
|
if y + row_i < grid.height:
|
|
grid.put_text(x + offset, y + row_i, line, style=style)
|
|
|
|
elif isinstance(node, Table):
|
|
_paint_table(node, grid, x, y, w)
|
|
|
|
elif isinstance(node, Form):
|
|
for child in node.children:
|
|
paint(child, grid, th)
|
|
|
|
elif isinstance(node, Field):
|
|
label_style = CellStyle(fg=th.palette.label)
|
|
field_style = CellStyle(fg=th.palette.form)
|
|
label_text = f"{node.field_name}: "
|
|
grid.put_text(x, y, label_text, style=label_style)
|
|
fl = th.form.field_l
|
|
fr = th.form.field_r
|
|
fx = x + len(label_text)
|
|
fw = min(node.field_width, w - len(label_text) - len(fl) - len(fr))
|
|
grid.put_text(fx, y, fl, style=field_style)
|
|
placeholder = node.placeholder or node.field_name
|
|
inner = placeholder.ljust(fw)[:fw]
|
|
grid.put_text(fx + len(fl), y, inner, style=CellStyle(fg=th.palette.muted))
|
|
grid.put_text(fx + len(fl) + fw, y, fr, style=field_style)
|
|
|
|
elif isinstance(node, Password):
|
|
label_style = CellStyle(fg=th.palette.label)
|
|
field_style = CellStyle(fg=th.palette.form)
|
|
label_text = f"{node.field_name}: "
|
|
grid.put_text(x, y, label_text, style=label_style)
|
|
fl = th.form.field_l
|
|
fr = th.form.field_r
|
|
fx = x + len(label_text)
|
|
fw = min(node.field_width, w - len(label_text) - len(fl) - len(fr))
|
|
grid.put_text(fx, y, fl, style=field_style)
|
|
inner = "•" * fw
|
|
grid.put_text(fx + len(fl), y, inner[:fw], style=CellStyle(fg=th.palette.muted))
|
|
grid.put_text(fx + len(fl) + fw, y, fr, style=field_style)
|
|
|
|
elif isinstance(node, Radio):
|
|
label_style = CellStyle(fg=th.palette.label)
|
|
label_text = f"{node.group}: "
|
|
grid.put_text(x, y, label_text, style=label_style)
|
|
rx = x + len(label_text)
|
|
for i, opt in enumerate(node.options):
|
|
dot = th.form.radio_on if i == 0 else th.form.radio_off
|
|
opt_style = CellStyle(fg=th.palette.form if i == 0 else th.palette.label)
|
|
grid.put_text(rx, y, dot, style=opt_style)
|
|
rx += len(dot) + 1
|
|
grid.put_text(rx, y, opt, style=CellStyle())
|
|
rx += len(opt) + 2
|
|
|
|
elif isinstance(node, Checkbox):
|
|
check_style = CellStyle(fg=th.palette.form)
|
|
box_char = th.form.check_on if node.checked else th.form.check_off
|
|
grid.put_text(x, y, box_char, style=check_style)
|
|
grid.put_text(x + len(box_char) + 1, y, node.checkbox_label)
|
|
|
|
elif isinstance(node, FormButton):
|
|
btn_style = CellStyle(bold=True, fg=th.palette.button)
|
|
btn_text = f"[ {node.button_label} ]"
|
|
grid.put_text(x, y, btn_text, style=btn_style, link=node.dest)
|
|
|
|
else:
|
|
# Generic: paint children
|
|
for child in node.children:
|
|
paint(child, grid, th)
|
|
|
|
|
|
def _paint_hnav(node: HNav, grid: CharGrid, x: int, y: int, w: int, th: ThemeDef) -> None:
|
|
"""Paint a horizontal navigation bar."""
|
|
active_style = CellStyle(bold=True, fg=th.palette.accent)
|
|
link_style = CellStyle(fg=th.palette.info)
|
|
sep_style = CellStyle(fg=th.palette.muted)
|
|
border_style = CellStyle()
|
|
|
|
items = [it for it in node.items if it.kind in ("item", "separator")]
|
|
marker = "▸ "
|
|
|
|
if node.nav_style in ("bar", "tabs", "pills"):
|
|
# Bordered bar
|
|
bc = th.border_dict("light")
|
|
grid.draw_border(x, y, w, 3, border_chars=bc,
|
|
title_caps=(th.title_caps.left, th.title_caps.right))
|
|
col = x + 2
|
|
for it in items:
|
|
if it.kind == "separator":
|
|
grid.put(col, y + 1, "│", style=sep_style)
|
|
col += 2
|
|
continue
|
|
if it.active:
|
|
grid.put_text(col, y + 1, marker, style=active_style)
|
|
col += len(marker)
|
|
grid.put_text(col, y + 1, it.label, style=active_style)
|
|
else:
|
|
grid.put_text(col, y + 1, it.label, style=link_style, link=it.dest)
|
|
col += len(it.label) + 2
|
|
if col < x + w - 2:
|
|
grid.put(col, y + 1, "│", style=sep_style)
|
|
col += 2
|
|
|
|
elif node.nav_style == "breadcrumb":
|
|
col = x + 2
|
|
sep = " ▸ "
|
|
for i, it in enumerate(items):
|
|
if it.kind == "separator":
|
|
continue
|
|
if i > 0:
|
|
grid.put_text(col, y, sep, style=sep_style)
|
|
col += len(sep)
|
|
if it.active:
|
|
grid.put_text(col, y, it.label, style=active_style)
|
|
else:
|
|
grid.put_text(col, y, it.label, style=link_style, link=it.dest)
|
|
col += len(it.label)
|
|
|
|
elif node.nav_style == "underline":
|
|
col = x + 2
|
|
active_start = 0
|
|
active_len = 0
|
|
for i, it in enumerate(items):
|
|
if it.kind == "separator":
|
|
continue
|
|
if it.active:
|
|
active_start = col
|
|
active_len = len(it.label)
|
|
grid.put_text(col, y, it.label, style=active_style)
|
|
else:
|
|
grid.put_text(col, y, it.label, style=link_style, link=it.dest)
|
|
col += len(it.label) + 5
|
|
# Underline beneath active
|
|
if active_len > 0:
|
|
for c in range(active_start, active_start + active_len):
|
|
grid.put(c, y + 1, "━", style=CellStyle(fg=th.palette.accent))
|
|
|
|
|
|
def _paint_vnav(node: VNav, grid: CharGrid, x: int, y: int, w: int, th: ThemeDef) -> None:
|
|
"""Paint a vertical navigation panel."""
|
|
active_style = CellStyle(bold=True, fg=th.palette.accent)
|
|
link_style = CellStyle(fg=th.palette.info)
|
|
heading_style = CellStyle(bold=True, fg=th.palette.muted)
|
|
sep_style = CellStyle(fg=th.palette.muted)
|
|
marker = "▸ "
|
|
|
|
items = node.items
|
|
row_y = y
|
|
|
|
if node.nav_style == "boxed":
|
|
# Draw a box and render items inside
|
|
bc = th.border_dict("light")
|
|
h = node.rect.h
|
|
grid.draw_border(x, y, w, h, border_chars=bc,
|
|
title_caps=(th.title_caps.left, th.title_caps.right))
|
|
row_y = y + 1
|
|
for it in items:
|
|
if it.kind == "separator":
|
|
# Draw internal separator
|
|
for c in range(x + 1, x + w - 1):
|
|
grid.put(c, row_y, bc.get("h", "─"), style=sep_style,
|
|
is_border=True)
|
|
grid.put(x, row_y, "├", style=sep_style, is_border=True)
|
|
grid.put(x + w - 1, row_y, "┤", style=sep_style, is_border=True)
|
|
row_y += 1
|
|
elif it.kind == "heading":
|
|
grid.put_text(x + 2, row_y, it.label.upper(), style=heading_style)
|
|
row_y += 1
|
|
elif it.kind == "item":
|
|
if it.active:
|
|
grid.put_text(x + 2, row_y, marker, style=active_style)
|
|
grid.put_text(x + 2 + len(marker), row_y, it.label, style=active_style)
|
|
else:
|
|
grid.put_text(x + 4, row_y, it.label, style=link_style, link=it.dest)
|
|
row_y += 1
|
|
|
|
elif node.nav_style == "tree":
|
|
for idx, it in enumerate(items):
|
|
if it.kind == "separator":
|
|
for c in range(x, x + w):
|
|
grid.put(c, row_y, "─", style=sep_style)
|
|
row_y += 1
|
|
elif it.kind == "heading":
|
|
grid.put_text(x, row_y, it.label, style=heading_style)
|
|
row_y += 1
|
|
elif it.kind == "item":
|
|
# Determine connector
|
|
remaining = [i for i in items[idx+1:] if i.kind == "item"]
|
|
connector = "└── " if not remaining else "├── "
|
|
grid.put_text(x, row_y, connector, style=sep_style)
|
|
if it.active:
|
|
grid.put_text(x + len(connector), row_y, it.label, style=active_style)
|
|
grid.put_text(x + len(connector) + len(it.label) + 2, row_y, "◀",
|
|
style=CellStyle(fg=th.palette.accent))
|
|
else:
|
|
grid.put_text(x + len(connector), row_y, it.label,
|
|
style=link_style, link=it.dest)
|
|
row_y += 1
|
|
|
|
else:
|
|
# list, sidebar, minimal
|
|
for it in items:
|
|
if it.kind == "separator":
|
|
for c in range(x, min(x + w, x + 16)):
|
|
grid.put(c, row_y, "─", style=sep_style)
|
|
row_y += 1
|
|
elif it.kind == "heading":
|
|
grid.put_text(x, row_y, it.label.upper(), style=heading_style)
|
|
row_y += 1
|
|
elif it.kind == "item":
|
|
if it.active:
|
|
grid.put_text(x, row_y, marker, style=active_style)
|
|
grid.put_text(x + len(marker), row_y, it.label, style=active_style)
|
|
else:
|
|
grid.put_text(x + 2, row_y, it.label, style=link_style, link=it.dest)
|
|
row_y += 1
|
|
|
|
|
|
def _paint_table(node: Table, grid: CharGrid, x: int, y: int, w: int) -> None:
|
|
"""Paint a box-drawn table with header and data rows."""
|
|
if not node.columns:
|
|
return
|
|
|
|
ch = BOX_CHARS[BorderWeight.LIGHT]
|
|
border_style = CellStyle()
|
|
header_style = CellStyle(bold=True)
|
|
|
|
num_cols = len(node.columns)
|
|
|
|
# Calculate column widths
|
|
# If columns have explicit widths, use them. Otherwise distribute evenly.
|
|
col_widths: list[int] = []
|
|
total_explicit = 0
|
|
auto_count = 0
|
|
for _, cw in node.columns:
|
|
if cw > 0:
|
|
col_widths.append(cw)
|
|
total_explicit += cw
|
|
else:
|
|
col_widths.append(0)
|
|
auto_count += 1
|
|
|
|
# Available inner width = total - borders (num_cols + 1 border chars)
|
|
inner_w = w - (num_cols + 1)
|
|
if auto_count > 0:
|
|
auto_each = max(1, (inner_w - total_explicit) // auto_count)
|
|
for i in range(len(col_widths)):
|
|
if col_widths[i] == 0:
|
|
col_widths[i] = auto_each
|
|
|
|
# Compute column x positions (after each left border)
|
|
col_x: list[int] = []
|
|
cx = x + 1 # after left border
|
|
for cw in col_widths:
|
|
col_x.append(cx)
|
|
cx += cw + 1 # +1 for separator
|
|
|
|
table_w = cx - x # total table width including right border
|
|
|
|
row_y = y
|
|
|
|
# ── Top border ──
|
|
grid.put(x, row_y, ch["tl"], border_style, is_border=True, border_weight=BorderWeight.LIGHT)
|
|
grid.put(x + table_w - 1, row_y, ch["tr"], border_style, is_border=True, border_weight=BorderWeight.LIGHT)
|
|
for ci, cw in enumerate(col_widths):
|
|
for j in range(cw):
|
|
grid.put(col_x[ci] + j, row_y, ch["h"], border_style, is_border=True, border_weight=BorderWeight.LIGHT)
|
|
# Column separator on top border
|
|
if ci < num_cols - 1:
|
|
grid.put(col_x[ci] + cw, row_y, ch["t_down"], border_style, is_border=True, border_weight=BorderWeight.LIGHT)
|
|
row_y += 1
|
|
|
|
# ── Header row ──
|
|
grid.put(x, row_y, ch["v"], border_style, is_border=True, border_weight=BorderWeight.LIGHT)
|
|
for ci, (col_name, _) in enumerate(node.columns):
|
|
text = col_name[:col_widths[ci]].ljust(col_widths[ci])
|
|
grid.put_text(col_x[ci], row_y, text, style=header_style)
|
|
sep_x = col_x[ci] + col_widths[ci]
|
|
grid.put(sep_x, row_y, ch["v"], border_style, is_border=True, border_weight=BorderWeight.LIGHT)
|
|
row_y += 1
|
|
|
|
# ── Header separator ──
|
|
grid.put(x, row_y, ch["t_right"], border_style, is_border=True, border_weight=BorderWeight.LIGHT)
|
|
grid.put(x + table_w - 1, row_y, ch["t_left"], border_style, is_border=True, border_weight=BorderWeight.LIGHT)
|
|
for ci, cw in enumerate(col_widths):
|
|
for j in range(cw):
|
|
grid.put(col_x[ci] + j, row_y, ch["h"], border_style, is_border=True, border_weight=BorderWeight.LIGHT)
|
|
if ci < num_cols - 1:
|
|
grid.put(col_x[ci] + cw, row_y, ch["cross"], border_style, is_border=True, border_weight=BorderWeight.LIGHT)
|
|
row_y += 1
|
|
|
|
# ── Data rows ──
|
|
cell_style = CellStyle()
|
|
for row_data in node.rows:
|
|
grid.put(x, row_y, ch["v"], border_style, is_border=True, border_weight=BorderWeight.LIGHT)
|
|
for ci in range(num_cols):
|
|
cell_text = row_data[ci] if ci < len(row_data) else ""
|
|
text = cell_text[:col_widths[ci]].ljust(col_widths[ci])
|
|
|
|
# Check for @color{hex}{text} modifiers in cell content
|
|
if "@" in cell_text:
|
|
pattern = re.compile(r"@color\{([0-9a-fA-F]{3})\}\{([^}]*)\}")
|
|
pos = 0
|
|
styled_parts: list[tuple[str, CellStyle]] = []
|
|
for m in pattern.finditer(cell_text):
|
|
if m.start() > pos:
|
|
styled_parts.append((cell_text[pos:m.start()], cell_style))
|
|
styled_parts.append((m.group(2), CellStyle(fg=m.group(1))))
|
|
pos = m.end()
|
|
if pos < len(cell_text):
|
|
styled_parts.append((cell_text[pos:], cell_style))
|
|
|
|
col_pos = col_x[ci]
|
|
for part_text, part_style in styled_parts:
|
|
for pch in part_text:
|
|
if col_pos < col_x[ci] + col_widths[ci]:
|
|
grid.put(col_pos, row_y, pch, style=part_style)
|
|
col_pos += 1
|
|
# Pad remaining
|
|
while col_pos < col_x[ci] + col_widths[ci]:
|
|
grid.put(col_pos, row_y, " ")
|
|
col_pos += 1
|
|
else:
|
|
grid.put_text(col_x[ci], row_y, text, style=cell_style)
|
|
|
|
sep_x = col_x[ci] + col_widths[ci]
|
|
grid.put(sep_x, row_y, ch["v"], border_style, is_border=True, border_weight=BorderWeight.LIGHT)
|
|
row_y += 1
|
|
|
|
# ── Bottom border ──
|
|
grid.put(x, row_y, ch["bl"], border_style, is_border=True, border_weight=BorderWeight.LIGHT)
|
|
grid.put(x + table_w - 1, row_y, ch["br"], border_style, is_border=True, border_weight=BorderWeight.LIGHT)
|
|
for ci, cw in enumerate(col_widths):
|
|
for j in range(cw):
|
|
grid.put(col_x[ci] + j, row_y, ch["h"], border_style, is_border=True, border_weight=BorderWeight.LIGHT)
|
|
if ci < num_cols - 1:
|
|
grid.put(col_x[ci] + cw, row_y, ch["t_up"], border_style, is_border=True, border_weight=BorderWeight.LIGHT)
|