Module fpdf.line_break

Routines for organizing lines and larger blocks of text, with manual and automatic line wrapping.

The contents of this module are internal to fpdf2, and not part of the public API. They may change at any time without prior warning or any deprecation period, in non-backward-compatible ways.

Classes

class CurrentLine (max_width: float, print_sh: bool = False)

Per-line text fragment management for use by MultiLineBreak. Args: print_sh (bool): If true, a soft-hyphen will be rendered normally, instead of triggering a line break. Default: False

Expand source code Browse git

class CurrentLine:
    def __init__(self, max_width: float, print_sh: bool = False):
        """
        Per-line text fragment management for use by MultiLineBreak.
            Args:
                print_sh (bool): If true, a soft-hyphen will be rendered
                    normally, instead of triggering a line break. Default: False
        """
        self.max_width = max_width
        self.print_sh = print_sh
        self.fragments: List[Fragment] = []
        self.height = 0
        self.number_of_spaces = 0

        # automatic break hints
        # CurrentLine class remembers 3 positions
        # 1 - position of last inserted character.
        #     class attributes (`width`, `fragments`)
        #     is used for this purpose
        # 2 - position of last inserted space
        #     SpaceHint is used fo this purpose.
        # 3 - position of last inserted soft-hyphen
        #     HyphenHint is used fo this purpose.
        # The purpose of multiple positions tracking - to have an ability
        # to break in multiple places, depending on condition.
        self.space_break_hint = None
        self.hyphen_break_hint = None

    @property
    def width(self):
        width = 0
        for i, fragment in enumerate(self.fragments):
            width += fragment.get_width(initial_cs=i > 0)
        return width

    def add_character(
        self,
        character: str,
        character_width: float,
        original_fragment: Fragment,
        original_fragment_index: int,
        original_character_index: int,
        height: float,
        url: str = None,
    ):
        assert character != NEWLINE
        self.height = height
        if not self.fragments:
            self.fragments.append(
                original_fragment.__class__(
                    characters="",
                    graphics_state=original_fragment.graphics_state,
                    k=original_fragment.k,
                    link=url,
                )
            )

        # characters are expected to be grouped into fragments by font and
        # character attributes. If the last existing fragment doesn't match
        # the properties of the pending character -> add a new fragment.
        elif isinstance(
            original_fragment, Fragment
        ) and not original_fragment.has_same_style(self.fragments[-1]):
            self.fragments.append(
                original_fragment.__class__(
                    characters="",
                    graphics_state=original_fragment.graphics_state,
                    k=original_fragment.k,
                    link=url,
                )
            )
        active_fragment = self.fragments[-1]

        if character in BREAKING_SPACE_SYMBOLS_STR:
            self.space_break_hint = SpaceHint(
                original_fragment_index,
                original_character_index,
                len(self.fragments),
                len(active_fragment.characters),
                self.width,
                self.number_of_spaces,
            )
            self.number_of_spaces += 1
        elif character == NBSP:
            # PDF viewers ignore NBSP for word spacing with "Tw".
            character = SPACE
            self.number_of_spaces += 1
        elif character == SOFT_HYPHEN and not self.print_sh:
            self.hyphen_break_hint = HyphenHint(
                original_fragment_index,
                original_character_index,
                len(self.fragments),
                len(active_fragment.characters),
                self.width,
                self.number_of_spaces,
                HYPHEN,
                character_width,
                original_fragment.graphics_state,
                original_fragment.k,
            )

        if character != SOFT_HYPHEN or self.print_sh:
            active_fragment.characters.append(character)

    def trim_trailing_spaces(self):
        if not self.fragments:
            return
        last_frag = self.fragments[-1]
        last_char = last_frag.characters[-1]
        while last_char == " ":
            last_frag.trim(-1)
            if not last_frag.characters:
                del self.fragments[-1]
            if not self.fragments:
                return
            last_frag = self.fragments[-1]
            last_char = last_frag.characters[-1]

    def _apply_automatic_hint(self, break_hint: Union[SpaceHint, HyphenHint]):
        """
        This function mutates the current_line, applying one of the states
        observed in the past and stored in
        `hyphen_break_hint` or `space_break_hint` attributes.
        """
        self.fragments = self.fragments[: break_hint.current_line_fragment_index]
        if self.fragments:
            self.fragments[-1].trim(break_hint.current_line_character_index)
        self.number_of_spaces = break_hint.number_of_spaces

    def manual_break(
        self, align: Align, trailing_nl: bool = False, trailing_form_feed: bool = False
    ):
        return TextLine(
            fragments=self.fragments,
            text_width=self.width,
            number_of_spaces=self.number_of_spaces,
            align=align,
            height=self.height,
            max_width=self.max_width,
            trailing_nl=trailing_nl,
            trailing_form_feed=trailing_form_feed,
        )

    def automatic_break_possible(self):
        return self.hyphen_break_hint is not None or self.space_break_hint is not None

    def automatic_break(self, align: Align):
        assert self.automatic_break_possible()
        if self.hyphen_break_hint is not None and (
            self.space_break_hint is None
            or self.hyphen_break_hint.line_width > self.space_break_hint.line_width
        ):
            self._apply_automatic_hint(self.hyphen_break_hint)
            self.add_character(
                self.hyphen_break_hint.curchar,
                self.hyphen_break_hint.curchar_width,
                self.hyphen_break_hint,
                self.hyphen_break_hint.original_fragment_index,
                self.hyphen_break_hint.original_character_index,
                self.height,
            )
            return (
                self.hyphen_break_hint.original_fragment_index,
                self.hyphen_break_hint.original_character_index,
                self.manual_break(align),
            )
        self._apply_automatic_hint(self.space_break_hint)
        return (
            self.space_break_hint.original_fragment_index,
            self.space_break_hint.original_character_index,
            self.manual_break(align),
        )

