Text¶

@prototype
def __init__(
    self,
    text: str,
    line_spacing: float = -1,
    font: str = "",
    slant: str = NORMAL,
    weight: str = NORMAL,
    t2c: Mapping[str, ParsableManimColor] | None = None,
    t2g: Mapping[str, Sequence[ParsableManimColor]] | None = None,
    t2s: Mapping[str, str] | None = None,
    t2w: Mapping[str, str] | None = None,
    gradient: Sequence[ParsableManimColor] | None = None,
    tab_width: int = 4,
    disable_ligatures: bool = False,
    **kwargs: Unpack[TypstOptions],
) -> None:
    if kwargs.get("fill_opacity") is None and kwargs.get("opacity") is None:
        kwargs["fill_opacity"] = 1.0  # filled, unless an opacity is given
    self.text = text
    """The text, as it was written."""
    self.original_text = text
    self.font = font
    self.slant, self.weight = slant, weight
    chars = text  # the text as written, as characters
    family = font or DEFAULT_FONT
    base: Style = (weight, slant)
    styles: list[Style] | None = None
    if t2w or t2s:
        styles = [base] * len(chars)
        for field, mapping in enumerate((t2w, t2s)):
            for key, value in (mapping or {}).items():
                for span in _find(chars, key):
                    for i in span:
                        style = list(styles[i])
                        style[field] = value
                        styles[i] = (style[0], style[1])
    ligatures = ", ligatures: false" if disable_ligatures else ""
    head = f"#text(font: {_fonts(family)}, {_arguments(base)}{ligatures})["
    body, runs = self._source(text, tab_width, len(head.encode()), base, styles)
    rules = _rules(text) + (_lines(line_spacing) if "\n" in text else "")
    if rules:
        kwargs["typst_preamble"] = rules + kwargs.get("typst_preamble", "")
    # set larger by its font's calibration, so font_size stays the size asked for
    super().__init__(
        f"{head}{body}]", font_scale=_calibration(family, kwargs), **kwargs
    )
    self._chars = chars
    self._clusters = self._characters(runs)
    colors: dict[int, ManimColor] = {}
    if gradient:
        colors |= dict(enumerate(color_gradient(list(gradient), len(chars))))
    for key, stops in (t2g or {}).items():
        for span in _find(chars, key):
            if span:
                colors |= dict(zip(span, color_gradient(list(stops), len(span))))
    for key, color in (t2c or {}).items():
        for span in _find(chars, key):
            colors |= dict.fromkeys(span, ManimColor(color))
    if colors:
        self._paint(colors)

def __init__(
    self,
    *text: str,
    alignment: Literal["left", "center", "right"] | None = None,
    **kwargs: Unpack[TextOptions],
) -> None:
    joined = "\n".join(text)
    if alignment is not None:  # Typst's alignments of these names
        kwargs["typst_preamble"] = f"#set align({alignment})\n" + kwargs.get(
            "typst_preamble", ""
        )
    self.lines_text = whole = Text(joined, **kwargs)
    """The lines as one [Text][manimgx.Text], joined by newlines: the paragraph's
    lines group its glyphs."""
    # the parts are the lines, each the group of its glyphs (CE's structure)
    starts = [0, *(i + 1 for i, ch in enumerate(joined) if ch == "\n")]
    lines: list[list[Mobject]] = [[] for _ in starts]
    for part, chars in zip(whole.submobjects, whole._clusters):
        lines[bisect.bisect_right(starts, chars.start) - 1].append(part)
    super().__init__(*(VGroup(*line) for line in lines))
    self.alignment = alignment

def __init__(
    self,
    *text_parts: str,
    include_underline: bool = True,
    match_underline_width_to_text: bool = False,
    underline_buff: float = MED_SMALL_BUFF,
    **kwargs: Unpack[MathTexOptions],
) -> None:
    from manimgx.config import config
    from manimgx.constants import DOWN, LEFT, RIGHT, UP
    from manimgx.mobjects.shapes import Line

    super().__init__(*text_parts, **kwargs)
    self.to_edge(UP)
    if include_underline:
        underline = Line(LEFT, RIGHT).next_to(self, DOWN, buff=underline_buff)
        underline.width = (
            self.width if match_underline_width_to_text else config.frame_width - 2
        )
        color = kwargs.get("color")
        if color is not None:  # color= colors the whole title, as set_color does
            underline.set_color(color)
        self.add(underline)
        self.underline = underline
        """The line under the title, its last part (a title made without one has
        none)."""

