文本¶

影片代码

import manimgx as m


class TextHero(m.Scene):
    def construct(self) -> None:
        title = m.Text("Text", font_size=72)
        styles = m.VGroup(
            m.Text("bold", weight=m.BOLD, font_size=40),
            m.Text("italic", slant=m.ITALIC, font_size=40),
            m.Text("monospace", font="monospace", font_size=40),
            m.Text("red and blue", t2c={"red": m.RED, "blue": m.BLUE}, font_size=40),
        ).arrange(buff=0.6)
        items = m.BulletedList("one idea", "at a time", font_size=40)
        page = m.VGroup(title, styles, items).arrange(m.DOWN, buff=0.7)
        self.play(m.Write(title))
        self.play(m.LaggedStart(*[m.FadeIn(style) for style in styles], lag_ratio=0.2))
        self.play(m.Write(items))
        self.wait()

Text 按你给出的原样在字体中书写文字：换行符（\n）开始新的一行。其大小为 font_size，默认为 48，除非你指定其他值。其组成部分是它的字符，因此 text[0] 是第一个字符；t2c 按文字为其部分着色。

标题、项目符号列表和段落为你排列文本行，代码清单则高亮显示程序的源代码。

Text ¶

某字体中的文本，由 Typst 按所写形式排版：未加样式时为白色。

空格保留，换行断行，制表符为 tab_width 个空格，无任何标记（"= Title" 不是标题）。行设在网格上：基线间距为 1 + line_spacing em，与其上的字形无关。各部分为字形，按阅读顺序排列，不含空格：Text("Hello")[0] 为 "H"，即 TypstGlyph。连字为单个字形（默认字体中 "office" 的 "ffi"），除非 disable_ligatures。

文本以一种字体排版，来自 ManimGX 附带的字体，因此在每台机器上看起来相同：除非 font 命名其他字体，否则为 New Computer Modern。 "serif"、"sans-serif"（或 "sans"）和 "monospace"（或 "mono"）分别为 New Computer Modern、Noto Sans 和 DejaVu Sans Mono。font_paths 中的字体优先；它们和 ManimGX 都没有的字体族从系统字体读取，无处可寻的回退到 New Computer Modern。字体缺少的字符用拥有该字符的其他字体排版： ManimGX 为阿拉伯文、希伯来文、印度文、泰文、中文、日文、韩文等附带 Noto 字体，以及符号和表情符号。任何字体中，默认大小 48 时大写字母高 0.449 场景单位，其他大小按比例：每个字体缩放至此， font_size 仍读取所请求的大小。

首字母来自右到左文字（阿拉伯文、希伯来文）的文本作为右到左段落排版，其行右对齐。中文、日文或韩文文本从其字符取语言（有假名的为日文，有谚文的为韩文，否则为中文），决定汉字的区域字形。

键选取字符：所写文本的切片 "[a:b]"（含空格），或字符串的每次出现（不出现于任何处的键不选取任何内容）。t2s 和 t2w 将所选内容设为另一倾斜或字重；gradient、然后 t2g、然后 t2c 为其着色，每个覆盖前一个。颜色从不改变排版：文本排版一次，每个字形取其绘制字符的颜色—— 跨越颜色边界的连字在该处切割，每段取其字符的颜色。自定义字形的路径构建方法也构建其颜色段。

m.Text(text, line_spacing=-1, font='', slant=NORMAL, weight=NORMAL, t2c=None, t2g=None, t2s=None, t2w=None, gradient=None, tab_width=4, disable_ligatures=False, **kwargs)

