mirror of
https://github.com/servo/servo.git
synced 2025-08-05 13:40:08 +01:00
layout: Share styles to inline box children via SharedInlineStyles
(#36896)
`TextRun`s use their parent style to render. Previously, these styles were cloned and stored directly in the box tree `TextRun` and resulting `TextFragment`s. This presents a problem for incremental layout. Wrapping the style in another layer of shared ownership and mutability will allow updating all `TextFragment`s during repaint-only incremental layout by simply updating the box tree styles of the original text parents. This adds a new set of borrows when accessing text styles, but also makes it so that during box tree block construction `InlineFormattingContext`s are created lazily and now `InlineFormattingContextBuilder::finish` consumes the builder, making the API make a bit more sense. This should also improve performance of box tree block construction slightly. Testing: This should not change observable behavior and thus is covered by existing WPT tests. Signed-off-by: Martin Robinson <mrobinson@igalia.com> Co-authored-by: Oriol Brufau <obrufau@igalia.com>
This commit is contained in:
parent
db83601b62
commit
a0dd2c1beb
24 changed files with 369 additions and 187 deletions
|
@ -13,9 +13,9 @@ use style::selector_parser::PseudoElement;
|
|||
use style::str::char_is_whitespace;
|
||||
|
||||
use super::OutsideMarker;
|
||||
use super::inline::InlineFormattingContext;
|
||||
use super::inline::construct::InlineFormattingContextBuilder;
|
||||
use super::inline::inline_box::InlineBox;
|
||||
use super::inline::{InlineFormattingContext, SharedInlineStyles};
|
||||
use crate::PropagatedBoxTreeData;
|
||||
use crate::cell::ArcRefCell;
|
||||
use crate::context::LayoutContext;
|
||||
|
@ -137,16 +137,25 @@ pub(crate) struct BlockContainerBuilder<'dom, 'style> {
|
|||
/// The propagated data to use for BoxTree construction.
|
||||
propagated_data: PropagatedBoxTreeData,
|
||||
|
||||
inline_formatting_context_builder: InlineFormattingContextBuilder,
|
||||
/// The [`InlineFormattingContextBuilder`] if we have encountered any inline items,
|
||||
/// otherwise None.
|
||||
///
|
||||
/// TODO: This can be `OnceCell` once `OnceCell::get_mut_or_init` is stabilized.
|
||||
inline_formatting_context_builder: Option<InlineFormattingContextBuilder>,
|
||||
|
||||
/// The [`NodeAndStyleInfo`] to use for anonymous block boxes pushed to the list of
|
||||
/// block-level boxes, lazily initialized (see `end_ongoing_inline_formatting_context`).
|
||||
/// block-level boxes, lazily initialized.
|
||||
anonymous_box_info: Option<NodeAndStyleInfo<'dom>>,
|
||||
|
||||
/// A collection of content that is being added to an anonymous table. This is
|
||||
/// composed of any sequence of internal table elements or table captions that
|
||||
/// are found outside of a table.
|
||||
anonymous_table_content: Vec<AnonymousTableContent<'dom>>,
|
||||
|
||||
/// Any [`InlineFormattingContexts`] created need to know about the ongoing `display: contents`
|
||||
/// ancestors that have been processed. This `Vec` allows passing those into new
|
||||
/// [`InlineFormattingContext`]s that we create.
|
||||
display_contents_shared_styles: Vec<SharedInlineStyles>,
|
||||
}
|
||||
|
||||
impl BlockContainer {
|
||||
|
@ -194,26 +203,44 @@ impl<'dom, 'style> BlockContainerBuilder<'dom, 'style> {
|
|||
have_already_seen_first_line_for_text_indent: false,
|
||||
anonymous_box_info: None,
|
||||
anonymous_table_content: Vec::new(),
|
||||
inline_formatting_context_builder: InlineFormattingContextBuilder::new(),
|
||||
inline_formatting_context_builder: None,
|
||||
display_contents_shared_styles: Vec::new(),
|
||||
}
|
||||
}
|
||||
|
||||
pub(crate) fn finish(mut self) -> BlockContainer {
|
||||
debug_assert!(
|
||||
!self
|
||||
.inline_formatting_context_builder
|
||||
.currently_processing_inline_box()
|
||||
);
|
||||
fn currently_processing_inline_box(&self) -> bool {
|
||||
self.inline_formatting_context_builder
|
||||
.as_ref()
|
||||
.is_some_and(InlineFormattingContextBuilder::currently_processing_inline_box)
|
||||
}
|
||||
|
||||
self.finish_anonymous_table_if_needed();
|
||||
fn ensure_inline_formatting_context_builder(&mut self) -> &mut InlineFormattingContextBuilder {
|
||||
self.inline_formatting_context_builder
|
||||
.get_or_insert_with(|| {
|
||||
let mut builder = InlineFormattingContextBuilder::new(self.info);
|
||||
for shared_inline_styles in self.display_contents_shared_styles.iter() {
|
||||
builder.enter_display_contents(shared_inline_styles.clone());
|
||||
}
|
||||
builder
|
||||
})
|
||||
}
|
||||
|
||||
if let Some(inline_formatting_context) = self.inline_formatting_context_builder.finish(
|
||||
fn finish_ongoing_inline_formatting_context(&mut self) -> Option<InlineFormattingContext> {
|
||||
self.inline_formatting_context_builder.take()?.finish(
|
||||
self.context,
|
||||
self.propagated_data,
|
||||
!self.have_already_seen_first_line_for_text_indent,
|
||||
self.info.is_single_line_text_input(),
|
||||
self.info.style.writing_mode.to_bidi_level(),
|
||||
) {
|
||||
)
|
||||
}
|
||||
|
||||
pub(crate) fn finish(mut self) -> BlockContainer {
|
||||
debug_assert!(!self.currently_processing_inline_box());
|
||||
|
||||
self.finish_anonymous_table_if_needed();
|
||||
|
||||
if let Some(inline_formatting_context) = self.finish_ongoing_inline_formatting_context() {
|
||||
// There are two options here. This block was composed of both one or more inline formatting contexts
|
||||
// and child blocks OR this block was a single inline formatting context. In the latter case, we
|
||||
// just return the inline formatting context as the block itself.
|
||||
|
@ -251,9 +278,7 @@ impl<'dom, 'style> BlockContainerBuilder<'dom, 'style> {
|
|||
//
|
||||
// Note that text content in the inline formatting context isn't enough to force the
|
||||
// creation of an inline table. It requires the parent to be an inline box.
|
||||
let inline_table = self
|
||||
.inline_formatting_context_builder
|
||||
.currently_processing_inline_box();
|
||||
let inline_table = self.currently_processing_inline_box();
|
||||
|
||||
// Text decorations are not propagated to atomic inline-level descendants.
|
||||
// From https://drafts.csswg.org/css2/#lining-striking-props:
|
||||
|
@ -276,10 +301,16 @@ impl<'dom, 'style> BlockContainerBuilder<'dom, 'style> {
|
|||
Table::construct_anonymous(self.context, self.info, contents, propagated_data);
|
||||
|
||||
if inline_table {
|
||||
self.inline_formatting_context_builder.push_atomic(ifc);
|
||||
self.ensure_inline_formatting_context_builder()
|
||||
.push_atomic(ifc);
|
||||
} else {
|
||||
let table_block = ArcRefCell::new(BlockLevelBox::Independent(ifc));
|
||||
self.end_ongoing_inline_formatting_context();
|
||||
|
||||
if let Some(inline_formatting_context) = self.finish_ongoing_inline_formatting_context()
|
||||
{
|
||||
self.push_block_level_job_for_inline_formatting_context(inline_formatting_context);
|
||||
}
|
||||
|
||||
self.block_level_boxes.push(BlockLevelJob {
|
||||
info: table_info,
|
||||
box_slot: BoxSlot::dummy(),
|
||||
|
@ -363,7 +394,22 @@ impl<'dom> TraversalHandler<'dom> for BlockContainerBuilder<'dom, '_> {
|
|||
self.finish_anonymous_table_if_needed();
|
||||
}
|
||||
|
||||
self.inline_formatting_context_builder.push_text(text, info);
|
||||
self.ensure_inline_formatting_context_builder()
|
||||
.push_text(text, info);
|
||||
}
|
||||
|
||||
fn enter_display_contents(&mut self, styles: SharedInlineStyles) {
|
||||
self.display_contents_shared_styles.push(styles.clone());
|
||||
if let Some(builder) = self.inline_formatting_context_builder.as_mut() {
|
||||
builder.enter_display_contents(styles);
|
||||
}
|
||||
}
|
||||
|
||||
fn leave_display_contents(&mut self) {
|
||||
self.display_contents_shared_styles.pop();
|
||||
if let Some(builder) = self.inline_formatting_context_builder.as_mut() {
|
||||
builder.leave_display_contents();
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
|
@ -433,14 +479,16 @@ impl<'dom> BlockContainerBuilder<'dom, '_> {
|
|||
(display_inside, contents.is_replaced())
|
||||
else {
|
||||
// If this inline element is an atomic, handle it and return.
|
||||
let atomic = self.inline_formatting_context_builder.push_atomic(
|
||||
let context = self.context;
|
||||
let propagaged_data = self.propagated_data.without_text_decorations();
|
||||
let atomic = self.ensure_inline_formatting_context_builder().push_atomic(
|
||||
IndependentFormattingContext::construct(
|
||||
self.context,
|
||||
context,
|
||||
info,
|
||||
display_inside,
|
||||
contents,
|
||||
// Text decorations are not propagated to atomic inline-level descendants.
|
||||
self.propagated_data.without_text_decorations(),
|
||||
propagaged_data,
|
||||
),
|
||||
);
|
||||
box_slot.set(LayoutBox::InlineLevel(vec![atomic]));
|
||||
|
@ -449,7 +497,7 @@ impl<'dom> BlockContainerBuilder<'dom, '_> {
|
|||
|
||||
// Otherwise, this is just a normal inline box. Whatever happened before, all we need to do
|
||||
// before recurring is to remember this ongoing inline level box.
|
||||
self.inline_formatting_context_builder
|
||||
self.ensure_inline_formatting_context_builder()
|
||||
.start_inline_box(InlineBox::new(info), None);
|
||||
|
||||
if is_list_item {
|
||||
|
@ -476,7 +524,10 @@ impl<'dom> BlockContainerBuilder<'dom, '_> {
|
|||
// `InlineFormattingContextBuilder::end_inline_box()` is returning all of those box tree
|
||||
// items.
|
||||
box_slot.set(LayoutBox::InlineLevel(
|
||||
self.inline_formatting_context_builder.end_inline_box(),
|
||||
self.inline_formatting_context_builder
|
||||
.as_mut()
|
||||
.expect("Should be building an InlineFormattingContext")
|
||||
.end_inline_box(),
|
||||
));
|
||||
}
|
||||
|
||||
|
@ -495,12 +546,15 @@ impl<'dom> BlockContainerBuilder<'dom, '_> {
|
|||
// that we want to have after we push the block below.
|
||||
if let Some(inline_formatting_context) = self
|
||||
.inline_formatting_context_builder
|
||||
.split_around_block_and_finish(
|
||||
self.context,
|
||||
self.propagated_data,
|
||||
!self.have_already_seen_first_line_for_text_indent,
|
||||
self.info.style.writing_mode.to_bidi_level(),
|
||||
)
|
||||
.as_mut()
|
||||
.and_then(|builder| {
|
||||
builder.split_around_block_and_finish(
|
||||
self.context,
|
||||
self.propagated_data,
|
||||
!self.have_already_seen_first_line_for_text_indent,
|
||||
self.info.style.writing_mode.to_bidi_level(),
|
||||
)
|
||||
})
|
||||
{
|
||||
self.push_block_level_job_for_inline_formatting_context(inline_formatting_context);
|
||||
}
|
||||
|
@ -555,17 +609,18 @@ impl<'dom> BlockContainerBuilder<'dom, '_> {
|
|||
contents: Contents,
|
||||
box_slot: BoxSlot<'dom>,
|
||||
) {
|
||||
if !self.inline_formatting_context_builder.is_empty() {
|
||||
let inline_level_box = self
|
||||
.inline_formatting_context_builder
|
||||
.push_absolutely_positioned_box(AbsolutelyPositionedBox::construct(
|
||||
self.context,
|
||||
info,
|
||||
display_inside,
|
||||
contents,
|
||||
));
|
||||
box_slot.set(LayoutBox::InlineLevel(vec![inline_level_box]));
|
||||
return;
|
||||
if let Some(builder) = self.inline_formatting_context_builder.as_mut() {
|
||||
if !builder.is_empty() {
|
||||
let inline_level_box =
|
||||
builder.push_absolutely_positioned_box(AbsolutelyPositionedBox::construct(
|
||||
self.context,
|
||||
info,
|
||||
display_inside,
|
||||
contents,
|
||||
));
|
||||
box_slot.set(LayoutBox::InlineLevel(vec![inline_level_box]));
|
||||
return;
|
||||
}
|
||||
}
|
||||
|
||||
let kind = BlockLevelCreator::OutOfFlowAbsolutelyPositionedBox {
|
||||
|
@ -587,18 +642,18 @@ impl<'dom> BlockContainerBuilder<'dom, '_> {
|
|||
contents: Contents,
|
||||
box_slot: BoxSlot<'dom>,
|
||||
) {
|
||||
if !self.inline_formatting_context_builder.is_empty() {
|
||||
let inline_level_box =
|
||||
self.inline_formatting_context_builder
|
||||
.push_float_box(FloatBox::construct(
|
||||
self.context,
|
||||
info,
|
||||
display_inside,
|
||||
contents,
|
||||
self.propagated_data,
|
||||
));
|
||||
box_slot.set(LayoutBox::InlineLevel(vec![inline_level_box]));
|
||||
return;
|
||||
if let Some(builder) = self.inline_formatting_context_builder.as_mut() {
|
||||
if !builder.is_empty() {
|
||||
let inline_level_box = builder.push_float_box(FloatBox::construct(
|
||||
self.context,
|
||||
info,
|
||||
display_inside,
|
||||
contents,
|
||||
self.propagated_data,
|
||||
));
|
||||
box_slot.set(LayoutBox::InlineLevel(vec![inline_level_box]));
|
||||
return;
|
||||
}
|
||||
}
|
||||
|
||||
let kind = BlockLevelCreator::OutOfFlowFloatBox {
|
||||
|
@ -613,18 +668,6 @@ impl<'dom> BlockContainerBuilder<'dom, '_> {
|
|||
});
|
||||
}
|
||||
|
||||
fn end_ongoing_inline_formatting_context(&mut self) {
|
||||
if let Some(inline_formatting_context) = self.inline_formatting_context_builder.finish(
|
||||
self.context,
|
||||
self.propagated_data,
|
||||
!self.have_already_seen_first_line_for_text_indent,
|
||||
self.info.is_single_line_text_input(),
|
||||
self.info.style.writing_mode.to_bidi_level(),
|
||||
) {
|
||||
self.push_block_level_job_for_inline_formatting_context(inline_formatting_context);
|
||||
}
|
||||
}
|
||||
|
||||
fn push_block_level_job_for_inline_formatting_context(
|
||||
&mut self,
|
||||
inline_formatting_context: InlineFormattingContext,
|
||||
|
|
|
@ -13,7 +13,10 @@ use style::values::specified::text::TextTransformCase;
|
|||
use unicode_bidi::Level;
|
||||
|
||||
use super::text_run::TextRun;
|
||||
use super::{InlineBox, InlineBoxIdentifier, InlineBoxes, InlineFormattingContext, InlineItem};
|
||||
use super::{
|
||||
InlineBox, InlineBoxIdentifier, InlineBoxes, InlineFormattingContext, InlineItem,
|
||||
SharedInlineStyles,
|
||||
};
|
||||
use crate::PropagatedBoxTreeData;
|
||||
use crate::cell::ArcRefCell;
|
||||
use crate::context::LayoutContext;
|
||||
|
@ -25,6 +28,12 @@ use crate::style_ext::ComputedValuesExt;
|
|||
|
||||
#[derive(Default)]
|
||||
pub(crate) struct InlineFormattingContextBuilder {
|
||||
/// A stack of [`SharedInlineStyles`] including one for the root, one for each inline box on the
|
||||
/// inline box stack, and importantly, one for every `display: contents` element that we are
|
||||
/// currently processing. Normally `display: contents` elements don't affect the structure of
|
||||
/// the [`InlineFormattingContext`], but the styles they provide do style their children.
|
||||
shared_inline_styles_stack: Vec<SharedInlineStyles>,
|
||||
|
||||
/// The collection of text strings that make up this [`InlineFormattingContext`] under
|
||||
/// construction.
|
||||
pub text_segments: Vec<String>,
|
||||
|
@ -63,7 +72,7 @@ pub(crate) struct InlineFormattingContextBuilder {
|
|||
/// The traversal is at all times as deep in the tree as this stack is,
|
||||
/// which is why the code doesn't need to keep track of the actual
|
||||
/// container root (see `handle_inline_level_element`).
|
||||
///
|
||||
//_
|
||||
/// When an inline box ends, it's removed from this stack.
|
||||
inline_box_stack: Vec<InlineBoxIdentifier>,
|
||||
|
||||
|
@ -83,10 +92,17 @@ pub(crate) struct InlineFormattingContextBuilder {
|
|||
}
|
||||
|
||||
impl InlineFormattingContextBuilder {
|
||||
pub(crate) fn new() -> Self {
|
||||
// For the purposes of `text-transform: capitalize` the start of the IFC is a word boundary.
|
||||
pub(crate) fn new(info: &NodeAndStyleInfo) -> Self {
|
||||
Self::new_for_shared_styles(vec![info.into()])
|
||||
}
|
||||
|
||||
pub(crate) fn new_for_shared_styles(
|
||||
shared_inline_styles_stack: Vec<SharedInlineStyles>,
|
||||
) -> Self {
|
||||
Self {
|
||||
// For the purposes of `text-transform: capitalize` the start of the IFC is a word boundary.
|
||||
on_word_boundary: true,
|
||||
shared_inline_styles_stack,
|
||||
..Default::default()
|
||||
}
|
||||
}
|
||||
|
@ -100,6 +116,13 @@ impl InlineFormattingContextBuilder {
|
|||
self.current_text_offset += string_to_push.len();
|
||||
}
|
||||
|
||||
fn shared_inline_styles(&self) -> SharedInlineStyles {
|
||||
self.shared_inline_styles_stack
|
||||
.last()
|
||||
.expect("Should always have at least one SharedInlineStyles")
|
||||
.clone()
|
||||
}
|
||||
|
||||
/// Return true if this [`InlineFormattingContextBuilder`] is empty for the purposes of ignoring
|
||||
/// during box tree construction. An IFC is empty if it only contains TextRuns with
|
||||
/// completely collapsible whitespace. When that happens it can be ignored completely.
|
||||
|
@ -179,6 +202,14 @@ impl InlineFormattingContextBuilder {
|
|||
) {
|
||||
self.push_control_character_string(inline_box.base.style.bidi_control_chars().0);
|
||||
|
||||
// Don't push a `SharedInlineStyles` if we are pushing this box when splitting
|
||||
// an IFC for a block-in-inline split. Shared styles are pushed as part of setting
|
||||
// up the second split of the IFC.
|
||||
if inline_box.is_first_split {
|
||||
self.shared_inline_styles_stack
|
||||
.push(inline_box.shared_inline_styles.clone());
|
||||
}
|
||||
|
||||
let (identifier, inline_box) = self.inline_boxes.start_inline_box(inline_box);
|
||||
let inline_level_box = ArcRefCell::new(InlineItem::StartInlineBox(inline_box));
|
||||
self.inline_items.push(inline_level_box.clone());
|
||||
|
@ -194,6 +225,8 @@ impl InlineFormattingContextBuilder {
|
|||
/// a single box tree items may be produced for a single inline box when that inline
|
||||
/// box is split around a block-level element.
|
||||
pub(crate) fn end_inline_box(&mut self) -> Vec<ArcRefCell<InlineItem>> {
|
||||
self.shared_inline_styles_stack.pop();
|
||||
|
||||
let (identifier, block_in_inline_splits) = self.end_inline_box_internal();
|
||||
let inline_level_box = self.inline_boxes.get(&identifier);
|
||||
{
|
||||
|
@ -272,8 +305,6 @@ impl InlineFormattingContextBuilder {
|
|||
}
|
||||
|
||||
let selection_range = info.get_selection_range();
|
||||
let selected_style = info.get_selected_style();
|
||||
|
||||
if let Some(last_character) = new_text.chars().next_back() {
|
||||
self.on_word_boundary = last_character.is_whitespace();
|
||||
self.last_inline_box_ended_with_collapsible_white_space =
|
||||
|
@ -295,14 +326,21 @@ impl InlineFormattingContextBuilder {
|
|||
.push(ArcRefCell::new(InlineItem::TextRun(ArcRefCell::new(
|
||||
TextRun::new(
|
||||
info.into(),
|
||||
info.style.clone(),
|
||||
self.shared_inline_styles(),
|
||||
new_range,
|
||||
selection_range,
|
||||
selected_style,
|
||||
),
|
||||
))));
|
||||
}
|
||||
|
||||
pub(crate) fn enter_display_contents(&mut self, shared_inline_styles: SharedInlineStyles) {
|
||||
self.shared_inline_styles_stack.push(shared_inline_styles);
|
||||
}
|
||||
|
||||
pub(crate) fn leave_display_contents(&mut self) {
|
||||
self.shared_inline_styles_stack.pop();
|
||||
}
|
||||
|
||||
pub(crate) fn split_around_block_and_finish(
|
||||
&mut self,
|
||||
layout_context: &LayoutContext,
|
||||
|
@ -318,7 +356,8 @@ impl InlineFormattingContextBuilder {
|
|||
// context. It has the same inline box structure as this builder, except the boxes are
|
||||
// marked as not being the first fragment. No inline content is carried over to this new
|
||||
// builder.
|
||||
let mut new_builder = InlineFormattingContextBuilder::new();
|
||||
let mut new_builder = Self::new_for_shared_styles(self.shared_inline_styles_stack.clone());
|
||||
|
||||
let block_in_inline_splits = std::mem::take(&mut self.block_in_inline_splits);
|
||||
for (identifier, historical_inline_boxes) in
|
||||
izip!(self.inline_box_stack.iter(), block_in_inline_splits)
|
||||
|
@ -356,7 +395,7 @@ impl InlineFormattingContextBuilder {
|
|||
|
||||
/// Finish the current inline formatting context, returning [`None`] if the context was empty.
|
||||
pub(crate) fn finish(
|
||||
&mut self,
|
||||
self,
|
||||
layout_context: &LayoutContext,
|
||||
propagated_data: PropagatedBoxTreeData,
|
||||
has_first_formatted_line: bool,
|
||||
|
@ -367,11 +406,9 @@ impl InlineFormattingContextBuilder {
|
|||
return None;
|
||||
}
|
||||
|
||||
let old_builder = std::mem::replace(self, InlineFormattingContextBuilder::new());
|
||||
assert!(old_builder.inline_box_stack.is_empty());
|
||||
|
||||
assert!(self.inline_box_stack.is_empty());
|
||||
Some(InlineFormattingContext::new_with_builder(
|
||||
old_builder,
|
||||
self,
|
||||
layout_context,
|
||||
propagated_data,
|
||||
has_first_formatted_line,
|
||||
|
|
|
@ -8,7 +8,10 @@ use app_units::Au;
|
|||
use fonts::FontMetrics;
|
||||
use malloc_size_of_derive::MallocSizeOf;
|
||||
|
||||
use super::{InlineContainerState, InlineContainerStateFlags, inline_container_needs_strut};
|
||||
use super::{
|
||||
InlineContainerState, InlineContainerStateFlags, SharedInlineStyles,
|
||||
inline_container_needs_strut,
|
||||
};
|
||||
use crate::ContainingBlock;
|
||||
use crate::cell::ArcRefCell;
|
||||
use crate::context::LayoutContext;
|
||||
|
@ -20,6 +23,9 @@ use crate::style_ext::{LayoutStyle, PaddingBorderMargin};
|
|||
#[derive(Debug, MallocSizeOf)]
|
||||
pub(crate) struct InlineBox {
|
||||
pub base: LayoutBoxBase,
|
||||
/// The [`SharedInlineStyles`] for this [`InlineBox`] that are used to share styles
|
||||
/// with all [`super::TextRun`] children.
|
||||
pub(super) shared_inline_styles: SharedInlineStyles,
|
||||
/// The identifier of this inline box in the containing [`super::InlineFormattingContext`].
|
||||
pub(super) identifier: InlineBoxIdentifier,
|
||||
/// Whether or not this is the first instance of an [`InlineBox`] before a possible
|
||||
|
@ -37,6 +43,7 @@ impl InlineBox {
|
|||
pub(crate) fn new(info: &NodeAndStyleInfo) -> Self {
|
||||
Self {
|
||||
base: LayoutBoxBase::new(info.into(), info.style.clone()),
|
||||
shared_inline_styles: info.into(),
|
||||
// This will be assigned later, when the box is actually added to the IFC.
|
||||
identifier: InlineBoxIdentifier::default(),
|
||||
is_first_split: true,
|
||||
|
@ -48,6 +55,7 @@ impl InlineBox {
|
|||
pub(crate) fn split_around_block(&self) -> Self {
|
||||
Self {
|
||||
base: LayoutBoxBase::new(self.base.base_fragment_info, self.base.style.clone()),
|
||||
shared_inline_styles: self.shared_inline_styles.clone(),
|
||||
is_first_split: false,
|
||||
is_last_split: false,
|
||||
..*self
|
||||
|
|
|
@ -7,7 +7,6 @@ use bitflags::bitflags;
|
|||
use fonts::{ByteIndex, FontMetrics, GlyphStore};
|
||||
use itertools::Either;
|
||||
use range::Range;
|
||||
use servo_arc::Arc;
|
||||
use style::Zero;
|
||||
use style::computed_values::position::T as Position;
|
||||
use style::computed_values::white_space_collapse::T as WhiteSpaceCollapse;
|
||||
|
@ -21,7 +20,7 @@ use unicode_bidi::{BidiInfo, Level};
|
|||
use webrender_api::FontInstanceKey;
|
||||
|
||||
use super::inline_box::{InlineBoxContainerState, InlineBoxIdentifier, InlineBoxTreePathToken};
|
||||
use super::{InlineFormattingContextLayout, LineBlockSizes};
|
||||
use super::{InlineFormattingContextLayout, LineBlockSizes, SharedInlineStyles};
|
||||
use crate::cell::ArcRefCell;
|
||||
use crate::fragment_tree::{BaseFragmentInfo, BoxFragment, Fragment, TextFragment};
|
||||
use crate::geom::{LogicalRect, LogicalVec2, PhysicalRect, ToLogical};
|
||||
|
@ -568,7 +567,7 @@ impl LineItemLayout<'_, '_> {
|
|||
self.current_state.fragments.push((
|
||||
Fragment::Text(ArcRefCell::new(TextFragment {
|
||||
base: text_item.base_fragment_info.into(),
|
||||
parent_style: text_item.parent_style,
|
||||
inline_styles: text_item.inline_styles.clone(),
|
||||
rect: PhysicalRect::zero(),
|
||||
font_metrics: text_item.font_metrics,
|
||||
font_key: text_item.font_key,
|
||||
|
@ -576,7 +575,6 @@ impl LineItemLayout<'_, '_> {
|
|||
text_decoration_line: text_item.text_decoration_line,
|
||||
justification_adjustment: self.justification_adjustment,
|
||||
selection_range: text_item.selection_range,
|
||||
selected_style: text_item.selected_style,
|
||||
})),
|
||||
content_rect,
|
||||
));
|
||||
|
@ -763,7 +761,7 @@ impl LineItem {
|
|||
|
||||
pub(super) struct TextRunLineItem {
|
||||
pub base_fragment_info: BaseFragmentInfo,
|
||||
pub parent_style: Arc<ComputedValues>,
|
||||
pub inline_styles: SharedInlineStyles,
|
||||
pub text: Vec<std::sync::Arc<GlyphStore>>,
|
||||
pub font_metrics: FontMetrics,
|
||||
pub font_key: FontInstanceKey,
|
||||
|
@ -771,13 +769,16 @@ pub(super) struct TextRunLineItem {
|
|||
/// The BiDi level of this [`TextRunLineItem`] to enable reordering.
|
||||
pub bidi_level: Level,
|
||||
pub selection_range: Option<Range<ByteIndex>>,
|
||||
pub selected_style: Arc<ComputedValues>,
|
||||
}
|
||||
|
||||
impl TextRunLineItem {
|
||||
fn trim_whitespace_at_end(&mut self, whitespace_trimmed: &mut Au) -> bool {
|
||||
if matches!(
|
||||
self.parent_style.get_inherited_text().white_space_collapse,
|
||||
self.inline_styles
|
||||
.style
|
||||
.borrow()
|
||||
.get_inherited_text()
|
||||
.white_space_collapse,
|
||||
WhiteSpaceCollapse::Preserve | WhiteSpaceCollapse::BreakSpaces
|
||||
) {
|
||||
return false;
|
||||
|
@ -803,7 +804,11 @@ impl TextRunLineItem {
|
|||
|
||||
fn trim_whitespace_at_start(&mut self, whitespace_trimmed: &mut Au) -> bool {
|
||||
if matches!(
|
||||
self.parent_style.get_inherited_text().white_space_collapse,
|
||||
self.inline_styles
|
||||
.style
|
||||
.borrow()
|
||||
.get_inherited_text()
|
||||
.white_space_collapse,
|
||||
WhiteSpaceCollapse::Preserve | WhiteSpaceCollapse::BreakSpaces
|
||||
) {
|
||||
return false;
|
||||
|
|
|
@ -118,6 +118,7 @@ use super::{
|
|||
};
|
||||
use crate::cell::ArcRefCell;
|
||||
use crate::context::LayoutContext;
|
||||
use crate::dom_traversal::NodeAndStyleInfo;
|
||||
use crate::flow::CollapsibleWithParentStartMargin;
|
||||
use crate::flow::float::{FloatBox, SequentialLayoutState};
|
||||
use crate::formatting_contexts::{
|
||||
|
@ -131,7 +132,7 @@ use crate::geom::{LogicalRect, LogicalVec2, ToLogical};
|
|||
use crate::positioned::{AbsolutelyPositionedBox, PositioningContext};
|
||||
use crate::sizing::{ComputeInlineContentSizes, ContentSizes, InlineContentSizesResult};
|
||||
use crate::style_ext::{ComputedValuesExt, PaddingBorderMargin};
|
||||
use crate::{ConstraintSpace, ContainingBlock, PropagatedBoxTreeData};
|
||||
use crate::{ConstraintSpace, ContainingBlock, PropagatedBoxTreeData, SharedStyle};
|
||||
|
||||
// From gfxFontConstants.h in Firefox.
|
||||
static FONT_SUBSCRIPT_OFFSET_RATIO: f32 = 0.20;
|
||||
|
@ -173,6 +174,25 @@ pub(crate) struct InlineFormattingContext {
|
|||
pub(super) has_right_to_left_content: bool,
|
||||
}
|
||||
|
||||
/// [`TextRun`] and `TextFragment`s need a handle on their parent inline box (or inline
|
||||
/// formatting context root)'s style. In order to implement incremental layout, these are
|
||||
/// wrapped in [`SharedStyle`]. This allows updating the parent box tree element without
|
||||
/// updating every single descendant box tree node and fragment.
|
||||
#[derive(Clone, Debug, MallocSizeOf)]
|
||||
pub(crate) struct SharedInlineStyles {
|
||||
pub style: SharedStyle,
|
||||
pub selected: SharedStyle,
|
||||
}
|
||||
|
||||
impl From<&NodeAndStyleInfo<'_>> for SharedInlineStyles {
|
||||
fn from(info: &NodeAndStyleInfo) -> Self {
|
||||
Self {
|
||||
style: SharedStyle::new(info.style.clone()),
|
||||
selected: SharedStyle::new(info.get_selected_style()),
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/// A collection of data used to cache [`FontMetrics`] in the [`InlineFormattingContext`]
|
||||
#[derive(Debug, MallocSizeOf)]
|
||||
pub(crate) struct FontKeyAndMetrics {
|
||||
|
@ -1313,7 +1333,7 @@ impl InlineFormattingContextLayout<'_> {
|
|||
) {
|
||||
let inline_advance = glyph_store.total_advance();
|
||||
let flags = if glyph_store.is_whitespace() {
|
||||
SegmentContentFlags::from(text_run.parent_style.get_inherited_text())
|
||||
SegmentContentFlags::from(text_run.inline_styles.style.borrow().get_inherited_text())
|
||||
} else {
|
||||
SegmentContentFlags::empty()
|
||||
};
|
||||
|
@ -1398,13 +1418,12 @@ impl InlineFormattingContextLayout<'_> {
|
|||
TextRunLineItem {
|
||||
text: vec![glyph_store],
|
||||
base_fragment_info: text_run.base_fragment_info,
|
||||
parent_style: text_run.parent_style.clone(),
|
||||
inline_styles: text_run.inline_styles.clone(),
|
||||
font_metrics,
|
||||
font_key: ifc_font_info.key,
|
||||
text_decoration_line: self.current_inline_container_state().text_decoration_line,
|
||||
bidi_level,
|
||||
selection_range,
|
||||
selected_style: text_run.selected_style.clone(),
|
||||
},
|
||||
));
|
||||
}
|
||||
|
@ -2363,8 +2382,9 @@ impl<'layout_data> ContentSizesComputation<'layout_data> {
|
|||
},
|
||||
InlineItem::TextRun(text_run) => {
|
||||
let text_run = &*text_run.borrow();
|
||||
let parent_style = text_run.inline_styles.style.borrow();
|
||||
for segment in text_run.shaped_text.iter() {
|
||||
let style_text = text_run.parent_style.get_inherited_text();
|
||||
let style_text = parent_style.get_inherited_text();
|
||||
let can_wrap = style_text.text_wrap_mode == TextWrapMode::Wrap;
|
||||
|
||||
// TODO: This should take account whether or not the first and last character prevent
|
||||
|
|
|
@ -26,7 +26,7 @@ use unicode_script::Script;
|
|||
use xi_unicode::linebreak_property;
|
||||
|
||||
use super::line_breaker::LineBreaker;
|
||||
use super::{FontKeyAndMetrics, InlineFormattingContextLayout};
|
||||
use super::{FontKeyAndMetrics, InlineFormattingContextLayout, SharedInlineStyles};
|
||||
use crate::fragment_tree::BaseFragmentInfo;
|
||||
|
||||
// These constants are the xi-unicode line breaking classes that are defined in
|
||||
|
@ -37,22 +37,6 @@ pub(crate) const XI_LINE_BREAKING_CLASS_ZW: u8 = 28;
|
|||
pub(crate) const XI_LINE_BREAKING_CLASS_WJ: u8 = 30;
|
||||
pub(crate) const XI_LINE_BREAKING_CLASS_ZWJ: u8 = 42;
|
||||
|
||||
/// <https://www.w3.org/TR/css-display-3/#css-text-run>
|
||||
#[derive(Debug, MallocSizeOf)]
|
||||
pub(crate) struct TextRun {
|
||||
pub base_fragment_info: BaseFragmentInfo,
|
||||
#[conditional_malloc_size_of]
|
||||
pub parent_style: Arc<ComputedValues>,
|
||||
pub text_range: Range<usize>,
|
||||
|
||||
/// The text of this [`TextRun`] with a font selected, broken into unbreakable
|
||||
/// segments, and shaped.
|
||||
pub shaped_text: Vec<TextRunSegment>,
|
||||
pub selection_range: Option<ServoRange<ByteIndex>>,
|
||||
#[conditional_malloc_size_of]
|
||||
pub selected_style: Arc<ComputedValues>,
|
||||
}
|
||||
|
||||
// There are two reasons why we might want to break at the start:
|
||||
//
|
||||
// 1. The line breaker told us that a break was necessary between two separate
|
||||
|
@ -334,21 +318,49 @@ impl TextRunSegment {
|
|||
}
|
||||
}
|
||||
|
||||
/// A single [`TextRun`] for the box tree. These are all descendants of
|
||||
/// [`super::InlineBox`] or the root of the [`super::InlineFormattingContext`]. During
|
||||
/// box tree construction, text is split into [`TextRun`]s based on their font, script,
|
||||
/// etc. When these are created text is already shaped.
|
||||
///
|
||||
/// <https://www.w3.org/TR/css-display-3/#css-text-run>
|
||||
#[derive(Debug, MallocSizeOf)]
|
||||
pub(crate) struct TextRun {
|
||||
/// The [`BaseFragmentInfo`] for this [`TextRun`]. Usually this comes from the
|
||||
/// original text node in the DOM for the text.
|
||||
pub base_fragment_info: BaseFragmentInfo,
|
||||
|
||||
/// The [`crate::SharedStyle`] from this [`TextRun`]s parent element. This is
|
||||
/// shared so that incremental layout can simply update the parent element and
|
||||
/// this [`TextRun`] will be updated automatically.
|
||||
pub inline_styles: SharedInlineStyles,
|
||||
|
||||
/// The range of text in [`super::InlineFormattingContext::text_content`] of the
|
||||
/// [`super::InlineFormattingContext`] that owns this [`TextRun`]. These are UTF-8 offsets.
|
||||
pub text_range: Range<usize>,
|
||||
|
||||
/// The text of this [`TextRun`] with a font selected, broken into unbreakable
|
||||
/// segments, and shaped.
|
||||
pub shaped_text: Vec<TextRunSegment>,
|
||||
|
||||
/// The selection range for the DOM text node that originated this [`TextRun`]. This
|
||||
/// comes directly from the DOM.
|
||||
pub selection_range: Option<ServoRange<ByteIndex>>,
|
||||
}
|
||||
|
||||
impl TextRun {
|
||||
pub(crate) fn new(
|
||||
base_fragment_info: BaseFragmentInfo,
|
||||
parent_style: Arc<ComputedValues>,
|
||||
inline_styles: SharedInlineStyles,
|
||||
text_range: Range<usize>,
|
||||
selection_range: Option<ServoRange<ByteIndex>>,
|
||||
selected_style: Arc<ComputedValues>,
|
||||
) -> Self {
|
||||
Self {
|
||||
base_fragment_info,
|
||||
parent_style,
|
||||
inline_styles,
|
||||
text_range,
|
||||
shaped_text: Vec::new(),
|
||||
selection_range,
|
||||
selected_style,
|
||||
}
|
||||
}
|
||||
|
||||
|
@ -360,11 +372,12 @@ impl TextRun {
|
|||
font_cache: &mut Vec<FontKeyAndMetrics>,
|
||||
bidi_info: &BidiInfo,
|
||||
) {
|
||||
let inherited_text_style = self.parent_style.get_inherited_text().clone();
|
||||
let parent_style = self.inline_styles.style.borrow().clone();
|
||||
let inherited_text_style = parent_style.get_inherited_text().clone();
|
||||
let letter_spacing = inherited_text_style
|
||||
.letter_spacing
|
||||
.0
|
||||
.resolve(self.parent_style.clone_font().font_size.computed_size());
|
||||
.resolve(parent_style.clone_font().font_size.computed_size());
|
||||
let letter_spacing = if letter_spacing.px() != 0. {
|
||||
Some(app_units::Au::from(letter_spacing))
|
||||
} else {
|
||||
|
@ -384,7 +397,13 @@ impl TextRun {
|
|||
let style_word_spacing: Option<Au> = specified_word_spacing.to_length().map(|l| l.into());
|
||||
|
||||
let segments = self
|
||||
.segment_text_by_font(formatting_context_text, font_context, font_cache, bidi_info)
|
||||
.segment_text_by_font(
|
||||
formatting_context_text,
|
||||
font_context,
|
||||
font_cache,
|
||||
bidi_info,
|
||||
&parent_style,
|
||||
)
|
||||
.into_iter()
|
||||
.map(|(mut segment, font)| {
|
||||
let word_spacing = style_word_spacing.unwrap_or_else(|| {
|
||||
|
@ -407,7 +426,7 @@ impl TextRun {
|
|||
};
|
||||
|
||||
segment.shape_text(
|
||||
&self.parent_style,
|
||||
&parent_style,
|
||||
formatting_context_text,
|
||||
linebreaker,
|
||||
&shaping_options,
|
||||
|
@ -430,8 +449,9 @@ impl TextRun {
|
|||
font_context: &FontContext,
|
||||
font_cache: &mut Vec<FontKeyAndMetrics>,
|
||||
bidi_info: &BidiInfo,
|
||||
parent_style: &Arc<ComputedValues>,
|
||||
) -> Vec<(TextRunSegment, FontRef)> {
|
||||
let font_group = font_context.font_group(self.parent_style.clone_font());
|
||||
let font_group = font_context.font_group(parent_style.clone_font());
|
||||
let mut current: Option<(TextRunSegment, FontRef)> = None;
|
||||
let mut results = Vec::new();
|
||||
|
||||
|
|
|
@ -249,7 +249,6 @@ pub(crate) struct CollapsibleWithParentStartMargin(bool);
|
|||
/// for a list that has `list-style-position: outside`.
|
||||
#[derive(Debug, MallocSizeOf)]
|
||||
pub(crate) struct OutsideMarker {
|
||||
#[conditional_malloc_size_of]
|
||||
pub list_item_style: Arc<ComputedValues>,
|
||||
pub base: LayoutBoxBase,
|
||||
pub block_container: BlockContainer,
|
||||
|
|
|
@ -174,7 +174,7 @@ impl BoxTree {
|
|||
|
||||
let update_point =
|
||||
match &*AtomicRef::filter_map(layout_data.self_box.borrow(), Option::as_ref)? {
|
||||
LayoutBox::DisplayContents => return None,
|
||||
LayoutBox::DisplayContents(..) => return None,
|
||||
LayoutBox::BlockLevel(block_level_box) => match &*block_level_box.borrow() {
|
||||
BlockLevelBox::OutOfFlowAbsolutelyPositionedBox(_)
|
||||
if box_style.position.is_absolutely_positioned() =>
|
||||
|
|
Loading…
Add table
Add a link
Reference in a new issue