def __init__(
    self,
    *items: str,
    buff: float = MED_LARGE_BUFF,
    **kwargs: Unpack[MathTexOptions],
) -> None:
    self.buff = buff
    pt = 1 / (
        kwargs.get("font_size", DEFAULT_FONT_SIZE) * SCALE_FACTOR_PER_FONT_POINT
    )
    kwargs["typst_preamble"] = (
        f"#set list(marker: [#box(scale(200%, $dot.c$))<{_BULLET}>], indent: 0pt,"
        f" body-indent: {SMALL_BUFF * pt}pt, spacing: {buff * pt}pt)\n"
        + kwargs.get("typst_preamble", "")
    )
    kwargs.setdefault("tex_environment", None)
    super().__init__(*items, **kwargs)

def __init__(
    self,
    code_file: StrPath | None = None,
    code_string: str | None = None,
    language: str | None = None,
    formatter_style: CodeStyle = "vim",
    tab_width: int = 4,
    add_line_numbers: bool = True,
    line_numbers_from: int = 1,
    background: Literal["rectangle", "window"] = "rectangle",
    background_config: FrameOptions | None = None,
    paragraph_config: CodeText | None = None,
) -> None:
    super().__init__()
    if code_file is not None:
        code_string = Path(code_file).read_text(encoding="utf-8")
        language = language or Path(code_file).suffix.removeprefix(".") or None
    elif code_string is None:
        raise ValueError("Either a code file or a code string must be specified.")
    style = _STYLES[formatter_style]
    text = self.default_paragraph_config | (paragraph_config or {})
    # the lines as pygments hands them to CE: tabs expanded, blank lines trimmed off
    code = (
        code_string.expandtabs(tab_width).replace("\r\n", "\n").replace("\r", "\n")
    )
    lines = code.strip("\n").split("\n")
    if not any(line.strip() for line in lines):
        lines = [""] * len(lines)

    # CE closes the first and last lines with an ascender, a descender and the first line
    # number, so that a listing's height depends on its lines alone, then takes them away
    suffix = f" pA{line_numbers_from}"
    closing = len(suffix) - 1  # its glyphs: all but the space
    rows = _typeset(
        lines, text, style.foreground, style=style, language=language, suffix=suffix
    )
    self.code_lines = VGroup(*rows).move_to(ORIGIN)
    """The lines, a part: its i-th part is the i-th line, a group of its glyphs."""

    if add_line_numbers:
        numbers = range(line_numbers_from, line_numbers_from + len(lines))
        self.line_numbers = VGroup(
            *_typeset([str(n) for n in numbers], text, style.line_numbers)
        ).move_to(ORIGIN)
        """The line numbers, a part (if the lines are numbered): its i-th part is
        the i-th line's number, lined up on the right."""
        right = self.line_numbers.get_right()[0]
        for row in self.line_numbers.submobjects:
            row.shift(RIGHT * (right - row.get_right()[0]))
        self.line_numbers.next_to(self.code_lines, LEFT)
        first = VGroup(*rows[0].submobjects[-len(str(line_numbers_from)) :])
        self.line_numbers.shift(
            UP * (first.get_y() - self.line_numbers.submobjects[0].get_y())
        )
        self.add(self.line_numbers)

    # what CE keeps of the closings: their height, on the left edge of their glyphs and of
    # the space before each, which CE's Text puts on the glyph before it
    boundary = sorted({0, len(rows) - 1})
    glyphs = [glyph for row in rows for glyph in row.submobjects]
    closings = [g for i in boundary for g in rows[i].submobjects[-closing:]]
    spaces = []
    for i in boundary:
        before = sum(len(row.submobjects) for row in rows[: i + 1]) - closing
        spaces.append(
            glyphs[before - 1] if before else rows[i].submobjects[-closing]
        )
    edge = min(
        [g.get_center()[0] for g in spaces] + [g.get_left()[0] for g in closings]
    )
    extent = Line(
        [edge, min(g.get_bottom()[1] for g in closings), 0],
        [edge, max(g.get_top()[1] for g in closings), 0],
    )
    for i in boundary:
        rows[i].remove(*rows[i].submobjects[-closing:])
    self.add(self.code_lines)

    config = self.default_background_config | (background_config or {})
    if config.get("fill_color") is None:
        config["fill_color"] = style.background
    listing = VGroup(*self.submobjects, extent)
    if background == "rectangle":
        self.background = SurroundingRectangle(listing, **config)
        """The rectangle behind the listing, its first part; a window's buttons are
        its submobjects."""
    elif background == "window":
        buttons = VGroup(
            *(
                Dot(radius=0.1, stroke_width=0, color=c)
                for c in ["#ff5f56", "#ffbd2e", "#27c93f"]
            )
        ).arrange(RIGHT, buff=0.1)
        buttons.next_to(listing, UP, buff=0.1).align_to(listing, LEFT).shift(
            LEFT * 0.1
        )
        self.background = SurroundingRectangle(listing, buttons, **config)
        buttons.shift(UP * 0.1 + LEFT * 0.1)
        self.background.add(buttons)
    else:
        raise ValueError(f"Unknown background type: {background}")
    self.add_to_back(self.background)