Render Context: flm.flmrendercontext

Render context classes for FLM rendering.

The render context carries state during the rendering of an FLM document or standalone fragment. It tracks which features are available, manages delayed rendering for forward references, and provides a logical-state mechanism for context-dependent rendering (e.g., nested enumerations).

See also FLMDocumentRenderContext for the document-mode subclass that supports full feature managers and delayed rendering.

The render context carries state during the rendering of an FLM document or standalone fragment. It tracks which features are available, manages delayed rendering for forward references, and provides a logical-state mechanism for context-dependent rendering (e.g., nested enumerations).

class flm.flmrendercontext.FLMRenderContext(fragment_renderer: TypeFragmentRenderer, *, doc: TypeFLMDocument | None = None, **kwargs)

Base class for render contexts.

A render context is passed to every node’s render() method and carries:

The class attributes is_standalone_mode and is_first_pass indicate whether we are in standalone mode and whether this is the first rendering pass, respectively.

is_standalone_mode: bool = False
is_first_pass: bool = True
doc: TypeFLMDocument | None = None
fragment_renderer: TypeFragmentRenderer = None
pass_name: str | None = None
supports_feature(feature_name) → bool

Return True if the given feature is active in this render context.

feature_render_manager(feature_name) → FeatureRenderManagerBase | None

Return the render manager for the given feature, or None.

register_delayed_render(node, fragment_renderer) → Hashable

Register a node for delayed rendering. Returns a key for later retrieval.

get_delayed_render_content(node) → str

Retrieve the rendered content for a delayed-render node.

get_is_delayed_render(node) → bool

Determine whether node should use delayed rendering.

If the node’s delayed_render attribute is a callable, it is invoked with (node, self) and the boolean result is cached by node ID so the callable is called at most once per node. If the attribute is a plain boolean, it is returned directly.

Parameters:

node – A parsed LaTeX node with flm_specinfo set.

Returns:

True if the node requires delayed rendering.

set_render_pass(pass_name: str | None) → None

Set the current rendering pass.

The rendering pipeline may perform multiple passes (e.g., a first pass followed by a 'second-pass' to resolve delayed content). This method updates pass_name and sets is_first_pass to True when pass_name is None, or False otherwise.

Parameters:

pass_name – The name of the rendering pass (e.g., 'second-pass'), or None to reset to the first pass.

get_logical_state(domainname)

Certain LaTeX nodes might render differently depending on where they are placed in. Render contexts provide a minimal ‘state function’ mechanism that enables nodes to track how to render. E.g., an enumeration environment will update the state when rendering content nodes to correctly render nested enumerations.

The full logical state is organized into ‘domains’, e.g., enumeration environments will store any state in a domain called ‘feature.enumeration’ to avoid interference with other possible features etc.

In each domain, the logical state is a dictionary. The render methods of nodes can set/remove keys as they see fit.

push_logical_state(domainname, propname, value)

Use as context manager:

with render_context.push_logical_state('myfeature', 'depth', depth+1):
   # ...

FIXME: SHOULDN’T THIS BE IMPLEMENTED BY A DIFFERENT “SUB-RENDER-CONTEXT” OBJECT WHICH IS THEN PASSED TO OTHER CALLS TO RENDER METHODS? …………………………

class flm.flmrendercontext.FLMStandaloneModeRenderContext(fragment_renderer)

Bases: FLMRenderContext

A render context for standalone-mode rendering.

This context does not support features, delayed rendering, or document managers. It is used by render_standalone().

is_standalone_mode: bool = True
supports_feature(feature_name)
feature_render_manager(feature_name)
register_delayed_render(node, fragment_renderer)
get_delayed_render_content(node)