text: 文本，按所写形式。
line_spacing: 行间距，以 em 计：基线间距为 1 + line_spacing em；-1 为 0.3。
font: 字体族，或 "serif"、"sans-serif" 或 "monospace"；"" 为 New Computer Modern。
slant: NORMAL、ITALIC 或 OBLIQUE。
weight: 按名称的字重，从 THIN 经 NORMAL 和 BOLD 到 ULTRAHEAVY；使用字体最接近的字重。
t2c: 每个键的颜色。
t2g: 每个键的渐变：其颜色沿键选取的内容分布。
t2s: 每个键的倾斜。
t2w: 每个键的字重。
gradient: 颜色沿整个文本逐字符分布，含空格。
tab_width: 制表符排版的空格数。
disable_ligatures: 每个字符是否各自为字形。
font_size: 文本的大小：一个 em 为 font_size / 96 场景单位，默认时为 0.5， 48（Text 按其大写字母确定大小：48 时高 0.449 单位）。
typst_preamble: 在文档之前设置的 Typst 代码：#set 和 #show 规则、#let 定义、导入（默认为 ""）。
font_paths: 字体文件（.ttf、.otf、.ttc、.otc）的目录，在 manimgx 附带的字体之前连同其子目录一起搜索；指向文件的路径不添加任何内容（默认为 None）。
should_center: mobject 是否居中于原点（默认为 True）。
height: 将 mobject 缩放至的高度，以场景单位计，而非按 font_size 确定大小（默认为 None）。
width: 将 mobject 缩放至的宽度，以场景单位计，而非按 font_size 确定大小；若同时给出 height，则宽度最后设置（默认为 None）。
package_path: Typst 包导入的目录，将包存放为 namespace/name/version 目录： #import "@preview/name:1.0.0" 读取 preview/name/1.0.0（默认为 None：除 mitex 外无任何包，mitex 由 manimgx 的引擎持有）。不下载任何内容。
background_stroke_color: 绘制于填充之后的轮廓颜色（默认黑色）。
background_stroke_opacity: 轮廓的不透明度，取值从 0 到 1（默认 1）。
background_stroke_width: 轮廓的宽度，以场景单位的百分之一计（默认 0：无）。
sheen_factor: 颜色朝 sheen_direction 变亮的程度，取值从 -1 到 1（默认 0）；负值变暗。
sheen_direction: 颜色变亮的方向（默认 UL）。
joint_type: 描边在路径转折处的连接方式：圆角、斜切或斜接，按二维场景的绘制方式（参见 LineJointType；默认 AUTO：斜接）。
cap_style: 描边在其显示的每一端的端点样式（开放路径的端点、虚线的端点）：圆头、平头或方头，按二维场景的绘制方式（参见 CapStyleType；默认 AUTO：平头）。
shade_in_3d: 三维场景的光是否对该 mobject 着色。
material: 其表面在三维场景中如何反射场景的光（参见 Material）；None：Manim 的着色（默认）。
name: mobject 的名称；未给出时为其类名。
z_index: 其在绘制顺序中的位置：索引较高者绘制于较低者之上（默认 0）。
target: MoveToTarget 将 mobject 移动至的状态。

还接受样式关键字。

源码

manimgx\mobjects\text.py

@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
    """文本，按所写形式。"""
    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)

text ¶

文本，按所写形式。

Paragraph ¶

作为一段落排版的文本行：在同一基线网格上，每行位于段落开头或 alignment 所定位置。

各行为一个 Text（lines_text），由换行连接，因此共享其网格：基线间距为 1 + line_spacing em（未给出 line_spacing 时为 1.3）。段落的各部分为各行，自顶向下，每行为其字形的组。

m.Paragraph(*text, alignment=None, **kwargs)

