mirror of
https://github.com/servo/servo.git
synced 2025-06-19 14:48:59 +01:00
287fe3b3ab
absolutely-positioned elements declared with `display: inline`. Although the computed `display` property of elements with `position: absolute` is `block`, `position: absolute; display: inline` can still behave differently from `position: absolute; display: block`. This is because the hypothetical box for `position: absolute` can be at the position it would have been if it had `display: inline`. CSS 2.1 § 10.3.7 describes this case in a parenthetical: "The static-position containing block is the containing block of a hypothetical box that would have been the first box of the element if its specified 'position' value had been 'static' and its specified 'float' had been 'none'. (Note that due to the rules in section 9.7 this hypothetical calculation might require also assuming a different computed value for 'display'.)" To handle this, I had to change both style computation and layout. For the former, I added an internal property `-servo-display-for-hypothetical-box`, which stores the `display` value supplied by the author, before the computed value is calculated. Flow construction now uses this value. As for layout, implementing the proper behavior is tricky because the position of an inline fragment in the inline direction cannot be determined until height assignment, which is a parallelism hazard because in parallel layout widths are computed before heights. However, in this particular case we can avoid the parallelism hazard because the inline direction of a hypothetical box only affects the layout if an absolutely-positioned element is unconstrained in the inline direction. Therefore, we can just lay out such absolutely-positioned elements with a bogus inline position and fix it up once the true inline position of the hypothetical box is computed. The name for this fix-up process is "late computation of inline position" (and the corresponding fix-up for the block position is called "late computation of block position"). This improves the header on /r/rust.
96 lines
3.1 KiB
Rust
96 lines
3.1 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 http://mozilla.org/MPL/2.0/. */
|
|
|
|
//! CSS table formatting contexts.
|
|
|
|
#![deny(unsafe_block)]
|
|
|
|
use context::LayoutContext;
|
|
use flow::{BaseFlow, TableColGroupFlowClass, FlowClass, Flow};
|
|
use fragment::{Fragment, TableColumnFragment};
|
|
use layout_debug;
|
|
use model::{MaybeAuto};
|
|
use wrapper::ThreadSafeLayoutNode;
|
|
|
|
use servo_util::geometry::Au;
|
|
use std::fmt;
|
|
|
|
/// A table formatting context.
|
|
pub struct TableColGroupFlow {
|
|
/// Data common to all flows.
|
|
pub base: BaseFlow,
|
|
|
|
/// The associated fragment.
|
|
pub fragment: Option<Fragment>,
|
|
|
|
/// The table column fragments
|
|
pub cols: Vec<Fragment>,
|
|
|
|
/// The specified inline-sizes of table columns
|
|
pub inline_sizes: Vec<Au>,
|
|
}
|
|
|
|
impl TableColGroupFlow {
|
|
pub fn from_node_and_fragments(node: &ThreadSafeLayoutNode,
|
|
fragment: Fragment,
|
|
fragments: Vec<Fragment>) -> TableColGroupFlow {
|
|
TableColGroupFlow {
|
|
base: BaseFlow::new((*node).clone()),
|
|
fragment: Some(fragment),
|
|
cols: fragments,
|
|
inline_sizes: vec!(),
|
|
}
|
|
}
|
|
}
|
|
|
|
impl Flow for TableColGroupFlow {
|
|
fn class(&self) -> FlowClass {
|
|
TableColGroupFlowClass
|
|
}
|
|
|
|
fn as_table_colgroup<'a>(&'a mut self) -> &'a mut TableColGroupFlow {
|
|
self
|
|
}
|
|
|
|
fn bubble_inline_sizes(&mut self, _: &LayoutContext) {
|
|
let _scope = layout_debug_scope!("table_colgroup::bubble_inline_sizes {:s}",
|
|
self.base.debug_id());
|
|
|
|
for fragment in self.cols.iter() {
|
|
// get the specified value from inline-size property
|
|
let inline_size = MaybeAuto::from_style(fragment.style().content_inline_size(),
|
|
Au::new(0)).specified_or_zero();
|
|
|
|
let span: int = match fragment.specific {
|
|
TableColumnFragment(col_fragment) => col_fragment.span.unwrap_or(1),
|
|
_ => fail!("Other fragment come out in TableColGroupFlow. {:?}", fragment.specific)
|
|
};
|
|
for _ in range(0, span) {
|
|
self.inline_sizes.push(inline_size);
|
|
}
|
|
}
|
|
}
|
|
|
|
/// Table column inline-sizes are assigned in table flow and propagated to table row or rowgroup flow.
|
|
/// Therefore, table colgroup flow does not need to assign its inline-size.
|
|
fn assign_inline_sizes(&mut self, _ctx: &LayoutContext) {
|
|
}
|
|
|
|
/// Table column do not have block-size.
|
|
fn assign_block_size(&mut self, _ctx: &LayoutContext) {
|
|
}
|
|
|
|
fn update_late_computed_inline_position_if_necessary(&mut self, _: Au) {}
|
|
|
|
fn update_late_computed_block_position_if_necessary(&mut self, _: Au) {}
|
|
}
|
|
|
|
impl fmt::Show for TableColGroupFlow {
|
|
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
|
|
match self.fragment {
|
|
Some(ref rb) => write!(f, "TableColGroupFlow: {}", rb),
|
|
None => write!(f, "TableColGroupFlow"),
|
|
}
|
|
}
|
|
}
|