fop-layout 0.1.1

Layout engine for Apache FOP Rust implementation
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140

//! Break and keep property extraction

use fop_core::{PropertyId, PropertyList};

use super::types::{BreakValue, Keep, KeepConstraint};

/// Extract keep constraints from properties
///
/// Extracts keep-together, keep-with-next, and keep-with-previous properties
/// from a PropertyList and returns a KeepConstraint struct.
///
/// # Examples
///
/// ```
/// use fop_core::{PropertyList, PropertyId, PropertyValue};
/// use fop_layout::layout::extract_keep_constraint;
/// use std::borrow::Cow;
///
/// let mut props = PropertyList::new();
/// props.set(PropertyId::KeepTogether, PropertyValue::String(Cow::Borrowed("always")));
///
/// let constraint = extract_keep_constraint(&props);
/// assert!(constraint.must_keep_together());
/// ```
pub fn extract_keep_constraint(properties: &PropertyList) -> KeepConstraint {
    let mut constraint = KeepConstraint::new();

    // Extract keep-together.within-page
    if let Ok(value) = properties.get(PropertyId::KeepTogether) {
        constraint.keep_together = Keep::from_property_value(&value);
    }

    // Extract keep-with-next.within-page
    if let Ok(value) = properties.get(PropertyId::KeepWithNext) {
        constraint.keep_with_next = Keep::from_property_value(&value);
    }

    // Extract keep-with-previous.within-page
    if let Ok(value) = properties.get(PropertyId::KeepWithPrevious) {
        constraint.keep_with_previous = Keep::from_property_value(&value);
    }

    constraint
}

/// Extract break-before property from properties
///
/// # Examples
///
/// ```
/// use fop_core::{PropertyList, PropertyId, PropertyValue};
/// use fop_layout::layout::extract_break_before;
/// use std::borrow::Cow;
///
/// let mut props = PropertyList::new();
/// props.set(PropertyId::BreakBefore, PropertyValue::String(Cow::Borrowed("page")));
///
/// let break_val = extract_break_before(&props);
/// assert!(break_val.forces_break());
/// ```
pub fn extract_break_before(properties: &PropertyList) -> BreakValue {
    properties
        .get(PropertyId::BreakBefore)
        .ok()
        .map(|v| BreakValue::from_property_value(&v))
        .unwrap_or(BreakValue::Auto)
}

/// Extract break-after property from properties
///
/// # Examples
///
/// ```
/// use fop_core::{PropertyList, PropertyId, PropertyValue};
/// use fop_layout::layout::extract_break_after;
/// use std::borrow::Cow;
///
/// let mut props = PropertyList::new();
/// props.set(PropertyId::BreakAfter, PropertyValue::String(Cow::Borrowed("page")));
///
/// let break_val = extract_break_after(&props);
/// assert!(break_val.forces_break());
/// ```
pub fn extract_break_after(properties: &PropertyList) -> BreakValue {
    properties
        .get(PropertyId::BreakAfter)
        .ok()
        .map(|v| BreakValue::from_property_value(&v))
        .unwrap_or(BreakValue::Auto)
}

/// Extract widows property from properties
///
/// Widows specifies the minimum number of lines that must be left at the
/// top of a page when a paragraph is broken across pages. The default is 2.
///
/// # Examples
///
/// ```
/// use fop_core::{PropertyList, PropertyId, PropertyValue};
/// use fop_layout::layout::extract_widows;
///
/// let mut props = PropertyList::new();
/// props.set(PropertyId::Widows, PropertyValue::Integer(3));
///
/// let widows = extract_widows(&props);
/// assert_eq!(widows, 3);
/// ```
pub fn extract_widows(properties: &PropertyList) -> i32 {
    properties
        .get(PropertyId::Widows)
        .ok()
        .and_then(|v| v.as_integer())
        .unwrap_or(2) // Default value per XSL-FO spec
}

/// Extract orphans property from properties
///
/// Orphans specifies the minimum number of lines that must be left at the
/// bottom of a page when a paragraph is broken across pages. The default is 2.
///
/// # Examples
///
/// ```
/// use fop_core::{PropertyList, PropertyId, PropertyValue};
/// use fop_layout::layout::extract_orphans;
///
/// let mut props = PropertyList::new();
/// props.set(PropertyId::Orphans, PropertyValue::Integer(3));
///
/// let orphans = extract_orphans(&props);
/// assert_eq!(orphans, 3);
/// ```
pub fn extract_orphans(properties: &PropertyList) -> i32 {
    properties
        .get(PropertyId::Orphans)
        .ok()
        .and_then(|v| v.as_integer())
        .unwrap_or(2) // Default value per XSL-FO spec
}