mirror of
https://github.com/servo/servo.git
synced 2025-07-23 15:23:42 +01:00
There were two kinds of layout tracing controlled by the same debugging option: - modern layout: Functionality that dumped a JSON serialization of the layout tree before and after layout. - legacy layout: A scope based tracing that reported the process of layout in a structured way. I don't think anyone working on layout is using either of these two features. For modern layout requiring data structure to implement `serde` serialization is incredibly inconvenient and also generates a lot of extra code. We also have a more modern tracing functionality based on perfetto that we have started to use for layout and IMO it's actually being used and more robust. Signed-off-by: Martin Robinson <mrobinson@igalia.com>
142 lines
3.8 KiB
Rust
142 lines
3.8 KiB
Rust
/* This Source Code Form is subject to the terms of the Mozilla Public
|
|
* License, v. 2.0. If a copy of the MPL was not distributed with this
|
|
* file, You can obtain one at https://mozilla.org/MPL/2.0/. */
|
|
|
|
#![deny(unsafe_code)]
|
|
|
|
mod cell;
|
|
pub mod context;
|
|
pub mod display_list;
|
|
pub mod dom;
|
|
mod dom_traversal;
|
|
mod flexbox;
|
|
pub mod flow;
|
|
mod formatting_contexts;
|
|
mod fragment_tree;
|
|
pub mod geom;
|
|
mod layout_box_base;
|
|
mod taffy;
|
|
#[macro_use]
|
|
mod construct_modern;
|
|
mod lists;
|
|
mod positioned;
|
|
pub mod query;
|
|
mod replaced;
|
|
mod sizing;
|
|
mod style_ext;
|
|
pub mod table;
|
|
pub mod traversal;
|
|
|
|
use app_units::Au;
|
|
pub use flow::BoxTree;
|
|
pub use fragment_tree::FragmentTree;
|
|
use geom::AuOrAuto;
|
|
use style::logical_geometry::WritingMode;
|
|
use style::properties::ComputedValues;
|
|
|
|
use crate::geom::{LogicalVec2, SizeConstraint};
|
|
use crate::style_ext::AspectRatio;
|
|
|
|
/// Represents the set of constraints that we use when computing the min-content
|
|
/// and max-content inline sizes of an element.
|
|
pub(crate) struct ConstraintSpace {
|
|
pub block_size: SizeConstraint,
|
|
pub writing_mode: WritingMode,
|
|
pub preferred_aspect_ratio: Option<AspectRatio>,
|
|
}
|
|
|
|
impl ConstraintSpace {
|
|
fn new(
|
|
block_size: SizeConstraint,
|
|
writing_mode: WritingMode,
|
|
preferred_aspect_ratio: Option<AspectRatio>,
|
|
) -> Self {
|
|
Self {
|
|
block_size,
|
|
writing_mode,
|
|
preferred_aspect_ratio,
|
|
}
|
|
}
|
|
|
|
fn new_for_style_and_ratio(
|
|
style: &ComputedValues,
|
|
preferred_aspect_ratio: Option<AspectRatio>,
|
|
) -> Self {
|
|
Self::new(
|
|
SizeConstraint::default(),
|
|
style.writing_mode,
|
|
preferred_aspect_ratio,
|
|
)
|
|
}
|
|
}
|
|
|
|
/// A variant of [`ContainingBlock`] that allows an indefinite inline size.
|
|
/// Useful for code that is shared for both layout (where we know the inline size
|
|
/// of the containing block) and intrinsic sizing (where we don't know it).
|
|
pub(crate) struct IndefiniteContainingBlock {
|
|
pub size: LogicalVec2<AuOrAuto>,
|
|
pub writing_mode: WritingMode,
|
|
}
|
|
|
|
impl From<&ConstraintSpace> for IndefiniteContainingBlock {
|
|
fn from(constraint_space: &ConstraintSpace) -> Self {
|
|
Self {
|
|
size: LogicalVec2 {
|
|
inline: AuOrAuto::Auto,
|
|
block: constraint_space.block_size.to_auto_or(),
|
|
},
|
|
writing_mode: constraint_space.writing_mode,
|
|
}
|
|
}
|
|
}
|
|
|
|
impl<'a> From<&'_ ContainingBlock<'a>> for IndefiniteContainingBlock {
|
|
fn from(containing_block: &ContainingBlock<'a>) -> Self {
|
|
Self {
|
|
size: LogicalVec2 {
|
|
inline: AuOrAuto::LengthPercentage(containing_block.size.inline),
|
|
block: containing_block.size.block.to_auto_or(),
|
|
},
|
|
writing_mode: containing_block.style.writing_mode,
|
|
}
|
|
}
|
|
}
|
|
|
|
impl<'a> From<&'_ DefiniteContainingBlock<'a>> for IndefiniteContainingBlock {
|
|
fn from(containing_block: &DefiniteContainingBlock<'a>) -> Self {
|
|
Self {
|
|
size: containing_block
|
|
.size
|
|
.map(|v| AuOrAuto::LengthPercentage(*v)),
|
|
writing_mode: containing_block.style.writing_mode,
|
|
}
|
|
}
|
|
}
|
|
|
|
#[derive(Debug)]
|
|
pub(crate) struct ContainingBlockSize {
|
|
inline: Au,
|
|
block: SizeConstraint,
|
|
}
|
|
|
|
pub(crate) struct ContainingBlock<'a> {
|
|
size: ContainingBlockSize,
|
|
style: &'a ComputedValues,
|
|
}
|
|
|
|
struct DefiniteContainingBlock<'a> {
|
|
size: LogicalVec2<Au>,
|
|
style: &'a ComputedValues,
|
|
}
|
|
|
|
impl<'a> From<&'_ DefiniteContainingBlock<'a>> for ContainingBlock<'a> {
|
|
fn from(definite: &DefiniteContainingBlock<'a>) -> Self {
|
|
ContainingBlock {
|
|
size: ContainingBlockSize {
|
|
inline: definite.size.inline,
|
|
block: SizeConstraint::Definite(definite.size.block),
|
|
},
|
|
style: definite.style,
|
|
}
|
|
}
|
|
}
|