*text: 各行：每个字符串为一行，或在换行处分为多行。
alignment: "left"、"center" 或 "right" 将各行在该侧对齐或居中；None 使每行从段落开头开始（左到右文本的左侧）。
line_spacing: 行间距，以 em 计：文本的基线间距为 1 + line_spacing em，与其上的字形无关（默认 -1：0.3）。
font: 字体族：manimgx 附带的（New Computer Modern、Libertinus Serif、 DejaVu Sans Mono、Noto Sans……）、"serif"、"sans-serif" 或 "monospace"、 font_paths 中的，或系统的字体族；无处可寻的字体族回退到 New Computer Modern（默认 ""：New Computer Modern）。
slant: 倾斜：NORMAL、ITALIC 或 OBLIQUE（默认 NORMAL）。
weight: 字重，按名称，从 THIN 经 NORMAL 和 BOLD 到 ULTRAHEAVY （默认 NORMAL）；使用字体最接近的字重。
t2c: 每个键的颜色：所写文本的切片 "[a:b]"（含空格），或字符串的每次出现（默认 None）。
t2g: 每个键的渐变：其颜色沿键选取的字符分布，如同 t2c 选取它们（默认 None）。
t2s: 每个键的倾斜，按 t2c 的方式选取字符（默认 None）。
t2w: 每个键的字重，按 t2c 的方式选取字符（默认 None）。
gradient: 颜色沿整个文本逐字符分布，含空格（默认 None）。
tab_width: 制表符排版的空格数（默认 4）。
disable_ligatures: 每个字符是否各自为字形，无连字（默认 False： "fi" 可为一个字形）。
font_size: 文本的大小：一个 em 为 font_size / 96 场景单位，默认时为 0.5， 48（Text 按其大写字母确定大小：48 时高 0.449 单位）。
typst_preamble: 在文档之前设置的 Typst 代码：#set 和 #show 规则、#let 定义、导入（默认为 ""）。
font_paths: 字体文件（.ttf、.otf、.ttc、.otc）的目录，在 manimgx 附带的字体之前连同其子目录一起搜索；指向文件的路径不添加任何内容（默认为 None）。
should_center: mobject 是否居中于原点（默认为 True）。
height: 将 mobject 缩放至的高度，以场景单位计，而非按 font_size 确定大小（默认为 None）。
width: 将 mobject 缩放至的宽度，以场景单位计，而非按 font_size 确定大小；若同时给出 height，则宽度最后设置（默认为 None）。
package_path: Typst 包导入的目录，将包存放为 namespace/name/version 目录： #import "@preview/name:1.0.0" 读取 preview/name/1.0.0（默认为 None：除 mitex 外无任何包，mitex 由 manimgx 的引擎持有）。不下载任何内容。
background_stroke_color: 绘制于填充之后的轮廓颜色（默认黑色）。
background_stroke_opacity: 轮廓的不透明度，取值从 0 到 1（默认 1）。
background_stroke_width: 轮廓的宽度，以场景单位的百分之一计（默认 0：无）。
sheen_factor: 颜色朝 sheen_direction 变亮的程度，取值从 -1 到 1（默认 0）；负值变暗。
sheen_direction: 颜色变亮的方向（默认 UL）。
joint_type: 描边在路径转折处的连接方式：圆角、斜切或斜接，按二维场景的绘制方式（参见 LineJointType；默认 AUTO：斜接）。
cap_style: 描边在其显示的每一端的端点样式（开放路径的端点、虚线的端点）：圆头、平头或方头，按二维场景的绘制方式（参见 CapStyleType；默认 AUTO：平头）。
shade_in_3d: 三维场景的光是否对该 mobject 着色。
material: 其表面在三维场景中如何反射场景的光（参见 Material）；None：Manim 的着色（默认）。
name: mobject 的名称；未给出时为其类名。
z_index: 其在绘制顺序中的位置：索引较高者绘制于较低者之上（默认 0）。
target: MoveToTarget 将 mobject 移动至的状态。

还接受样式关键字。

源码

manimgx\mobjects\text.py

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)
    """作为单个 [Text][manimgx.Text] 的各行，由换行连接：段落的
    各行组其字形。"""
    # 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

lines_text ¶

作为单个 Text 的各行，由换行连接：段落的各行组其字形。

Title ¶

代码

import manimgx as m


class TitleExample(m.Scene):
    def construct(self) -> None:
        title = m.Title(r"The Pythagorean theorem: $a^2 + b^2 = c^2$")
        self.play(m.Write(title))

标题：位于画面顶部的 LaTeX 文本，其上有一条横线。

横线为最后一个部分，即标题的 underline；color 如 set_color 般为横线和文本着色。

m.Title(*text_parts, include_underline=True, match_underline_width_to_text=False, underline_buff=MED_SMALL_BUFF, **kwargs)

