Mirrors/servo
1
0
Fork 0
mirror of https://github.com/servo/servo.git synced 2025-06-06 16:45:39 +00:00
Code Issues Projects Releases Packages Wiki Activity

Rename compute_absolute_position to compute_stacking_relative_position

Browse source
This commit is contained in:
Matt Brubeck 2017-08-07 16:08:01 -07:00
parent 1f0e42e8fe
commit a08bc13df9
14 changed files with 30 additions and 29 deletions
Download patch file Download diff file Expand all files Collapse all files

2
components/layout/block.rs
View file

@ -1944,7 +1944,7 @@ impl Flow for BlockFlow {
} }
} }
fn compute_absolute_position(&mut self, _layout_context: &LayoutContext) { fn compute_stacking_relative_position(&mut self, _layout_context: &LayoutContext) {
// FIXME (mbrubeck): Get the real container size, taking the container writing mode into // FIXME (mbrubeck): Get the real container size, taking the container writing mode into
// account. Must handle vertical writing modes. // account. Must handle vertical writing modes.
let container_size = Size2D::new(self.base.block_container_inline_size, Au(0)); let container_size = Size2D::new(self.base.block_container_inline_size, Au(0));

4
components/layout/flex.rs
View file

@ -949,8 +949,8 @@ impl Flow for FlexFlow {
} }
} }
fn compute_absolute_position(&mut self, layout_context: &LayoutContext) { fn compute_stacking_relative_position(&mut self, layout_context: &LayoutContext) {
self.block_flow.compute_absolute_position(layout_context) self.block_flow.compute_stacking_relative_position(layout_context)
} }
fn place_float_if_applicable<'a>(&mut self) { fn place_float_if_applicable<'a>(&mut self) {

5
components/layout/flow.rs
View file

@ -339,8 +339,9 @@ pub trait Flow: fmt::Debug + Sync + Send + 'static {
mut_base(self).overflow = overflow mut_base(self).overflow = overflow
} }
/// Phase 4 of reflow: computes absolute positions. /// Phase 4 of reflow: Compute the stacking-relative position (origin of the content box,
fn compute_absolute_position(&mut self, _: &LayoutContext) { /// in coordinates relative to the nearest ancestor stacking context).
fn compute_stacking_relative_position(&mut self, _: &LayoutContext) {
// The default implementation is a no-op. // The default implementation is a no-op.
mut_base(self).restyle_damage.remove(REPOSITION) mut_base(self).restyle_damage.remove(REPOSITION)
} }

2
components/layout/inline.rs
View file

