use super::*;
#[derive(Debug, Clone, Copy, PartialEq)]
pub(in crate::layout) struct ContainingBlock {
pub(in crate::layout) rect: PageTopRect,
pub(in crate::layout) origin_page_index: Option<usize>,
}
#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
pub(in crate::layout) struct AtomicInlineCoordinateSpaceId(u64);
impl AtomicInlineCoordinateSpaceId {
pub(in crate::layout) const fn new(value: u64) -> Self {
Self(value)
}
}
#[derive(Debug, Clone, Copy, Default, PartialEq, Eq)]
pub(in crate::layout) enum PositionedCoordinateSpace {
#[default]
Page,
AtomicInline(AtomicInlineCoordinateSpaceId),
}
#[derive(Debug, Clone, Copy, PartialEq)]
pub(in crate::layout) struct PositionedContainingBlockContext {
pub(in crate::layout) geometry: ContainingBlock,
pub(in crate::layout) coordinate_space: PositionedCoordinateSpace,
}
impl PositionedContainingBlockContext {
pub(in crate::layout) const fn page(geometry: ContainingBlock) -> Self {
Self {
geometry,
coordinate_space: PositionedCoordinateSpace::Page,
}
}
pub(in crate::layout) const fn in_space(
geometry: ContainingBlock,
coordinate_space: PositionedCoordinateSpace,
) -> Self {
Self {
geometry,
coordinate_space,
}
}
}
impl std::ops::Deref for PositionedContainingBlockContext {
type Target = ContainingBlock;
fn deref(&self) -> &Self::Target {
&self.geometry
}
}
#[derive(Debug, Clone, Copy)]
pub(in crate::layout) struct EscapedAtomPositioningContext {
pub(in crate::layout) actual_containing_block: ContainingBlock,
pub(in crate::layout) static_position: AtomicInlineStaticPosition,
}
#[derive(Debug, Clone, Copy, PartialEq)]
pub(in crate::layout) struct AtomicInlineStaticPosition {
pub(in crate::layout) content_rect: PageTopRect,
pub(in crate::layout) axes: WritingModeAxes,
}
impl AtomicInlineStaticPosition {
pub(in crate::layout) fn new(content_rect: PageTopRect, axes: WritingModeAxes) -> Self {
Self { content_rect, axes }
}
fn static_position_rectangle(self) -> StaticPositionRectangle {
let area = match self.axes.physical_axis(LogicalAxis::Inline) {
PhysicalAxis::Horizontal => PageTopRect::new(
self.content_rect.x(),
self.content_rect.top_y(),
self.content_rect.width(),
0.0,
),
PhysicalAxis::Vertical => {
let x = match self.axes.physical_side(LogicalSide::BlockStart) {
PhysicalSide::Left => self.content_rect.x(),
PhysicalSide::Right => self.content_rect.x() + self.content_rect.width(),
PhysicalSide::Top | PhysicalSide::Bottom => {
unreachable!("a vertical writing mode has a horizontal block axis")
}
};
PageTopRect::new(
x,
self.content_rect.top_y(),
0.0,
self.content_rect.height(),
)
}
};
StaticPositionRectangle {
area,
writing_mode: self.axes.writing_mode(),
direction: self.axes.direction(),
justify_items: css::SelfAlignment::NORMAL,
align_items: css::SelfAlignment::NORMAL,
}
}
pub(in crate::layout) fn in_atomic_space(self) -> AbsoluteStaticPosition {
AbsoluteStaticPosition::from_page_rect(
self.content_rect.x(),
self.content_rect.x() + self.content_rect.width(),
self.content_rect.top_y(),
)
.with_static_position_rectangle(self.static_position_rectangle())
}
pub(in crate::layout) fn in_page_owned_containing_block(
self,
containing_block: ContainingBlock,
) -> AbsoluteStaticPosition {
let horizontal_offset = containing_block.x();
let mut rectangle = self.static_position_rectangle();
rectangle.area = PageTopRect::new(
rectangle.area.x() + horizontal_offset,
rectangle.area.top_y(),
rectangle.area.width(),
rectangle.area.height(),
);
AbsoluteStaticPosition::from_page_rect(
self.content_rect.x() + horizontal_offset,
self.content_rect.x() + self.content_rect.width() + horizontal_offset,
self.content_rect.top_y(),
)
.with_static_position_rectangle(rectangle)
}
}
#[derive(Debug, Clone, Copy, PartialEq)]
pub(in crate::layout) struct NormalFlowRelativeContainingBlock {
pub(in crate::layout) physical_content_width: PhysicalContentWidth,
pub(in crate::layout) physical_content_height: Option<PhysicalContentHeight>,
}
impl ContainingBlock {
pub(in crate::layout) fn from_page_top_rect(rect: PageTopRect) -> Self {
Self {
rect,
origin_page_index: None,
}
}
pub(in crate::layout) fn on_page(mut self, page_index: usize) -> Self {
self.origin_page_index = Some(page_index);
self
}
pub(in crate::layout) fn translated(mut self, translation: PaintTranslation) -> Self {
self.rect = PageTopRect::new(
self.rect.x() + translation.x,
self.rect.top_y() + translation.y,
self.rect.width(),
self.rect.height(),
);
self
}
pub(in crate::layout) fn x(self) -> f32 {
self.rect.x()
}
pub(in crate::layout) fn top_y(self) -> f32 {
self.rect.top_y()
}
pub(in crate::layout) fn width(self) -> f32 {
self.rect.width()
}
pub(in crate::layout) fn height(self) -> f32 {
self.rect.height()
}
}
#[derive(Debug, Clone, Copy, PartialEq)]
pub(in crate::layout) enum OrthogonalAvailableHeight {
InitialContainingBlock(PhysicalContentHeight),
NearestScrollContainer(PhysicalContentHeight),
}
impl OrthogonalAvailableHeight {
pub(in crate::layout) fn initial_containing_block(value: PhysicalContentHeight) -> Self {
Self::InitialContainingBlock(value.non_negative())
}
pub(in crate::layout) fn nearest_scroll_container(value: PhysicalContentHeight) -> Self {
Self::NearestScrollContainer(value.non_negative())
}
pub(in crate::layout) fn value(self) -> PhysicalContentHeight {
match self {
Self::InitialContainingBlock(value) | Self::NearestScrollContainer(value) => value,
}
}
}
#[derive(Debug, Clone, Copy, PartialEq)]
pub(in crate::layout) enum DirectOrthogonalAvailableHeight {
Definite(PhysicalContentHeight),
Maximum(PhysicalContentHeight),
MinimumFloor(PhysicalContentHeight),
}
impl DirectOrthogonalAvailableHeight {
pub(in crate::layout) fn value(self) -> PhysicalContentHeight {
match self {
Self::Definite(value) | Self::Maximum(value) | Self::MinimumFloor(value) => value,
}
}
pub(in crate::layout) fn capped_by_initial_containing_block(
self,
initial: PhysicalContentHeight,
) -> Option<Self> {
let value = self.value().points();
match self {
Self::Definite(_) => Some(self),
_ => (value < initial.points()).then(|| match self {
Self::Maximum(_) => {
Self::Maximum(PhysicalContentHeight::new(content_box_pt(value.max(0.0))))
}
Self::MinimumFloor(_) => {
Self::MinimumFloor(PhysicalContentHeight::new(content_box_pt(value.max(0.0))))
}
Self::Definite(_) => unreachable!("definite direct height returns before capping"),
}),
}
}
}
#[derive(Debug, Clone, Copy, PartialEq)]
pub(in crate::layout) enum OrthogonalInlineMeasure {
DefiniteContainingBlock(PhysicalContentHeight),
DirectContainingBlock(DirectOrthogonalAvailableHeight),
NearestScrollContainer(PhysicalContentHeight),
InitialContainingBlock(PhysicalContentHeight),
}
impl OrthogonalInlineMeasure {
pub(in crate::layout) fn value(self) -> PhysicalContentHeight {
match self {
Self::DefiniteContainingBlock(value)
| Self::NearestScrollContainer(value)
| Self::InitialContainingBlock(value) => value,
Self::DirectContainingBlock(value) => value.value(),
}
}
}
#[derive(Debug, Clone, Copy, PartialEq)]
pub(in crate::layout) struct ChildAvailableSpace {
pub(in crate::layout) writing_mode: WritingMode,
pub(in crate::layout) physical_content_width: PhysicalContentWidth,
pub(in crate::layout) physical_width_is_definite: bool,
pub(in crate::layout) orthogonal_physical_width_percentage_basis: PhysicalContentWidth,
pub(in crate::layout) physical_content_height: PercentageBasis<PhysicalContentHeight>,
pub(in crate::layout) orthogonal_available_height: OrthogonalAvailableHeight,
pub(in crate::layout) direct_orthogonal_available_height:
Option<DirectOrthogonalAvailableHeight>,
}
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub(in crate::layout) enum IntrinsicInlinePercentageBasisSource {
MeasurementAvailableWidth,
}
pub(in crate::layout) type IntrinsicInlinePercentageBasis =
PercentageBasis<ContentBoxLength, IntrinsicInlinePercentageBasisSource>;
impl ChildAvailableSpace {
pub(in crate::layout) fn new(
writing_mode: WritingMode,
physical_content_width: PhysicalContentWidth,
physical_width_is_definite: bool,
physical_content_height: Option<PhysicalContentHeight>,
fallback_physical_content_height: PhysicalContentHeight,
) -> Self {
Self {
writing_mode,
physical_content_width: PhysicalContentWidth::new(content_box_pt(
physical_content_width.points().max(0.0),
)),
physical_width_is_definite,
orthogonal_physical_width_percentage_basis: PhysicalContentWidth::new(content_box_pt(
physical_content_width.points().max(0.0),
)),
physical_content_height: physical_content_height.map_or_else(
PercentageBasis::indefinite,
|height| {
PercentageBasis::definite(PhysicalContentHeight::new(content_box_pt(
height.points().max(0.0),
)))
},
),
orthogonal_available_height: OrthogonalAvailableHeight::initial_containing_block(
fallback_physical_content_height,
),
direct_orthogonal_available_height: None,
}
}
pub(in crate::layout) fn with_direct_orthogonal_available_height(
mut self,
height: Option<DirectOrthogonalAvailableHeight>,
) -> Self {
self.direct_orthogonal_available_height = height;
self
}
pub(in crate::layout) fn with_orthogonal_physical_width_percentage_basis(
mut self,
basis: PhysicalContentWidth,
) -> Self {
self.orthogonal_physical_width_percentage_basis = basis;
self
}
pub(in crate::layout) fn with_orthogonal_available_height(
mut self,
height: OrthogonalAvailableHeight,
) -> Self {
self.orthogonal_available_height = match height {
OrthogonalAvailableHeight::InitialContainingBlock(value) => {
OrthogonalAvailableHeight::initial_containing_block(value)
}
OrthogonalAvailableHeight::NearestScrollContainer(value) => {
OrthogonalAvailableHeight::nearest_scroll_container(value)
}
};
self
}
pub(in crate::layout) fn orthogonal_inline_measure(self) -> OrthogonalInlineMeasure {
if let Some(value) = self.physical_content_height.value() {
return OrthogonalInlineMeasure::DefiniteContainingBlock(value);
}
if let Some(value) = self.direct_orthogonal_available_height {
return OrthogonalInlineMeasure::DirectContainingBlock(value);
}
match self.orthogonal_available_height {
OrthogonalAvailableHeight::NearestScrollContainer(value) => {
OrthogonalInlineMeasure::NearestScrollContainer(value)
}
OrthogonalAvailableHeight::InitialContainingBlock(value) => {
OrthogonalInlineMeasure::InitialContainingBlock(value)
}
}
}
pub(in crate::layout) fn available_physical_height(self) -> PhysicalContentHeight {
self.orthogonal_inline_measure().value()
}
pub(in crate::layout) fn physical_height_percentage_basis(
self,
) -> PercentageBasis<PhysicalContentHeight> {
self.physical_content_height
}
pub(in crate::layout) fn logical_inline_size_for(
self,
writing_mode: WritingMode,
) -> LogicalInlineContentSize {
if WritingModeAxes::new(writing_mode, Direction::Ltr).swaps_physical_axes() {
LogicalInlineContentSize::new(
self.orthogonal_inline_measure()
.value()
.content_box_length(),
)
} else {
LogicalInlineContentSize::new(self.physical_content_width.content_box_length())
}
}
pub(in crate::layout) fn logical_inline_percentage_basis_for(
self,
writing_mode: WritingMode,
) -> LogicalInlinePercentageBasis {
if WritingModeAxes::new(writing_mode, Direction::Ltr).swaps_physical_axes() {
self.physical_height_percentage_basis()
.map_value(|height| LogicalInlineContentSize::new(height.content_box_length()))
} else if self.physical_width_is_definite {
PercentageBasis::definite(LogicalInlineContentSize::new(
self.physical_content_width.content_box_length(),
))
} else {
PercentageBasis::indefinite()
}
}
}
#[derive(Debug, Clone, Copy, PartialEq)]
pub(in crate::layout) struct OverflowClip {
pub(in crate::layout) rect: PaintRect,
pub(in crate::layout) clips_x: bool,
pub(in crate::layout) clips_y: bool,
pub(in crate::layout) non_scrollable_x: bool,
pub(in crate::layout) non_scrollable_y: bool,
}
impl OverflowClip {
pub(in crate::layout) fn from_paint_rect(rect: PaintRect) -> Self {
Self {
rect,
clips_x: true,
clips_y: true,
non_scrollable_x: false,
non_scrollable_y: false,
}
}
pub(in crate::layout) fn from_paint_rect_with_axes_and_non_scrollable(
rect: PaintRect,
clips_x: bool,
clips_y: bool,
non_scrollable_x: bool,
non_scrollable_y: bool,
) -> Self {
Self {
rect,
clips_x,
clips_y,
non_scrollable_x: clips_x && non_scrollable_x,
non_scrollable_y: clips_y && non_scrollable_y,
}
}
pub(in crate::layout) fn with_axes_and_non_scrollable(
mut self,
clips_x: bool,
clips_y: bool,
non_scrollable_x: bool,
non_scrollable_y: bool,
) -> Self {
self.clips_x = clips_x;
self.clips_y = clips_y;
self.non_scrollable_x = clips_x && non_scrollable_x;
self.non_scrollable_y = clips_y && non_scrollable_y;
self
}
pub(in crate::layout) fn from_page_top_rect(rect: PageTopRect) -> Self {
Self::from_paint_rect(rect.paint_rect())
}
pub(in crate::layout) fn paint_rect(self) -> PaintRect {
self.rect
}
pub(in crate::layout) fn intersect(self, other: Self) -> Option<Self> {
let rect = self.rect.intersection(&other.rect)?;
Some(Self {
rect,
clips_x: self.clips_x || other.clips_x,
clips_y: self.clips_y || other.clips_y,
non_scrollable_x: self.non_scrollable_x || other.non_scrollable_x,
non_scrollable_y: self.non_scrollable_y || other.non_scrollable_y,
})
}
}