*text_parts: 标题，以 LaTeX 表示：每个字符串为一个部分。
include_underline: 是否在标题下绘制横线。
match_underline_width_to_text: 横线是否与标题同宽；若否，横线横跨画面但每侧留 1 单位。
underline_buff: 标题与横线之间的间距，以场景单位计。
arg_separator: 将字符串连接为 tex_string 的分隔符，即 MathTex 排版的公式，或 Tex 排版的文本（默认 " "；Tex 为 ""）。
substrings_to_isolate: 使其各自成为部分的子串：每个字符串在每个子串的每次出现处分割（默认 None）。
tex_to_color_map: 每个子串的颜色，子串如 substrings_to_isolate 般成为独立部分并着色（默认 None）。
tex_environment: 字符串的读取方式：名称含 "align"（"align*"，MathTex 的默认）为数学；任何其他（"center"，Tex 的默认，也使行居中），或 None 为 LaTeX 文本，数学在 $ 符号之间。
font_size: 文本的大小：一个 em 为 font_size / 96 场景单位，默认时为 0.5， 48（Text 按其大写字母确定大小：48 时高 0.449 单位）。
typst_preamble: 在文档之前设置的 Typst 代码：#set 和 #show 规则、#let 定义、导入（默认为 ""）。
font_paths: 字体文件（.ttf、.otf、.ttc、.otc）的目录，在 manimgx 附带的字体之前连同其子目录一起搜索；指向文件的路径不添加任何内容（默认为 None）。
should_center: mobject 是否居中于原点（默认为 True）。
height: 将 mobject 缩放至的高度，以场景单位计，而非按 font_size 确定大小（默认为 None）。
width: 将 mobject 缩放至的宽度，以场景单位计，而非按 font_size 确定大小；若同时给出 height，则宽度最后设置（默认为 None）。
package_path: Typst 包导入的目录，将包存放为 namespace/name/version 目录： #import "@preview/name:1.0.0" 读取 preview/name/1.0.0（默认为 None：除 mitex 外无任何包，mitex 由 manimgx 的引擎持有）。不下载任何内容。
background_stroke_color: 绘制于填充之后的轮廓颜色（默认黑色）。
background_stroke_opacity: 轮廓的不透明度，取值从 0 到 1（默认 1）。
background_stroke_width: 轮廓的宽度，以场景单位的百分之一计（默认 0：无）。
sheen_factor: 颜色朝 sheen_direction 变亮的程度，取值从 -1 到 1（默认 0）；负值变暗。
sheen_direction: 颜色变亮的方向（默认 UL）。
joint_type: 描边在路径转折处的连接方式：圆角、斜切或斜接，按二维场景的绘制方式（参见 LineJointType；默认 AUTO：斜接）。
cap_style: 描边在其显示的每一端的端点样式（开放路径的端点、虚线的端点）：圆头、平头或方头，按二维场景的绘制方式（参见 CapStyleType；默认 AUTO：平头）。
shade_in_3d: 三维场景的光是否对该 mobject 着色。
material: 其表面在三维场景中如何反射场景的光（参见 Material）；None：Manim 的着色（默认）。
name: mobject 的名称；未给出时为其类名。
z_index: 其在绘制顺序中的位置：索引较高者绘制于较低者之上（默认 0）。
target: MoveToTarget 将 mobject 移动至的状态。

还接受样式关键字。

源码

manimgx\mobjects\text.py

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
        """标题下方的横线，其最后一个部分（无横线的标题
        无此部分）。"""

underline ¶

标题下方的横线，其最后一个部分（无横线的标题无此部分）。

BulletedList ¶

代码

import manimgx as m


class BulletedListExample(m.Scene):
    def construct(self) -> None:
        items = m.BulletedList(
            "Typeset in the engine",
            "No LaTeX installation",
            r"Math too: $a^2 + b^2 = c^2$",
            font_size=72,
        )
        self.add(items)
        self.play(items.animate.fade_all_but(1))

项目列表：每行一个项，每项在项目符号之后，左对齐。