@ -1534,7 +1534,7 @@ impl Flow for InlineFlow {
} }
} }
fn compute_absolute_position(&mut self, _: &LayoutContext) { fn compute_stacking_relative_position(&mut self, _: &LayoutContext) {
// First, gather up the positions of all the containing blocks (if any). // First, gather up the positions of all the containing blocks (if any).
// //
// FIXME(pcwalton): This will get the absolute containing blocks inside `...` wrong in the // FIXME(pcwalton): This will get the absolute containing blocks inside `...` wrong in the

4
components/layout/list_item.rs
View file

@ -119,8 +119,8 @@ impl Flow for ListItemFlow {
} }
} }
fn compute_absolute_position(&mut self, layout_context: &LayoutContext) { fn compute_stacking_relative_position(&mut self, layout_context: &LayoutContext) {
self.block_flow.compute_absolute_position(layout_context) self.block_flow.compute_stacking_relative_position(layout_context)
} }
fn place_float_if_applicable<'a>(&mut self) { fn place_float_if_applicable<'a>(&mut self) {

8
components/layout/multicol.rs
View file

@ -166,8 +166,8 @@ impl Flow for MulticolFlow {
} }
} }
fn compute_absolute_position(&mut self, layout_context: &LayoutContext) { fn compute_stacking_relative_position(&mut self, layout_context: &LayoutContext) {
self.block_flow.compute_absolute_position(layout_context); self.block_flow.compute_stacking_relative_position(layout_context);
let pitch = LogicalSize::new(self.block_flow.base.writing_mode, self.column_pitch, Au(0)); let pitch = LogicalSize::new(self.block_flow.base.writing_mode, self.column_pitch, Au(0));
let pitch = pitch.to_physical(self.block_flow.base.writing_mode); let pitch = pitch.to_physical(self.block_flow.base.writing_mode);
for (i, child) in self.block_flow.base.children.iter_mut().enumerate() { for (i, child) in self.block_flow.base.children.iter_mut().enumerate() {
@ -254,8 +254,8 @@ impl Flow for MulticolColumnFlow {
Flow::fragment(&mut self.block_flow, layout_context, fragmentation_context) Flow::fragment(&mut self.block_flow, layout_context, fragmentation_context)
} }
fn compute_absolute_position(&mut self, layout_context: &LayoutContext) { fn compute_stacking_relative_position(&mut self, layout_context: &LayoutContext) {
self.block_flow.compute_absolute_position(layout_context) self.block_flow.compute_stacking_relative_position(layout_context)
} }
fn update_late_computed_inline_position_if_necessary(&mut self, inline_position: Au) { fn update_late_computed_inline_position_if_necessary(&mut self, inline_position: Au) {

4
components/layout/table.rs
View file

@ -473,8 +473,8 @@ impl Flow for TableFlow {
self.block_flow.assign_block_size_for_table_like_flow(vertical_spacing) self.block_flow.assign_block_size_for_table_like_flow(vertical_spacing)
} }
fn compute_absolute_position(&mut self, layout_context: &LayoutContext) { fn compute_stacking_relative_position(&mut self, layout_context: &LayoutContext) {
self.block_flow.compute_absolute_position(layout_context) self.block_flow.compute_stacking_relative_position(layout_context)
} }
fn generated_containing_block_size(&self, flow: OpaqueFlow) -> LogicalSize<Au> { fn generated_containing_block_size(&self, flow: OpaqueFlow) -> LogicalSize<Au> {

4
components/layout/table_caption.rs
View file

@ -62,8 +62,8 @@ impl Flow for TableCaptionFlow {
self.block_flow.assign_block_size(layout_context); self.block_flow.assign_block_size(layout_context);
} }
fn compute_absolute_position(&mut self, layout_context: &LayoutContext) { fn compute_stacking_relative_position(&mut self, layout_context: &LayoutContext) {
self.block_flow.compute_absolute_position(layout_context) self.block_flow.compute_stacking_relative_position(layout_context)
} }
fn update_late_computed_inline_position_if_necessary(&mut self, inline_position: Au) { fn update_late_computed_inline_position_if_necessary(&mut self, inline_position: Au) {

4
components/layout/table_cell.rs
View file

@ -230,8 +230,8 @@ impl Flow for TableCellFlow {
self.assign_block_size_table_cell_base(layout_context); self.assign_block_size_table_cell_base(layout_context);
} }
fn compute_absolute_position(&mut self, layout_context: &LayoutContext) { fn compute_stacking_relative_position(&mut self, layout_context: &LayoutContext) {
self.block_flow.compute_absolute_position(layout_context) self.block_flow.compute_stacking_relative_position(layout_context)
} }
fn update_late_computed_inline_position_if_necessary(&mut self, inline_position: Au) { fn update_late_computed_inline_position_if_necessary(&mut self, inline_position: Au) {

4
components/layout/table_row.rs
View file

@ -452,8 +452,8 @@ impl Flow for TableRowFlow {
self.assign_block_size_table_row_base(layout_context); self.assign_block_size_table_row_base(layout_context);
} }
fn compute_absolute_position(&mut self, layout_context: &LayoutContext) { fn compute_stacking_relative_position(&mut self, layout_context: &LayoutContext) {
self.block_flow.compute_absolute_position(layout_context) self.block_flow.compute_stacking_relative_position(layout_context)
} }
fn update_late_computed_inline_position_if_necessary(&mut self, inline_position: Au) { fn update_late_computed_inline_position_if_necessary(&mut self, inline_position: Au) {

4
components/layout/table_rowgroup.rs
View file

@ -165,8 +165,8 @@ impl Flow for TableRowGroupFlow {
self.block_flow.assign_block_size_for_table_like_flow(self.spacing.vertical.0) self.block_flow.assign_block_size_for_table_like_flow(self.spacing.vertical.0)
} }
fn compute_absolute_position(&mut self, layout_context: &LayoutContext) { fn compute_stacking_relative_position(&mut self, layout_context: &LayoutContext) {
self.block_flow.compute_absolute_position(layout_context) self.block_flow.compute_stacking_relative_position(layout_context)
} }
fn update_late_computed_inline_position_if_necessary(&mut self, inline_position: Au) { fn update_late_computed_inline_position_if_necessary(&mut self, inline_position: Au) {

4
components/layout/table_wrapper.rs
View file

@ -428,8 +428,8 @@ impl Flow for TableWrapperFlow {
debug_assert!(remaining.is_none()); debug_assert!(remaining.is_none());
} }
fn compute_absolute_position(&mut self, layout_context: &LayoutContext) { fn compute_stacking_relative_position(&mut self, layout_context: &LayoutContext) {
self.block_flow.compute_absolute_position(layout_context) self.block_flow.compute_stacking_relative_position(layout_context)
} }
fn place_float_if_applicable<'a>(&mut self) { fn place_float_if_applicable<'a>(&mut self) {

6
components/layout/traversal.rs
View file

@ -201,14 +201,14 @@ impl<'a> PostorderFlowTraversal for AssignBSizes<'a> {
} }
#[derive(Copy, Clone)] #[derive(Copy, Clone)]
pub struct ComputeAbsolutePositions<'a> { pub struct ComputeStackingRelativePositions<'a> {
pub layout_context: &'a LayoutContext<'a>, pub layout_context: &'a LayoutContext<'a>,
} }
impl<'a> PreorderFlowTraversal for ComputeAbsolutePositions<'a> { impl<'a> PreorderFlowTraversal for ComputeStackingRelativePositions<'a> {
#[inline] #[inline]
fn process(&self, flow: &mut Flow) { fn process(&self, flow: &mut Flow) {
flow.compute_absolute_position(self.layout_context); flow.compute_stacking_relative_position(self.layout_context);
} }
} }

4
components/layout_thread/lib.rs
View file

@ -82,7 +82,7 @@ use layout::query::{process_margin_style_query, process_node_overflow_request, p
use layout::query::{process_node_geometry_request, process_node_scroll_area_request}; use layout::query::{process_node_geometry_request, process_node_scroll_area_request};
use layout::query::{process_node_scroll_root_id_request, process_offset_parent_query}; use layout::query::{process_node_scroll_root_id_request, process_offset_parent_query};
use layout::sequential; use layout::sequential;
use layout::traversal::{ComputeAbsolutePositions, RecalcStyleAndConstructFlows}; use layout::traversal::{ComputeStackingRelativePositions, RecalcStyleAndConstructFlows};
use layout::webrender_helpers::WebRenderDisplayListConverter; use layout::webrender_helpers::WebRenderDisplayListConverter;
use layout::wrapper::LayoutNodeLayoutData; use layout::wrapper::LayoutNodeLayoutData;
use layout_traits::LayoutThreadFactory; use layout_traits::LayoutThreadFactory;
@ -975,7 +975,7 @@ impl LayoutThread {
flow::mut_base(layout_root).clip = data.page_clip_rect; flow::mut_base(layout_root).clip = data.page_clip_rect;
if flow::base(layout_root).restyle_damage.contains(REPOSITION) { if flow::base(layout_root).restyle_damage.contains(REPOSITION) {
layout_root.traverse_preorder(&ComputeAbsolutePositions { layout_root.traverse_preorder(&ComputeStackingRelativePositions {
layout_context: layout_context layout_context: layout_context
}); });
} }