` lists.
heading_sizes (dict): [**DEPRECATED since v2.7.9**]
font size per heading level names ("h1", "h2"...) - Set `tag_styles` instead
pre_code_font (str): [**DEPRECATED since v2.7.9**]
font to use for `` & `` blocks - Set `tag_styles` instead
warn_on_tags_not_matching (bool): control warnings production for unmatched HTML tags. Defaults to `True`.
tag_indents (dict): [**DEPRECATED since v2.8.0**]
mapping of HTML tag names to numeric values representing their horizontal left indentation. - Set `tag_styles` instead
tag_styles (dict[str, fpdf.fonts.TextStyle]): mapping of HTML tag names to `fpdf.TextStyle` or `fpdf.FontFace` instances
font_family (str): optional font family. Default to Times.
render_title_tag (bool): Render the document at the beginning of the PDF. Default to False.
"""
super().__init__()
self.pdf = pdf
self.image_map = image_map or (lambda src: src)
self.ul_bullet_char = ul_bullet_char
self.li_prefix_color = (
color_as_decimal(li_prefix_color)
if isinstance(li_prefix_color, str)
else convert_to_device_color(li_prefix_color)
)
self.warn_on_tags_not_matching = warn_on_tags_not_matching
# The following 4 attributes are there to serve as "temporary state",
# so that changes to those settings are saved,
# but not reflected onto self.pdf yet,
# and only "effectively" applied when self._write_paragraph() is called.
# This way, we often avoid useless operators in the PDF content stream.
self.font_family = pdf.font_family or font_family
self.font_size_pt = pdf.font_size_pt
self.font_emphasis = TextEmphasis.NONE
self.font_color = pdf.text_color
# For historical / backward-compatibility reasons,
# write_html() sets an active font (Times by default):
self.pdf.set_font(
family=self.font_family,
size=self.font_size_pt,
style=self.font_emphasis.style,
)
self.style_stack = [] # list of FontFace
self.h = pdf.font_size_pt / pdf.k
self._page_break_after_paragraph = False
self._pre_formatted = False # preserve whitespace while True.
# nothing written yet to <pre>, remove one initial nl:
self._pre_started = False
self.follows_trailing_space = False # The last write has ended with a space.
self.follows_heading = False # We don't want extra space below a heading.
self.href = ""
self.align = ""
self.indent = 0
self.line_height_stack = []
self.ol_type = [] # when inside a <ol> tag, can be "a", "A", "i", "I" or "1"
self.bullet = []
self.heading_level = None
self._tags_stack = []
self._column = self.pdf.text_columns(skip_leading_spaces=True)
self._paragraph = self._column.paragraph()
# <title>-related properties:
self.render_title_tag = render_title_tag
self._in_title = False
# <table>-related properties:
self.table_line_separators = table_line_separators
self.table = None # becomes a Table instance when processing <table> tags
self.table_row = None # becomes a Row instance when processing <tr> tags
self.tr = None # becomes a dict of attributes when processing <tr> tags
self.td_th = None # becomes a dict of attributes when processing <td>/<th> tags
# "inserted" is a special attribute indicating that a cell has be inserted in self.table_row
self.tag_styles = _scale_units(pdf, DEFAULT_TAG_STYLES)
for tag, tag_style in (tag_styles or {}).items():
if tag not in DEFAULT_TAG_STYLES:
raise NotImplementedError(
f"Cannot set style for HTML tag <{tag}> (contributions are welcome to add support for this)"
)
if not isinstance(tag_style, FontFace):
raise ValueError(
f"tag_styles values must be instances of FontFace or TextStyle - received: {tag_style}"
)
# We convert FontFace values provided for block tags into TextStyle values:
if tag in BLOCK_TAGS and not isinstance(tag_style, TextStyle):
# pylint: disable=redefined-loop-name
tag_style = TextStyle(
font_family=tag_style.family,
font_style=(
"" if not tag_style.emphasis else tag_style.emphasis.style
),
font_size_pt=tag_style.size_pt,
color=tag_style.color,
fill_color=tag_style.fill_color,
# Using default tag margins:
t_margin=self.tag_styles[tag].t_margin,
l_margin=self.tag_styles[tag].l_margin,
b_margin=self.tag_styles[tag].b_margin,
)
self.tag_styles[tag] = tag_style
if heading_sizes is not None:
warnings.warn(
(
"The heading_sizes parameter is deprecated since v2.7.9 "
"and will be removed in a future release. "
"Set the `tag_styles` parameter instead."
),
DeprecationWarning,
stacklevel=get_stack_level(),
)
for tag, size in heading_sizes.items():
self.tag_styles[tag] = self.tag_styles[tag].replace(font_size_pt=size)
if pre_code_font is not None:
warnings.warn(
(
"The pre_code_font parameter is deprecated since v2.7.9 "
"and will be removed in a future release. "
"Set the `tag_styles` parameter instead."
),
DeprecationWarning,
stacklevel=get_stack_level(),
)
self.tag_styles["code"] = self.tag_styles["code"].replace(
family=pre_code_font
)
self.tag_styles["pre"] = self.tag_styles["pre"].replace(
font_family=pre_code_font
)
if dd_tag_indent is not None:
warnings.warn(
(
"The dd_tag_indent parameter is deprecated since v2.7.9 "
"and will be removed in a future release. "
"Set the `tag_styles` parameter instead."
),
DeprecationWarning,
stacklevel=get_stack_level(),
)
self.tag_styles["dd"] = self.tag_styles["dd"].replace(
l_margin=dd_tag_indent
)
if li_tag_indent is not None:
warnings.warn(
(
"The li_tag_indent parameter is deprecated since v2.7.9 "
"and will be removed in a future release. "
"Set the `tag_styles` parameter instead."
),
DeprecationWarning,
stacklevel=get_stack_level(),
)
self.tag_styles["li"] = self.tag_styles["li"].replace(
l_margin=li_tag_indent
)
if tag_indents:
warnings.warn(
(
"The tag_indents parameter is deprecated since v2.8.0 "
"and will be removed in a future release. "
"Set the `tag_styles` parameter instead."
),
DeprecationWarning,
stacklevel=get_stack_level(),
)
for tag, indent in tag_indents.items():
if tag not in self.tag_styles:
raise NotImplementedError(
f"Cannot set style for HTML tag <{tag}> (contributions are welcome to add support for this)"
)
self.tag_styles[tag] = self.tag_styles[tag].replace(l_margin=indent)
def _new_paragraph(
self,
align=None,
line_height=1.0,
top_margin=0,
bottom_margin=0,
indent=0,
bullet="",
):
# Note that currently top_margin is ignored if bullet is also provided,
# due to the behaviour of TextRegion._render_column_lines()
self._end_paragraph()
self.align = align or ""
if isinstance(indent, Align):
# Explicit alignment takes priority over alignment provided as TextStyle.l_margin:
if not self.align:
self.align = indent
indent = 0
if not top_margin and not self.follows_heading:
top_margin = self.font_size_pt / self.pdf.k
self._paragraph = self._column.paragraph(
text_align=self.align,
line_height=line_height,
skip_leading_spaces=True,
top_margin=top_margin,
bottom_margin=bottom_margin,
indent=indent,
bullet_string=bullet,
)
self.follows_trailing_space = True
self.follows_heading = False
def _end_paragraph(self):
self.align = ""
if not self._paragraph:
return
self._column.end_paragraph()
self._column.render()
self._paragraph = None
self.follows_trailing_space = True
if self._page_break_after_paragraph:
# pylint: disable=protected-access
self.pdf._perform_page_break()
self._page_break_after_paragraph = False
def _write_paragraph(self, text, link=None):
if not text:
return
if not self._paragraph:
self._new_paragraph()
# The following local stack is required
# in order for FPDF._get_current_graphics_state()
# to properly capture the current graphics state,
# and then to be able to drop those temporary changes,
# because they will only be "effectively" applied in .end_paragraph().
# pylint: disable=protected-access
self.pdf._push_local_stack()
prev_page = self.pdf.page
self.pdf.page = 0
self.pdf.set_font(
family=self.font_family,
size=self.font_size_pt,
style=self.font_emphasis.style,
)
if self.font_color != self.pdf.text_color:
self.pdf.set_text_color(self.font_color)
self._paragraph.write(text, link=link)
self.pdf.page = prev_page
self.pdf._pop_local_stack()
def _ln(self, h=None):
if self._paragraph:
self._paragraph.ln(h=h)
else:
self._column.ln(h=h)
self.follows_trailing_space = True
def handle_data(self, data):
if self._in_title:
if self.pdf.title:
LOGGER.warning('Ignoring repeated <title> "%s"', data)
else:
self.pdf.set_title(data)
if not self.render_title_tag:
return
if self.td_th is not None:
data = data.strip()
if not data:
return
if "inserted" in self.td_th:
td_th_tag = self.td_th["tag"]
raise NotImplementedError(
f"Unsupported nested HTML tags inside <{td_th_tag}> element: <{self._tags_stack[-1]}>"
)
# We could potentially support nested <b> / <em> / <font> tags
# by building a list of Fragment instances from the HTML cell content
# and then passing those fragments to Row.cell().
# However there should be an incoming refactoring of this code
# dedicated to text layout, and we should probably wait for that
# before supporting this feature.
align = self.td_th.get("align", self.tr.get("align"))
if align:
align = align.upper()
bgcolor = color_as_decimal(
self.td_th.get("bgcolor", self.tr.get("bgcolor", None))
)
colspan = int(self.td_th.get("colspan", "1"))
rowspan = int(self.td_th.get("rowspan", "1"))
emphasis = 0
if self.td_th.get("b"):
emphasis |= TextEmphasis.B
if self.td_th.get("i"):
emphasis |= TextEmphasis.I
if self.td_th.get("U"):
emphasis |= TextEmphasis.U
font_style = None
if bgcolor or emphasis:
font_style = FontFace(
emphasis=emphasis, fill_color=bgcolor, color=self.pdf.text_color
)
self.table_row.cell(
text=data,
align=align,
style=font_style,
colspan=colspan,
rowspan=rowspan,
)
self.td_th["inserted"] = True
elif self.table is not None:
# ignore anything else than td inside a table
pass
elif self._pre_formatted: # pre blocks
# If we want to mimic the exact HTML semantics about newlines at the
# beginning and end of the block, then this needs some more thought.
if data.startswith("\n") and self._pre_started:
if data.endswith("\n"):
data = data[1:-1]
else:
data = data[1:]
self._pre_started = False
self._write_data(data)
else:
data = _WS_SUB_PAT.sub(" ", data)
if self.follows_trailing_space and data[0] == " ":
self._write_data(data[1:])
else:
self._write_data(data)
self.follows_trailing_space = data[-1] == " "
if self._page_break_after_paragraph:
self._end_paragraph()
def _write_data(self, data):
if self.href:
self.put_link(data)
else:
if self.heading_level:
if self.pdf.section_title_styles:
raise NotImplementedError(
"Combining write_html() & section styles is currently not supported."
" You can open up an issue on github.com/py-pdf/fpdf2 if this is something you would like to see implemented."
)
self.pdf.start_section(data, self.heading_level - 1, strict=False)
self._write_paragraph(data)
def handle_starttag(self, tag, attrs):
self._pre_started = False
attrs = dict(attrs)
css_style = parse_css_style(attrs.get("style", ""))
self._tags_stack.append(tag)
if css_style.get("break-before") == "page":
self._end_paragraph()
# pylint: disable=protected-access
self.pdf._perform_page_break()
if tag in ("b", "i", "u") and self.td_th is not None:
self.td_th[tag] = True
if tag == "a":
self.href = attrs["href"]
try:
page = int(self.href)
self.href = self.pdf.add_link(page=page)
except ValueError:
pass
if tag == "br":
self._write_paragraph("\n")
if tag == "hr":
self._end_paragraph()
width = css_style.get("width", attrs.get("width"))
if width:
if width[-1] == "%":
width = self.pdf.epw * int(width[:-1]) / 100
else:
width = int(width) / self.pdf.k
else:
width = self.pdf.epw
# Centering:
x_start = self.pdf.l_margin + (self.pdf.epw - width) / 2
self.pdf.line(
x1=x_start,
y1=self.pdf.y,
x2=x_start + width,
y2=self.pdf.y,
)
self._write_paragraph("\n")
if tag == "p":
self.style_stack.append(
FontFace(
family=self.font_family,
emphasis=self.font_emphasis,
size_pt=self.font_size_pt,
color=self.font_color,
)
)
align = None
if "align" in attrs:
align = attrs.get("align")[0].upper()
if not align in ["L", "R", "J", "C"]:
align = None
line_height = css_style.get("line-height", attrs.get("line-height"))
# "line-height" attributes are not valid in HTML,
# but we support it for backward compatibility,
# because fpdf2 honors it since 2.6.1 and PR #629
if line_height:
try:
# YYY parse and convert non-float line_height values
line_height = float(line_height)
except ValueError:
line_height = None
tag_style = self.tag_styles[tag]
self._new_paragraph(
align=align,
line_height=line_height,
top_margin=tag_style.t_margin,
bottom_margin=tag_style.b_margin,
indent=tag_style.l_margin,
)
if tag in HEADING_TAGS:
self.style_stack.append(
FontFace(
family=self.font_family,
emphasis=self.font_emphasis,
size_pt=self.font_size_pt,
color=self.font_color,
)
)
self.heading_level = 0 if tag == "title" else int(tag[1:])
tag_style = self.tag_styles[tag]
hsize = (tag_style.size_pt or self.font_size_pt) / self.pdf.k
if attrs:
align = attrs.get("align")
if not align in ["L", "R", "J", "C"]:
align = None
else:
align = None
self._new_paragraph(
align=align,
top_margin=tag_style.t_margin,
bottom_margin=tag_style.b_margin * hsize,
indent=tag_style.l_margin,
)
if "color" in css_style:
self.font_color = color_as_decimal(css_style["color"])
elif "color" in attrs:
# "color" attributes are not valid in HTML,
# but we support it for backward compatibility:
self.font_color = color_as_decimal(attrs["color"])
elif tag_style.color:
self.font_color = tag_style.color
self.font_family = tag_style.family or self.font_family
self.font_size_pt = tag_style.size_pt or self.font_size_pt
if tag_style.emphasis:
self.font_emphasis |= tag_style.emphasis
if tag in (
"b",
"blockquote",
"center",
"code",
"del",
"em",
"i",
"dd",
"dt",
"pre",
"s",
"strong",
"u",
):
if tag in BLOCK_TAGS:
self._end_paragraph()
self.style_stack.append(
FontFace(
family=self.font_family,
emphasis=self.font_emphasis,
size_pt=self.font_size_pt,
color=self.font_color,
)
)
tag_style = self.tag_styles[tag]
if tag_style.color:
self.font_color = tag_style.color
self.font_family = tag_style.family or self.font_family
self.font_size_pt = tag_style.size_pt or self.font_size_pt
if tag_style.emphasis:
self.font_emphasis |= tag_style.emphasis
if tag == "pre":
self._pre_formatted = True
self._pre_started = True
if tag in BLOCK_TAGS:
if tag == "dd":
# Not compliant with the HTML spec, but backward-compatible
# cf. https://github.com/py-pdf/fpdf2/pull/1217#discussion_r1666643777
self.follows_heading = True
self._new_paragraph(
align="C" if tag == "center" else None,
line_height=(
self.line_height_stack[-1] if self.line_height_stack else None
),
top_margin=tag_style.t_margin,
bottom_margin=tag_style.b_margin,
indent=tag_style.l_margin,
)
if tag == "ul":
self.indent += 1
bullet_char = (
ul_prefix(attrs["type"]) if "type" in attrs else self.ul_bullet_char
)
self.bullet.append(bullet_char)
line_height = css_style.get("line-height", attrs.get("line-height"))
# "line-height" attributes are not valid in HTML,
# but we support it for backward compatibility,
# because fpdf2 honors it since 2.6.1 and PR #629
if line_height:
try:
# YYY parse and convert non-float line_height values
self.line_height_stack.append(float(line_height))
except ValueError:
pass
else:
self.line_height_stack.append(None)
if self.indent == 1:
tag_style = self.tag_styles[tag]
self._new_paragraph(
line_height=0,
top_margin=tag_style.t_margin,
bottom_margin=tag_style.b_margin,
indent=tag_style.l_margin,
)
self._write_paragraph("\u00a0")
self._end_paragraph()
if tag == "ol":
self.indent += 1
start = int(attrs["start"]) if "start" in attrs else 1
self.bullet.append(start - 1)
self.ol_type.append(attrs.get("type", "1"))
line_height = css_style.get("line-height", attrs.get("line-height"))
# "line-height" attributes are not valid in HTML,
# but we support it for backward compatibility,
# because fpdf2 honors it since 2.6.1 and PR #629
if line_height:
try:
# YYY parse and convert non-float line_height values
self.line_height_stack.append(float(line_height))
except ValueError:
pass
else:
self.line_height_stack.append(None)
if self.indent == 1:
tag_style = self.tag_styles[tag]
self._new_paragraph(
line_height=0,
top_margin=tag_style.t_margin,
bottom_margin=tag_style.b_margin,
indent=tag_style.l_margin,
)
self._write_paragraph("\u00a0")
self._end_paragraph()
if tag == "li":
prev_text_color = self.pdf.text_color
self.pdf.text_color = self.li_prefix_color
if self.bullet:
bullet = self.bullet[self.indent - 1]
else:
# Allow <li> to be used outside of <ul> or <ol>.
bullet = self.ul_bullet_char
if not isinstance(bullet, str):
bullet += 1
self.bullet[self.indent - 1] = bullet
ol_type = self.ol_type[self.indent - 1]
bullet = f"{ol_prefix(ol_type, bullet)}."
tag_style = self.tag_styles[tag]
self._ln(tag_style.t_margin)
self._new_paragraph(
line_height=(
self.line_height_stack[-1] if self.line_height_stack else None
),
indent=tag_style.l_margin * self.indent,
bottom_margin=tag_style.b_margin,
bullet=bullet,
)
self.pdf.text_color = prev_text_color
if tag == "font":
self.style_stack.append(
FontFace(
family=self.font_family,
emphasis=self.font_emphasis,
size_pt=self.font_size_pt,
color=self.font_color,
)
)
if "color" in attrs:
self.font_color = color_as_decimal(attrs["color"])
if "font-size" in css_style:
self.font_size_pt = int(css_style.get("font-size"))
elif "size" in attrs:
self.font_size_pt = int(attrs.get("size"))
if "face" in attrs:
self.font_family = attrs.get("face").lower()
if tag == "table":
width = css_style.get("width", attrs.get("width"))
if width:
if width[-1] == "%":
width = self.pdf.epw * int(width[:-1]) / 100
else:
width = int(width) / self.pdf.k
if "border" not in attrs: # default borders
borders_layout = (
"HORIZONTAL_LINES"
if self.table_line_separators
else "SINGLE_TOP_LINE"
)
elif int(attrs["border"]): # explicitly enabled borders
borders_layout = (
"ALL" if self.table_line_separators else "NO_HORIZONTAL_LINES"
)
else: # explicitly disabled borders
borders_layout = "NONE"
align = attrs.get("align", "center").upper()
padding = float(attrs["cellpadding"]) if "cellpadding" in attrs else None
spacing = float(attrs.get("cellspacing", 0))
self.table = Table(
self.pdf,
align=align,
borders_layout=borders_layout,
line_height=self.h * self.TABLE_LINE_HEIGHT,
width=width,
padding=padding,
gutter_width=spacing,
gutter_height=spacing,
)
self._ln()
if tag == "tr":
if not self.table:
raise FPDFException("Invalid HTML: <tr> used outside any <table>")
self.tr = {k.lower(): v for k, v in attrs.items()}
self.table_row = self.table.row()
if tag in ("td", "th"):
if not self.table_row:
raise FPDFException(f"Invalid HTML: <{tag}> used outside any <tr>")
self.td_th = {k.lower(): v for k, v in attrs.items()}
self.td_th["tag"] = tag
if tag == "th":
if "align" not in self.td_th:
self.td_th["align"] = "CENTER"
self.td_th["b"] = True
elif len(self.table.rows) == 1 and not self.table_row.cells:
# => we are in the 1st <tr>, and the 1st cell is a <td>
# => we do not treat the first row as a header
# pylint: disable=protected-access
self.table._first_row_as_headings = False
self.table._num_heading_rows = 0
if "height" in attrs:
LOGGER.warning(
'Ignoring unsupported height="%s" specified on a <%s>',
attrs["height"],
tag,
)
if "width" in attrs:
width = attrs["width"]
# pylint: disable=protected-access
if len(self.table.rows) == 1: # => first table row
if width[-1] == "%":
width = width[:-1]
if not self.table._col_widths:
self.table._col_widths = []
self.table._col_widths.append(int(width))
else:
LOGGER.warning(
'Ignoring width="%s" specified on a <%s> that is not in the first <tr>',
width,
tag,
)
if tag == "img" and "src" in attrs:
width = int(attrs.get("width", 0)) / self.pdf.k
height = int(attrs.get("height", 0)) / self.pdf.k
if self.table_row: # => <img> in a <table>
if width or height:
LOGGER.warning(
'Ignoring unsupported "width" / "height" set on <img> element'
)
if self.align:
LOGGER.warning("Ignoring unsupported <img> alignment")
self.table_row.cell(img=attrs["src"], img_fill_width=True)
self.td_th["inserted"] = True
return
x = self.pdf.get_x()
if self.align and self.align[0].upper() == "C":
x = Align.C
self.pdf.image(
self.image_map(attrs["src"]), x=x, w=width, h=height, link=self.href
)
if tag == "toc":
self._end_paragraph()
self.pdf.insert_toc_placeholder(
self.render_toc, pages=int(attrs.get("pages", 1))
)
if tag == "sup":
self.pdf.char_vpos = "SUP"
if tag == "sub":
self.pdf.char_vpos = "SUB"
if tag == "title":
self._in_title = True
if css_style.get("break-after") == "page":
if tag in ("br", "hr", "img"):
self._end_paragraph()
# pylint: disable=protected-access
self.pdf._perform_page_break()
else:
self._page_break_after_paragraph = True
def handle_endtag(self, tag):
while (
self._tags_stack
and tag != self._tags_stack[-1]
and self._tags_stack[-1] in self.HTML_UNCLOSED_TAGS
):
self._tags_stack.pop()
if not self._tags_stack:
if self.warn_on_tags_not_matching:
LOGGER.warning(
"Unexpected HTML end tag </%s>, start tag may be missing?", tag
)
elif tag == self._tags_stack[-1]:
self._tags_stack.pop()
elif self.warn_on_tags_not_matching:
LOGGER.warning(
"Unexpected HTML end tag </%s>, start tag was <%s>",
tag,
self._tags_stack[-1],
)
if tag == "a":
self.href = ""
if tag == "p":
if self.style_stack:
font_face = self.style_stack.pop()
self.font_family = font_face.family or self.font_family
self.font_size_pt = font_face.size_pt or self.font_size_pt
self.font_emphasis = font_face.emphasis
self.font_color = font_face.color
self._end_paragraph()
self.align = ""
if tag in HEADING_TAGS:
self.heading_level = None
if self.style_stack:
font_face = self.style_stack.pop()
self.font_family = font_face.family or self.font_family
self.font_size_pt = font_face.size_pt or self.font_size_pt
self.font_emphasis = font_face.emphasis
self.font_color = font_face.color
self._end_paragraph()
self.follows_heading = True # We don't want extra space below a heading.
if tag in (
"b",
"blockquote",
"center",
"code",
"em",
"i",
"dd",
"dt",
"pre",
"s",
"strong",
"u",
):
if self.style_stack:
font_face = self.style_stack.pop()
self.font_family = font_face.family or self.font_family
self.font_size_pt = font_face.size_pt or self.font_size_pt
self.font_emphasis = font_face.emphasis
self.font_color = font_face.color
if tag == "pre":
self._pre_formatted = False
self._pre_started = False
if tag in BLOCK_TAGS:
self._end_paragraph()
if tag in ("ul", "ol"):
self._end_paragraph()
self.indent -= 1
if tag == "ol":
self.ol_type.pop()
self.line_height_stack.pop()
self.bullet.pop()
if tag == "table":
self.table.render()
self.table = None
self._ln(self.h)
if tag == "tr":
self.tr = None
self.table_row = None
if tag in ("td", "th"):
if "inserted" not in self.td_th:
# handle_data() was not called => we call it to produce an empty cell:
bgcolor = color_as_decimal(
self.td_th.get("bgcolor", self.tr.get("bgcolor", None))
)
style = FontFace(fill_color=bgcolor) if bgcolor else None
colspan = int(self.td_th.get("colspan", "1"))
rowspan = int(self.td_th.get("rowspan", "1"))
self.table_row.cell(
text="", style=style, colspan=colspan, rowspan=rowspan
)
self.td_th = None
if tag == "font":
if self.style_stack:
font_face = self.style_stack.pop()
self.font_family = font_face.family or self.font_family
self.font_size_pt = font_face.size_pt or self.font_size_pt
self.font_emphasis = font_face.emphasis
self.font_color = font_face.color
if tag == "sup":
self.pdf.char_vpos = "LINE"
if tag == "sub":
self.pdf.char_vpos = "LINE"
if tag == "title":
self._in_title = False
def feed(self, data):
super().feed(data)
while self._tags_stack and self._tags_stack[-1] in self.HTML_UNCLOSED_TAGS:
self._tags_stack.pop()
self._end_paragraph() # render the final chunk of text and clean up our local context.
if self._tags_stack and self.warn_on_tags_not_matching:
LOGGER.warning("Missing HTML end tag for <%s>", self._tags_stack[-1])
def put_link(self, text):
"Insert a hyperlink"
prev_style = FontFace(
family=self.font_family,
emphasis=self.font_emphasis,
size_pt=self.font_size_pt,
color=self.font_color,
)
tag_style = self.tag_styles["a"]
if tag_style.color:
self.font_color = tag_style.color
self.font_family = tag_style.family or self.font_family
self.font_size_pt = tag_style.size_pt or self.font_size_pt
if tag_style.emphasis:
self.font_emphasis |= tag_style.emphasis
self._write_paragraph(text, link=self.href)
# Restore previous style:
self.font_family = prev_style.family or self.font_family
self.font_size_pt = prev_style.size_pt or self.font_size_pt
self.font_emphasis = prev_style.emphasis
self.font_color = prev_style.color
# pylint: disable=no-self-use
def render_toc(self, pdf, outline):
"This method can be overridden by subclasses to customize the Table of Contents style."
pdf.ln()
for section in outline:
link = pdf.add_link(page=section.page_number)
text = f'{" " * section.level * 2} {section.name}'
text += f' {"." * (60 - section.level*2 - len(section.name))} {section.page_number}'
pdf.multi_cell(
w=pdf.epw,
h=pdf.font_size,
text=text,
new_x=XPos.LMARGIN,
new_y=YPos.NEXT,
link=link,
)
# Subclasses of _markupbase.ParserBase must implement this:
def error(self, message):
raise RuntimeError(message)
def _scale_units(pdf, in_tag_styles):
conversion_factor = get_scale_factor("mm") / pdf.k
out_tag_styles = {}
for tag_name, tag_style in in_tag_styles.items():
if isinstance(tag_style, TextStyle):
out_tag_styles[tag_name] = tag_style.replace(
t_margin=tag_style.t_margin * conversion_factor,
l_margin=(
tag_style.l_margin * conversion_factor
if isinstance(tag_style.l_margin, (int, float))
else tag_style.l_margin
),
b_margin=tag_style.b_margin * conversion_factor,
)
else:
out_tag_styles[tag_name] = tag_style
return out_tag_styles
def ul_prefix(ul_type):
if ul_type == "circle":
return DEGREE_WIN1252
if ul_type == "disc":
return BULLET_WIN1252
if len(ul_type) == 1:
return ul_type
raise NotImplementedError(f"Unsupported type: {ul_type}")
def ol_prefix(ol_type, index):
if ol_type == "1":
return index
if ol_type == "a":
return ascii_lowercase[index - 1]
if ol_type == "A":
return ascii_uppercase[index - 1]
if ol_type == "I":
return int2roman(index)
if ol_type == "i":
return int2roman(index).lower()
raise NotImplementedError(f"Unsupported type: {ol_type}")
class HTMLMixin:
"""
[**DEPRECATED since v2.6.0**]
You can now directly use the `FPDF.write_html()` method
"""
def __init__(self, *args, **kwargs):
super().__init__(*args, **kwargs)
warnings.warn(
(
"The HTMLMixin class is deprecated since v2.6.0. "
"Simply use the FPDF class as a replacement."
),
DeprecationWarning,
stacklevel=get_stack_level(),
)