Enum FragmentationContext 

pub enum FragmentationContext {
    Continuous {
        width: f32,
        container: Fragmentainer,
    },
    Paged {
        page_size: LogicalSize,
        pages: Vec<Fragmentainer>,
    },
    MultiColumn {
        column_width: f32,
        column_height: f32,
        gap: f32,
        columns: Vec<Fragmentainer>,
    },
    Regions {
        regions: Vec<Fragmentainer>,
    },
}

Represents a series of containers that content flows into during layout.

This is the core abstraction for fragmentation support. Different media types use different fragmentation contexts:

• Screen rendering: Continuous (single infinite container)
• Print rendering: Paged (series of fixed-size page containers)
• Multi-column layout: MultiColumn (series of column containers)

Variants

Continuous

Continuous media (screen): single infinite container.

Used for normal screen rendering where content can scroll indefinitely. The container grows as needed and never forces breaks.

Fields

width: f32

Width of the viewport

container: Fragmentainer

The single fragmentainer (grows infinitely)

Paged

Paged media (print): series of page boxes.

Used for PDF generation and print preview. Content flows from one page to the next when a page is full.

Fields

page_size: LogicalSize

Size of each page

pages: Vec<Fragmentainer>

All pages (fragmentainers) that have been created

MultiColumn

Multi-column layout: series of column boxes.

Future support for CSS multi-column layout.

Fields

column_width: f32

Width of each column

column_height: f32

Height of each column

gap: f32

Gap between columns

columns: Vec<Fragmentainer>

All columns that have been created

Regions

CSS Regions: series of region boxes.

Future support for CSS Regions specification.

Fields

regions: Vec<Fragmentainer>

Pre-defined region boxes

Implementations

impl FragmentationContext

pub fn new_continuous(width: f32) -> Self

Create a continuous fragmentation context for screen rendering.

• width - The viewport width

pub fn new_paged(page_size: LogicalSize) -> Self

Create a paged fragmentation context for print rendering.

• page_size - The size of each page

pub fn fragmentainer_count(&self) -> usize

Get the number of fragmentainers (pages, columns, etc.) in this context.

pub fn current(&self) -> &Fragmentainer

Get a reference to the current fragmentainer being filled.

pub fn current_mut(&mut self) -> &mut Fragmentainer

Get a mutable reference to the current fragmentainer being filled.

pub fn advance(&mut self) -> Result<(), String>

Advance to the next fragmentainer, creating a new one if necessary.

• For continuous media, this is a no-op (continuous media can’t advance).
• For paged media, this creates a new page.
• For regions, this fails if no more regions are available.

Returns

• Ok(()) if the advance succeeded, Err(String) if it failed (e.g., no more regions).

pub fn fragmentainers(&self) -> Vec<&Fragmentainer>

Get all fragmentainers in this context.

pub fn page_size(&self) -> Option<LogicalSize>

Get the page size for paged media, or None for other contexts.

pub fn page_content_height(&self) -> f32

Get the page content height (page height minus margins). For continuous media, returns f32::MAX.

pub fn is_paged(&self) -> bool

Check if this is paged media.

Trait Implementations

impl Clone for FragmentationContext

fn clone(&self) -> FragmentationContext

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for FragmentationContext

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.