Instance variables

prop width

Expand source code

@property
def width(self):
    width = 0
    for i, fragment in enumerate(self.fragments):
        width += fragment.get_width(initial_cs=i > 0)
    return width

Methods

def add_character(self, character: str, character_width: float, original_fragment: Fragment, original_fragment_index: int, original_character_index: int, height: float, url: str = None)

def automatic_break(self, align: Align)

def automatic_break_possible(self)

def manual_break(self, align: Align, trailing_nl: bool = False, trailing_form_feed: bool = False)

def trim_trailing_spaces(self)

class Fragment (characters: Union[list, str], graphics_state: dict, k: float, link: Union[str, int, ForwardRef(None)] = None)

A fragment of text with font/size/style and other associated information.

Expand source code Browse git

class Fragment:
    """
    A fragment of text with font/size/style and other associated information.
    """

    def __init__(
        self,
        characters: Union[list, str],
        graphics_state: dict,
        k: float,
        link: Optional[Union[int, str]] = None,
    ):
        if isinstance(characters, str):
            self.characters = list(characters)
        else:
            self.characters = characters
        self.graphics_state = graphics_state
        self.k = k
        self.link = link

    def __repr__(self):
        return (
            f"Fragment(characters={self.characters},"
            f" graphics_state={self.graphics_state},"
            f" k={self.k}, link={self.link})"
        )

    @property
    def font(self) -> Union[CoreFont, TTFFont]:
        return self.graphics_state["current_font"]

    @font.setter
    def font(self, v):
        self.graphics_state["current_font"] = v

    @property
    def is_ttf_font(self):
        return self.font and self.font.type == "TTF"

    @property
    def font_style(self):
        return self.graphics_state["font_style"]

    @property
    def font_family(self):
        return self.graphics_state["font_family"]

    @property
    def font_size_pt(self):
        size = self.graphics_state["font_size_pt"]
        vpos = self.graphics_state["char_vpos"]
        if vpos == CharVPos.SUB:
            size *= self.graphics_state["sub_scale"]
        elif vpos == CharVPos.SUP:
            size *= self.graphics_state["sup_scale"]
        elif vpos == CharVPos.NOM:
            size *= self.graphics_state["nom_scale"]
        elif vpos == CharVPos.DENOM:
            size *= self.graphics_state["denom_scale"]
        return size

    @property
    def font_size(self):
        return self.graphics_state["font_size_pt"] / self.k

    @property
    def font_stretching(self):
        return self.graphics_state["font_stretching"]

    @property
    def char_spacing(self):
        return self.graphics_state["char_spacing"]

    @property
    def text_mode(self):
        return self.graphics_state["text_mode"]

    @property
    def underline(self):
        return self.graphics_state["underline"]

    @property
    def draw_color(self):
        return self.graphics_state["draw_color"]

    @property
    def fill_color(self):
        return self.graphics_state["fill_color"]

    @property
    def text_color(self):
        return self.graphics_state["text_color"]

    @property
    def line_width(self):
        return self.graphics_state["line_width"]

    @property
    def char_vpos(self):
        return self.graphics_state["char_vpos"]

    @property
    def lift(self):
        vpos = self.graphics_state["char_vpos"]
        if vpos == CharVPos.SUB:
            lift = self.graphics_state["sub_lift"]
        elif vpos == CharVPos.SUP:
            lift = self.graphics_state["sup_lift"]
        elif vpos == CharVPos.NOM:
            lift = self.graphics_state["nom_lift"]
        elif vpos == CharVPos.DENOM:
            lift = self.graphics_state["denom_lift"]
        else:
            lift = 0.0
        return lift * self.graphics_state["font_size_pt"]

    @property
    def string(self):
        return "".join(self.characters)

    @property
    def width(self):
        return self.get_width()

    @property
    def text_shaping_parameters(self):
        return self.graphics_state["text_shaping"]

    @property
    def paragraph_direction(self):
        return (
            self.text_shaping_parameters["paragraph_direction"]
            if self.text_shaping_parameters
            else TextDirection.LTR
        )

    @property
    def fragment_direction(self):
        return (
            self.text_shaping_parameters["fragment_direction"]
            if self.text_shaping_parameters
            else TextDirection.LTR
        )

    def trim(self, index: int):
        self.characters = self.characters[:index]

    def __eq__(self, other: Any):
        return (
            self.characters == other.characters
            and self.graphics_state == other.graphics_state
            and self.k == other.k
        )

    def __hash__(self):
        return hash((self.characters, self.graphics_state, self.k))

    def get_width(
        self,
        start: int = 0,
        end: int = None,
        chars: str = None,
        initial_cs: bool = True,
    ):
        """
        Return the width of the string with the given font/size/style/etc.

        Args:
            start (int): Index of the start character. Default start of fragment.
            end (int): Index of the end character. Default end of fragment.
            chars (str): Specific text to get the width for (not necessarily the
                same as the contents of the fragment). If given, this takes
                precedence over the start/end arguments.
        """

        if chars is None:
            chars = self.characters[start:end]
        (char_len, w) = self.font.get_text_width(
            chars, self.font_size_pt, self.text_shaping_parameters
        )
        char_spacing = self.char_spacing
        if self.font_stretching != 100:
            w *= self.font_stretching * 0.01
            char_spacing *= self.font_stretching * 0.01
        if self.char_spacing != 0:
            # initial_cs must be False if the fragment is located at the
            # beginning of a text object, because the first char won't get spaced.
            if initial_cs:
                w += char_spacing * char_len
            else:
                w += char_spacing * (char_len - 1)
        return w / self.k

    def has_same_style(self, other: "Fragment"):
        """Returns if 2 fragments are equivalent other than the characters/string"""
        return (
            self.graphics_state == other.graphics_state
            and self.k == other.k
            and isinstance(other, self.__class__)
        )

    def get_character_width(self, character: str, print_sh=False, initial_cs=True):
        """
        Return the width of a single character out of the stored text.
        """
        if character == SOFT_HYPHEN and not print_sh:
            # HYPHEN is inserted instead of SOFT_HYPHEN
            character = HYPHEN
        return self.get_width(chars=character, initial_cs=initial_cs)

    def render_pdf_text(self, frag_ws, current_ws, word_spacing, adjust_x, adjust_y, h):
        if self.is_ttf_font:
            if self.text_shaping_parameters:
                return self.render_with_text_shaping(
                    adjust_x, adjust_y, h, word_spacing
                )
            return self.render_pdf_text_ttf(frag_ws, word_spacing)
        return self.render_pdf_text_core(frag_ws, current_ws)

    def render_pdf_text_ttf(self, frag_ws, word_spacing):
        ret = ""
        mapped_text = ""
        for char in self.string:
            mapped_char = self.font.subset.pick(ord(char))
            if mapped_char:
                mapped_text += chr(mapped_char)
        if word_spacing:
            # do this once in advance
            u_space = escape_parens(" ".encode("utf-16-be").decode("latin-1"))

            # According to the PDF reference, word spacing shall be applied to every
            # occurrence of the single-byte character code 32 in a string when using
            # a simple font or a composite font that defines code 32 as a single-byte code.
            # It shall not apply to occurrences of the byte value 32 in multiple-byte codes.
            # FPDF uses 2 bytes per character (UTF-16-BE encoding) so the "Tw" operator doesn't work
            # As a workaround, we do word spacing using an adjustment before each space.
            # Determine the index of the space character (" ") in the current
            # subset and split words whenever this mapping code is found
            #
            words = mapped_text.split(chr(self.font.subset.pick(ord(" "))))
            words_strl = []
            for word_i, word in enumerate(words):
                # pylint: disable=redefined-loop-name
                word = escape_parens(word.encode("utf-16-be").decode("latin-1"))
                if word_i == 0:
                    words_strl.append(f"({word})")
                else:
                    adj = -(frag_ws * self.k) * 1000 / self.font_size_pt
                    words_strl.append(f"{adj:.3f}({u_space}{word})")
            escaped_text = " ".join(words_strl)
            ret += f"[{escaped_text}] TJ"
        else:
            escaped_text = escape_parens(
                mapped_text.encode("utf-16-be").decode("latin-1")
            )
            ret += f"({escaped_text}) Tj"
        return ret

    def render_with_text_shaping(self, pos_x, pos_y, h, word_spacing):
        ret = ""
        text = ""
        space_mapped_code = self.font.subset.pick(ord(" "))

        def adjust_pos(pos):
            return (
                pos
                * self.font.scale
                * self.font_size_pt
                * (self.font_stretching / 100)
                / 1000
                / self.k
            )

        char_spacing = self.char_spacing * (self.font_stretching / 100) / self.k
        for ti in self.font.shape_text(
            self.string, self.font_size_pt, self.text_shaping_parameters
        ):
            if ti["mapped_char"] is None:  # Missing glyph
                continue
            char = chr(ti["mapped_char"]).encode("utf-16-be").decode("latin-1")
            if ti["x_offset"] != 0 or ti["y_offset"] != 0:
                if text:
                    ret += f"({escape_parens(text)}) Tj "
                    text = ""
                offsetx = pos_x + adjust_pos(ti["x_offset"])
                offsety = pos_y - adjust_pos(ti["y_offset"])
                ret += (
                    f"1 0 0 1 {(offsetx) * self.k:.2f} {(h - offsety) * self.k:.2f} Tm "
                )
            text += char
            pos_x += adjust_pos(ti["x_advance"]) + char_spacing
            pos_y += adjust_pos(ti["y_advance"])
            if word_spacing and ti["mapped_char"] == space_mapped_code:
                pos_x += word_spacing

            # if only moving "x" we don't need to move the text matrix
            if ti["force_positioning"] or (
                word_spacing and ti["mapped_char"] == space_mapped_code
            ):
                if text:
                    ret += f"({escape_parens(text)}) Tj "
                    text = ""
                ret += f"1 0 0 1 {(pos_x) * self.k:.2f} {(h - pos_y) * self.k:.2f} Tm "

        if text:
            ret += f"({escape_parens(text)}) Tj"
        return ret

    def render_pdf_text_core(self, frag_ws, current_ws):
        ret = ""
        if frag_ws != current_ws:
            ret += f"{frag_ws * self.k:.3f} Tw "
        escaped_text = escape_parens(self.string)
        ret += f"({escaped_text}) Tj"
        return ret

