fop-layout

Layout engine for the Apache FOP Rust implementation. Transforms the FO tree (from fop-core) into an area tree that can be rendered to PDF or other formats.

Pipeline

FO Tree (fop-core)
    |
    v
LayoutEngine        -- coordinates the process
    |
    +-- BlockLayout  -- stacks blocks vertically
    +-- InlineLayout -- positions text horizontally, breaks lines
    +-- TableLayout  -- computes column widths, positions cells
    +-- ListLayout   -- positions labels and bodies side-by-side
    +-- PageBreaker  -- splits content across pages
    |
    v
Area Tree            -- positioned rectangles ready for rendering

Usage

use fop_core::FoTreeBuilder;
use fop_layout::LayoutEngine;
use std::io::Cursor;

let xml = r#"<?xml version="1.0"?>
<fo:root xmlns:fo="http://www.w3.org/1999/XSL/Format">
    <fo:layout-master-set>
        <fo:simple-page-master master-name="A4"
            page-width="210mm" page-height="297mm">
            <fo:region-body margin="1in"/>
        </fo:simple-page-master>
    </fo:layout-master-set>
    <fo:page-sequence master-reference="A4">
        <fo:flow flow-name="xsl-region-body">
            <fo:block>Hello, Layout!</fo:block>
        </fo:flow>
    </fo:page-sequence>
</fo:root>"#;

let fo_tree = FoTreeBuilder::new().parse(Cursor::new(xml)).unwrap();
let engine = LayoutEngine::new();
let area_tree = engine.layout(&fo_tree).unwrap();

println!("Generated {} areas", area_tree.len());

Architecture

area/ - Area Tree Data Structures

Area Types: Page, Region, Block, Inline, Line, Table, ListItem, Image

Each area has a Rect (position + size) and an optional TraitSet for styling (font, color, borders).

layout/ - Layout Algorithms

Total: 2,994 lines across 11 files

Key Algorithms

Knuth-Plass Line Breaking

Optimal line breaking using the Knuth-Plass algorithm (same as TeX). Minimizes total "badness" across all lines rather than greedily filling each line.

use fop_layout::KnuthPlassBreaker;
use fop_types::Length;

let breaker = KnuthPlassBreaker::new(Length::from_pt(300.0));
let items = breaker.text_to_items("Long paragraph text...", 12.0);
let breaks = breaker.find_breaks(&items);

Table Layout

Computes column widths using fixed, proportional, or automatic sizing.

use fop_layout::{TableLayout, ColumnWidth};
use fop_types::Length;

let layout = TableLayout::new(Length::from_pt(500.0))
    .with_border_spacing(Length::from_pt(2.0));

let widths = layout.compute_fixed_widths(&[
    ColumnWidth::Fixed(Length::from_pt(100.0)),
    ColumnWidth::Proportional(2.0),
    ColumnWidth::Proportional(1.0),
]);

List Layout

Positions list labels (markers) and bodies side-by-side with 9 marker styles.

use fop_layout::{ListLayout, ListMarkerStyle};
use fop_types::Length;

let layout = ListLayout::new(Length::from_pt(400.0))
    .with_label_width(Length::from_pt(30.0))
    .with_label_separation(Length::from_pt(10.0));

let marker = layout.generate_marker(1, ListMarkerStyle::Decimal); // "1."
let marker = layout.generate_marker(1, ListMarkerStyle::Disc);    // "•"

Marker Styles: Disc, Circle, Square, Decimal, LowerAlpha, UpperAlpha, LowerRoman, UpperRoman, None

Page Breaking

Splits content across multiple pages when it overflows.

use fop_layout::PageBreaker;
use fop_types::Length;

let breaker = PageBreaker::new(
    Length::from_mm(210.0),  // A4 width
    Length::from_mm(297.0),  // A4 height
    [Length::from_inch(1.0); 4],  // 1-inch margins
);

assert_eq!(breaker.content_height(), Length::from_pt(698.0));
assert!(breaker.fits_on_page(Length::from_pt(100.0), Length::from_pt(200.0)));

Tests

52 unit tests covering:

• Block layout vertical stacking
• Inline layout horizontal positioning
• Knuth-Plass line breaking (various paragraph widths)
• Table layout (fixed, proportional, auto, mixed columns)
• List layout (all 9 marker styles, positioning)
• Page breaking (overflow detection, multi-page, area splitting)
• Area tree construction and traversal
• Property extraction from FO nodes

Dependencies

• fop-types (internal)
• fop-core (internal)
• thiserror 2.0
• log 0.4