Typst 将各项设为列表：每个项目符号为居中点（LaTeX 的 \cdot 的两倍大小），距其项 SMALL_BUFF，各项间距 buff，以列表字号的场景单位计。每项为 LaTeX 文本（数学在 $ 符号之间）且为独立部分，其项目符号在前：items[1] 为第二项。 height 和 width 按设置缩放列表。

m.BulletedList(*items, buff=MED_LARGE_BUFF, **kwargs)

*items: 各项，以 LaTeX 表示。
buff: 项之间的间距，以场景单位计。
arg_separator: 将字符串连接为 tex_string 的分隔符，即 MathTex 排版的公式，或 Tex 排版的文本（默认 " "；Tex 为 ""）。
substrings_to_isolate: 使其各自成为部分的子串：每个字符串在每个子串的每次出现处分割（默认 None）。
tex_to_color_map: 每个子串的颜色，子串如 substrings_to_isolate 般成为独立部分并着色（默认 None）。
tex_environment: 字符串的读取方式：名称含 "align"（"align*"，MathTex 的默认）为数学；任何其他（"center"，Tex 的默认，也使行居中），或 None 为 LaTeX 文本，数学在 $ 符号之间。
font_size: 文本的大小：一个 em 为 font_size / 96 场景单位，默认时为 0.5， 48（Text 按其大写字母确定大小：48 时高 0.449 单位）。
typst_preamble: 在文档之前设置的 Typst 代码：#set 和 #show 规则、#let 定义、导入（默认为 ""）。
font_paths: 字体文件（.ttf、.otf、.ttc、.otc）的目录，在 manimgx 附带的字体之前连同其子目录一起搜索；指向文件的路径不添加任何内容（默认为 None）。
should_center: mobject 是否居中于原点（默认为 True）。
height: 将 mobject 缩放至的高度，以场景单位计，而非按 font_size 确定大小（默认为 None）。
width: 将 mobject 缩放至的宽度，以场景单位计，而非按 font_size 确定大小；若同时给出 height，则宽度最后设置（默认为 None）。
package_path: Typst 包导入的目录，将包存放为 namespace/name/version 目录： #import "@preview/name:1.0.0" 读取 preview/name/1.0.0（默认为 None：除 mitex 外无任何包，mitex 由 manimgx 的引擎持有）。不下载任何内容。
background_stroke_color: 绘制于填充之后的轮廓颜色（默认黑色）。
background_stroke_opacity: 轮廓的不透明度，取值从 0 到 1（默认 1）。
background_stroke_width: 轮廓的宽度，以场景单位的百分之一计（默认 0：无）。
sheen_factor: 颜色朝 sheen_direction 变亮的程度，取值从 -1 到 1（默认 0）；负值变暗。
sheen_direction: 颜色变亮的方向（默认 UL）。
joint_type: 描边在路径转折处的连接方式：圆角、斜切或斜接，按二维场景的绘制方式（参见 LineJointType；默认 AUTO：斜接）。
cap_style: 描边在其显示的每一端的端点样式（开放路径的端点、虚线的端点）：圆头、平头或方头，按二维场景的绘制方式（参见 CapStyleType；默认 AUTO：平头）。
shade_in_3d: 三维场景的光是否对该 mobject 着色。
material: 其表面在三维场景中如何反射场景的光（参见 Material）；None：Manim 的着色（默认）。
name: mobject 的名称；未给出时为其类名。
z_index: 其在绘制顺序中的位置：索引较高者绘制于较低者之上（默认 0）。
target: MoveToTarget 将 mobject 移动至的状态。

还接受样式关键字。

源码

manimgx\mobjects\text.py

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)

fade_all_but ¶

淡出除一项外的所有项：其余项的填充为 opacity，该项为 1。

bulleted_list.fade_all_but(index, opacity=0.5)

index: 项的索引，从 0 开始。
opacity: 其他项的填充不透明度，从 0 到 1。

源码

manimgx\mobjects\text.py