Subclasses

• TotalPagesSubstitutionFragment

Instance variables

prop char_spacing

Expand source code

@property
def char_spacing(self):
    return self.graphics_state["char_spacing"]

prop char_vpos

Expand source code

@property
def char_vpos(self):
    return self.graphics_state["char_vpos"]

prop draw_color

Expand source code

@property
def draw_color(self):
    return self.graphics_state["draw_color"]

prop fill_color

Expand source code

@property
def fill_color(self):
    return self.graphics_state["fill_color"]

prop font : Union[CoreFont, TTFFont]

Expand source code

@property
def font(self) -> Union[CoreFont, TTFFont]:
    return self.graphics_state["current_font"]

prop font_family

Expand source code

@property
def font_family(self):
    return self.graphics_state["font_family"]

prop font_size

Expand source code

@property
def font_size(self):
    return self.graphics_state["font_size_pt"] / self.k

prop font_size_pt

Expand source code

@property
def font_size_pt(self):
    size = self.graphics_state["font_size_pt"]
    vpos = self.graphics_state["char_vpos"]
    if vpos == CharVPos.SUB:
        size *= self.graphics_state["sub_scale"]
    elif vpos == CharVPos.SUP:
        size *= self.graphics_state["sup_scale"]
    elif vpos == CharVPos.NOM:
        size *= self.graphics_state["nom_scale"]
    elif vpos == CharVPos.DENOM:
        size *= self.graphics_state["denom_scale"]
    return size

