1326 lines
43 KiB
Python
1326 lines
43 KiB
Python
"""DrawingML <p:txBody> -> SVG <text> conversion.
|
|
|
|
Reverse of svg_to_pptx/drawingml/elements.py convert_text.
|
|
|
|
Strategy (v1):
|
|
- Each <a:p> paragraph emits one <text> element (one line of baseline).
|
|
Multiple <a:r> runs in one paragraph become <tspan>s sharing the text
|
|
element's x.
|
|
- Vertical layout: y of first paragraph is determined by anchor (t/ctr/b)
|
|
and tIns/bIns. Subsequent paragraphs stack downward with line height
|
|
derived from the largest font in the paragraph * 1.2 (default leading).
|
|
- Horizontal layout: text-anchor follows pPr@algn. x is computed from the
|
|
text frame plus lIns/rIns and the alignment.
|
|
- No automatic word wrap (PPT's wrap is layout-time; v1 trusts the existing
|
|
text frame width and emits text as-is). a:br produces an explicit linebreak.
|
|
- Bullet points (a:buChar / a:buAutoNum) are rendered as literal prefixes
|
|
so the visual lands without relying on PowerPoint list semantics.
|
|
|
|
Color / font / size attributes propagate from a:rPr; missing attributes fall
|
|
back to paragraph/list defaults, endParaRPr, or spec-default values.
|
|
"""
|
|
|
|
from __future__ import annotations
|
|
|
|
from dataclasses import dataclass, field
|
|
from xml.etree import ElementTree as ET
|
|
|
|
from svg_to_pptx.drawingml.utils import detect_text_lang, is_cjk_char
|
|
|
|
from .color_resolver import ColorPalette, find_color_elem, resolve_color
|
|
from .emu_units import (
|
|
NS, Xfrm, fmt_num, emu_to_px, format_ooxml_alpha,
|
|
hundredths_pt_to_px,
|
|
)
|
|
from .fill_to_svg import resolve_fill
|
|
|
|
|
|
# ---------------------------------------------------------------------------
|
|
# Defaults (matches DrawingML spec)
|
|
# ---------------------------------------------------------------------------
|
|
|
|
# Default body insets when bodyPr omits them: 0.1 inch left/right, 0.05 top/bot.
|
|
DEFAULT_INSETS_EMU = {"l": 91440, "t": 45720, "r": 91440, "b": 45720}
|
|
|
|
# Default font size = 1800 (= 18 pt = 24 px). Spec is actually 1800 (18pt).
|
|
DEFAULT_FONT_SIZE_PX = 24.0
|
|
DEFAULT_LINE_HEIGHT_RATIO = 1.2 # leading multiplier
|
|
DEFAULT_FILL_HEX = "#000000"
|
|
|
|
|
|
@dataclass
|
|
class TextRun:
|
|
"""A single run with resolved style + text."""
|
|
|
|
text: str
|
|
font_size_px: float
|
|
font_family: str # full font-family stack (latin, ea fallback joined)
|
|
fill: str
|
|
fill_opacity: float = 1.0
|
|
defs: list[str] = field(default_factory=list)
|
|
bold: bool = False
|
|
italic: bool = False
|
|
underline: bool = False
|
|
strikethrough: bool = False
|
|
letter_spacing_px: float = 0.0
|
|
is_break: bool = False # marks an a:br within a paragraph
|
|
|
|
|
|
@dataclass
|
|
class TextParagraph:
|
|
"""One <a:p>: a list of runs sharing alignment + level."""
|
|
|
|
runs: list[TextRun] = field(default_factory=list)
|
|
align: str = "l" # l / ctr / r / just / dist
|
|
level: int = 0
|
|
indent_px: float = 0.0
|
|
margin_left_px: float = 0.0
|
|
line_height_ratio: float = DEFAULT_LINE_HEIGHT_RATIO
|
|
space_before_px: float = 0.0
|
|
space_after_px: float = 0.0
|
|
empty_line_font_size_px: float = DEFAULT_FONT_SIZE_PX
|
|
bullet_prefix: str = "" # rendered prefix like '• ' or '1. '
|
|
|
|
|
|
@dataclass
|
|
class TextResult:
|
|
"""Resolved text body ready for SVG emission.
|
|
|
|
`svg` is one or more <text> elements, already absolutely positioned
|
|
inside the slide coordinate system. `defs` holds text gradient fills.
|
|
"""
|
|
|
|
svg: str = ""
|
|
defs: list[str] = field(default_factory=list)
|
|
|
|
|
|
VERTICAL_TEXT_MODES = {"eaVert", "vert", "wordArtVert", "wordArtVertRtl"}
|
|
|
|
|
|
# ---------------------------------------------------------------------------
|
|
# Public API
|
|
# ---------------------------------------------------------------------------
|
|
|
|
def convert_txbody(
|
|
tx_body: ET.Element | None,
|
|
xfrm: Xfrm,
|
|
palette: ColorPalette | None,
|
|
*,
|
|
theme_fonts: dict[str, str] | None = None,
|
|
slide_number: int | None = None,
|
|
default_fill: str = DEFAULT_FILL_HEX,
|
|
default_font_size_px: float = DEFAULT_FONT_SIZE_PX,
|
|
fallback_lst_styles: tuple[ET.Element, ...] = (),
|
|
fallback_run_props: tuple[ET.Element, ...] = (),
|
|
id_prefix: str = "txt",
|
|
id_seq: list[int] | None = None,
|
|
) -> TextResult:
|
|
"""Convert <p:txBody> under the given shape geometry to SVG <text>(s)."""
|
|
if tx_body is None:
|
|
return TextResult()
|
|
|
|
body_pr = tx_body.find("a:bodyPr", NS)
|
|
paragraphs = _parse_paragraphs(
|
|
tx_body, palette, theme_fonts or {}, default_fill=default_fill,
|
|
default_font_size_px=default_font_size_px,
|
|
fallback_lst_styles=fallback_lst_styles,
|
|
fallback_run_props=fallback_run_props,
|
|
slide_number=slide_number, id_prefix=id_prefix, id_seq=id_seq,
|
|
)
|
|
if not paragraphs or not _has_visible_text(paragraphs):
|
|
return TextResult()
|
|
|
|
# Insets + anchor + wrap
|
|
lins = _read_emu_attr(body_pr, "lIns", DEFAULT_INSETS_EMU["l"])
|
|
tins = _read_emu_attr(body_pr, "tIns", DEFAULT_INSETS_EMU["t"])
|
|
rins = _read_emu_attr(body_pr, "rIns", DEFAULT_INSETS_EMU["r"])
|
|
bins = _read_emu_attr(body_pr, "bIns", DEFAULT_INSETS_EMU["b"])
|
|
anchor = body_pr.attrib.get("anchor", "t") if body_pr is not None else "t"
|
|
wrap_mode = body_pr.attrib.get("wrap", "square") if body_pr is not None else "square"
|
|
respect_edge_spacing = (
|
|
body_pr is not None
|
|
and body_pr.attrib.get("spcFirstLastPara") in {"1", "true"}
|
|
)
|
|
|
|
inner_x = xfrm.x + lins
|
|
inner_y = xfrm.y + tins
|
|
inner_w = max(xfrm.w - lins - rins, 1.0)
|
|
inner_h = max(xfrm.h - tins - bins, 1.0)
|
|
|
|
# Pre-wrap each paragraph into concrete display lines.
|
|
wrap_width = inner_w if wrap_mode == "square" else float("inf")
|
|
para_lines: list[list[list[TextRun]]] = [
|
|
_wrap_paragraph_into_lines(p, wrap_width) for p in paragraphs
|
|
]
|
|
|
|
# Pre-compute heights to support anchor=ctr / b
|
|
para_heights = [
|
|
_paragraph_height_from_lines(p, lines)
|
|
for p, lines in zip(paragraphs, para_lines)
|
|
]
|
|
space_before = [paragraph.space_before_px for paragraph in paragraphs]
|
|
space_after = [paragraph.space_after_px for paragraph in paragraphs]
|
|
if not respect_edge_spacing:
|
|
space_before[0] = 0.0
|
|
space_after[-1] = 0.0
|
|
total_h = sum(
|
|
before + height + after
|
|
for before, height, after in zip(
|
|
space_before,
|
|
para_heights,
|
|
space_after,
|
|
)
|
|
)
|
|
if anchor == "ctr":
|
|
cursor_y = inner_y + max(0.0, (inner_h - total_h) / 2.0)
|
|
elif anchor == "b":
|
|
cursor_y = inner_y + max(0.0, inner_h - total_h)
|
|
else:
|
|
cursor_y = inner_y
|
|
|
|
bottom_y = inner_y + inner_h
|
|
text_blocks: list[str] = []
|
|
for para, lines, height, before, after in zip(
|
|
paragraphs,
|
|
para_lines,
|
|
para_heights,
|
|
space_before,
|
|
space_after,
|
|
):
|
|
cursor_y += before
|
|
visible_lines = _clip_lines_to_bottom(para, lines, cursor_y, bottom_y)
|
|
if visible_lines:
|
|
text_blocks.append(
|
|
_emit_paragraph(para, visible_lines, inner_x, inner_w, cursor_y)
|
|
)
|
|
cursor_y += height + after
|
|
if cursor_y >= bottom_y:
|
|
break
|
|
|
|
return TextResult(svg="\n".join(text_blocks), defs=_collect_text_defs(paragraphs))
|
|
|
|
|
|
def is_vertical_txbody(tx_body: ET.Element | None, xfrm: Xfrm | None = None) -> bool:
|
|
if tx_body is None:
|
|
return False
|
|
body_pr = tx_body.find("a:bodyPr", NS)
|
|
if body_pr is None:
|
|
return False
|
|
if body_pr.attrib.get("vert") in VERTICAL_TEXT_MODES:
|
|
return True
|
|
return _looks_like_auto_stacked_cjk(tx_body, body_pr, xfrm)
|
|
|
|
|
|
def convert_vertical_txbody(
|
|
tx_body: ET.Element | None,
|
|
xfrm: Xfrm,
|
|
palette: ColorPalette | None,
|
|
*,
|
|
theme_fonts: dict[str, str] | None = None,
|
|
slide_number: int | None = None,
|
|
default_fill: str = DEFAULT_FILL_HEX,
|
|
default_font_size_px: float = DEFAULT_FONT_SIZE_PX,
|
|
fallback_lst_styles: tuple[ET.Element, ...] = (),
|
|
fallback_run_props: tuple[ET.Element, ...] = (),
|
|
id_prefix: str = "txt",
|
|
id_seq: list[int] | None = None,
|
|
) -> TextResult:
|
|
"""Render East Asian vertical text as upright stacked glyphs.
|
|
|
|
PowerPoint often combines ``bodyPr@vert=eaVert`` with a rotated text box.
|
|
Rendering the text inside the rotated shape group makes Chinese glyphs lie
|
|
sideways. This helper computes the final rotated box and places glyphs
|
|
upright in slide coordinates.
|
|
"""
|
|
if tx_body is None:
|
|
return TextResult()
|
|
|
|
paragraphs = _parse_paragraphs(
|
|
tx_body, palette, theme_fonts or {}, default_fill=default_fill,
|
|
default_font_size_px=default_font_size_px,
|
|
fallback_lst_styles=fallback_lst_styles,
|
|
fallback_run_props=fallback_run_props,
|
|
slide_number=slide_number, id_prefix=id_prefix, id_seq=id_seq,
|
|
)
|
|
runs = [
|
|
run
|
|
for para in paragraphs
|
|
for run in para.runs
|
|
if not run.is_break and run.text
|
|
]
|
|
if not runs:
|
|
return TextResult()
|
|
|
|
box_x, box_y, box_w, box_h = _rotated_bbox(xfrm)
|
|
center_x = box_x + box_w / 2.0
|
|
|
|
glyphs: list[tuple[str, TextRun]] = []
|
|
for run in runs:
|
|
for char in run.text:
|
|
glyphs.append((" " if char in "\t\r\n" else char, run))
|
|
|
|
if not glyphs:
|
|
return TextResult()
|
|
|
|
advances = [glyph_run.font_size_px * 1.05 for _, glyph_run in glyphs]
|
|
total_h = sum(advances)
|
|
top_y = box_y + max(0.0, (box_h - total_h) / 2.0)
|
|
|
|
bottom_y = box_y + box_h
|
|
spans: list[str] = []
|
|
cursor_y = top_y
|
|
first_run: TextRun | None = None
|
|
first_baseline: float | None = None
|
|
previous_baseline: float | None = None
|
|
for (char, run), advance in zip(glyphs, advances):
|
|
if cursor_y + advance > bottom_y:
|
|
break
|
|
baseline_y = cursor_y + run.font_size_px * 0.85
|
|
tspan_attrs = _run_tspan_attrs(run)
|
|
if first_run is None:
|
|
first_run = run
|
|
first_baseline = baseline_y
|
|
spans.append(f"<tspan{tspan_attrs}>{_xml_escape(char)}</tspan>")
|
|
else:
|
|
dy = baseline_y - (previous_baseline or baseline_y)
|
|
spans.append(
|
|
f'<tspan x="{fmt_num(center_x)}" dy="{fmt_num(dy)}"'
|
|
f"{tspan_attrs}>{_xml_escape(char)}</tspan>"
|
|
)
|
|
previous_baseline = baseline_y
|
|
cursor_y += advance
|
|
|
|
if first_run is None or first_baseline is None:
|
|
return TextResult()
|
|
|
|
attrs = _text_base_attrs(first_run, center_x, first_baseline, "middle")
|
|
return TextResult(
|
|
svg=f"<text{attrs}>{''.join(spans)}</text>",
|
|
defs=_collect_text_defs(paragraphs),
|
|
)
|
|
|
|
|
|
def _rotated_bbox(xfrm: Xfrm) -> tuple[float, float, float, float]:
|
|
rot = round(xfrm.rot) % 360
|
|
cx = xfrm.x + xfrm.w / 2.0
|
|
cy = xfrm.y + xfrm.h / 2.0
|
|
if rot in (90, 270):
|
|
return cx - xfrm.h / 2.0, cy - xfrm.w / 2.0, xfrm.h, xfrm.w
|
|
return xfrm.x, xfrm.y, xfrm.w, xfrm.h
|
|
|
|
|
|
def _looks_like_auto_stacked_cjk(
|
|
tx_body: ET.Element,
|
|
body_pr: ET.Element,
|
|
xfrm: Xfrm | None,
|
|
) -> bool:
|
|
"""Detect PowerPoint's narrow-box CJK vertical layout without vert=eaVert."""
|
|
if xfrm is None or xfrm.w <= 0 or xfrm.h <= 0:
|
|
return False
|
|
if body_pr.attrib.get("wrap", "square") != "square":
|
|
return False
|
|
if xfrm.w > 64 or xfrm.h < xfrm.w * 2.4:
|
|
return False
|
|
|
|
text = _plain_text(tx_body)
|
|
chars = [ch for ch in text if not ch.isspace()]
|
|
if len(chars) < 3 or len(chars) > 16:
|
|
return False
|
|
cjk_count = sum(1 for ch in chars if _is_cjk(ch))
|
|
if cjk_count / len(chars) < 0.8:
|
|
return False
|
|
|
|
lins = _read_emu_attr(body_pr, "lIns", DEFAULT_INSETS_EMU["l"])
|
|
rins = _read_emu_attr(body_pr, "rIns", DEFAULT_INSETS_EMU["r"])
|
|
inner_w = max(xfrm.w - lins - rins, 1.0)
|
|
return inner_w <= DEFAULT_FONT_SIZE_PX
|
|
|
|
|
|
def _plain_text(tx_body: ET.Element) -> str:
|
|
"""Return concatenated literal text for layout heuristics."""
|
|
parts: list[str] = []
|
|
for text_elem in tx_body.findall(".//a:t", NS):
|
|
if text_elem.text:
|
|
parts.append(text_elem.text)
|
|
return "".join(parts)
|
|
|
|
|
|
# ---------------------------------------------------------------------------
|
|
# Parsing helpers
|
|
# ---------------------------------------------------------------------------
|
|
|
|
def _read_emu_attr(elem: ET.Element | None, attr: str, default_emu: int) -> float:
|
|
"""Read an EMU integer attribute and return px."""
|
|
if elem is None:
|
|
return emu_to_px(default_emu)
|
|
val = elem.attrib.get(attr)
|
|
if val is None:
|
|
return emu_to_px(default_emu)
|
|
try:
|
|
return emu_to_px(int(val))
|
|
except ValueError:
|
|
return emu_to_px(default_emu)
|
|
|
|
|
|
def _parse_paragraphs(
|
|
tx_body: ET.Element,
|
|
palette: ColorPalette | None,
|
|
theme_fonts: dict[str, str],
|
|
*,
|
|
default_fill: str = DEFAULT_FILL_HEX,
|
|
default_font_size_px: float = DEFAULT_FONT_SIZE_PX,
|
|
fallback_lst_styles: tuple[ET.Element, ...] = (),
|
|
fallback_run_props: tuple[ET.Element, ...] = (),
|
|
slide_number: int | None = None,
|
|
id_prefix: str = "txt",
|
|
id_seq: list[int] | None = None,
|
|
) -> list[TextParagraph]:
|
|
"""Walk <a:p> children producing TextParagraph objects."""
|
|
paragraphs: list[TextParagraph] = []
|
|
autonum_state: dict[int, int] = {}
|
|
lst_style = tx_body.find("a:lstStyle", NS)
|
|
lst_styles = (
|
|
(lst_style,) + fallback_lst_styles
|
|
if lst_style is not None else fallback_lst_styles
|
|
)
|
|
|
|
for p_elem in tx_body.findall("a:p", NS):
|
|
para = _parse_paragraph(
|
|
p_elem, palette, theme_fonts, autonum_state,
|
|
lst_styles=lst_styles,
|
|
fallback_run_props=fallback_run_props,
|
|
default_fill=default_fill,
|
|
default_font_size_px=default_font_size_px,
|
|
slide_number=slide_number,
|
|
id_prefix=id_prefix, id_seq=id_seq,
|
|
)
|
|
paragraphs.append(para)
|
|
|
|
return paragraphs
|
|
|
|
|
|
def _parse_paragraph(
|
|
p_elem: ET.Element,
|
|
palette: ColorPalette | None,
|
|
theme_fonts: dict[str, str],
|
|
autonum_state: dict[int, int],
|
|
*,
|
|
lst_styles: tuple[ET.Element, ...] = (),
|
|
fallback_run_props: tuple[ET.Element, ...] = (),
|
|
default_fill: str = DEFAULT_FILL_HEX,
|
|
default_font_size_px: float = DEFAULT_FONT_SIZE_PX,
|
|
slide_number: int | None = None,
|
|
id_prefix: str = "txt",
|
|
id_seq: list[int] | None = None,
|
|
) -> TextParagraph:
|
|
para = TextParagraph()
|
|
|
|
p_pr = p_elem.find("a:pPr", NS)
|
|
if p_pr is not None:
|
|
try:
|
|
para.level = int(p_pr.attrib.get("lvl", "0"))
|
|
except ValueError:
|
|
para.level = 0
|
|
|
|
para_style_chain = (p_pr,) + _lst_style_level_prs(lst_styles, para.level)
|
|
para.align = _attr_chain(para_style_chain, "algn") or "l"
|
|
para.margin_left_px = _emu_px_attr_chain(para_style_chain, "marL", 0.0)
|
|
para.indent_px = _emu_px_attr_chain(para_style_chain, "indent", 0.0)
|
|
para.line_height_ratio = _line_height_ratio(para_style_chain)
|
|
para.space_before_px = _spacing_points_px(para_style_chain, "a:spcBef/a:spcPts")
|
|
para.space_after_px = _spacing_points_px(para_style_chain, "a:spcAft/a:spcPts")
|
|
para.bullet_prefix = _resolve_bullet_prefix(
|
|
para_style_chain, para.level, autonum_state,
|
|
)
|
|
|
|
# Default endParaRPr style (applies if a run has no rPr)
|
|
end_rpr = p_elem.find("a:endParaRPr", NS)
|
|
# defRPr from pPr and txBody/lstStyle, both optional.
|
|
def_rpr = p_pr.find("a:defRPr", NS) if p_pr is not None else None
|
|
list_def_rpr = _child_chain(para_style_chain[1:], "a:defRPr")
|
|
para.empty_line_font_size_px = _font_size_px(
|
|
(end_rpr, def_rpr, list_def_rpr) + fallback_run_props,
|
|
default_font_size_px,
|
|
)
|
|
|
|
def resolved_run(text: str, rpr: ET.Element | None) -> TextRun:
|
|
return _build_run(
|
|
text, rpr, end_rpr, palette, theme_fonts,
|
|
def_rpr=def_rpr,
|
|
list_def_rpr=list_def_rpr,
|
|
fallback_run_props=fallback_run_props,
|
|
default_fill=default_fill,
|
|
default_font_size_px=default_font_size_px,
|
|
id_prefix=id_prefix, id_seq=id_seq,
|
|
)
|
|
|
|
for child in list(p_elem):
|
|
if not isinstance(child.tag, str):
|
|
continue
|
|
local = child.tag.split("}", 1)[-1]
|
|
if local == "r":
|
|
rpr = child.find("a:rPr", NS)
|
|
text_elem = child.find("a:t", NS)
|
|
text = text_elem.text or "" if text_elem is not None else ""
|
|
para.runs.append(resolved_run(text, rpr))
|
|
elif local == "br":
|
|
break_rpr = child.find("a:rPr", NS)
|
|
para.runs.append(TextRun(
|
|
text="",
|
|
font_size_px=_font_size_px(
|
|
(break_rpr, def_rpr, list_def_rpr, end_rpr)
|
|
+ fallback_run_props,
|
|
default_font_size_px,
|
|
),
|
|
font_family="sans-serif",
|
|
fill=default_fill,
|
|
is_break=True,
|
|
))
|
|
elif local == "fld":
|
|
# Slide SVGs have a concrete page context, so resolve slide-number
|
|
# fields there. Standalone master/layout renders keep the literal
|
|
# fallback because one shared part can serve many slide numbers.
|
|
rpr = child.find("a:rPr", NS)
|
|
text_elem = child.find("a:t", NS)
|
|
text = text_elem.text or "" if text_elem is not None else ""
|
|
field_type = child.attrib.get("type", "").strip().lower()
|
|
if field_type == "slidenum" and slide_number is not None:
|
|
text = str(slide_number)
|
|
if text:
|
|
para.runs.append(resolved_run(text, rpr))
|
|
|
|
return para
|
|
|
|
|
|
def _font_size_px(
|
|
sources: tuple[ET.Element | None, ...],
|
|
default_font_size_px: float,
|
|
) -> float:
|
|
"""Resolve one effective DrawingML run size into SVG pixels."""
|
|
return hundredths_pt_to_px(
|
|
_attr_chain(sources, "sz"),
|
|
default_font_size_px,
|
|
)
|
|
|
|
|
|
def _build_run(
|
|
text: str,
|
|
rpr: ET.Element | None,
|
|
end_rpr: ET.Element | None,
|
|
palette: ColorPalette | None,
|
|
theme_fonts: dict[str, str],
|
|
*,
|
|
def_rpr: ET.Element | None = None,
|
|
list_def_rpr: ET.Element | None = None,
|
|
fallback_run_props: tuple[ET.Element, ...] = (),
|
|
default_fill: str = DEFAULT_FILL_HEX,
|
|
default_font_size_px: float = DEFAULT_FONT_SIZE_PX,
|
|
id_prefix: str = "txt",
|
|
id_seq: list[int] | None = None,
|
|
) -> TextRun:
|
|
"""Resolve a single <a:r> run from its rPr and fallback run properties."""
|
|
style_chain = (
|
|
rpr, def_rpr, list_def_rpr, end_rpr,
|
|
) + fallback_run_props
|
|
# font-size: rPr > pPr/defRPr > lstStyle/lvlNpPr/defRPr > endParaRPr > default
|
|
font_size_px = _font_size_px(style_chain, default_font_size_px)
|
|
# Bold / italic
|
|
bold = _attr_chain(style_chain, "b") == "1"
|
|
italic = _attr_chain(style_chain, "i") == "1"
|
|
# Underline / strike
|
|
u_val = _attr_chain(style_chain, "u")
|
|
underline = u_val not in (None, "", "none")
|
|
strike_val = _attr_chain(style_chain, "strike")
|
|
strikethrough = strike_val in ("sngStrike", "dblStrike")
|
|
|
|
# Letter spacing (rPr@spc, in 1/100 pt)
|
|
spc = _attr_chain(style_chain, "spc")
|
|
letter_spacing_px = 0.0
|
|
if spc is not None:
|
|
try:
|
|
letter_spacing_px = float(spc) / 100.0 * 4.0 / 3.0 # pt -> px
|
|
except ValueError:
|
|
pass
|
|
|
|
# Color
|
|
fill = default_fill
|
|
fill_opacity = 1.0
|
|
defs: list[str] = []
|
|
color_source = None
|
|
for src in style_chain:
|
|
if src is None:
|
|
continue
|
|
grad = src.find("a:gradFill", NS)
|
|
if grad is not None:
|
|
grad_fill = resolve_fill(
|
|
grad, palette,
|
|
id_prefix=id_prefix,
|
|
id_seq=id_seq,
|
|
)
|
|
if grad_fill.attrs.get("fill"):
|
|
fill = grad_fill.attrs["fill"]
|
|
fill_opacity = 1.0
|
|
defs.extend(grad_fill.defs)
|
|
color_source = None
|
|
break
|
|
solid = src.find("a:solidFill", NS)
|
|
if solid is not None:
|
|
color_source = solid
|
|
break
|
|
if color_source is not None:
|
|
color_elem = find_color_elem(color_source)
|
|
hex_, alpha = resolve_color(color_elem, palette)
|
|
if hex_:
|
|
fill = hex_
|
|
fill_opacity = alpha
|
|
|
|
# Font typeface
|
|
latin_face = _typeface_chain(style_chain, "latin")
|
|
ea_face = _typeface_chain(style_chain, "ea")
|
|
cs_face = _typeface_chain(style_chain, "cs")
|
|
lang = _attr_chain(style_chain, "lang")
|
|
alt_lang = _attr_chain(style_chain, "altLang")
|
|
|
|
# Resolve theme refs (e.g. typeface="+mn-lt" / "+mj-ea")
|
|
latin_face = _resolve_theme_typeface(
|
|
latin_face,
|
|
theme_fonts,
|
|
text=text,
|
|
lang=lang,
|
|
alt_lang=alt_lang,
|
|
)
|
|
ea_face = _resolve_theme_typeface(
|
|
ea_face,
|
|
theme_fonts,
|
|
text=text,
|
|
lang=lang,
|
|
alt_lang=alt_lang,
|
|
)
|
|
cs_face = _resolve_theme_typeface(
|
|
cs_face,
|
|
theme_fonts,
|
|
text=text,
|
|
lang=lang,
|
|
alt_lang=alt_lang,
|
|
)
|
|
|
|
font_family = _build_font_stack(latin_face, ea_face, cs_face)
|
|
|
|
return TextRun(
|
|
text=text,
|
|
font_size_px=font_size_px,
|
|
font_family=font_family,
|
|
fill=fill,
|
|
fill_opacity=fill_opacity,
|
|
defs=defs,
|
|
bold=bold,
|
|
italic=italic,
|
|
underline=underline,
|
|
strikethrough=strikethrough,
|
|
letter_spacing_px=letter_spacing_px,
|
|
)
|
|
|
|
|
|
def _lst_style_level_prs(
|
|
lst_styles: tuple[ET.Element, ...],
|
|
level: int,
|
|
) -> tuple[ET.Element, ...]:
|
|
"""Return txBody/lstStyle paragraph properties for a paragraph level."""
|
|
level_idx = min(max(level, 0), 8) + 1
|
|
level_prs: list[ET.Element] = []
|
|
for lst_style in lst_styles:
|
|
lvl_pr = lst_style.find(f"a:lvl{level_idx}pPr", NS)
|
|
if lvl_pr is not None:
|
|
level_prs.append(lvl_pr)
|
|
return tuple(level_prs)
|
|
|
|
|
|
def _child_chain(
|
|
sources: tuple[ET.Element | None, ...],
|
|
path: str,
|
|
) -> ET.Element | None:
|
|
for src in sources:
|
|
if src is None:
|
|
continue
|
|
child = src.find(path, NS)
|
|
if child is not None:
|
|
return child
|
|
return None
|
|
|
|
|
|
def _emu_px_attr_chain(
|
|
sources: tuple[ET.Element | None, ...],
|
|
attr: str,
|
|
default: float,
|
|
) -> float:
|
|
value = _attr_chain(sources, attr)
|
|
if value is None:
|
|
return default
|
|
try:
|
|
return emu_to_px(int(value))
|
|
except ValueError:
|
|
return default
|
|
|
|
|
|
def _line_height_ratio(sources: tuple[ET.Element | None, ...]) -> float:
|
|
ln_spc = _child_chain(sources, "a:lnSpc")
|
|
if ln_spc is None:
|
|
return DEFAULT_LINE_HEIGHT_RATIO
|
|
spc_pct = ln_spc.find("a:spcPct", NS)
|
|
if spc_pct is None:
|
|
return DEFAULT_LINE_HEIGHT_RATIO
|
|
try:
|
|
return float(spc_pct.attrib.get("val", "100000")) / 100000.0
|
|
except ValueError:
|
|
return DEFAULT_LINE_HEIGHT_RATIO
|
|
|
|
|
|
def _spacing_points_px(
|
|
sources: tuple[ET.Element | None, ...],
|
|
path: str,
|
|
) -> float:
|
|
spacing = _child_chain(sources, path)
|
|
if spacing is None:
|
|
return 0.0
|
|
try:
|
|
return hundredths_pt_to_px(int(spacing.attrib.get("val", "0")))
|
|
except ValueError:
|
|
return 0.0
|
|
|
|
|
|
def _attr_chain(sources: tuple[ET.Element | None, ...], attr: str) -> str | None:
|
|
"""Return the first non-empty value of `attr` from any source element."""
|
|
for src in sources:
|
|
if src is None:
|
|
continue
|
|
v = src.attrib.get(attr)
|
|
if v is not None:
|
|
return v
|
|
return None
|
|
|
|
|
|
def _typeface(rpr: ET.Element | None, child_tag: str) -> str | None:
|
|
if rpr is None:
|
|
return None
|
|
elem = rpr.find(f"a:{child_tag}", NS)
|
|
if elem is None:
|
|
return None
|
|
val = elem.attrib.get("typeface")
|
|
return val or None
|
|
|
|
|
|
def _typeface_chain(
|
|
sources: tuple[ET.Element | None, ...],
|
|
child_tag: str,
|
|
) -> str | None:
|
|
for src in sources:
|
|
face = _typeface(src, child_tag)
|
|
if face:
|
|
return face
|
|
return None
|
|
|
|
|
|
def _theme_script_from_lang(lang: str | None) -> str | None:
|
|
"""Map a DrawingML language tag to one theme supplemental-script key."""
|
|
if not lang:
|
|
return None
|
|
normalized = lang.strip().replace("_", "-").lower()
|
|
if not normalized:
|
|
return None
|
|
parts = normalized.split("-")
|
|
primary = parts[0]
|
|
if primary == "ja":
|
|
return "Jpan"
|
|
if primary == "ko":
|
|
return "Hang"
|
|
if primary != "zh":
|
|
return None
|
|
if any(part in {"hant", "cht", "tw", "hk", "mo"} for part in parts[1:]):
|
|
return "Hant"
|
|
return "Hans"
|
|
|
|
|
|
def _theme_script_from_text(text: str) -> str | None:
|
|
"""Infer a CJK theme script from glyph ranges, defaulting plain Han to Hans."""
|
|
if any(
|
|
0x3100 <= ord(char) <= 0x312F
|
|
or 0x31A0 <= ord(char) <= 0x31BF
|
|
for char in text
|
|
):
|
|
return "Hant"
|
|
return {
|
|
"ko-KR": "Hang",
|
|
"ja-JP": "Jpan",
|
|
"zh-CN": "Hans",
|
|
}.get(detect_text_lang(text))
|
|
|
|
|
|
def _run_theme_script(
|
|
text: str,
|
|
lang: str | None,
|
|
alt_lang: str | None,
|
|
) -> str | None:
|
|
"""Resolve EA script from run language first, then alternate language/text."""
|
|
return (
|
|
_theme_script_from_lang(lang)
|
|
or _theme_script_from_lang(alt_lang)
|
|
or _theme_script_from_text(text)
|
|
)
|
|
|
|
|
|
def _resolve_theme_typeface(
|
|
face: str | None,
|
|
theme_fonts: dict[str, str],
|
|
*,
|
|
text: str = "",
|
|
lang: str | None = None,
|
|
alt_lang: str | None = None,
|
|
) -> str | None:
|
|
"""Resolve DrawingML major/minor Latin, EA, and complex-script tokens."""
|
|
if not face or not face.startswith("+"):
|
|
return face
|
|
code = face[1:]
|
|
if code == "mj-lt":
|
|
return theme_fonts.get("majorLatin") or face
|
|
if code == "mn-lt":
|
|
return theme_fonts.get("minorLatin") or face
|
|
if code in {"mj-ea", "mn-ea"}:
|
|
prefix = "major" if code.startswith("mj") else "minor"
|
|
script = _run_theme_script(text, lang, alt_lang)
|
|
script_face = (
|
|
theme_fonts.get(f"{prefix}Script{script}")
|
|
if script is not None else None
|
|
)
|
|
return (
|
|
theme_fonts.get(f"{prefix}EastAsia")
|
|
or script_face
|
|
or theme_fonts.get(f"{prefix}Latin")
|
|
or face
|
|
)
|
|
if code == "mj-cs":
|
|
return (
|
|
theme_fonts.get("majorComplexScript")
|
|
or theme_fonts.get("majorLatin")
|
|
or face
|
|
)
|
|
if code == "mn-cs":
|
|
return (
|
|
theme_fonts.get("minorComplexScript")
|
|
or theme_fonts.get("minorLatin")
|
|
or face
|
|
)
|
|
return face
|
|
|
|
|
|
def _build_font_stack(latin: str | None, ea: str | None, cs: str | None) -> str:
|
|
"""Build a CSS font-family stack: original PPT names first, then fallbacks."""
|
|
parts: list[str] = []
|
|
seen: set[str] = set()
|
|
for face in (latin, ea, cs):
|
|
if face and face not in seen:
|
|
parts.append(_quote_font(face))
|
|
seen.add(face)
|
|
# Generic fallback so the browser can render even if PPT fonts are absent.
|
|
parts.append("sans-serif")
|
|
return ", ".join(parts)
|
|
|
|
|
|
def _quote_font(name: str) -> str:
|
|
"""Quote a font name if it contains spaces or non-ASCII chars.
|
|
|
|
Uses XML entity-escaped double quotes (") so the resulting CSS string
|
|
survives being embedded inside an SVG attribute that itself uses double
|
|
quotes. CSS parsers accept the unescaped form after attribute parsing.
|
|
"""
|
|
if any(c.isspace() or ord(c) > 127 for c in name):
|
|
return f""{name}""
|
|
return name
|
|
|
|
|
|
def _resolve_bullet_prefix(
|
|
sources: tuple[ET.Element | None, ...],
|
|
level: int,
|
|
autonum_state: dict[int, int],
|
|
) -> str:
|
|
"""Render bullet glyphs / numbering as a literal text prefix."""
|
|
bu_none = _child_chain(sources, "a:buNone")
|
|
if bu_none is not None:
|
|
autonum_state.pop(level, None)
|
|
return ""
|
|
bu_char = _child_chain(sources, "a:buChar")
|
|
if bu_char is not None:
|
|
ch = bu_char.attrib.get("char", "•")
|
|
return f"{ch} "
|
|
bu_auto = _child_chain(sources, "a:buAutoNum")
|
|
if bu_auto is not None:
|
|
start_at = bu_auto.attrib.get("startAt")
|
|
if start_at is not None:
|
|
try:
|
|
autonum_state[level] = int(start_at)
|
|
except ValueError:
|
|
autonum_state[level] = 1
|
|
else:
|
|
autonum_state[level] = autonum_state.get(level, 0) + 1
|
|
return _format_auto_number(
|
|
autonum_state[level],
|
|
bu_auto.attrib.get("type", "arabicPeriod"),
|
|
)
|
|
return ""
|
|
|
|
|
|
def _format_auto_number(value: int, kind: str) -> str:
|
|
lower = kind.lower()
|
|
if "alphalc" in lower:
|
|
token = _alpha_number(value, uppercase=False)
|
|
elif "alphauc" in lower:
|
|
token = _alpha_number(value, uppercase=True)
|
|
elif "romanlc" in lower:
|
|
token = _roman_number(value).lower()
|
|
elif "romanuc" in lower:
|
|
token = _roman_number(value).upper()
|
|
else:
|
|
token = str(value)
|
|
|
|
if "parenboth" in lower:
|
|
return f"({token}) "
|
|
if "parenr" in lower:
|
|
return f"{token}) "
|
|
if "period" in lower:
|
|
return f"{token}. "
|
|
return f"{token} "
|
|
|
|
|
|
def _alpha_number(value: int, *, uppercase: bool) -> str:
|
|
value = max(1, value)
|
|
chars: list[str] = []
|
|
while value:
|
|
value -= 1
|
|
chars.append(chr(ord("A") + (value % 26)))
|
|
value //= 26
|
|
text = "".join(reversed(chars))
|
|
return text if uppercase else text.lower()
|
|
|
|
|
|
def _roman_number(value: int) -> str:
|
|
value = max(1, min(value, 3999))
|
|
parts: list[str] = []
|
|
for n, token in (
|
|
(1000, "M"), (900, "CM"), (500, "D"), (400, "CD"),
|
|
(100, "C"), (90, "XC"), (50, "L"), (40, "XL"),
|
|
(10, "X"), (9, "IX"), (5, "V"), (4, "IV"), (1, "I"),
|
|
):
|
|
while value >= n:
|
|
parts.append(token)
|
|
value -= n
|
|
return "".join(parts)
|
|
|
|
|
|
# ---------------------------------------------------------------------------
|
|
# Layout / emission
|
|
# ---------------------------------------------------------------------------
|
|
|
|
def _has_visible_text(paragraphs: list[TextParagraph]) -> bool:
|
|
for p in paragraphs:
|
|
for r in p.runs:
|
|
if r.text.strip():
|
|
return True
|
|
return False
|
|
|
|
|
|
def _collect_text_defs(paragraphs: list[TextParagraph]) -> list[str]:
|
|
"""Return unique text fill defs referenced by parsed runs."""
|
|
defs: list[str] = []
|
|
seen: set[str] = set()
|
|
for para in paragraphs:
|
|
for run in para.runs:
|
|
for item in run.defs:
|
|
if item not in seen:
|
|
defs.append(item)
|
|
seen.add(item)
|
|
return defs
|
|
|
|
|
|
# ---------------------------------------------------------------------------
|
|
# Word-wrap / text measurement
|
|
# ---------------------------------------------------------------------------
|
|
|
|
def _is_cjk(ch: str) -> bool:
|
|
"""Check if a character is CJK (Chinese/Japanese/Korean) or full-width."""
|
|
return is_cjk_char(ch)
|
|
|
|
|
|
def _char_width(ch: str, font_size: float, bold: bool) -> float:
|
|
"""Estimate a single character's rendered width in pixels.
|
|
|
|
Mirrors svg_to_pptx/drawingml/utils.py estimate_text_width so wrapping breaks
|
|
align with the same heuristic used to estimate text-box sizes elsewhere.
|
|
"""
|
|
if _is_cjk(ch):
|
|
w = font_size # CJK is approximately 1em per glyph
|
|
elif ch == ' ':
|
|
w = font_size * 0.3
|
|
elif ch in 'mMwWOQ%':
|
|
w = font_size * 0.75
|
|
elif ch in 'iIlj!|':
|
|
w = font_size * 0.3
|
|
elif ch.isdigit():
|
|
# digits are tabular (uniform ~0.55em) in most UI fonts, including
|
|
# '1' — classing it with 'il|' under-sizes the width and makes
|
|
# renderers that ignore wrap="none" (LibreOffice) wrap the line
|
|
w = font_size * 0.55
|
|
else:
|
|
w = font_size * 0.55
|
|
# Bold Latin generally expands a little. CJK glyphs keep their em advance
|
|
# in common PPT fonts; applying the bold multiplier causes short Chinese
|
|
# titles such as "少年强国说" to wrap even though PowerPoint keeps them on
|
|
# one line.
|
|
if bold and not _is_cjk(ch):
|
|
w *= 1.05
|
|
return w
|
|
|
|
|
|
def _estimate_run_width(text: str, run: TextRun) -> float:
|
|
glyph_width = sum(_char_width(c, run.font_size_px, run.bold) for c in text)
|
|
tracking_width = run.letter_spacing_px * max(len(text) - 1, 0)
|
|
return (glyph_width + tracking_width) * 1.05
|
|
|
|
|
|
def _advance_width(ch: str, index_in_segment: int, run: TextRun) -> float:
|
|
"""Return the width added by one character inside a measured line segment."""
|
|
tracking = run.letter_spacing_px if index_in_segment > 0 else 0.0
|
|
return _char_width(ch, run.font_size_px, run.bold) + tracking
|
|
|
|
|
|
def _find_break_point(
|
|
text: str, start: int, max_width: float, run: TextRun,
|
|
) -> tuple[int, float]:
|
|
"""Find the longest prefix of text[start:] that fits in max_width.
|
|
|
|
Returns (end_index, used_width). Prefers breaking after whitespace, after
|
|
CJK characters, or after hyphens. If even the first character doesn't fit,
|
|
returns (start, 0.0) — the caller should flush the current line first.
|
|
"""
|
|
cur_w = 0.0
|
|
last_break = start
|
|
last_break_w = 0.0
|
|
|
|
for i in range(start, len(text)):
|
|
ch = text[i]
|
|
ch_w = _advance_width(ch, i - start, run)
|
|
if cur_w + ch_w > max_width:
|
|
if last_break > start:
|
|
return last_break, last_break_w
|
|
return start, 0.0
|
|
cur_w += ch_w
|
|
# Update last_break point
|
|
if ch.isspace() or _is_cjk(ch) or ch in "-—、，。！？：；":
|
|
last_break = i + 1
|
|
last_break_w = cur_w
|
|
# Whole rest fits
|
|
return len(text), cur_w
|
|
|
|
|
|
def _wrap_paragraph_into_lines(
|
|
para: TextParagraph,
|
|
max_width: float,
|
|
) -> list[list[TextRun]]:
|
|
"""Split a paragraph's runs into display lines respecting `max_width`.
|
|
|
|
Each line is a list of (possibly truncated) TextRuns. Explicit a:br runs
|
|
force a new line. When max_width is +inf the original runs are returned
|
|
unchanged (one logical line per a:br segment).
|
|
|
|
Bullet prefix is prepended to the first non-empty run if present.
|
|
"""
|
|
lines: list[list[TextRun]] = [[]]
|
|
cur_w = 0.0
|
|
|
|
if _should_keep_single_line(para, max_width):
|
|
return [[_copy_run(run, text=run.text) for run in para.runs if not run.is_break and run.text]]
|
|
|
|
if para.bullet_prefix and para.runs:
|
|
first_run = next((r for r in para.runs if not r.is_break), None)
|
|
if first_run is not None:
|
|
bullet_run = _copy_run(first_run, text=para.bullet_prefix)
|
|
lines[-1].append(bullet_run)
|
|
cur_w = _estimate_run_width(para.bullet_prefix, bullet_run)
|
|
|
|
for run in para.runs:
|
|
if run.is_break:
|
|
# Keep the break on the line it terminates so consecutive breaks
|
|
# form a break-only empty line. Visible text owns a non-empty
|
|
# line's height; the break rPr owns only that empty line.
|
|
lines[-1].append(run)
|
|
lines.append([])
|
|
cur_w = 0.0
|
|
continue
|
|
if not run.text:
|
|
continue
|
|
text = run.text
|
|
i = 0
|
|
while i < len(text):
|
|
avail = max_width - cur_w
|
|
if avail <= 0 and lines[-1]:
|
|
# Line is full; start a new one
|
|
lines.append([])
|
|
cur_w = 0.0
|
|
avail = max_width
|
|
|
|
end, used = _find_break_point(text, i, avail, run)
|
|
if end == i:
|
|
# Nothing fits even from a fresh line — force one char to avoid
|
|
# an infinite loop.
|
|
if lines[-1]:
|
|
lines.append([])
|
|
cur_w = 0.0
|
|
continue
|
|
end = i + 1
|
|
used = _advance_width(text[i], 0, run)
|
|
|
|
chunk = text[i:end]
|
|
lines[-1].append(_copy_run(run, text=chunk))
|
|
cur_w += used
|
|
i = end
|
|
|
|
if i < len(text):
|
|
# More to render — wrap to next line
|
|
lines.append([])
|
|
cur_w = 0.0
|
|
|
|
return lines
|
|
|
|
|
|
def _should_keep_single_line(para: TextParagraph, max_width: float) -> bool:
|
|
if max_width == float("inf") or para.bullet_prefix:
|
|
return False
|
|
if any(run.is_break for run in para.runs):
|
|
return False
|
|
|
|
text_runs = [run for run in para.runs if run.text]
|
|
if not text_runs:
|
|
return False
|
|
text = "".join(run.text for run in text_runs)
|
|
non_space_count = sum(1 for ch in text if not ch.isspace())
|
|
|
|
# Short labels/titles are usually intentionally single-line in PPT. Let
|
|
# them overflow slightly rather than inventing a line break from imperfect
|
|
# font metrics or alignment spaces.
|
|
if non_space_count <= 18:
|
|
return True
|
|
|
|
estimated = sum(_estimate_run_width(run.text, run) for run in text_runs)
|
|
return estimated <= max_width * 1.12
|
|
|
|
|
|
def _copy_run(run: TextRun, *, text: str) -> TextRun:
|
|
return TextRun(
|
|
text=text,
|
|
font_size_px=run.font_size_px,
|
|
font_family=run.font_family,
|
|
fill=run.fill,
|
|
fill_opacity=run.fill_opacity,
|
|
defs=list(run.defs),
|
|
bold=run.bold,
|
|
italic=run.italic,
|
|
underline=run.underline,
|
|
strikethrough=run.strikethrough,
|
|
letter_spacing_px=run.letter_spacing_px,
|
|
)
|
|
|
|
|
|
def _paragraph_height_from_lines(p: TextParagraph,
|
|
lines: list[list[TextRun]]) -> float:
|
|
"""Total px height after wrapping. Each line uses its own max font size."""
|
|
if not lines:
|
|
return p.empty_line_font_size_px * p.line_height_ratio
|
|
height = 0.0
|
|
for line in lines:
|
|
height += _line_height(p, line)
|
|
return height
|
|
|
|
|
|
def _line_height(p: TextParagraph, line: list[TextRun]) -> float:
|
|
return _line_font_size(p, line) * p.line_height_ratio
|
|
|
|
|
|
def _line_font_size(p: TextParagraph, line: list[TextRun]) -> float:
|
|
visible_sizes = [
|
|
run.font_size_px
|
|
for run in line
|
|
if not run.is_break and run.text
|
|
]
|
|
if visible_sizes:
|
|
return max(visible_sizes)
|
|
break_sizes = [run.font_size_px for run in line if run.is_break]
|
|
return max(break_sizes, default=p.empty_line_font_size_px)
|
|
|
|
|
|
def _clip_lines_to_bottom(
|
|
para: TextParagraph,
|
|
lines: list[list[TextRun]],
|
|
top_y: float,
|
|
bottom_y: float,
|
|
) -> list[list[TextRun]]:
|
|
"""Return the leading display lines whose line boxes fit in the text frame."""
|
|
visible: list[list[TextRun]] = []
|
|
cursor_y = top_y
|
|
for line in lines:
|
|
line_h = _line_height(para, line)
|
|
# PowerPoint lets the first line that starts within the box render even
|
|
# when it slightly exceeds the bottom — only suppress lines whose top
|
|
# is already at/below the bottom edge.
|
|
if cursor_y >= bottom_y:
|
|
break
|
|
visible.append(line)
|
|
cursor_y += line_h
|
|
return visible
|
|
|
|
|
|
def _paragraph_height(p: TextParagraph) -> float:
|
|
"""Legacy helper kept for callers that don't pre-wrap (currently unused)."""
|
|
lines = _wrap_paragraph_into_lines(p, float("inf"))
|
|
return _paragraph_height_from_lines(p, lines)
|
|
|
|
|
|
def _emit_paragraph(
|
|
para: TextParagraph,
|
|
lines: list[list[TextRun]],
|
|
inner_x: float, inner_w: float,
|
|
top_y: float,
|
|
) -> str:
|
|
"""Render a paragraph (already split into lines) as one <text> element.
|
|
|
|
Each pre-wrapped display line becomes a sequence of <tspan>s: the first
|
|
tspan on a line carries the explicit x and dy (line-height advance);
|
|
subsequent tspans on the same line inherit x.
|
|
"""
|
|
align = para.align
|
|
if align == "ctr":
|
|
anchor_x = inner_x + inner_w / 2.0
|
|
text_anchor = "middle"
|
|
elif align == "r":
|
|
anchor_x = inner_x + inner_w
|
|
text_anchor = "end"
|
|
else: # 'l' / 'just' / 'dist' / unknown
|
|
anchor_x = inner_x + para.indent_px + para.margin_left_px
|
|
text_anchor = "start"
|
|
|
|
if not lines:
|
|
return ""
|
|
|
|
visible_lines = [
|
|
[run for run in line if not run.is_break and run.text]
|
|
for line in lines
|
|
]
|
|
first_line_idx = next(
|
|
(index for index, line in enumerate(visible_lines) if line),
|
|
None,
|
|
)
|
|
if first_line_idx is None:
|
|
return ""
|
|
|
|
first_run = visible_lines[first_line_idx][0]
|
|
first_baseline = top_y + 0.85 * first_run.font_size_px
|
|
|
|
spans: list[str] = []
|
|
for line_idx, line in enumerate(visible_lines):
|
|
line_advance = None
|
|
if line_idx > 0:
|
|
height_line = (
|
|
lines[line_idx - 1]
|
|
if line_idx <= first_line_idx else lines[line_idx]
|
|
)
|
|
line_advance = _line_height(para, height_line)
|
|
if not line:
|
|
if line_advance is not None:
|
|
spans.append(
|
|
f'<tspan x="{fmt_num(anchor_x)}" '
|
|
f'dy="{fmt_num(line_advance)}"></tspan>'
|
|
)
|
|
continue
|
|
for run_idx, run in enumerate(line):
|
|
attrs = _run_tspan_attrs(run)
|
|
if run_idx == 0 and line_advance is not None:
|
|
spans.append(
|
|
f'<tspan x="{fmt_num(anchor_x)}" '
|
|
f'dy="{fmt_num(line_advance)}"'
|
|
f'{attrs}>{_xml_escape(run.text)}</tspan>'
|
|
)
|
|
else:
|
|
spans.append(
|
|
f"<tspan{attrs}>{_xml_escape(run.text)}</tspan>"
|
|
)
|
|
|
|
base_attrs = _text_base_attrs(first_run, anchor_x, first_baseline, text_anchor)
|
|
return f"<text{base_attrs}>{''.join(spans)}</text>"
|
|
|
|
|
|
def _text_base_attrs(run: TextRun | None, x: float, y: float,
|
|
text_anchor: str) -> str:
|
|
parts = [
|
|
f'x="{fmt_num(x)}"',
|
|
f'y="{fmt_num(y)}"',
|
|
f'text-anchor="{text_anchor}"',
|
|
'xml:space="preserve"',
|
|
]
|
|
if run is None:
|
|
return " " + " ".join(parts)
|
|
parts.append(f'font-family="{run.font_family}"')
|
|
parts.append(f'font-size="{fmt_num(run.font_size_px)}"')
|
|
parts.append(f'fill="{run.fill}"')
|
|
if run.fill_opacity < 1.0:
|
|
parts.append(
|
|
f'fill-opacity="{format_ooxml_alpha(run.fill_opacity)}"'
|
|
)
|
|
if run.bold:
|
|
parts.append('font-weight="bold"')
|
|
if run.italic:
|
|
parts.append('font-style="italic"')
|
|
if run.underline and run.strikethrough:
|
|
parts.append('text-decoration="underline line-through"')
|
|
elif run.underline:
|
|
parts.append('text-decoration="underline"')
|
|
elif run.strikethrough:
|
|
parts.append('text-decoration="line-through"')
|
|
if run.letter_spacing_px:
|
|
parts.append(f'letter-spacing="{fmt_num(run.letter_spacing_px)}"')
|
|
return " " + " ".join(parts)
|
|
|
|
|
|
def _run_tspan_attrs(run: TextRun) -> str:
|
|
"""Per-run overrides on a <tspan>. Only emit attributes that differ from
|
|
the run that drove the parent <text> (we keep things simple: emit only
|
|
overrides that can plausibly change run-to-run, never re-emit common
|
|
defaults). For v1 we always emit fill, font family, and font size so each
|
|
imported run keeps its resolved typeface even when adjacent runs differ.
|
|
"""
|
|
parts = [
|
|
f'fill="{run.fill}"',
|
|
f'font-family="{run.font_family}"',
|
|
f'font-size="{fmt_num(run.font_size_px)}"',
|
|
]
|
|
if run.fill_opacity < 1.0:
|
|
parts.append(
|
|
f'fill-opacity="{format_ooxml_alpha(run.fill_opacity)}"'
|
|
)
|
|
if run.bold:
|
|
parts.append('font-weight="bold"')
|
|
if run.italic:
|
|
parts.append('font-style="italic"')
|
|
if run.underline and run.strikethrough:
|
|
parts.append('text-decoration="underline line-through"')
|
|
elif run.underline:
|
|
parts.append('text-decoration="underline"')
|
|
elif run.strikethrough:
|
|
parts.append('text-decoration="line-through"')
|
|
if run.letter_spacing_px:
|
|
parts.append(f'letter-spacing="{fmt_num(run.letter_spacing_px)}"')
|
|
return " " + " ".join(parts)
|
|
|
|
|
|
def _xml_escape(text: str) -> str:
|
|
return (text.replace("&", "&")
|
|
.replace("<", "<")
|
|
.replace(">", ">")
|
|
.replace('"', """))
|