def fade_all_but(self, index: int, opacity: float = 0.5) -> Self:
    """淡出除一项外的所有项：其余项的填充为 `opacity`，该项为 1。

    Args:
        index: 项的索引，从 0 开始。
        opacity: 其他项的填充不透明度，从 0 到 1。
    """
    part = self.submobjects[index]
    for other in self.submobjects:
        other.set_fill(opacity=1 if other is part else opacity)
    return self

Code ¶

源代码列表，带高亮：其各行、行号，以及位于其后的矩形或窗口。

代码由 Typst 的文法按 formatter_style 的颜色进行高亮，默认使用等宽字体。其组成部分为 background、line_numbers（若行已编号）以及 code_lines，后者的第 i 个部分是第 i 行，即由该行字形组成的组，不含空格。制表符会被展开，开头和结尾的空行会被丢弃。

m.Code(code_file=None, code_string=None, language=None, formatter_style='vim', tab_width=4, add_line_numbers=True, line_numbers_from=1, background='rectangle', background_config=None, paragraph_config=None)

code_file: 从中读取代码的文件（UTF-8 编码）；其扩展名指定语言，除非 language 已指定。
code_string: 当没有 code_file 时使用的代码；二者必须给出其一（否则抛出 ValueError）。
language: 按名称或文件扩展名指定用于高亮代码的语言（"python"、"rust"、"cpp"、 "js"、……：即 Typst 的 raw 所识别的那些）；None 或其不认识的语言表示纯文本。
formatter_style: 颜色方案："vim"，唯一可用样式，黑色背景。
tab_width: 制表位之间相隔的列数。
add_line_numbers: 是否在左侧对各行编号。
line_numbers_from: 第一行的编号。
background: "rectangle" 或 "window"：一个矩形，或一个顶部带有窗口三个按钮的矩形。
background_config: 背景的环绕矩形关键字，叠加于 default_background_config 之上：边距为 0.3、圆角、细白色轮廓以及样式的背景色。
paragraph_config: 文本的代码文本关键字，叠加于 default_paragraph_config 之上。

源码

manimgx\mobjects\code.py

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 {})
    # tabs expanded, empty 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)
    """各行，作为一个部分：其第 i 个部分是第 i 行，即由该行字形组成的组。"""

    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)
        """行号，作为一个部分（若行已编号）：其第 i 个部分是第 i 行的编号，右对齐
        排列。"""
        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)
        """列表背后的矩形，为其第一个部分；窗口的按钮为其子对象。"""
    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)

default_background_config ¶

背景的关键字，除非被 background_config 更改；其填充色为样式的背景色，除非给定 fill_color。

default_paragraph_config ¶

文本的关键字，除非被 paragraph_config 更改。

code_lines ¶

各行，作为一个部分：其第 i 个部分是第 i 行，即由该行字形组成的组。

line_numbers ¶

行号，作为一个部分（若行已编号）：其第 i 个部分是第 i 行的编号，右对齐排列。

background ¶

列表背后的矩形，为其第一个部分；窗口的按钮为其子对象。

CodeText ¶

Code 列表的文本：其 paragraph_config，即应用于列表的文本关键字。

font: 字体族："Monospace" 为默认值，在所有平台上均为内置的 DejaVu Sans Mono；任何其他字体族要么是 manimgx 附带的，要么是系统提供的。
font_size: 文本的大小：一个 em 为 font_size / 72 场景单位（默认 24）。
line_spacing: 各行之间的距离，超出字体大小的部分：它们的基线相距 (1 + line_spacing) * font_size / 96 场景单位（默认 0.5；-1 对应 0.3）。
disable_ligatures: 是否每个字符都是独立的字形，不使用连字（默认 True）。

font ¶

字体族："Monospace" 为默认值，在所有平台上均为内置的 DejaVu Sans Mono；任何其他字体族要么是 manimgx 附带的，要么是系统提供的。

font_size ¶

文本的大小：一个 em 为 font_size / 72 场景单位（默认 24）。

line_spacing ¶

各行之间的距离，超出字体大小的部分：它们的基线相距 (1 + line_spacing) * font_size / 96 场景单位（默认 0.5；-1 对应 0.3）。

disable_ligatures ¶

是否每个字符都是独立的字形，不使用连字（默认 True）。