prop font_stretching

Expand source code

@property
def font_stretching(self):
    return self.graphics_state["font_stretching"]

prop font_style

Expand source code

@property
def font_style(self):
    return self.graphics_state["font_style"]

prop fragment_direction

Expand source code

@property
def fragment_direction(self):
    return (
        self.text_shaping_parameters["fragment_direction"]
        if self.text_shaping_parameters
        else TextDirection.LTR
    )

prop is_ttf_font

Expand source code

@property
def is_ttf_font(self):
    return self.font and self.font.type == "TTF"

prop lift

Expand source code

@property
def lift(self):
    vpos = self.graphics_state["char_vpos"]
    if vpos == CharVPos.SUB:
        lift = self.graphics_state["sub_lift"]
    elif vpos == CharVPos.SUP:
        lift = self.graphics_state["sup_lift"]
    elif vpos == CharVPos.NOM:
        lift = self.graphics_state["nom_lift"]
    elif vpos == CharVPos.DENOM:
        lift = self.graphics_state["denom_lift"]
    else:
        lift = 0.0
    return lift * self.graphics_state["font_size_pt"]

prop line_width

Expand source code

@property
def line_width(self):
    return self.graphics_state["line_width"]

prop paragraph_direction

Expand source code

@property
def paragraph_direction(self):
    return (
        self.text_shaping_parameters["paragraph_direction"]
        if self.text_shaping_parameters
        else TextDirection.LTR
    )

