def callback(node):
if (node.nodeType
== node.ELEMENT_NODE) and (node.nodeName.startswith("s:")):
hook_name = node.nodeName[2:]
if hook_name not in cls._SPECIAL:
if hook_name in cls._HOOKS:
hook_class = cls._HOOKS[hook_name]
replace_by = hook_class.handle(rendered_presentation,
node)
if replace_by is None:
# Delete node
XMLTools.remove_node(node)
elif replace_by is node:
# Keep node
pass
else:
XMLTools.replace_node(node, replace_by)
continue_descent_with_replaced_elements = node.nodeName not in cls._BREAK_DESCENT_ON
if continue_descent_with_replaced_elements:
if not isinstance(replace_by, list):
XMLTools.walk(replace_by, callback)
else:
for new_child in replace_by:
XMLTools.walk(new_child, callback)
else:
_log.warning(
"Unknown hook '%s' used in source document.",
hook_name)
elif node.nodeType == node.TEXT_NODE:
text = node.wholeText
new_text = cls._replace_text(text)
if text != new_text:
node.replaceWholeText(new_text)
def handle(cls, rendered_presentation, node):
properties = {
"formula": XMLTools.inner_text(node),
"long": XMLTools.get_bool_attr(node, "long"),
}
if node.hasAttribute("scale"):
user_scale = float(node.getAttribute("scale"))
else:
user_scale = 1
tex_renderer = rendered_presentation.renderer.get_custom_renderer(
"latex")
rendered_formula = tex_renderer.render(properties)
local_filename = "imgs/latex/%s.png" % (rendered_formula.keyhash)
uri = "%simgs/latex/%s.png" % (
rendered_presentation.renderer.rendering_params.resource_uri,
rendered_formula.keyhash)
scale_factor = 0.625 * user_scale
width_px = round(rendered_formula.data["info"]["width"] * scale_factor)
baseline_px = round(rendered_formula.data["info"]["baseline"] *
scale_factor)
#print(properties["formula"], rendered_formula.data["info"], width_px)
# For now, always wrap in div for long formulae. Could easily add an
# option to override this if it's useful.
wrap_in_div = properties["long"]
img_node = node.ownerDocument.createElement("img")
img_node.setAttribute("src", uri)
if properties["long"]:
img_node.setAttribute("style",
"width: %dpx; margin-top: 5px" % (width_px))
else:
img_node.setAttribute(
"style", "width: %dpx; margin-bottom: %dpx; margin-top: 5px" %
(width_px, -baseline_px + 1))
img_node.setAttribute("alt", properties["formula"])
if not wrap_in_div:
replacement_node = img_node
else:
replacement_node = node.ownerDocument.createElement("div")
replacement_node.setAttribute("class", "texformula")
replacement_node.appendChild(img_node)
rendered_presentation.add_file(local_filename,
rendered_formula.data["png_data"])
return replacement_node
def handle(cls, rendered_presentation, node):
acronym_id = XMLTools.inner_text(node)
acronym = rendered_presentation.renderer.get_custom_renderer("acronym")
resolved = acronym.resolve(acronym_id)
if resolved is None:
replacement_node = node.ownerDocument.createTextNode(acronym_id)
else:
rendered_presentation.add_feature(PresentationFeature.Acronyms)
outer_span_node = node.ownerDocument.createElement("span")
replacement_node = outer_span_node
if resolved.uri is not None:
link_node = outer_span_node.appendChild(
node.ownerDocument.createElement("a"))
link_node.setAttribute("href", resolved.uri)
link_node.setAttribute("class", "tooltip-link")
chain_node = link_node
else:
chain_node = outer_span_node
chain_node.setAttribute("class", "tooltip")
chain_node.appendChild(
node.ownerDocument.createTextNode(resolved.acronym))
inner_span = chain_node.appendChild(
node.ownerDocument.createElement("span"))
inner_span.setAttribute("class", "text")
inner_span.appendChild(
node.ownerDocument.createTextNode(resolved.text))
return replacement_node
def handle(cls, rendered_presentation, node):
text = XMLTools.inner_text(node).strip()
style = {
"fr": "«»",
"de": "„“",
"sgl": "‘’",
}.get(node.getAttribute("type"), "“”")
replacement_text = style[0] + text + style[1]
replacement_node = node.ownerDocument.createTextNode(replacement_text)
return replacement_node
def handle(cls, rendered_presentation, node):
if node.hasAttribute("src"):
with open(
rendered_presentation.renderer.lookup_include(
node.getAttribute("src"))) as f:
text = f.read()
else:
text = XMLTools.inner_text(node)
text = text.strip("\n")
text = textwrap.dedent(text)
text = text.strip("\n")
text = text.expandtabs(4)
return cls.handle_text(text, rendered_presentation, node)
def handle(cls, rendered_presentation, node):
text = XMLTools.inner_text(node).strip()
if text not in cls._REPLACEMENTS:
_log.warning("%s(%s) not available. Ignored the sequence.",
cls._TAG_NAME, text)
return None
else:
replacement_text = cls._REPLACEMENTS[text]
text_node = node.ownerDocument.createTextNode(replacement_text)
if cls._SPAN_ATTRIBUTES is None:
replacement_node = text_node
else:
replacement_node = node.ownerDocument.createElement("span")
for (key, value) in cls._SPAN_ATTRIBUTES.items():
replacement_node.setAttribute(key, value)
replacement_node.appendChild(text_node)
return replacement_node
def handle(cls, rendered_presentation, node):
value = int(XMLTools.inner_text(node))
last_digit = value % 10
if last_digit == 1:
suffix = "st"
elif last_digit == 2:
suffix = "nd"
elif last_digit == 3:
suffix = "rd"
else:
suffix = "th"
replacement_nodes = [
node.ownerDocument.createTextNode(str(value)),
node.ownerDocument.createElement("sup"),
]
replacement_nodes[1].appendChild(
node.ownerDocument.createTextNode(suffix))
return replacement_nodes
def handle(cls, rendered_presentation, node):
transformations = [ ]
for child_node in node.childNodes:
if (child_node.nodeType == child_node.ELEMENT_NODE) and (child_node.tagName == "transform"):
transformations.append(cls._parse_transformation(child_node))
properties = {
"src": rendered_presentation.renderer.lookup_include(node.getAttribute("src")),
"max_dimension": rendered_presentation.renderer.rendering_params.image_max_dimension,
}
if len(transformations) > 0:
properties["svg_transform"] = transformations
img_renderer = rendered_presentation.renderer.get_custom_renderer("img")
rendered_image = img_renderer.render(properties)
local_filename = "imgs/img/%s.%s" % (rendered_image.keyhash, rendered_image.data["extension"])
uri = "%simgs/img/%s.%s" % (rendered_presentation.renderer.rendering_params.resource_uri, rendered_image.keyhash, rendered_image.data["extension"])
img_style = [ ]
if node.hasAttribute("width"):
img_style.append(("width", node.getAttribute("width")))
if node.hasAttribute("height"):
img_style.append(("height", node.getAttribute("height")))
if node.hasAttribute("render"):
img_style.append(("image-rendering", node.getAttribute("render")))
create_filldiv = XMLTools.get_bool_attr(node, "fill", default_value = True)
img_node = node.ownerDocument.createElement("img")
img_node.setAttribute("src", uri)
img_node.setAttribute("class", "fill")
if len(img_style) > 0:
img_node.setAttribute("style", ";".join("%s:%s" % (key, value) for (key, value) in img_style))
if create_filldiv:
replacement_node = node.ownerDocument.createElement("div")
replacement_node.setAttribute("class", "fillimg")
replacement_node.appendChild(img_node)
else:
replacement_node = img_node
rendered_presentation.add_file(local_filename, rendered_image.data["img_data"])
return replacement_node
def handle(cls, rendered_presentation, node):
if not node.hasAttribute("cmd"):
raise MalformedXMLInputException(
"An s:exec node must have a 'cmd' attribute.")
cmd_str = node.getAttribute("cmd")
cmd = CmdlineParser().parse(cmd_str)
if not cmd[0].startswith("/"):
# Not an absolute path given, look up path of executable
try:
full_executable_path = rendered_presentation.renderer.lookup_include(
cmd[0])
except FailedToLookupFileException as e:
# Try if this is a path command
full_executable_path = shutil.which(cmd[0])
if full_executable_path is None:
raise FailedToLookupFileException(
"Could lookup executable \"%s\" neither in include dirs (%s) not in $PATH."
% (cmd[0], str(e)))
cmd[0] = full_executable_path
properties = {
"cmd": cmd,
"cache": XMLTools.get_bool_attr(node, "cache", default_value=True),
}
exec_renderer = rendered_presentation.renderer.get_custom_renderer(
"exec")
result = exec_renderer.render(properties)
xml_data = result.data["stdout"]
try:
doc = xml.dom.minidom.parseString(xml_data)
except xml.parsers.expat.ExpatError as e:
raise MalformedXMLInputException(
"Ouptut of script execution (%s) returned invalid XML: %s" %
(CmdlineEscape().cmdline(cmd), str(e)))
root = doc.firstChild
return list(root.childNodes)
def handle(cls, rendered_presentation, node):
def callback(inner_node):
text = inner_node.wholeText.replace(" ", "\u00a0")
inner_node.replaceWholeText(text)
XMLTools.walk(node, callback, predicate = lambda node: (node.nodeType == node.TEXT_NODE))
return list(node.childNodes)