use super::*;
#[derive(Debug, Clone, Copy, PartialEq)]
pub(in crate::layout) struct InlineIntrinsicContribution {
pub(in crate::layout) min_content: LogicalInlineContentSize,
pub(in crate::layout) max_content: LogicalInlineContentSize,
}
impl InlineIntrinsicContribution {
pub(in crate::layout) fn new(
min_content: LogicalInlineContentSize,
max_content: LogicalInlineContentSize,
) -> Self {
debug_assert!(min_content.points() <= max_content.points());
Self {
min_content,
max_content,
}
}
pub(in crate::layout) fn zero() -> Self {
Self::new(
LogicalInlineContentSize::new(content_box_pt(0.0)),
LogicalInlineContentSize::new(content_box_pt(0.0)),
)
}
pub(in crate::layout) fn include_max(&mut self, other: Self) {
self.min_content = self.min_content.max(other.min_content);
self.max_content = self.max_content.max(other.max_content);
}
}
impl Default for InlineIntrinsicContribution {
fn default() -> Self {
Self::zero()
}
}
#[derive(Debug, Clone)]
pub(in crate::layout) struct InlineMeasuredParagraph {
#[allow(dead_code)]
pub(in crate::layout) graph: InlineOpportunityGraph,
#[allow(dead_code)]
pub(in crate::layout) contribution: InlineIntrinsicContribution,
}
#[derive(Debug, Clone, Default)]
pub(in crate::layout) struct InlineIntrinsicMeasurement {
pub(in crate::layout) paragraphs: Vec<InlineMeasuredParagraph>,
pub(in crate::layout) sequence: InlineLineSequence,
pub(in crate::layout) contribution: InlineIntrinsicContribution,
}
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub(in crate::layout) struct IntrinsicMeasurementSensitivity {
pub(in crate::layout) block_extent_depends_on_available_inline_size: bool,
}
impl InlineIntrinsicMeasurement {
pub(in crate::layout) fn sensitivity(&self) -> IntrinsicMeasurementSensitivity {
IntrinsicMeasurementSensitivity {
block_extent_depends_on_available_inline_size: self.paragraphs.iter().any(
|paragraph| {
paragraph
.graph
.opportunities
.iter()
.any(|opportunity| !matches!(opportunity.kind, BreakEffect::Forced))
},
),
}
}
pub(in crate::layout) fn height(&self) -> f32 {
self.sequence.total_height()
}
pub(in crate::layout) fn physical_height(&self, style: &ComputedStyle) -> f32 {
match style.writing_mode {
WritingMode::HorizontalTb => self.height(),
WritingMode::VerticalRl
| WritingMode::VerticalLr
| WritingMode::SidewaysRl
| WritingMode::SidewaysLr => self
.sequence
.records
.iter()
.filter_map(|record| record.fragment.as_ref())
.map(|fragment| fragment.metrics.width)
.fold(0.0, f32::max),
}
}
pub(in crate::layout) fn physical_width(&self, style: &ComputedStyle) -> f32 {
match style.writing_mode {
WritingMode::HorizontalTb => self.contribution.max_content.points(),
WritingMode::VerticalRl
| WritingMode::VerticalLr
| WritingMode::SidewaysRl
| WritingMode::SidewaysLr => self.height(),
}
}
pub(in crate::layout) fn logical_block_span(&self, style: &ComputedStyle) -> f32 {
match style.writing_mode {
WritingMode::HorizontalTb => self.height(),
WritingMode::VerticalRl
| WritingMode::VerticalLr
| WritingMode::SidewaysRl
| WritingMode::SidewaysLr => self
.sequence
.records
.iter()
.filter(|record| !record.kind.is_phantom())
.map(|record| {
let line_block_size = record
.fragment
.as_ref()
.map(|fragment| {
fragment
.items
.iter()
.map(|item| inline_line_item_logical_block_size(&item.item, style))
.fold(style.line_height, f32::max)
})
.unwrap_or_else(|| record.height());
record.block_before + line_block_size
})
.sum(),
}
}
pub(in crate::layout) fn line_count(&self) -> usize {
self.sequence.line_count()
}
#[allow(dead_code)]
pub(in crate::layout) fn forced_empty_line_count(&self) -> usize {
self.sequence.forced_empty_line_count()
}
}