prop string

Expand source code

@property
def string(self):
    return "".join(self.characters)

prop text_color

Expand source code

@property
def text_color(self):
    return self.graphics_state["text_color"]

prop text_mode

Expand source code

@property
def text_mode(self):
    return self.graphics_state["text_mode"]

prop text_shaping_parameters

Expand source code

@property
def text_shaping_parameters(self):
    return self.graphics_state["text_shaping"]

prop underline

Expand source code

@property
def underline(self):
    return self.graphics_state["underline"]

prop width

Expand source code

@property
def width(self):
    return self.get_width()

Methods

def get_character_width(self, character: str, print_sh=False, initial_cs=True)

Return the width of a single character out of the stored text.

def get_width(self, start: int = 0, end: int = None, chars: str = None, initial_cs: bool = True)

Return the width of the string with the given font/size/style/etc.

Args

start : int

Index of the start character. Default start of fragment.

end : int

Index of the end character. Default end of fragment.

chars : str

Specific text to get the width for (not necessarily the same as the contents of the fragment). If given, this takes precedence over the start/end arguments.

def has_same_style(self, other: Fragment)

Returns if 2 fragments are equivalent other than the characters/string

def render_pdf_text(self, frag_ws, current_ws, word_spacing, adjust_x, adjust_y, h)

def render_pdf_text_core(self, frag_ws, current_ws)

def render_pdf_text_ttf(self, frag_ws, word_spacing)

def render_with_text_shaping(self, pos_x, pos_y, h, word_spacing)

def trim(self, index: int)

class HyphenHint (original_fragment_index: int, original_character_index: int, current_line_fragment_index: int, current_line_character_index: int, line_width: float, number_of_spaces: int, curchar: str, curchar_width: float, graphics_state: dict, k: float)

HyphenHint(original_fragment_index, original_character_index, current_line_fragment_index, current_line_character_index, line_width, number_of_spaces, curchar, curchar_width, graphics_state, k)