字重与倾斜¶

文本的 weight 是其笔画粗细程度，slant 是其倾斜程度。

m.NORMAL ¶

文本的正体倾斜（直立）及其常规字重（400）。

m.ITALIC ¶

文本的斜体倾斜。

m.OBLIQUE ¶

文本的倾斜体：将正体字母倾斜。

m.THIN ¶

文本字重：细体（100）。

m.ULTRALIGHT ¶

文本字重：超轻体（200）。

m.LIGHT ¶

文本字重：轻体（300）。

m.SEMILIGHT ¶

文本字重：半轻体（350）。

m.BOOK ¶

文本字重：书体（380）。

m.MEDIUM ¶

文本字重：中等（500）。

m.SEMIBOLD ¶

文本字重：半粗体（600）。

m.BOLD ¶

文本字重：粗体（700）。

m.ULTRABOLD ¶

文本字重：超粗体（800）。

m.HEAVY ¶

文本字重：重体（900）。

m.ULTRAHEAVY ¶

文本字重：超重体（950）。

TypstOptions ¶

Typst 的关键字，用于传递它们的类：文本和 LaTeX。

除此之外，它们还接受[外观关键字][manimgx.drawing.paint.Look]和绘制关键字，后者在排版赋予各部分的颜色之上重新着色。

font_size: 文本的大小：一个 em 为 font_size / 96 场景单位，默认时为 0.5， 48（Text 按其大写字母确定大小：48 时高 0.449 单位）。
typst_preamble: 在文档之前设置的 Typst 代码：#set 和 #show 规则、#let 定义、导入（默认为 ""）。
font_paths: 字体文件（.ttf、.otf、.ttc、.otc）的目录，在 manimgx 附带的字体之前连同其子目录一起搜索；指向文件的路径不添加任何内容（默认为 None）。
should_center: mobject 是否居中于原点（默认为 True）。
height: 将 mobject 缩放至的高度，以场景单位计，而非按 font_size 确定大小（默认为 None）。
width: 将 mobject 缩放至的宽度，以场景单位计，而非按 font_size 确定大小；若同时给出 height，则宽度最后设置（默认为 None）。
package_path: Typst 包导入的目录，将包存放为 namespace/name/version 目录： #import "@preview/name:1.0.0" 读取 preview/name/1.0.0（默认为 None：除 mitex 外无任何包，mitex 由 manimgx 的引擎持有）。不下载任何内容。
background_stroke_color: 绘制于填充之后的轮廓颜色（默认黑色）。
background_stroke_opacity: 轮廓的不透明度，取值从 0 到 1（默认 1）。
background_stroke_width: 轮廓的宽度，以场景单位的百分之一计（默认 0：无）。
sheen_factor: 颜色朝 sheen_direction 变亮的程度，取值从 -1 到 1（默认 0）；负值变暗。
sheen_direction: 颜色变亮的方向（默认 UL）。
joint_type: 描边在路径转折处的连接方式：圆角、斜切或斜接，按二维场景的绘制方式（参见 LineJointType；默认 AUTO：斜接）。
cap_style: 描边在其显示的每一端的端点样式（开放路径的端点、虚线的端点）：圆头、平头或方头，按二维场景的绘制方式（参见 CapStyleType；默认 AUTO：平头）。
shade_in_3d: 三维场景的光是否对该 mobject 着色。
material: 其表面在三维场景中如何反射场景的光（参见 Material）；None：Manim 的着色（默认）。
name: mobject 的名称；未给出时为其类名。
z_index: 其在绘制顺序中的位置：索引较高者绘制于较低者之上（默认 0）。
target: MoveToTarget 将 mobject 移动至的状态。
color: 填充与描边共用的颜色。
opacity: 填充与描边共用的不透明度，取值从 0 到 1。
fill_color: 填充的颜色。
fill_opacity: 填充的不透明度，取值从 0 到 1。
stroke_color: 描边的颜色。
stroke_opacity: 描边的不透明度，取值从 0 到 1。
stroke_width: 描边的宽度，以场景单位的百分之一计。