use super::*;
#[derive(Debug, Clone)]
pub(in crate::layout) struct InlineParagraphRun {
pub(in crate::layout) item: InlineLineItem,
pub(in crate::layout) width: f32,
pub(in crate::layout) shaped: Option<Rc<ShapedInlineLine>>,
}
#[derive(Debug, Clone)]
pub(in crate::layout) struct InlineFragmentContinuation {
source_start: InlineAtom,
start_edge: InlineBoxEdgeFragment,
end_edge: InlineBoxEdgeFragment,
}
impl InlineFragmentContinuation {
pub(in crate::layout) fn from_source_start(atom: &InlineAtom) -> Option<Self> {
let InlineAtomContent::InlineEdge(InlineEdgeRole::BoxEdge(start_edge)) = atom.content()
else {
return None;
};
(start_edge.logical_edge == InlineLogicalEdge::Start
&& atom.style().box_decoration_break == BoxDecorationBreak::Clone)
.then(|| Self {
source_start: atom.clone(),
start_edge: *start_edge,
end_edge: inline_fragment_continuation_edge(
atom.style(),
InlineLogicalEdge::End,
start_edge.positioning_containing_block_id,
),
})
}
pub(in crate::layout) fn edge_atom(&self, logical_edge: InlineLogicalEdge) -> InlineAtom {
let mut atom = self.source_start.clone();
let style = atom.style().clone();
let edge_fragment = match logical_edge {
InlineLogicalEdge::Start => self.start_edge,
InlineLogicalEdge::End => self.end_edge,
};
{
let data = Rc::make_mut(&mut atom.data);
data.content = InlineAtomContent::InlineEdge(InlineEdgeRole::BoxEdge(edge_fragment));
data.current_color_override = None;
}
match style.writing_mode {
WritingMode::HorizontalTb => atom.size.width = edge_fragment.advance,
WritingMode::VerticalRl
| WritingMode::VerticalLr
| WritingMode::SidewaysRl
| WritingMode::SidewaysLr => atom.size.height = edge_fragment.advance,
}
atom
}
pub(in crate::layout) fn start_item(&self) -> InlineItem {
InlineItem::Atom(Box::new(self.edge_atom(InlineLogicalEdge::Start)))
}
pub(in crate::layout) fn end_item(&self) -> InlineItem {
InlineItem::Atom(Box::new(self.edge_atom(InlineLogicalEdge::End)))
}
pub(super) fn start_measured_item(&self) -> MeasuredInlineItem {
let atom = self.edge_atom(InlineLogicalEdge::Start);
let width = inline_atom_logical_inline_size(&atom, atom.style());
MeasuredInlineItem::new(InlineLineItem::Atom(atom), width, None)
}
pub(super) fn end_measured_item(&self) -> MeasuredInlineItem {
let atom = self.edge_atom(InlineLogicalEdge::End);
let width = inline_atom_logical_inline_size(&atom, atom.style());
MeasuredInlineItem::new(InlineLineItem::Atom(atom), width, None)
}
}
fn inline_fragment_continuation_edge(
style: &ComputedStyle,
logical_edge: InlineLogicalEdge,
positioning_containing_block_id: Option<InlinePositioningContainingBlockId>,
) -> InlineBoxEdgeFragment {
let edge = match logical_edge {
InlineLogicalEdge::Start => InlineBoxEdge::Start,
InlineLogicalEdge::End => InlineBoxEdge::End,
};
let (_, border, padding) = inline_box_edge_components(style, edge);
InlineBoxEdgeFragment {
logical_edge,
physical_side: inline_box_edge_physical_side(style, edge),
positioning_containing_block_id,
advance: inline_box_edge_width(style, edge).points(),
paint_extent: (border + padding).max(0.0),
}
}
pub(super) fn mark_clone_continuation_fragment_edges(
items: &mut [MeasuredInlineItem],
leading_edge_count: usize,
trailing_edge_count: usize,
) {
if leading_edge_count != 0
&& let Some(InlineLineItem::Fragment(fragment)) = items[leading_edge_count..]
.iter_mut()
.map(|item| &mut item.item)
.find(|item| matches!(item, InlineLineItem::Fragment(fragment) if fragment.source() != InlineTextSource::BidiControl))
{
let mut edges = fragment.hanging_edges();
edges.blocks_start = true;
*fragment = fragment.clone().with_hanging_edges(edges);
}
let trailing_content_end = items.len() - trailing_edge_count;
if trailing_edge_count != 0
&& let Some(InlineLineItem::Fragment(fragment)) = items[..trailing_content_end]
.iter_mut()
.rev()
.map(|item| &mut item.item)
.find(|item| matches!(item, InlineLineItem::Fragment(fragment) if fragment.source() != InlineTextSource::BidiControl))
{
let mut edges = fragment.hanging_edges();
edges.blocks_end = true;
*fragment = fragment.clone().with_hanging_edges(edges);
}
}
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub(in crate::layout) struct InlineLineEdgeReplacement {
pub(in crate::layout) source_bytes: usize,
pub(in crate::layout) text: &'static str,
}
#[derive(Debug, Clone, Copy, PartialEq, Eq, Default)]
pub(in crate::layout) enum SelectedLineShapingContext {
#[default]
None,
PreserveJoining,
}
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub(in crate::layout) struct DiscretionaryMarkerOwner {
pub(in crate::layout) style_position: InlineGraphPosition,
}
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub(in crate::layout) struct DiscretionaryBreakEffect {
pub(in crate::layout) source_boundary: InlineGraphPosition,
pub(in crate::layout) marker_owner: DiscretionaryMarkerOwner,
pub(in crate::layout) left_replacement: Option<InlineLineEdgeReplacement>,
pub(in crate::layout) right_replacement: Option<InlineLineEdgeReplacement>,
pub(in crate::layout) leading_shaping_context: SelectedLineShapingContext,
}
impl AsRef<InlineLineItem> for InlineParagraphRun {
fn as_ref(&self) -> &InlineLineItem {
&self.item
}
}
#[derive(Debug, Clone, Copy, PartialEq)]
pub(in crate::layout) struct InlineItemBaseAdvance(LayoutLength);
impl InlineItemBaseAdvance {
pub(in crate::layout) fn from_points(points: f32) -> Self {
Self(layout_pt(points))
}
pub(in crate::layout) fn points(self) -> f32 {
self.0.points()
}
}
#[derive(Debug, Clone, Copy, PartialEq)]
pub(in crate::layout) struct InlineBoundaryAdvance(LayoutLength);
impl InlineBoundaryAdvance {
pub(in crate::layout) fn zero() -> Self {
Self(layout_pt(0.0))
}
pub(in crate::layout) fn between(left: UsedLetterSpacing, _right: UsedLetterSpacing) -> Self {
Self(left.0)
}
pub(in crate::layout) fn points(self) -> f32 {
self.0.points()
}
}
#[derive(Debug, Clone, Copy, PartialEq)]
pub(in crate::layout) struct UsedLetterSpacing(LayoutLength);
impl UsedLetterSpacing {
pub(in crate::layout) fn new(value: LayoutLength) -> Self {
Self(value)
}
}
#[derive(Debug, Clone, Copy, PartialEq)]
pub(in crate::layout) struct InlineUsedAdvance(LayoutLength);
impl InlineUsedAdvance {
pub(in crate::layout) fn points(self) -> f32 {
self.0.points()
}
}
#[derive(Debug, Clone, Copy, PartialEq)]
pub(in crate::layout) struct MeasuredInlineAdvance {
base: InlineItemBaseAdvance,
boundary_before: InlineBoundaryAdvance,
}
impl MeasuredInlineAdvance {
pub(in crate::layout) fn from_base_points(points: f32) -> Self {
Self {
base: InlineItemBaseAdvance::from_points(points),
boundary_before: InlineBoundaryAdvance::zero(),
}
}
pub(in crate::layout) fn base(self) -> InlineItemBaseAdvance {
self.base
}
pub(in crate::layout) fn replace_base_points(&mut self, points: f32) {
self.base = InlineItemBaseAdvance::from_points(points);
}
pub(in crate::layout) fn boundary_before(self) -> InlineBoundaryAdvance {
self.boundary_before
}
pub(in crate::layout) fn set_boundary_before(&mut self, advance: InlineBoundaryAdvance) {
self.boundary_before = advance;
}
pub(in crate::layout) fn clear_boundary_before(&mut self) {
self.boundary_before = InlineBoundaryAdvance::zero();
}
pub(in crate::layout) fn used(self) -> InlineUsedAdvance {
InlineUsedAdvance(layout_pt(
self.base.points() + self.boundary_before.points(),
))
}
}
#[derive(Debug, Clone)]
pub(in crate::layout) struct MeasuredInlineItem {
pub(in crate::layout) item: InlineLineItem,
pub(in crate::layout) advance: MeasuredInlineAdvance,
pub(in crate::layout) shaped: Option<Rc<ShapedInlineLine>>,
}
impl MeasuredInlineItem {
pub(in crate::layout) fn new(
item: InlineLineItem,
base_advance_points: f32,
shaped: Option<Rc<ShapedInlineLine>>,
) -> Self {
Self {
item,
advance: MeasuredInlineAdvance::from_base_points(base_advance_points),
shaped,
}
}
pub(in crate::layout) fn base_advance(&self) -> InlineItemBaseAdvance {
self.advance.base()
}
pub(in crate::layout) fn used_advance(&self) -> InlineUsedAdvance {
self.advance.used()
}
}
impl AsRef<InlineLineItem> for MeasuredInlineItem {
fn as_ref(&self) -> &InlineLineItem {
&self.item
}
}
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub(in crate::layout) enum InlineLineEdgeEffectKind {
CollapsedEndTrim,
PreWrapHang,
UnconditionalSeparatorHang,
}
#[derive(Debug, Clone, PartialEq, Eq)]
pub(in crate::layout) struct InlineLineEdgeEffect {
pub(in crate::layout) kind: InlineLineEdgeEffectKind,
pub(in crate::layout) item_index: usize,
pub(in crate::layout) source_range: std::ops::Range<usize>,
}
#[derive(Debug, Clone, Default)]
pub(in crate::layout) struct InlineLineEdgeEffects {
pub(in crate::layout) collapsed_end_trim_width: f32,
pub(in crate::layout) pre_wrap_hanging_width: f32,
pub(in crate::layout) hanging_space_separator_width: f32,
pub(in crate::layout) retained_break_spaces_end: bool,
pub(in crate::layout) source_effects: Rc<[InlineLineEdgeEffect]>,
}
#[derive(Debug, Clone)]
pub(in crate::layout) struct MaterializedInlineGraphLine {
pub(in crate::layout) items: Vec<MeasuredInlineItem>,
pub(in crate::layout) fitting_width: f32,
pub(in crate::layout) content_width: f32,
pub(in crate::layout) edge_effects: InlineLineEdgeEffects,
}
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub(in crate::layout) enum SelectedLineEndCondition {
SoftWrap,
ForcedBreak,
ParagraphEnd,
IntrinsicSegmentEnd,
}
impl SelectedLineEndCondition {
pub(in crate::layout) fn pre_wrap_hanging_width(
self,
suffix_width: f32,
untrimmed_width: f32,
available_width: Option<f32>,
) -> f32 {
match self {
Self::SoftWrap | Self::IntrinsicSegmentEnd => suffix_width,
Self::ForcedBreak | Self::ParagraphEnd => available_width
.map(|available_width| (untrimmed_width - available_width).clamp(0.0, suffix_width))
.unwrap_or(0.0),
}
}
}
impl MaterializedInlineGraphLine {
pub(in crate::layout) fn used_text(&self) -> String {
let mut text = text_for_measured_items(&self.items);
if self.edge_effects.collapsed_end_trim_width > 0.0 {
text.truncate(text.trim_end_matches(is_css_collapsible_whitespace).len());
}
text
}
pub(in crate::layout) fn used_text_contains_whitespace(&self) -> bool {
if self.edge_effects.collapsed_end_trim_width == 0.0 {
return self.items.iter().any(|item| {
matches!(&item.item, InlineLineItem::Fragment(fragment) if fragment.text().chars().any(char::is_whitespace))
});
}
let mut trimming_trailing_space = true;
for item in self.items.iter().rev() {
let InlineLineItem::Fragment(fragment) = &item.item else {
continue;
};
for character in fragment.text().chars().rev() {
if trimming_trailing_space && is_css_collapsible_whitespace(character) {
continue;
}
trimming_trailing_space = false;
if character.is_whitespace() {
return true;
}
}
}
false
}
}
#[derive(Debug, Clone, Copy, Default)]
pub(in crate::layout) struct InlineContentWidth {
pub(in crate::layout) fitting_width: f32,
pub(in crate::layout) content_width: f32,
pub(in crate::layout) trailing_space_width: f32,
}
#[derive(Debug, Clone)]
pub(in crate::layout) struct BorrowedInlineLineMeasurement {
pub(in crate::layout) content_width: f32,
}
pub(in crate::layout) fn measured_inline_items(
items: &[MeasuredInlineItem],
) -> Vec<InlineLineItem> {
items.iter().map(|item| item.item.clone()).collect()
}
pub(in crate::layout) fn inline_content_width_for_line_items<T, F>(
items: &[T],
font_system: &mut FontSystem,
mut item_width: F,
) -> InlineContentWidth
where
T: AsRef<InlineLineItem>,
F: FnMut(&T) -> f32,
{
let raw_width = items.iter().map(&mut item_width).sum::<f32>();
let trailing_space_width =
trailing_hanging_space_separator_width_for_line_items(items, font_system);
InlineContentWidth {
fitting_width: (raw_width - trailing_space_width).max(0.0),
content_width: (raw_width - trailing_space_width).max(0.0),
trailing_space_width,
}
}
pub(in crate::layout) fn resolve_materialized_line_leaders(
line: &mut MaterializedInlineGraphLine,
font_system: &mut FontSystem,
available_inline_width: f32,
) {
let leader_count = line
.items
.iter()
.filter(|item| {
matches!(
&item.item,
InlineLineItem::Atom(atom) if matches!(atom.content(), InlineAtomContent::Leader(_))
)
})
.count();
if leader_count == 0 {
return;
}
let old_trailing_space_width =
trailing_hanging_space_separator_width_for_line_items(&line.items, font_system);
let consumed_pre_wrap_width = (line.edge_effects.pre_wrap_hanging_width
+ line.edge_effects.hanging_space_separator_width
- old_trailing_space_width)
.max(0.0);
let mut remaining_inline_width = (available_inline_width - line.content_width).max(0.0);
let mut remaining_leaders = leader_count;
let mut resolved_items = Vec::with_capacity(line.items.len());
for item in std::mem::take(&mut line.items) {
let InlineLineItem::Atom(atom) = &item.item else {
resolved_items.push(item);
continue;
};
let InlineAtomContent::Leader(pattern) = atom.content() else {
resolved_items.push(item);
continue;
};
let pattern_width = font_system.measure_text(pattern, atom.style());
let leader_share = if remaining_leaders > 0 {
remaining_inline_width / remaining_leaders as f32
} else {
0.0
};
remaining_leaders = remaining_leaders.saturating_sub(1);
if pattern.is_empty()
|| pattern_width <= 0.0
|| leader_share <= 0.0
|| !leader_share.is_finite()
|| available_inline_width == f32::MAX
{
continue;
}
let repeat_count = (leader_share / pattern_width).floor() as usize;
if repeat_count == 0 {
continue;
}
let text = pattern.repeat(repeat_count);
let fragment = InlineFragment::new(
text,
atom.style().clone(),
atom.baseline_shift(),
atom.link_target().map(ToOwned::to_owned),
false,
InlineTextSource::Normal,
true,
InlineHangingEdges::default(),
Vec::new(),
)
.with_visual_offset(atom.visual_offset);
let shaped = font_system.shape_unwrapped_line(
fragment.text(),
fragment.style(),
fragment.style().line_height,
);
let width = shaped
.as_ref()
.map(ShapedInlineLine::advance_width)
.unwrap_or(0.0);
let shaped = shaped.map(Rc::new);
remaining_inline_width = (remaining_inline_width - width).max(0.0);
resolved_items.push(MeasuredInlineItem::new(
InlineLineItem::Fragment(fragment),
width,
shaped,
));
}
line.items = resolved_items;
let widths = inline_content_width_for_line_items(&line.items, font_system, |item| {
item.used_advance().points()
});
line.edge_effects.pre_wrap_hanging_width = consumed_pre_wrap_width;
line.edge_effects.hanging_space_separator_width = widths.trailing_space_width;
line.fitting_width = (widths.fitting_width - consumed_pre_wrap_width).max(0.0);
line.content_width = (widths.content_width - consumed_pre_wrap_width).max(0.0);
}
#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord)]
pub(in crate::layout) struct InlineGraphPosition {
pub(in crate::layout) run_index: usize,
pub(in crate::layout) byte_offset: usize,
}
impl InlineGraphPosition {
pub(in crate::layout) const fn at_run_start(run_index: usize) -> Self {
Self {
run_index,
byte_offset: 0,
}
}
}
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub(in crate::layout) struct InlineGraphRange {
pub(in crate::layout) start: InlineGraphPosition,
pub(in crate::layout) end: InlineGraphPosition,
}
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub(in crate::layout) struct UnbreakableInlineFloatContinuation {
pub(in crate::layout) source_range: InlineGraphRange,
pub(in crate::layout) marker: InlineGraphPosition,
}
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub(in crate::layout) enum BreakEffect {
Forced,
SoftWrap,
ExplicitVirtual,
PreservedSpace,
BreakSpaces,
Hyphenation,
Emergency,
AtomicBoundary,
FloatPlacement,
}
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub(in crate::layout) enum SelectedWhitespaceEdge {
None,
CollapseAtNextLineStart,
PreWrapHang,
BreakSpacesRetained,
}
impl SelectedWhitespaceEdge {
pub(in crate::layout) const fn trims_next_line_start(self) -> bool {
matches!(self, Self::CollapseAtNextLineStart)
}
pub(in crate::layout) const fn hangs_from_fitting_measure(self) -> bool {
matches!(self, Self::PreWrapHang)
}
pub(in crate::layout) const fn retains_break_spaces_advance(self) -> bool {
matches!(self, Self::BreakSpacesRetained)
}
}
pub(in crate::layout) type InlineBreakKind = BreakEffect;
#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord)]
pub(in crate::layout) enum BreakAvailability {
Ordinary,
RelaxedWordBreak(WordBreakRelaxation),
OverflowWrap(OverflowWrapFallback),
}
#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord)]
pub(in crate::layout) enum WordBreakRelaxation {
KeepAll,
AutoPhraseWrap,
AutoPhraseHyphenation,
}
#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord)]
pub(in crate::layout) enum OverflowWrapFallback {
Anywhere,
BreakWord,
}
impl BreakAvailability {
pub(in crate::layout) const fn fitting_stage(self) -> u8 {
match self {
Self::Ordinary => 0,
Self::RelaxedWordBreak(WordBreakRelaxation::KeepAll) => 1,
Self::RelaxedWordBreak(WordBreakRelaxation::AutoPhraseWrap) => 1,
Self::RelaxedWordBreak(WordBreakRelaxation::AutoPhraseHyphenation) => 2,
Self::OverflowWrap(_) => 3,
}
}
pub(in crate::layout) const fn is_fallback(self) -> bool {
!matches!(self, Self::Ordinary)
}
pub(in crate::layout) const fn participates_in_min_content(self) -> bool {
matches!(
self,
Self::Ordinary | Self::OverflowWrap(OverflowWrapFallback::Anywhere)
)
}
}
pub(in crate::layout) const fn discretionary_hyphenation_availability(
policy: DiscretionaryHyphenationPolicy,
) -> Option<BreakAvailability> {
match policy {
DiscretionaryHyphenationPolicy::Disabled => None,
DiscretionaryHyphenationPolicy::Ordinary => Some(BreakAvailability::Ordinary),
DiscretionaryHyphenationPolicy::DeferredForAutoPhrase => Some(
BreakAvailability::RelaxedWordBreak(WordBreakRelaxation::AutoPhraseHyphenation),
),
}
}
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub(in crate::layout) struct InlineBreakOpportunity {
pub(in crate::layout) position: InlineGraphPosition,
pub(in crate::layout) kind: BreakEffect,
pub(in crate::layout) availability: BreakAvailability,
pub(in crate::layout) whitespace_edge: SelectedWhitespaceEdge,
pub(in crate::layout) discretionary: Option<DiscretionaryBreakEffect>,
}
impl InlineBreakOpportunity {
pub(in crate::layout) const fn trims_next_line_start(self) -> bool {
self.whitespace_edge.trims_next_line_start()
}
pub(in crate::layout) const fn hangs_from_fitting_measure(self) -> bool {
self.whitespace_edge.hangs_from_fitting_measure()
}
pub(in crate::layout) const fn is_discretionary(self) -> bool {
self.discretionary.is_some()
}
}
#[derive(Debug, Clone)]
pub(in crate::layout) struct InlineOpportunityGraph {
pub(in crate::layout) runs: Vec<InlineParagraphRun>,
pub(in crate::layout) opportunities: Vec<InlineBreakOpportunity>,
pub(super) wrap_inside_avoid_depths: BTreeMap<InlineGraphPosition, u16>,
pub(super) monotonic_source_measurement: RefCell<Option<Option<Rc<InlineLineMeasureIndex>>>>,
}
#[derive(Debug, Clone)]
pub(super) struct InlineLineMeasureIndex {
pub(super) run_starts: Vec<f32>,
pub(super) opportunity_advances: Vec<f32>,
}
pub(in crate::layout) struct LineMeasureCursor<'a> {
pub(super) opportunities: &'a [InlineBreakOpportunity],
pub(super) index: Rc<InlineLineMeasureIndex>,
pub(super) first_opportunity: usize,
pub(super) start_advance: f32,
}
impl LineMeasureCursor<'_> {
pub(in crate::layout) fn last_fitting(
&self,
available_width: f32,
) -> Option<InlineBreakOpportunity> {
let first_too_wide = self.index.opportunity_advances[self.first_opportunity..]
.partition_point(|advance| *advance - self.start_advance <= available_width + 0.5);
self.opportunities
.get(first_too_wide.saturating_sub(1))
.copied()
}
pub(in crate::layout) fn first(&self) -> Option<InlineBreakOpportunity> {
self.opportunities.first().copied()
}
}
pub(super) fn inline_box_edge_is_wrap_inside_avoid_start(item: &InlineLineItem) -> bool {
matches!(
item,
InlineLineItem::Atom(atom)
if matches!(
atom.content(),
InlineAtomContent::InlineEdge(InlineEdgeRole::BoxEdge(edge))
if edge.logical_edge == InlineLogicalEdge::Start
) && matches!(atom.style().wrap_inside, css::WrapInside::Avoid)
)
}
pub(super) fn inline_box_edge_is_wrap_inside_avoid_end(item: &InlineLineItem) -> bool {
matches!(
item,
InlineLineItem::Atom(atom)
if matches!(
atom.content(),
InlineAtomContent::InlineEdge(InlineEdgeRole::BoxEdge(edge))
if edge.logical_edge == InlineLogicalEdge::End
) && matches!(atom.style().wrap_inside, css::WrapInside::Avoid)
)
}
#[derive(Debug, Clone)]
pub(in crate::layout) struct InlineLineFragment {
pub(in crate::layout) items: Rc<[MeasuredInlineItem]>,
pub(in crate::layout) metrics: InlineLineMetrics,
pub(in crate::layout) hanging_widths: HangingPunctuationWidths,
pub(in crate::layout) indent: f32,
pub(in crate::layout) source_paint_indent: Option<f32>,
pub(in crate::layout) available_width: f32,
pub(in crate::layout) float_replay: InlineFloatReplay,
pub(in crate::layout) edge_effects: InlineLineEdgeEffects,
pub(in crate::layout) bidi_scope_continuations: BidiLineScopeContinuations,
pub(in crate::layout) text: Rc<str>,
pub(in crate::layout) text_box_trim: TextBoxLineTrim,
pub(in crate::layout) source_end: Option<InlineGraphPosition>,
pub(in crate::layout) first_line_style_materialized: bool,
}
impl InlineLineFragment {
#[allow(clippy::too_many_arguments)]
pub(in crate::layout) fn new(
items: Vec<MeasuredInlineItem>,
metrics: InlineLineMetrics,
hanging_widths: HangingPunctuationWidths,
indent: f32,
available_width: f32,
selected_float_page_index: usize,
text: impl Into<String>,
) -> Self {
Self {
items: Rc::from(items.into_boxed_slice()),
metrics,
hanging_widths,
indent,
source_paint_indent: None,
available_width,
float_replay: InlineFloatReplay::RequeryContainingBlock {
selected_float_page_index,
},
edge_effects: InlineLineEdgeEffects::default(),
bidi_scope_continuations: BidiLineScopeContinuations::default(),
text: Rc::from(text.into()),
text_box_trim: TextBoxLineTrim::default(),
source_end: None,
first_line_style_materialized: false,
}
}
pub(in crate::layout) fn items(&self) -> &[MeasuredInlineItem] {
&self.items
}
pub(in crate::layout) fn text(&self) -> &str {
&self.text
}
pub(in crate::layout) fn with_source_paint_indent(mut self, indent: f32) -> Self {
self.source_paint_indent = Some(indent);
self
}
pub(in crate::layout) fn with_edge_effects(
mut self,
edge_effects: InlineLineEdgeEffects,
) -> Self {
self.edge_effects = edge_effects;
self
}
pub(in crate::layout) fn with_bidi_scope_continuations(
mut self,
continuations: BidiLineScopeContinuations,
) -> Self {
self.bidi_scope_continuations = continuations;
self
}
pub(in crate::layout) fn with_source_end(mut self, source_end: InlineGraphPosition) -> Self {
self.source_end = Some(source_end);
self
}
pub(in crate::layout) fn mark_first_line_style_materialized(&mut self) {
self.first_line_style_materialized = true;
}
pub(in crate::layout) fn freeze_float_band(&mut self) {
self.float_replay = self.float_replay.freeze_selected_band();
}
pub(in crate::layout) fn requery_float_band(&mut self) {
self.float_replay = self.float_replay.requery_containing_block();
}
pub(in crate::layout) fn with_float_replay(mut self, replay: InlineFloatReplay) -> Self {
self.float_replay = replay;
self
}
}