Expand source code Browse git

class HyphenHint(NamedTuple):
    original_fragment_index: int
    original_character_index: int
    current_line_fragment_index: int
    current_line_character_index: int
    line_width: float
    number_of_spaces: int
    curchar: str
    curchar_width: float
    graphics_state: dict
    k: float

Ancestors

• builtins.tuple

Instance variables

var curchar : str

Alias for field number 6

var curchar_width : float

Alias for field number 7

var current_line_character_index : int

Alias for field number 3

var current_line_fragment_index : int

Alias for field number 2

var graphics_state : dict

Alias for field number 8

var k : float

Alias for field number 9

var line_width : float

Alias for field number 4

var number_of_spaces : int

Alias for field number 5

var original_character_index : int

Alias for field number 1

var original_fragment_index : int

Alias for field number 0

class MultiLineBreak (fragments: Sequence[Fragment], max_width: Union[float, ], margins: Sequence[numbers.Number], align: Align = Align.L, print_sh: bool = False, wrapmode: WrapMode = WrapMode.WORD, line_height: float = 1.0, skip_leading_spaces: bool = False)

Accept text as Fragments, to be split into individual lines depending on line width and text height.

Args

fragments

A sequence of Fragment()s containing text.

max_width

Either a fixed width as float or a callback function get_width(height). If a function, it gets called with the largest height encountered on the current line, and must return the applicable width for the line with the given height at the current vertical position. The height is relevant in those cases where the lateral boundaries of the enclosing TextRegion() are not vertical.

margins : sequence of floats

The extra clearance that may apply at the beginning and/or end of a line (usually either FPDF.c_margin or 0.0 for each side).

align : Align

The horizontal alignment of the current text block.

print_sh : bool

If True, a soft-hyphen will be rendered normally, instead of triggering a line break. Default: False

wrapmode : WrapMode

Selects word or character based wrapping.

line_height : float, optional

A multiplier relative to the font size changing the vertical space occupied by a line of text. Default 1.0.

skip_leading_spaces : bool, optional

On each line, any space characters at the beginning will be skipped. Default value: False.

Expand source code Browse git

class MultiLineBreak:
    def __init__(
        self,
        fragments: Sequence[Fragment],
        max_width: Union[float, callable],
        margins: Sequence[Number],
        align: Align = Align.L,
        print_sh: bool = False,
        wrapmode: WrapMode = WrapMode.WORD,
        line_height: float = 1.0,
        skip_leading_spaces: bool = False,
    ):
        """Accept text as Fragments, to be split into individual lines depending
        on line width and text height.
        Args:
            fragments: A sequence of Fragment()s containing text.
            max_width: Either a fixed width as float or a callback function
                get_width(height). If a function, it gets called with the largest
                height encountered on the current line, and must return the
                applicable width for the line with the given height at the current
                vertical position. The height is relevant in those cases where the
                lateral boundaries of the enclosing TextRegion() are not vertical.
            margins (sequence of floats): The extra clearance that may apply at the beginning
                and/or end of a line (usually either FPDF.c_margin or 0.0 for each side).
            align (Align): The horizontal alignment of the current text block.
            print_sh (bool): If True, a soft-hyphen will be rendered
                normally, instead of triggering a line break. Default: False
            wrapmode (WrapMode): Selects word or character based wrapping.
            line_height (float, optional): A multiplier relative to the font
                size changing the vertical space occupied by a line of text. Default 1.0.
            skip_leading_spaces (bool, optional): On each line, any space characters
                at the beginning will be skipped. Default value: False.
        """

        self.fragments = fragments
        if callable(max_width):
            self.get_width = max_width
        else:
            self.get_width = lambda height: max_width
        self.margins = margins
        self.align = align
        self.print_sh = print_sh
        self.wrapmode = wrapmode
        self.line_height = line_height
        self.skip_leading_spaces = skip_leading_spaces
        self.fragment_index = 0
        self.character_index = 0
        self.idx_last_forced_break = None

    # pylint: disable=too-many-return-statements
    def get_line(self):
        first_char = True  # "Tw" ignores the first character in a text object.
        idx_last_forced_break = self.idx_last_forced_break
        self.idx_last_forced_break = None

        if self.fragment_index == len(self.fragments):
            return None

        current_font_height = 0

        max_width = self.get_width(current_font_height)
        # The full max width will be passed on via TextLine to FPDF._render_styled_text_line().
        current_line = CurrentLine(max_width=max_width, print_sh=self.print_sh)
        # For line wrapping we need to use the reduced width.
        for margin in self.margins:
            max_width -= margin

        if self.skip_leading_spaces:
            # write_html() with TextColumns uses this, since it can't know in
            # advance where the lines will be broken.
            while self.fragment_index < len(self.fragments):
                if self.character_index >= len(
                    self.fragments[self.fragment_index].characters
                ):
                    self.character_index = 0
                    self.fragment_index += 1
                    continue
                character = self.fragments[self.fragment_index].characters[
                    self.character_index
                ]
                if character == SPACE:
                    self.character_index += 1
                else:
                    break

        while self.fragment_index < len(self.fragments):
            current_fragment = self.fragments[self.fragment_index]

            if current_fragment.font_size > current_font_height:
                current_font_height = current_fragment.font_size  # document units
                max_width = self.get_width(current_font_height)
                current_line.max_width = max_width
                for margin in self.margins:
                    max_width -= margin

            if self.character_index >= len(current_fragment.characters):
                self.character_index = 0
                self.fragment_index += 1

                continue

            character = current_fragment.characters[self.character_index]
            character_width = current_fragment.get_character_width(
                character, self.print_sh, initial_cs=not first_char
            )
            first_char = False

            if character in (NEWLINE, FORM_FEED):
                self.character_index += 1
                if not current_line.fragments:
                    current_line.height = current_font_height * self.line_height
                return current_line.manual_break(
                    Align.L if self.align == Align.J else self.align,
                    trailing_nl=character == NEWLINE,
                    trailing_form_feed=character == FORM_FEED,
                )
            if current_line.width + character_width > max_width:
                if (
                    character in BREAKING_SPACE_SYMBOLS_STR
                ):  # must come first, always drop a current space.
                    self.character_index += 1
                    return current_line.manual_break(self.align)
                if self.wrapmode == WrapMode.CHAR:
                    # If the line ends with one or more spaces, then we want to get
                    # rid of them so it can be justified correctly.
                    current_line.trim_trailing_spaces()
                    return current_line.manual_break(self.align)
                if current_line.automatic_break_possible():
                    (
                        self.fragment_index,
                        self.character_index,
                        line,
                    ) = current_line.automatic_break(self.align)
                    self.character_index += 1
                    return line
                if idx_last_forced_break == self.character_index:
                    raise FPDFException(
                        "Not enough horizontal space to render a single character"
                    )
                self.idx_last_forced_break = self.character_index
                return current_line.manual_break(
                    Align.L if self.align == Align.J else self.align
                )

            current_line.add_character(
                character,
                character_width,
                current_fragment,
                self.fragment_index,
                self.character_index,
                current_font_height * self.line_height,
                current_fragment.link,
            )

            self.character_index += 1

        if current_line.width:
            return current_line.manual_break(
                Align.L if self.align == Align.J else self.align
            )
        return None

Methods

def get_line(self)

class SpaceHint (original_fragment_index: int, original_character_index: int, current_line_fragment_index: int, current_line_character_index: int, line_width: float, number_of_spaces: int)

SpaceHint(original_fragment_index, original_character_index, current_line_fragment_index, current_line_character_index, line_width, number_of_spaces)

Expand source code Browse git

class SpaceHint(NamedTuple):
    original_fragment_index: int
    original_character_index: int
    current_line_fragment_index: int
    current_line_character_index: int
    line_width: float
    number_of_spaces: int

Ancestors

• builtins.tuple

Instance variables

var current_line_character_index : int

Alias for field number 3

var current_line_fragment_index : int

Alias for field number 2

var line_width : float

Alias for field number 4

var number_of_spaces : int

Alias for field number 5

var original_character_index : int

Alias for field number 1

var original_fragment_index : int

Alias for field number 0

class TextLine (fragments: tuple, text_width: float, number_of_spaces: int, align: Align, height: float, max_width: float, trailing_nl: bool = False, trailing_form_feed: bool = False)

TextLine(fragments, text_width, number_of_spaces, align, height, max_width, trailing_nl, trailing_form_feed)

Expand source code Browse git

class TextLine(NamedTuple):
    fragments: tuple
    text_width: float
    number_of_spaces: int
    align: Align
    height: float
    max_width: float
    trailing_nl: bool = False
    trailing_form_feed: bool = False

    def get_ordered_fragments(self):
        if not self.fragments:
            return tuple()
        directional_runs = []
        direction = None
        for fragment in self.fragments:
            if fragment.fragment_direction == direction:
                directional_runs[-1].append(fragment)
            else:
                directional_runs.append([fragment])
                direction = fragment.fragment_direction
        if self.fragments[0].paragraph_direction == TextDirection.RTL or (
            not self.fragments[0].paragraph_direction
            and self.fragments[0].fragment_direction == TextDirection.RTL
        ):
            directional_runs = directional_runs[::-1]
        ordered_fragments = []
        for run in directional_runs:
            ordered_fragments += (
                run[::-1] if run[0].fragment_direction == TextDirection.RTL else run
            )
        return tuple(ordered_fragments)

Ancestors

• builtins.tuple

Instance variables

var align : Align

Alias for field number 3

var fragments : tuple

Alias for field number 0

var height : float

Alias for field number 4

var max_width : float

Alias for field number 5

var number_of_spaces : int

Alias for field number 2

var text_width : float

Alias for field number 1

var trailing_form_feed : bool

Alias for field number 7

var trailing_nl : bool

Alias for field number 6

Methods

def get_ordered_fragments(self)

class TotalPagesSubstitutionFragment (*args, **kwargs)

A special type of text fragment that represents a placeholder for the total number of pages in a PDF document.

A placeholder will be generated during the initial content rendering phase of a PDF document. This placeholder is later replaced by the total number of pages in the document when the final output is being produced.

Expand source code Browse git

class TotalPagesSubstitutionFragment(Fragment):
    """
    A special type of text fragment that represents a placeholder for the total number of pages
    in a PDF document.

    A placeholder will be generated during the initial content rendering phase of a PDF document.
    This placeholder is later replaced by the total number of pages in the document when the final
    output is being produced.
    """

    def __init__(self, *args, **kwargs):
        super().__init__(*args, **kwargs)
        self.uuid = uuid4()

    def get_placeholder_string(self):
        """
        This method returns a placeholder string containing a universally unique identifier (UUID4),
        ensuring that the placeholder is distinct and does not conflict with other placeholders
        within the document.
        """
        return f"::placeholder:{self.uuid}::"

    def render_pdf_text(self, *args, **kwargs):
        """
        This method is invoked during the page content rendering phase, which is common to all
        `Fragment` instances. It stores the provided arguments and keyword arguments to preserve
        the necessary information and graphic state for the final substitution rendering.

        The method then returns the unique placeholder string.
        """
        self._render_args = args
        self._render_kwargs = kwargs
        return self.get_placeholder_string()

    def render_text_substitution(self, replacement_text: str):
        """
        This method is invoked at the output phase. It calls `render_pdf_text()` from the superclass
        to render the fragment with the preserved rendering state (stored in `_render_args` and `_render_kwargs`)
        and insert the final text in place of the placeholder.
        """
        self.characters = list(replacement_text)
        return super().render_pdf_text(*self._render_args, **self._render_kwargs)

Ancestors

• Fragment

Methods

def get_placeholder_string(self)

This method returns a placeholder string containing a universally unique identifier (UUID4), ensuring that the placeholder is distinct and does not conflict with other placeholders within the document.

def render_pdf_text(self, *args, **kwargs)

This method is invoked during the page content rendering phase, which is common to all Fragment instances. It stores the provided arguments and keyword arguments to preserve the necessary information and graphic state for the final substitution rendering.

The method then returns the unique placeholder string.

def render_text_substitution(self, replacement_text: str)

This method is invoked at the output phase. It calls render_pdf_text() from the superclass to render the fragment with the preserved rendering state (stored in _render_args and _render_kwargs) and insert the final text in place of the placeholder.

Inherited members

• Fragment:
  • get_character_width
  • get_width
  • has_same_style